1/* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements.  See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License.  You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16package org.apache.harmony.luni.tests.java.net;
17
18import java.net.CookieManager;
19import java.net.CookieStore;
20import java.net.HttpCookie;
21import java.net.URI;
22import java.net.URISyntaxException;
23import java.util.ArrayList;
24import java.util.List;
25import java.util.RandomAccess;
26
27import junit.framework.TestCase;
28
29public class CookieStoreTest extends TestCase {
30
31    private CookieManager cookieManager;
32
33    private CookieStore cookieStore;
34
35    /**
36     * @tests java.net.CookieStore#add(URI, HttpCookie)
37     *
38     * @since 1.6
39     */
40    public void test_add_LURI_LHttpCookie() throws URISyntaxException {
41        URI uri = new URI("http://harmony.test.unit.org");
42        HttpCookie cookie = new HttpCookie("name1", "value1");
43        cookie.setDiscard(true);
44        try {
45            cookieStore.add(null, cookie);
46            fail("should throw NullPointerException");
47        } catch (NullPointerException e) {
48            // expected
49        }
50
51        try {
52            cookieStore.add(uri, null);
53            fail("should throw NullPointerException");
54        } catch (NullPointerException e) {
55            // expected
56        }
57
58        try {
59            cookieStore.add(null, null);
60            fail("should throw NullPointerException");
61        } catch (NullPointerException e) {
62            // expected
63        }
64
65        cookieStore.add(uri, cookie);
66        List<HttpCookie> list = cookieStore.get(uri);
67        assertEquals(1, list.size());
68        assertTrue(list.contains(cookie));
69
70        HttpCookie cookie2 = new HttpCookie("  NaME1   ", "  TESTVALUE1   ");
71        cookieStore.add(uri, cookie2);
72        list = cookieStore.get(uri);
73        assertEquals(1, list.size());
74        assertEquals("  TESTVALUE1   ", list.get(0).getValue());
75        assertTrue(list.contains(cookie2));
76
77        // domain and path attributes works
78        HttpCookie anotherCookie = new HttpCookie("name1", "value1");
79        anotherCookie.setDomain("domain");
80        anotherCookie.setPath("Path");
81        cookieStore.add(uri, anotherCookie);
82        list = cookieStore.get(uri);
83        assertEquals(2, list.size());
84        assertNull(list.get(0).getDomain());
85        assertEquals("domain", list.get(1).getDomain());
86        assertEquals("Path", list.get(1).getPath());
87
88        URI uri2 = new URI("http://.test.unit.org");
89        HttpCookie cookie3 = new HttpCookie("NaME2", "VALUE2");
90        cookieStore.add(uri2, cookie3);
91        list = cookieStore.get(uri2);
92        assertEquals(1, list.size());
93        assertEquals("VALUE2", list.get(0).getValue());
94        list = cookieStore.getCookies();
95        assertEquals(3, list.size());
96
97        // expired cookie won't be selected.
98        HttpCookie cookie4 = new HttpCookie("cookie4", "value4");
99        cookie4.setMaxAge(-2);
100        assertTrue(cookie4.hasExpired());
101        cookieStore.add(uri2, cookie4);
102        list = cookieStore.getCookies();
103        assertEquals(3, list.size());
104        assertFalse(cookieStore.remove(uri2, cookie4));
105
106        cookie4.setMaxAge(3000);
107        cookie4.setDomain("domain");
108        cookie4.setPath("path");
109        cookieStore.add(uri2, cookie4);
110        list = cookieStore.get(uri2);
111        assertEquals(2, list.size());
112
113        cookieStore.add(uri, cookie4);
114        list = cookieStore.get(uri);
115        assertEquals(3, list.size());
116        list = cookieStore.get(uri2);
117        assertEquals(2, list.size());
118        list = cookieStore.getCookies();
119        assertEquals(4, list.size());
120
121        URI baduri = new URI("bad_url");
122        HttpCookie cookie6 = new HttpCookie("cookie5", "value5");
123        cookieStore.add(baduri, cookie6);
124        list = cookieStore.get(baduri);
125        assertTrue(list.contains(cookie6));
126    }
127
128    /**
129     * @tests java.net.CookieStore#get(URI)
130     *
131     * @since 1.6
132     */
133    public void test_get_LURI() throws URISyntaxException {
134        try {
135            cookieStore.get(null);
136            fail("should throw NullPointerException");
137        } catch (NullPointerException e) {
138            // expected
139        }
140
141        URI uri1 = new URI("http://get.uri1.test.org");
142        List<HttpCookie> list = cookieStore.get(uri1);
143        assertTrue(list.isEmpty());
144        assertTrue(list instanceof ArrayList);
145
146        HttpCookie cookie1 = new HttpCookie("cookie_name1", "cookie_value1");
147        HttpCookie cookie2 = new HttpCookie("cookie_name2", "cookie_value2");
148        cookieStore.add(uri1, cookie1);
149        cookieStore.add(uri1, cookie2);
150        URI uri2 = new URI("http://get.uri2.test.org");
151        HttpCookie cookie3 = new HttpCookie("cookie_name3", "cookie_value3");
152        cookieStore.add(uri2, cookie3);
153        list = cookieStore.get(uri1);
154        assertEquals(2, list.size());
155        list = cookieStore.get(uri2);
156        assertEquals(1, list.size());
157
158        // domain-match cookies also be selected.
159        HttpCookie cookie4 = new HttpCookie("cookie_name4", "cookie_value4");
160        cookie4.setDomain(".uri1.test.org");
161        cookieStore.add(uri2, cookie4);
162        list = cookieStore.get(uri1);
163        assertEquals(3, list.size());
164
165        cookieStore.add(uri1, cookie4);
166        list = cookieStore.get(uri1);
167        assertEquals(3, list.size());
168        list = cookieStore.get(uri2);
169        assertEquals(2, list.size());
170
171        // expired cookie won't be selected.
172        HttpCookie cookie5 = new HttpCookie("cookie_name5", "cookie_value5");
173        cookie5.setMaxAge(-333);
174        assertTrue(cookie5.hasExpired());
175        cookieStore.add(uri1, cookie5);
176        list = cookieStore.get(uri1);
177        assertEquals(3, list.size());
178        assertFalse(cookieStore.remove(uri1, cookie5));
179        list = cookieStore.getCookies();
180        assertEquals(4, list.size());
181
182        cookie4.setMaxAge(-123);
183        list = cookieStore.get(uri1);
184        assertEquals(2, list.size());
185        list = cookieStore.getCookies();
186        assertEquals(3, list.size());
187        // expired cookies are also deleted even if it domain-matches the URI
188        HttpCookie cookie6 = new HttpCookie("cookie_name6", "cookie_value6");
189        cookie6.setMaxAge(-2);
190        cookie6.setDomain(".uri1.test.org");
191        cookieStore.add(uri2, cookie6);
192        list = cookieStore.get(uri1);
193        assertEquals(2, list.size());
194        assertFalse(cookieStore.remove(null, cookie6));
195
196        URI uri3 = new URI("http://get.uri3.test.org");
197        assertTrue(cookieStore.get(uri3).isEmpty());
198        URI baduri = new URI("invalid_uri");
199        assertTrue(cookieStore.get(baduri).isEmpty());
200    }
201
202    /**
203     * @tests java.net.CookieStore#getCookies()
204     *
205     * @since 1.6
206     */
207    public void test_getCookies() throws URISyntaxException {
208        List<HttpCookie> list = cookieStore.getCookies();
209        assertTrue(list.isEmpty());
210        assertTrue(list instanceof RandomAccess);
211
212        HttpCookie cookie1 = new HttpCookie("cookie_name", "cookie_value");
213        URI uri1 = new URI("http://getcookies1.test.org");
214        cookieStore.add(uri1, cookie1);
215        list = cookieStore.getCookies();
216        assertTrue(list.contains(cookie1));
217
218        HttpCookie cookie2 = new HttpCookie("cookie_name2", "cookie_value2");
219        URI uri2 = new URI("http://getcookies2.test.org");
220        cookieStore.add(uri2, cookie2);
221        list = cookieStore.getCookies();
222        assertEquals(2, list.size());
223        assertTrue(list.contains(cookie1));
224        assertTrue(list.contains(cookie2));
225
226        // duplicated cookie won't be selected.
227        cookieStore.add(uri2, cookie1);
228        list = cookieStore.getCookies();
229        assertEquals(2, list.size());
230        // expired cookie won't be selected.
231        HttpCookie cookie3 = new HttpCookie("cookie_name3", "cookie_value3");
232        cookie3.setMaxAge(-1357);
233        cookieStore.add(uri1, cookie3);
234        list = cookieStore.getCookies();
235        assertEquals(2, list.size());
236
237        try {
238            list.add(new HttpCookie("readOnlyName", "readOnlyValue"));
239            fail("should throw UnsupportedOperationException");
240        } catch (UnsupportedOperationException e) {
241            // expected
242        }
243
244        try {
245            list.remove(new HttpCookie("readOnlyName", "readOnlyValue"));
246            fail("should throw UnsupportedOperationException");
247        } catch (UnsupportedOperationException e) {
248            // expected
249        }
250    }
251
252    /**
253     * @tests java.net.CookieStore#getURIs()
254     *
255     * @since 1.6
256     */
257    public void test_getURIs() throws URISyntaxException {
258        List<URI> list = cookieStore.getURIs();
259        assertTrue(list.isEmpty());
260        assertTrue(list instanceof ArrayList);
261
262        URI uri1 = new URI("http://geturis1.test.com");
263        HttpCookie cookie1 = new HttpCookie("cookie_name1", "cookie_value1");
264        cookieStore.add(uri1, cookie1);
265        list = cookieStore.getURIs();
266        assertEquals("geturis1.test.com", list.get(0).getHost());
267
268        HttpCookie cookie2 = new HttpCookie("cookie_name2", "cookie_value2");
269        cookieStore.add(uri1, cookie2);
270        list = cookieStore.getURIs();
271        assertEquals(1, list.size());
272
273        URI uri2 = new URI("http://geturis2.test.com");
274        cookieStore.add(uri2, cookie2);
275        list = cookieStore.getURIs();
276        assertEquals(2, list.size());
277        assertTrue(list.contains(uri1));
278        assertTrue(list.contains(uri2));
279    }
280
281    /**
282     * @tests java.net.CookieStore#remove(URI, HttpCookie)
283     *
284     * @since 1.6
285     */
286    public void test_remove_LURI_LHttpCookie() throws URISyntaxException {
287        URI uri1 = new URI("http://remove1.test.com");
288        HttpCookie cookie1 = new HttpCookie("cookie_name1", "cookie_value1");
289        try {
290            cookieStore.remove(uri1, null);
291            fail("should throw NullPointerException");
292        } catch (NullPointerException e) {
293            // expected
294        }
295        assertFalse(cookieStore.remove(uri1, cookie1));
296        assertFalse(cookieStore.remove(null, cookie1));
297
298        cookieStore.add(uri1, cookie1);
299        URI uri2 = new URI("http://remove2.test.com");
300        HttpCookie cookie2 = new HttpCookie("cookie_name2", "cookie_value2");
301        cookieStore.add(uri2, cookie2);
302        assertTrue(cookieStore.remove(uri1, cookie1));
303        assertFalse(cookieStore.remove(uri1, cookie1));
304        assertEquals(2, cookieStore.getURIs().size());
305        assertEquals(1, cookieStore.getCookies().size());
306        assertTrue(cookieStore.remove(uri2, cookie2));
307        assertFalse(cookieStore.remove(uri2, cookie2));
308        assertEquals(2, cookieStore.getURIs().size());
309        assertEquals(0, cookieStore.getCookies().size());
310
311        assertTrue(cookieStore.removeAll());
312        cookieStore.add(uri1, cookie1);
313        cookieStore.add(uri2, cookie2);
314        HttpCookie cookie3 = new HttpCookie("cookie_name3", "cookie_value3");
315        assertFalse(cookieStore.remove(null, cookie3));
316        assertTrue(cookieStore.remove(null, cookie1));
317        assertFalse(cookieStore.remove(null, cookie1));
318        assertEquals(2, cookieStore.getURIs().size());
319        assertEquals(1, cookieStore.getCookies().size());
320        assertTrue(cookieStore.remove(null, cookie2));
321        assertFalse(cookieStore.remove(null, cookie2));
322        assertEquals(2, cookieStore.getURIs().size());
323        assertEquals(0, cookieStore.getCookies().size());
324
325        cookieStore.removeAll();
326        // expired cookies can also be deleted.
327        cookie2.setMaxAge(-34857);
328        cookieStore.add(uri2, cookie2);
329        assertTrue(cookieStore.remove(uri2, cookie2));
330        assertFalse(cookieStore.remove(uri2, cookie2));
331        assertEquals(0, cookieStore.getCookies().size());
332
333        cookie2.setMaxAge(34857);
334        cookieStore.add(uri1, cookie1);
335        cookieStore.add(uri2, cookie1);
336        cookieStore.add(uri2, cookie2);
337        assertTrue(cookieStore.remove(uri1, cookie1));
338        assertFalse(cookieStore.remove(uri1, cookie1));
339        assertFalse(cookieStore.get(uri2).contains(cookie1));
340        assertTrue(cookieStore.get(uri2).contains(cookie2));
341        assertEquals(0, cookieStore.get(uri1).size());
342        cookieStore.remove(uri2, cookie2);
343
344        cookieStore.removeAll();
345        cookieStore.add(uri2, cookie2);
346        cookieStore.add(uri1, cookie1);
347        assertEquals(2, cookieStore.getCookies().size());
348        assertTrue(cookieStore.remove(uri2, cookie1));
349        assertFalse(cookieStore.remove(uri2, cookie1));
350        assertEquals(2, cookieStore.getURIs().size());
351        assertEquals(1, cookieStore.getCookies().size());
352        assertTrue(cookieStore.getCookies().contains(cookie2));
353
354        cookieStore.removeAll();
355        URI uri3 = new URI("http://remove3.test.com");
356        URI uri4 = new URI("http://test.com");
357        HttpCookie cookie4 = new HttpCookie("cookie_name4", "cookie_value4");
358        cookie4.setDomain(".test.com");
359        cookie2.setMaxAge(-34857);
360        cookie3.setMaxAge(-22);
361        cookie4.setMaxAge(-45);
362        cookieStore.add(uri1, cookie1);
363        cookieStore.add(uri2, cookie2);
364        cookieStore.add(uri3, cookie3);
365        cookieStore.add(uri4, cookie4);
366        assertEquals(0, cookieStore.get(uri2).size());
367        assertFalse(cookieStore.remove(uri2, cookie2));
368        assertTrue(cookieStore.remove(uri3, cookie3));
369        assertFalse(cookieStore.remove(uri4, cookie4));
370    }
371
372    /**
373     * @tests java.net.CookieStore#test_removeAll()
374     *
375     * @since 1.6
376     */
377    public void test_removeAll() throws URISyntaxException {
378        // Spec says returns true if this store changed as a result of the call.
379        // But RI always return true.
380        assertTrue(cookieStore.removeAll());
381
382        URI uri1 = new URI("http://removeAll1.test.com");
383        HttpCookie cookie1 = new HttpCookie("cookie_name1", "cookie_value1");
384        cookieStore.add(uri1, cookie1);
385        URI uri2 = new URI("http://removeAll2.test.com");
386        HttpCookie cookie2 = new HttpCookie("cookie_name2", "cookie_value2");
387        cookieStore.add(uri2, cookie2);
388
389        assertTrue(cookieStore.removeAll());
390        assertTrue(cookieStore.getURIs().isEmpty());
391        assertTrue(cookieStore.getCookies().isEmpty());
392
393        assertTrue(cookieStore.removeAll());
394    }
395
396    @Override
397    protected void setUp() throws Exception {
398        super.setUp();
399        cookieManager = new CookieManager();
400        cookieStore = cookieManager.getCookieStore();
401    }
402
403    @Override
404    protected void tearDown() throws Exception {
405        cookieManager = null;
406        cookieStore = null;
407        super.tearDown();
408    }
409
410}
411