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