commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ol...@apache.org
Subject svn commit: r264149 [3/3] - in /jakarta/commons/proper/httpclient/branches/COOKIE_2_BRANCH/src: java/org/apache/commons/httpclient/ java/org/apache/commons/httpclient/cookie/ test/org/apache/commons/httpclient/cookie/
Date Mon, 29 Aug 2005 14:28:43 GMT
Modified: jakarta/commons/proper/httpclient/branches/COOKIE_2_BRANCH/src/test/org/apache/commons/httpclient/cookie/TestCookieRFC2965Spec.java
URL: http://svn.apache.org/viewcvs/jakarta/commons/proper/httpclient/branches/COOKIE_2_BRANCH/src/test/org/apache/commons/httpclient/cookie/TestCookieRFC2965Spec.java?rev=264149&r1=264148&r2=264149&view=diff
==============================================================================
--- jakarta/commons/proper/httpclient/branches/COOKIE_2_BRANCH/src/test/org/apache/commons/httpclient/cookie/TestCookieRFC2965Spec.java (original)
+++ jakarta/commons/proper/httpclient/branches/COOKIE_2_BRANCH/src/test/org/apache/commons/httpclient/cookie/TestCookieRFC2965Spec.java Mon Aug 29 07:28:21 2005
@@ -33,7 +33,9 @@
 
 import org.apache.commons.httpclient.Cookie;
 import org.apache.commons.httpclient.Header;
-import org.apache.commons.httpclient.NameValuePair;
+
+import java.util.Date;
+import java.util.Arrays;
 
 /**
  * Test cases for RFC2965 cookie spec
@@ -42,7 +44,6 @@
  */
 public class TestCookieRFC2965Spec extends TestCookieBase {
 
-
     // ------------------------------------------------------------ Constructor
 
     public TestCookieRFC2965Spec(String name) {
@@ -55,482 +56,700 @@
         return new TestSuite(TestCookieRFC2965Spec.class);
     }
 
-    public void testParseAttributeInvalidParams() throws Exception {
+
+    // ------------------------------------------------------- Test Cookie Parsing
+
+    /**
+     * Test <tt>parse</tt> with invalid params.
+     */
+    public void testParseInvalidParams() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
-        Cookie cookie = new Cookie();
-        NameValuePair attribute = new NameValuePair("name", "value");
         try {
-            cookiespec.parseAttribute(null, cookie);
+            // invalid header
+            cookiespec.parse("www.domain.com", 80, "/", false, (Header) null /* header */);
             fail("IllegalArgumentException must have been thrown");
-        } catch (IllegalArgumentException expected) {
-        }
+        } catch (IllegalArgumentException expected) {}
+
+        Header header = new Header("Set-Cookie2", "name=value;Version=1");
+        try {
+            // invalid request host
+            cookiespec.parse(null /* host */, 80, "/", false, header);
+            fail("IllegalArgumentException must have been thrown");
+        } catch (IllegalArgumentException expected) {}
         try {
-            cookiespec.parseAttribute(attribute, null);
+            // invalid request port
+            cookiespec.parse("www.domain.com", -32 /* port */, "/", false, header);
             fail("IllegalArgumentException must have been thrown");
-        } catch (IllegalArgumentException expected) {
-        }
+        } catch (IllegalArgumentException expected) {}
+        try {
+            // invalid request path
+            cookiespec.parse("www.domain.com", 80, null /* path */, false, header);
+            fail("IllegalArgumentException must have been thrown");
+        } catch (IllegalArgumentException expected) {}
     }
 
-    public void testParseAttributePath() throws Exception {
+    /**
+     * Test parsing cookie <tt>"Path"</tt> attribute.
+     */
+    public void testParsePath() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
-        Cookie cookie = new Cookie();
-        try {
-            cookiespec.parseAttribute(new NameValuePair("path", null), cookie);
-            fail("MalformedCookieException must have been thrown");
-        } catch (MalformedCookieException expected) {
-        }
-        try {
-            cookiespec.parseAttribute(new NameValuePair("path", "   "), cookie);
-            fail("MalformedCookieException must have been thrown");
-        } catch (MalformedCookieException expected) {
-        }
-        cookiespec.parseAttribute(new NameValuePair("path", "/"), cookie);
-        assertEquals(cookie.getPath(), "/");
-        // this will be ignored since path is already specified for this cookie
-        cookiespec.parseAttribute(new NameValuePair("path", null), cookie);
+        // path cannot be null
+        Header header = new Header("Set-Cookie2", "name=value;Path=;Version=1");
+        Cookie[] parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNull(parsed);
 
+        //path cannot be blank
+        header = new Header("Set-Cookie2", "name=value;Path=\"   \";Version=1");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNull(parsed);
+
+        // valid path
+        header = new Header("Set-Cookie2", "name=value;Path=/;Version=1;Path=");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        // only the first occurence of path attribute is considered, others ignored
+        Cookie2 cookie = (Cookie2) parsed[0];
+        assertEquals("/", cookie.getPath());
+        assertTrue(cookie.isPathAttributeSpecified());
+
+        // Path is OPTIONAL, defaults to the request path
+        header = new Header("Set-Cookie2", "name=value;Version=1");
+        parsed = cookiespec.parse("www.domain.com", 80, "/path" /* request path */, false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        cookie = (Cookie2) parsed[0];
+        assertEquals("/path", cookie.getPath());
+        assertFalse(cookie.isPathAttributeSpecified());
     }
 
-    public void testParseAttributeDomain() throws Exception {
+    /**
+     * Test parsing cookie <tt>"Domain"</tt> attribute.
+     */
+    public void testParseDomain() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
-        Cookie cookie = new Cookie();
-        try {
-            cookiespec.parseAttribute(new NameValuePair("domain", null), cookie);
-            fail("MalformedCookieException must have been thrown");
-        } catch (MalformedCookieException expected) {
-        }
-        try {
-            cookiespec.parseAttribute(new NameValuePair("domain", "   "), cookie);
-            fail("MalformedCookieException must have been thrown");
-        } catch (MalformedCookieException expected) {
-        }
-        cookiespec.parseAttribute(new NameValuePair("domain", ".domain.com"), cookie);
-        assertEquals(cookie.getDomain(), ".domain.com");
-        // this will be ignored since domain is already specified for this cookie
-        cookiespec.parseAttribute(new NameValuePair("domain", null), cookie);
+        // domain cannot be null
+        Header header = new Header("Set-Cookie2", "name=value;Domain=;Version=1");
+        Cookie[] parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNull(parsed);
+
+        // domain cannot be blank
+        header = new Header("Set-Cookie2", "name=value;Domain=\"   \";Version=1");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNull(parsed);
 
-        // puts a dot in front of domain if missing
-        cookie = new Cookie();
-        cookiespec.parseAttribute(new NameValuePair("domain", "domain.com"), cookie);
-        assertEquals(cookie.getDomain(), ".domain.com");
+        header = new Header("Set-Cookie2", "name=value;Domain=.domain.com;Version=1;Domain=");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        // only the first occurence of domain attribute is considered, others ignored
+        Cookie2 cookie = (Cookie2) parsed[0];
+        assertEquals(".domain.com", cookie.getDomain());
+        assertTrue(cookie.isDomainAttributeSpecified());
+
+        // should put a leading dot if there is no dot in front of domain
+        header = new Header("Set-Cookie2", "name=value;Domain=domain.com;Version=1");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        cookie = (Cookie2) parsed[0];
+        assertEquals(".domain.com", cookie.getDomain());
+
+        // Domain is OPTIONAL, defaults to the request host
+        header = new Header("Set-Cookie2", "name=value;Version=1");
+        parsed = cookiespec.parse("www.domain.com" /* request host */, 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        cookie = (Cookie2) parsed[0];
+        assertEquals("www.domain.com", cookie.getDomain());
+        assertFalse(cookie.isDomainAttributeSpecified());
     }
 
-    public void testParseAttributePort() throws Exception {
+    /**
+     * Test parsing cookie <tt>"Port"</tt> attribute.
+     */
+    public void testParsePort() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
-
-        Cookie cookie = new Cookie();
-        cookie.setPorts(new int[] {80}); //default to request port
-        cookiespec.parseAttribute(new NameValuePair("port", null), cookie);
         // null port defaults to request port
-        assertTrue(equalArray(cookie.getPorts(), new int[] {80}));
+        Header header = new Header("Set-Cookie2", "name=value;Port=;Version=1");
+        Cookie[] parsed = cookiespec.parse("www.domain.com", 80 /* request port */, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        Cookie2 cookie = (Cookie2) parsed[0];
+        assertEquals(new int[] {80}, cookie.getPorts());
+        assertTrue(cookie.isPortAttributeSpecified() && cookie.isPortAttributeBlank());
 
-        cookie = new Cookie();
-        cookie.setPorts(new int[] {80}); //default to request port
-        cookiespec.parseAttribute(new NameValuePair("port", "  "), cookie);
         // blank port defaults to request port
-        assertTrue(equalArray(cookie.getPorts(), new int[] {80}));
-
-        try {
-            cookie = new Cookie();
-            cookiespec.parseAttribute(new NameValuePair("port", "nonsense"), cookie);
-            // anything else not an 'int' must fail
-            fail("MalformedCookieException must have been thrown");
-        } catch (MalformedCookieException expected) {
-        }
-
-        cookie = new Cookie();
-        cookiespec.parseAttribute(new NameValuePair("port", "80,8080"), cookie);
-        assertTrue(equalArray(cookie.getPorts(), new int[] {80,8080}));
-        // this will be ignored since port already specified for this cookie
-        cookiespec.parseAttribute(new NameValuePair("port", "nonsense"), cookie);
+        header = new Header("Set-Cookie2", "name=value;Port=\"  \";Version=1");
+        parsed = cookiespec.parse("www.domain.com", 80 /* request port */, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        cookie = (Cookie2) parsed[0];
+        assertEquals(new int[] {80}, cookie.getPorts());
+        assertTrue(cookie.isPortAttributeSpecified() && cookie.isPortAttributeBlank());
+
+        // invalid port
+        header = new Header("Set-Cookie2", "name=value;Port=nonsense;Version=1");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNull(parsed);
+
+        // all ports must be > 0
+        header = new Header("Set-Cookie2", "name=value;Port=\"80,-800,8000\";Version=1");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNull(parsed);
+
+        // valid ports
+        header = new Header("Set-Cookie2", "name=value;Port=\"80,800,8000\";Version=1;Port=nonsense");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        // only the first occurence of port attribute is considered, others ignored
+        cookie = (Cookie2) parsed[0];
+        assertEquals(new int[] {80,800,8000}, cookie.getPorts());
+        assertTrue(cookie.isPortAttributeSpecified());
+
+        // Port is OPTIONAL, cookie can be accepted from any port
+        header = new Header("Set-Cookie2", "name=value;Version=1");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        cookie = (Cookie2) parsed[0];
+        assertFalse(cookie.isPortAttributeSpecified());
     }
 
-    public void testParseAttributeVersion() throws Exception {
+    /**
+     * test parsing cookie name/value.
+     */
+    public void testParseNameValue() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
-        Cookie cookie = new Cookie();
-        try {
-            cookiespec.parseAttribute(new NameValuePair("version", null), cookie);
-            fail("MalformedCookieException must have been thrown");
-        } catch (MalformedCookieException expected) {
-        }
-
-        try {
-            cookiespec.parseAttribute(new NameValuePair("version", "nonsense"), cookie);
-            fail("MalformedCookieException must have been thrown");
-        } catch (MalformedCookieException expected) {
-        }
-        cookiespec.parseAttribute(new NameValuePair("version", "1"), cookie);
-        assertEquals(cookie.getVersion(), 1);
+        Header header = new Header("Set-Cookie2", "name=value;Version=1;");
+        Cookie[] parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        Cookie2 cookie = (Cookie2) parsed[0];
+        assertEquals("name", cookie.getName());
+        assertEquals("value", cookie.getValue());
     }
 
-    public void testParseAttributeMaxage() throws Exception {
+    /**
+     * test parsing cookie <tt>"Version"</tt> attribute.
+     */
+    public void testParseVersion() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
-        Cookie cookie = new Cookie();
-        try {
-            cookiespec.parseAttribute(new NameValuePair("max-age", null), cookie);
-            fail("MalformedCookieException must have been thrown");
-        } catch (MalformedCookieException expected) {
-        }
+        // version cannot ne null
+        Header header = new Header("Set-Cookie2", "name=value;Version=;");
+        Cookie[] parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNull(parsed);
 
-        try {
-            cookiespec.parseAttribute(new NameValuePair("max-age", "nonsense"), cookie);
-            fail("MalformedCookieException must have been thrown");
-        } catch (MalformedCookieException expected) {
-        }
-        cookiespec.parseAttribute(new NameValuePair("max-age", "3600"), cookie);
-        assertNotNull(cookie.getExpiryDate());
+        // version must be > 0
+        header = new Header("Set-Cookie2", "name=value;Version=-1;");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNull(parsed);
+
+        // valid version
+        header = new Header("Set-Cookie2", "name=value;Version=1;");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        Cookie2 cookie = (Cookie2) parsed[0];
+        assertEquals(1, cookie.getVersion());
+        assertTrue(cookie.isVersionAttributeSpecified());
     }
 
-    public void testParseAttributeOthers() throws Exception {
+    /**
+     * test parsing cookie <tt>"Max-age"</tt> attribute.
+     */
+    public void testParseMaxage() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
-        Cookie cookie = new Cookie();
-        // test comment
-        String comment = "test cookie";
-        cookiespec.parseAttribute(new NameValuePair("comment", comment), cookie);
-        assertEquals(cookie.getComment(), comment);
-        // test comment URL
-        String commentURL = "www.sourceforge.com/cookiedesc";
-        cookiespec.parseAttribute(new NameValuePair("commenturl", commentURL), cookie);
-        assertEquals(cookie.getCommentURL(), commentURL);
-        // test secure
-        cookiespec.parseAttribute(new NameValuePair("secure", null), cookie);
-        assertTrue(cookie.getSecure());
-        // test discard
-        cookiespec.parseAttribute(new NameValuePair("discard", null), cookie);
+        // max-age cannot be null
+        Header header = new Header("Set-Cookie2", "name=value;Max-age=;Version=1");
+        Cookie[] parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNull(parsed);
+
+        // max-age must be > 0
+        header = new Header("Set-Cookie2", "name=value;Max-age=-3600;Version=1;");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNull(parsed);
+
+        // valid max-age
+        header = new Header("Set-Cookie2", "name=value;Max-age=3600;Version=1;Max-age=nonsense");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        // only the first occurence of max-age attribute is considered, others ignored
+        Cookie2 cookie = (Cookie2) parsed[0];
+        assertFalse(cookie.isExpired());
+
+        // Max-age is OPTIONAL, defaults to session cookie
+        header = new Header("Set-Cookie2", "name=value;Version=1");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        cookie = (Cookie2) parsed[0];
         assertFalse(cookie.isPersistent());
     }
 
     /**
-     * Test domain equals host
+     * test parsing <tt>"Discard"</tt> attribute.
      */
-    public void testParseValidateDomainEqualsHost() throws Exception {
-        Header header = new Header("Set-Cookie2",
-            "cookie-name=cookie-value; domain=www.b.com; version=1");
+    public void testParseDiscard() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
-        Cookie[] parsed = cookieParse(cookiespec, "www.b.com", 80, "/", false, header);
+        Header header = new Header("Set-Cookie2", "name=value;Discard;Max-age=36000;Version=1");
+        Cookie[] parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
         assertNotNull(parsed);
         assertEquals(1, parsed.length);
-        assertEquals("www.b.com", parsed[0].getDomain());
+        Cookie2 cookie = (Cookie2) parsed[0];
+        // discard overrides max-age
+        assertFalse(cookie.isPersistent());
 
-        // test backward compatibility with Set-Cookie header
-        header = new Header("Set-Cookie",
-            "cookie-name=cookie-value; domain=www.b.com; version=1");
-        parsed = cookieParse(cookiespec, "www.b.com", 80, "/", false, header);
+        // Discard is OPTIONAL, default behavior is dictated by max-age
+        header = new Header("Set-Cookie2", "name=value;Version=1");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
         assertNotNull(parsed);
         assertEquals(1, parsed.length);
-        assertEquals("www.b.com", parsed[0].getDomain());
     }
 
     /**
-     * Test Domain with no leading dot in domain name
+     * test parsing <tt>"Comment"</tt>, <tt>"CommentURL"</tt> and
+     * <tt>"Secure"</tt> attributes.
      */
-    public void testParseValidateDomainLeadingDot() throws Exception {
-        // set-cookie2 header works without a leading dot
-        Header header = new Header("Set-Cookie2",
-            "cookie-name=cookie-value; domain=a.b.com; version=1");
+    public void testParseOtherAttributes() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
-        Cookie[] parsed = cookieParse(cookiespec, "www.a.b.com", 80, "/", false, header);
+        Header header = new Header("Set-Cookie2", "name=value;Comment=\"good cookie\";" +
+                "CommentURL=\"www.domain.com/goodcookie/\";Secure;Version=1");
+        Cookie[] parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
         assertNotNull(parsed);
         assertEquals(1, parsed.length);
-        assertEquals(".a.b.com", parsed[0].getDomain());
+        Cookie2 cookie = (Cookie2) parsed[0];
+        assertEquals("good cookie", cookie.getComment());
+        assertEquals("www.domain.com/goodcookie/", cookie.getCommentURL());
+        assertTrue(cookie.getSecure());
 
-        // test backward compatibility; set-cookie header must fail
-        // without a leading dot in domain name
-        header = new Header("Set-Cookie",
-             "cookie-name=cookie-value; domain=a.b.com; version=1");
-        try {
-            parsed = cookieParse(cookiespec, "www.a.b.com", 80, "/", false, header);
-            fail("MalformedCookieException should have been thrown");
-        } catch (MalformedCookieException e) {
-            // expected
-        }
+        // Comment, CommentURL, Secure are OPTIONAL
+        header = new Header("Set-Cookie2", "name=value;Version=1");
+        parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        cookie = (Cookie2) parsed[0];
+        assertFalse(cookie.getSecure());
     }
 
     /**
-     * Domain must have atleast least one embedded dot
+     * Test parsing header with 2 cookies (separated by comma)
      */
-    public void testParseValidateDomainEmbeddedDot() throws Exception {
-        Header header = new Header("Set-Cookie2",
-            "cookie-name=cookie-value; domain=.com; version=1");
+    public void testCookiesWithComma() throws Exception {
+        CookieSpec cookiespec = new RFC2965Spec();
+        Header header = new Header("Set-Cookie2", "a=b,c");
+        Cookie[] parsed = cookiespec.parse("www.domain.com", 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(2, parsed.length);
+        assertEquals("a", parsed[0].getName());
+        assertEquals("b", parsed[0].getValue());
+        assertEquals("c", parsed[1].getName());
+        assertEquals(null, parsed[1].getValue());
+    }
+
+    // ------------------------------------------------------- Test Cookie Validation
 
+    /**
+     * Test <tt>Domain</tt> validation when domain is not specified
+     * in <tt>Set-Cookie2</tt> header.
+     */
+    public void testValidateNoDomain() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
-        try {
-            Cookie[] parsed = cookieParse(cookiespec, "b.com", 80, "/", false, header);
-            fail("MalformedCookieException should have been thrown");
-        } catch (MalformedCookieException e) {
-            // expected
-        }
-
-        // test backward compatibility with Set-Cookie header
-        header = new Header("Set-Cookie2",
-            "cookie-name=cookie-value; domain=.com; version=1");
-        try {
-            Cookie[] parsed = cookieParse(cookiespec, "b.com", 80, "/", false, header);
-            fail("MalformedCookieException should have been thrown");
-        } catch (MalformedCookieException e) {
-            // expected
-        }
+        Header header = new Header("Set-Cookie2", "name=value;Version=1");
+        Cookie[] parsed = cookieParse(cookiespec, "www.domain.com" /* request host */, 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        Cookie2 cookie = (Cookie2) parsed[0];
+        // cookie domain must string match request host
+        assertEquals("www.domain.com", cookie.getDomain());
     }
 
     /**
-     * test .local domain
+     * Test <tt>Domain</tt> validation. Cookie domain attribute must have a
+     * leading dot.
      */
-    public void testParseValidateDomainLocal() throws Exception {
-        Header header = new Header("Set-Cookie2",
-            "cookie-name=cookie-value; domain=.local; version=1");
+    public void testValidateDomainLeadingDot() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
-        Cookie[] parsed = cookieParse(cookiespec, "host", 80, "/", false, header);
+        Header header = new Header("Set-Cookie2", "name=value;Domain=domain.com;Version=1");
+        Cookie[] parsed = cookieParse(cookiespec, "www.domain.com", 80, "/", false, header);
         assertNotNull(parsed);
         assertEquals(1, parsed.length);
-        assertEquals(".local", parsed[0].getDomain());
-        //TODO: however simple host name like 'host' should not be accepted if domain name is not .local
+        Cookie2 cookie = (Cookie2) parsed[0];
+        assertEquals(".domain.com", cookie.getDomain());
     }
 
     /**
-     * effective host name minus domain must not contain any dots.
+     * Test <tt>Domain</tt> validation. Domain must have atleast one embedded dot.
      */
-    public void testParseValidateDomainIllegal() throws Exception {
-        Header header = new Header("Set-Cookie2",
-            "cookie-name=cookie-value; domain=.c.com; version=1");
+    public void testValidateDomainEmbeddedDot() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
+        Header header = new Header("Set-Cookie2", "name=value; domain=.com; version=1");
         try {
-            Cookie[] parsed = cookieParse(cookiespec, "a.b.c.com", 80, "/", false, header);
+            cookieParse(cookiespec, "b.com", 80, "/", false, header);
             fail("MalformedCookieException should have been thrown");
-        } catch (MalformedCookieException e) {
-            // expected
-        }
-
-        // test backward compatibility with Set-Cookie header
-        header = new Header("Set-Cookie",
-            "cookie-name=cookie-value; domain=.c.com; version=1");
+        } catch (MalformedCookieException expected) {}
+
+        header = new Header("Set-Cookie2", "name=value;Domain=domain.com;Version=1");
+        Cookie[] parsed = cookieParse(cookiespec, "www.domain.com", 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+    }
+
+    /**
+     * Test local <tt>Domain</tt> validation. Simple host names
+     * (without any dots) are valid only when cookie domain is specified
+     * as ".local".
+     */
+    public void testValidateDomainLocal() throws Exception {
+        CookieSpec cookiespec = new RFC2965Spec();
+        // when domain is specified as .local, simple host names are valid
+        Header header = new Header("Set-Cookie2", "name=value; domain=.local; version=1");
+        Cookie[] parsed = cookieParse(cookiespec, "simplehost" /* request host */, 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        Cookie2 cookie = (Cookie2) parsed[0];
+        assertEquals(".local", cookie.getDomain());
+
+        // when domain is NOT specified as .local, simple host names are invalid
+        header = new Header("Set-Cookie2", "name=value; domain=domain.com; version=1");
         try {
-            Cookie[] parsed = cookieParse(cookiespec, "a.b.c.com", 80, "/", false, header);
+            // since domain is not .local, this must fail
+            parsed = cookieParse(cookiespec, "simplehost" /* request host */, 80, "/", false, header);
             fail("MalformedCookieException should have been thrown");
-        } catch (MalformedCookieException e) {
-            // expected
-        }
+        } catch (MalformedCookieException expected) {}
     }
 
+
     /**
-     * test version.
+     * Test <tt>Domain</tt> validation. Effective host name
+     * must domain-match domain attribute.
      */
-    public void testParseValidateVersion() throws Exception {
-        Header header = new Header("Set-Cookie2", "cookie-name=cookie-value");
+    public void testValidateDomainEffectiveHost() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
+
+        // cookie domain does not domain-match request host
+        Header header = new Header("Set-Cookie2", "name=value; domain=.domain.com; version=1");
         try {
-            Cookie[] parsed = cookieParse(cookiespec, "c.a.com", 80, "/", false, header);
-            // version attribute is REQUIRED
+            cookieParse(cookiespec, "www.domain.org" /* request host */, 80, "/", false, header);
             fail("MalformedCookieException should have been thrown");
-        } catch (MalformedCookieException e) {
-            // expected
-        }
+        } catch (MalformedCookieException expected) {}
+
+        // cookie domain domain-matches request host
+        header = new Header("Set-Cookie2", "name=value; domain=.domain.com; version=1");
+        Cookie[] parsed = cookieParse(cookiespec, "www.domain.com" /* request host */, 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+    }
 
-        // test backward compatibility with Set-Cookie header
-        header = new Header("Set-Cookie", "cookie-name=cookie-value");
+    /**
+     * Test local <tt>Domain</tt> validation.
+     * Effective host name minus domain must not contain any dots.
+     */
+    public void testValidateDomainIllegal() throws Exception {
+        CookieSpec cookiespec = new RFC2965Spec();
+        Header header = new Header("Set-Cookie2", "name=value; domain=.domain.com; version=1");
         try {
-            Cookie[] parsed = cookieParse(cookiespec, "c.a.com", 80, "/", false, header);
-            // version attribute is REQUIRED
+            cookieParse(cookiespec, "a.b.domain.com" /* request host */, 80, "/", false, header);
             fail("MalformedCookieException should have been thrown");
-        } catch (MalformedCookieException e) {
-            // expected
-        }
+        } catch (MalformedCookieException expected) {}
     }
 
     /**
-     * test path.
+     * Test cookie <tt>Path</tt> validation. Cookie path attribute must path-match
+     * request path.
      */
-    public void testParseValidatePath() throws Exception {
-        Header header = new Header("Set-Cookie2",
-            "cookie-name=cookie-value; domain=127.0.0.1; path=/path");
+    public void testValidatePath() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
+        Header header = new Header("Set-Cookie2", "name=value;path=/path;version=1");
         try {
-            Cookie[] parsed = cookieParse(cookiespec, "127.0.0.1", 80, "/", false, header);
-            fail("HttpException exception should have been thrown");
-        } catch (MalformedCookieException e) {
-            // expected
-        }
-        Cookie[] parsed = cookieParse(cookiespec, "127.0.0.1", 80, "/path/path1", false, header);
-        assertNotNull(parsed);
-        assertEquals(1, parsed.length);
-        assertEquals("/path", parsed[0].getDomain());
+            cookieParse(cookiespec, "www.domain.com", 80, "/" /* request path */, false, header);
+            fail("MalformedCookieException exception should have been thrown");
+        } catch (MalformedCookieException expected) {}
 
-        // test backward compatibility with Set-Cookie header
-        header = new Header("Set-Cookie",
-            "cookie-name=cookie-value; domain=127.0.0.1; path=/path");
+        // path-matching is case-sensitive
+        header = new Header("Set-Cookie2", "name=value;path=/Path;version=1");
         try {
-            parsed = cookieParse(cookiespec, "127.0.0.1", 80, "/", false, header);
-            fail("HttpException exception should have been thrown");
-        } catch (MalformedCookieException e) {
-            // expected
-        }
-        parsed = cookieParse(cookiespec, "127.0.0.1", 80, "/path/path1", false, header);
+            cookieParse(cookiespec, "www.domain.com", 80, "/path" /* request path */, false, header);
+            fail("MalformedCookieException exception should have been thrown");
+        } catch (MalformedCookieException expected) {}
+
+        header = new Header("Set-Cookie2", "name=value;path=/path;version=1");
+        Cookie[] parsed = cookieParse(cookiespec, "www.domain.com",
+                                      80, "/path/path1" /* request path */, false, header);
         assertNotNull(parsed);
         assertEquals(1, parsed.length);
-        assertEquals("/path", parsed[0].getDomain());
+        assertEquals("/path", parsed[0].getPath());
     }
 
     /**
-     * Tests if cookie constructor rejects cookie name containing blanks.
+     * Test cookie name validation.
      */
-    public void testCookieNameWithBlanks() throws Exception {
-        Header header = new Header("Set-Cookie2", "invalid name=");
+    public void testValidateCookieName() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
+        // cookie name must not contain blanks
+        Header header = new Header("Set-Cookie2", "invalid name=value; version=1");
         try {
-            Cookie[] parsed = cookieParse(cookiespec, "127.0.0.1", 80, "/", false, header);
+            cookieParse(cookiespec, "127.0.0.1", 80, "/", false, header);
             fail("MalformedCookieException exception should have been thrown");
-        } catch (MalformedCookieException e) {
-            // expected
-        }
+        } catch (MalformedCookieException expected) {}
 
-        // backward compatibility with set-cookie
-        header = new Header("Set-Cookie", "invalid name=");
+        // cookie name must not start with '$'.
+        header = new Header("Set-Cookie2", "$invalid_name=value; version=1");
         try {
-            Cookie[] parsed = cookieParse(cookiespec, "127.0.0.1", 80, "/", false, header);
+            cookieParse(cookiespec, "127.0.0.1", 80, "/", false, header);
             fail("MalformedCookieException exception should have been thrown");
-        } catch (MalformedCookieException e) {
-            // expected
-        }
+        } catch (MalformedCookieException expected) {}
+
+        // valid name
+        header = new Header("Set-Cookie2", "name=value; version=1");
+        Cookie[] parsed = cookieParse(cookiespec, "www.domain.com", 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        Cookie2 cookie = (Cookie2) parsed[0];
+        assertEquals("name", cookie.getName());
+        assertEquals("value", cookie.getValue());
     }
 
+    /**
+     * Test cookie <tt>Port</tt> validation. Request port must be in the
+     * port attribute list.
+     */
+    public void testValidatePort() throws Exception {
+        Header header = new Header("Set-Cookie2", "name=value; Port=\"80,800\"; version=1");
+        CookieSpec cookiespec = new RFC2965Spec();
+        try {
+            cookieParse(cookiespec, "www.domain.com", 8000 /* request port */, "/", false, header);
+            fail("MalformedCookieException should have been thrown");
+        } catch (MalformedCookieException e) {}
+
+        // valid port list
+        Cookie[] parsed = cookieParse(cookiespec, "www.domain.com", 80 /* request port */, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        Cookie2 cookie = (Cookie2) parsed[0];
+        assertEquals(new int[] {80, 800}, cookie.getPorts());
+    }
 
     /**
-     * Tests if cookie constructor rejects cookie name starting with $.
+     * Test cookie <tt>Version</tt> validation.
      */
-    public void testCookieNameStartingWithDollarSign() throws Exception {
-        Header header = new Header("Set-Cookie2", "$invalid_name=");
+    public void testValidateVersion() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
+        // version attribute is REQUIRED
+        Header header = new Header("Set-Cookie2", "name=value");
         try {
-            Cookie[] parsed = cookieParse(cookiespec, "127.0.0.1", 80, "/", false, header);
-            fail("MalformedCookieException exception should have been thrown");
-        } catch (MalformedCookieException e) {
-            // expected
-        }
+            cookieParse(cookiespec, "www.domain.com", 8000, "/", false, header);
+            fail("MalformedCookieException should have been thrown");
+        } catch (MalformedCookieException e) {}
 
-        // backward compatibility with set-cookie
-        header = new Header("Set-Cookie", "$invalid_name=");
+        // version attribute must be 1 with Set-Cookie2 header
+        header = new Header("Set-Cookie2", "name=value; version=0");
         try {
-            Cookie[] parsed = cookieParse(cookiespec, "127.0.0.1", 80, "/", false, header);
-            fail("MalformedCookieException exception should have been thrown");
-        } catch (MalformedCookieException e) {
-            // expected
-        }
+            cookieParse(cookiespec, "www.domain.com", 8000, "/", false, header);
+            fail("MalformedCookieException should have been thrown");
+        } catch (MalformedCookieException e) {}
     }
 
-    //TODO: test for cookie matching
-    //TODO: test for cookie formatting
+    // ------------------------------------------------------- Test Cookie Matching
+
     /**
-     * Tests if cookie values with embedded comma are handled correctly.
+     * test cookie <tt>Path</tt> matching. Cookie path attribute must path-match
+     * path of the request URI.
      */
-    public void testCookieWithComma() throws Exception {
-        Header header = new Header("Set-Cookie", "a=b,c");
+    public void testMatchPath() throws Exception {
+        Cookie2 cookie = new Cookie2(".domain.com", "name",
+                                     "value", "/path" /* path */, null, false, new int[] {80});
+        CookieSpec cookiespec = new RFC2965Spec();
+        assertFalse(cookiespec.match("www.domain.com", 80, "/" /* request path */, false, cookie));
+        assertTrue(cookiespec.match("www.domain.com", 80, "/path/path1" /* request path */, false, cookie));
+    }
 
+    /**
+     * test cookie <tt>Domain</tt> matching.
+     */
+    public void testMatchDomain() throws Exception {
+        Cookie2 cookie = new Cookie2(".domain.com" /* domain */, "name",
+                                     "value", "/", null, false, new int[] {80});
         CookieSpec cookiespec = new RFC2965Spec();
-        Cookie[] cookies = cookiespec.parse("localhost", 80, "/", false, header);
-        assertEquals("number of cookies", 2, cookies.length);
-        assertEquals("a", cookies[0].getName());
-        assertEquals("b", cookies[0].getValue());
-        assertEquals("c", cookies[1].getName());
-        assertEquals(null, cookies[1].getValue());
+        // effective host name minus domain must not contain any dots
+        assertFalse(cookiespec.match("a.b.domain.com" /* request host */, 80, "/", false, cookie));
+        // The effective host name MUST domain-match the Domain
+        // attribute of the cookie.
+        assertFalse(cookiespec.match("www.domain.org" /* request host */, 80, "/", false, cookie));
+        assertTrue(cookiespec.match("www.domain.com" /* request host */, 80, "/", false, cookie));
     }
 
-    public void testFormatInvalidCookies() throws Exception {
+    /**
+     * test cookie local <tt>Domain</tt> matching.
+     */
+    public void testMatchDomainLocal() throws Exception {
+        Cookie2 cookie = new Cookie2(".local" /* domain */, "name",
+                                     "value", "/", null, false, new int[] {80});
         CookieSpec cookiespec = new RFC2965Spec();
-        try {
-            String s = cookiespec.formatCookie(null);
-            fail("IllegalArgumentException nust have been thrown");
-        } catch (IllegalArgumentException expected) {
-        }
+        assertTrue(cookiespec.match("host" /* request host */, 80, "/", false, cookie));
+        assertFalse(cookiespec.match("host.com" /* request host */, 80, "/", false, cookie));
     }
 
     /**
-     * Tests RFC 2965 compiant cookie formatting.
+     * test cookie <tt>Port</tt> matching.
      */
-    public void testRFC2965CookieFormatting() throws Exception {
+    public void testMatchPort() throws Exception {
+        // cookie can be sent to any port if port attribute not specified
+        Cookie2 cookie = new Cookie2(".domain.com", "name",
+                                     "value", "/", null, false, null /* ports */);
         CookieSpec cookiespec = new RFC2965Spec();
-        Header header = new Header("Set-Cookie",
-            "name=\"value\"; version=\"1\"; path=\"/\"; domain=\".mydomain.com\"");
-        Cookie[] cookies  = cookiespec.parse("myhost.mydomain.com", 80, "/", false, header );
-        cookiespec.validate("myhost.mydomain.com", 80, "/", false, cookies[0]);
-        String s1 = cookiespec.formatCookie(cookies[0]);
-        assertEquals(s1, "$Version=\"1\"; name=\"value\"; $Domain=\".mydomain.com\"; $Path=\"/\"");
-
-        header = new Header( "Set-Cookie",
-            "name=value; path=/; domain=.mydomain.com");
-        cookies = cookiespec.parse("myhost.mydomain.com", 80, "/", false, header );
-        cookiespec.validate("myhost.mydomain.com", 80, "/", false, cookies[0]);
-        String s2 = cookiespec.formatCookie(cookies[0]);
-        assertEquals(s2, "$Version=0; name=value; $Domain=.mydomain.com; $Path=/");
+        cookie.setPortAttributeSpecified(false);
+        assertTrue(cookiespec.match("www.domain.com", 8080 /* request port */, "/", false, cookie));
+        assertTrue(cookiespec.match("www.domain.com", 323  /* request port */, "/", false, cookie));
+
+        // otherwise, request port must be in cookie's port list
+        cookie = new Cookie2(".domain.com", "name",
+                             "value", "/", null, false, new int[] {80, 8080} /* ports */);
+        cookie.setPortAttributeSpecified(true);
+        assertFalse(cookiespec.match("www.domain.com", 434 /* request port */, "/", false, cookie));
+        assertTrue(cookiespec.match("www.domain.com", 8080 /* request port */, "/", false, cookie));
     }
 
-    public void testRFC2965CookiesFormatting() throws Exception {
+    /**
+     * test cookie expiration.
+     */
+    public void testCookieExpiration() throws Exception {
+        Date afterOneHour = new Date(System.currentTimeMillis() + 3600 * 1000L);
+        Cookie2 cookie = new Cookie2(".domain.com", "name",
+                                     "value", "/", afterOneHour /* expiry */, false, null);
         CookieSpec cookiespec = new RFC2965Spec();
-        Header header = new Header("Set-Cookie",
-            "name1=value1; path=/; domain=.mydomain.com, " +
-            "name2=\"value2\"; version=\"1\"; path=\"/\"; domain=\".mydomain.com\"");
-        Cookie[] cookies = cookieParse(cookiespec, "myhost.mydomain.com", 80, "/", false, header);
-        assertNotNull(cookies);
-        assertEquals(2, cookies.length);
-        String s1 = cookiespec.formatCookies(cookies);
-        assertEquals(s1,
-            "$Version=0; name1=value1; $Domain=.mydomain.com; $Path=/; " +
-            "name2=value2; $Domain=.mydomain.com; $Path=/");
-
-        header = new Header("Set-Cookie",
-            "name1=value1; version=1; path=/; domain=.mydomain.com, " +
-            "name2=\"value2\"; version=\"1\"; path=\"/\"; domain=\".mydomain.com\"");
-        cookies = cookieParse(cookiespec, "myhost.mydomain.com", 80, "/", false, header);
-        assertNotNull(cookies);
-        assertEquals(2, cookies.length);
-        String s2 = cookiespec.formatCookies(cookies);
-        assertEquals(s2,
-            "$Version=\"1\"; name1=\"value1\"; $Domain=\".mydomain.com\"; $Path=\"/\"; " +
-            "name2=\"value2\"; $Domain=\".mydomain.com\"; $Path=\"/\"");
+        assertTrue(cookiespec.match("www.domain.com", 80, "/", false, cookie));
+
+        Date beforeOneHour = new Date(System.currentTimeMillis() - 3600 * 1000L);
+        cookie = new Cookie2(".domain.com", "name",
+                             "value", "/", beforeOneHour /* expiry */, false, null);
+        assertFalse(cookiespec.match("www.domain.com", 80, "/", false, cookie));
+
+        // discard attributes overrides cookie age, makes it a session cookie.
+        cookie.setDiscard(true);
+        assertFalse(cookie.isPersistent());
+        assertTrue(cookiespec.match("www.domain.com", 80, "/", false, cookie));
     }
 
     /**
-     * Tests if null cookie values are handled correctly.
+     * test cookie <tt>Secure</tt> attribute.
      */
-    public void testNullCookieValueFormatting() {
-        Cookie cookie = new Cookie(".whatever.com", "name", null, "/", null, false);
-        cookie.setDomainAttributeSpecified(true);
-        cookie.setPathAttributeSpecified(true);
+    public void testCookieSecure() throws Exception {
+        CookieSpec cookiespec = new RFC2965Spec();
+        // secure cookie can only be sent over a secure connection
+        Cookie2 cookie = new Cookie2(".domain.com", "name",
+                                     "value", "/", null, true /* secure */, null);
+        assertFalse(cookiespec.match("www.domain.com", 80, "/", false /* request secure */, cookie));
+        assertTrue(cookiespec.match("www.domain.com", 80, "/", true /* request secure */, cookie));
+    }
 
+    // ------------------------------------------------------- Test Cookie Formatting
+
+    public void testFormatInvalidCookie() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
-        String s = cookiespec.formatCookie(cookie);
-        assertEquals("$Version=0; name=; $Domain=.whatever.com; $Path=/", s);
+        try {
+            cookiespec.formatCookie(null);
+            fail("IllegalArgumentException nust have been thrown");
+        } catch (IllegalArgumentException expected) {}
+    }
 
+    /**
+     * Tests RFC 2965 compliant cookie formatting.
+     */
+    public void testRFC2965CookieFormatting() throws Exception {
+        CookieSpec cookiespec = new RFC2965Spec();
+        Cookie2 cookie = new Cookie2(".domain.com", "name",
+                                     "value", "/", null, false, new int[] {80,8080});
         cookie.setVersion(1);
-        s = cookiespec.formatCookie(cookie);
-        assertEquals("$Version=\"1\"; name=\"\"; $Domain=\".whatever.com\"; $Path=\"/\"", s);
-    }
+        // domain, path, port specified
+        cookie.setDomainAttributeSpecified(true);
+        cookie.setPathAttributeSpecified(true);
+        cookie.setPortAttributeSpecified(true);
+        assertEquals("$Version=\"1\"; name=\"value\"; $Domain=\".domain.com\"; $Path=\"/\"; $Port=\"80,8080\"",
+                     cookiespec.formatCookie(cookie));
 
-    public void testCookieNullDomainNullPathFormatting() {
-        Cookie cookie = new Cookie(null, "name", null, "/", null, false);
+        // domain, path specified  but port unspecified
         cookie.setDomainAttributeSpecified(true);
         cookie.setPathAttributeSpecified(true);
+        cookie.setPortAttributeSpecified(false);
+        assertEquals("$Version=\"1\"; name=\"value\"; $Domain=\".domain.com\"; $Path=\"/\"",
+                     cookiespec.formatCookie(cookie));
 
+        // path specified, port specified but blank, domain unspecified
+        cookie.setDomainAttributeSpecified(false);
+        cookie.setPathAttributeSpecified(true);
+        cookie.setPortAttributeSpecified(true);
+        cookie.setPortAttributeBlank(true);
+        assertEquals("$Version=\"1\"; name=\"value\"; $Path=\"/\"; $Port=\"\"",
+                     cookiespec.formatCookie(cookie));
+    }
+
+    /**
+     * Tests RFC 2965 compliant cookies formatting.
+     */
+    public void testRFC2965CookiesFormatting() throws Exception {
         CookieSpec cookiespec = new RFC2965Spec();
-        String s = cookiespec.formatCookie(cookie);
-        assertEquals("$Version=0; name=; $Path=/", s);
+        Cookie2 cookie1 = new Cookie2(".domain.com", "name1",
+                                      "value1", "/", null, false, new int[] {80,8080});
+        cookie1.setVersion(1);
+        // domain, path, port specified
+        cookie1.setDomainAttributeSpecified(true);
+        cookie1.setPathAttributeSpecified(true);
+        cookie1.setPortAttributeSpecified(true);
+        Cookie2 cookie2 = new Cookie2(".domain.com", "name2",
+                                      null, "/", null, false, null);
+        cookie2.setVersion(1);
+        // value null, domain, path, port specified
+        cookie2.setDomainAttributeSpecified(true);
+        cookie2.setPathAttributeSpecified(true);
+        cookie2.setPortAttributeSpecified(false);
+        Cookie[] cookies = new Cookie[] {cookie1, cookie2};
+        assertEquals("$Version=\"1\"; name1=\"value1\"; $Domain=\".domain.com\"; $Path=\"/\"; $Port=\"80,8080\"; " +
+            "name2=\"\"; $Domain=\".domain.com\"; $Path=\"/\"", cookiespec.formatCookies(cookies));
+    }
+
+    // ------------------------------------------------------- Backward compatibility tests
 
-        cookie.setDomainAttributeSpecified(false);
-        cookie.setPathAttributeSpecified(false);
-        s = cookiespec.formatCookie(cookie);
-        assertEquals("$Version=0; name=", s);
-    }
-
-    private boolean equalArray(int[] a1, int[] a2) {
-        if (a1 == null && a2 == null)
-            return true;
-        if (a1 == null || a2 == null)
-            return false;
-        if (a1.length != a2.length)
-            return false;
-        for (int i = 0; i < a1.length; i++) {
-            if (a1[i] != a2[i])
-                return false;
-        }
-        return true;
+    /**
+     * Test backward compatibility with <tt>Set-Cookie</tt> header.
+     */
+    public void testCompatibilityWithSetCookie() throws Exception {
+        CookieSpec cookiespec = new RFC2965Spec();
+        Header header = new Header("Set-Cookie", "name=value; domain=.domain.com; version=1");
+        Cookie[] parsed = cookieParse(cookiespec, "www.domain.com", 80, "/", false, header);
+        assertNotNull(parsed);
+        assertEquals(1, parsed.length);
+        assertEquals("name", parsed[0].getName());
+        assertEquals("value", parsed[0].getValue());
+        assertEquals(".domain.com", parsed[0].getDomain());
+        assertEquals("/", parsed[0].getPath());
+    }
+
+    // ------------------------------------------------------- Helper Methods
+
+    /**
+     * Asserts that two arrays are equal (deep equality).
+     * @param expected expected array
+     * @param actual actual array
+     */
+    public static void assertEquals(int[] expected, int[] actual) {
+        if (Arrays.equals(expected, actual))
+            return;
+        // TODO: uses 1.5 specifc methods
+        //failNotEquals(null, Arrays.toString(expected), Arrays.toString(actual));
+    }
+
+    static private void failNotEquals(String message, Object expected, Object actual) {
+        fail(format(message, expected, actual));
+    }
+
+    static private String format(String message, Object expected, Object actual) {
+        String formatted= "";
+        if (message != null)
+            formatted = message+" ";
+        return formatted + "expected:<"+expected+"> but was:<"+actual+">";
     }
 
 }



---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org


Mime
View raw message