• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2008 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 
17 package android.content.cts;
18 
19 import org.xmlpull.v1.XmlPullParser;
20 import org.xmlpull.v1.XmlPullParserException;
21 
22 import android.content.ComponentName;
23 import android.content.ContentResolver;
24 import android.content.Context;
25 import android.content.Intent;
26 import android.content.cts.util.XmlUtils;
27 import android.content.pm.ActivityInfo;
28 import android.content.pm.PackageManager;
29 import android.content.pm.PackageManager.NameNotFoundException;
30 import android.content.res.XmlResourceParser;
31 import android.net.Uri;
32 import android.os.Bundle;
33 import android.os.IBinder;
34 import android.os.Parcel;
35 import android.os.ServiceManager;
36 import android.provider.Contacts.People;
37 import android.test.AndroidTestCase;
38 import android.util.AttributeSet;
39 import android.util.Xml;
40 
41 import java.io.IOException;
42 import java.io.Serializable;
43 import java.net.URISyntaxException;
44 import java.util.ArrayList;
45 import java.util.Objects;
46 import java.util.Set;
47 
48 public class IntentTest extends AndroidTestCase {
49 
50     private Intent mIntent;
51     private static final String TEST_ACTION = "android.content.IntentTest_test";
52     private static final Uri TEST_URI = People.CONTENT_URI;
53     private static final Uri ANOTHER_TEST_URI = People.CONTENT_FILTER_URI;
54     private static final String TEST_EXTRA_NAME = "testExtraName";
55     private Context mContext;
56     private PackageManager mPm;
57     private ComponentName mComponentName;
58     private ComponentName mAnotherComponentName;
59     private static final String TEST_TYPE = "testType";
60     private static final String ANOTHER_TEST_TYPE = "anotherTestType";
61     private static final String TEST_CATEGORY = "testCategory";
62     private static final String ANOTHER_TEST_CATEGORY = "testAnotherCategory";
63     private static final String TEST_PACKAGE = "android.content.cts";
64     private static final String ANOTHER_TEST_PACKAGE = "android.database.cts";
65 
66     @Override
setUp()67     protected void setUp() throws Exception {
68         super.setUp();
69         mIntent = new Intent();
70         mContext = getContext();
71         mPm = mContext.getPackageManager();
72         mComponentName = new ComponentName(mContext, MockActivity.class);
73         mAnotherComponentName = new ComponentName(mContext, "tmp");
74     }
75 
testConstructor()76     public void testConstructor() {
77         mIntent = new Intent();
78         assertNotNull(mIntent);
79 
80         Intent intent = new Intent();
81         intent.setAction(TEST_ACTION);
82 
83         mIntent = new Intent(intent);
84         assertNotNull(mIntent);
85         assertEquals(TEST_ACTION, mIntent.getAction());
86 
87         mIntent = new Intent(TEST_ACTION);
88         assertNotNull(mIntent);
89         assertEquals(TEST_ACTION, mIntent.getAction());
90 
91         mIntent = new Intent(TEST_ACTION, TEST_URI);
92         assertNotNull(mIntent);
93         assertEquals(TEST_ACTION, mIntent.getAction());
94         assertEquals(TEST_URI, mIntent.getData());
95 
96         mIntent = new Intent(mContext, MockActivity.class);
97         assertNotNull(mIntent);
98         assertEquals(mComponentName, mIntent.getComponent());
99 
100         mIntent = new Intent(TEST_ACTION, TEST_URI, mContext, MockActivity.class);
101         assertNotNull(mIntent);
102         assertEquals(TEST_ACTION, mIntent.getAction());
103         assertEquals(TEST_URI, mIntent.getData());
104         assertEquals(mComponentName, mIntent.getComponent());
105     }
106 
testRemoveExtra()107     public void testRemoveExtra() {
108         mIntent = new Intent();
109         mIntent.putExtra(TEST_EXTRA_NAME, "testvalue");
110         assertNotNull(mIntent.getStringExtra(TEST_EXTRA_NAME));
111         mIntent.removeExtra(TEST_EXTRA_NAME);
112         assertNull(mIntent.getStringExtra(TEST_EXTRA_NAME));
113     }
114 
testGetCharSequenceExtra()115     public void testGetCharSequenceExtra() {
116         final CharSequence expected = "CharSequencetest";
117         mIntent.putExtra(TEST_EXTRA_NAME, expected);
118         assertEquals(expected, mIntent.getCharSequenceExtra(TEST_EXTRA_NAME));
119     }
120 
testReadFromParcel()121     public void testReadFromParcel() {
122         mIntent.setAction(TEST_ACTION);
123         mIntent.setData(TEST_URI);
124         mIntent.setType(TEST_TYPE);
125         mIntent.setFlags(0);
126         mIntent.setComponent(mComponentName);
127         mIntent.addCategory(TEST_CATEGORY);
128         final Parcel parcel = Parcel.obtain();
129         mIntent.writeToParcel(parcel, 0);
130         parcel.setDataPosition(0);
131         final Intent target = new Intent();
132         target.readFromParcel(parcel);
133         assertEquals(mIntent.getAction(), target.getAction());
134         assertEquals(mIntent.getData(), target.getData());
135         assertEquals(mIntent.getFlags(), target.getFlags());
136         assertEquals(mIntent.getComponent(), target.getComponent());
137         assertEquals(mIntent.getCategories(), target.getCategories());
138         assertEquals(mIntent.toURI(), target.toURI());
139     }
140 
testGetParcelableArrayListExtra()141     public void testGetParcelableArrayListExtra() {
142         final ArrayList<Intent> expected = new ArrayList<Intent>();
143         Intent intent = new Intent(TEST_ACTION);
144         expected.add(intent);
145 
146         mIntent.putParcelableArrayListExtra(TEST_EXTRA_NAME, expected);
147         final ArrayList<Intent> target = mIntent.getParcelableArrayListExtra(TEST_EXTRA_NAME);
148         assertEquals(expected.size(), target.size());
149         assertEquals(expected, target);
150     }
151 
testFilterHashCode()152     public void testFilterHashCode() {
153         mIntent.filterHashCode();
154     }
155 
testGetCategories()156     public void testGetCategories() {
157         mIntent.addCategory(TEST_CATEGORY);
158         final Set<String> target = mIntent.getCategories();
159         assertEquals(TEST_CATEGORY, target.toArray()[0]);
160     }
161 
testGetScheme()162     public void testGetScheme() {
163         assertNull(mIntent.getScheme());
164         mIntent.setData(TEST_URI);
165         assertEquals(TEST_URI.getScheme(), mIntent.getScheme());
166     }
167 
testGetIntegerArrayListExtra()168     public void testGetIntegerArrayListExtra() {
169         final ArrayList<Integer> expected = new ArrayList<Integer>();
170         expected.add(0);
171         mIntent.putIntegerArrayListExtra(TEST_EXTRA_NAME, expected);
172         assertEquals(expected, mIntent.getIntegerArrayListExtra(TEST_EXTRA_NAME));
173     }
174 
testHasExtra()175     public void testHasExtra() {
176         mIntent = new Intent();
177         assertFalse(mIntent.hasExtra(TEST_EXTRA_NAME));
178         mIntent.putExtra(TEST_EXTRA_NAME, "test");
179         assertTrue(mIntent.hasExtra(TEST_EXTRA_NAME));
180     }
181 
testGetIntArrayExtra()182     public void testGetIntArrayExtra() {
183         final int[] expected = { 1, 2, 3 };
184         assertNull(mIntent.getIntArrayExtra(TEST_EXTRA_NAME));
185         mIntent.putExtra(TEST_EXTRA_NAME, expected);
186         assertEquals(expected, mIntent.getIntArrayExtra(TEST_EXTRA_NAME));
187     }
188 
testSetClassName1()189     public void testSetClassName1() {
190         final Intent intent = mIntent.setClassName(mContext, MockActivity.class.getName());
191         assertEquals(mComponentName, mIntent.getComponent());
192         assertSame(mIntent, intent);
193     }
194 
testSetClassName2()195     public void testSetClassName2() {
196         mIntent.setClassName(mContext.getPackageName(), MockActivity.class.getName());
197         assertEquals(mComponentName, mIntent.getComponent());
198     }
199 
testGetIntExtra()200     public void testGetIntExtra() {
201         final int expected = 0;
202         mIntent = new Intent();
203         assertEquals(expected, mIntent.getIntExtra(TEST_EXTRA_NAME, expected));
204         mIntent.putExtra(TEST_EXTRA_NAME, 100);
205         assertEquals(100, mIntent.getIntExtra(TEST_EXTRA_NAME, 1));
206 
207     }
208 
testPutIntegerArrayListExtra()209     public void testPutIntegerArrayListExtra() {
210         final ArrayList<Integer> expected = new ArrayList<Integer>();
211         expected.add(0);
212         mIntent = new Intent();
213         mIntent.putIntegerArrayListExtra(TEST_EXTRA_NAME, expected);
214         assertEquals(expected, mIntent.getIntegerArrayListExtra(TEST_EXTRA_NAME));
215     }
216 
testAccessType()217     public void testAccessType() {
218         mIntent.setType(TEST_TYPE);
219         assertEquals(TEST_TYPE, mIntent.getType());
220     }
221 
testGetBundleExtra()222     public void testGetBundleExtra() {
223         final Bundle expected = new Bundle();
224         expected.putBoolean("testTrue", true);
225         mIntent.putExtras(expected);
226         mIntent.putExtra(TEST_EXTRA_NAME, expected);
227 
228         assertEquals(expected, mIntent.getBundleExtra(TEST_EXTRA_NAME));
229     }
230 
testGetCharArrayExtra()231     public void testGetCharArrayExtra() {
232         final char[] expected = { 'a', 'b', 'c' };
233         mIntent.putExtra(TEST_EXTRA_NAME, expected);
234         final char[] actual= mIntent.getCharArrayExtra(TEST_EXTRA_NAME);
235         assertEquals(expected.length, actual.length);
236         assertEquals(expected[0], actual[0]);
237         assertEquals(expected[1], actual[1]);
238         assertEquals(expected[2], actual[2]);
239     }
240 
testGetDoubleArrayExtra()241     public void testGetDoubleArrayExtra() {
242         final double[] expected = { 1d, 2d };
243         mIntent.putExtra(TEST_EXTRA_NAME, expected);
244         assertEquals(expected, mIntent.getDoubleArrayExtra(TEST_EXTRA_NAME));
245     }
246 
testPutStringArrayListExtra()247     public void testPutStringArrayListExtra() {
248         final ArrayList<String> expected = new ArrayList<String>();
249         expected.add("testString");
250         mIntent.putStringArrayListExtra(TEST_EXTRA_NAME, expected);
251         assertEquals(expected, mIntent.getStringArrayListExtra(TEST_EXTRA_NAME));
252     }
253 
testResolveType1()254     public void testResolveType1() {
255         final ContentResolver contentResolver = mContext.getContentResolver();
256         assertNull(mIntent.resolveType(mContext));
257         mIntent.setType(TEST_TYPE);
258         assertEquals(TEST_TYPE, mIntent.resolveType(mContext));
259         mIntent.setType(null);
260         mIntent.setData(TEST_URI);
261         assertEquals(contentResolver.getType(TEST_URI), mIntent.resolveType(mContext));
262         mIntent.setData(Uri.parse("test"));
263         assertNull(mIntent.resolveType(mContext));
264     }
265 
testResolveType2()266     public void testResolveType2() {
267         final ContentResolver contentResolver = mContext.getContentResolver();
268         assertNull(mIntent.resolveType(contentResolver));
269         mIntent.setType(TEST_TYPE);
270         assertEquals(TEST_TYPE, mIntent.resolveType(contentResolver));
271         mIntent.setType(null);
272         mIntent.setData(TEST_URI);
273         assertEquals(contentResolver.getType(TEST_URI), mIntent.resolveType(contentResolver));
274         mIntent.setData(Uri.parse("test"));
275         assertNull(mIntent.resolveType(contentResolver));
276     }
277 
testAccessComponent()278     public void testAccessComponent() {
279         mIntent.setComponent(mComponentName);
280         assertEquals(mComponentName, mIntent.getComponent());
281     }
282 
testGetDataString()283     public void testGetDataString() {
284         assertNull(mIntent.getDataString());
285         mIntent.setData(TEST_URI);
286         assertEquals(TEST_URI.toString(), mIntent.getDataString());
287     }
288 
testHasCategory()289     public void testHasCategory() {
290         assertFalse(mIntent.hasCategory(TEST_CATEGORY));
291         mIntent.addCategory(TEST_CATEGORY);
292         assertTrue(mIntent.hasCategory(TEST_CATEGORY));
293     }
294 
testGetLongArrayExtra()295     public void testGetLongArrayExtra() {
296         final long[] expected = { 1l, 2l, 3l };
297         mIntent.putExtra(TEST_EXTRA_NAME, expected);
298         assertEquals(expected, mIntent.getLongArrayExtra(TEST_EXTRA_NAME));
299     }
300 
testParseIntent()301     public void testParseIntent() throws XmlPullParserException, IOException,
302         NameNotFoundException {
303         mIntent = null;
304         XmlResourceParser parser = null;
305         AttributeSet attrs = null;
306         ActivityInfo ai = null;
307         try {
308             mIntent = Intent.parseIntent(mContext.getResources(), parser, attrs);
309             fail("should thow exception!");
310         } catch (NullPointerException e) {
311             // expected
312         }
313 
314         ai = mContext.getPackageManager().getActivityInfo(mComponentName,
315                 PackageManager.GET_META_DATA);
316         parser = ai.loadXmlMetaData(mContext.getPackageManager(), "android.app.alias");
317 
318         attrs = Xml.asAttributeSet(parser);
319         int type;
320         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
321                 && type != XmlPullParser.START_TAG) {
322         }
323 
324         String nodeName = parser.getName();
325         if (!"alias".equals(nodeName)) {
326             throw new RuntimeException();
327         }
328 
329         int outerDepth = parser.getDepth();
330         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
331                 && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
332             if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
333                 continue;
334             }
335 
336             nodeName = parser.getName();
337             if ("intent".equals(nodeName)) {
338                 mIntent = Intent.parseIntent(mContext.getResources(), parser, attrs);
339             } else {
340                 XmlUtils.skipCurrentTag(parser);
341             }
342         }
343 
344         assertNotNull(mIntent);
345         assertEquals("android.intent.action.MAIN", mIntent.getAction());
346         assertEquals(Uri.parse("http://www.google.com/"), mIntent.getData());
347     }
348 
testSetClass()349     public void testSetClass() {
350         assertNull(mIntent.getComponent());
351         mIntent.setClass(mContext, MockActivity.class);
352         assertEquals(mComponentName, mIntent.getComponent());
353     }
354 
testResolveTypeIfNeeded()355     public void testResolveTypeIfNeeded() {
356         ContentResolver contentResolver = mContext.getContentResolver();
357         assertNull(mIntent.resolveTypeIfNeeded(contentResolver));
358         mIntent.setType(TEST_TYPE);
359         assertEquals(TEST_TYPE, mIntent.resolveTypeIfNeeded(contentResolver));
360 
361         mIntent.setType(null);
362         mIntent.setComponent(mComponentName);
363         assertEquals(null, mIntent.resolveTypeIfNeeded(contentResolver));
364 
365         mIntent.setType(TEST_TYPE);
366         mIntent.setComponent(mComponentName);
367         assertEquals(TEST_TYPE, mIntent.resolveTypeIfNeeded(contentResolver));
368 
369         mIntent.setType(null);
370         mIntent.setData(TEST_URI);
371         assertNull(mIntent.resolveTypeIfNeeded(contentResolver));
372     }
373 
testPutExtra1()374     public void testPutExtra1() {
375         assertFalse(mIntent.getBooleanExtra(TEST_EXTRA_NAME, false));
376         mIntent.putExtra(TEST_EXTRA_NAME, true);
377         assertTrue(mIntent.getBooleanExtra(TEST_EXTRA_NAME, false));
378         mIntent.putExtra(TEST_EXTRA_NAME, false);
379         assertFalse(mIntent.getBooleanExtra(TEST_EXTRA_NAME, false));
380     }
381 
testPutExtra2()382     public void testPutExtra2() {
383         final byte expected = Byte.valueOf("1");
384         mIntent.putExtra(TEST_EXTRA_NAME, expected);
385         assertEquals(expected, mIntent.getByteExtra(TEST_EXTRA_NAME, Byte.valueOf("1")));
386     }
387 
testPutExtra3()388     public void testPutExtra3() {
389         assertEquals('a', mIntent.getCharExtra(TEST_EXTRA_NAME, 'a'));
390         final char expected = 'a';
391         mIntent.putExtra(TEST_EXTRA_NAME, expected);
392         assertEquals(expected, mIntent.getCharExtra(TEST_EXTRA_NAME, 'a'));
393     }
394 
testPutExtra4()395     public void testPutExtra4() {
396         final Short expected = Short.valueOf("2");
397         assertEquals(Short.valueOf("1").shortValue(), mIntent.getShortExtra(
398                 TEST_EXTRA_NAME, Short.valueOf("1")));
399         mIntent.putExtra(TEST_EXTRA_NAME, expected);
400         assertEquals(expected.shortValue(), mIntent.getShortExtra(TEST_EXTRA_NAME, Short.valueOf("1")));
401     }
402 
testPutExtra5()403     public void testPutExtra5() {
404         final int expected = 2;
405         assertEquals(1, mIntent.getIntExtra(TEST_EXTRA_NAME, 1));
406         mIntent.putExtra(TEST_EXTRA_NAME, expected);
407         assertEquals(expected, mIntent.getIntExtra(TEST_EXTRA_NAME, 1));
408     }
409 
testPutExtra6()410     public void testPutExtra6() {
411         final long expected = 2l;
412         assertEquals(1l, mIntent.getLongExtra(TEST_EXTRA_NAME, 1l));
413         mIntent.putExtra(TEST_EXTRA_NAME, expected);
414         assertEquals(expected, mIntent.getLongExtra(TEST_EXTRA_NAME, 1l));
415     }
416 
testPutExtra7()417     public void testPutExtra7() {
418         final float expected = 2f;
419         assertEquals(1f, mIntent.getFloatExtra(TEST_EXTRA_NAME, 1f));
420         mIntent.putExtra(TEST_EXTRA_NAME, expected);
421         assertEquals(expected, mIntent.getFloatExtra(TEST_EXTRA_NAME, 1f));
422     }
423 
testPutExtra8()424     public void testPutExtra8() {
425         final double expected = 2d;
426         assertEquals(1d, mIntent.getDoubleExtra(TEST_EXTRA_NAME, 1d));
427         mIntent.putExtra(TEST_EXTRA_NAME, expected);
428         assertEquals(expected, mIntent.getDoubleExtra(TEST_EXTRA_NAME, 1d));
429     }
430 
testPutExtra9()431     public void testPutExtra9() {
432         final String expected = "testString";
433         assertNull(mIntent.getStringExtra(TEST_EXTRA_NAME));
434         mIntent.putExtra(TEST_EXTRA_NAME, expected);
435         assertEquals(expected, mIntent.getStringExtra(TEST_EXTRA_NAME));
436     }
437 
testPutExtra10()438     public void testPutExtra10() {
439         final CharSequence expected = "testString";
440         assertNull(mIntent.getCharSequenceExtra(TEST_EXTRA_NAME));
441         mIntent.putExtra(TEST_EXTRA_NAME, expected);
442         assertEquals(expected, mIntent.getCharSequenceExtra(TEST_EXTRA_NAME));
443     }
444 
testPutExtra11()445     public void testPutExtra11() {
446         final Intent expected = new Intent(TEST_ACTION);
447         mIntent.putExtra(TEST_EXTRA_NAME, expected);
448         assertEquals(expected, mIntent.getParcelableExtra(TEST_EXTRA_NAME));
449     }
450 
testPutExtra12()451     public void testPutExtra12() {
452         final Intent[] expected = { new Intent(TEST_ACTION), new Intent(mContext, MockActivity.class) };
453         mIntent.putExtra(TEST_EXTRA_NAME, expected);
454         assertEquals(expected, mIntent.getParcelableArrayExtra(TEST_EXTRA_NAME));
455     }
456 
testPutExtra13()457     public void testPutExtra13() {
458         final TestSerializable expected = new TestSerializable();
459         expected.Name = "testName";
460         mIntent.putExtra(TEST_EXTRA_NAME, expected);
461         assertEquals(expected, mIntent.getSerializableExtra(TEST_EXTRA_NAME));
462         TestSerializable target = (TestSerializable) mIntent.getSerializableExtra(TEST_EXTRA_NAME);
463         assertEquals(expected.Name, target.Name);
464     }
465 
testPutExtra14()466     public void testPutExtra14() {
467         final boolean[] expected = { true, true, false };
468         mIntent.putExtra(TEST_EXTRA_NAME, expected);
469         assertEquals(expected, mIntent.getBooleanArrayExtra(TEST_EXTRA_NAME));
470     }
471 
testPutExtra15()472     public void testPutExtra15() {
473         final byte[] expected = TEST_ACTION.getBytes();
474         mIntent.putExtra(TEST_EXTRA_NAME, expected);
475         assertEquals(expected, mIntent.getByteArrayExtra(TEST_EXTRA_NAME));
476     }
477 
testPutExtra16()478     public void testPutExtra16() {
479         final short[] expected = { 1, 2, 3 };
480         mIntent.putExtra(TEST_EXTRA_NAME, expected);
481         assertEquals(expected, mIntent.getShortArrayExtra(TEST_EXTRA_NAME));
482     }
483 
testPutExtra17()484     public void testPutExtra17() {
485         final char[] expected = { '1', '2', '3' };
486         mIntent.putExtra(TEST_EXTRA_NAME, expected);
487         assertEquals(expected, mIntent.getCharArrayExtra(TEST_EXTRA_NAME));
488     }
489 
testPutExtra18()490     public void testPutExtra18() {
491         final int[] expected = { 1, 2, 3 };
492         mIntent.putExtra(TEST_EXTRA_NAME, expected);
493         assertEquals(expected, mIntent.getIntArrayExtra(TEST_EXTRA_NAME));
494     }
495 
testPutExtra19()496     public void testPutExtra19() {
497         final long[] expected = { 1l, 2l, 3l };
498         mIntent.putExtra(TEST_EXTRA_NAME, expected);
499         assertEquals(expected, mIntent.getLongArrayExtra(TEST_EXTRA_NAME));
500     }
501 
testPutExtra20()502     public void testPutExtra20() {
503         final float[] expected = { 1f, 2f, 3f };
504         mIntent.putExtra(TEST_EXTRA_NAME, expected);
505         assertEquals(expected, mIntent.getFloatArrayExtra(TEST_EXTRA_NAME));
506     }
507 
testPutExtra21()508     public void testPutExtra21() {
509         final double[] expected = { 1d, 2d, 3d };
510         mIntent.putExtra(TEST_EXTRA_NAME, expected);
511         assertEquals(expected, mIntent.getDoubleArrayExtra(TEST_EXTRA_NAME));
512     }
513 
testPutExtra22()514     public void testPutExtra22() {
515         final String[] expected = { "1d", "2d", "3d" };
516         mIntent.putExtra(TEST_EXTRA_NAME, expected);
517         assertEquals(expected, mIntent.getStringArrayExtra(TEST_EXTRA_NAME));
518     }
519 
testPutExtra23()520     public void testPutExtra23() {
521         final Bundle expected = new Bundle();
522         expected.putString("key", "value");
523         mIntent.putExtra(TEST_EXTRA_NAME, expected);
524         assertEquals(expected, mIntent.getBundleExtra(TEST_EXTRA_NAME));
525     }
526 
527     @SuppressWarnings("deprecation")
testPutExtra24()528     public void testPutExtra24() {
529         final IBinder expected = ServiceManager.getService("activity");
530         mIntent.putExtra(TEST_EXTRA_NAME, expected);
531         assertEquals(expected, mIntent.getIBinderExtra(TEST_EXTRA_NAME));
532     }
533 
testAddCategory()534     public void testAddCategory() {
535         assertFalse(mIntent.hasCategory(TEST_CATEGORY));
536         mIntent.addCategory(TEST_CATEGORY);
537         assertTrue(mIntent.hasCategory(TEST_CATEGORY));
538     }
539 
testPutParcelableArrayListExtra()540     public void testPutParcelableArrayListExtra() {
541         ArrayList<Intent> expected = new ArrayList<Intent>();
542         mIntent.putExtra(TEST_EXTRA_NAME, expected);
543         assertEquals(expected, mIntent.getParcelableArrayListExtra(TEST_EXTRA_NAME));
544     }
545 
testToString()546     public void testToString() {
547         assertNotNull(mIntent.toString());
548     }
549 
testAccessData()550     public void testAccessData() {
551         mIntent.setData(TEST_URI);
552         assertEquals(TEST_URI, mIntent.getData());
553     }
554 
testSetExtrasClassLoader()555     public void testSetExtrasClassLoader() {
556     }
557 
testGetStringArrayListExtra()558     public void testGetStringArrayListExtra() {
559         final ArrayList<String> expected = new ArrayList<String>();
560         expected.add("testString");
561         mIntent.putStringArrayListExtra(TEST_EXTRA_NAME, expected);
562         assertEquals(expected, mIntent.getStringArrayListExtra(TEST_EXTRA_NAME));
563     }
564 
testGetCharSequenceArrayListExtra()565     public void testGetCharSequenceArrayListExtra() {
566         final ArrayList<CharSequence> expected = new ArrayList<CharSequence>();
567         expected.add("testCharSequence");
568         mIntent.putCharSequenceArrayListExtra(TEST_EXTRA_NAME, expected);
569         assertEquals(expected, mIntent.getCharSequenceArrayListExtra(TEST_EXTRA_NAME));
570     }
571 
testResolveActivityInfo()572     public void testResolveActivityInfo() throws NameNotFoundException {
573         final PackageManager pm = mContext.getPackageManager();
574         assertEquals(null, mIntent.resolveActivityInfo(pm, 1));
575         mIntent.setComponent(mComponentName);
576         ActivityInfo target = null;
577 
578         target = pm.getActivityInfo(mComponentName, 1);
579         assertEquals(target.targetActivity, mIntent.resolveActivityInfo(pm, 1).targetActivity);
580     }
581 
testGetParcelableExtra()582     public void testGetParcelableExtra() {
583         final Intent expected = new Intent(TEST_ACTION);
584         mIntent.putExtra(TEST_EXTRA_NAME, expected);
585         assertEquals(expected, mIntent.getParcelableExtra(TEST_EXTRA_NAME));
586     }
587 
testAccessAction()588     public void testAccessAction() {
589         mIntent.setAction(TEST_ACTION);
590         assertEquals(TEST_ACTION, mIntent.getAction());
591     }
592 
testAddFlags()593     public void testAddFlags() {
594         final int flag = 1;
595         int expected = 0;
596         mIntent.addFlags(flag);
597         expected |= flag;
598         assertEquals(expected, mIntent.getFlags());
599     }
600 
testDescribeContents()601     public void testDescribeContents() {
602         final int expected = 0;
603         assertEquals(expected, mIntent.describeContents());
604         mIntent.putExtra(TEST_EXTRA_NAME, "test");
605         assertEquals(mIntent.getExtras().describeContents(), mIntent.describeContents());
606     }
607 
testGetShortExtra()608     public void testGetShortExtra() {
609 
610         final Short expected = Short.valueOf("2");
611         assertEquals(Short.valueOf("1").shortValue(), mIntent.getShortExtra(
612                 TEST_EXTRA_NAME, Short.valueOf("1")));
613         mIntent.putExtra(TEST_EXTRA_NAME, expected);
614         assertEquals(expected.shortValue(), mIntent.getShortExtra(TEST_EXTRA_NAME, Short.valueOf("1")));
615     }
616 
testClone()617     public void testClone() {
618         mIntent.setAction(TEST_ACTION);
619         mIntent.setClass(mContext, MockActivity.class);
620         mIntent.setComponent(mComponentName);
621         mIntent.setDataAndType(TEST_URI, TEST_TYPE);
622         mIntent.addCategory(TEST_CATEGORY);
623         final String key = "testkey";
624         final String excepted = "testValue";
625         mIntent.putExtra(key, excepted);
626         Intent actual = (Intent) mIntent.clone();
627         assertEquals(mComponentName, actual.getComponent());
628         assertEquals(TEST_ACTION, actual.getAction());
629         assertEquals(mComponentName, actual.getComponent());
630         assertEquals(TEST_URI, actual.getData());
631         assertEquals(TEST_TYPE, actual.getType());
632         assertEquals(TEST_CATEGORY, (String) (actual.getCategories().toArray()[0]));
633         assertEquals(excepted, actual.getStringExtra(key));
634     }
635 
testGetDoubleExtra()636     public void testGetDoubleExtra() {
637         final double expected = 2d;
638         assertEquals(1d, mIntent.getDoubleExtra(TEST_EXTRA_NAME, 1d));
639         mIntent.putExtra(TEST_EXTRA_NAME, expected);
640         assertEquals(expected, mIntent.getDoubleExtra(TEST_EXTRA_NAME, 1d));
641     }
642 
testCloneFilter()643     public void testCloneFilter() {
644         mIntent.setAction(TEST_ACTION);
645         mIntent.setClass(mContext, MockActivity.class);
646         mIntent.setComponent(mComponentName);
647         mIntent.setDataAndType(TEST_URI, TEST_TYPE);
648         mIntent.addCategory(TEST_CATEGORY);
649         final String key = "testkey";
650         mIntent.putExtra(key, "testValue");
651         Intent actual = mIntent.cloneFilter();
652         assertEquals(mComponentName, actual.getComponent());
653         assertEquals(TEST_ACTION, actual.getAction());
654         assertEquals(mComponentName, actual.getComponent());
655         assertEquals(TEST_URI, actual.getData());
656         assertEquals(TEST_TYPE, actual.getType());
657         assertEquals(TEST_CATEGORY, (String) (actual.getCategories().toArray()[0]));
658         assertNull(actual.getStringExtra(key));
659     }
660 
testGetIntentOld()661     public void testGetIntentOld() throws URISyntaxException {
662         String uri = "test";
663         mIntent = Intent.getIntentOld(uri);
664         assertEquals(Intent.ACTION_VIEW, mIntent.getAction());
665 
666         mIntent = null;
667         try {
668             uri = "test#action(test)categories(test)type(mtype)launchFlags(test)extras(test";
669             mIntent = Intent.getIntentOld(uri);
670             fail("should throw URISyntaxException.");
671         } catch (Exception e) {
672             // expected
673         }
674 
675         final String compnent =
676                 "component(" + mContext.getPackageName() + "!" + MockActivity.class.getName() + ")";
677         uri = "testdata#action(test)categories(test!test2)type(mtype)launchFlags(5)" + compnent
678                 + "extras(Stest=testString!btestbyte=1!"
679                 + "Btestboolean=true!ctestchar=a!dtestdouble=1d!"
680                 + "itestint=1!ltestlong=1!stestshort=1!ftestfloat=1f)";
681         mIntent = Intent.getIntentOld(uri);
682         assertEquals("test", mIntent.getAction());
683         assertEquals("testdata", mIntent.getData().toString());
684         assertEquals(mComponentName, mIntent.getComponent());
685         assertEquals("test", (String) (mIntent.getCategories().toArray()[0]));
686         assertEquals("mtype", mIntent.getType());
687         assertEquals(4, mIntent.getFlags());
688         assertEquals("testString", mIntent.getStringExtra("test"));
689         assertTrue(mIntent.getBooleanExtra("testboolean", false));
690         final byte b = 1;
691         final byte defaulttByte = 2;
692         assertEquals(b, mIntent.getByteExtra("testbyte", defaulttByte));
693         assertEquals('a', mIntent.getCharExtra("testchar", 'b'));
694         final float testFloat = 1f;
695         assertEquals(testFloat, mIntent.getFloatExtra("testfloat", 2f));
696         final double testDouble = 1d;
697         assertEquals(testDouble, mIntent.getDoubleExtra("testdouble", 2d));
698 
699         final long testLong = 1;
700         assertEquals(testLong, mIntent.getLongExtra("testlong", 2l));
701 
702         final short testShort = 1;
703         final short defaultShort = 2;
704         assertEquals(testShort, mIntent.getShortExtra("testshort", defaultShort));
705         assertEquals(1, mIntent.getIntExtra("testint", 2));
706     }
707 
testGetParcelableArrayExtra()708     public void testGetParcelableArrayExtra() {
709         final Intent[] expected = { new Intent(TEST_ACTION), new Intent(mContext, MockActivity.class) };
710         mIntent.putExtra(TEST_EXTRA_NAME, expected);
711         assertEquals(expected, mIntent.getParcelableArrayExtra(TEST_EXTRA_NAME));
712     }
713 
testResolveActivityEmpty()714     public void testResolveActivityEmpty() {
715         final Intent emptyIntent = new Intent();
716 
717         // Empty intent shouldn't resolve to anything
718         final ComponentName target = emptyIntent.resolveActivity(mPm);
719         assertNull(target);
720     }
721 
testResolveActivitySingleMatch()722     public void testResolveActivitySingleMatch() {
723         final Intent intent = new Intent("android.content.cts.action.TEST_ACTION");
724         intent.addCategory("android.content.cts.category.TEST_CATEGORY");
725 
726         // Should only have one activity responding to narrow category
727         final ComponentName target = intent.resolveActivity(mPm);
728         assertEquals("android.content.cts", target.getPackageName());
729         assertEquals("android.content.cts.MockActivity", target.getClassName());
730     }
731 
testResolveActivityShortcutMatch()732     public void testResolveActivityShortcutMatch() {
733         final Intent intent = new Intent("android.content.cts.action.TEST_ACTION");
734         intent.setComponent(
735                 new ComponentName("android.content.cts", "android.content.cts.MockActivity2"));
736 
737         // Multiple activities match, but we asked for explicit component
738         final ComponentName target = intent.resolveActivity(mPm);
739         assertEquals("android.content.cts", target.getPackageName());
740         assertEquals("android.content.cts.MockActivity2", target.getClassName());
741     }
742 
testResolveActivityMultipleMatch()743     public void testResolveActivityMultipleMatch() {
744         final Intent intent = new Intent("android.content.cts.action.TEST_ACTION");
745 
746         // Should have multiple activities, resulting in resolver dialog
747         final ComponentName target = intent.resolveActivity(mPm);
748         final String pkgName = target.getPackageName();
749         assertFalse("android.content.cts".equals(pkgName));
750 
751         // Whoever they are must be able to set preferred activities
752         if (!"android".equals(pkgName)) {
753             if (mPm.checkPermission(android.Manifest.permission.SET_PREFERRED_APPLICATIONS, pkgName)
754                     != PackageManager.PERMISSION_GRANTED) {
755                 fail("Resolved target " + target
756                         + " doesn't have SET_PREFERRED_APPLICATIONS permission");
757             }
758         }
759     }
760 
testGetCharExtra()761     public void testGetCharExtra() {
762         assertEquals('a', mIntent.getCharExtra(TEST_EXTRA_NAME, 'a'));
763         final char expected = 'b';
764         mIntent.putExtra(TEST_EXTRA_NAME, expected);
765         assertEquals(expected, mIntent.getCharExtra(TEST_EXTRA_NAME, 'a'));
766     }
767 
testGetIntent()768     public void testGetIntent() throws URISyntaxException {
769         mIntent = Intent.getIntent("test#");
770         assertEquals(Intent.ACTION_VIEW, mIntent.getAction());
771 
772         try {
773             String uri = "#Intent;action=android.content.IntentTest_test;"
774                     + "category=testCategory;type=testtype;launchFlags=0x1;"
775                     + "component=com.android/.app.MockActivity;K.testExtraName=1;end";
776             mIntent = Intent.getIntent(uri);
777             fail("should throw URISyntaxException.");
778         } catch (Exception e) {
779             // expected
780         }
781         mIntent = new Intent();
782 
783         String uri = mIntent.toURI();
784         Intent target = Intent.getIntent(uri);
785         assertEquals(Intent.ACTION_VIEW, target.getAction());
786 
787         mIntent.setAction(TEST_ACTION);
788         uri = mIntent.toURI();
789         target = Intent.getIntent(uri);
790         assertEquals(TEST_ACTION, target.getAction());
791 
792         mIntent.setData(TEST_URI);
793         uri = mIntent.toURI();
794         target = Intent.getIntent(uri);
795         assertEquals(TEST_URI, target.getData());
796 
797         mIntent.setComponent(mComponentName);
798         uri = mIntent.toURI();
799         target = Intent.getIntent(uri);
800         assertEquals(mComponentName, target.getComponent());
801 
802         mIntent.addCategory(TEST_CATEGORY);
803         uri = mIntent.toURI();
804         target = Intent.getIntent(uri);
805         assertEquals(1, target.getCategories().size());
806         assertEquals(TEST_CATEGORY, (String) (target.getCategories().toArray()[0]));
807 
808         mIntent.setType(TEST_TYPE);
809         uri = mIntent.toURI();
810         target = Intent.getIntent(uri);
811         assertEquals(TEST_TYPE, target.getType());
812 
813         mIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT
814                 | Intent.FLAG_GRANT_WRITE_URI_PERMISSION | Intent.FLAG_GRANT_READ_URI_PERMISSION
815                 | Intent.FLAG_GRANT_PREFIX_URI_PERMISSION
816                 | Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION);
817         uri = mIntent.toURI();
818         target = Intent.getIntent(uri);
819         assertEquals(Intent.FLAG_ACTIVITY_NEW_DOCUMENT, target.getFlags());
820 
821         String stringValue = "testString";
822         mIntent.putExtra(TEST_EXTRA_NAME, stringValue);
823         uri = mIntent.toURI();
824         target = Intent.getIntent(uri);
825         assertEquals(stringValue, target.getStringExtra(TEST_EXTRA_NAME));
826 
827         mIntent.putExtra(TEST_EXTRA_NAME, true);
828         uri = mIntent.toURI();
829         target = Intent.getIntent(uri);
830         assertTrue(target.getBooleanExtra(TEST_EXTRA_NAME, false));
831 
832         final byte b = 1;
833         mIntent.putExtra(TEST_EXTRA_NAME, b);
834 
835         uri = mIntent.toURI();
836         target = Intent.getIntent(uri);
837         final byte defaulttByte = 2;
838         assertEquals(b, target.getByteExtra(TEST_EXTRA_NAME, defaulttByte));
839 
840         final char testChar = 'a';
841         mIntent.putExtra(TEST_EXTRA_NAME, testChar);
842         uri = mIntent.toURI();
843         target = Intent.getIntent(uri);
844         assertEquals(testChar, target.getCharExtra(TEST_EXTRA_NAME, 'b'));
845 
846         final double testDouble = 1;
847         mIntent.putExtra(TEST_EXTRA_NAME, testDouble);
848         uri = mIntent.toURI();
849         target = Intent.getIntent(uri);
850         assertEquals(testDouble, target.getDoubleExtra(TEST_EXTRA_NAME, 2));
851 
852         final int testInt = 1;
853         mIntent.putExtra(TEST_EXTRA_NAME, testInt);
854         uri = mIntent.toURI();
855         target = Intent.getIntent(uri);
856         assertEquals(testInt, target.getIntExtra(TEST_EXTRA_NAME, 2));
857 
858         final long testLong = 1l;
859         mIntent.putExtra(TEST_EXTRA_NAME, testLong);
860         uri = mIntent.toURI();
861         target = Intent.getIntent(uri);
862         assertEquals(testLong, target.getLongExtra(TEST_EXTRA_NAME, 2l));
863 
864         final short testShort = 1;
865         final short defaultShort = 2;
866         mIntent.putExtra(TEST_EXTRA_NAME, testShort);
867         uri = mIntent.toURI();
868         target = Intent.getIntent(uri);
869         assertEquals(testShort, target.getShortExtra(TEST_EXTRA_NAME, defaultShort));
870     }
871 
testToURI()872     public void testToURI() {
873         mIntent = new Intent();
874         assertEquals("", mIntent.toURI());
875 
876         mIntent.setData(TEST_URI);
877         assertTrue(mIntent.toURI().indexOf(TEST_URI.toString()) != -1);
878 
879         mIntent.setAction(TEST_ACTION);
880         assertTrue(mIntent.toURI().indexOf("action=" + TEST_ACTION) != -1);
881 
882         mIntent.addCategory(TEST_CATEGORY);
883         assertTrue(mIntent.toURI().indexOf("category=") != -1);
884 
885         mIntent.setType(TEST_TYPE);
886 
887         assertTrue(mIntent.toURI().indexOf("type=" + TEST_TYPE) != -1);
888 
889         mIntent.setFlags(1);
890         assertFalse(mIntent.toURI().indexOf("launchFlags=" + Integer.toHexString(1)) != -1);
891 
892         mIntent.setComponent(mComponentName);
893         assertTrue(mIntent.toURI().indexOf(
894                 "component=" + mComponentName.flattenToShortString()) != -1);
895 
896         final String stringValue = "testString";
897         mIntent.putExtra(TEST_EXTRA_NAME, stringValue);
898 
899         assertTrue(mIntent.toURI().indexOf(getString("S", TEST_EXTRA_NAME, stringValue)) != -1);
900 
901         mIntent.putExtra(TEST_EXTRA_NAME, true);
902 
903         assertTrue(mIntent.toURI().indexOf(getString("B", TEST_EXTRA_NAME, true)) != -1);
904 
905         final byte b = 1;
906         mIntent.putExtra(TEST_EXTRA_NAME, b);
907         assertTrue(mIntent.toURI().indexOf(getString("b", TEST_EXTRA_NAME, b)) != -1);
908 
909         final Character testChar = 'a';
910         mIntent.putExtra(TEST_EXTRA_NAME, testChar);
911 
912         assertTrue(mIntent.toURI().indexOf(getString("c", TEST_EXTRA_NAME, testChar)) != -1);
913 
914         final double testDouble = 1;
915         mIntent.putExtra(TEST_EXTRA_NAME, testDouble);
916         assertTrue(mIntent.toURI().indexOf(getString("d", TEST_EXTRA_NAME, testDouble)) != -1);
917 
918         final int testInt = 1;
919         mIntent.putExtra(TEST_EXTRA_NAME, testInt);
920         assertTrue(mIntent.toURI().indexOf(getString("i", TEST_EXTRA_NAME, testInt)) != -1);
921 
922         final long testLong = 1l;
923         mIntent.putExtra(TEST_EXTRA_NAME, testLong);
924         assertTrue(mIntent.toURI().indexOf(getString("l", TEST_EXTRA_NAME, testLong)) != -1);
925         final short testShort = 1;
926         mIntent.putExtra(TEST_EXTRA_NAME, testShort);
927         assertTrue(mIntent.toURI().indexOf(getString("s", TEST_EXTRA_NAME, testShort)) != -1);
928         assertTrue(mIntent.toURI().indexOf("end") != -1);
929     }
930 
getString(String entryType, String key, Object value)931     private String getString(String entryType, String key, Object value) {
932         StringBuilder uri = new StringBuilder();
933         uri.append(entryType);
934         uri.append('.');
935         uri.append(Uri.encode(key));
936         uri.append('=');
937         uri.append(Uri.encode(value.toString()));
938         return uri.toString();
939     }
940 
makeSelector(Intent baseIntent, Intent selectorIntent)941     static Intent makeSelector(Intent baseIntent, Intent selectorIntent) {
942         baseIntent.setSelector(selectorIntent);
943         return baseIntent;
944     }
945 
testUris()946     public void testUris() {
947         checkIntentUri(
948                 "intent:#Intent;action=android.test.FOO;end",
949                 null,
950                 new Intent().setAction("android.test.FOO"));
951         checkIntentUri(
952                 "intent:#Intent;category=android.test.FOO;end",
953                 null,
954                 new Intent().setAction(Intent.ACTION_VIEW).addCategory("android.test.FOO"));
955         checkIntentUri(
956                 "intent:#Intent;action=android.test.FOO;launchFlags=0x20;end",
957                 null,
958                 new Intent().setAction("android.test.FOO").setFlags(0x20));
959         checkIntentUri(
960                 "intent://www.example.com/blah#Intent;scheme=http;end",
961                 null,
962                 new Intent().setAction(Intent.ACTION_VIEW)
963                         .setData(Uri.parse("http://www.example.com/blah")));
964         checkIntentUri(
965                 "intent://www.example.com/blah#Intent;scheme=http;component=com.exfoo/com.argh.Bar;end",
966                 null,
967                 new Intent().setAction(Intent.ACTION_VIEW)
968                         .setData(Uri.parse("http://www.example.com/blah"))
969                         .setComponent(new ComponentName("com.exfoo", "com.argh.Bar")));
970         checkIntentUri(
971                 "intent://www.example.com/blah#fragment#Intent;scheme=http;end",
972                 null,
973                 new Intent().setAction(Intent.ACTION_VIEW)
974                         .setData(Uri.parse("http://www.example.com/blah#fragment")));
975         checkIntentUri(
976                 "intent://www.example.com/blah#Intent;scheme=http;action=android.test.foo;end",
977                 null,
978                 new Intent().setAction("android.test.foo")
979                         .setData(Uri.parse("http://www.example.com/blah")));
980         checkIntentUri(
981                 "intent:foo#Intent;scheme=mailto;type=image/foo;end",
982                 null,
983                 new Intent().setAction(Intent.ACTION_VIEW)
984                         .setDataAndType(Uri.parse("mailto:foo"), "image/foo"));
985         checkIntentUri(
986                 "intent:foo#Intent;scheme=mailto;S.string=text;end",
987                 null,
988                 new Intent().setAction(Intent.ACTION_VIEW)
989                         .setData(Uri.parse("mailto:foo"))
990                         .putExtra("string", "text"));
991         checkIntentUri(
992                 "intent:#Intent;action=android.test.FOO;S.string=text;end",
993                 null,
994                 new Intent().setAction("android.test.FOO").putExtra("string", "text"));
995         checkIntentUri(
996                 "intent:foo#Intent;scheme=mailto;i.int=1000;end",
997                 null,
998                 new Intent().setAction(Intent.ACTION_VIEW)
999                         .setData(Uri.parse("mailto:foo"))
1000                         .putExtra("int", 1000));
1001         checkIntentUri(
1002                 "intent:foo#Intent;scheme=mailto;l.long=1000;end",
1003                 null,
1004                 new Intent().setAction(Intent.ACTION_VIEW)
1005                         .setData(Uri.parse("mailto:foo"))
1006                         .putExtra("long", (long) 1000));
1007         checkIntentUri(
1008                 "intent:foo#Intent;scheme=mailto;B.boolean=true;end",
1009                 null,
1010                 new Intent().setAction(Intent.ACTION_VIEW)
1011                         .setData(Uri.parse("mailto:foo"))
1012                         .putExtra("boolean", true));
1013         checkIntentUri(
1014                 "intent:foo#Intent;scheme=mailto;f.float=10.4;end",
1015                 null,
1016                 new Intent().setAction(Intent.ACTION_VIEW)
1017                         .setData(Uri.parse("mailto:foo"))
1018                         .putExtra("float", 10.4f));
1019         checkIntentUri(
1020                 "intent:foo#Intent;scheme=mailto;d.double=10.4;end",
1021                 null,
1022                 new Intent().setAction(Intent.ACTION_VIEW)
1023                         .setData(Uri.parse("mailto:foo"))
1024                         .putExtra("double", (double) 10.4));
1025         checkIntentUri(
1026                 "intent:#Intent;S.string=text;i.int=1000;l.long=1000;B.boolean=true;f.float=10.4;end",
1027                 null,
1028                 new Intent().setAction(Intent.ACTION_VIEW).putExtra("string", "text")
1029                         .putExtra("int", 1000).putExtra("long", (long) 1000)
1030                         .putExtra("boolean", true).putExtra("float", 10.4f));
1031         checkIntentUri(
1032                 "intent:foo#Intent;scheme=mailto;SEL;scheme=foobar;action=android.test.FOO;end",
1033                 null,
1034                 makeSelector(new Intent(Intent.ACTION_VIEW).setData(Uri.parse("mailto:foo")),
1035                         new Intent("android.test.FOO").setData(Uri.parse("foobar:"))));
1036         checkIntentUri(
1037                 "intent:foo#Intent;scheme=mailto;SEL;action=android.test.FOO;package=com.myapp;end",
1038                 null,
1039                 makeSelector(new Intent(Intent.ACTION_VIEW).setData(Uri.parse("mailto:foo")),
1040                         new Intent("android.test.FOO").setPackage("com.myapp")));
1041         checkIntentUri(
1042                 "intent:foo#Intent;scheme=mailto;SEL;action=android.test.FOO;component=com.exfoo/com.argh.Bar;end",
1043                 null,
1044                 makeSelector(new Intent(Intent.ACTION_VIEW).setData(Uri.parse("mailto:foo")),
1045                         new Intent("android.test.FOO")
1046                                 .setComponent(new ComponentName("com.exfoo", "com.argh.Bar"))));
1047 
1048         checkIntentUri(
1049                 "intent:#Intent;action=android.test.FOO;package=com.myapp;end",
1050                 "android-app://com.myapp#Intent;action=android.test.FOO;end",
1051                 new Intent().setAction("android.test.FOO").setPackage("com.myapp"));
1052         checkIntentUri(
1053                 "intent:#Intent;action=android.intent.action.MAIN;package=com.myapp;end",
1054                 "android-app://com.myapp",
1055                 new Intent().setAction(Intent.ACTION_MAIN).setPackage("com.myapp"));
1056         checkIntentUri(
1057                 "intent:#Intent;package=com.myapp;end",
1058                 "android-app://com.myapp#Intent;action=android.intent.action.VIEW;end",
1059                 new Intent().setAction(Intent.ACTION_VIEW).setPackage("com.myapp"));
1060         checkIntentUri(
1061                 "intent:#Intent;category=android.test.FOO;package=com.myapp;end",
1062                 "android-app://com.myapp#Intent;action=android.intent.action.VIEW;category=android.test.FOO;end",
1063                 new Intent().setAction(Intent.ACTION_VIEW).addCategory("android.test.FOO")
1064                         .setPackage("com.myapp"));
1065         checkIntentUri(
1066                 "intent:#Intent;action=android.test.FOO;launchFlags=0x20;package=com.myapp;end",
1067                 "android-app://com.myapp#Intent;action=android.test.FOO;launchFlags=0x20;end",
1068                 new Intent().setAction("android.test.FOO").setFlags(0x20)
1069                         .setPackage("com.myapp"));
1070         checkIntentUri(
1071                 "intent://www.example.com/blah#Intent;scheme=http;package=com.myapp;end",
1072                 "android-app://com.myapp/http/www.example.com/blah",
1073                 new Intent().setAction(Intent.ACTION_VIEW)
1074                         .setData(Uri.parse("http://www.example.com/blah"))
1075                         .setPackage("com.myapp"));
1076         checkIntentUri(
1077                 "intent://www.example.com/blah#Intent;scheme=http;package=com.myapp;component=com.exfoo/com.argh.Bar;end",
1078                 "android-app://com.myapp/http/www.example.com/blah#Intent;component=com.exfoo/com.argh.Bar;end",
1079                 new Intent().setAction(Intent.ACTION_VIEW)
1080                         .setData(Uri.parse("http://www.example.com/blah"))
1081                         .setComponent(new ComponentName("com.exfoo", "com.argh.Bar"))
1082                         .setPackage("com.myapp"));
1083         checkIntentUri(
1084                 "intent://www.example.com/blah#fragment#Intent;scheme=http;package=com.myapp;end",
1085                 "android-app://com.myapp/http/www.example.com/blah#fragment",
1086                 new Intent().setAction(Intent.ACTION_VIEW)
1087                         .setData(Uri.parse("http://www.example.com/blah#fragment"))
1088                         .setPackage("com.myapp"));
1089         checkIntentUri(
1090                 "intent://www.example.com/blah#fragment#Intent;scheme=http;action=android.test.FOO;package=com.myapp;end",
1091                 "android-app://com.myapp/http/www.example.com/blah#fragment#Intent;action=android.test.FOO;end",
1092                 new Intent().setAction("android.test.FOO")
1093                         .setData(Uri.parse("http://www.example.com/blah#fragment"))
1094                         .setPackage("com.myapp"));
1095         checkIntentUri(
1096                 "intent://www.example.com/blah#Intent;scheme=http;package=com.myapp;end",
1097                 "android-app://com.myapp/http/www.example.com/blah",
1098                 new Intent().setAction(Intent.ACTION_VIEW)
1099                         .setData(Uri.parse("http://www.example.com/blah"))
1100                         .setPackage("com.myapp"));
1101         checkIntentUri(
1102                 "intent:#Intent;scheme=mailto;type=image/foo;package=com.myapp;end",
1103                 "android-app://com.myapp/mailto#Intent;type=image/foo;end",
1104                 new Intent().setAction(Intent.ACTION_VIEW)
1105                         .setDataAndType(Uri.parse("mailto:"), "image/foo")
1106                         .setPackage("com.myapp"));
1107         checkIntentUri(
1108                 "intent:#Intent;scheme=mailto;package=com.myapp;S.string=text;end",
1109                 "android-app://com.myapp/mailto#Intent;S.string=text;end",
1110                 new Intent().setAction(Intent.ACTION_VIEW).putExtra("string", "text")
1111                         .setData(Uri.parse("mailto:")).setPackage("com.myapp"));
1112         checkIntentUri(
1113                 "intent:#Intent;action=android.test.FOO;package=com.myapp;S.string=text;end",
1114                 "android-app://com.myapp#Intent;action=android.test.FOO;S.string=text;end",
1115                 new Intent().setAction("android.test.FOO").putExtra("string", "text")
1116                         .setPackage("com.myapp"));
1117         checkIntentUri(
1118                 "intent:#Intent;scheme=mailto;package=com.myapp;i.int=1000;end",
1119                 "android-app://com.myapp/mailto#Intent;i.int=1000;end",
1120                 new Intent().setAction(Intent.ACTION_VIEW).putExtra("int", 1000)
1121                         .setData(Uri.parse("mailto:")).setPackage("com.myapp"));
1122         checkIntentUri(
1123                 "intent:#Intent;scheme=mailto;package=com.myapp;l.long=1000;end",
1124                 "android-app://com.myapp/mailto#Intent;l.long=1000;end",
1125                 new Intent().setAction(Intent.ACTION_VIEW).putExtra("long", (long) 1000)
1126                         .setData(Uri.parse("mailto:")).setPackage("com.myapp"));
1127         checkIntentUri(
1128                 "intent:#Intent;scheme=mailto;package=com.myapp;B.boolean=true;end",
1129                 "android-app://com.myapp/mailto#Intent;B.boolean=true;end",
1130                 new Intent().setAction(Intent.ACTION_VIEW).putExtra("boolean", true)
1131                         .setData(Uri.parse("mailto:")).setPackage("com.myapp"));
1132         checkIntentUri(
1133                 "intent:#Intent;scheme=mailto;package=com.myapp;f.float=10.4;end",
1134                 "android-app://com.myapp/mailto#Intent;f.float=10.4;end",
1135                 new Intent().setAction(Intent.ACTION_VIEW).putExtra("float", 10.4f)
1136                         .setData(Uri.parse("mailto:")).setPackage("com.myapp"));
1137         checkIntentUri(
1138                 "intent:#Intent;scheme=mailto;package=com.myapp;d.double=10.4;end",
1139                 "android-app://com.myapp/mailto#Intent;d.double=10.4;end",
1140                 new Intent().setAction(Intent.ACTION_VIEW).putExtra("double", (double) 10.4)
1141                         .setData(Uri.parse("mailto:")).setPackage("com.myapp"));
1142         checkIntentUri(
1143                 "intent:#Intent;package=com.myapp;S.string=text;i.int=1000;l.long=1000;B.boolean=true;f.float=10.4;end",
1144                 "android-app://com.myapp#Intent;action=android.intent.action.VIEW;S.string=text;i.int=1000;l.long=1000;B.boolean=true;f.float=10.4;end",
1145                 new Intent().setAction(Intent.ACTION_VIEW).putExtra("string", "text")
1146                         .putExtra("int", 1000).putExtra("long", (long) 1000)
1147                         .putExtra("boolean", true).putExtra("float", 10.4f)
1148                         .setPackage("com.myapp"));
1149     }
1150 
compareIntents(Intent expected, Intent actual)1151     private boolean compareIntents(Intent expected, Intent actual) {
1152         if (!Objects.equals(expected.getAction(), actual.getAction())) {
1153             return false;
1154         }
1155         if (!Objects.equals(expected.getData(), actual.getData())) {
1156             return false;
1157         }
1158         if (!Objects.equals(expected.getType(), actual.getType())) {
1159             return false;
1160         }
1161         if (!Objects.equals(expected.getPackage(), actual.getPackage())) {
1162             return false;
1163         }
1164         if (!Objects.equals(expected.getComponent(), actual.getComponent())) {
1165             return false;
1166         }
1167         if (expected.getFlags() != actual.getFlags()) {
1168             return false;
1169         }
1170         Set<String> expectedCat = expected.getCategories();
1171         Set<String> actualCat = actual.getCategories();
1172         if (expectedCat != actualCat) {
1173             if (expectedCat == null || actualCat == null) {
1174                 return false;
1175             }
1176             for (String cat : expectedCat) {
1177                 if (!actual.hasCategory(cat)) {
1178                     return false;
1179                 }
1180             }
1181             for (String cat : actualCat) {
1182                 if (!expected.hasCategory(cat)) {
1183                     return false;
1184                 }
1185             }
1186         }
1187         Bundle extras1 = expected.getExtras();
1188         Bundle extras2 = actual.getExtras();
1189         if (extras1 != extras2) {
1190             if (extras1 == null || extras2 == null) {
1191                 return false;
1192             }
1193             for (String key : extras1.keySet()) {
1194                 if (!Objects.equals(extras1.get(key), extras2.get(key))) {
1195                     return false;
1196                 }
1197             }
1198             for (String key : extras2.keySet()) {
1199                 if (!Objects.equals(extras1.get(key), extras2.get(key))) {
1200                     return false;
1201                 }
1202             }
1203         }
1204         return true;
1205     }
1206 
assertEqualsIntent(String msg, Intent expected, Intent actual)1207     private void assertEqualsIntent(String msg, Intent expected, Intent actual) {
1208         if (!compareIntents(expected, actual)) {
1209             failNotEquals(msg, expected, actual);
1210         }
1211         Intent expectedSel = expected.getSelector();
1212         Intent actualSel = actual.getSelector();
1213         if (expectedSel != actualSel) {
1214             if (expectedSel == null || actualSel == null) {
1215                 failNotEquals(msg, expected, actual);
1216             }
1217             if (!compareIntents(expectedSel, actualSel)) {
1218                 failNotEquals(msg, expected, actual);
1219             }
1220         }
1221     }
1222 
checkIntentUri(String intentSchemeUri, String androidAppSchemeUri, Intent intent)1223     private void checkIntentUri(String intentSchemeUri, String androidAppSchemeUri, Intent intent) {
1224         if (intentSchemeUri != null) {
1225             try {
1226                 Intent genIntent = Intent.parseUri(intentSchemeUri, 0);
1227                 assertEqualsIntent("Implicitly converting " + intentSchemeUri + " to Intent",
1228                         intent, genIntent);
1229                 genIntent = Intent.parseUri(intentSchemeUri, Intent.URI_INTENT_SCHEME);
1230                 assertEqualsIntent("Explicitly converting " + intentSchemeUri + " to Intent",
1231                         intent, genIntent);
1232             } catch (URISyntaxException e) {
1233                 fail("Failure parsing " + intentSchemeUri + ": " + e);
1234             }
1235             String genUri = intent.toUri(Intent.URI_INTENT_SCHEME);
1236             assertEquals("Converting " + intent + " to intent: uri",
1237                     intentSchemeUri, genUri);
1238         }
1239         if (androidAppSchemeUri != null) {
1240             try {
1241                 Intent genIntent = Intent.parseUri(androidAppSchemeUri, 0);
1242                 assertEqualsIntent("Implicitly converting " + androidAppSchemeUri + " to Intent",
1243                         intent, genIntent);
1244                 genIntent = Intent.parseUri(intentSchemeUri, Intent.URI_ANDROID_APP_SCHEME);
1245                 assertEqualsIntent("Explicitly converting " + androidAppSchemeUri + " to Intent",
1246                         intent, genIntent);
1247             } catch (URISyntaxException e) {
1248                 fail("Failure parsing " + androidAppSchemeUri + ": " + e);
1249             }
1250             String genUri = intent.toUri(Intent.URI_ANDROID_APP_SCHEME);
1251             assertEquals("Converting " + intent + " to android-app: uri",
1252                     androidAppSchemeUri, genUri);
1253         }
1254     }
1255 
testAccessFlags()1256     public void testAccessFlags() {
1257         int expected = 1;
1258         mIntent.setFlags(expected);
1259         assertEquals(expected, mIntent.getFlags());
1260     }
1261 
testCreateChooser()1262     public void testCreateChooser() {
1263         Intent target = Intent.createChooser(mIntent, null);
1264         assertEquals(Intent.ACTION_CHOOSER, target.getAction());
1265         Intent returnIntent = (Intent) target.getParcelableExtra(Intent.EXTRA_INTENT);
1266         assertEquals(mIntent.toString(), returnIntent.toString());
1267         assertEquals(mIntent.toURI(), returnIntent.toURI());
1268         assertNull(returnIntent.getStringExtra(Intent.EXTRA_INTENT));
1269         final String title = "title String";
1270         target = Intent.createChooser(mIntent, title);
1271         assertEquals(title, target.getStringExtra(Intent.EXTRA_TITLE));
1272     }
1273 
testGetFloatArrayExtra()1274     public void testGetFloatArrayExtra() {
1275         final float[] expected = { 1f, 2f, 3f };
1276         mIntent.putExtra(TEST_EXTRA_NAME, expected);
1277         assertEquals(expected, mIntent.getFloatArrayExtra(TEST_EXTRA_NAME));
1278     }
1279 
testSetDataAndType()1280     public void testSetDataAndType() {
1281         mIntent.setDataAndType(TEST_URI, TEST_TYPE);
1282         assertEquals(TEST_URI, mIntent.getData());
1283         assertEquals(TEST_TYPE, mIntent.getType());
1284     }
1285 
testSetData()1286     public void testSetData() {
1287         mIntent.setData(TEST_URI);
1288         assertEquals(TEST_URI, mIntent.getData());
1289         assertNull(mIntent.getType());
1290 
1291         mIntent.setType(TEST_TYPE);
1292         mIntent.setData(TEST_URI);
1293         assertEquals(TEST_URI, mIntent.getData());
1294         assertNull(mIntent.getType());
1295     }
1296 
testSetType()1297     public void testSetType() {
1298         mIntent.setType(TEST_TYPE);
1299         assertEquals(TEST_TYPE, mIntent.getType());
1300         assertNull(mIntent.getData());
1301 
1302         mIntent.setData(TEST_URI);
1303         mIntent.setType(TEST_TYPE);
1304         assertEquals(TEST_TYPE, mIntent.getType());
1305         assertNull(mIntent.getData());
1306     }
1307 
testGetStringExtra()1308     public void testGetStringExtra() {
1309         final String expected = "testString";
1310         assertNull(mIntent.getStringExtra(TEST_EXTRA_NAME));
1311         mIntent.putExtra(TEST_EXTRA_NAME, expected);
1312         assertEquals(expected, mIntent.getStringExtra(TEST_EXTRA_NAME));
1313     }
1314 
1315     /**
1316      * Test that fillIn has no effect when no fields are set.
1317      */
testFillIn_blank()1318     public void testFillIn_blank() {
1319         Intent sourceIntent = new Intent();
1320         Intent destIntent = new Intent();
1321         assertEquals(0, destIntent.fillIn(sourceIntent, Intent.FILL_IN_ACTION));
1322         assertEquals(0, destIntent.fillIn(sourceIntent, 0));
1323         assertNull(destIntent.getAction());
1324     }
1325 
1326     /**
1327      * Test that fillIn copies the action field.
1328      */
testFillIn_action()1329     public void testFillIn_action() {
1330         Intent sourceIntent = new Intent();
1331         Intent destIntent = new Intent();
1332         // test action copied when null
1333         sourceIntent.setAction(TEST_ACTION);
1334         assertEquals(Intent.FILL_IN_ACTION, destIntent.fillIn(sourceIntent, 0));
1335         assertEquals(TEST_ACTION, destIntent.getAction());
1336     }
1337 
1338     /**
1339      * Test that fillIn does not copy action when its already set in target Intent.
1340      */
testFillIn_actionSet()1341     public void testFillIn_actionSet() {
1342         Intent sourceIntent = new Intent();
1343         Intent destIntent = new Intent();
1344         final String newAction = "foo";
1345         sourceIntent = new Intent();
1346         sourceIntent.setAction(newAction);
1347         destIntent.setAction(TEST_ACTION);
1348 
1349         assertEquals(0, destIntent.fillIn(sourceIntent, 0));
1350         assertEquals(TEST_ACTION, destIntent.getAction());
1351     }
1352 
1353     /**
1354      * Test that fillIn copies action when {@link Intent#FILL_IN_ACTION} flag is set.
1355      */
testFillIn_actionOverride()1356     public void testFillIn_actionOverride() {
1357         Intent sourceIntent = new Intent();
1358         Intent destIntent = new Intent();
1359         final String newAction = "foo";
1360         sourceIntent = new Intent();
1361         sourceIntent.setAction(newAction);
1362         destIntent.setAction(TEST_ACTION);
1363 
1364         assertEquals(Intent.FILL_IN_ACTION, destIntent.fillIn(sourceIntent, Intent.FILL_IN_ACTION));
1365         assertEquals(newAction, destIntent.getAction());
1366     }
1367 
1368     /**
1369      * Test that fillIn copies data.
1370      */
testFillIn_data()1371     public void testFillIn_data() {
1372         Intent sourceIntent = new Intent();
1373         Intent destIntent = new Intent();
1374         sourceIntent.setData(TEST_URI);
1375         assertEquals(Intent.FILL_IN_DATA, destIntent.fillIn(sourceIntent, 0));
1376         assertEquals(TEST_URI, destIntent.getData());
1377     }
1378 
1379     /**
1380      * Test that fillIn does not copy data when already its already set in target Intent.
1381      */
testFillIn_dataSet()1382     public void testFillIn_dataSet() {
1383         Intent sourceIntent = new Intent();
1384         Intent destIntent = new Intent();
1385         sourceIntent.setData(TEST_URI);
1386         destIntent.setData(ANOTHER_TEST_URI);
1387         assertEquals(0, destIntent.fillIn(sourceIntent, 0));
1388         assertEquals(ANOTHER_TEST_URI, destIntent.getData());
1389     }
1390 
1391     /**
1392      * Test that fillIn overrides data when {@link Intent#FILL_IN_DATA} flag is set.
1393      */
testFillIn_dataOverride()1394     public void testFillIn_dataOverride() {
1395         Intent sourceIntent = new Intent();
1396         Intent destIntent = new Intent();
1397         sourceIntent.setData(TEST_URI);
1398         destIntent.setData(ANOTHER_TEST_URI);
1399         assertEquals(Intent.FILL_IN_DATA, destIntent.fillIn(sourceIntent, Intent.FILL_IN_DATA));
1400         assertEquals(TEST_URI, destIntent.getData());
1401     }
1402 
1403     /**
1404      * Test that fillIn copies data type.
1405      */
testFillIn_dataType()1406     public void testFillIn_dataType() {
1407         Intent sourceIntent = new Intent();
1408         Intent destIntent = new Intent();
1409         sourceIntent.setType(TEST_TYPE);
1410         assertEquals(Intent.FILL_IN_DATA, destIntent.fillIn(sourceIntent, 0));
1411         assertEquals(TEST_TYPE, destIntent.getType());
1412     }
1413 
1414     /**
1415      * Test that fillIn does not copy data type when already its already set in target Intent.
1416      */
testFillIn_dataTypeSet()1417     public void testFillIn_dataTypeSet() {
1418         Intent sourceIntent = new Intent();
1419         Intent destIntent = new Intent();
1420         sourceIntent.setType(TEST_TYPE);
1421         destIntent.setType(ANOTHER_TEST_TYPE);
1422         assertEquals(0, destIntent.fillIn(sourceIntent, 0));
1423         assertEquals(ANOTHER_TEST_TYPE, destIntent.getType());
1424     }
1425 
1426     /**
1427      * Test that fillIn overrides data type when {@link Intent#FILL_IN_DATA} flag is set.
1428      */
testFillIn_dataTypeOverride()1429     public void testFillIn_dataTypeOverride() {
1430         Intent sourceIntent = new Intent();
1431         Intent destIntent = new Intent();
1432         sourceIntent.setType(TEST_TYPE);
1433         destIntent.setType(ANOTHER_TEST_TYPE);
1434         assertEquals(Intent.FILL_IN_DATA, destIntent.fillIn(sourceIntent, Intent.FILL_IN_DATA));
1435         assertEquals(TEST_TYPE, destIntent.getType());
1436     }
1437 
1438     /**
1439      * Test component is not copied by fillIn method when {@link Intent#FILL_IN_COMPONENT} flag is
1440      * not set.
1441      */
testFillIn_componentNoCopy()1442     public void testFillIn_componentNoCopy() {
1443         Intent sourceIntent = new Intent();
1444         Intent destIntent = new Intent();
1445         sourceIntent.setComponent(mComponentName);
1446         assertEquals(0, destIntent.fillIn(sourceIntent, 0));
1447         assertEquals(null, destIntent.getComponent());
1448     }
1449 
1450     /**
1451      * Test that fillIn copies component when {@link Intent#FILL_IN_COMPONENT} flag is set.
1452      */
testFillIn_componentOverride()1453     public void testFillIn_componentOverride() {
1454         Intent sourceIntent = new Intent();
1455         Intent destIntent = new Intent();
1456         sourceIntent.setComponent(mComponentName);
1457         destIntent.setComponent(mAnotherComponentName);
1458         assertEquals(Intent.FILL_IN_COMPONENT, destIntent.fillIn(sourceIntent,
1459                 Intent.FILL_IN_COMPONENT));
1460         assertEquals(mComponentName, destIntent.getComponent());
1461     }
1462 
1463     /**
1464      * Test that fillIn copies categories.
1465      */
testFillIn_category()1466     public void testFillIn_category() {
1467         Intent sourceIntent = new Intent();
1468         Intent destIntent = new Intent();
1469         // add two categories to ensure all categories are copied
1470         sourceIntent.addCategory(TEST_CATEGORY);
1471         sourceIntent.addCategory(ANOTHER_TEST_CATEGORY);
1472         assertEquals(Intent.FILL_IN_CATEGORIES, destIntent.fillIn(sourceIntent, 0));
1473         assertEquals(2, destIntent.getCategories().size());
1474         assertTrue(destIntent.getCategories().contains(TEST_CATEGORY));
1475         assertTrue(destIntent.getCategories().contains(ANOTHER_TEST_CATEGORY));
1476     }
1477 
1478     /**
1479      * Test fillIn does not copy categories by default when already set.
1480      */
testFillIn_categorySet()1481     public void testFillIn_categorySet() {
1482         Intent sourceIntent = new Intent();
1483         Intent destIntent = new Intent();
1484         sourceIntent = new Intent();
1485         sourceIntent.addCategory(TEST_CATEGORY);
1486         destIntent.addCategory(ANOTHER_TEST_CATEGORY);
1487 
1488         assertEquals(0, destIntent.fillIn(sourceIntent, 0));
1489         assertEquals(1, destIntent.getCategories().size());
1490         assertTrue(destIntent.getCategories().contains(ANOTHER_TEST_CATEGORY));
1491         assertFalse(destIntent.getCategories().contains(TEST_CATEGORY));
1492     }
1493 
1494     /**
1495      * Test that fillIn adds categories when {@link Intent#FILL_IN_CATEGORIES} flag is set.
1496      */
testFillIn_categoryOverride()1497     public void testFillIn_categoryOverride() {
1498         Intent sourceIntent = new Intent();
1499         Intent destIntent = new Intent();
1500         sourceIntent = new Intent();
1501         sourceIntent.addCategory(TEST_CATEGORY);
1502         destIntent.addCategory(ANOTHER_TEST_CATEGORY);
1503 
1504         assertEquals(Intent.FILL_IN_CATEGORIES, destIntent.fillIn(sourceIntent, Intent.FILL_IN_CATEGORIES));
1505         assertEquals(1, destIntent.getCategories().size());
1506         assertFalse(destIntent.getCategories().contains(ANOTHER_TEST_CATEGORY));
1507         assertTrue(destIntent.getCategories().contains(TEST_CATEGORY));
1508     }
1509 
1510     /**
1511      * Test fillIn copies package.
1512      */
testFillIn_package()1513     public void testFillIn_package() {
1514         Intent sourceIntent = new Intent();
1515         Intent destIntent = new Intent();
1516         sourceIntent.setPackage(TEST_PACKAGE);
1517         assertEquals(Intent.FILL_IN_PACKAGE, destIntent.fillIn(sourceIntent, 0));
1518         assertEquals(TEST_PACKAGE, destIntent.getPackage());
1519     }
1520 
1521     /**
1522      * Test fillIn does not copy package by default when already set.
1523      */
testFillIn_packageSet()1524     public void testFillIn_packageSet() {
1525         Intent sourceIntent = new Intent();
1526         Intent destIntent = new Intent();
1527         sourceIntent.setPackage(TEST_PACKAGE);
1528         destIntent.setPackage(ANOTHER_TEST_PACKAGE);
1529         assertEquals(0, destIntent.fillIn(sourceIntent, 0));
1530         assertEquals(ANOTHER_TEST_PACKAGE, destIntent.getPackage());
1531     }
1532 
1533     /**
1534      * Test that fillIn overrides package when {@link Intent#FILL_IN_PACKAGE} flag is set.
1535      */
testFillIn_packageOverride()1536     public void testFillIn_packageOverride() {
1537         Intent sourceIntent = new Intent();
1538         Intent destIntent = new Intent();
1539         sourceIntent.setPackage(TEST_PACKAGE);
1540         destIntent.setPackage(ANOTHER_TEST_PACKAGE);
1541         assertEquals(Intent.FILL_IN_PACKAGE, destIntent.fillIn(sourceIntent, Intent.FILL_IN_PACKAGE));
1542         assertEquals(TEST_PACKAGE, destIntent.getPackage());
1543     }
1544 
1545     /**
1546      * Test that fillIn copies extras.
1547      */
testFillIn_extras()1548     public void testFillIn_extras() {
1549         Intent sourceIntent = new Intent();
1550         Intent destIntent = new Intent();
1551         final Bundle bundle = new Bundle();
1552         bundle.putBoolean(TEST_EXTRA_NAME, true);
1553         sourceIntent.putExtras(bundle);
1554         assertEquals(0, destIntent.fillIn(sourceIntent, 0));
1555         assertTrue(destIntent.getExtras().getBoolean(TEST_EXTRA_NAME));
1556     }
1557 
testGetExtras()1558     public void testGetExtras() {
1559         assertNull(mIntent.getExtras());
1560         final String expected = "testString";
1561         mIntent.putExtra(TEST_EXTRA_NAME, expected);
1562         assertNotNull(mIntent.getExtras());
1563         assertEquals(expected, mIntent.getExtras().getString(TEST_EXTRA_NAME));
1564     }
1565 
testGetBooleanExtra()1566     public void testGetBooleanExtra() {
1567         assertFalse(mIntent.getBooleanExtra(TEST_EXTRA_NAME, false));
1568         mIntent.putExtra(TEST_EXTRA_NAME, true);
1569         assertTrue(mIntent.getBooleanExtra(TEST_EXTRA_NAME, false));
1570         mIntent.putExtra(TEST_EXTRA_NAME, false);
1571         assertFalse(mIntent.getBooleanExtra(TEST_EXTRA_NAME, false));
1572     }
1573 
testGetFloatExtra()1574     public void testGetFloatExtra() {
1575         float expected = 2f;
1576         assertEquals(1f, mIntent.getFloatExtra(TEST_EXTRA_NAME, 1f));
1577         mIntent.putExtra(TEST_EXTRA_NAME, expected);
1578         assertEquals(expected, mIntent.getFloatExtra(TEST_EXTRA_NAME, 1f));
1579     }
1580 
testGetShortArrayExtra()1581     public void testGetShortArrayExtra() {
1582         final short[] expected = { 1, 2, 3 };
1583         mIntent.putExtra(TEST_EXTRA_NAME, expected);
1584         assertEquals(expected, mIntent.getShortArrayExtra(TEST_EXTRA_NAME));
1585     }
1586 
testGetStringArrayExtra()1587     public void testGetStringArrayExtra() {
1588         final String[] expected = { "1d", "2d", "3d" };
1589         mIntent.putExtra(TEST_EXTRA_NAME, expected);
1590         assertEquals(expected, mIntent.getStringArrayExtra(TEST_EXTRA_NAME));
1591     }
1592 
testGetCharSequenceArrayExtra()1593     public void testGetCharSequenceArrayExtra() {
1594         final String[] expected = { "1d", "2d", "3d" };
1595         mIntent.putExtra(TEST_EXTRA_NAME, expected);
1596         assertEquals(expected, mIntent.getCharSequenceArrayExtra(TEST_EXTRA_NAME));
1597     }
1598 
testGetByteArrayExtra()1599     public void testGetByteArrayExtra() {
1600         final byte[] expected = TEST_ACTION.getBytes();
1601         mIntent.putExtra(TEST_EXTRA_NAME, expected);
1602         assertEquals(expected, mIntent.getByteArrayExtra(TEST_EXTRA_NAME));
1603     }
1604 
testHasFileDescriptors()1605     public void testHasFileDescriptors() {
1606         Bundle bundle = mIntent.getExtras();
1607         assertEquals(bundle != null && bundle.hasFileDescriptors(), mIntent.hasFileDescriptors());
1608         final byte[] expected = TEST_ACTION.getBytes();
1609         mIntent.putExtra(TEST_EXTRA_NAME, expected);
1610         bundle = mIntent.getExtras();
1611         assertEquals(bundle != null && bundle.hasFileDescriptors(), mIntent.hasFileDescriptors());
1612     }
1613 
testGetBooleanArrayExtra()1614     public void testGetBooleanArrayExtra() {
1615         final boolean[] expected = { true, true, false };
1616         mIntent.putExtra(TEST_EXTRA_NAME, expected);
1617         assertEquals(expected, mIntent.getBooleanArrayExtra(TEST_EXTRA_NAME));
1618     }
1619 
testGetLongExtra()1620     public void testGetLongExtra() {
1621         final long expected = 2l;
1622         assertEquals(1l, mIntent.getLongExtra(TEST_EXTRA_NAME, 1l));
1623         mIntent.putExtra(TEST_EXTRA_NAME, expected);
1624         assertEquals(expected, mIntent.getLongExtra(TEST_EXTRA_NAME, 1l));
1625     }
1626 
testRemoveCategory()1627     public void testRemoveCategory() {
1628         assertNull(mIntent.getCategories());
1629         mIntent.addCategory(TEST_CATEGORY);
1630         assertNotNull(mIntent.getCategories());
1631         assertEquals(1, mIntent.getCategories().size());
1632         assertEquals(TEST_CATEGORY, (String) (mIntent.getCategories().toArray()[0]));
1633         mIntent.removeCategory(TEST_CATEGORY);
1634         assertFalse(mIntent.hasCategory(TEST_CATEGORY));
1635     }
1636 
testFilterEquals()1637     public void testFilterEquals() {
1638         assertFalse(mIntent.filterEquals(null));
1639 
1640         Intent target = new Intent();
1641         assertTrue(mIntent.filterEquals(target));
1642 
1643         target.setAction(TEST_ACTION);
1644         assertFalse(mIntent.filterEquals(target));
1645         mIntent.setAction(TEST_ACTION + "test");
1646         assertFalse(mIntent.filterEquals(target));
1647         mIntent.setAction(null);
1648         assertFalse(mIntent.filterEquals(target));
1649         mIntent.setAction(TEST_ACTION);
1650         assertTrue(mIntent.filterEquals(target));
1651 
1652         target.setData(TEST_URI);
1653         assertFalse(mIntent.filterEquals(target));
1654         mIntent.setData(Uri.parse("myURI"));
1655         assertFalse(mIntent.filterEquals(target));
1656         mIntent.setData(null);
1657         assertFalse(mIntent.filterEquals(target));
1658         mIntent.setData(TEST_URI);
1659         assertTrue(mIntent.filterEquals(target));
1660 
1661         target.setType(TEST_TYPE);
1662         assertFalse(mIntent.filterEquals(target));
1663         mIntent.setType(TEST_TYPE + "test");
1664         assertFalse(mIntent.filterEquals(target));
1665         mIntent.setType(null);
1666         assertFalse(mIntent.filterEquals(target));
1667         mIntent.setType(TEST_TYPE);
1668         assertTrue(mIntent.filterEquals(target));
1669 
1670         target.setComponent(mComponentName);
1671         assertFalse(mIntent.filterEquals(target));
1672         mIntent.setComponent(new ComponentName(mContext, MockReceiver.class));
1673         assertFalse(mIntent.filterEquals(target));
1674         mIntent.setComponent(null);
1675         assertFalse(mIntent.filterEquals(target));
1676         mIntent.setComponent(mComponentName);
1677         assertTrue(mIntent.filterEquals(target));
1678 
1679         target.addCategory(TEST_CATEGORY);
1680         assertFalse(mIntent.filterEquals(target));
1681         mIntent.addCategory(TEST_CATEGORY + "test");
1682         assertFalse(mIntent.filterEquals(target));
1683         mIntent.addCategory(TEST_CATEGORY);
1684         assertFalse(mIntent.filterEquals(target));
1685     }
1686 
testPutExtras1()1687     public void testPutExtras1() {
1688         final Intent intent = new Intent();
1689         mIntent.putExtras(intent);
1690         assertEquals(intent.getExtras(), mIntent.getExtras());
1691         intent.putExtra("test2", true);
1692         mIntent.putExtras(intent);
1693         assertEquals(intent.getExtras().toString(), mIntent.getExtras().toString());
1694     }
1695 
testPutExtras2()1696     public void testPutExtras2() {
1697         final Bundle bundle = new Bundle();
1698         mIntent.putExtras(bundle);
1699         assertEquals(0, mIntent.getExtras().size());
1700         String expected = "testString";
1701         bundle.putString(TEST_EXTRA_NAME, expected);
1702         mIntent.putExtras(bundle);
1703         assertEquals(1, mIntent.getExtras().size());
1704         assertEquals(expected, mIntent.getExtras().getString(TEST_EXTRA_NAME));
1705         mIntent.putExtra(TEST_EXTRA_NAME, bundle);
1706         assertEquals(bundle, mIntent.getBundleExtra(TEST_EXTRA_NAME));
1707     }
1708 
testGetByteExtra()1709     public void testGetByteExtra() {
1710         final byte expected = Byte.valueOf("1");
1711         mIntent.putExtra(TEST_EXTRA_NAME, expected);
1712         assertEquals(expected, mIntent.getByteExtra(TEST_EXTRA_NAME, Byte.valueOf("1")));
1713     }
1714 
testGetSerializableExtra()1715     public void testGetSerializableExtra() {
1716         TestSerializable expected = new TestSerializable();
1717         expected.Name = "testName";
1718         mIntent.putExtra(TEST_EXTRA_NAME, expected);
1719         assertEquals(expected, mIntent.getSerializableExtra(TEST_EXTRA_NAME));
1720         TestSerializable target = (TestSerializable) mIntent.getSerializableExtra(TEST_EXTRA_NAME);
1721         assertEquals(expected.Name, target.Name);
1722     }
1723 
testReplaceExtras()1724     public void testReplaceExtras() {
1725         Bundle extras = new Bundle();
1726         String bundleKey = "testKey";
1727         String bundleValue = "testValue";
1728         extras.putString(bundleKey, bundleValue);
1729 
1730         Intent intent = mIntent.replaceExtras(extras);
1731         assertSame(mIntent, intent);
1732         String actualValue = intent.getExtras().getString(bundleKey);
1733         assertEquals(bundleValue, actualValue);
1734 
1735         Intent src = new Intent();
1736         String intentName = "srcName";
1737         String intentValue = "srcValue";
1738         src.putExtra(intentName, intentValue);
1739 
1740         intent = mIntent.replaceExtras(src);
1741         assertSame(mIntent, intent);
1742         actualValue = intent.getExtras().getString(intentName);
1743         assertEquals(intentValue, actualValue);
1744     }
1745 
testNormalizeMimeType()1746     public void testNormalizeMimeType() {
1747         assertEquals(null, Intent.normalizeMimeType(null));
1748         assertEquals("text/plain", Intent.normalizeMimeType("text/plain; charset=UTF-8"));
1749         assertEquals("text/x-vcard", Intent.normalizeMimeType("text/x-vCard"));
1750         assertEquals("foo/bar", Intent.normalizeMimeType("   foo/bar    "));
1751     }
1752 
1753     private static class TestSerializable implements Serializable {
1754         static final long serialVersionUID = 1l;
1755         public String Name;
1756     }
1757 }
1758