/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package javax.servlet.http;

import java.util.BitSet;

import org.junit.Assert;
import org.junit.Test;

/**
 * Basic tests for Cookie in default configuration.
 */
public class TestCookie {
    public static final BitSet CHAR;  // <any US-ASCII character (octets 0 - 127)>
    public static final BitSet CTL;   // <any US-ASCII control character (octets 0 - 31) and DEL (127)>
    public static final BitSet SEPARATORS;
    public static final BitSet TOKEN; // 1*<any CHAR except CTLs or separators>

    static {
        CHAR = new BitSet(256);
        CHAR.set(0, 128);

        CTL = new BitSet(256);
        CTL.set(0, 32);
        CTL.set(127);

        SEPARATORS = new BitSet(256);
        for (char ch : "()<>@,;:\\\"/[]?={} \t".toCharArray()) {
            SEPARATORS.set(ch);
        }

        TOKEN = new BitSet(256);
        TOKEN.or(CHAR); // any CHAR
        TOKEN.andNot(CTL); // except CTLs
        TOKEN.andNot(SEPARATORS); // or separators
    }

    @Test
    public void testDefaults() {
        Cookie cookie = new Cookie("foo", null);
        Assert.assertEquals("foo", cookie.getName());
        Assert.assertNull(cookie.getValue());
        Assert.assertEquals(0, cookie.getVersion());
        Assert.assertEquals(-1, cookie.getMaxAge());
    }

    @Test
    public void testInitialValue() {
        Cookie cookie = new Cookie("foo", "bar");
        Assert.assertEquals("foo", cookie.getName());
        Assert.assertEquals("bar", cookie.getValue());
        Assert.assertEquals(0, cookie.getVersion());
    }

    @Test
    public void defaultImpliesNetscape() {
        // $Foo is allowed by Netscape but not by RFC2109
        Cookie cookie = new Cookie("$Foo", null);
        Assert.assertEquals("$Foo", cookie.getName());
    }

    @Test
    public void tokenVersion() {
        Cookie cookie = new Cookie("Version", null);
        Assert.assertEquals("Version", cookie.getName());
    }

    @Test
    public void attributeVersion() {
        Cookie cookie = new Cookie("Comment", null);
        Assert.assertEquals("Comment", cookie.getName());
    }

    @Test
    public void attributeDiscard() {
        Cookie cookie = new Cookie("Discard", null);
        Assert.assertEquals("Discard", cookie.getName());
    }

    @Test
    public void attributeExpires() {
        Cookie cookie = new Cookie("Expires", null);
        Assert.assertEquals("Expires", cookie.getName());
    }

    @Test
    public void attributeMaxAge() {
        Cookie cookie = new Cookie("Max-Age", null);
        Assert.assertEquals("Max-Age", cookie.getName());
    }

    @Test
    public void attributeDomain() {
        Cookie cookie = new Cookie("Domain", null);
        Assert.assertEquals("Domain", cookie.getName());
    }

    @Test
    public void attributePath() {
        Cookie cookie = new Cookie("Path", null);
        Assert.assertEquals("Path", cookie.getName());
    }

    @Test
    public void attributeSecure() {
        Cookie cookie = new Cookie("Secure", null);
        Assert.assertEquals("Secure", cookie.getName());
    }

    @Test
    public void attributeHttpOnly() {
        Cookie cookie = new Cookie("HttpOnly", null);
        Assert.assertEquals("HttpOnly", cookie.getName());
    }

    @Test
    public void strictNamingImpliesRFC2109() {
        // Needs to be something RFC6265 allows, but strict naming does not.
        @SuppressWarnings("unused")
        Cookie cookie = new Cookie("$Foo", null);
    }

    @Test
    public void testClone() {
        Cookie a = new Cookie("a","a");
        a.setComment("comment");
        a.setDomain("domain");
        a.setHttpOnly(true);
        a.setMaxAge(123);
        a.setPath("/path");
        a.setSecure(true);

        Cookie b = (Cookie) a.clone();

        Assert.assertEquals("a", b.getName());
        Assert.assertEquals("a", b.getValue());
        Assert.assertEquals("comment", b.getComment());
        Assert.assertEquals("domain", b.getDomain());
        Assert.assertTrue(b.isHttpOnly());
        Assert.assertEquals(123, b.getMaxAge());
        Assert.assertEquals("/path", b.getPath());
        Assert.assertTrue(b.getSecure());
    }


    public static void checkCharInName(CookieNameValidator validator, BitSet allowed) {
        for (char ch = 0; ch < allowed.size(); ch++) {
            boolean expected = allowed.get(ch);
            String name = "X" + ch + "X";
            try {
                validator.validate(name);
                if (!expected) {
                    Assert.fail(String.format("Char %d should not be allowed", Integer.valueOf(ch)));
                }
            } catch (IllegalArgumentException e) {
                if (expected) {
                    Assert.fail(String.format("Char %d should be allowed", Integer.valueOf(ch)));
                }
            }
        }
    }
}
