1 /*
2  * Copyright (C) 2006 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.app.activity;
18 
19 import android.app.Activity;
20 import android.app.ActivityManager;
21 import android.app.BroadcastOptions;
22 import android.app.PendingIntent;
23 import android.content.BroadcastReceiver;
24 import android.content.Context;
25 import android.content.Intent;
26 import android.content.IntentFilter;
27 import android.os.Binder;
28 import android.os.Bundle;
29 import android.os.IBinder;
30 import android.os.Parcel;
31 import android.os.UserHandle;
32 import android.util.Log;
33 
34 import androidx.test.filters.FlakyTest;
35 import androidx.test.filters.LargeTest;
36 
37 @LargeTest
38 public class BroadcastTest extends ActivityTestsBase {
39     public static final int BROADCAST_TIMEOUT = 5 * 1000;
40 
41     public static final String BROADCAST_REGISTERED =
42             "com.android.frameworks.coretests.activity.BROADCAST_REGISTERED";
43     public static final String BROADCAST_LOCAL =
44             "com.android.frameworks.coretests.activity.BROADCAST_LOCAL";
45     public static final String BROADCAST_LOCAL_GRANTED =
46             "com.android.frameworks.coretests.activity.BROADCAST_LOCAL_GRANTED";
47     public static final String BROADCAST_LOCAL_DENIED =
48             "com.android.frameworks.coretests.activity.BROADCAST_LOCAL_DENIED";
49     public static final String BROADCAST_REMOTE =
50             "com.android.frameworks.coretests.activity.BROADCAST_REMOTE";
51     public static final String BROADCAST_REMOTE_GRANTED =
52             "com.android.frameworks.coretests.activity.BROADCAST_REMOTE_GRANTED";
53     public static final String BROADCAST_REMOTE_DENIED =
54             "com.android.frameworks.coretests.activity.BROADCAST_REMOTE_DENIED";
55     public static final String BROADCAST_ALL =
56             "com.android.frameworks.coretests.activity.BROADCAST_ALL";
57     public static final String BROADCAST_MULTI =
58             "com.android.frameworks.coretests.activity.BROADCAST_MULTI";
59     public static final String BROADCAST_ABORT =
60             "com.android.frameworks.coretests.activity.BROADCAST_ABORT";
61 
62     public static final String BROADCAST_STICKY1 =
63             "com.android.frameworks.coretests.activity.BROADCAST_STICKY1";
64     public static final String BROADCAST_STICKY2 =
65             "com.android.frameworks.coretests.activity.BROADCAST_STICKY2";
66 
67     public static final String BROADCAST_FAIL_REGISTER =
68             "com.android.frameworks.coretests.activity.BROADCAST_FAIL_REGISTER";
69     public static final String BROADCAST_FAIL_BIND =
70             "com.android.frameworks.coretests.activity.BROADCAST_FAIL_BIND";
71 
72     public static final String RECEIVER_REG = "receiver-reg";
73     public static final String RECEIVER_LOCAL = "receiver-local";
74     public static final String RECEIVER_REMOTE = "receiver-remote";
75     public static final String RECEIVER_ABORT = "receiver-abort";
76     public static final String RECEIVER_RESULTS = "receiver-results";
77 
78     public static final String DATA_1 = "one";
79     public static final String DATA_2 = "two";
80 
81     public static final int GOT_RECEIVE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION;
82     public static final int ERROR_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 1;
83 
84     private String[] mExpectedReceivers = null;
85     private int mNextReceiver;
86 
87     private String[] mExpectedData = null;
88     private boolean[] mReceivedData = null;
89 
90     boolean mReceiverRegistered = false;
91 
setExpectedReceivers(String[] receivers)92     public void setExpectedReceivers(String[] receivers) {
93         mExpectedReceivers = receivers;
94         mNextReceiver = 0;
95     }
96 
setExpectedData(String[] data)97     public void setExpectedData(String[] data) {
98         mExpectedData = data;
99         mReceivedData = new boolean[data.length];
100     }
101 
onTimeout()102     public void onTimeout() {
103         String msg = "Timeout";
104         if (mExpectedReceivers != null && mNextReceiver < mExpectedReceivers.length) {
105             msg = msg + " waiting for " + mExpectedReceivers[mNextReceiver];
106         }
107         finishBad(msg);
108     }
109 
makeBroadcastIntent(String action)110     public Intent makeBroadcastIntent(String action) {
111         Intent intent = new Intent(action, null);
112         intent.putExtra("caller", mCallTarget);
113         return intent;
114     }
115 
finishWithResult(int resultCode, Intent data)116     public void finishWithResult(int resultCode, Intent data) {
117         unregisterMyReceiver();
118         super.finishWithResult(resultCode, data);
119     }
120 
gotReceive(String name, Intent intent)121     public final void gotReceive(String name, Intent intent) {
122         synchronized (this) {
123 
124             //System.out.println("Got receive: " + name);
125             //System.out.println(mNextReceiver + " in " + mExpectedReceivers);
126             //new RuntimeException("stack").printStackTrace();
127 
128             addIntermediate(name);
129 
130             if (mExpectedData != null) {
131                 int n = mExpectedData.length;
132                 int i;
133                 boolean prev = false;
134                 for (i = 0; i < n; i++) {
135                     if (mExpectedData[i].equals(intent.getStringExtra("test"))) {
136                         if (mReceivedData[i]) {
137                             prev = true;
138                             continue;
139                         }
140                         mReceivedData[i] = true;
141                         break;
142                     }
143                 }
144                 if (i >= n) {
145                     if (prev) {
146                         finishBad("Receive got data too many times: "
147                                 + intent.getStringExtra("test"));
148                     } else {
149                         finishBad("Receive got unexpected data: "
150                                 + intent.getStringExtra("test"));
151                     }
152                     new RuntimeException("stack").printStackTrace();
153                     return;
154                 }
155             }
156 
157             if (mNextReceiver >= mExpectedReceivers.length) {
158                 finishBad("Got too many onReceiveIntent() calls!");
159 //                System.out.println("Too many intents received: now at "
160 //                        + mNextReceiver + ", expect list: "
161 //                        + Arrays.toString(mExpectedReceivers));
162                 fail("Got too many onReceiveIntent() calls!");
163             } else if (!mExpectedReceivers[mNextReceiver].equals(name)) {
164                 finishBad("Receive out of order: got " + name
165                         + " but expected "
166                         + mExpectedReceivers[mNextReceiver]);
167                 fail("Receive out of order: got " + name
168                         + " but expected "
169                         + mExpectedReceivers[mNextReceiver]);
170             } else {
171                 mNextReceiver++;
172                 if (mNextReceiver == mExpectedReceivers.length) {
173                     finishTest();
174                 }
175             }
176         }
177     }
178 
registerMyReceiver(IntentFilter filter, String permission)179     public void registerMyReceiver(IntentFilter filter, String permission) {
180         mReceiverRegistered = true;
181         //System.out.println("Registering: " + mReceiver);
182         getContext().registerReceiver(mReceiver, filter, permission, null);
183     }
184 
unregisterMyReceiver()185     public void unregisterMyReceiver() {
186         if (mReceiverRegistered) {
187             unregisterMyReceiverNoCheck();
188         }
189     }
190 
unregisterMyReceiverNoCheck()191     public void unregisterMyReceiverNoCheck() {
192         mReceiverRegistered = false;
193         //System.out.println("Unregistering: " + mReceiver);
194         getContext().unregisterReceiver(mReceiver);
195     }
196 
onRegisteredReceiver(Intent intent)197     public void onRegisteredReceiver(Intent intent) {
198         gotReceive(RECEIVER_REG, intent);
199     }
200 
201     private Binder mCallTarget = new Binder() {
202         public boolean onTransact(int code, Parcel data, Parcel reply,
203                 int flags) {
204             data.setDataPosition(0);
205             data.enforceInterface(LaunchpadActivity.LAUNCH);
206             if (code == GOT_RECEIVE_TRANSACTION) {
207                 String name = data.readString();
208                 gotReceive(name, null);
209                 return true;
210             } else if (code == ERROR_TRANSACTION) {
211                 finishBad(data.readString());
212                 return true;
213             }
214             return false;
215         }
216     };
217 
finishTest()218     private void finishTest() {
219         if (mReceiverRegistered) {
220             addIntermediate("before-unregister");
221             unregisterMyReceiver();
222         }
223         finishTiming(true);
224         finishGood();
225     }
226 
227     private BroadcastReceiver mReceiver = new BroadcastReceiver() {
228         public void onReceive(Context context, Intent intent) {
229             //System.out.println("Receive in: " + this + ": " + intent);
230             onRegisteredReceiver(intent);
231         }
232     };
233 
234     // Mark flaky until http://b/issue?id=1191607 is resolved.
235     @FlakyTest
testRegistered()236     public void testRegistered() throws Exception {
237         runLaunchpad(LaunchpadActivity.BROADCAST_REGISTERED);
238     }
239 
testLocal()240     public void testLocal() throws Exception {
241         runLaunchpad(LaunchpadActivity.BROADCAST_LOCAL);
242     }
243 
testRemote()244     public void testRemote() throws Exception {
245         runLaunchpad(LaunchpadActivity.BROADCAST_REMOTE);
246     }
247 
testAbort()248     public void testAbort() throws Exception {
249         runLaunchpad(LaunchpadActivity.BROADCAST_ABORT);
250     }
251 
252     @FlakyTest
testAll()253     public void testAll() throws Exception {
254         runLaunchpad(LaunchpadActivity.BROADCAST_ALL);
255     }
256 
257     @FlakyTest
testMulti()258     public void testMulti() throws Exception {
259         runLaunchpad(LaunchpadActivity.BROADCAST_MULTI);
260     }
261 
262     private class TestBroadcastReceiver extends BroadcastReceiver {
263         public boolean mHaveResult = false;
264 
265         @Override
onReceive(Context context, Intent intent)266         public void onReceive(Context context, Intent intent) {
267             synchronized (BroadcastTest.this) {
268                 mHaveResult = true;
269                 BroadcastTest.this.notifyAll();
270             }
271         }
272     }
273 
testResult()274     public void testResult() throws Exception {
275         TestBroadcastReceiver broadcastReceiver = new TestBroadcastReceiver();
276 
277         synchronized (this) {
278             Bundle map = new Bundle();
279             map.putString("foo", "you");
280             map.putString("remove", "me");
281             getContext().sendOrderedBroadcast(
282                     new Intent("com.android.frameworks.coretests.activity.BROADCAST_RESULT"),
283                     null, broadcastReceiver, null, 1, "foo", map);
284             while (!broadcastReceiver.mHaveResult) {
285                 try {
286                     wait();
287                 } catch (InterruptedException e) {
288                 }
289             }
290 
291             //System.out.println("Code: " + mResultCode + ", data: " + mResultData);
292             //System.out.println("Extras: " + mResultExtras);
293 
294             assertEquals("Incorrect code: " + broadcastReceiver.getResultCode(),
295                     3, broadcastReceiver.getResultCode());
296 
297             assertEquals("bar", broadcastReceiver.getResultData());
298 
299             Bundle resultExtras = broadcastReceiver.getResultExtras(false);
300             assertEquals("them", resultExtras.getString("bar"));
301             assertEquals("you", resultExtras.getString("foo"));
302             assertNull(resultExtras.getString("remove"));
303         }
304     }
305 
testSetSticky()306     public void testSetSticky() throws Exception {
307         Intent intent = new Intent(LaunchpadActivity.BROADCAST_STICKY1, null);
308         intent.putExtra("test", LaunchpadActivity.DATA_1);
309         ActivityManager.getService().unbroadcastIntent(null, intent,
310                 UserHandle.myUserId());
311 
312         ActivityManager.broadcastStickyIntent(intent, UserHandle.myUserId());
313         addIntermediate("finished-broadcast");
314 
315         IntentFilter filter = new IntentFilter(LaunchpadActivity.BROADCAST_STICKY1);
316         Intent sticky = getContext().registerReceiver(null, filter);
317         assertNotNull("Sticky not found", sticky);
318         assertEquals(LaunchpadActivity.DATA_1, sticky.getStringExtra("test"));
319     }
320 
testClearSticky()321     public void testClearSticky() throws Exception {
322         Intent intent = new Intent(LaunchpadActivity.BROADCAST_STICKY1, null);
323         intent.putExtra("test", LaunchpadActivity.DATA_1);
324         ActivityManager.broadcastStickyIntent(intent, UserHandle.myUserId());
325 
326         ActivityManager.getService().unbroadcastIntent(
327                 null, new Intent(LaunchpadActivity.BROADCAST_STICKY1, null),
328                 UserHandle.myUserId());
329         addIntermediate("finished-unbroadcast");
330 
331         IntentFilter filter = new IntentFilter(LaunchpadActivity.BROADCAST_STICKY1);
332         Intent sticky = getContext().registerReceiver(null, filter);
333         assertNull("Sticky not found", sticky);
334     }
335 
testReplaceSticky()336     public void testReplaceSticky() throws Exception {
337         Intent intent = new Intent(LaunchpadActivity.BROADCAST_STICKY1, null);
338         intent.putExtra("test", LaunchpadActivity.DATA_1);
339         ActivityManager.broadcastStickyIntent(intent, UserHandle.myUserId());
340         intent.putExtra("test", LaunchpadActivity.DATA_2);
341 
342         ActivityManager.broadcastStickyIntent(intent, UserHandle.myUserId());
343         addIntermediate("finished-broadcast");
344 
345         IntentFilter filter = new IntentFilter(LaunchpadActivity.BROADCAST_STICKY1);
346         Intent sticky = getContext().registerReceiver(null, filter);
347         assertNotNull("Sticky not found", sticky);
348         assertEquals(LaunchpadActivity.DATA_2, sticky.getStringExtra("test"));
349     }
350 
351     // Marking flaky until http://b/issue?id=1191337 is resolved
352     @FlakyTest
testReceiveSticky()353     public void testReceiveSticky() throws Exception {
354         Intent intent = new Intent(LaunchpadActivity.BROADCAST_STICKY1, null);
355         intent.putExtra("test", LaunchpadActivity.DATA_1);
356         ActivityManager.broadcastStickyIntent(intent, UserHandle.myUserId());
357 
358         runLaunchpad(LaunchpadActivity.BROADCAST_STICKY1);
359     }
360 
361     // Marking flaky until http://b/issue?id=1191337 is resolved
362     @FlakyTest
testReceive2Sticky()363     public void testReceive2Sticky() throws Exception {
364         Intent intent = new Intent(LaunchpadActivity.BROADCAST_STICKY1, null);
365         intent.putExtra("test", LaunchpadActivity.DATA_1);
366         ActivityManager.broadcastStickyIntent(intent, UserHandle.myUserId());
367         intent = new Intent(LaunchpadActivity.BROADCAST_STICKY2, null);
368         intent.putExtra("test", LaunchpadActivity.DATA_2);
369         ActivityManager.broadcastStickyIntent(intent, UserHandle.myUserId());
370 
371         runLaunchpad(LaunchpadActivity.BROADCAST_STICKY2);
372     }
373 
testRegisteredReceivePermissionGranted()374     public void testRegisteredReceivePermissionGranted() throws Exception {
375         setExpectedReceivers(new String[]{RECEIVER_REG});
376         registerMyReceiver(new IntentFilter(BROADCAST_REGISTERED), PERMISSION_GRANTED);
377         addIntermediate("after-register");
378         getContext().sendBroadcast(makeBroadcastIntent(BROADCAST_REGISTERED));
379         waitForResultOrThrow(BROADCAST_TIMEOUT);
380     }
381 
testRegisteredReceivePermissionDenied()382     public void testRegisteredReceivePermissionDenied() throws Exception {
383         setExpectedReceivers(new String[]{RECEIVER_RESULTS});
384         registerMyReceiver(new IntentFilter(BROADCAST_REGISTERED), PERMISSION_DENIED);
385         addIntermediate("after-register");
386 
387         BroadcastReceiver finish = new BroadcastReceiver() {
388             public void onReceive(Context context, Intent intent) {
389                 gotReceive(RECEIVER_RESULTS, intent);
390             }
391         };
392 
393         getContext().sendOrderedBroadcast(
394                 makeBroadcastIntent(BROADCAST_REGISTERED),
395                 null, finish, null, Activity.RESULT_CANCELED, null, null);
396         waitForResultOrThrow(BROADCAST_TIMEOUT);
397     }
398 
testRegisteredBroadcastPermissionGranted()399     public void testRegisteredBroadcastPermissionGranted() throws Exception {
400         setExpectedReceivers(new String[]{RECEIVER_REG});
401         registerMyReceiver(new IntentFilter(BROADCAST_REGISTERED), null);
402         addIntermediate("after-register");
403         getContext().sendBroadcast(
404                 makeBroadcastIntent(BROADCAST_REGISTERED),
405                 PERMISSION_GRANTED);
406         waitForResultOrThrow(BROADCAST_TIMEOUT);
407     }
408 
testRegisteredBroadcastPermissionDenied()409     public void testRegisteredBroadcastPermissionDenied() throws Exception {
410         setExpectedReceivers(new String[]{RECEIVER_RESULTS});
411         registerMyReceiver(new IntentFilter(BROADCAST_REGISTERED), null);
412         addIntermediate("after-register");
413 
414         BroadcastReceiver finish = new BroadcastReceiver() {
415             public void onReceive(Context context, Intent intent) {
416                 gotReceive(RECEIVER_RESULTS, intent);
417             }
418         };
419 
420         getContext().sendOrderedBroadcast(
421                 makeBroadcastIntent(BROADCAST_REGISTERED),
422                 PERMISSION_DENIED, finish, null, Activity.RESULT_CANCELED,
423                 null, null);
424         waitForResultOrThrow(BROADCAST_TIMEOUT);
425     }
426 
testLocalReceivePermissionGranted()427     public void testLocalReceivePermissionGranted() throws Exception {
428         setExpectedReceivers(new String[]{RECEIVER_LOCAL});
429         getContext().sendBroadcast(makeBroadcastIntent(BROADCAST_LOCAL_GRANTED));
430         waitForResultOrThrow(BROADCAST_TIMEOUT);
431     }
432 
testLocalReceivePermissionDenied()433     public void testLocalReceivePermissionDenied() throws Exception {
434         setExpectedReceivers(new String[]{RECEIVER_RESULTS});
435 
436         BroadcastReceiver finish = new BroadcastReceiver() {
437             public void onReceive(Context context, Intent intent) {
438                 gotReceive(RECEIVER_RESULTS, intent);
439             }
440         };
441 
442         getContext().sendOrderedBroadcast(
443                 makeBroadcastIntent(BROADCAST_LOCAL_DENIED),
444                 null, finish, null, Activity.RESULT_CANCELED,
445                 null, null);
446         waitForResultOrThrow(BROADCAST_TIMEOUT);
447     }
448 
testLocalBroadcastPermissionGranted()449     public void testLocalBroadcastPermissionGranted() throws Exception {
450         setExpectedReceivers(new String[]{RECEIVER_LOCAL});
451         getContext().sendBroadcast(
452                 makeBroadcastIntent(BROADCAST_LOCAL),
453                 PERMISSION_GRANTED);
454         waitForResultOrThrow(BROADCAST_TIMEOUT);
455     }
456 
testLocalBroadcastPermissionDenied()457     public void testLocalBroadcastPermissionDenied() throws Exception {
458         setExpectedReceivers(new String[]{RECEIVER_RESULTS});
459 
460         BroadcastReceiver finish = new BroadcastReceiver() {
461             public void onReceive(Context context, Intent intent) {
462                 gotReceive(RECEIVER_RESULTS, intent);
463             }
464         };
465 
466         getContext().sendOrderedBroadcast(
467                 makeBroadcastIntent(BROADCAST_LOCAL),
468                 PERMISSION_DENIED, finish, null, Activity.RESULT_CANCELED,
469                 null, null);
470         waitForResultOrThrow(BROADCAST_TIMEOUT);
471     }
472 
testRemoteReceivePermissionGranted()473     public void testRemoteReceivePermissionGranted() throws Exception {
474         setExpectedReceivers(new String[]{RECEIVER_REMOTE});
475         getContext().sendBroadcast(makeBroadcastIntent(BROADCAST_REMOTE_GRANTED));
476         waitForResultOrThrow(BROADCAST_TIMEOUT);
477     }
478 
testRemoteReceivePermissionDenied()479     public void testRemoteReceivePermissionDenied() throws Exception {
480         setExpectedReceivers(new String[]{RECEIVER_RESULTS});
481 
482         BroadcastReceiver finish = new BroadcastReceiver() {
483             public void onReceive(Context context, Intent intent) {
484                 gotReceive(RECEIVER_RESULTS, intent);
485             }
486         };
487 
488         getContext().sendOrderedBroadcast(
489                 makeBroadcastIntent(BROADCAST_REMOTE_DENIED),
490                 null, finish, null, Activity.RESULT_CANCELED,
491                 null, null);
492         waitForResultOrThrow(BROADCAST_TIMEOUT);
493     }
494 
testRemoteBroadcastPermissionGranted()495     public void testRemoteBroadcastPermissionGranted() throws Exception {
496         setExpectedReceivers(new String[]{RECEIVER_REMOTE});
497         getContext().sendBroadcast(
498                 makeBroadcastIntent(BROADCAST_REMOTE),
499                 PERMISSION_GRANTED);
500         waitForResultOrThrow(BROADCAST_TIMEOUT);
501     }
502 
testRemoteBroadcastPermissionDenied()503     public void testRemoteBroadcastPermissionDenied() throws Exception {
504         setExpectedReceivers(new String[]{RECEIVER_RESULTS});
505 
506         BroadcastReceiver finish = new BroadcastReceiver() {
507             public void onReceive(Context context, Intent intent) {
508                 gotReceive(RECEIVER_RESULTS, intent);
509             }
510         };
511 
512         getContext().sendOrderedBroadcast(
513                 makeBroadcastIntent(BROADCAST_REMOTE),
514                 PERMISSION_DENIED, finish, null, Activity.RESULT_CANCELED,
515                 null, null);
516         waitForResultOrThrow(BROADCAST_TIMEOUT);
517     }
518 
testReceiverCanNotRegister()519     public void testReceiverCanNotRegister() throws Exception {
520         setExpectedReceivers(new String[]{RECEIVER_LOCAL});
521         getContext().sendBroadcast(makeBroadcastIntent(BROADCAST_FAIL_REGISTER));
522         waitForResultOrThrow(BROADCAST_TIMEOUT);
523     }
524 
testReceiverCanNotBind()525     public void testReceiverCanNotBind() throws Exception {
526         setExpectedReceivers(new String[]{RECEIVER_LOCAL});
527         getContext().sendBroadcast(makeBroadcastIntent(BROADCAST_FAIL_BIND));
528         waitForResultOrThrow(BROADCAST_TIMEOUT);
529     }
530 
testLocalUnregisterTwice()531     public void testLocalUnregisterTwice() throws Exception {
532         registerMyReceiver(new IntentFilter(BROADCAST_REGISTERED), null);
533         unregisterMyReceiverNoCheck();
534         try {
535             unregisterMyReceiverNoCheck();
536             fail("No exception thrown on second unregister");
537         } catch (IllegalArgumentException e) {
538             Log.i("foo", "Unregister exception", e);
539         }
540     }
541 
testBroadcastOption_interactive()542     public void testBroadcastOption_interactive() throws Exception {
543         final BroadcastOptions options = BroadcastOptions.makeBasic();
544         options.setInteractive(true);
545         final Intent intent = makeBroadcastIntent(BROADCAST_REGISTERED);
546 
547         try {
548             getContext().sendBroadcast(intent, null, options.toBundle());
549             fail("No exception thrown with BroadcastOptions.setInteractive(true)");
550         } catch (SecurityException se) {
551             // Expected, correct behavior - this case intentionally empty
552         } catch (Exception e) {
553             fail("Unexpected exception " + e.getMessage()
554                     + " thrown with BroadcastOptions.setInteractive(true)");
555         }
556     }
557 
testBroadcastOption_interactive_PendingIntent()558     public void testBroadcastOption_interactive_PendingIntent() throws Exception {
559         final BroadcastOptions options = BroadcastOptions.makeBasic();
560         options.setInteractive(true);
561         final Intent intent = makeBroadcastIntent(BROADCAST_REGISTERED);
562         PendingIntent brPending = PendingIntent.getBroadcast(getContext(),
563                 1, intent, PendingIntent.FLAG_IMMUTABLE);
564 
565         try {
566             brPending.send(getContext(), 1, null, null, null, null, options.toBundle());
567             fail("No exception thrown with BroadcastOptions.setInteractive(true)");
568         } catch (SecurityException se) {
569             // Expected, correct behavior - this case intentionally empty
570         } catch (Exception e) {
571             fail("Unexpected exception " + e.getMessage()
572                     + " thrown with BroadcastOptions.setInteractive(true)");
573         } finally {
574             brPending.cancel();
575         }
576     }
577 }
578