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 static android.content.Intent.EXTENDED_FLAG_MISSING_CREATOR_OR_INVALID_TOKEN; 20 import static android.content.Intent.FLAG_RECEIVER_FOREGROUND; 21 import static android.content.Intent.FLAG_RECEIVER_OFFLOAD; 22 23 import static com.google.common.truth.Truth.assertThat; 24 25 import static org.junit.Assert.assertArrayEquals; 26 import static org.junit.Assert.assertEquals; 27 import static org.junit.Assert.assertFalse; 28 import static org.junit.Assert.assertNotNull; 29 import static org.junit.Assert.assertNull; 30 import static org.junit.Assert.assertSame; 31 import static org.junit.Assert.assertThrows; 32 import static org.junit.Assert.assertTrue; 33 import static org.junit.Assert.fail; 34 35 import android.app.PendingIntent; 36 import android.app.compat.CompatChanges; 37 import android.content.ClipData; 38 import android.content.ClipDescription; 39 import android.content.ComponentName; 40 import android.content.ContentResolver; 41 import android.content.Context; 42 import android.content.Intent; 43 import android.content.IntentSender; 44 import android.content.cts.util.XmlUtils; 45 import android.content.pm.ActivityInfo; 46 import android.content.pm.PackageManager; 47 import android.content.pm.PackageManager.NameNotFoundException; 48 import android.content.res.XmlResourceParser; 49 import android.net.Uri; 50 import android.os.Binder; 51 import android.os.Bundle; 52 import android.os.IBinder; 53 import android.os.Parcel; 54 import android.os.Parcelable; 55 import android.platform.test.annotations.AppModeFull; 56 import android.platform.test.annotations.AppModeSdkSandbox; 57 import android.platform.test.annotations.DisabledOnRavenwood; 58 import android.platform.test.annotations.RequiresFlagsEnabled; 59 import android.platform.test.flag.junit.CheckFlagsRule; 60 import android.platform.test.flag.junit.DeviceFlagsValueProvider; 61 import android.platform.test.ravenwood.RavenwoodRule; 62 import android.security.Flags; 63 import android.test.mock.MockContext; 64 import android.util.AttributeSet; 65 import android.util.Xml; 66 67 import androidx.test.ext.junit.runners.AndroidJUnit4; 68 import androidx.test.platform.app.InstrumentationRegistry; 69 70 import org.junit.Before; 71 import org.junit.Rule; 72 import org.junit.Test; 73 import org.junit.runner.RunWith; 74 import org.xmlpull.v1.XmlPullParser; 75 import org.xmlpull.v1.XmlPullParserException; 76 77 import java.io.IOException; 78 import java.io.Serializable; 79 import java.net.URISyntaxException; 80 import java.util.ArrayList; 81 import java.util.Objects; 82 import java.util.Set; 83 84 @RunWith(AndroidJUnit4.class) 85 @AppModeSdkSandbox(reason = "Allow test in the SDK sandbox (does not prevent other modes).") 86 public class IntentTest { 87 @Rule 88 public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule(); 89 90 private Intent mIntent; 91 private static final String TEST_ACTION = "android.content.IntentTest_test"; 92 private static final Uri TEST_URI = Uri.parse("content://com.example/people"); 93 private static final Uri ANOTHER_TEST_URI = Uri.parse("content://com.example/places"); 94 private static final String TEST_EXTRA_NAME = "testExtraName"; 95 private Context mContext; 96 private PackageManager mPm; 97 private ComponentName mComponentName; 98 private ComponentName mAnotherComponentName; 99 private static final String TEST_TYPE = "testType"; 100 private static final String ANOTHER_TEST_TYPE = "anotherTestType"; 101 private static final String TEST_IDENTIFIER = "testIdentifier"; 102 private static final String ANOTHER_TEST_IDENTIFIER = "anotherTestIdentifier"; 103 private static final String TEST_CATEGORY = "testCategory"; 104 private static final String ANOTHER_TEST_CATEGORY = "testAnotherCategory"; 105 private static final String TEST_PACKAGE = "android.content.cts"; 106 private static final String TEST_ACTIVITY = TEST_PACKAGE + ".MockActivity"; 107 private static final String ANOTHER_TEST_PACKAGE = "android.database.cts"; 108 private static final double DELTA_FLOAT = 0.0f; 109 private static final double DELTA_DOUBLE = 0.0d; 110 111 @Before setUp()112 public void setUp() throws Exception { 113 if (RavenwoodRule.isOnRavenwood()) { 114 // TODO: replace with mockito when better supported 115 mContext = new MockContext() { 116 @Override 117 public String getPackageName() { 118 return TEST_PACKAGE; 119 } 120 }; 121 } else { 122 mContext = InstrumentationRegistry.getInstrumentation().getTargetContext(); 123 mPm = mContext.getPackageManager(); 124 } 125 126 mIntent = new Intent(); 127 mComponentName = new ComponentName(mContext, MockActivity.class); 128 mAnotherComponentName = new ComponentName(mContext, "tmp"); 129 } 130 131 @Test testConstructor()132 public void testConstructor() { 133 mIntent = new Intent(); 134 assertNotNull(mIntent); 135 136 Intent intent = new Intent(); 137 intent.setAction(TEST_ACTION); 138 139 mIntent = new Intent(intent); 140 assertNotNull(mIntent); 141 assertEquals(TEST_ACTION, mIntent.getAction()); 142 143 mIntent = new Intent(TEST_ACTION); 144 assertNotNull(mIntent); 145 assertEquals(TEST_ACTION, mIntent.getAction()); 146 147 mIntent = new Intent(TEST_ACTION, TEST_URI); 148 assertNotNull(mIntent); 149 assertEquals(TEST_ACTION, mIntent.getAction()); 150 assertEquals(TEST_URI, mIntent.getData()); 151 152 mIntent = new Intent(mContext, MockActivity.class); 153 assertNotNull(mIntent); 154 assertEquals(mComponentName, mIntent.getComponent()); 155 156 mIntent = new Intent(TEST_ACTION, TEST_URI, mContext, MockActivity.class); 157 assertNotNull(mIntent); 158 assertEquals(TEST_ACTION, mIntent.getAction()); 159 assertEquals(TEST_URI, mIntent.getData()); 160 assertEquals(mComponentName, mIntent.getComponent()); 161 } 162 163 @Test testRemoveExtra()164 public void testRemoveExtra() { 165 mIntent = new Intent(); 166 mIntent.putExtra(TEST_EXTRA_NAME, "testvalue"); 167 assertNotNull(mIntent.getStringExtra(TEST_EXTRA_NAME)); 168 mIntent.removeExtra(TEST_EXTRA_NAME); 169 assertNull(mIntent.getStringExtra(TEST_EXTRA_NAME)); 170 } 171 172 @Test testGetCharSequenceExtra()173 public void testGetCharSequenceExtra() { 174 final CharSequence expected = "CharSequencetest"; 175 mIntent.putExtra(TEST_EXTRA_NAME, expected); 176 assertEquals(expected, mIntent.getCharSequenceExtra(TEST_EXTRA_NAME)); 177 } 178 179 @Test 180 @DisabledOnRavenwood(blockedBy = CompatChanges.class) testReadFromParcel()181 public void testReadFromParcel() { 182 mIntent.setAction(TEST_ACTION); 183 mIntent.setData(TEST_URI); 184 mIntent.setType(TEST_TYPE); 185 mIntent.setIdentifier(TEST_IDENTIFIER); 186 mIntent.setFlags(0); 187 mIntent.setComponent(mComponentName); 188 mIntent.addCategory(TEST_CATEGORY); 189 final Parcel parcel = Parcel.obtain(); 190 mIntent.writeToParcel(parcel, 0); 191 parcel.setDataPosition(0); 192 final Intent target = new Intent(); 193 target.readFromParcel(parcel); 194 assertEquals(mIntent.getAction(), target.getAction()); 195 assertEquals(mIntent.getData(), target.getData()); 196 assertEquals(mIntent.getIdentifier(), target.getIdentifier()); 197 assertEquals(mIntent.getFlags(), target.getFlags()); 198 assertEquals(mIntent.getComponent(), target.getComponent()); 199 assertEquals(mIntent.getCategories(), target.getCategories()); 200 assertEquals(mIntent.toURI(), target.toURI()); 201 } 202 203 @Test testGetParcelableArrayListExtra()204 public void testGetParcelableArrayListExtra() { 205 final ArrayList<Intent> expected = new ArrayList<Intent>(); 206 Intent intent = new Intent(TEST_ACTION); 207 expected.add(intent); 208 209 mIntent.putParcelableArrayListExtra(TEST_EXTRA_NAME, expected); 210 final ArrayList<Intent> target = mIntent.getParcelableArrayListExtra(TEST_EXTRA_NAME); 211 assertEquals(expected.size(), target.size()); 212 assertEquals(expected, target); 213 } 214 215 @Test 216 @DisabledOnRavenwood(blockedBy = CompatChanges.class) testGetParcelableArrayListExtraTypeSafe_withMismatchingType_returnsNull()217 public void testGetParcelableArrayListExtraTypeSafe_withMismatchingType_returnsNull() { 218 final ArrayList<TestParcelable> original = new ArrayList<>(); 219 original.add(new TestParcelable(0)); 220 mIntent.putParcelableArrayListExtra(TEST_EXTRA_NAME, original); 221 roundtrip(); 222 assertNull(mIntent.getParcelableArrayListExtra(TEST_EXTRA_NAME, Intent.class)); 223 } 224 225 @Test 226 @DisabledOnRavenwood(blockedBy = CompatChanges.class) testGetParcelableArrayListExtraTypeSafe_withMatchingType_returnsObject()227 public void testGetParcelableArrayListExtraTypeSafe_withMatchingType_returnsObject() { 228 final ArrayList<TestParcelable> original = new ArrayList<>(); 229 original.add(new TestParcelable(0)); 230 original.add(new TestParcelable(1)); 231 mIntent.putParcelableArrayListExtra(TEST_EXTRA_NAME, original); 232 roundtrip(); 233 assertEquals(original, 234 mIntent.getParcelableArrayListExtra(TEST_EXTRA_NAME, TestParcelable.class)); 235 } 236 237 @Test 238 @DisabledOnRavenwood(blockedBy = CompatChanges.class) testGetParcelableArrayListExtraTypeSafe_withBaseType_returnsObject()239 public void testGetParcelableArrayListExtraTypeSafe_withBaseType_returnsObject() { 240 final ArrayList<TestParcelable> original = new ArrayList<>(); 241 original.add(new TestParcelable(0)); 242 original.add(new TestParcelable(1)); 243 mIntent.putParcelableArrayListExtra(TEST_EXTRA_NAME, original); 244 roundtrip(); 245 assertEquals(original, 246 mIntent.getParcelableArrayListExtra(TEST_EXTRA_NAME, Parcelable.class)); 247 } 248 249 @Test testFilterHashCode()250 public void testFilterHashCode() { 251 mIntent.filterHashCode(); 252 } 253 254 @Test testGetCategories()255 public void testGetCategories() { 256 mIntent.addCategory(TEST_CATEGORY); 257 final Set<String> target = mIntent.getCategories(); 258 assertEquals(TEST_CATEGORY, target.toArray()[0]); 259 } 260 261 @Test testGetScheme()262 public void testGetScheme() { 263 assertNull(mIntent.getScheme()); 264 mIntent.setData(TEST_URI); 265 assertEquals(TEST_URI.getScheme(), mIntent.getScheme()); 266 } 267 268 @Test testGetIntegerArrayListExtra()269 public void testGetIntegerArrayListExtra() { 270 final ArrayList<Integer> expected = new ArrayList<Integer>(); 271 expected.add(0); 272 mIntent.putIntegerArrayListExtra(TEST_EXTRA_NAME, expected); 273 assertEquals(expected, mIntent.getIntegerArrayListExtra(TEST_EXTRA_NAME)); 274 } 275 276 @Test testHasExtra()277 public void testHasExtra() { 278 mIntent = new Intent(); 279 assertFalse(mIntent.hasExtra(TEST_EXTRA_NAME)); 280 mIntent.putExtra(TEST_EXTRA_NAME, "test"); 281 assertTrue(mIntent.hasExtra(TEST_EXTRA_NAME)); 282 } 283 284 @Test testGetIntArrayExtra()285 public void testGetIntArrayExtra() { 286 final int[] expected = { 1, 2, 3 }; 287 assertNull(mIntent.getIntArrayExtra(TEST_EXTRA_NAME)); 288 mIntent.putExtra(TEST_EXTRA_NAME, expected); 289 assertEquals(expected, mIntent.getIntArrayExtra(TEST_EXTRA_NAME)); 290 } 291 292 @Test testSetClassName1()293 public void testSetClassName1() { 294 final Intent intent = mIntent.setClassName(mContext, MockActivity.class.getName()); 295 assertEquals(mComponentName, mIntent.getComponent()); 296 assertSame(mIntent, intent); 297 } 298 299 @Test testSetClassName2()300 public void testSetClassName2() { 301 mIntent.setClassName(mContext.getPackageName(), MockActivity.class.getName()); 302 assertEquals(mComponentName, mIntent.getComponent()); 303 } 304 305 @Test testGetIntExtra()306 public void testGetIntExtra() { 307 final int expected = 0; 308 mIntent = new Intent(); 309 assertEquals(expected, mIntent.getIntExtra(TEST_EXTRA_NAME, expected)); 310 mIntent.putExtra(TEST_EXTRA_NAME, 100); 311 assertEquals(100, mIntent.getIntExtra(TEST_EXTRA_NAME, 1)); 312 313 } 314 315 @Test testPutIntegerArrayListExtra()316 public void testPutIntegerArrayListExtra() { 317 final ArrayList<Integer> expected = new ArrayList<Integer>(); 318 expected.add(0); 319 mIntent = new Intent(); 320 mIntent.putIntegerArrayListExtra(TEST_EXTRA_NAME, expected); 321 assertEquals(expected, mIntent.getIntegerArrayListExtra(TEST_EXTRA_NAME)); 322 } 323 324 @Test testAccessType()325 public void testAccessType() { 326 mIntent.setType(TEST_TYPE); 327 assertEquals(TEST_TYPE, mIntent.getType()); 328 } 329 330 @Test testGetBundleExtra()331 public void testGetBundleExtra() { 332 final Bundle expected = new Bundle(); 333 expected.putBoolean("testTrue", true); 334 mIntent.putExtras(expected); 335 mIntent.putExtra(TEST_EXTRA_NAME, expected); 336 337 assertEquals(expected, mIntent.getBundleExtra(TEST_EXTRA_NAME)); 338 } 339 340 @Test testGetCharArrayExtra()341 public void testGetCharArrayExtra() { 342 final char[] expected = { 'a', 'b', 'c' }; 343 mIntent.putExtra(TEST_EXTRA_NAME, expected); 344 final char[] actual= mIntent.getCharArrayExtra(TEST_EXTRA_NAME); 345 assertEquals(expected.length, actual.length); 346 assertEquals(expected[0], actual[0]); 347 assertEquals(expected[1], actual[1]); 348 assertEquals(expected[2], actual[2]); 349 } 350 351 @Test testGetDoubleArrayExtra()352 public void testGetDoubleArrayExtra() { 353 final double[] expected = { 1d, 2d }; 354 mIntent.putExtra(TEST_EXTRA_NAME, expected); 355 assertEquals(expected, mIntent.getDoubleArrayExtra(TEST_EXTRA_NAME)); 356 } 357 358 @Test testPutStringArrayListExtra()359 public void testPutStringArrayListExtra() { 360 final ArrayList<String> expected = new ArrayList<String>(); 361 expected.add("testString"); 362 mIntent.putStringArrayListExtra(TEST_EXTRA_NAME, expected); 363 assertEquals(expected, mIntent.getStringArrayListExtra(TEST_EXTRA_NAME)); 364 } 365 366 @Test 367 @DisabledOnRavenwood(blockedBy = ContentResolver.class) testResolveType1()368 public void testResolveType1() { 369 final ContentResolver contentResolver = mContext.getContentResolver(); 370 assertNull(mIntent.resolveType(mContext)); 371 mIntent.setType(TEST_TYPE); 372 assertEquals(TEST_TYPE, mIntent.resolveType(mContext)); 373 mIntent.setType(null); 374 mIntent.setData(TEST_URI); 375 assertEquals(contentResolver.getType(TEST_URI), mIntent.resolveType(mContext)); 376 mIntent.setData(Uri.parse("test")); 377 assertNull(mIntent.resolveType(mContext)); 378 } 379 380 @Test 381 @DisabledOnRavenwood(blockedBy = ContentResolver.class) testResolveType2()382 public void testResolveType2() { 383 final ContentResolver contentResolver = mContext.getContentResolver(); 384 assertNull(mIntent.resolveType(contentResolver)); 385 mIntent.setType(TEST_TYPE); 386 assertEquals(TEST_TYPE, mIntent.resolveType(contentResolver)); 387 mIntent.setType(null); 388 mIntent.setData(TEST_URI); 389 assertEquals(contentResolver.getType(TEST_URI), mIntent.resolveType(contentResolver)); 390 mIntent.setData(Uri.parse("test")); 391 assertNull(mIntent.resolveType(contentResolver)); 392 } 393 394 @Test testAccessComponent()395 public void testAccessComponent() { 396 mIntent.setComponent(mComponentName); 397 assertEquals(mComponentName, mIntent.getComponent()); 398 } 399 400 @Test testGetDataString()401 public void testGetDataString() { 402 assertNull(mIntent.getDataString()); 403 mIntent.setData(TEST_URI); 404 assertEquals(TEST_URI.toString(), mIntent.getDataString()); 405 } 406 407 @Test testGetIdentifer()408 public void testGetIdentifer() { 409 assertNull(mIntent.getIdentifier()); 410 mIntent.setIdentifier(TEST_IDENTIFIER); 411 assertEquals(TEST_IDENTIFIER, mIntent.getIdentifier()); 412 } 413 414 @Test testHasCategory()415 public void testHasCategory() { 416 assertFalse(mIntent.hasCategory(TEST_CATEGORY)); 417 mIntent.addCategory(TEST_CATEGORY); 418 assertTrue(mIntent.hasCategory(TEST_CATEGORY)); 419 } 420 421 @Test testGetLongArrayExtra()422 public void testGetLongArrayExtra() { 423 final long[] expected = { 1l, 2l, 3l }; 424 mIntent.putExtra(TEST_EXTRA_NAME, expected); 425 assertEquals(expected, mIntent.getLongArrayExtra(TEST_EXTRA_NAME)); 426 } 427 428 @Test 429 @DisabledOnRavenwood(blockedBy = PackageManager.class) testParseIntent()430 public void testParseIntent() throws XmlPullParserException, IOException, 431 NameNotFoundException { 432 mIntent = null; 433 XmlResourceParser parser = null; 434 AttributeSet attrs = null; 435 ActivityInfo ai = null; 436 try { 437 mIntent = Intent.parseIntent(mContext.getResources(), parser, attrs); 438 fail("should thow exception!"); 439 } catch (NullPointerException e) { 440 // expected 441 } 442 443 ai = mContext.getPackageManager().getActivityInfo( 444 new ComponentName(TEST_PACKAGE, TEST_ACTIVITY), 445 PackageManager.GET_META_DATA); 446 parser = ai.loadXmlMetaData(mContext.getPackageManager(), "android.app.intent"); 447 448 attrs = Xml.asAttributeSet(parser); 449 int type; 450 while ((type = parser.next()) != XmlPullParser.END_DOCUMENT 451 && type != XmlPullParser.START_TAG) { 452 } 453 454 String nodeName = parser.getName(); 455 if (!"alias".equals(nodeName)) { 456 throw new RuntimeException(); 457 } 458 459 int outerDepth = parser.getDepth(); 460 while ((type = parser.next()) != XmlPullParser.END_DOCUMENT 461 && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) { 462 if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) { 463 continue; 464 } 465 466 nodeName = parser.getName(); 467 if ("intent".equals(nodeName)) { 468 mIntent = Intent.parseIntent(mContext.getResources(), parser, attrs); 469 } else { 470 XmlUtils.skipCurrentTag(parser); 471 } 472 } 473 474 assertNotNull(mIntent); 475 assertEquals("android.intent.action.MAIN", mIntent.getAction()); 476 assertEquals(Uri.parse("http://www.google.com/"), mIntent.getData()); 477 assertEquals("something/something", mIntent.getType()); 478 assertEquals("testIdentifier", mIntent.getIdentifier()); 479 assertEquals(2, mIntent.getCategories().size()); 480 assertTrue(mIntent.hasCategory("some.category")); 481 assertTrue(mIntent.hasCategory("some.other.category")); 482 assertEquals(1, mIntent.getIntExtra("an_int", 0)); 483 assertEquals(2, mIntent.getIntExtra("another_int", 0)); 484 assertEquals(true, mIntent.getBooleanExtra("an_boolean", false)); 485 assertEquals(false, mIntent.getBooleanExtra("another_boolean", true)); 486 assertEquals(1.1f, mIntent.getFloatExtra("an_float", 0), Float.MIN_NORMAL); 487 assertEquals(2.2f, mIntent.getFloatExtra("another_float", 0), Float.MIN_NORMAL); 488 assertEquals("one", mIntent.getStringExtra("an_string")); 489 assertEquals("two", mIntent.getStringExtra("another_string")); 490 } 491 492 @Test testSetClass()493 public void testSetClass() { 494 assertNull(mIntent.getComponent()); 495 mIntent.setClass(mContext, MockActivity.class); 496 assertEquals(mComponentName, mIntent.getComponent()); 497 } 498 499 @Test 500 @DisabledOnRavenwood(blockedBy = ContentResolver.class) testResolveTypeIfNeeded()501 public void testResolveTypeIfNeeded() { 502 ContentResolver contentResolver = mContext.getContentResolver(); 503 assertNull(mIntent.resolveTypeIfNeeded(contentResolver)); 504 mIntent.setType(TEST_TYPE); 505 assertEquals(TEST_TYPE, mIntent.resolveTypeIfNeeded(contentResolver)); 506 507 mIntent.setType(null); 508 mIntent.setComponent(mComponentName); 509 assertEquals(null, mIntent.resolveTypeIfNeeded(contentResolver)); 510 511 mIntent.setType(TEST_TYPE); 512 mIntent.setComponent(mComponentName); 513 assertEquals(TEST_TYPE, mIntent.resolveTypeIfNeeded(contentResolver)); 514 515 mIntent.setType(null); 516 mIntent.setData(TEST_URI); 517 assertNull(mIntent.resolveTypeIfNeeded(contentResolver)); 518 } 519 520 @Test testPutExtra1()521 public void testPutExtra1() { 522 assertFalse(mIntent.getBooleanExtra(TEST_EXTRA_NAME, false)); 523 mIntent.putExtra(TEST_EXTRA_NAME, true); 524 assertTrue(mIntent.getBooleanExtra(TEST_EXTRA_NAME, false)); 525 mIntent.putExtra(TEST_EXTRA_NAME, false); 526 assertFalse(mIntent.getBooleanExtra(TEST_EXTRA_NAME, false)); 527 } 528 529 @Test testPutExtra2()530 public void testPutExtra2() { 531 final byte expected = Byte.valueOf("1"); 532 mIntent.putExtra(TEST_EXTRA_NAME, expected); 533 assertEquals(expected, mIntent.getByteExtra(TEST_EXTRA_NAME, Byte.valueOf("1"))); 534 } 535 536 @Test testPutExtra3()537 public void testPutExtra3() { 538 assertEquals('a', mIntent.getCharExtra(TEST_EXTRA_NAME, 'a')); 539 final char expected = 'a'; 540 mIntent.putExtra(TEST_EXTRA_NAME, expected); 541 assertEquals(expected, mIntent.getCharExtra(TEST_EXTRA_NAME, 'a')); 542 } 543 544 @Test testPutExtra4()545 public void testPutExtra4() { 546 final Short expected = Short.valueOf("2"); 547 assertEquals(Short.valueOf("1").shortValue(), mIntent.getShortExtra( 548 TEST_EXTRA_NAME, Short.valueOf("1"))); 549 mIntent.putExtra(TEST_EXTRA_NAME, expected); 550 assertEquals(expected.shortValue(), mIntent.getShortExtra(TEST_EXTRA_NAME, Short.valueOf("1"))); 551 } 552 553 @Test testPutExtra5()554 public void testPutExtra5() { 555 final int expected = 2; 556 assertEquals(1, mIntent.getIntExtra(TEST_EXTRA_NAME, 1)); 557 mIntent.putExtra(TEST_EXTRA_NAME, expected); 558 assertEquals(expected, mIntent.getIntExtra(TEST_EXTRA_NAME, 1)); 559 } 560 561 @Test testPutExtra6()562 public void testPutExtra6() { 563 final long expected = 2l; 564 assertEquals(1l, mIntent.getLongExtra(TEST_EXTRA_NAME, 1l)); 565 mIntent.putExtra(TEST_EXTRA_NAME, expected); 566 assertEquals(expected, mIntent.getLongExtra(TEST_EXTRA_NAME, 1l)); 567 } 568 569 @Test testPutExtra7()570 public void testPutExtra7() { 571 final float expected = 2f; 572 assertEquals(1f, mIntent.getFloatExtra(TEST_EXTRA_NAME, 1f), DELTA_FLOAT); 573 mIntent.putExtra(TEST_EXTRA_NAME, expected); 574 assertEquals(expected, mIntent.getFloatExtra(TEST_EXTRA_NAME, 1f), DELTA_FLOAT); 575 } 576 577 @Test testPutExtra8()578 public void testPutExtra8() { 579 final double expected = 2d; 580 assertEquals(1d, mIntent.getDoubleExtra(TEST_EXTRA_NAME, 1d), DELTA_DOUBLE); 581 mIntent.putExtra(TEST_EXTRA_NAME, expected); 582 assertEquals(expected, mIntent.getDoubleExtra(TEST_EXTRA_NAME, 1d), DELTA_DOUBLE); 583 } 584 585 @Test testPutExtra9()586 public void testPutExtra9() { 587 final String expected = "testString"; 588 assertNull(mIntent.getStringExtra(TEST_EXTRA_NAME)); 589 mIntent.putExtra(TEST_EXTRA_NAME, expected); 590 assertEquals(expected, mIntent.getStringExtra(TEST_EXTRA_NAME)); 591 } 592 593 @Test testPutExtra10()594 public void testPutExtra10() { 595 final CharSequence expected = "testString"; 596 assertNull(mIntent.getCharSequenceExtra(TEST_EXTRA_NAME)); 597 mIntent.putExtra(TEST_EXTRA_NAME, expected); 598 assertEquals(expected, mIntent.getCharSequenceExtra(TEST_EXTRA_NAME)); 599 } 600 601 @Test testPutExtra11()602 public void testPutExtra11() { 603 final Intent expected = new Intent(TEST_ACTION); 604 mIntent.putExtra(TEST_EXTRA_NAME, expected); 605 assertEquals(expected, mIntent.getParcelableExtra(TEST_EXTRA_NAME)); 606 } 607 608 @Test testPutExtra12()609 public void testPutExtra12() { 610 final Intent[] expected = { new Intent(TEST_ACTION), new Intent(mContext, MockActivity.class) }; 611 mIntent.putExtra(TEST_EXTRA_NAME, expected); 612 assertEquals(expected, mIntent.getParcelableArrayExtra(TEST_EXTRA_NAME)); 613 } 614 615 @Test testPutExtra13()616 public void testPutExtra13() { 617 final TestSerializable expected = new TestSerializable(); 618 expected.Name = "testName"; 619 mIntent.putExtra(TEST_EXTRA_NAME, expected); 620 assertEquals(expected, mIntent.getSerializableExtra(TEST_EXTRA_NAME)); 621 TestSerializable target = (TestSerializable) mIntent.getSerializableExtra(TEST_EXTRA_NAME); 622 assertEquals(expected.Name, target.Name); 623 } 624 625 @Test testPutExtra14()626 public void testPutExtra14() { 627 final boolean[] expected = { true, true, false }; 628 mIntent.putExtra(TEST_EXTRA_NAME, expected); 629 assertEquals(expected, mIntent.getBooleanArrayExtra(TEST_EXTRA_NAME)); 630 } 631 632 @Test testPutExtra15()633 public void testPutExtra15() { 634 final byte[] expected = TEST_ACTION.getBytes(); 635 mIntent.putExtra(TEST_EXTRA_NAME, expected); 636 assertEquals(expected, mIntent.getByteArrayExtra(TEST_EXTRA_NAME)); 637 } 638 639 @Test testPutExtra16()640 public void testPutExtra16() { 641 final short[] expected = { 1, 2, 3 }; 642 mIntent.putExtra(TEST_EXTRA_NAME, expected); 643 assertEquals(expected, mIntent.getShortArrayExtra(TEST_EXTRA_NAME)); 644 } 645 646 @Test testPutExtra17()647 public void testPutExtra17() { 648 final char[] expected = { '1', '2', '3' }; 649 mIntent.putExtra(TEST_EXTRA_NAME, expected); 650 assertEquals(expected, mIntent.getCharArrayExtra(TEST_EXTRA_NAME)); 651 } 652 653 @Test testPutExtra18()654 public void testPutExtra18() { 655 final int[] expected = { 1, 2, 3 }; 656 mIntent.putExtra(TEST_EXTRA_NAME, expected); 657 assertEquals(expected, mIntent.getIntArrayExtra(TEST_EXTRA_NAME)); 658 } 659 660 @Test testPutExtra19()661 public void testPutExtra19() { 662 final long[] expected = { 1l, 2l, 3l }; 663 mIntent.putExtra(TEST_EXTRA_NAME, expected); 664 assertEquals(expected, mIntent.getLongArrayExtra(TEST_EXTRA_NAME)); 665 } 666 667 @Test testPutExtra20()668 public void testPutExtra20() { 669 final float[] expected = { 1f, 2f, 3f }; 670 mIntent.putExtra(TEST_EXTRA_NAME, expected); 671 assertEquals(expected, mIntent.getFloatArrayExtra(TEST_EXTRA_NAME)); 672 } 673 674 @Test testPutExtra21()675 public void testPutExtra21() { 676 final double[] expected = { 1d, 2d, 3d }; 677 mIntent.putExtra(TEST_EXTRA_NAME, expected); 678 assertEquals(expected, mIntent.getDoubleArrayExtra(TEST_EXTRA_NAME)); 679 } 680 681 @Test testPutExtra22()682 public void testPutExtra22() { 683 final String[] expected = { "1d", "2d", "3d" }; 684 mIntent.putExtra(TEST_EXTRA_NAME, expected); 685 assertEquals(expected, mIntent.getStringArrayExtra(TEST_EXTRA_NAME)); 686 } 687 688 @Test testPutExtra23()689 public void testPutExtra23() { 690 final Bundle expected = new Bundle(); 691 expected.putString("key", "value"); 692 mIntent.putExtra(TEST_EXTRA_NAME, expected); 693 assertEquals(expected, mIntent.getBundleExtra(TEST_EXTRA_NAME)); 694 } 695 696 @Test 697 @SuppressWarnings("deprecation") testPutExtra24()698 public void testPutExtra24() { 699 final IBinder expected = new Binder(); 700 mIntent.putExtra(TEST_EXTRA_NAME, expected); 701 assertEquals(expected, mIntent.getIBinderExtra(TEST_EXTRA_NAME)); 702 } 703 704 @Test testAddCategory()705 public void testAddCategory() { 706 assertFalse(mIntent.hasCategory(TEST_CATEGORY)); 707 mIntent.addCategory(TEST_CATEGORY); 708 assertTrue(mIntent.hasCategory(TEST_CATEGORY)); 709 } 710 711 @Test testPutParcelableArrayListExtra()712 public void testPutParcelableArrayListExtra() { 713 ArrayList<Intent> expected = new ArrayList<Intent>(); 714 mIntent.putExtra(TEST_EXTRA_NAME, expected); 715 assertEquals(expected, mIntent.getParcelableArrayListExtra(TEST_EXTRA_NAME)); 716 } 717 718 @Test testToString()719 public void testToString() { 720 assertNotNull(mIntent.toString()); 721 } 722 723 @Test testAccessData()724 public void testAccessData() { 725 mIntent.setData(TEST_URI); 726 assertEquals(TEST_URI, mIntent.getData()); 727 } 728 729 @Test testSetExtrasClassLoader()730 public void testSetExtrasClassLoader() { 731 } 732 733 @Test testGetStringArrayListExtra()734 public void testGetStringArrayListExtra() { 735 final ArrayList<String> expected = new ArrayList<String>(); 736 expected.add("testString"); 737 mIntent.putStringArrayListExtra(TEST_EXTRA_NAME, expected); 738 assertEquals(expected, mIntent.getStringArrayListExtra(TEST_EXTRA_NAME)); 739 } 740 741 @Test testGetCharSequenceArrayListExtra()742 public void testGetCharSequenceArrayListExtra() { 743 final ArrayList<CharSequence> expected = new ArrayList<CharSequence>(); 744 expected.add("testCharSequence"); 745 mIntent.putCharSequenceArrayListExtra(TEST_EXTRA_NAME, expected); 746 assertEquals(expected, mIntent.getCharSequenceArrayListExtra(TEST_EXTRA_NAME)); 747 } 748 749 @Test 750 @DisabledOnRavenwood(blockedBy = PackageManager.class) testResolveActivityInfo()751 public void testResolveActivityInfo() throws NameNotFoundException { 752 ComponentName componentName = new 753 ComponentName(TEST_PACKAGE, TEST_ACTIVITY); 754 final PackageManager pm = mContext.getPackageManager(); 755 assertEquals(null, mIntent.resolveActivityInfo(pm, 1)); 756 mIntent.setComponent(componentName); 757 ActivityInfo target = null; 758 759 target = pm.getActivityInfo(componentName, 1); 760 assertEquals(target.targetActivity, mIntent.resolveActivityInfo(pm, 1).targetActivity); 761 } 762 763 @Test testGetParcelableExtra()764 public void testGetParcelableExtra() { 765 final Intent expected = new Intent(TEST_ACTION); 766 mIntent.putExtra(TEST_EXTRA_NAME, expected); 767 assertEquals(expected, mIntent.getParcelableExtra(TEST_EXTRA_NAME)); 768 } 769 770 @Test testGetParcelableExtraTypeSafe_withMismatchingType_returnsNull()771 public void testGetParcelableExtraTypeSafe_withMismatchingType_returnsNull() { 772 mIntent.putExtra(TEST_EXTRA_NAME, new TestParcelable(42)); 773 assertNull(mIntent.getParcelableExtra(TEST_EXTRA_NAME, Intent.class)); 774 } 775 776 @Test testGetParcelableExtraTypeSafe_withMatchingType_returnsObject()777 public void testGetParcelableExtraTypeSafe_withMatchingType_returnsObject() { 778 final TestParcelable original = new TestParcelable(42); 779 mIntent.putExtra(TEST_EXTRA_NAME, original); 780 assertEquals(original, mIntent.getParcelableExtra(TEST_EXTRA_NAME, TestParcelable.class)); 781 } 782 783 @Test testGetParcelableExtraTypeSafe_withBaseType_returnsObject()784 public void testGetParcelableExtraTypeSafe_withBaseType_returnsObject() { 785 final TestParcelable original = new TestParcelable(42); 786 mIntent.putExtra(TEST_EXTRA_NAME, original); 787 assertEquals(original, mIntent.getParcelableExtra(TEST_EXTRA_NAME, Parcelable.class)); 788 } 789 790 @Test testAccessAction()791 public void testAccessAction() { 792 mIntent.setAction(TEST_ACTION); 793 assertEquals(TEST_ACTION, mIntent.getAction()); 794 } 795 796 @Test testAddFlags()797 public void testAddFlags() { 798 final int flag = 1; 799 int expected = 0; 800 mIntent.addFlags(flag); 801 expected |= flag; 802 assertEquals(expected, mIntent.getFlags()); 803 } 804 805 @Test testAddExtendedFlags()806 public void testAddExtendedFlags() { 807 final int flag = 1; 808 long expected = 0; 809 mIntent.addExtendedFlags(flag); 810 expected |= flag; 811 assertEquals(expected, mIntent.getExtendedFlags()); 812 } 813 814 @Test 815 @RequiresFlagsEnabled(android.security.Flags.FLAG_ENFORCE_INTENT_FILTER_MATCH) testIsMismatchingFilter()816 public void testIsMismatchingFilter() { 817 assertFalse(mIntent.isMismatchingFilter()); 818 mIntent.addExtendedFlags(Intent.EXTENDED_FLAG_FILTER_MISMATCH); 819 assertTrue(mIntent.isMismatchingFilter()); 820 } 821 822 @Test testDescribeContents()823 public void testDescribeContents() { 824 final int expected = 0; 825 assertEquals(expected, mIntent.describeContents()); 826 mIntent.putExtra(TEST_EXTRA_NAME, "test"); 827 assertEquals(mIntent.getExtras().describeContents(), mIntent.describeContents()); 828 } 829 830 @Test testGetShortExtra()831 public void testGetShortExtra() { 832 833 final Short expected = Short.valueOf("2"); 834 assertEquals(Short.valueOf("1").shortValue(), mIntent.getShortExtra( 835 TEST_EXTRA_NAME, Short.valueOf("1"))); 836 mIntent.putExtra(TEST_EXTRA_NAME, expected); 837 assertEquals(expected.shortValue(), mIntent.getShortExtra(TEST_EXTRA_NAME, Short.valueOf("1"))); 838 } 839 840 @Test testClone()841 public void testClone() { 842 mIntent.setAction(TEST_ACTION); 843 mIntent.setClass(mContext, MockActivity.class); 844 mIntent.setComponent(mComponentName); 845 mIntent.setDataAndType(TEST_URI, TEST_TYPE); 846 mIntent.setIdentifier(TEST_IDENTIFIER); 847 mIntent.addCategory(TEST_CATEGORY); 848 final String key = "testkey"; 849 final String excepted = "testValue"; 850 mIntent.putExtra(key, excepted); 851 Intent actual = (Intent) mIntent.clone(); 852 assertEquals(mComponentName, actual.getComponent()); 853 assertEquals(TEST_ACTION, actual.getAction()); 854 assertEquals(mComponentName, actual.getComponent()); 855 assertEquals(TEST_URI, actual.getData()); 856 assertEquals(TEST_TYPE, actual.getType()); 857 assertEquals(TEST_IDENTIFIER, actual.getIdentifier()); 858 assertEquals(TEST_CATEGORY, (String) (actual.getCategories().toArray()[0])); 859 assertEquals(excepted, actual.getStringExtra(key)); 860 } 861 862 @Test testGetDoubleExtra()863 public void testGetDoubleExtra() { 864 final double expected = 2d; 865 assertEquals(1d, mIntent.getDoubleExtra(TEST_EXTRA_NAME, 1d), DELTA_DOUBLE); 866 mIntent.putExtra(TEST_EXTRA_NAME, expected); 867 assertEquals(expected, mIntent.getDoubleExtra(TEST_EXTRA_NAME, 1d), DELTA_DOUBLE); 868 } 869 870 @Test testCloneFilter()871 public void testCloneFilter() { 872 mIntent.setAction(TEST_ACTION); 873 mIntent.setClass(mContext, MockActivity.class); 874 mIntent.setComponent(mComponentName); 875 mIntent.setDataAndType(TEST_URI, TEST_TYPE); 876 mIntent.setIdentifier(TEST_IDENTIFIER); 877 mIntent.addCategory(TEST_CATEGORY); 878 final String key = "testkey"; 879 mIntent.putExtra(key, "testValue"); 880 Intent actual = mIntent.cloneFilter(); 881 assertEquals(mComponentName, actual.getComponent()); 882 assertEquals(TEST_ACTION, actual.getAction()); 883 assertEquals(mComponentName, actual.getComponent()); 884 assertEquals(TEST_URI, actual.getData()); 885 assertEquals(TEST_TYPE, actual.getType()); 886 assertEquals(TEST_IDENTIFIER, actual.getIdentifier()); 887 assertEquals(TEST_CATEGORY, (String) (actual.getCategories().toArray()[0])); 888 assertNull(actual.getStringExtra(key)); 889 } 890 891 @Test testGetIntentOld()892 public void testGetIntentOld() throws URISyntaxException { 893 String uri = "test"; 894 mIntent = Intent.getIntentOld(uri); 895 assertEquals(Intent.ACTION_VIEW, mIntent.getAction()); 896 897 mIntent = null; 898 try { 899 uri = "test#action(test)categories(test)type(mtype)launchFlags(test)extras(test"; 900 mIntent = Intent.getIntentOld(uri); 901 fail("should throw URISyntaxException."); 902 } catch (Exception e) { 903 // expected 904 } 905 906 final String compnent = 907 "component(" + mContext.getPackageName() + "!" + MockActivity.class.getName() + ")"; 908 uri = "testdata#action(test)categories(test!test2)type(mtype)launchFlags(5)" + compnent 909 + "extras(Stest=testString!btestbyte=1!" 910 + "Btestboolean=true!ctestchar=a!dtestdouble=1d!" 911 + "itestint=1!ltestlong=1!stestshort=1!ftestfloat=1f)"; 912 mIntent = Intent.getIntentOld(uri); 913 assertEquals("test", mIntent.getAction()); 914 assertEquals("testdata", mIntent.getData().toString()); 915 assertEquals(mComponentName, mIntent.getComponent()); 916 assertEquals("test", (String) (mIntent.getCategories().toArray()[0])); 917 assertEquals("mtype", mIntent.getType()); 918 assertEquals(4, mIntent.getFlags()); 919 assertEquals("testString", mIntent.getStringExtra("test")); 920 assertTrue(mIntent.getBooleanExtra("testboolean", false)); 921 final byte b = 1; 922 final byte defaulttByte = 2; 923 assertEquals(b, mIntent.getByteExtra("testbyte", defaulttByte)); 924 assertEquals('a', mIntent.getCharExtra("testchar", 'b')); 925 final float testFloat = 1f; 926 assertEquals(testFloat, mIntent.getFloatExtra("testfloat", 2f), DELTA_FLOAT); 927 final double testDouble = 1d; 928 assertEquals(testDouble, mIntent.getDoubleExtra("testdouble", 2d), DELTA_DOUBLE); 929 930 final long testLong = 1; 931 assertEquals(testLong, mIntent.getLongExtra("testlong", 2l)); 932 933 final short testShort = 1; 934 final short defaultShort = 2; 935 assertEquals(testShort, mIntent.getShortExtra("testshort", defaultShort)); 936 assertEquals(1, mIntent.getIntExtra("testint", 2)); 937 } 938 939 @Test testGetParcelableArrayExtra()940 public void testGetParcelableArrayExtra() { 941 final Intent[] expected = { new Intent(TEST_ACTION), new Intent(mContext, MockActivity.class) }; 942 mIntent.putExtra(TEST_EXTRA_NAME, expected); 943 assertArrayEquals(expected, mIntent.getParcelableArrayExtra(TEST_EXTRA_NAME)); 944 } 945 946 @Test 947 @DisabledOnRavenwood(blockedBy = CompatChanges.class) testGetParcelableArrayExtraTypeSafe_withMismatchingType_returnsNull()948 public void testGetParcelableArrayExtraTypeSafe_withMismatchingType_returnsNull() { 949 mIntent.putExtra(TEST_EXTRA_NAME, new TestParcelable[] {new TestParcelable(42)}); 950 roundtrip(); 951 assertNull(mIntent.getParcelableArrayExtra(TEST_EXTRA_NAME, Intent.class)); 952 } 953 954 @Test 955 @DisabledOnRavenwood(blockedBy = CompatChanges.class) testGetParcelableArrayExtraTypeSafe_withMatchingType_returnsObject()956 public void testGetParcelableArrayExtraTypeSafe_withMatchingType_returnsObject() { 957 final TestParcelable[] original = { new TestParcelable(1), new TestParcelable(2) }; 958 mIntent.putExtra(TEST_EXTRA_NAME, original); 959 roundtrip(); 960 assertArrayEquals(original, 961 mIntent.getParcelableArrayExtra(TEST_EXTRA_NAME, TestParcelable.class)); 962 } 963 964 @Test 965 @DisabledOnRavenwood(blockedBy = CompatChanges.class) testGetParcelableArrayExtraTypeSafe_withBaseType_returnsObject()966 public void testGetParcelableArrayExtraTypeSafe_withBaseType_returnsObject() { 967 final TestParcelable[] original = { new TestParcelable(1), new TestParcelable(2) }; 968 mIntent.putExtra(TEST_EXTRA_NAME, original); 969 roundtrip(); 970 assertArrayEquals(original, 971 mIntent.getParcelableArrayExtra(TEST_EXTRA_NAME, Parcelable.class)); 972 } 973 974 @Test 975 @DisabledOnRavenwood(blockedBy = PackageManager.class) testResolveActivityEmpty()976 public void testResolveActivityEmpty() { 977 final Intent emptyIntent = new Intent(); 978 979 // Empty intent shouldn't resolve to anything 980 final ComponentName target = emptyIntent.resolveActivity(mPm); 981 assertNull(target); 982 } 983 984 @Test 985 @DisabledOnRavenwood(blockedBy = PackageManager.class) testResolveActivitySingleMatch()986 public void testResolveActivitySingleMatch() { 987 final Intent intent = new Intent("android.content.cts.action.TEST_ACTION"); 988 intent.addCategory("android.content.cts.category.TEST_CATEGORY"); 989 990 // Should only have one activity responding to narrow category 991 final ComponentName target = intent.resolveActivity(mPm); 992 assertEquals(TEST_PACKAGE, target.getPackageName()); 993 assertEquals(TEST_ACTIVITY, target.getClassName()); 994 } 995 996 @Test 997 @DisabledOnRavenwood(blockedBy = PackageManager.class) testResolveActivityShortcutMatch()998 public void testResolveActivityShortcutMatch() { 999 final Intent intent = new Intent("android.content.cts.action.TEST_ACTION"); 1000 intent.setComponent( 1001 new ComponentName(TEST_PACKAGE, "android.content.cts.MockActivity2")); 1002 1003 // Multiple activities match, but we asked for explicit component 1004 final ComponentName target = intent.resolveActivity(mPm); 1005 assertEquals(TEST_PACKAGE, target.getPackageName()); 1006 assertEquals("android.content.cts.MockActivity2", target.getClassName()); 1007 } 1008 1009 @AppModeFull 1010 @Test 1011 @DisabledOnRavenwood(blockedBy = PackageManager.class) testResolveActivityMultipleMatch()1012 public void testResolveActivityMultipleMatch() { 1013 final Intent intent = new Intent("android.content.cts.action.TEST_ACTION"); 1014 1015 // Should have multiple activities, resulting in resolver dialog 1016 final ComponentName target = intent.resolveActivity(mPm); 1017 final String pkgName = target.getPackageName(); 1018 assertFalse(TEST_PACKAGE.equals(pkgName)); 1019 1020 // Whoever they are must be able to set preferred activities 1021 if (!"android".equals(pkgName)) { 1022 if (mPm.checkPermission(android.Manifest.permission.SET_PREFERRED_APPLICATIONS, pkgName) 1023 != PackageManager.PERMISSION_GRANTED) { 1024 fail("Resolved target " + target 1025 + " doesn't have SET_PREFERRED_APPLICATIONS permission"); 1026 } 1027 } 1028 } 1029 1030 @Test testGetCharExtra()1031 public void testGetCharExtra() { 1032 assertEquals('a', mIntent.getCharExtra(TEST_EXTRA_NAME, 'a')); 1033 final char expected = 'b'; 1034 mIntent.putExtra(TEST_EXTRA_NAME, expected); 1035 assertEquals(expected, mIntent.getCharExtra(TEST_EXTRA_NAME, 'a')); 1036 } 1037 1038 @Test testGetIntent()1039 public void testGetIntent() throws URISyntaxException { 1040 mIntent = Intent.getIntent("test#"); 1041 assertEquals(Intent.ACTION_VIEW, mIntent.getAction()); 1042 1043 try { 1044 String uri = "#Intent;action=android.content.IntentTest_test;" 1045 + "category=testCategory;type=testtype;identifier=testident;launchFlags=0x1;" 1046 + "component=com.android/.app.MockActivity;K.testExtraName=1;end"; 1047 mIntent = Intent.getIntent(uri); 1048 fail("should throw URISyntaxException."); 1049 } catch (Exception e) { 1050 // expected 1051 } 1052 mIntent = new Intent(); 1053 1054 String uri = mIntent.toURI(); 1055 Intent target = Intent.getIntent(uri); 1056 assertEquals(Intent.ACTION_VIEW, target.getAction()); 1057 1058 mIntent.setAction(TEST_ACTION); 1059 uri = mIntent.toURI(); 1060 target = Intent.getIntent(uri); 1061 assertEquals(TEST_ACTION, target.getAction()); 1062 1063 mIntent.setData(TEST_URI); 1064 uri = mIntent.toURI(); 1065 target = Intent.getIntent(uri); 1066 assertEquals(TEST_URI, target.getData()); 1067 1068 mIntent.setComponent(mComponentName); 1069 uri = mIntent.toURI(); 1070 target = Intent.getIntent(uri); 1071 assertEquals(mComponentName, target.getComponent()); 1072 1073 mIntent.addCategory(TEST_CATEGORY); 1074 uri = mIntent.toURI(); 1075 target = Intent.getIntent(uri); 1076 assertEquals(1, target.getCategories().size()); 1077 assertEquals(TEST_CATEGORY, (String) (target.getCategories().toArray()[0])); 1078 1079 mIntent.setType(TEST_TYPE); 1080 uri = mIntent.toURI(); 1081 target = Intent.getIntent(uri); 1082 assertEquals(TEST_TYPE, target.getType()); 1083 1084 mIntent.setIdentifier(TEST_IDENTIFIER); 1085 uri = mIntent.toURI(); 1086 target = Intent.getIntent(uri); 1087 assertEquals(TEST_IDENTIFIER, target.getIdentifier()); 1088 1089 mIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT 1090 | Intent.FLAG_GRANT_WRITE_URI_PERMISSION | Intent.FLAG_GRANT_READ_URI_PERMISSION 1091 | Intent.FLAG_GRANT_PREFIX_URI_PERMISSION 1092 | Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION); 1093 uri = mIntent.toURI(); 1094 target = Intent.getIntent(uri); 1095 assertEquals(Intent.FLAG_ACTIVITY_NEW_DOCUMENT, target.getFlags()); 1096 1097 String stringValue = "testString"; 1098 mIntent.putExtra(TEST_EXTRA_NAME, stringValue); 1099 uri = mIntent.toURI(); 1100 target = Intent.getIntent(uri); 1101 assertEquals(stringValue, target.getStringExtra(TEST_EXTRA_NAME)); 1102 1103 mIntent.putExtra(TEST_EXTRA_NAME, true); 1104 uri = mIntent.toURI(); 1105 target = Intent.getIntent(uri); 1106 assertTrue(target.getBooleanExtra(TEST_EXTRA_NAME, false)); 1107 1108 final byte b = 1; 1109 mIntent.putExtra(TEST_EXTRA_NAME, b); 1110 1111 uri = mIntent.toURI(); 1112 target = Intent.getIntent(uri); 1113 final byte defaulttByte = 2; 1114 assertEquals(b, target.getByteExtra(TEST_EXTRA_NAME, defaulttByte)); 1115 1116 final char testChar = 'a'; 1117 mIntent.putExtra(TEST_EXTRA_NAME, testChar); 1118 uri = mIntent.toURI(); 1119 target = Intent.getIntent(uri); 1120 assertEquals(testChar, target.getCharExtra(TEST_EXTRA_NAME, 'b')); 1121 1122 final double testDouble = 1; 1123 mIntent.putExtra(TEST_EXTRA_NAME, testDouble); 1124 uri = mIntent.toURI(); 1125 target = Intent.getIntent(uri); 1126 assertEquals(testDouble, target.getDoubleExtra(TEST_EXTRA_NAME, 2), DELTA_DOUBLE); 1127 1128 final int testInt = 1; 1129 mIntent.putExtra(TEST_EXTRA_NAME, testInt); 1130 uri = mIntent.toURI(); 1131 target = Intent.getIntent(uri); 1132 assertEquals(testInt, target.getIntExtra(TEST_EXTRA_NAME, 2)); 1133 1134 final long testLong = 1l; 1135 mIntent.putExtra(TEST_EXTRA_NAME, testLong); 1136 uri = mIntent.toURI(); 1137 target = Intent.getIntent(uri); 1138 assertEquals(testLong, target.getLongExtra(TEST_EXTRA_NAME, 2l)); 1139 1140 final short testShort = 1; 1141 final short defaultShort = 2; 1142 mIntent.putExtra(TEST_EXTRA_NAME, testShort); 1143 uri = mIntent.toURI(); 1144 target = Intent.getIntent(uri); 1145 assertEquals(testShort, target.getShortExtra(TEST_EXTRA_NAME, defaultShort)); 1146 } 1147 1148 @Test testToURI()1149 public void testToURI() { 1150 mIntent = new Intent(); 1151 assertEquals("", mIntent.toURI()); 1152 1153 mIntent.setData(TEST_URI); 1154 assertTrue(mIntent.toURI().indexOf(TEST_URI.toString()) != -1); 1155 1156 mIntent.setAction(TEST_ACTION); 1157 assertTrue(mIntent.toURI().indexOf("action=" + TEST_ACTION) != -1); 1158 1159 mIntent.addCategory(TEST_CATEGORY); 1160 assertTrue(mIntent.toURI().indexOf("category=") != -1); 1161 1162 mIntent.setType(TEST_TYPE); 1163 assertTrue(mIntent.toURI().indexOf("type=" + TEST_TYPE) != -1); 1164 1165 mIntent.setIdentifier(TEST_IDENTIFIER); 1166 assertTrue(mIntent.toURI().indexOf("identifier=" + TEST_IDENTIFIER) != -1); 1167 1168 mIntent.setFlags(1); 1169 assertFalse(mIntent.toURI().indexOf("launchFlags=" + Integer.toHexString(1)) != -1); 1170 1171 mIntent.setComponent(mComponentName); 1172 assertTrue(mIntent.toURI().indexOf( 1173 "component=" + mComponentName.flattenToShortString()) != -1); 1174 1175 final String stringValue = "testString"; 1176 mIntent.putExtra(TEST_EXTRA_NAME, stringValue); 1177 1178 assertTrue(mIntent.toURI().indexOf(getString("S", TEST_EXTRA_NAME, stringValue)) != -1); 1179 1180 mIntent.putExtra(TEST_EXTRA_NAME, true); 1181 1182 assertTrue(mIntent.toURI().indexOf(getString("B", TEST_EXTRA_NAME, true)) != -1); 1183 1184 final byte b = 1; 1185 mIntent.putExtra(TEST_EXTRA_NAME, b); 1186 assertTrue(mIntent.toURI().indexOf(getString("b", TEST_EXTRA_NAME, b)) != -1); 1187 1188 final Character testChar = 'a'; 1189 mIntent.putExtra(TEST_EXTRA_NAME, testChar); 1190 1191 assertTrue(mIntent.toURI().indexOf(getString("c", TEST_EXTRA_NAME, testChar)) != -1); 1192 1193 final double testDouble = 1; 1194 mIntent.putExtra(TEST_EXTRA_NAME, testDouble); 1195 assertTrue(mIntent.toURI().indexOf(getString("d", TEST_EXTRA_NAME, testDouble)) != -1); 1196 1197 final int testInt = 1; 1198 mIntent.putExtra(TEST_EXTRA_NAME, testInt); 1199 assertTrue(mIntent.toURI().indexOf(getString("i", TEST_EXTRA_NAME, testInt)) != -1); 1200 1201 final long testLong = 1l; 1202 mIntent.putExtra(TEST_EXTRA_NAME, testLong); 1203 assertTrue(mIntent.toURI().indexOf(getString("l", TEST_EXTRA_NAME, testLong)) != -1); 1204 final short testShort = 1; 1205 mIntent.putExtra(TEST_EXTRA_NAME, testShort); 1206 assertTrue(mIntent.toURI().indexOf(getString("s", TEST_EXTRA_NAME, testShort)) != -1); 1207 assertTrue(mIntent.toURI().indexOf("end") != -1); 1208 } 1209 getString(String entryType, String key, Object value)1210 private String getString(String entryType, String key, Object value) { 1211 StringBuilder uri = new StringBuilder(); 1212 uri.append(entryType); 1213 uri.append('.'); 1214 uri.append(Uri.encode(key)); 1215 uri.append('='); 1216 uri.append(Uri.encode(value.toString())); 1217 return uri.toString(); 1218 } 1219 makeSelector(Intent baseIntent, Intent selectorIntent)1220 static Intent makeSelector(Intent baseIntent, Intent selectorIntent) { 1221 baseIntent.setSelector(selectorIntent); 1222 return baseIntent; 1223 } 1224 1225 @Test 1226 @DisabledOnRavenwood(reason = "feature flag dependent test") testUris()1227 public void testUris() { 1228 checkIntentUri( 1229 "intent:#Intent;action=android.test.FOO;end", 1230 null, 1231 new Intent().setAction("android.test.FOO")); 1232 checkIntentUri( 1233 "intent:#Intent;category=android.test.FOO;end", 1234 null, 1235 new Intent().setAction(Intent.ACTION_VIEW).addCategory("android.test.FOO")); 1236 checkIntentUri( 1237 "intent:#Intent;action=android.test.FOO;launchFlags=0x20;end", 1238 null, 1239 new Intent().setAction("android.test.FOO").setFlags(0x20)); 1240 checkIntentUri( 1241 "intent://www.example.com/blah#Intent;scheme=http;end", 1242 null, 1243 new Intent().setAction(Intent.ACTION_VIEW) 1244 .setData(Uri.parse("http://www.example.com/blah"))); 1245 checkIntentUri( 1246 "intent://www.example.com/blah#Intent;scheme=http;component=com.exfoo/com.argh.Bar;end", 1247 null, 1248 new Intent().setAction(Intent.ACTION_VIEW) 1249 .setData(Uri.parse("http://www.example.com/blah")) 1250 .setComponent(new ComponentName("com.exfoo", "com.argh.Bar"))); 1251 checkIntentUri( 1252 "intent://www.example.com/blah#fragment#Intent;scheme=http;end", 1253 null, 1254 new Intent().setAction(Intent.ACTION_VIEW) 1255 .setData(Uri.parse("http://www.example.com/blah#fragment"))); 1256 checkIntentUri( 1257 "intent://www.example.com/blah#Intent;scheme=http;action=android.test.foo;end", 1258 null, 1259 new Intent().setAction("android.test.foo") 1260 .setData(Uri.parse("http://www.example.com/blah"))); 1261 checkIntentUri( 1262 "intent:foo#Intent;scheme=mailto;type=image/foo;end", 1263 null, 1264 new Intent().setAction(Intent.ACTION_VIEW) 1265 .setDataAndType(Uri.parse("mailto:foo"), "image/foo")); 1266 checkIntentUri( 1267 "intent:foo#Intent;scheme=mailto;S.string=text;end", 1268 null, 1269 new Intent().setAction(Intent.ACTION_VIEW) 1270 .setData(Uri.parse("mailto:foo")) 1271 .putExtra("string", "text")); 1272 checkIntentUri( 1273 "intent:#Intent;action=android.test.FOO;S.string=text;end", 1274 null, 1275 new Intent().setAction("android.test.FOO").putExtra("string", "text")); 1276 checkIntentUri( 1277 "intent:foo#Intent;scheme=mailto;i.int=1000;end", 1278 null, 1279 new Intent().setAction(Intent.ACTION_VIEW) 1280 .setData(Uri.parse("mailto:foo")) 1281 .putExtra("int", 1000)); 1282 checkIntentUri( 1283 "intent:foo#Intent;scheme=mailto;l.long=1000;end", 1284 null, 1285 new Intent().setAction(Intent.ACTION_VIEW) 1286 .setData(Uri.parse("mailto:foo")) 1287 .putExtra("long", (long) 1000)); 1288 checkIntentUri( 1289 "intent:foo#Intent;scheme=mailto;B.boolean=true;end", 1290 null, 1291 new Intent().setAction(Intent.ACTION_VIEW) 1292 .setData(Uri.parse("mailto:foo")) 1293 .putExtra("boolean", true)); 1294 checkIntentUri( 1295 "intent:foo#Intent;scheme=mailto;f.float=10.4;end", 1296 null, 1297 new Intent().setAction(Intent.ACTION_VIEW) 1298 .setData(Uri.parse("mailto:foo")) 1299 .putExtra("float", 10.4f)); 1300 checkIntentUri( 1301 "intent:foo#Intent;scheme=mailto;d.double=10.4;end", 1302 null, 1303 new Intent().setAction(Intent.ACTION_VIEW) 1304 .setData(Uri.parse("mailto:foo")) 1305 .putExtra("double", (double) 10.4)); 1306 checkIntentUri( 1307 "intent:#Intent;S.string=text;i.int=1000;l.long=1000;B.boolean=true;f.float=10.4;end", 1308 null, 1309 new Intent().setAction(Intent.ACTION_VIEW).putExtra("string", "text") 1310 .putExtra("int", 1000).putExtra("long", (long) 1000) 1311 .putExtra("boolean", true).putExtra("float", 10.4f)); 1312 checkIntentUri( 1313 "intent:foo#Intent;scheme=mailto;SEL;scheme=foobar;action=android.test.FOO;end", 1314 null, 1315 makeSelector(new Intent(Intent.ACTION_VIEW).setData(Uri.parse("mailto:foo")), 1316 new Intent("android.test.FOO").setData(Uri.parse("foobar:")))); 1317 checkIntentUri( 1318 "intent:foo#Intent;scheme=mailto;SEL;action=android.test.FOO;package=com.myapp;end", 1319 null, 1320 makeSelector(new Intent(Intent.ACTION_VIEW).setData(Uri.parse("mailto:foo")), 1321 new Intent("android.test.FOO").setPackage("com.myapp"))); 1322 checkIntentUri( 1323 "intent:foo#Intent;scheme=mailto;SEL;action=android.test.FOO;component=com.exfoo/com.argh.Bar;end", 1324 null, 1325 makeSelector(new Intent(Intent.ACTION_VIEW).setData(Uri.parse("mailto:foo")), 1326 new Intent("android.test.FOO") 1327 .setComponent(new ComponentName("com.exfoo", "com.argh.Bar")))); 1328 1329 checkIntentUri( 1330 "intent:#Intent;action=android.test.FOO;package=com.myapp;end", 1331 "android-app://com.myapp#Intent;action=android.test.FOO;end", 1332 new Intent().setAction("android.test.FOO").setPackage("com.myapp")); 1333 checkIntentUri( 1334 "intent:#Intent;action=android.intent.action.MAIN;package=com.myapp;end", 1335 "android-app://com.myapp", 1336 new Intent().setAction(Intent.ACTION_MAIN).setPackage("com.myapp")); 1337 checkIntentUri( 1338 "intent:#Intent;package=com.myapp;end", 1339 "android-app://com.myapp#Intent;action=android.intent.action.VIEW;end", 1340 new Intent().setAction(Intent.ACTION_VIEW).setPackage("com.myapp")); 1341 checkIntentUri( 1342 "intent:#Intent;category=android.test.FOO;package=com.myapp;end", 1343 "android-app://com.myapp#Intent;action=android.intent.action.VIEW;category=android.test.FOO;end", 1344 new Intent().setAction(Intent.ACTION_VIEW).addCategory("android.test.FOO") 1345 .setPackage("com.myapp")); 1346 checkIntentUri( 1347 "intent:#Intent;action=android.test.FOO;launchFlags=0x20;package=com.myapp;end", 1348 "android-app://com.myapp#Intent;action=android.test.FOO;launchFlags=0x20;end", 1349 new Intent().setAction("android.test.FOO").setFlags(0x20) 1350 .setPackage("com.myapp")); 1351 checkIntentUri( 1352 "intent://www.example.com/blah#Intent;scheme=http;package=com.myapp;end", 1353 "android-app://com.myapp/http/www.example.com/blah", 1354 new Intent().setAction(Intent.ACTION_VIEW) 1355 .setData(Uri.parse("http://www.example.com/blah")) 1356 .setPackage("com.myapp")); 1357 checkIntentUri( 1358 "intent://www.example.com/blah#Intent;scheme=http;package=com.myapp;component=com.exfoo/com.argh.Bar;end", 1359 "android-app://com.myapp/http/www.example.com/blah#Intent;component=com.exfoo/com.argh.Bar;end", 1360 new Intent().setAction(Intent.ACTION_VIEW) 1361 .setData(Uri.parse("http://www.example.com/blah")) 1362 .setComponent(new ComponentName("com.exfoo", "com.argh.Bar")) 1363 .setPackage("com.myapp")); 1364 checkIntentUri( 1365 "intent://www.example.com/blah#fragment#Intent;scheme=http;package=com.myapp;end", 1366 "android-app://com.myapp/http/www.example.com/blah#fragment", 1367 new Intent().setAction(Intent.ACTION_VIEW) 1368 .setData(Uri.parse("http://www.example.com/blah#fragment")) 1369 .setPackage("com.myapp")); 1370 checkIntentUri( 1371 "intent://www.example.com/blah#fragment#Intent;scheme=http;action=android.test.FOO;package=com.myapp;end", 1372 "android-app://com.myapp/http/www.example.com/blah#fragment#Intent;action=android.test.FOO;end", 1373 new Intent().setAction("android.test.FOO") 1374 .setData(Uri.parse("http://www.example.com/blah#fragment")) 1375 .setPackage("com.myapp")); 1376 checkIntentUri( 1377 "intent://www.example.com/blah#Intent;scheme=http;package=com.myapp;end", 1378 "android-app://com.myapp/http/www.example.com/blah", 1379 new Intent().setAction(Intent.ACTION_VIEW) 1380 .setData(Uri.parse("http://www.example.com/blah")) 1381 .setPackage("com.myapp")); 1382 checkIntentUri( 1383 "intent:#Intent;scheme=mailto;type=image/foo;package=com.myapp;end", 1384 "android-app://com.myapp/mailto#Intent;type=image/foo;end", 1385 new Intent().setAction(Intent.ACTION_VIEW) 1386 .setDataAndType(Uri.parse("mailto:"), "image/foo") 1387 .setPackage("com.myapp")); 1388 checkIntentUri( 1389 "intent:#Intent;scheme=mailto;package=com.myapp;S.string=text;end", 1390 "android-app://com.myapp/mailto#Intent;S.string=text;end", 1391 new Intent().setAction(Intent.ACTION_VIEW).putExtra("string", "text") 1392 .setData(Uri.parse("mailto:")).setPackage("com.myapp")); 1393 checkIntentUri( 1394 "intent:#Intent;action=android.test.FOO;package=com.myapp;S.string=text;end", 1395 "android-app://com.myapp#Intent;action=android.test.FOO;S.string=text;end", 1396 new Intent().setAction("android.test.FOO").putExtra("string", "text") 1397 .setPackage("com.myapp")); 1398 checkIntentUri( 1399 "intent:#Intent;scheme=mailto;package=com.myapp;i.int=1000;end", 1400 "android-app://com.myapp/mailto#Intent;i.int=1000;end", 1401 new Intent().setAction(Intent.ACTION_VIEW).putExtra("int", 1000) 1402 .setData(Uri.parse("mailto:")).setPackage("com.myapp")); 1403 checkIntentUri( 1404 "intent:#Intent;scheme=mailto;package=com.myapp;l.long=1000;end", 1405 "android-app://com.myapp/mailto#Intent;l.long=1000;end", 1406 new Intent().setAction(Intent.ACTION_VIEW).putExtra("long", (long) 1000) 1407 .setData(Uri.parse("mailto:")).setPackage("com.myapp")); 1408 checkIntentUri( 1409 "intent:#Intent;scheme=mailto;package=com.myapp;B.boolean=true;end", 1410 "android-app://com.myapp/mailto#Intent;B.boolean=true;end", 1411 new Intent().setAction(Intent.ACTION_VIEW).putExtra("boolean", true) 1412 .setData(Uri.parse("mailto:")).setPackage("com.myapp")); 1413 checkIntentUri( 1414 "intent:#Intent;scheme=mailto;package=com.myapp;f.float=10.4;end", 1415 "android-app://com.myapp/mailto#Intent;f.float=10.4;end", 1416 new Intent().setAction(Intent.ACTION_VIEW).putExtra("float", 10.4f) 1417 .setData(Uri.parse("mailto:")).setPackage("com.myapp")); 1418 checkIntentUri( 1419 "intent:#Intent;scheme=mailto;package=com.myapp;d.double=10.4;end", 1420 "android-app://com.myapp/mailto#Intent;d.double=10.4;end", 1421 new Intent().setAction(Intent.ACTION_VIEW).putExtra("double", (double) 10.4) 1422 .setData(Uri.parse("mailto:")).setPackage("com.myapp")); 1423 checkIntentUri( 1424 "intent:#Intent;package=com.myapp;S.string=text;i.int=1000;l.long=1000;B.boolean=true;f.float=10.4;end", 1425 "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", 1426 new Intent().setAction(Intent.ACTION_VIEW).putExtra("string", "text") 1427 .putExtra("int", 1000).putExtra("long", (long) 1000) 1428 .putExtra("boolean", true).putExtra("float", 10.4f) 1429 .setPackage("com.myapp")); 1430 checkIntentUri( 1431 "intent://example.org/db?123#Intent;scheme=z39.50r;end", 1432 null, 1433 new Intent().setAction(Intent.ACTION_VIEW) 1434 .setData(Uri.parse("z39.50r://example.org/db?123"))); 1435 } 1436 1437 @Test testMalformedUris()1438 public void testMalformedUris() { 1439 assertThrows(URISyntaxException.class, () -> Intent.parseUri( 1440 "intent:#Intent;scheme=mailto;package=com.myapp;d.double=10.4", 0)); 1441 assertThrows(URISyntaxException.class, () -> Intent.parseUri( 1442 "android-app://com.myapp/mailto#Intent;d.double=10.4", 0)); 1443 } 1444 compareIntents(Intent expected, Intent actual)1445 private boolean compareIntents(Intent expected, Intent actual) { 1446 if (!Objects.equals(expected.getAction(), actual.getAction())) { 1447 return false; 1448 } 1449 if (!Objects.equals(expected.getData(), actual.getData())) { 1450 return false; 1451 } 1452 if (!Objects.equals(expected.getType(), actual.getType())) { 1453 return false; 1454 } 1455 if (!Objects.equals(expected.getIdentifier(), actual.getIdentifier())) { 1456 return false; 1457 } 1458 if (!Objects.equals(expected.getPackage(), actual.getPackage())) { 1459 return false; 1460 } 1461 if (!Objects.equals(expected.getComponent(), actual.getComponent())) { 1462 return false; 1463 } 1464 if (expected.getFlags() != actual.getFlags()) { 1465 return false; 1466 } 1467 Set<String> expectedCat = expected.getCategories(); 1468 Set<String> actualCat = actual.getCategories(); 1469 if (expectedCat != actualCat) { 1470 if (expectedCat == null || actualCat == null) { 1471 return false; 1472 } 1473 for (String cat : expectedCat) { 1474 if (!actual.hasCategory(cat)) { 1475 return false; 1476 } 1477 } 1478 for (String cat : actualCat) { 1479 if (!expected.hasCategory(cat)) { 1480 return false; 1481 } 1482 } 1483 } 1484 Bundle extras1 = expected.getExtras(); 1485 Bundle extras2 = actual.getExtras(); 1486 if (extras1 != extras2) { 1487 if (extras1 == null || extras2 == null) { 1488 return false; 1489 } 1490 for (String key : extras1.keySet()) { 1491 if (!Objects.equals(extras1.get(key), extras2.get(key))) { 1492 return false; 1493 } 1494 } 1495 for (String key : extras2.keySet()) { 1496 if (!Objects.equals(extras1.get(key), extras2.get(key))) { 1497 return false; 1498 } 1499 } 1500 } 1501 return true; 1502 } 1503 assertEqualsIntent(String msg, Intent expected, Intent actual)1504 private void assertEqualsIntent(String msg, Intent expected, Intent actual) { 1505 if (!compareIntents(expected, actual)) { 1506 failNotEquals(msg, expected, actual); 1507 } 1508 Intent expectedSel = expected.getSelector(); 1509 Intent actualSel = actual.getSelector(); 1510 if (expectedSel != actualSel) { 1511 if (expectedSel == null || actualSel == null) { 1512 failNotEquals(msg, expected, actual); 1513 } 1514 if (!compareIntents(expectedSel, actualSel)) { 1515 failNotEquals(msg, expected, actual); 1516 } 1517 } 1518 } 1519 failNotEquals(String msg, Object expected, Object actual)1520 private void failNotEquals(String msg, Object expected, Object actual) { 1521 fail(msg + ": expected " + Objects.toString(expected) 1522 + " actual " + Objects.toString(actual)); 1523 } 1524 checkIntentUri(String intentSchemeUri, String androidAppSchemeUri, Intent intent)1525 private void checkIntentUri(String intentSchemeUri, String androidAppSchemeUri, Intent intent) { 1526 if (intentSchemeUri != null) { 1527 try { 1528 Intent genIntent = Intent.parseUri(intentSchemeUri, 0); 1529 assertEqualsIntent("Implicitly converting " + intentSchemeUri + " to Intent", 1530 intent, genIntent); 1531 genIntent = Intent.parseUri(intentSchemeUri, Intent.URI_INTENT_SCHEME); 1532 assertEqualsIntent("Explicitly converting " + intentSchemeUri + " to Intent", 1533 intent, genIntent); 1534 } catch (URISyntaxException e) { 1535 fail("Failure parsing " + intentSchemeUri + ": " + e); 1536 } 1537 String genUri = intent.toUri(Intent.URI_INTENT_SCHEME); 1538 assertEquals("Converting " + intent + " to intent: uri", 1539 intentSchemeUri, genUri); 1540 } 1541 if (androidAppSchemeUri != null) { 1542 try { 1543 Intent genIntent = Intent.parseUri(androidAppSchemeUri, 0); 1544 assertEqualsIntent("Implicitly converting " + androidAppSchemeUri + " to Intent", 1545 intent, genIntent); 1546 genIntent = Intent.parseUri(intentSchemeUri, Intent.URI_ANDROID_APP_SCHEME); 1547 assertEqualsIntent("Explicitly converting " + androidAppSchemeUri + " to Intent", 1548 intent, genIntent); 1549 } catch (URISyntaxException e) { 1550 fail("Failure parsing " + androidAppSchemeUri + ": " + e); 1551 } 1552 String genUri = intent.toUri(Intent.URI_ANDROID_APP_SCHEME); 1553 assertEquals("Converting " + intent + " to android-app: uri", 1554 androidAppSchemeUri, genUri); 1555 } 1556 } 1557 1558 @Test testAccessFlags()1559 public void testAccessFlags() { 1560 int expected = 1; 1561 mIntent.setFlags(expected); 1562 assertEquals(expected, mIntent.getFlags()); 1563 } 1564 1565 @Test 1566 @DisabledOnRavenwood(blockedBy = PendingIntent.class) testCreateChooser()1567 public void testCreateChooser() { 1568 Intent target = Intent.createChooser(mIntent, null); 1569 assertEquals(Intent.ACTION_CHOOSER, target.getAction()); 1570 Intent returnIntent = target.getParcelableExtra(Intent.EXTRA_INTENT); 1571 assertEquals(mIntent.toString(), returnIntent.toString()); 1572 assertEquals(mIntent.toURI(), returnIntent.toURI()); 1573 assertNull(returnIntent.getStringExtra(Intent.EXTRA_INTENT)); 1574 1575 final String title = "title String"; 1576 target = Intent.createChooser(mIntent, title); 1577 assertEquals(title, target.getStringExtra(Intent.EXTRA_TITLE)); 1578 assertNotNull(target.resolveActivity(mPm)); 1579 1580 IntentSender sender = PendingIntent.getActivity( 1581 mContext, 0, mIntent, PendingIntent.FLAG_IMMUTABLE).getIntentSender(); 1582 target = Intent.createChooser(mIntent, null, sender); 1583 1584 assertEquals(sender, target.getParcelableExtra( 1585 Intent.EXTRA_CHOOSER_RESULT_INTENT_SENDER, IntentSender.class)); 1586 // Asser that setting the data URI *without* a permission granting flag *doesn't* copy 1587 // anything to ClipData. 1588 Uri data = Uri.parse("some://uri"); 1589 mIntent.setData(data); 1590 target = Intent.createChooser(mIntent, null); 1591 assertNull(target.getClipData()); 1592 1593 // Now add the flag and verify that ClipData is written. 1594 mIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); 1595 target = Intent.createChooser(mIntent, null); 1596 ClipData clipData = target.getClipData(); 1597 assertEquals(1, clipData.getItemCount()); 1598 assertEquals(data, clipData.getItemAt(0).getUri()); 1599 assertEquals(0, clipData.getDescription().getMimeTypeCount()); 1600 // Ensure flag is propagated. 1601 assertEquals(Intent.FLAG_GRANT_READ_URI_PERMISSION, 1602 target.getFlags() & Intent.FLAG_GRANT_READ_URI_PERMISSION); 1603 1604 // Add a MIME type, check for it in the ClipData 1605 final String mimeType = "image/png"; 1606 mIntent.setDataAndType(data, mimeType); 1607 target = Intent.createChooser(mIntent, null); 1608 clipData = target.getClipData(); 1609 assertEquals(1, clipData.getDescription().getMimeTypeCount()); 1610 assertEquals(mimeType, clipData.getDescription().getMimeType(0)); 1611 1612 // Ensure that ClipData that is already set is overwritten. 1613 Uri anotherUri = Uri.parse("another://uri"); 1614 ClipData anotherClipData = new ClipData( 1615 new ClipDescription("desc", new String[0]), new ClipData.Item(anotherUri)); 1616 mIntent.setClipData(anotherClipData); 1617 target = Intent.createChooser(mIntent, null); 1618 clipData = target.getClipData(); 1619 assertEquals(1, clipData.getItemCount()); 1620 assertEquals(anotherUri, clipData.getItemAt(0).getUri()); 1621 } 1622 1623 @Test testGetFloatArrayExtra()1624 public void testGetFloatArrayExtra() { 1625 final float[] expected = { 1f, 2f, 3f }; 1626 mIntent.putExtra(TEST_EXTRA_NAME, expected); 1627 assertEquals(expected, mIntent.getFloatArrayExtra(TEST_EXTRA_NAME)); 1628 } 1629 1630 @Test testSetDataAndType()1631 public void testSetDataAndType() { 1632 mIntent.setDataAndType(TEST_URI, TEST_TYPE); 1633 assertEquals(TEST_URI, mIntent.getData()); 1634 assertEquals(TEST_TYPE, mIntent.getType()); 1635 } 1636 1637 @Test testSetData()1638 public void testSetData() { 1639 mIntent.setData(TEST_URI); 1640 assertEquals(TEST_URI, mIntent.getData()); 1641 assertNull(mIntent.getType()); 1642 1643 mIntent.setType(TEST_TYPE); 1644 mIntent.setData(TEST_URI); 1645 assertEquals(TEST_URI, mIntent.getData()); 1646 assertNull(mIntent.getType()); 1647 } 1648 1649 @Test testSetType()1650 public void testSetType() { 1651 mIntent.setType(TEST_TYPE); 1652 assertEquals(TEST_TYPE, mIntent.getType()); 1653 assertNull(mIntent.getData()); 1654 1655 mIntent.setData(TEST_URI); 1656 mIntent.setType(TEST_TYPE); 1657 assertEquals(TEST_TYPE, mIntent.getType()); 1658 assertNull(mIntent.getData()); 1659 } 1660 1661 @Test testGetStringExtra()1662 public void testGetStringExtra() { 1663 final String expected = "testString"; 1664 assertNull(mIntent.getStringExtra(TEST_EXTRA_NAME)); 1665 mIntent.putExtra(TEST_EXTRA_NAME, expected); 1666 assertEquals(expected, mIntent.getStringExtra(TEST_EXTRA_NAME)); 1667 } 1668 1669 /** 1670 * Test that fillIn has no effect when no fields are set. 1671 */ 1672 @Test testFillIn_blank()1673 public void testFillIn_blank() { 1674 Intent sourceIntent = new Intent(); 1675 Intent destIntent = new Intent(); 1676 assertEquals(0, destIntent.fillIn(sourceIntent, Intent.FILL_IN_ACTION)); 1677 assertEquals(0, destIntent.fillIn(sourceIntent, 0)); 1678 assertNull(destIntent.getAction()); 1679 } 1680 1681 /** 1682 * Test that fillIn copies the action field. 1683 */ 1684 @Test testFillIn_action()1685 public void testFillIn_action() { 1686 Intent sourceIntent = new Intent(); 1687 Intent destIntent = new Intent(); 1688 // test action copied when null 1689 sourceIntent.setAction(TEST_ACTION); 1690 assertEquals(Intent.FILL_IN_ACTION, destIntent.fillIn(sourceIntent, 0)); 1691 assertEquals(TEST_ACTION, destIntent.getAction()); 1692 } 1693 1694 /** 1695 * Test that fillIn does not copy action when its already set in target Intent. 1696 */ 1697 @Test testFillIn_actionSet()1698 public void testFillIn_actionSet() { 1699 Intent sourceIntent = new Intent(); 1700 Intent destIntent = new Intent(); 1701 final String newAction = "foo"; 1702 sourceIntent = new Intent(); 1703 sourceIntent.setAction(newAction); 1704 destIntent.setAction(TEST_ACTION); 1705 1706 assertEquals(0, destIntent.fillIn(sourceIntent, 0)); 1707 assertEquals(TEST_ACTION, destIntent.getAction()); 1708 } 1709 1710 /** 1711 * Test that fillIn copies action when {@link Intent#FILL_IN_ACTION} flag is set. 1712 */ 1713 @Test testFillIn_actionOverride()1714 public void testFillIn_actionOverride() { 1715 Intent sourceIntent = new Intent(); 1716 Intent destIntent = new Intent(); 1717 final String newAction = "foo"; 1718 sourceIntent = new Intent(); 1719 sourceIntent.setAction(newAction); 1720 destIntent.setAction(TEST_ACTION); 1721 1722 assertEquals(Intent.FILL_IN_ACTION, destIntent.fillIn(sourceIntent, Intent.FILL_IN_ACTION)); 1723 assertEquals(newAction, destIntent.getAction()); 1724 } 1725 1726 /** 1727 * Test that fillIn copies data. 1728 */ 1729 @Test testFillIn_data()1730 public void testFillIn_data() { 1731 Intent sourceIntent = new Intent(); 1732 Intent destIntent = new Intent(); 1733 sourceIntent.setData(TEST_URI); 1734 assertEquals(Intent.FILL_IN_DATA, destIntent.fillIn(sourceIntent, 0)); 1735 assertEquals(TEST_URI, destIntent.getData()); 1736 } 1737 1738 /** 1739 * Test that fillIn does not copy data when already its already set in target Intent. 1740 */ 1741 @Test testFillIn_dataSet()1742 public void testFillIn_dataSet() { 1743 Intent sourceIntent = new Intent(); 1744 Intent destIntent = new Intent(); 1745 sourceIntent.setData(TEST_URI); 1746 destIntent.setData(ANOTHER_TEST_URI); 1747 assertEquals(0, destIntent.fillIn(sourceIntent, 0)); 1748 assertEquals(ANOTHER_TEST_URI, destIntent.getData()); 1749 } 1750 1751 /** 1752 * Test that fillIn overrides data when {@link Intent#FILL_IN_DATA} flag is set. 1753 */ 1754 @Test testFillIn_dataOverride()1755 public void testFillIn_dataOverride() { 1756 Intent sourceIntent = new Intent(); 1757 Intent destIntent = new Intent(); 1758 sourceIntent.setData(TEST_URI); 1759 destIntent.setData(ANOTHER_TEST_URI); 1760 assertEquals(Intent.FILL_IN_DATA, destIntent.fillIn(sourceIntent, Intent.FILL_IN_DATA)); 1761 assertEquals(TEST_URI, destIntent.getData()); 1762 } 1763 1764 /** 1765 * Test that fillIn copies data type. 1766 */ 1767 @Test testFillIn_dataType()1768 public void testFillIn_dataType() { 1769 Intent sourceIntent = new Intent(); 1770 Intent destIntent = new Intent(); 1771 sourceIntent.setType(TEST_TYPE); 1772 assertEquals(Intent.FILL_IN_DATA, destIntent.fillIn(sourceIntent, 0)); 1773 assertEquals(TEST_TYPE, destIntent.getType()); 1774 } 1775 1776 /** 1777 * Test that fillIn does not copy data type when already its already set in target Intent. 1778 */ 1779 @Test testFillIn_dataTypeSet()1780 public void testFillIn_dataTypeSet() { 1781 Intent sourceIntent = new Intent(); 1782 Intent destIntent = new Intent(); 1783 sourceIntent.setType(TEST_TYPE); 1784 destIntent.setType(ANOTHER_TEST_TYPE); 1785 assertEquals(0, destIntent.fillIn(sourceIntent, 0)); 1786 assertEquals(ANOTHER_TEST_TYPE, destIntent.getType()); 1787 } 1788 1789 /** 1790 * Test that fillIn overrides data type when {@link Intent#FILL_IN_DATA} flag is set. 1791 */ 1792 @Test testFillIn_dataTypeOverride()1793 public void testFillIn_dataTypeOverride() { 1794 Intent sourceIntent = new Intent(); 1795 Intent destIntent = new Intent(); 1796 sourceIntent.setType(TEST_TYPE); 1797 destIntent.setType(ANOTHER_TEST_TYPE); 1798 assertEquals(Intent.FILL_IN_DATA, destIntent.fillIn(sourceIntent, Intent.FILL_IN_DATA)); 1799 assertEquals(TEST_TYPE, destIntent.getType()); 1800 } 1801 1802 /** 1803 * Test that fillIn copies identifier. 1804 */ 1805 @Test testFillIn_identifier()1806 public void testFillIn_identifier() { 1807 Intent sourceIntent = new Intent(); 1808 Intent destIntent = new Intent(); 1809 sourceIntent.setIdentifier(TEST_IDENTIFIER); 1810 assertEquals(Intent.FILL_IN_IDENTIFIER, destIntent.fillIn(sourceIntent, 0)); 1811 assertEquals(TEST_IDENTIFIER, destIntent.getIdentifier()); 1812 } 1813 1814 /** 1815 * Test that fillIn does not copy identifier when already its already set in target Intent. 1816 */ 1817 @Test testFillIn_identifierSet()1818 public void testFillIn_identifierSet() { 1819 Intent sourceIntent = new Intent(); 1820 Intent destIntent = new Intent(); 1821 sourceIntent.setIdentifier(TEST_IDENTIFIER); 1822 destIntent.setIdentifier(ANOTHER_TEST_IDENTIFIER); 1823 assertEquals(0, destIntent.fillIn(sourceIntent, 0)); 1824 assertEquals(ANOTHER_TEST_IDENTIFIER, destIntent.getIdentifier()); 1825 } 1826 1827 /** 1828 * Test that fillIn overrides identifier when {@link Intent#FILL_IN_IDENTIFIER} flag is set. 1829 */ 1830 @Test testFillIn_identifierOverride()1831 public void testFillIn_identifierOverride() { 1832 Intent sourceIntent = new Intent(); 1833 Intent destIntent = new Intent(); 1834 sourceIntent.setIdentifier(TEST_IDENTIFIER); 1835 destIntent.setIdentifier(TEST_IDENTIFIER); 1836 assertEquals(Intent.FILL_IN_IDENTIFIER, destIntent.fillIn(sourceIntent, 1837 Intent.FILL_IN_IDENTIFIER)); 1838 assertEquals(TEST_IDENTIFIER, destIntent.getIdentifier()); 1839 } 1840 1841 /** 1842 * Test component is not copied by fillIn method when {@link Intent#FILL_IN_COMPONENT} flag is 1843 * not set. 1844 */ 1845 @Test testFillIn_componentNoCopy()1846 public void testFillIn_componentNoCopy() { 1847 Intent sourceIntent = new Intent(); 1848 Intent destIntent = new Intent(); 1849 sourceIntent.setComponent(mComponentName); 1850 assertEquals(0, destIntent.fillIn(sourceIntent, 0)); 1851 assertEquals(null, destIntent.getComponent()); 1852 } 1853 1854 /** 1855 * Test that fillIn copies component when {@link Intent#FILL_IN_COMPONENT} flag is set. 1856 */ 1857 @Test testFillIn_componentOverride()1858 public void testFillIn_componentOverride() { 1859 Intent sourceIntent = new Intent(); 1860 Intent destIntent = new Intent(); 1861 sourceIntent.setComponent(mComponentName); 1862 destIntent.setComponent(mAnotherComponentName); 1863 assertEquals(Intent.FILL_IN_COMPONENT, destIntent.fillIn(sourceIntent, 1864 Intent.FILL_IN_COMPONENT)); 1865 assertEquals(mComponentName, destIntent.getComponent()); 1866 } 1867 1868 /** 1869 * Test that fillIn copies categories. 1870 */ 1871 @Test testFillIn_category()1872 public void testFillIn_category() { 1873 Intent sourceIntent = new Intent(); 1874 Intent destIntent = new Intent(); 1875 // add two categories to ensure all categories are copied 1876 sourceIntent.addCategory(TEST_CATEGORY); 1877 sourceIntent.addCategory(ANOTHER_TEST_CATEGORY); 1878 assertEquals(Intent.FILL_IN_CATEGORIES, destIntent.fillIn(sourceIntent, 0)); 1879 assertEquals(2, destIntent.getCategories().size()); 1880 assertTrue(destIntent.getCategories().contains(TEST_CATEGORY)); 1881 assertTrue(destIntent.getCategories().contains(ANOTHER_TEST_CATEGORY)); 1882 } 1883 1884 /** 1885 * Test fillIn does not copy categories by default when already set. 1886 */ 1887 @Test testFillIn_categorySet()1888 public void testFillIn_categorySet() { 1889 Intent sourceIntent = new Intent(); 1890 Intent destIntent = new Intent(); 1891 sourceIntent = new Intent(); 1892 sourceIntent.addCategory(TEST_CATEGORY); 1893 destIntent.addCategory(ANOTHER_TEST_CATEGORY); 1894 1895 assertEquals(0, destIntent.fillIn(sourceIntent, 0)); 1896 assertEquals(1, destIntent.getCategories().size()); 1897 assertTrue(destIntent.getCategories().contains(ANOTHER_TEST_CATEGORY)); 1898 assertFalse(destIntent.getCategories().contains(TEST_CATEGORY)); 1899 } 1900 1901 /** 1902 * Test that fillIn adds categories when {@link Intent#FILL_IN_CATEGORIES} flag is set. 1903 */ 1904 @Test testFillIn_categoryOverride()1905 public void testFillIn_categoryOverride() { 1906 Intent sourceIntent = new Intent(); 1907 Intent destIntent = new Intent(); 1908 sourceIntent = new Intent(); 1909 sourceIntent.addCategory(TEST_CATEGORY); 1910 destIntent.addCategory(ANOTHER_TEST_CATEGORY); 1911 1912 assertEquals(Intent.FILL_IN_CATEGORIES, destIntent.fillIn(sourceIntent, Intent.FILL_IN_CATEGORIES)); 1913 assertEquals(1, destIntent.getCategories().size()); 1914 assertFalse(destIntent.getCategories().contains(ANOTHER_TEST_CATEGORY)); 1915 assertTrue(destIntent.getCategories().contains(TEST_CATEGORY)); 1916 } 1917 1918 /** 1919 * Test fillIn copies package. 1920 */ 1921 @Test testFillIn_package()1922 public void testFillIn_package() { 1923 Intent sourceIntent = new Intent(); 1924 Intent destIntent = new Intent(); 1925 sourceIntent.setPackage(TEST_PACKAGE); 1926 assertEquals(Intent.FILL_IN_PACKAGE, destIntent.fillIn(sourceIntent, 0)); 1927 assertEquals(TEST_PACKAGE, destIntent.getPackage()); 1928 } 1929 1930 /** 1931 * Test fillIn does not copy package by default when already set. 1932 */ 1933 @Test testFillIn_packageSet()1934 public void testFillIn_packageSet() { 1935 Intent sourceIntent = new Intent(); 1936 Intent destIntent = new Intent(); 1937 sourceIntent.setPackage(TEST_PACKAGE); 1938 destIntent.setPackage(ANOTHER_TEST_PACKAGE); 1939 assertEquals(0, destIntent.fillIn(sourceIntent, 0)); 1940 assertEquals(ANOTHER_TEST_PACKAGE, destIntent.getPackage()); 1941 } 1942 1943 /** 1944 * Test that fillIn overrides package when {@link Intent#FILL_IN_PACKAGE} flag is set. 1945 */ 1946 @Test testFillIn_packageOverride()1947 public void testFillIn_packageOverride() { 1948 Intent sourceIntent = new Intent(); 1949 Intent destIntent = new Intent(); 1950 sourceIntent.setPackage(TEST_PACKAGE); 1951 destIntent.setPackage(ANOTHER_TEST_PACKAGE); 1952 assertEquals(Intent.FILL_IN_PACKAGE, destIntent.fillIn(sourceIntent, Intent.FILL_IN_PACKAGE)); 1953 assertEquals(TEST_PACKAGE, destIntent.getPackage()); 1954 } 1955 1956 /** 1957 * Test that fillIn copies extras. 1958 */ 1959 @Test testFillIn_extras()1960 public void testFillIn_extras() { 1961 Intent sourceIntent = new Intent(); 1962 Intent destIntent = new Intent(); 1963 final Bundle bundle = new Bundle(); 1964 bundle.putBoolean(TEST_EXTRA_NAME, true); 1965 sourceIntent.putExtras(bundle); 1966 assertEquals(0, destIntent.fillIn(sourceIntent, 0)); 1967 assertTrue(destIntent.getExtras().getBoolean(TEST_EXTRA_NAME)); 1968 } 1969 1970 @Test testGetExtras()1971 public void testGetExtras() { 1972 assertNull(mIntent.getExtras()); 1973 final String expected = "testString"; 1974 mIntent.putExtra(TEST_EXTRA_NAME, expected); 1975 assertNotNull(mIntent.getExtras()); 1976 assertEquals(expected, mIntent.getExtras().getString(TEST_EXTRA_NAME)); 1977 } 1978 1979 @Test testGetBooleanExtra()1980 public void testGetBooleanExtra() { 1981 assertFalse(mIntent.getBooleanExtra(TEST_EXTRA_NAME, false)); 1982 mIntent.putExtra(TEST_EXTRA_NAME, true); 1983 assertTrue(mIntent.getBooleanExtra(TEST_EXTRA_NAME, false)); 1984 mIntent.putExtra(TEST_EXTRA_NAME, false); 1985 assertFalse(mIntent.getBooleanExtra(TEST_EXTRA_NAME, false)); 1986 } 1987 1988 @Test testGetFloatExtra()1989 public void testGetFloatExtra() { 1990 float expected = 2f; 1991 assertEquals(1f, mIntent.getFloatExtra(TEST_EXTRA_NAME, 1f), DELTA_FLOAT); 1992 mIntent.putExtra(TEST_EXTRA_NAME, expected); 1993 assertEquals(expected, mIntent.getFloatExtra(TEST_EXTRA_NAME, 1f), DELTA_FLOAT); 1994 } 1995 1996 @Test testGetShortArrayExtra()1997 public void testGetShortArrayExtra() { 1998 final short[] expected = { 1, 2, 3 }; 1999 mIntent.putExtra(TEST_EXTRA_NAME, expected); 2000 assertEquals(expected, mIntent.getShortArrayExtra(TEST_EXTRA_NAME)); 2001 } 2002 2003 @Test testGetStringArrayExtra()2004 public void testGetStringArrayExtra() { 2005 final String[] expected = { "1d", "2d", "3d" }; 2006 mIntent.putExtra(TEST_EXTRA_NAME, expected); 2007 assertEquals(expected, mIntent.getStringArrayExtra(TEST_EXTRA_NAME)); 2008 } 2009 2010 @Test testGetCharSequenceArrayExtra()2011 public void testGetCharSequenceArrayExtra() { 2012 final String[] expected = { "1d", "2d", "3d" }; 2013 mIntent.putExtra(TEST_EXTRA_NAME, expected); 2014 assertEquals(expected, mIntent.getCharSequenceArrayExtra(TEST_EXTRA_NAME)); 2015 } 2016 2017 @Test testGetByteArrayExtra()2018 public void testGetByteArrayExtra() { 2019 final byte[] expected = TEST_ACTION.getBytes(); 2020 mIntent.putExtra(TEST_EXTRA_NAME, expected); 2021 assertEquals(expected, mIntent.getByteArrayExtra(TEST_EXTRA_NAME)); 2022 } 2023 2024 @Test testHasFileDescriptors()2025 public void testHasFileDescriptors() { 2026 Bundle bundle = mIntent.getExtras(); 2027 assertEquals(bundle != null && bundle.hasFileDescriptors(), mIntent.hasFileDescriptors()); 2028 final byte[] expected = TEST_ACTION.getBytes(); 2029 mIntent.putExtra(TEST_EXTRA_NAME, expected); 2030 bundle = mIntent.getExtras(); 2031 assertEquals(bundle != null && bundle.hasFileDescriptors(), mIntent.hasFileDescriptors()); 2032 } 2033 2034 @Test testGetBooleanArrayExtra()2035 public void testGetBooleanArrayExtra() { 2036 final boolean[] expected = { true, true, false }; 2037 mIntent.putExtra(TEST_EXTRA_NAME, expected); 2038 assertEquals(expected, mIntent.getBooleanArrayExtra(TEST_EXTRA_NAME)); 2039 } 2040 2041 @Test testGetLongExtra()2042 public void testGetLongExtra() { 2043 final long expected = 2l; 2044 assertEquals(1l, mIntent.getLongExtra(TEST_EXTRA_NAME, 1l)); 2045 mIntent.putExtra(TEST_EXTRA_NAME, expected); 2046 assertEquals(expected, mIntent.getLongExtra(TEST_EXTRA_NAME, 1l)); 2047 } 2048 2049 @Test testRemoveCategory()2050 public void testRemoveCategory() { 2051 assertNull(mIntent.getCategories()); 2052 mIntent.addCategory(TEST_CATEGORY); 2053 assertNotNull(mIntent.getCategories()); 2054 assertEquals(1, mIntent.getCategories().size()); 2055 assertEquals(TEST_CATEGORY, (String) (mIntent.getCategories().toArray()[0])); 2056 mIntent.removeCategory(TEST_CATEGORY); 2057 assertFalse(mIntent.hasCategory(TEST_CATEGORY)); 2058 } 2059 2060 @Test testFilterEquals()2061 public void testFilterEquals() { 2062 assertFalse(mIntent.filterEquals(null)); 2063 2064 Intent target = new Intent(); 2065 assertTrue(mIntent.filterEquals(target)); 2066 2067 target.setAction(TEST_ACTION); 2068 assertFalse(mIntent.filterEquals(target)); 2069 mIntent.setAction(TEST_ACTION + "test"); 2070 assertFalse(mIntent.filterEquals(target)); 2071 mIntent.setAction(null); 2072 assertFalse(mIntent.filterEquals(target)); 2073 mIntent.setAction(TEST_ACTION); 2074 assertTrue(mIntent.filterEquals(target)); 2075 2076 target.setData(TEST_URI); 2077 assertFalse(mIntent.filterEquals(target)); 2078 mIntent.setData(Uri.parse("myURI")); 2079 assertFalse(mIntent.filterEquals(target)); 2080 mIntent.setData(null); 2081 assertFalse(mIntent.filterEquals(target)); 2082 mIntent.setData(TEST_URI); 2083 assertTrue(mIntent.filterEquals(target)); 2084 2085 target.setType(TEST_TYPE); 2086 assertFalse(mIntent.filterEquals(target)); 2087 mIntent.setType(TEST_TYPE + "test"); 2088 assertFalse(mIntent.filterEquals(target)); 2089 mIntent.setType(null); 2090 assertFalse(mIntent.filterEquals(target)); 2091 mIntent.setType(TEST_TYPE); 2092 assertTrue(mIntent.filterEquals(target)); 2093 2094 target.setIdentifier(TEST_IDENTIFIER); 2095 assertFalse(mIntent.filterEquals(target)); 2096 mIntent.setIdentifier(TEST_IDENTIFIER + "test"); 2097 assertFalse(mIntent.filterEquals(target)); 2098 mIntent.setIdentifier(null); 2099 assertFalse(mIntent.filterEquals(target)); 2100 mIntent.setIdentifier(TEST_IDENTIFIER); 2101 assertTrue(mIntent.filterEquals(target)); 2102 2103 target.setComponent(mComponentName); 2104 assertFalse(mIntent.filterEquals(target)); 2105 mIntent.setComponent(new ComponentName(mContext, MockReceiver.class)); 2106 assertFalse(mIntent.filterEquals(target)); 2107 mIntent.setComponent(null); 2108 assertFalse(mIntent.filterEquals(target)); 2109 mIntent.setComponent(mComponentName); 2110 assertTrue(mIntent.filterEquals(target)); 2111 2112 target.addCategory(TEST_CATEGORY); 2113 assertFalse(mIntent.filterEquals(target)); 2114 mIntent.addCategory(TEST_CATEGORY + "test"); 2115 assertFalse(mIntent.filterEquals(target)); 2116 mIntent.addCategory(TEST_CATEGORY); 2117 assertFalse(mIntent.filterEquals(target)); 2118 } 2119 2120 @Test testPutExtras1()2121 public void testPutExtras1() { 2122 final Intent intent = new Intent(); 2123 mIntent.putExtras(intent); 2124 assertEquals(intent.getExtras(), mIntent.getExtras()); 2125 intent.putExtra("test2", true); 2126 mIntent.putExtras(intent); 2127 assertEquals(intent.getExtras().toString(), mIntent.getExtras().toString()); 2128 } 2129 2130 @Test testPutExtras2()2131 public void testPutExtras2() { 2132 final Bundle bundle = new Bundle(); 2133 mIntent.putExtras(bundle); 2134 assertEquals(0, mIntent.getExtras().size()); 2135 String expected = "testString"; 2136 bundle.putString(TEST_EXTRA_NAME, expected); 2137 mIntent.putExtras(bundle); 2138 assertEquals(1, mIntent.getExtras().size()); 2139 assertEquals(expected, mIntent.getExtras().getString(TEST_EXTRA_NAME)); 2140 mIntent.putExtra(TEST_EXTRA_NAME, bundle); 2141 assertEquals(bundle, mIntent.getBundleExtra(TEST_EXTRA_NAME)); 2142 } 2143 2144 @Test testGetByteExtra()2145 public void testGetByteExtra() { 2146 final byte expected = Byte.valueOf("1"); 2147 mIntent.putExtra(TEST_EXTRA_NAME, expected); 2148 assertEquals(expected, mIntent.getByteExtra(TEST_EXTRA_NAME, Byte.valueOf("1"))); 2149 } 2150 2151 @Test testGetSerializableExtra()2152 public void testGetSerializableExtra() { 2153 TestSerializable expected = new TestSerializable(); 2154 expected.Name = "testName"; 2155 mIntent.putExtra(TEST_EXTRA_NAME, expected); 2156 assertEquals(expected, mIntent.getSerializableExtra(TEST_EXTRA_NAME)); 2157 TestSerializable target = (TestSerializable) mIntent.getSerializableExtra(TEST_EXTRA_NAME); 2158 assertEquals(expected.Name, target.Name); 2159 } 2160 2161 @Test 2162 @DisabledOnRavenwood(blockedBy = CompatChanges.class) testGetSerializableExtraTypeSafe_withMismatchingType_returnsNull()2163 public void testGetSerializableExtraTypeSafe_withMismatchingType_returnsNull() { 2164 mIntent.putExtra(TEST_EXTRA_NAME, new TestSerializable()); 2165 roundtrip(); 2166 assertNull(mIntent.getSerializableExtra(TEST_EXTRA_NAME, Long.class)); 2167 } 2168 2169 @Test 2170 @DisabledOnRavenwood(blockedBy = CompatChanges.class) testGetSerializableExtraTypeSafe_withMatchingType_returnsObject()2171 public void testGetSerializableExtraTypeSafe_withMatchingType_returnsObject() { 2172 String original = "Hello, World!"; 2173 mIntent.putExtra(TEST_EXTRA_NAME, original); 2174 roundtrip(); 2175 assertEquals(original, mIntent.getSerializableExtra(TEST_EXTRA_NAME, String.class)); 2176 } 2177 2178 @Test 2179 @DisabledOnRavenwood(blockedBy = CompatChanges.class) testGetSerializableExtraTypeSafe_withBaseType_returnsObject()2180 public void testGetSerializableExtraTypeSafe_withBaseType_returnsObject() { 2181 String original = "Hello, World!"; 2182 mIntent.putExtra(TEST_EXTRA_NAME, original); 2183 roundtrip(); 2184 assertEquals(original, mIntent.getSerializableExtra(TEST_EXTRA_NAME, Serializable.class)); 2185 } 2186 2187 @Test testReplaceExtras()2188 public void testReplaceExtras() { 2189 Bundle extras = new Bundle(); 2190 String bundleKey = "testKey"; 2191 String bundleValue = "testValue"; 2192 extras.putString(bundleKey, bundleValue); 2193 2194 Intent intent = mIntent.replaceExtras(extras); 2195 assertSame(mIntent, intent); 2196 String actualValue = intent.getExtras().getString(bundleKey); 2197 assertEquals(bundleValue, actualValue); 2198 2199 Intent src = new Intent(); 2200 String intentName = "srcName"; 2201 String intentValue = "srcValue"; 2202 src.putExtra(intentName, intentValue); 2203 2204 intent = mIntent.replaceExtras(src); 2205 assertSame(mIntent, intent); 2206 actualValue = intent.getExtras().getString(intentName); 2207 assertEquals(intentValue, actualValue); 2208 } 2209 2210 @Test testNormalizeMimeType()2211 public void testNormalizeMimeType() { 2212 assertEquals(null, Intent.normalizeMimeType(null)); 2213 assertEquals("text/plain", Intent.normalizeMimeType("text/plain; charset=UTF-8")); 2214 assertEquals("text/x-vcard", Intent.normalizeMimeType("text/x-vCard")); 2215 assertEquals("foo/bar", Intent.normalizeMimeType(" foo/bar ")); 2216 } 2217 2218 @Test testIntegerEncoding()2219 public void testIntegerEncoding() throws Exception { 2220 var intent = new Intent("action#action") 2221 .setFlags(FLAG_RECEIVER_OFFLOAD | FLAG_RECEIVER_FOREGROUND) 2222 .addExtendedFlags(FLAG_RECEIVER_OFFLOAD) 2223 .addExtendedFlags(FLAG_RECEIVER_FOREGROUND); 2224 var uri = intent.toUri(Intent.URI_INTENT_SCHEME); 2225 var otherIntent = Intent.parseUri(uri, Intent.URI_INTENT_SCHEME); 2226 2227 assertEquals(otherIntent.getFlags(), intent.getFlags()); 2228 assertEquals(otherIntent.getExtendedFlags(), intent.getExtendedFlags()); 2229 2230 var badUri = "intent:#Intent;action=action%23action;launchFlags=0x990000000;" 2231 + "extendedLaunchFlags=0x890000000;end"; 2232 assertThrows(NumberFormatException.class, 2233 () -> Intent.parseUri(badUri, Intent.URI_INTENT_SCHEME)); 2234 } 2235 2236 @Test testEncoding()2237 public void testEncoding() throws URISyntaxException { 2238 // This doesn't validate setPackage, as it's not possible to have both an explicit package 2239 // and a selector but the inner selector Intent later on will cover setPackage 2240 var intent = new Intent("action#base") 2241 .setClassName("com.example.test.app", "com.example.test.app.IntendedActivity") 2242 .addCategory("category#base") 2243 .setType("type#base") 2244 .setIdentifier("identifier#base") 2245 .setComponent(ComponentName.createRelative("package.sub#base", ".Class#Base")) 2246 .putExtra("extraKey#base", "extraValue#base"); 2247 2248 // Insert malicious scheme to be encoded to avoid deserialization errors (b/261858325) 2249 var badUri = Uri.fromParts(new Intent() 2250 .setClassName("com.example.malicious.app", 2251 "com.example.malicious.app.MaliciousActivity") 2252 .toUri(Intent.URI_INTENT_SCHEME), 2253 "", null); 2254 var selectorIntent = new Intent().setData(badUri) 2255 .addCategory("category#selector") 2256 .setType("type#selector") 2257 .setIdentifier("identifier#selector") 2258 .setPackage("package#selector") 2259 .setComponent( 2260 ComponentName.createRelative("package.sub#selector", ".Class#Selector")) 2261 .putExtra("extraKey#selector", "extraValue#selector"); 2262 intent.setSelector(selectorIntent); 2263 2264 intent.setFlags(FLAG_RECEIVER_OFFLOAD | FLAG_RECEIVER_FOREGROUND); 2265 2266 var uriString = intent.toUri(Intent.URI_INTENT_SCHEME); 2267 var deserialized = Intent.parseUri(uriString, Intent.URI_INTENT_SCHEME); 2268 2269 assertThat(uriString).isEqualTo( 2270 "intent:#Intent;action=action%23base;category=category%23base;type=type%23base;" 2271 + "identifier=identifier%23base;launchFlags=0x90000000;" 2272 + "component=package.sub%23base/" 2273 + ".Class%23Base;S.extraKey%23base=extraValue%23base;SEL;" 2274 + "category=category%23selector;type=type%23selector;" 2275 + "identifier=identifier%23selector;package=package%23selector;" 2276 + "component=package.sub%23selector/.Class%23Selector;S" 2277 + ".extraKey%23selector=extraValue%23selector;end"); 2278 2279 assertThat(deserialized.toInsecureString()) 2280 .isEqualTo(intent.toInsecureString()); 2281 } 2282 2283 @Test 2284 @RequiresFlagsEnabled(Flags.FLAG_PREVENT_INTENT_REDIRECT) testRemoveLaunchSecurityProtection()2285 public void testRemoveLaunchSecurityProtection() { 2286 Intent intent = new Intent(TEST_ACTION); 2287 intent.setCreatorToken(new Binder()); 2288 intent.addExtendedFlags(EXTENDED_FLAG_MISSING_CREATOR_OR_INVALID_TOKEN); 2289 intent.removeLaunchSecurityProtection(); 2290 assertThat(intent.getExtendedFlags()).isEqualTo(0); 2291 assertThat(intent.getCreatorToken()).isNull(); 2292 } 2293 roundtrip()2294 private void roundtrip() { 2295 Parcel p = Parcel.obtain(); 2296 p.writeParcelable(mIntent, 0); 2297 p.setDataPosition(0); 2298 mIntent = p.readParcelable(getClass().getClassLoader(), Intent.class); 2299 mIntent.setExtrasClassLoader(getClass().getClassLoader()); 2300 } 2301 2302 public static class TestSerializable implements Serializable { 2303 static final long serialVersionUID = 1l; 2304 public String Name; 2305 } 2306 2307 public static class TestParcelable implements Parcelable { 2308 public final int value; 2309 TestParcelable(int value)2310 TestParcelable(int value) { 2311 this.value = value; 2312 } 2313 TestParcelable(Parcel in)2314 protected TestParcelable(Parcel in) { 2315 value = in.readInt(); 2316 } 2317 2318 @Override describeContents()2319 public int describeContents() { 2320 return 0; 2321 } 2322 2323 @Override writeToParcel(Parcel out, int flags)2324 public void writeToParcel(Parcel out, int flags) { 2325 out.writeInt(value); 2326 } 2327 2328 @Override equals(Object other)2329 public boolean equals(Object other) { 2330 if (this == other) { 2331 return true; 2332 } 2333 if (!(other instanceof TestParcelable)) { 2334 return false; 2335 } 2336 TestParcelable that = (TestParcelable) other; 2337 return value == that.value; 2338 } 2339 2340 @Override hashCode()2341 public int hashCode() { 2342 return value; 2343 } 2344 2345 public static final Creator<TestParcelable> CREATOR = new Creator<TestParcelable>() { 2346 @Override 2347 public TestParcelable createFromParcel(Parcel in) { 2348 return new TestParcelable(in); 2349 } 2350 @Override 2351 public TestParcelable[] newArray(int size) { 2352 return new TestParcelable[size]; 2353 } 2354 }; 2355 } 2356 } 2357