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