UriTest.java revision 58a345936d7e2b66bdeefb492e4f777754792d7e 
1/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * 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 */
16
17package android.net;
18
19import android.net.Uri;
20import android.content.ContentUris;
21import android.os.Parcel;
22import android.test.suitebuilder.annotation.SmallTest;
23import junit.framework.TestCase;
24
25import java.io.File;
26import java.util.Arrays;
27import java.util.Iterator;
28import java.util.List;
29import java.util.Set;
30
31public class UriTest extends TestCase {
32
33    @SmallTest
34    public void testToStringWithPathOnly() {
35        Uri.Builder builder = new Uri.Builder();
36
37        // Not a valid path, but this came from a user's test case.
38        builder.path("//foo");
39        Uri uri = builder.build();
40        assertEquals("//foo", uri.toString());
41    }
42
43    @SmallTest
44    public void testParcelling() {
45        parcelAndUnparcel(Uri.parse("foo:bob%20lee"));
46        parcelAndUnparcel(Uri.fromParts("foo", "bob lee", "fragment"));
47        parcelAndUnparcel(new Uri.Builder()
48            .scheme("http")
49            .authority("crazybob.org")
50            .path("/rss/")
51            .encodedQuery("a=b")
52            .fragment("foo")
53            .build());
54    }
55
56    private void parcelAndUnparcel(Uri u) {
57        Parcel p = Parcel.obtain();
58        try {
59            Uri.writeToParcel(p, u);
60            p.setDataPosition(0);
61            assertEquals(u, Uri.CREATOR.createFromParcel(p));
62
63            p.setDataPosition(0);
64            u = u.buildUpon().build();
65            Uri.writeToParcel(p, u);
66            p.setDataPosition(0);
67            assertEquals(u, Uri.CREATOR.createFromParcel(p));
68        }
69        finally {
70            p.recycle();
71        }
72    }
73
74    @SmallTest
75    public void testBuildUponOpaqueStringUri() {
76        Uri u = Uri.parse("bob:lee").buildUpon().scheme("robert").build();
77        assertEquals("robert", u.getScheme());
78        assertEquals("lee", u.getEncodedSchemeSpecificPart());
79        assertEquals("lee", u.getSchemeSpecificPart());
80        assertNull(u.getQuery());
81        assertNull(u.getPath());
82        assertNull(u.getAuthority());
83        assertNull(u.getHost());
84    }
85
86    @SmallTest
87    public void testStringUri() {
88        assertEquals("bob lee",
89                Uri.parse("foo:bob%20lee").getSchemeSpecificPart());
90        assertEquals("bob%20lee",
91                Uri.parse("foo:bob%20lee").getEncodedSchemeSpecificPart());
92        assertEquals("/bob%20lee",
93                Uri.parse("foo:/bob%20lee").getEncodedPath());
94        assertNull(Uri.parse("foo:bob%20lee").getPath());
95        assertEquals("bob%20lee",
96                Uri.parse("foo:?bob%20lee").getEncodedQuery());
97        assertNull(Uri.parse("foo:bar#?bob%20lee").getQuery());
98        assertEquals("bob%20lee",
99                Uri.parse("foo:#bob%20lee").getEncodedFragment());
100    }
101
102    @SmallTest
103    public void testStringUriIsHierarchical() {
104        assertTrue(Uri.parse("bob").isHierarchical());
105        assertFalse(Uri.parse("bob:").isHierarchical());
106    }
107
108    @SmallTest
109    public void testNullUriString() {
110        try {
111            Uri.parse(null);
112            fail();
113        } catch (NullPointerException e) {}
114    }
115
116    @SmallTest
117    public void testNullFile() {
118        try {
119            Uri.fromFile(null);
120            fail();
121        } catch (NullPointerException e) {}
122    }
123
124    @SmallTest
125    public void testCompareTo() {
126        Uri a = Uri.parse("foo:a");
127        Uri b = Uri.parse("foo:b");
128        Uri b2 = Uri.parse("foo:b");
129
130        assertTrue(a.compareTo(b) < 0);
131        assertTrue(b.compareTo(a) > 0);
132        assertEquals(0, b.compareTo(b2));
133    }
134
135    @SmallTest
136    public void testEqualsAndHashCode() {
137
138        Uri a = Uri.parse("http://crazybob.org/test/?foo=bar#tee");
139
140        Uri b = new Uri.Builder()
141                .scheme("http")
142                .authority("crazybob.org")
143                .path("/test/")
144                .encodedQuery("foo=bar")
145                .fragment("tee")
146                .build();
147
148        // Try alternate builder methods.
149        Uri c = new Uri.Builder()
150                .scheme("http")
151                .encodedAuthority("crazybob.org")
152                .encodedPath("/test/")
153                .encodedQuery("foo=bar")
154                .encodedFragment("tee")
155                .build();
156
157        assertFalse(Uri.EMPTY.equals(null));
158
159        assertEquals(a, b);
160        assertEquals(b, c);
161        assertEquals(c, a);
162
163        assertEquals(a.hashCode(), b.hashCode());
164        assertEquals(b.hashCode(), c.hashCode());
165    }
166
167    @SmallTest
168    public void testAuthorityParsing() {
169        Uri uri = Uri.parse("http://localhost:42");
170        assertEquals("localhost", uri.getHost());
171        assertEquals(42, uri.getPort());
172
173        uri = Uri.parse("http://bob@localhost:42");
174        assertEquals("bob", uri.getUserInfo());
175        assertEquals("localhost", uri.getHost());
176        assertEquals(42, uri.getPort());
177
178        uri = Uri.parse("http://bob%20lee@localhost:42");
179        assertEquals("bob lee", uri.getUserInfo());
180        assertEquals("bob%20lee", uri.getEncodedUserInfo());
181
182        uri = Uri.parse("http://bob%40lee%3ajr@local%68ost:4%32");
183        assertEquals("bob@lee:jr", uri.getUserInfo());
184        assertEquals("localhost", uri.getHost());
185        assertEquals(42, uri.getPort());
186
187        uri = Uri.parse("http://localhost");
188        assertEquals("localhost", uri.getHost());
189        assertEquals(-1, uri.getPort());
190    }
191
192    @SmallTest
193    public void testBuildUponOpaqueUri() {
194        Uri a = Uri.fromParts("foo", "bar", "tee");
195        Uri b = a.buildUpon().fragment("new").build();
196        assertEquals("new", b.getFragment());
197        assertEquals("bar", b.getSchemeSpecificPart());
198        assertEquals("foo", b.getScheme());
199    }
200
201    @SmallTest
202    public void testBuildUponEncodedOpaqueUri() {
203        Uri a = new Uri.Builder()
204                .scheme("foo")
205                .encodedOpaquePart("bar")
206                .fragment("tee")
207                .build();
208        Uri b = a.buildUpon().fragment("new").build();
209        assertEquals("new", b.getFragment());
210        assertEquals("bar", b.getSchemeSpecificPart());
211        assertEquals("foo", b.getScheme());
212    }
213
214    @SmallTest
215    public void testPathSegmentDecoding() {
216        Uri uri = Uri.parse("foo://bar/a%20a/b%20b");
217        assertEquals("a a", uri.getPathSegments().get(0));
218        assertEquals("b b", uri.getPathSegments().get(1));
219    }
220
221    @SmallTest
222    public void testSms() {
223        Uri base = Uri.parse("content://sms");
224        Uri appended = base.buildUpon()
225                .appendEncodedPath("conversations/addr=555-1212")
226                .build();
227        assertEquals("content://sms/conversations/addr=555-1212",
228                appended.toString());
229        assertEquals(2, appended.getPathSegments().size());
230        assertEquals("conversations", appended.getPathSegments().get(0));
231        assertEquals("addr=555-1212", appended.getPathSegments().get(1));
232    }
233
234    @SmallTest
235    public void testEncodeWithAllowedChars() {
236        String encoded = Uri.encode("Bob:/", "/");
237        assertEquals(-1, encoded.indexOf(':'));
238        assertTrue(encoded.indexOf('/') > -1);
239    }
240
241    @SmallTest
242    public void testEncodeDecode() {
243        code(null);
244        code("");
245        code("Bob");
246        code(":Bob");
247        code("::Bob");
248        code("Bob::Lee");
249        code("Bob:Lee");
250        code("Bob::");
251        code("Bob:");
252        code("::Bob::");
253    }
254
255    private void code(String s) {
256        assertEquals(s, Uri.decode(Uri.encode(s, null)));
257    }
258
259    @SmallTest
260    public void testFile() {
261        File f = new File("/tmp/bob");
262
263        Uri uri = Uri.fromFile(f);
264
265        assertEquals("file:///tmp/bob", uri.toString());
266    }
267
268    @SmallTest
269    public void testQueryParameters() {
270        Uri uri = Uri.parse("content://user");
271
272        assertEquals(null, uri.getQueryParameter("a"));
273
274        uri = uri.buildUpon().appendQueryParameter("a", "b").build();
275
276        assertEquals("b", uri.getQueryParameter("a"));
277
278        uri = uri.buildUpon().appendQueryParameter("a", "b2").build();
279
280        assertEquals(Arrays.asList("b", "b2"), uri.getQueryParameters("a"));
281
282        uri = uri.buildUpon().appendQueryParameter("c", "d").build();
283
284        assertEquals(Arrays.asList("b", "b2"), uri.getQueryParameters("a"));
285        assertEquals("d", uri.getQueryParameter("c"));
286    }
287
288    @SmallTest
289    public void testSchemeOnly() {
290        Uri uri = Uri.parse("empty:");
291        assertEquals("empty", uri.getScheme());
292        assertTrue(uri.isAbsolute());
293        assertNull(uri.getPath());
294    }
295
296    @SmallTest
297    public void testEmptyPath() {
298        Uri uri = Uri.parse("content://user");
299        assertEquals(0, uri.getPathSegments().size());
300    }
301
302    @SmallTest
303    public void testPathOperations() {
304        Uri uri = Uri.parse("content://user/a/b");
305
306        assertEquals(2, uri.getPathSegments().size());
307        assertEquals("b", uri.getLastPathSegment());
308
309        Uri first = uri;
310        uri = uri.buildUpon().appendPath("c").build();
311
312        assertEquals(3, uri.getPathSegments().size());
313        assertEquals("c", uri.getLastPathSegment());
314        assertEquals("content://user/a/b/c", uri.toString());
315
316        uri = ContentUris.withAppendedId(uri, 100);
317
318        assertEquals(4, uri.getPathSegments().size());
319        assertEquals("100", uri.getLastPathSegment());
320        assertEquals(100, ContentUris.parseId(uri));
321        assertEquals("content://user/a/b/c/100", uri.toString());
322
323        // Make sure the original URI is still intact.
324        assertEquals(2, first.getPathSegments().size());
325        assertEquals("b", first.getLastPathSegment());
326
327        try {
328            first.getPathSegments().get(2);
329            fail();
330        } catch (IndexOutOfBoundsException e) {}
331
332        assertEquals(null, Uri.EMPTY.getLastPathSegment());
333
334        Uri withC = Uri.parse("foo:/a/b/").buildUpon().appendPath("c").build();
335        assertEquals("/a/b/c", withC.getPath());
336    }
337
338    @SmallTest
339    public void testOpaqueUri() {
340        Uri uri = Uri.parse("mailto:nobody");
341        testOpaqueUri(uri);
342
343        uri = uri.buildUpon().build();
344        testOpaqueUri(uri);
345
346        uri = Uri.fromParts("mailto", "nobody", null);
347        testOpaqueUri(uri);
348
349        uri = uri.buildUpon().build();
350        testOpaqueUri(uri);
351
352        uri = new Uri.Builder()
353                .scheme("mailto")
354                .opaquePart("nobody")
355                .build();
356        testOpaqueUri(uri);
357
358        uri = uri.buildUpon().build();
359        testOpaqueUri(uri);
360    }
361
362    private void testOpaqueUri(Uri uri) {
363        assertEquals("mailto", uri.getScheme());
364        assertEquals("nobody", uri.getSchemeSpecificPart());
365        assertEquals("nobody", uri.getEncodedSchemeSpecificPart());
366
367        assertNull(uri.getFragment());
368        assertTrue(uri.isAbsolute());
369        assertTrue(uri.isOpaque());
370        assertFalse(uri.isRelative());
371        assertFalse(uri.isHierarchical());
372
373        assertNull(uri.getAuthority());
374        assertNull(uri.getEncodedAuthority());
375        assertNull(uri.getPath());
376        assertNull(uri.getEncodedPath());
377        assertNull(uri.getUserInfo());
378        assertNull(uri.getEncodedUserInfo());
379        assertNull(uri.getQuery());
380        assertNull(uri.getEncodedQuery());
381        assertNull(uri.getHost());
382        assertEquals(-1, uri.getPort());
383
384        assertTrue(uri.getPathSegments().isEmpty());
385        assertNull(uri.getLastPathSegment());
386
387        assertEquals("mailto:nobody", uri.toString());
388
389        Uri withFragment = uri.buildUpon().fragment("top").build();
390        assertEquals("mailto:nobody#top", withFragment.toString());
391    }
392
393    @SmallTest
394    public void testHierarchicalUris() {
395        testHierarchical("http", "google.com", "/p1/p2", "query", "fragment");
396        testHierarchical("file", null, "/p1/p2", null, null);
397        testHierarchical("content", "contact", "/p1/p2", null, null);
398        testHierarchical("http", "google.com", "/p1/p2", null, "fragment");
399        testHierarchical("http", "google.com", "", null, "fragment");
400        testHierarchical("http", "google.com", "", "query", "fragment");
401        testHierarchical("http", "google.com", "", "query", null);
402        testHierarchical("http", null, "/", "query", null);
403    }
404
405    private static void testHierarchical(String scheme, String authority,
406            String path, String query, String fragment) {
407        StringBuilder sb = new StringBuilder();
408
409        if (authority != null) {
410            sb.append("//").append(authority);
411        }
412        if (path != null) {
413            sb.append(path);
414        }
415        if (query != null) {
416            sb.append('?').append(query);
417        }
418
419        String ssp = sb.toString();
420
421        if (scheme != null) {
422            sb.insert(0, scheme + ":");
423        }
424        if (fragment != null) {
425            sb.append('#').append(fragment);
426        }
427
428        String uriString = sb.toString();
429
430        Uri uri = Uri.parse(uriString);
431
432        // Run these twice to test caching.
433        compareHierarchical(
434                uriString, ssp, uri, scheme, authority, path, query, fragment);
435        compareHierarchical(
436                uriString, ssp, uri, scheme, authority, path, query, fragment);
437
438        // Test rebuilt version.
439        uri = uri.buildUpon().build();
440
441        // Run these twice to test caching.
442        compareHierarchical(
443                uriString, ssp, uri, scheme, authority, path, query, fragment);
444        compareHierarchical(
445                uriString, ssp, uri, scheme, authority, path, query, fragment);
446
447        // The decoded and encoded versions of the inputs are all the same.
448        // We'll test the actual encoding decoding separately.
449
450        // Test building with encoded versions.
451        Uri built = new Uri.Builder()
452                .scheme(scheme)
453                .encodedAuthority(authority)
454                .encodedPath(path)
455                .encodedQuery(query)
456                .encodedFragment(fragment)
457                .build();
458
459        compareHierarchical(
460                uriString, ssp, built, scheme, authority, path, query, fragment);
461        compareHierarchical(
462                uriString, ssp, built, scheme, authority, path, query, fragment);
463
464        // Test building with decoded versions.
465        built = new Uri.Builder()
466                .scheme(scheme)
467                .authority(authority)
468                .path(path)
469                .query(query)
470                .fragment(fragment)
471                .build();
472
473        compareHierarchical(
474                uriString, ssp, built, scheme, authority, path, query, fragment);
475        compareHierarchical(
476                uriString, ssp, built, scheme, authority, path, query, fragment);
477
478        // Rebuild.
479        built = built.buildUpon().build();
480
481        compareHierarchical(
482                uriString, ssp, built, scheme, authority, path, query, fragment);
483        compareHierarchical(
484                uriString, ssp, built, scheme, authority, path, query, fragment);
485    }
486
487    private static void compareHierarchical(String uriString, String ssp,
488            Uri uri,
489            String scheme, String authority, String path, String query,
490            String fragment) {
491        assertEquals(scheme, uri.getScheme());
492        assertEquals(authority, uri.getAuthority());
493        assertEquals(authority, uri.getEncodedAuthority());
494        assertEquals(path, uri.getPath());
495        assertEquals(path, uri.getEncodedPath());
496        assertEquals(query, uri.getQuery());
497        assertEquals(query, uri.getEncodedQuery());
498        assertEquals(fragment, uri.getFragment());
499        assertEquals(fragment, uri.getEncodedFragment());
500        assertEquals(ssp, uri.getSchemeSpecificPart());
501
502        if (scheme != null) {
503            assertTrue(uri.isAbsolute());
504            assertFalse(uri.isRelative());
505        } else {
506            assertFalse(uri.isAbsolute());
507            assertTrue(uri.isRelative());
508        }
509
510        assertFalse(uri.isOpaque());
511        assertTrue(uri.isHierarchical());
512
513        assertEquals(uriString, uri.toString());
514    }
515
516    public void testEmptyToStringNotNull() {
517        assertNotNull(Uri.EMPTY.toString());
518    }
519
520    @SmallTest
521    public void testParcellingWithoutFragment() {
522        parcelAndUnparcel(Uri.parse("foo:bob%20lee"));
523        parcelAndUnparcel(Uri.fromParts("foo", "bob lee", "fragment"));
524        parcelAndUnparcel(new Uri.Builder()
525            .scheme("http")
526            .authority("crazybob.org")
527            .path("/rss/")
528            .encodedQuery("a=b")
529            .build());
530    }
531
532    public void testGetQueryParameter() {
533        String nestedUrl = "http://crazybob.org/?a=1&b=2";
534        Uri uri = Uri.parse("http://test/").buildUpon()
535                .appendQueryParameter("foo", "bar")
536                .appendQueryParameter("nested", nestedUrl).build();
537        assertEquals(nestedUrl, uri.getQueryParameter("nested"));
538        assertEquals(nestedUrl, uri.getQueryParameters("nested").get(0));
539    }
540
541    public void testGetQueryParameterWorkaround() {
542        // This was a workaround for a bug where getQueryParameter called
543        // getQuery() instead of getEncodedQuery().
544        String nestedUrl = "http://crazybob.org/?a=1&b=2";
545        Uri uri = Uri.parse("http://test/").buildUpon()
546                .appendQueryParameter("foo", "bar")
547                .appendQueryParameter("nested", Uri.encode(nestedUrl)).build();
548        assertEquals(nestedUrl, Uri.decode(uri.getQueryParameter("nested")));
549        assertEquals(nestedUrl,
550                Uri.decode(uri.getQueryParameters("nested").get(0)));
551    }
552
553    public void testGetQueryParameterEdgeCases() {
554        Uri uri;
555
556        // key at beginning of URL
557        uri = Uri.parse("http://test/").buildUpon()
558            .appendQueryParameter("key", "a b")
559            .appendQueryParameter("keya", "c d")
560            .appendQueryParameter("bkey", "e f")
561            .build();
562        assertEquals("a b", uri.getQueryParameter("key"));
563
564        // key in middle of URL
565        uri = Uri.parse("http://test/").buildUpon()
566            .appendQueryParameter("akeyb", "a b")
567            .appendQueryParameter("keya", "c d")
568            .appendQueryParameter("key", "e f")
569            .appendQueryParameter("bkey", "g h")
570            .build();
571        assertEquals("e f", uri.getQueryParameter("key"));
572
573        // key at end of URL
574        uri = Uri.parse("http://test/").buildUpon()
575            .appendQueryParameter("akeyb", "a b")
576            .appendQueryParameter("keya", "c d")
577            .appendQueryParameter("key", "y z")
578            .build();
579        assertEquals("y z", uri.getQueryParameter("key"));
580
581        // key is a substring of parameters, but not present
582        uri = Uri.parse("http://test/").buildUpon()
583            .appendQueryParameter("akeyb", "a b")
584            .appendQueryParameter("keya", "c d")
585            .appendQueryParameter("bkey", "e f")
586            .build();
587        assertNull(uri.getQueryParameter("key"));
588
589        // key is a prefix or suffix of the query
590        uri = Uri.parse("http://test/?qq=foo");
591        assertNull(uri.getQueryParameter("q"));
592        assertNull(uri.getQueryParameter("oo"));
593
594        // escaped keys
595        uri = Uri.parse("http://www.google.com/?a%20b=foo&c%20d=");
596        assertEquals("foo", uri.getQueryParameter("a b"));
597        assertEquals("", uri.getQueryParameter("c d"));
598        assertNull(uri.getQueryParameter("e f"));
599        assertNull(uri.getQueryParameter("b"));
600        assertNull(uri.getQueryParameter("c"));
601        assertNull(uri.getQueryParameter(" d"));
602
603        // empty values
604        uri = Uri.parse("http://www.google.com/?a=&b=&&c=");
605        assertEquals("", uri.getQueryParameter("a"));
606        assertEquals("", uri.getQueryParameter("b"));
607        assertEquals("", uri.getQueryParameter("c"));
608    }
609
610    public void testGetQueryParameterEmptyKey() {
611        Uri uri = Uri.parse("http://www.google.com/?=b");
612        assertEquals("b", uri.getQueryParameter(""));
613    }
614
615    public void testGetQueryParameterEmptyKey2() {
616      Uri uri = Uri.parse("http://www.google.com/?a=b&&c=d");
617      assertEquals("", uri.getQueryParameter(""));
618    }
619
620    public void testGetQueryParameterEmptyKey3() {
621      Uri uri = Uri.parse("http://www.google.com?");
622      assertEquals("", uri.getQueryParameter(""));
623    }
624
625    public void testGetQueryParameterEmptyKey4() {
626      Uri uri = Uri.parse("http://www.google.com?a=b&");
627      assertEquals("", uri.getQueryParameter(""));
628    }
629
630    public void testGetQueryParametersEmptyKey() {
631        Uri uri = Uri.parse("http://www.google.com/?=b&");
632        List<String> values = uri.getQueryParameters("");
633        assertEquals(2, values.size());
634        assertEquals("b", values.get(0));
635        assertEquals("", values.get(1));
636    }
637
638    public void testGetQueryParametersEmptyKey2() {
639        Uri uri = Uri.parse("http://www.google.com?");
640        List<String> values = uri.getQueryParameters("");
641        assertEquals(1, values.size());
642        assertEquals("", values.get(0));
643    }
644
645    public void testGetQueryParametersEmptyKey3() {
646      Uri uri = Uri.parse("http://www.google.com/?a=b&&c=d");
647      List<String> values = uri.getQueryParameters("");
648      assertEquals(1, values.size());
649      assertEquals("", values.get(0));
650    }
651
652    public void testGetQueryParameterNames() {
653        Uri uri = Uri.parse("http://test?a=1");
654        Set<String> names = uri.getQueryParameterNames();
655        assertEquals(1, names.size());
656        assertEquals("a", names.iterator().next());
657    }
658
659    public void testGetQueryParameterNamesEmptyKey() {
660        Uri uri = Uri.parse("http://www.google.com/?a=x&&c=z");
661        Set<String> names = uri.getQueryParameterNames();
662        Iterator<String> iter = names.iterator();
663        assertEquals(3, names.size());
664        assertEquals("a", iter.next());
665        assertEquals("", iter.next());
666        assertEquals("c", iter.next());
667    }
668
669    public void testGetQueryParameterNamesEmptyKey2() {
670        Uri uri = Uri.parse("http://www.google.com/?a=x&=d&c=z");
671        Set<String> names = uri.getQueryParameterNames();
672        Iterator<String> iter = names.iterator();
673        assertEquals(3, names.size());
674        assertEquals("a", iter.next());
675        assertEquals("", iter.next());
676        assertEquals("c", iter.next());
677    }
678
679    public void testGetQueryParameterNamesEmptyValues() {
680        Uri uri = Uri.parse("http://www.google.com/?a=foo&b=&c=");
681        Set<String> names = uri.getQueryParameterNames();
682        Iterator<String> iter = names.iterator();
683        assertEquals(3, names.size());
684        assertEquals("a", iter.next());
685        assertEquals("b", iter.next());
686        assertEquals("c", iter.next());
687    }
688
689    public void testGetQueryParameterNamesEdgeCases() {
690        Uri uri = Uri.parse("http://foo?a=bar&b=bar&c=&&d=baz&e&f&g=buzz&&&a&b=bar&h");
691        Set<String> names = uri.getQueryParameterNames();
692        Iterator<String> iter = names.iterator();
693        assertEquals(9, names.size());
694        assertEquals("a", iter.next());
695        assertEquals("b", iter.next());
696        assertEquals("c", iter.next());
697        assertEquals("", iter.next());
698        assertEquals("d", iter.next());
699        assertEquals("e", iter.next());
700        assertEquals("f", iter.next());
701        assertEquals("g", iter.next());
702        assertEquals("h", iter.next());
703    }
704
705    public void testGetQueryParameterNamesEscapedKeys() {
706        Uri uri = Uri.parse("http://www.google.com/?a%20b=foo&c%20d=");
707        Set<String> names = uri.getQueryParameterNames();
708        assertEquals(2, names.size());
709        Iterator<String> iter = names.iterator();
710        assertEquals("a b", iter.next());
711        assertEquals("c d", iter.next());
712    }
713
714    public void testGetQueryParameterEscapedKeys() {
715        Uri uri = Uri.parse("http://www.google.com/?a%20b=foo&c%20d=");
716        String value = uri.getQueryParameter("a b");
717        assertEquals("foo", value);
718    }
719
720    public void testClearQueryParameters() {
721        Uri uri = Uri.parse("http://www.google.com/?a=x&b=y&c=z").buildUpon()
722            .clearQuery().appendQueryParameter("foo", "bar").build();
723        Set<String> names = uri.getQueryParameterNames();
724        assertEquals(1, names.size());
725        assertEquals("foo", names.iterator().next());
726    }
727}
728