• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2008 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.content.cts;
18 
19 import static android.Manifest.permission.READ_WALLPAPER_INTERNAL;
20 import static android.content.pm.PackageManager.PERMISSION_DENIED;
21 import static android.content.pm.PackageManager.PERMISSION_GRANTED;
22 
23 import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;
24 
25 import android.app.Activity;
26 import android.app.AppOpsManager;
27 import android.app.BroadcastOptions;
28 import android.app.Instrumentation;
29 import android.app.WallpaperManager;
30 import android.content.ActivityNotFoundException;
31 import android.content.AttributionSource;
32 import android.content.BroadcastReceiver;
33 import android.content.ComponentName;
34 import android.content.Context;
35 import android.content.ContextParams;
36 import android.content.Intent;
37 import android.content.IntentFilter;
38 import android.content.ServiceConnection;
39 import android.content.SharedPreferences;
40 import android.content.pm.PackageManager;
41 import android.content.res.ColorStateList;
42 import android.content.res.Resources.NotFoundException;
43 import android.content.res.Resources.Theme;
44 import android.content.res.TypedArray;
45 import android.content.res.XmlResourceParser;
46 import android.database.Cursor;
47 import android.database.sqlite.SQLiteCursorDriver;
48 import android.database.sqlite.SQLiteDatabase;
49 import android.database.sqlite.SQLiteQuery;
50 import android.graphics.Bitmap;
51 import android.graphics.drawable.BitmapDrawable;
52 import android.graphics.drawable.Drawable;
53 import android.net.Uri;
54 import android.os.Binder;
55 import android.os.Bundle;
56 import android.os.Handler;
57 import android.os.IBinder;
58 import android.os.Looper;
59 import android.os.Process;
60 import android.os.UserHandle;
61 import android.platform.test.annotations.AppModeFull;
62 import android.preference.PreferenceManager;
63 import android.test.AndroidTestCase;
64 import android.test.suitebuilder.annotation.Suppress;
65 import android.util.AttributeSet;
66 import android.util.Log;
67 import android.util.Xml;
68 import android.view.WindowManager;
69 
70 import com.android.compatibility.common.util.PollingCheck;
71 import com.android.compatibility.common.util.ShellIdentityUtils;
72 import com.android.compatibility.common.util.SystemUtil;
73 import com.android.cts.IBinderPermissionTestService;
74 
75 import org.xmlpull.v1.XmlPullParser;
76 import org.xmlpull.v1.XmlPullParserException;
77 
78 import java.io.File;
79 import java.io.FileOutputStream;
80 import java.io.IOException;
81 import java.io.InputStream;
82 import java.util.ArrayList;
83 import java.util.Arrays;
84 import java.util.List;
85 
86 @AppModeFull // TODO(Instant) Figure out which APIs should work.
87 public class ContextTest extends AndroidTestCase {
88     private static final String TAG = "ContextTest";
89     private static final String ACTUAL_RESULT = "ResultSetByReceiver";
90 
91     private static final String INTIAL_RESULT = "IntialResult";
92 
93     private static final String VALUE_ADDED = "ValueAdded";
94     private static final String KEY_ADDED = "AddedByReceiver";
95 
96     private static final String VALUE_REMOVED = "ValueWillBeRemove";
97     private static final String KEY_REMOVED = "ToBeRemoved";
98 
99     private static final String VALUE_KEPT = "ValueKept";
100     private static final String KEY_KEPT = "ToBeKept";
101 
102     private static final String MOCK_STICKY_ACTION = "android.content.cts.ContextTest."
103             + "STICKY_BROADCAST_RESULT";
104 
105     private static final String ACTION_BROADCAST_TESTORDER =
106             "android.content.cts.ContextTest.BROADCAST_TESTORDER";
107     private final static String MOCK_ACTION1 = ACTION_BROADCAST_TESTORDER + "1";
108     private final static String MOCK_ACTION2 = ACTION_BROADCAST_TESTORDER + "2";
109 
110     // Note: keep these constants in sync with the permissions used by BinderPermissionTestService.
111     //
112     // A permission that's granted to this test package.
113     public static final String GRANTED_PERMISSION = "android.permission.USE_CREDENTIALS";
114     // A permission that's not granted to this test package.
115     public static final String NOT_GRANTED_PERMISSION = "android.permission.HARDWARE_TEST";
116 
117     private static final int BROADCAST_TIMEOUT = 10000;
118     private static final int ROOT_UID = 0;
119 
120     /**
121      * Shell command to broadcast {@link ResultReceiver#MOCK_ACTION} as an external app.
122      */
123     private static final String EXTERNAL_APP_BROADCAST_COMMAND =
124             "am broadcast -a " + ResultReceiver.MOCK_ACTION + " -f "
125                     + Intent.FLAG_RECEIVER_FOREGROUND;
126 
127     private Object mLockObj;
128 
129     private ArrayList<BroadcastReceiver> mRegisteredReceiverList;
130 
131     private boolean mWallpaperChanged;
132     private BitmapDrawable mOriginalWallpaper;
133     private volatile IBinderPermissionTestService mBinderPermissionTestService;
134     private ServiceConnection mBinderPermissionTestConnection;
135 
136     protected Context mContext;
137 
138     /**
139      * Returns the Context object that's being tested.
140      */
getContextUnderTest()141     protected Context getContextUnderTest() {
142         return getContext();
143     }
144 
145     @Override
setUp()146     protected void setUp() throws Exception {
147         super.setUp();
148         mContext = getContextUnderTest();
149         mContext.setTheme(R.style.Test_Theme);
150 
151         mLockObj = new Object();
152 
153         mRegisteredReceiverList = new ArrayList<BroadcastReceiver>();
154 
155         SystemUtil.runWithShellPermissionIdentity(
156                 () -> mOriginalWallpaper = (BitmapDrawable) mContext.getWallpaper(),
157                 READ_WALLPAPER_INTERNAL);
158     }
159 
160     @Override
tearDown()161     protected void tearDown() throws Exception {
162         if (mWallpaperChanged) {
163             mContext.setWallpaper(mOriginalWallpaper.getBitmap());
164         }
165 
166         for (BroadcastReceiver receiver : mRegisteredReceiverList) {
167             mContext.unregisterReceiver(receiver);
168         }
169 
170         super.tearDown();
171     }
172 
testGetString()173     public void testGetString() {
174         String testString = mContext.getString(R.string.context_test_string1);
175         assertEquals("This is %s string.", testString);
176 
177         testString = mContext.getString(R.string.context_test_string1, "expected");
178         assertEquals("This is expected string.", testString);
179 
180         testString = mContext.getString(R.string.context_test_string2);
181         assertEquals("This is test string.", testString);
182 
183         // Test wrong resource id
184         try {
185             testString = mContext.getString(0, "expected");
186             fail("Wrong resource id should not be accepted.");
187         } catch (NotFoundException e) {
188         }
189 
190         // Test wrong resource id
191         try {
192             testString = mContext.getString(0);
193             fail("Wrong resource id should not be accepted.");
194         } catch (NotFoundException e) {
195         }
196     }
197 
testGetText()198     public void testGetText() {
199         CharSequence testCharSequence = mContext.getText(R.string.context_test_string2);
200         assertEquals("This is test string.", testCharSequence.toString());
201 
202         // Test wrong resource id
203         try {
204             testCharSequence = mContext.getText(0);
205             fail("Wrong resource id should not be accepted.");
206         } catch (NotFoundException e) {
207         }
208     }
209 
testCreateAttributionContext()210     public void testCreateAttributionContext() throws Exception {
211         final String tag = "testCreateAttributionContext";
212         final Context attrib = mContext.createAttributionContext(tag);
213         assertEquals(tag, attrib.getAttributionTag());
214         assertEquals(null, mContext.getAttributionTag());
215     }
216 
testCreateAttributionContextFromParams()217     public void testCreateAttributionContextFromParams() throws Exception {
218         final ContextParams params = new ContextParams.Builder()
219                 .setAttributionTag("foo")
220                 .setNextAttributionSource(new AttributionSource.Builder(1)
221                         .setPackageName("bar")
222                         .setAttributionTag("baz")
223                         .build())
224                 .build();
225         final Context attributionContext = getContext().createContext(params);
226 
227         assertEquals(params, attributionContext.getParams());
228         assertEquals(params.getNextAttributionSource(),
229                 attributionContext.getAttributionSource().getNext());
230         assertEquals(params.getAttributionTag(),
231                 attributionContext.getAttributionSource().getAttributionTag());
232     }
233 
testContextParams()234     public void testContextParams() throws Exception {
235         final ContextParams params = new ContextParams.Builder()
236                 .setAttributionTag("foo")
237                 .setNextAttributionSource(new AttributionSource.Builder(1)
238                         .setPackageName("bar")
239                         .setAttributionTag("baz")
240                         .build())
241                 .build();
242 
243         assertEquals("foo", params.getAttributionTag());
244         assertEquals(1, params.getNextAttributionSource().getUid());
245         assertEquals("bar", params.getNextAttributionSource().getPackageName());
246         assertEquals("baz", params.getNextAttributionSource().getAttributionTag());
247     }
248 
testAttributionSourceSetNext()249     public void testAttributionSourceSetNext() throws Exception {
250         final AttributionSource next = new AttributionSource.Builder(2)
251                 .setPackageName("nextBar")
252                 .setAttributionTag("nextBaz")
253                 .build();
254         final ContextParams params = new ContextParams.Builder()
255                 .setAttributionTag("foo")
256                 .setNextAttributionSource(new AttributionSource.Builder(1)
257                         .setPackageName("bar")
258                         .setAttributionTag("baz")
259                         .setNext(next)
260                         .build())
261                 .build();
262 
263         // Setting a 'next' should not affect prev.
264         assertEquals("foo", params.getAttributionTag());
265         assertEquals(1, params.getNextAttributionSource().getUid());
266         assertEquals("bar", params.getNextAttributionSource().getPackageName());
267         assertEquals("baz", params.getNextAttributionSource().getAttributionTag());
268 
269         final AttributionSource check =
270                 params.getNextAttributionSource().getNext();
271         assertEquals(2, check.getUid());
272         assertEquals("nextBar", check.getPackageName());
273         assertEquals("nextBaz", check.getAttributionTag());
274     }
275 
testContextParams_Inherit()276     public void testContextParams_Inherit() throws Exception {
277         final ContextParams orig = new ContextParams.Builder()
278                 .setAttributionTag("foo").build();
279         {
280             final ContextParams params = new ContextParams.Builder(orig).build();
281             assertEquals("foo", params.getAttributionTag());
282         }
283         {
284             final ContextParams params = new ContextParams.Builder(orig)
285                     .setAttributionTag("bar").build();
286             assertEquals("bar", params.getAttributionTag());
287         }
288         {
289             final ContextParams params = new ContextParams.Builder(orig)
290                     .setAttributionTag(null).build();
291             assertEquals(null, params.getAttributionTag());
292         }
293     }
294 
295     /**
296      * Ensure that default and device encrypted storage areas are stored
297      * separately on disk. All devices must support these storage areas, even if
298      * they don't have file-based encryption, so that apps can go through a
299      * backup/restore cycle between FBE and non-FBE devices.
300      */
testCreateDeviceProtectedStorageContext()301     public void testCreateDeviceProtectedStorageContext() throws Exception {
302         final Context deviceContext = mContext.createDeviceProtectedStorageContext();
303 
304         assertFalse(mContext.isDeviceProtectedStorage());
305         assertTrue(deviceContext.isDeviceProtectedStorage());
306 
307         final File defaultFile = new File(mContext.getFilesDir(), "test");
308         final File deviceFile = new File(deviceContext.getFilesDir(), "test");
309 
310         assertFalse(deviceFile.equals(defaultFile));
311 
312         deviceFile.createNewFile();
313 
314         // Make sure storage areas are mutually exclusive
315         assertFalse(defaultFile.exists());
316         assertTrue(deviceFile.exists());
317     }
318 
testMoveSharedPreferencesFrom()319     public void testMoveSharedPreferencesFrom() throws Exception {
320         final Context deviceContext = mContext.createDeviceProtectedStorageContext();
321 
322         mContext.getSharedPreferences("test", Context.MODE_PRIVATE).edit().putInt("answer", 42)
323                 .commit();
324 
325         // Verify that we can migrate
326         assertTrue(deviceContext.moveSharedPreferencesFrom(mContext, "test"));
327         assertEquals(0, mContext.getSharedPreferences("test", Context.MODE_PRIVATE)
328                 .getInt("answer", 0));
329         assertEquals(42, deviceContext.getSharedPreferences("test", Context.MODE_PRIVATE)
330                 .getInt("answer", 0));
331 
332         // Trying to migrate again when already done is a no-op
333         assertTrue(deviceContext.moveSharedPreferencesFrom(mContext, "test"));
334         assertEquals(0, mContext.getSharedPreferences("test", Context.MODE_PRIVATE)
335                 .getInt("answer", 0));
336         assertEquals(42, deviceContext.getSharedPreferences("test", Context.MODE_PRIVATE)
337                 .getInt("answer", 0));
338 
339         // Add a new value and verify that we can migrate back
340         deviceContext.getSharedPreferences("test", Context.MODE_PRIVATE).edit()
341                 .putInt("question", 24).commit();
342 
343         assertTrue(mContext.moveSharedPreferencesFrom(deviceContext, "test"));
344         assertEquals(42, mContext.getSharedPreferences("test", Context.MODE_PRIVATE)
345                 .getInt("answer", 0));
346         assertEquals(24, mContext.getSharedPreferences("test", Context.MODE_PRIVATE)
347                 .getInt("question", 0));
348         assertEquals(0, deviceContext.getSharedPreferences("test", Context.MODE_PRIVATE)
349                 .getInt("answer", 0));
350         assertEquals(0, deviceContext.getSharedPreferences("test", Context.MODE_PRIVATE)
351                 .getInt("question", 0));
352     }
353 
testMoveDatabaseFrom()354     public void testMoveDatabaseFrom() throws Exception {
355         final Context deviceContext = mContext.createDeviceProtectedStorageContext();
356 
357         SQLiteDatabase db = mContext.openOrCreateDatabase("test.db",
358                 Context.MODE_PRIVATE | Context.MODE_ENABLE_WRITE_AHEAD_LOGGING, null);
359         db.execSQL("CREATE TABLE list(item TEXT);");
360         db.execSQL("INSERT INTO list VALUES ('cat')");
361         db.execSQL("INSERT INTO list VALUES ('dog')");
362         db.close();
363 
364         // Verify that we can migrate
365         assertTrue(deviceContext.moveDatabaseFrom(mContext, "test.db"));
366         db = deviceContext.openOrCreateDatabase("test.db",
367                 Context.MODE_PRIVATE | Context.MODE_ENABLE_WRITE_AHEAD_LOGGING, null);
368         Cursor c = db.query("list", null, null, null, null, null, null);
369         assertEquals(2, c.getCount());
370         assertTrue(c.moveToFirst());
371         assertEquals("cat", c.getString(0));
372         assertTrue(c.moveToNext());
373         assertEquals("dog", c.getString(0));
374         c.close();
375         db.execSQL("INSERT INTO list VALUES ('mouse')");
376         db.close();
377 
378         // Trying to migrate again when already done is a no-op
379         assertTrue(deviceContext.moveDatabaseFrom(mContext, "test.db"));
380 
381         // Verify that we can migrate back
382         assertTrue(mContext.moveDatabaseFrom(deviceContext, "test.db"));
383         db = mContext.openOrCreateDatabase("test.db",
384                 Context.MODE_PRIVATE | Context.MODE_ENABLE_WRITE_AHEAD_LOGGING, null);
385         c = db.query("list", null, null, null, null, null, null);
386         assertEquals(3, c.getCount());
387         assertTrue(c.moveToFirst());
388         assertEquals("cat", c.getString(0));
389         assertTrue(c.moveToNext());
390         assertEquals("dog", c.getString(0));
391         assertTrue(c.moveToNext());
392         assertEquals("mouse", c.getString(0));
393         c.close();
394         db.close();
395     }
396 
testAccessTheme()397     public void testAccessTheme() {
398         mContext.setTheme(R.style.Test_Theme);
399         final Theme testTheme = mContext.getTheme();
400         assertNotNull(testTheme);
401 
402         int[] attrs = {
403             android.R.attr.windowNoTitle,
404             android.R.attr.panelColorForeground,
405             android.R.attr.panelColorBackground
406         };
407         TypedArray attrArray = null;
408         try {
409             attrArray = testTheme.obtainStyledAttributes(attrs);
410             assertTrue(attrArray.getBoolean(0, false));
411             assertEquals(0xff000000, attrArray.getColor(1, 0));
412             assertEquals(0xffffffff, attrArray.getColor(2, 0));
413         } finally {
414             if (attrArray != null) {
415                 attrArray.recycle();
416                 attrArray = null;
417             }
418         }
419 
420         // setTheme only works for the first time
421         mContext.setTheme(android.R.style.Theme_Black);
422         assertSame(testTheme, mContext.getTheme());
423     }
424 
testObtainStyledAttributes()425     public void testObtainStyledAttributes() {
426         // Test obtainStyledAttributes(int[])
427         TypedArray testTypedArray = mContext
428                 .obtainStyledAttributes(android.R.styleable.View);
429         assertNotNull(testTypedArray);
430         assertTrue(testTypedArray.length() > 2);
431         assertTrue(testTypedArray.length() > 0);
432         testTypedArray.recycle();
433 
434         // Test obtainStyledAttributes(int, int[])
435         testTypedArray = mContext.obtainStyledAttributes(android.R.style.TextAppearance_Small,
436                 android.R.styleable.TextAppearance);
437         assertNotNull(testTypedArray);
438         assertTrue(testTypedArray.length() > 2);
439         testTypedArray.recycle();
440 
441         // Test wrong null array pointer
442         try {
443             testTypedArray = mContext.obtainStyledAttributes(-1, null);
444             fail("obtainStyledAttributes will throw a NullPointerException here.");
445         } catch (NullPointerException e) {
446         }
447 
448         // Test obtainStyledAttributes(AttributeSet, int[]) with unavailable resource id.
449         int testInt[] = { 0, 0 };
450         testTypedArray = mContext.obtainStyledAttributes(-1, testInt);
451         // fail("Wrong resource id should not be accepted.");
452         assertNotNull(testTypedArray);
453         assertEquals(2, testTypedArray.length());
454         testTypedArray.recycle();
455 
456         // Test obtainStyledAttributes(AttributeSet, int[])
457         int[] attrs = android.R.styleable.DatePicker;
458         testTypedArray = mContext.obtainStyledAttributes(getAttributeSet(R.layout.context_layout),
459                 attrs);
460         assertNotNull(testTypedArray);
461         assertEquals(attrs.length, testTypedArray.length());
462         testTypedArray.recycle();
463 
464         // Test obtainStyledAttributes(AttributeSet, int[], int, int)
465         testTypedArray = mContext.obtainStyledAttributes(getAttributeSet(R.layout.context_layout),
466                 attrs, 0, 0);
467         assertNotNull(testTypedArray);
468         assertEquals(attrs.length, testTypedArray.length());
469         testTypedArray.recycle();
470     }
471 
testGetSystemService()472     public void testGetSystemService() {
473         // Test invalid service name
474         assertNull(mContext.getSystemService("invalid"));
475 
476         // Test valid service name
477         assertNotNull(mContext.getSystemService(Context.WINDOW_SERVICE));
478     }
479 
testGetSystemServiceByClass()480     public void testGetSystemServiceByClass() {
481         // Test invalid service class
482         assertNull(mContext.getSystemService(Object.class));
483 
484         // Test valid service name
485         assertNotNull(mContext.getSystemService(WindowManager.class));
486         assertEquals(mContext.getSystemService(Context.WINDOW_SERVICE),
487                 mContext.getSystemService(WindowManager.class));
488     }
489 
testGetColorStateList()490     public void testGetColorStateList() {
491         try {
492             mContext.getColorStateList(0);
493             fail("Failed at testGetColorStateList");
494         } catch (NotFoundException e) {
495             //expected
496         }
497 
498         final ColorStateList colorStateList = mContext.getColorStateList(R.color.color2);
499         final int[] focusedState = {android.R.attr.state_focused};
500         final int focusColor = colorStateList.getColorForState(focusedState, R.color.failColor);
501         assertEquals(0xffff0000, focusColor);
502     }
503 
testGetColor()504     public void testGetColor() {
505         try {
506             mContext.getColor(0);
507             fail("Failed at testGetColor");
508         } catch (NotFoundException e) {
509             //expected
510         }
511 
512         final int color = mContext.getColor(R.color.color2);
513         assertEquals(0xffffff00, color);
514     }
515 
516     /**
517      * Developers have come to expect at least ext4-style filename behavior, so
518      * verify that the underlying filesystem supports them.
519      */
testFilenames()520     public void testFilenames() throws Exception {
521         final File base = mContext.getFilesDir();
522         assertValidFile(new File(base, "foo"));
523         assertValidFile(new File(base, ".bar"));
524         assertValidFile(new File(base, "foo.bar"));
525         assertValidFile(new File(base, "\u2603"));
526         assertValidFile(new File(base, "\uD83D\uDCA9"));
527 
528         final int pid = android.os.Process.myPid();
529         final StringBuilder sb = new StringBuilder(255);
530         while (sb.length() <= 255) {
531             sb.append(pid);
532             sb.append(mContext.getPackageName());
533         }
534         sb.setLength(255);
535 
536         final String longName = sb.toString();
537         final File longDir = new File(base, longName);
538         assertValidFile(longDir);
539         longDir.mkdir();
540         final File longFile = new File(longDir, longName);
541         assertValidFile(longFile);
542     }
543 
testMainLooper()544     public void testMainLooper() throws Exception {
545         final Thread mainThread = Looper.getMainLooper().getThread();
546         final Handler handler = new Handler(mContext.getMainLooper());
547         handler.post(() -> {
548             assertEquals(mainThread, Thread.currentThread());
549         });
550     }
551 
testMainExecutor()552     public void testMainExecutor() throws Exception {
553         final Thread mainThread = Looper.getMainLooper().getThread();
554         mContext.getMainExecutor().execute(() -> {
555             assertEquals(mainThread, Thread.currentThread());
556         });
557     }
558 
assertValidFile(File file)559     private void assertValidFile(File file) throws Exception {
560         Log.d(TAG, "Checking " + file);
561         if (file.exists()) {
562             assertTrue("File already exists and couldn't be deleted before test: " + file,
563                     file.delete());
564         }
565         assertTrue("Failed to create " + file, file.createNewFile());
566         assertTrue("Doesn't exist after create " + file, file.exists());
567         assertTrue("Failed to delete after create " + file, file.delete());
568         new FileOutputStream(file).close();
569         assertTrue("Doesn't exist after stream " + file, file.exists());
570         assertTrue("Failed to delete after stream " + file, file.delete());
571     }
572 
beginDocument(XmlPullParser parser, String firstElementName)573     static void beginDocument(XmlPullParser parser, String firstElementName)
574             throws XmlPullParserException, IOException
575     {
576         int type;
577         while ((type=parser.next()) != parser.START_TAG
578                 && type != parser.END_DOCUMENT) {
579             ;
580         }
581 
582         if (type != parser.START_TAG) {
583             throw new XmlPullParserException("No start tag found");
584         }
585 
586         if (!parser.getName().equals(firstElementName)) {
587             throw new XmlPullParserException("Unexpected start tag: found " + parser.getName() +
588                     ", expected " + firstElementName);
589         }
590     }
591 
getAttributeSet(int resourceId)592     private AttributeSet getAttributeSet(int resourceId) {
593         final XmlResourceParser parser = mContext.getResources().getXml(
594                 resourceId);
595 
596         try {
597             beginDocument(parser, "RelativeLayout");
598         } catch (XmlPullParserException e) {
599             e.printStackTrace();
600         } catch (IOException e) {
601             e.printStackTrace();
602         }
603 
604         final AttributeSet attr = Xml.asAttributeSet(parser);
605         assertNotNull(attr);
606         return attr;
607     }
608 
registerBroadcastReceiver(BroadcastReceiver receiver, IntentFilter filter)609     private void registerBroadcastReceiver(BroadcastReceiver receiver, IntentFilter filter) {
610         // All of the broadcasts for tests that use this method are sent by the local app, so by
611         // default all receivers can be registered as not exported.
612         registerBroadcastReceiver(receiver, filter, Context.RECEIVER_NOT_EXPORTED);
613     }
614 
registerBroadcastReceiver(BroadcastReceiver receiver, IntentFilter filter, int flags)615     private void registerBroadcastReceiver(BroadcastReceiver receiver, IntentFilter filter,
616             int flags) {
617         mContext.registerReceiver(receiver, filter, flags);
618 
619         mRegisteredReceiverList.add(receiver);
620     }
621 
testSendOrderedBroadcast1()622     public void testSendOrderedBroadcast1() throws InterruptedException {
623         final HighPriorityBroadcastReceiver highPriorityReceiver =
624                 new HighPriorityBroadcastReceiver();
625         final LowPriorityBroadcastReceiver lowPriorityReceiver =
626                 new LowPriorityBroadcastReceiver();
627 
628         final IntentFilter filterHighPriority = new IntentFilter(ResultReceiver.MOCK_ACTION);
629         filterHighPriority.setPriority(1);
630         final IntentFilter filterLowPriority = new IntentFilter(ResultReceiver.MOCK_ACTION);
631         registerBroadcastReceiver(highPriorityReceiver, filterHighPriority);
632         registerBroadcastReceiver(lowPriorityReceiver, filterLowPriority);
633 
634         final Intent broadcastIntent = new Intent(ResultReceiver.MOCK_ACTION);
635         broadcastIntent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
636         mContext.sendOrderedBroadcast(broadcastIntent, null);
637         new PollingCheck(BROADCAST_TIMEOUT) {
638             @Override
639             protected boolean check() {
640                 return highPriorityReceiver.hasReceivedBroadCast()
641                         && !lowPriorityReceiver.hasReceivedBroadCast();
642             }
643         }.run();
644 
645         synchronized (highPriorityReceiver) {
646             highPriorityReceiver.notify();
647         }
648 
649         new PollingCheck(BROADCAST_TIMEOUT) {
650             @Override
651             protected boolean check() {
652                 return highPriorityReceiver.hasReceivedBroadCast()
653                         && lowPriorityReceiver.hasReceivedBroadCast();
654             }
655         }.run();
656     }
657 
testSendOrderedBroadcast2()658     public void testSendOrderedBroadcast2() throws InterruptedException {
659         final TestBroadcastReceiver broadcastReceiver = new TestBroadcastReceiver();
660         broadcastReceiver.mIsOrderedBroadcasts = true;
661 
662         Bundle bundle = new Bundle();
663         bundle.putString(KEY_KEPT, VALUE_KEPT);
664         bundle.putString(KEY_REMOVED, VALUE_REMOVED);
665         Intent intent = new Intent(ResultReceiver.MOCK_ACTION);
666         intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
667         mContext.sendOrderedBroadcast(intent, null, broadcastReceiver, null, 1,
668                 INTIAL_RESULT, bundle);
669 
670         synchronized (mLockObj) {
671             try {
672                 mLockObj.wait(BROADCAST_TIMEOUT);
673             } catch (InterruptedException e) {
674                 fail("unexpected InterruptedException.");
675             }
676         }
677 
678         assertTrue("Receiver didn't make any response.", broadcastReceiver.hadReceivedBroadCast());
679         assertEquals("Incorrect code: " + broadcastReceiver.getResultCode(), 3,
680                 broadcastReceiver.getResultCode());
681         assertEquals(ACTUAL_RESULT, broadcastReceiver.getResultData());
682         Bundle resultExtras = broadcastReceiver.getResultExtras(false);
683         assertEquals(VALUE_ADDED, resultExtras.getString(KEY_ADDED));
684         assertEquals(VALUE_KEPT, resultExtras.getString(KEY_KEPT));
685         assertNull(resultExtras.getString(KEY_REMOVED));
686     }
687 
testSendOrderedBroadcastWithAppOp()688     public void testSendOrderedBroadcastWithAppOp() {
689         // we use a HighPriorityBroadcastReceiver because the final receiver should get the
690         // broadcast only at the end.
691         final ResultReceiver receiver = new HighPriorityBroadcastReceiver();
692         final ResultReceiver finalReceiver = new ResultReceiver();
693 
694         AppOpsManager aom =
695                 (AppOpsManager) getContextUnderTest().getSystemService(Context.APP_OPS_SERVICE);
696         ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(aom,
697                 (appOpsMan) -> appOpsMan.setUidMode(AppOpsManager.OPSTR_READ_CELL_BROADCASTS,
698                 Process.myUid(), AppOpsManager.MODE_ALLOWED));
699 
700         registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION));
701 
702         mContext.sendOrderedBroadcast(
703                 new Intent(ResultReceiver.MOCK_ACTION),
704                 null, // permission
705                 AppOpsManager.OPSTR_READ_CELL_BROADCASTS,
706                 finalReceiver,
707                 null, // scheduler
708                 0, // initial code
709                 null, //initial data
710                 null); // initial extras
711 
712         new PollingCheck(BROADCAST_TIMEOUT){
713             @Override
714             protected boolean check() {
715                 return receiver.hasReceivedBroadCast()
716                         && !finalReceiver.hasReceivedBroadCast();
717             }
718         }.run();
719 
720         synchronized (receiver) {
721             receiver.notify();
722         }
723 
724         new PollingCheck(BROADCAST_TIMEOUT){
725             @Override
726             protected boolean check() {
727                 // ensure that first receiver has received broadcast before final receiver
728                 return receiver.hasReceivedBroadCast()
729                         && finalReceiver.hasReceivedBroadCast();
730             }
731         }.run();
732     }
733 
testSendOrderedBroadcastWithAppOp_NotGranted()734     public void testSendOrderedBroadcastWithAppOp_NotGranted() {
735         final ResultReceiver receiver = new ResultReceiver();
736 
737         AppOpsManager aom =
738                 (AppOpsManager) getContextUnderTest().getSystemService(Context.APP_OPS_SERVICE);
739         ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(aom,
740                 (appOpsMan) -> appOpsMan.setUidMode(AppOpsManager.OPSTR_READ_CELL_BROADCASTS,
741                         Process.myUid(), AppOpsManager.MODE_ERRORED));
742 
743         registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION));
744 
745         mContext.sendOrderedBroadcast(
746                 new Intent(ResultReceiver.MOCK_ACTION),
747                 null, // permission
748                 AppOpsManager.OPSTR_READ_CELL_BROADCASTS,
749                 null, // final receiver
750                 null, // scheduler
751                 0, // initial code
752                 null, //initial data
753                 null); // initial extras
754 
755         boolean broadcastNeverSent = false;
756         try {
757             new PollingCheck(BROADCAST_TIMEOUT) {
758                 @Override
759                 protected boolean check() {
760                     return receiver.hasReceivedBroadCast();
761                 }
762 
763                 public void runWithInterruption() throws InterruptedException {
764                     if (check()) {
765                         return;
766                     }
767 
768                     long timeout = BROADCAST_TIMEOUT;
769                     while (timeout > 0) {
770                         try {
771                             Thread.sleep(50 /* time slice */);
772                         } catch (InterruptedException e) {
773                             fail("unexpected InterruptedException");
774                         }
775 
776                         if (check()) {
777                             return;
778                         }
779 
780                         timeout -= 50; // time slice
781                     }
782                     throw new InterruptedException();
783                 }
784             }.runWithInterruption();
785         } catch (InterruptedException e) {
786             broadcastNeverSent = true;
787         }
788 
789         assertTrue(broadcastNeverSent);
790     }
791 
testRegisterReceiver1()792     public void testRegisterReceiver1() throws InterruptedException {
793         final FilteredReceiver broadcastReceiver = new FilteredReceiver();
794         final IntentFilter filter = new IntentFilter(MOCK_ACTION1);
795 
796         // Test registerReceiver
797         mContext.registerReceiver(broadcastReceiver, filter);
798 
799         // Test unwanted intent(action = MOCK_ACTION2)
800         broadcastReceiver.reset();
801         waitForFilteredIntent(mContext, MOCK_ACTION2);
802         assertFalse(broadcastReceiver.hadReceivedBroadCast1());
803         assertFalse(broadcastReceiver.hadReceivedBroadCast2());
804 
805         // Send wanted intent(action = MOCK_ACTION1)
806         broadcastReceiver.reset();
807         waitForFilteredIntent(mContext, MOCK_ACTION1);
808         assertTrue(broadcastReceiver.hadReceivedBroadCast1());
809         assertFalse(broadcastReceiver.hadReceivedBroadCast2());
810 
811         mContext.unregisterReceiver(broadcastReceiver);
812 
813         // Test unregisterReceiver
814         FilteredReceiver broadcastReceiver2 = new FilteredReceiver();
815         mContext.registerReceiver(broadcastReceiver2, filter);
816         mContext.unregisterReceiver(broadcastReceiver2);
817 
818         // Test unwanted intent(action = MOCK_ACTION2)
819         broadcastReceiver2.reset();
820         waitForFilteredIntent(mContext, MOCK_ACTION2);
821         assertFalse(broadcastReceiver2.hadReceivedBroadCast1());
822         assertFalse(broadcastReceiver2.hadReceivedBroadCast2());
823 
824         // Send wanted intent(action = MOCK_ACTION1), but the receiver is unregistered.
825         broadcastReceiver2.reset();
826         waitForFilteredIntent(mContext, MOCK_ACTION1);
827         assertFalse(broadcastReceiver2.hadReceivedBroadCast1());
828         assertFalse(broadcastReceiver2.hadReceivedBroadCast2());
829     }
830 
testRegisterReceiver2()831     public void testRegisterReceiver2() throws InterruptedException {
832         FilteredReceiver broadcastReceiver = new FilteredReceiver();
833         IntentFilter filter = new IntentFilter();
834         filter.addAction(MOCK_ACTION1);
835 
836         // Test registerReceiver
837         mContext.registerReceiver(broadcastReceiver, filter, null, null);
838 
839         // Test unwanted intent(action = MOCK_ACTION2)
840         broadcastReceiver.reset();
841         waitForFilteredIntent(mContext, MOCK_ACTION2);
842         assertFalse(broadcastReceiver.hadReceivedBroadCast1());
843         assertFalse(broadcastReceiver.hadReceivedBroadCast2());
844 
845         // Send wanted intent(action = MOCK_ACTION1)
846         broadcastReceiver.reset();
847         waitForFilteredIntent(mContext, MOCK_ACTION1);
848         assertTrue(broadcastReceiver.hadReceivedBroadCast1());
849         assertFalse(broadcastReceiver.hadReceivedBroadCast2());
850 
851         mContext.unregisterReceiver(broadcastReceiver);
852     }
853 
testRegisterReceiverForAllUsers()854     public void testRegisterReceiverForAllUsers() throws InterruptedException {
855         FilteredReceiver broadcastReceiver = new FilteredReceiver();
856         IntentFilter filter = new IntentFilter();
857         filter.addAction(MOCK_ACTION1);
858 
859         // Test registerReceiverForAllUsers without permission: verify SecurityException.
860         try {
861             mContext.registerReceiverForAllUsers(broadcastReceiver, filter, null, null);
862             fail("testRegisterReceiverForAllUsers: "
863                     + "SecurityException expected on registerReceiverForAllUsers");
864         } catch (SecurityException se) {
865             // expected
866         }
867 
868         // Test registerReceiverForAllUsers with permission.
869         try {
870             ShellIdentityUtils.invokeMethodWithShellPermissions(
871                     mContext,
872                     (ctx) -> ctx.registerReceiverForAllUsers(broadcastReceiver, filter, null, null)
873             );
874         } catch (SecurityException se) {
875             fail("testRegisterReceiverForAllUsers: SecurityException not expected");
876         }
877 
878         // Test unwanted intent(action = MOCK_ACTION2)
879         broadcastReceiver.reset();
880         waitForFilteredIntent(mContext, MOCK_ACTION2);
881         assertFalse(broadcastReceiver.hadReceivedBroadCast1());
882         assertFalse(broadcastReceiver.hadReceivedBroadCast2());
883 
884         // Send wanted intent(action = MOCK_ACTION1)
885         broadcastReceiver.reset();
886         waitForFilteredIntent(mContext, MOCK_ACTION1);
887         assertTrue(broadcastReceiver.hadReceivedBroadCast1());
888         assertEquals(broadcastReceiver.getSendingUser(), Process.myUserHandle());
889         assertFalse(broadcastReceiver.hadReceivedBroadCast2());
890 
891         mContext.unregisterReceiver(broadcastReceiver);
892     }
893 
testAccessWallpaper()894     public void testAccessWallpaper() throws IOException, InterruptedException {
895         if (!isWallpaperSupported()) return;
896 
897         // set Wallpaper by context#setWallpaper(Bitmap)
898         Bitmap bitmap = Bitmap.createBitmap(20, 30, Bitmap.Config.RGB_565);
899         // Test getWallpaper
900         Drawable testDrawable = mContext.getWallpaper();
901         // Test peekWallpaper
902         Drawable testDrawable2 = mContext.peekWallpaper();
903 
904         mContext.setWallpaper(bitmap);
905         mWallpaperChanged = true;
906         synchronized(this) {
907             wait(500);
908         }
909 
910         assertNotSame(testDrawable, mContext.peekWallpaper());
911         assertNotNull(mContext.getWallpaper());
912         assertNotSame(testDrawable2, mContext.peekWallpaper());
913         assertNotNull(mContext.peekWallpaper());
914 
915         // set Wallpaper by context#setWallpaper(InputStream)
916         mContext.clearWallpaper();
917 
918         testDrawable = mContext.getWallpaper();
919         InputStream stream = mContext.getResources().openRawResource(R.drawable.scenery);
920 
921         mContext.setWallpaper(stream);
922         synchronized (this) {
923             wait(1000);
924         }
925 
926         assertNotSame(testDrawable, mContext.peekWallpaper());
927     }
928 
testAccessDatabase()929     public void testAccessDatabase() {
930         String DATABASE_NAME = "databasetest";
931         String DATABASE_NAME1 = DATABASE_NAME + "1";
932         String DATABASE_NAME2 = DATABASE_NAME + "2";
933         SQLiteDatabase mDatabase;
934         File mDatabaseFile;
935 
936         SQLiteDatabase.CursorFactory factory = new SQLiteDatabase.CursorFactory() {
937             public Cursor newCursor(SQLiteDatabase db, SQLiteCursorDriver masterQuery,
938                                     String editTable, SQLiteQuery query) {
939                 return new android.database.sqlite.SQLiteCursor(db, masterQuery, editTable, query) {
940                     @Override
941                     public boolean requery() {
942                         setSelectionArguments(new String[] { "2" });
943                         return super.requery();
944                     }
945                 };
946             }
947         };
948 
949         // FIXME: Move cleanup into tearDown()
950         for (String db : mContext.databaseList()) {
951             File f = mContext.getDatabasePath(db);
952             if (f.exists()) {
953                 mContext.deleteDatabase(db);
954             }
955         }
956 
957         // Test openOrCreateDatabase with null and actual factory
958         mDatabase = mContext.openOrCreateDatabase(DATABASE_NAME1,
959                 Context.MODE_ENABLE_WRITE_AHEAD_LOGGING, factory);
960         assertNotNull(mDatabase);
961         mDatabase.close();
962         mDatabase = mContext.openOrCreateDatabase(DATABASE_NAME2,
963                 Context.MODE_ENABLE_WRITE_AHEAD_LOGGING, factory);
964         assertNotNull(mDatabase);
965         mDatabase.close();
966 
967         // Test getDatabasePath
968         File actualDBPath = mContext.getDatabasePath(DATABASE_NAME1);
969 
970         // Test databaseList()
971         List<String> list = Arrays.asList(mContext.databaseList());
972         assertTrue("1) database list: " + list, list.contains(DATABASE_NAME1));
973         assertTrue("2) database list: " + list, list.contains(DATABASE_NAME2));
974 
975         // Test deleteDatabase()
976         for (int i = 1; i < 3; i++) {
977             mDatabaseFile = mContext.getDatabasePath(DATABASE_NAME + i);
978             assertTrue(mDatabaseFile.exists());
979             mContext.deleteDatabase(DATABASE_NAME + i);
980             mDatabaseFile = new File(actualDBPath, DATABASE_NAME + i);
981             assertFalse(mDatabaseFile.exists());
982         }
983     }
984 
testEnforceUriPermission1()985     public void testEnforceUriPermission1() {
986         try {
987             Uri uri = Uri.parse("content://ctstest");
988             mContext.enforceUriPermission(uri, Binder.getCallingPid(),
989                     Binder.getCallingUid(), Intent.FLAG_GRANT_WRITE_URI_PERMISSION,
990                     "enforceUriPermission is not working without possessing an IPC.");
991             fail("enforceUriPermission is not working without possessing an IPC.");
992         } catch (SecurityException e) {
993             // If the function is OK, it should throw a SecurityException here because currently no
994             // IPC is handled by this process.
995         }
996     }
997 
testEnforceUriPermission2()998     public void testEnforceUriPermission2() {
999         Uri uri = Uri.parse("content://ctstest");
1000         try {
1001             mContext.enforceUriPermission(uri, NOT_GRANTED_PERMISSION,
1002                     NOT_GRANTED_PERMISSION, Binder.getCallingPid(), Binder.getCallingUid(),
1003                     Intent.FLAG_GRANT_WRITE_URI_PERMISSION,
1004                     "enforceUriPermission is not working without possessing an IPC.");
1005             fail("enforceUriPermission is not working without possessing an IPC.");
1006         } catch (SecurityException e) {
1007             // If the function is ok, it should throw a SecurityException here because currently no
1008             // IPC is handled by this process.
1009         }
1010     }
1011 
testGetPackageResourcePath()1012     public void testGetPackageResourcePath() {
1013         assertNotNull(mContext.getPackageResourcePath());
1014     }
1015 
testStartActivityWithActivityNotFound()1016     public void testStartActivityWithActivityNotFound() {
1017         Intent intent = new Intent(mContext, ContextCtsActivity.class);
1018         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
1019         try {
1020             mContext.startActivity(intent);
1021             fail("Test startActivity should throw a ActivityNotFoundException here.");
1022         } catch (ActivityNotFoundException e) {
1023             // Because ContextWrapper is a wrapper class, so no need to test
1024             // the details of the function's performance. Getting a result
1025             // from the wrapped class is enough for testing.
1026         }
1027     }
1028 
testStartActivities()1029     public void testStartActivities() throws Exception {
1030         final Intent[] intents = {
1031                 new Intent().setComponent(new ComponentName(mContext,
1032                         AvailableIntentsActivity.class)).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK),
1033                 new Intent().setComponent(new ComponentName(mContext,
1034                         ImageCaptureActivity.class)).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
1035         };
1036 
1037         final Instrumentation.ActivityMonitor firstMonitor = getInstrumentation()
1038                 .addMonitor(AvailableIntentsActivity.class.getName(), null /* result */,
1039                         false /* block */);
1040         final Instrumentation.ActivityMonitor secondMonitor = getInstrumentation()
1041                 .addMonitor(ImageCaptureActivity.class.getName(), null /* result */,
1042                         false /* block */);
1043 
1044         mContext.startActivities(intents);
1045 
1046         Activity firstActivity = getInstrumentation().waitForMonitorWithTimeout(firstMonitor, 5000);
1047         assertNotNull(firstActivity);
1048 
1049         Activity secondActivity = getInstrumentation().waitForMonitorWithTimeout(secondMonitor,
1050                 5000);
1051         assertNotNull(secondActivity);
1052     }
1053 
testStartActivityAsUser()1054     public void testStartActivityAsUser() {
1055         try (ActivitySession activitySession = new ActivitySession()) {
1056             Intent intent = new Intent(mContext, AvailableIntentsActivity.class);
1057 
1058             activitySession.assertActivityLaunched(intent.getComponent().getClassName(),
1059                     () -> SystemUtil.runWithShellPermissionIdentity(() ->
1060                             mContext.startActivityAsUser(intent, UserHandle.CURRENT)));
1061         }
1062     }
1063 
testStartActivity()1064     public void testStartActivity()  {
1065         try (ActivitySession activitySession = new ActivitySession()) {
1066             Intent intent = new Intent(mContext, AvailableIntentsActivity.class);
1067             intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
1068 
1069             activitySession.assertActivityLaunched(intent.getComponent().getClassName(),
1070                     () -> mContext.startActivity(intent));
1071         }
1072     }
1073 
1074     /**
1075      * Helper class to launch / close test activity.
1076      */
1077     private class ActivitySession implements AutoCloseable {
1078         private Activity mTestActivity;
1079         private static final int ACTIVITY_LAUNCH_TIMEOUT = 5000;
1080 
assertActivityLaunched(String activityClassName, Runnable activityStarter)1081         void assertActivityLaunched(String activityClassName, Runnable activityStarter) {
1082             final Instrumentation.ActivityMonitor monitor = getInstrumentation()
1083                     .addMonitor(activityClassName, null /* result */,
1084                             false /* block */);
1085             activityStarter.run();
1086             // Wait for activity launch with timeout.
1087             mTestActivity = getInstrumentation().waitForMonitorWithTimeout(monitor,
1088                     ACTIVITY_LAUNCH_TIMEOUT);
1089             assertNotNull(mTestActivity);
1090         }
1091 
1092         @Override
close()1093         public void close() {
1094             if (mTestActivity != null) {
1095                 mTestActivity.finishAndRemoveTask();
1096             }
1097         }
1098     }
1099 
testCreatePackageContext()1100     public void testCreatePackageContext() throws PackageManager.NameNotFoundException {
1101         Context actualContext = mContext.createPackageContext("com.android.shell",
1102                 Context.CONTEXT_IGNORE_SECURITY);
1103 
1104         assertNotNull(actualContext);
1105     }
1106 
testCreatePackageContextAsUser()1107     public void testCreatePackageContextAsUser() throws Exception {
1108         for (UserHandle user : new UserHandle[] {
1109                 android.os.Process.myUserHandle(),
1110                 UserHandle.ALL, UserHandle.CURRENT, UserHandle.SYSTEM
1111         }) {
1112             assertEquals(user, mContext
1113                     .createPackageContextAsUser("com.android.shell", 0, user).getUser());
1114         }
1115     }
1116 
testCreateContextAsUser()1117     public void testCreateContextAsUser() throws Exception {
1118         for (UserHandle user : new UserHandle[] {
1119                 android.os.Process.myUserHandle(),
1120                 UserHandle.ALL, UserHandle.CURRENT, UserHandle.SYSTEM
1121         }) {
1122             assertEquals(user, mContext.createContextAsUser(user, 0).getUser());
1123         }
1124     }
1125 
testGetMainLooper()1126     public void testGetMainLooper() {
1127         assertNotNull(mContext.getMainLooper());
1128     }
1129 
testGetApplicationContext()1130     public void testGetApplicationContext() {
1131         assertSame(mContext.getApplicationContext(), mContext.getApplicationContext());
1132     }
1133 
testGetSharedPreferences()1134     public void testGetSharedPreferences() {
1135         SharedPreferences sp;
1136         SharedPreferences localSP;
1137 
1138         sp = PreferenceManager.getDefaultSharedPreferences(mContext);
1139         String packageName = mContext.getPackageName();
1140         localSP = mContext.getSharedPreferences(packageName + "_preferences",
1141                 Context.MODE_PRIVATE);
1142         assertSame(sp, localSP);
1143     }
1144 
testRevokeUriPermission()1145     public void testRevokeUriPermission() {
1146         Uri uri = Uri.parse("contents://ctstest");
1147         mContext.revokeUriPermission(uri, Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
1148     }
1149 
testAccessService()1150     public void testAccessService() throws InterruptedException {
1151         MockContextService.reset();
1152         bindExpectResult(mContext, new Intent(mContext, MockContextService.class));
1153 
1154         // Check startService
1155         assertTrue(MockContextService.hadCalledOnStart());
1156         // Check bindService
1157         assertTrue(MockContextService.hadCalledOnBind());
1158 
1159         assertTrue(MockContextService.hadCalledOnDestory());
1160         // Check unbinService
1161         assertTrue(MockContextService.hadCalledOnUnbind());
1162     }
1163 
testGetPackageCodePath()1164     public void testGetPackageCodePath() {
1165         assertNotNull(mContext.getPackageCodePath());
1166     }
1167 
testGetPackageName()1168     public void testGetPackageName() {
1169         assertEquals("android.content.cts", mContext.getPackageName());
1170     }
1171 
testGetCacheDir()1172     public void testGetCacheDir() {
1173         assertNotNull(mContext.getCacheDir());
1174     }
1175 
testGetContentResolver()1176     public void testGetContentResolver() {
1177         assertSame(mContext.getContentResolver(), mContext.getContentResolver());
1178     }
1179 
testGetFileStreamPath()1180     public void testGetFileStreamPath() {
1181         String TEST_FILENAME = "TestGetFileStreamPath";
1182 
1183         // Test the path including the input filename
1184         String fileStreamPath = mContext.getFileStreamPath(TEST_FILENAME).toString();
1185         assertTrue(fileStreamPath.indexOf(TEST_FILENAME) >= 0);
1186     }
1187 
testGetClassLoader()1188     public void testGetClassLoader() {
1189         assertSame(mContext.getClassLoader(), mContext.getClassLoader());
1190     }
1191 
testGetWallpaperDesiredMinimumHeightAndWidth()1192     public void testGetWallpaperDesiredMinimumHeightAndWidth() {
1193         if (!isWallpaperSupported()) return;
1194 
1195         int height = mContext.getWallpaperDesiredMinimumHeight();
1196         int width = mContext.getWallpaperDesiredMinimumWidth();
1197 
1198         // returned value is <= 0, the caller should use the height of the
1199         // default display instead.
1200         // That is to say, the return values of desired minimumHeight and
1201         // minimunWidth are at the same side of 0-dividing line.
1202         assertTrue((height > 0 && width > 0) || (height <= 0 && width <= 0));
1203     }
1204 
testAccessStickyBroadcast()1205     public void testAccessStickyBroadcast() throws InterruptedException {
1206         ResultReceiver resultReceiver = new ResultReceiver();
1207 
1208         Intent intent = new Intent(MOCK_STICKY_ACTION);
1209         TestBroadcastReceiver stickyReceiver = new TestBroadcastReceiver();
1210 
1211         mContext.sendStickyBroadcast(intent);
1212 
1213         waitForReceiveBroadCast(resultReceiver);
1214 
1215         assertEquals(intent.getAction(), mContext.registerReceiver(stickyReceiver,
1216                 new IntentFilter(MOCK_STICKY_ACTION)).getAction());
1217 
1218         synchronized (mLockObj) {
1219             mLockObj.wait(BROADCAST_TIMEOUT);
1220         }
1221 
1222         assertTrue("Receiver didn't make any response.", stickyReceiver.hadReceivedBroadCast());
1223 
1224         mContext.unregisterReceiver(stickyReceiver);
1225         mContext.removeStickyBroadcast(intent);
1226 
1227         assertNull(mContext.registerReceiver(stickyReceiver,
1228                 new IntentFilter(MOCK_STICKY_ACTION)));
1229         mContext.unregisterReceiver(stickyReceiver);
1230     }
1231 
testCheckCallingOrSelfUriPermissions()1232     public void testCheckCallingOrSelfUriPermissions() {
1233         List<Uri> uris = new ArrayList<>();
1234         Uri uri1 = Uri.parse("content://ctstest1");
1235         uris.add(uri1);
1236         Uri uri2 = Uri.parse("content://ctstest2");
1237         uris.add(uri2);
1238 
1239         int[] retValue = mContext.checkCallingOrSelfUriPermissions(uris,
1240                 Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
1241         assertEquals(retValue.length, 2);
1242         // This package does not have access to the given URIs
1243         assertEquals(PERMISSION_DENIED, retValue[0]);
1244         assertEquals(PERMISSION_DENIED, retValue[1]);
1245     }
1246 
testCheckCallingOrSelfUriPermission()1247     public void testCheckCallingOrSelfUriPermission() {
1248         Uri uri = Uri.parse("content://ctstest");
1249 
1250         int retValue = mContext.checkCallingOrSelfUriPermission(uri,
1251                 Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
1252         assertEquals(PackageManager.PERMISSION_DENIED, retValue);
1253     }
1254 
testGrantUriPermission()1255     public void testGrantUriPermission() {
1256         mContext.grantUriPermission("com.android.mms", Uri.parse("contents://ctstest"),
1257                 Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
1258     }
1259 
testCheckPermissionGranted()1260     public void testCheckPermissionGranted() {
1261         int returnValue = mContext.checkPermission(
1262                 GRANTED_PERMISSION, Process.myPid(), Process.myUid());
1263         assertEquals(PackageManager.PERMISSION_GRANTED, returnValue);
1264     }
1265 
testCheckPermissionNotGranted()1266     public void testCheckPermissionNotGranted() {
1267         int returnValue = mContext.checkPermission(
1268                 NOT_GRANTED_PERMISSION, Process.myPid(), Process.myUid());
1269         assertEquals(PackageManager.PERMISSION_DENIED, returnValue);
1270     }
1271 
testCheckPermissionRootUser()1272     public void testCheckPermissionRootUser() {
1273         // Test with root user, everything will be granted.
1274         int returnValue = mContext.checkPermission(NOT_GRANTED_PERMISSION, 1, ROOT_UID);
1275         assertEquals(PackageManager.PERMISSION_GRANTED, returnValue);
1276     }
1277 
testCheckPermissionInvalidRequest()1278     public void testCheckPermissionInvalidRequest() {
1279         // Test with null permission.
1280         try {
1281             int returnValue = mContext.checkPermission(null, 0, ROOT_UID);
1282             fail("checkPermission should not accept null permission");
1283         } catch (IllegalArgumentException e) {
1284         }
1285 
1286         // Test with invalid uid and included granted permission.
1287         int returnValue = mContext.checkPermission(GRANTED_PERMISSION, 1, -11);
1288         assertEquals(PackageManager.PERMISSION_DENIED, returnValue);
1289     }
1290 
testCheckSelfPermissionGranted()1291     public void testCheckSelfPermissionGranted() {
1292         int returnValue = mContext.checkSelfPermission(GRANTED_PERMISSION);
1293         assertEquals(PackageManager.PERMISSION_GRANTED, returnValue);
1294     }
1295 
testCheckSelfPermissionNotGranted()1296     public void testCheckSelfPermissionNotGranted() {
1297         int returnValue = mContext.checkSelfPermission(NOT_GRANTED_PERMISSION);
1298         assertEquals(PackageManager.PERMISSION_DENIED, returnValue);
1299     }
1300 
testEnforcePermissionGranted()1301     public void testEnforcePermissionGranted() {
1302         mContext.enforcePermission(
1303                 GRANTED_PERMISSION, Process.myPid(), Process.myUid(),
1304                 "permission isn't granted");
1305     }
1306 
testEnforcePermissionNotGranted()1307     public void testEnforcePermissionNotGranted() {
1308         try {
1309             mContext.enforcePermission(
1310                     NOT_GRANTED_PERMISSION, Process.myPid(), Process.myUid(),
1311                     "permission isn't granted");
1312             fail("Permission shouldn't be granted.");
1313         } catch (SecurityException expected) {
1314         }
1315     }
1316 
testCheckCallingOrSelfPermission_noIpc()1317     public void testCheckCallingOrSelfPermission_noIpc() {
1318         // There's no ongoing Binder call, so this package's permissions are checked.
1319         int retValue = mContext.checkCallingOrSelfPermission(GRANTED_PERMISSION);
1320         assertEquals(PackageManager.PERMISSION_GRANTED, retValue);
1321 
1322         retValue = mContext.checkCallingOrSelfPermission(NOT_GRANTED_PERMISSION);
1323         assertEquals(PackageManager.PERMISSION_DENIED, retValue);
1324     }
1325 
testCheckCallingOrSelfPermission_ipc()1326     public void testCheckCallingOrSelfPermission_ipc() throws Exception {
1327         bindBinderPermissionTestService();
1328         try {
1329             int retValue = mBinderPermissionTestService.doCheckCallingOrSelfPermission(
1330                     GRANTED_PERMISSION);
1331             assertEquals(PackageManager.PERMISSION_GRANTED, retValue);
1332 
1333             retValue = mBinderPermissionTestService.doCheckCallingOrSelfPermission(
1334                     NOT_GRANTED_PERMISSION);
1335             assertEquals(PackageManager.PERMISSION_DENIED, retValue);
1336         } finally {
1337             mContext.unbindService(mBinderPermissionTestConnection);
1338         }
1339     }
1340 
testEnforceCallingOrSelfPermission_noIpc()1341     public void testEnforceCallingOrSelfPermission_noIpc() {
1342         // There's no ongoing Binder call, so this package's permissions are checked.
1343         mContext.enforceCallingOrSelfPermission(
1344                 GRANTED_PERMISSION, "permission isn't granted");
1345 
1346         try {
1347             mContext.enforceCallingOrSelfPermission(
1348                     NOT_GRANTED_PERMISSION, "permission isn't granted");
1349             fail("Permission shouldn't be granted.");
1350         } catch (SecurityException expected) {
1351         }
1352     }
1353 
testEnforceCallingOrSelfPermission_ipc()1354     public void testEnforceCallingOrSelfPermission_ipc() throws Exception {
1355         bindBinderPermissionTestService();
1356         try {
1357             mBinderPermissionTestService.doEnforceCallingOrSelfPermission(GRANTED_PERMISSION);
1358 
1359             try {
1360                 mBinderPermissionTestService.doEnforceCallingOrSelfPermission(
1361                         NOT_GRANTED_PERMISSION);
1362                 fail("Permission shouldn't be granted.");
1363             } catch (SecurityException expected) {
1364             }
1365         } finally {
1366             mContext.unbindService(mBinderPermissionTestConnection);
1367         }
1368     }
1369 
testCheckCallingPermission_noIpc()1370     public void testCheckCallingPermission_noIpc() {
1371         // Denied because no IPC is active.
1372         int retValue = mContext.checkCallingPermission(GRANTED_PERMISSION);
1373         assertEquals(PackageManager.PERMISSION_DENIED, retValue);
1374     }
1375 
testEnforceCallingPermission_noIpc()1376     public void testEnforceCallingPermission_noIpc() {
1377         try {
1378             mContext.enforceCallingPermission(
1379                     GRANTED_PERMISSION,
1380                     "enforceCallingPermission is not working without possessing an IPC.");
1381             fail("enforceCallingPermission is not working without possessing an IPC.");
1382         } catch (SecurityException e) {
1383             // Currently no IPC is handled by this process, this exception is expected
1384         }
1385     }
1386 
testEnforceCallingPermission_ipc()1387     public void testEnforceCallingPermission_ipc() throws Exception {
1388         bindBinderPermissionTestService();
1389         try {
1390             mBinderPermissionTestService.doEnforceCallingPermission(GRANTED_PERMISSION);
1391 
1392             try {
1393                 mBinderPermissionTestService.doEnforceCallingPermission(NOT_GRANTED_PERMISSION);
1394                 fail("Permission shouldn't be granted.");
1395             } catch (SecurityException expected) {
1396             }
1397         } finally {
1398             mContext.unbindService(mBinderPermissionTestConnection);
1399         }
1400     }
1401 
testCheckCallingPermission_ipc()1402     public void testCheckCallingPermission_ipc() throws Exception {
1403         bindBinderPermissionTestService();
1404         try {
1405             int returnValue = mBinderPermissionTestService.doCheckCallingPermission(
1406                     GRANTED_PERMISSION);
1407             assertEquals(PackageManager.PERMISSION_GRANTED, returnValue);
1408 
1409             returnValue = mBinderPermissionTestService.doCheckCallingPermission(
1410                     NOT_GRANTED_PERMISSION);
1411             assertEquals(PackageManager.PERMISSION_DENIED, returnValue);
1412         } finally {
1413             mContext.unbindService(mBinderPermissionTestConnection);
1414         }
1415     }
1416 
bindBinderPermissionTestService()1417     private void bindBinderPermissionTestService() {
1418         Intent intent = new Intent(mContext, IBinderPermissionTestService.class);
1419         intent.setComponent(new ComponentName(
1420                 "com.android.cts", "com.android.cts.BinderPermissionTestService"));
1421 
1422         mBinderPermissionTestConnection = new ServiceConnection() {
1423             @Override
1424             public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
1425                 mBinderPermissionTestService =
1426                         IBinderPermissionTestService.Stub.asInterface(iBinder);
1427             }
1428 
1429             @Override
1430             public void onServiceDisconnected(ComponentName componentName) {
1431             }
1432         };
1433 
1434         assertTrue("Service not bound", mContext.bindService(
1435                 intent, mBinderPermissionTestConnection, Context.BIND_AUTO_CREATE));
1436 
1437         new PollingCheck(15 * 1000) {
1438             protected boolean check() {
1439                 return mBinderPermissionTestService != null; // Service was bound.
1440             }
1441         }.run();
1442     }
1443 
testCheckUriPermissions()1444     public void testCheckUriPermissions() {
1445         List<Uri> uris = new ArrayList<>();
1446         Uri uri1 = Uri.parse("content://ctstest1");
1447         uris.add(uri1);
1448         Uri uri2 = Uri.parse("content://ctstest2");
1449         uris.add(uri2);
1450 
1451         // Root has access to all URIs
1452         int[] retValue = mContext.checkUriPermissions(uris, Binder.getCallingPid(), 0,
1453                 Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
1454         assertEquals(retValue.length, 2);
1455         assertEquals(PERMISSION_GRANTED, retValue[0]);
1456         assertEquals(PERMISSION_GRANTED, retValue[1]);
1457 
1458         retValue = mContext.checkUriPermissions(uris, Binder.getCallingPid(),
1459                 Binder.getCallingUid(), Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
1460         assertEquals(retValue.length, 2);
1461         // This package does not have access to the given URIs
1462         assertEquals(PERMISSION_DENIED, retValue[0]);
1463         assertEquals(PERMISSION_DENIED, retValue[1]);
1464     }
1465 
testCheckUriPermission1()1466     public void testCheckUriPermission1() {
1467         Uri uri = Uri.parse("content://ctstest");
1468 
1469         int retValue = mContext.checkUriPermission(uri, Binder.getCallingPid(), 0,
1470                 Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
1471         assertEquals(PackageManager.PERMISSION_GRANTED, retValue);
1472 
1473         retValue = mContext.checkUriPermission(uri, Binder.getCallingPid(),
1474                 Binder.getCallingUid(), Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
1475         assertEquals(PackageManager.PERMISSION_DENIED, retValue);
1476     }
1477 
testCheckUriPermission2()1478     public void testCheckUriPermission2() {
1479         Uri uri = Uri.parse("content://ctstest");
1480 
1481         int retValue = mContext.checkUriPermission(uri, NOT_GRANTED_PERMISSION,
1482                 NOT_GRANTED_PERMISSION, Binder.getCallingPid(), 0,
1483                 Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
1484         assertEquals(PackageManager.PERMISSION_GRANTED, retValue);
1485 
1486         retValue = mContext.checkUriPermission(uri, NOT_GRANTED_PERMISSION,
1487                 NOT_GRANTED_PERMISSION, Binder.getCallingPid(), Binder.getCallingUid(),
1488                 Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
1489         assertEquals(PackageManager.PERMISSION_DENIED, retValue);
1490     }
1491 
testCheckCallingUriPermissions()1492     public void testCheckCallingUriPermissions() {
1493         List<Uri> uris = new ArrayList<>();
1494         Uri uri1 = Uri.parse("content://ctstest1");
1495         uris.add(uri1);
1496         Uri uri2 = Uri.parse("content://ctstest2");
1497         uris.add(uri2);
1498 
1499         int[] retValue = mContext.checkCallingUriPermissions(uris,
1500                 Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
1501         assertEquals(retValue.length, 2);
1502         // This package does not have access to the given URIs
1503         assertEquals(PERMISSION_DENIED, retValue[0]);
1504         assertEquals(PERMISSION_DENIED, retValue[1]);
1505     }
1506 
testCheckCallingUriPermission()1507     public void testCheckCallingUriPermission() {
1508         Uri uri = Uri.parse("content://ctstest");
1509 
1510         int retValue = mContext.checkCallingUriPermission(uri,
1511                 Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
1512         assertEquals(PackageManager.PERMISSION_DENIED, retValue);
1513     }
1514 
testEnforceCallingUriPermission()1515     public void testEnforceCallingUriPermission() {
1516         try {
1517             Uri uri = Uri.parse("content://ctstest");
1518             mContext.enforceCallingUriPermission(uri, Intent.FLAG_GRANT_WRITE_URI_PERMISSION,
1519                     "enforceCallingUriPermission is not working without possessing an IPC.");
1520             fail("enforceCallingUriPermission is not working without possessing an IPC.");
1521         } catch (SecurityException e) {
1522             // If the function is OK, it should throw a SecurityException here because currently no
1523             // IPC is handled by this process.
1524         }
1525     }
1526 
testGetDir()1527     public void testGetDir() {
1528         File dir = mContext.getDir("testpath", Context.MODE_PRIVATE);
1529         assertNotNull(dir);
1530         dir.delete();
1531     }
1532 
testGetPackageManager()1533     public void testGetPackageManager() {
1534         assertSame(mContext.getPackageManager(), mContext.getPackageManager());
1535     }
1536 
testSendBroadcast1()1537     public void testSendBroadcast1() throws InterruptedException {
1538         final ResultReceiver receiver = new ResultReceiver();
1539 
1540         registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION));
1541 
1542         mContext.sendBroadcast(new Intent(ResultReceiver.MOCK_ACTION));
1543 
1544         new PollingCheck(BROADCAST_TIMEOUT){
1545             @Override
1546             protected boolean check() {
1547                 return receiver.hasReceivedBroadCast();
1548             }
1549         }.run();
1550     }
1551 
testSendBroadcast2()1552     public void testSendBroadcast2() throws InterruptedException {
1553         final ResultReceiver receiver = new ResultReceiver();
1554 
1555         registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION));
1556 
1557         mContext.sendBroadcast(new Intent(ResultReceiver.MOCK_ACTION), null);
1558 
1559         new PollingCheck(BROADCAST_TIMEOUT){
1560             @Override
1561             protected boolean check() {
1562                 return receiver.hasReceivedBroadCast();
1563             }
1564         }.run();
1565     }
1566 
1567     /**
1568      * Verify the receiver should get the broadcast since it has all of the required permissions.
1569      */
testSendBroadcastRequireAllOfPermissions_receiverHasAllPermissions()1570     public void testSendBroadcastRequireAllOfPermissions_receiverHasAllPermissions()
1571             throws Exception {
1572         final ResultReceiver receiver = new ResultReceiver();
1573 
1574         registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION));
1575         BroadcastOptions options = BroadcastOptions.makeBasic();
1576         options.setRequireAllOfPermissions(
1577                 new String[] { // this test APK has both these permissions
1578                         android.Manifest.permission.ACCESS_WIFI_STATE,
1579                         android.Manifest.permission.ACCESS_NETWORK_STATE
1580                 });
1581         mContext.sendBroadcast(new Intent(ResultReceiver.MOCK_ACTION), null,
1582                 options.toBundle());
1583 
1584         new PollingCheck(BROADCAST_TIMEOUT) {
1585             @Override
1586             protected boolean check() {
1587                 return receiver.hasReceivedBroadCast();
1588             }
1589         }.run();
1590     }
1591 
1592     /** The receiver should not get the broadcast if it does not have all the permissions. */
testSendBroadcastRequireAllOfPermissions_receiverHasSomePermissions()1593     public void testSendBroadcastRequireAllOfPermissions_receiverHasSomePermissions()
1594             throws Exception {
1595         final ResultReceiver receiver = new ResultReceiver();
1596 
1597         registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION));
1598         BroadcastOptions options = BroadcastOptions.makeBasic();
1599         options.setRequireAllOfPermissions(
1600                 new String[] { // this test APK only has ACCESS_WIFI_STATE
1601                         android.Manifest.permission.ACCESS_WIFI_STATE,
1602                         android.Manifest.permission.NETWORK_STACK,
1603                 });
1604 
1605         mContext.sendBroadcast(
1606                 new Intent(ResultReceiver.MOCK_ACTION), null,
1607                 options.toBundle());
1608 
1609         Thread.sleep(BROADCAST_TIMEOUT);
1610         assertFalse(receiver.hasReceivedBroadCast());
1611     }
1612 
1613     /**
1614      * Verify the receiver will get the broadcast since it has none of the excluded permissions.
1615      */
testSendBroadcastRequireNoneOfPermissions_receiverHasNoneOfExcludedPermissions()1616     public void testSendBroadcastRequireNoneOfPermissions_receiverHasNoneOfExcludedPermissions()
1617             throws Exception {
1618         final ResultReceiver receiver = new ResultReceiver();
1619 
1620         registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION));
1621         BroadcastOptions options = BroadcastOptions.makeBasic();
1622         options.setRequireAllOfPermissions(
1623                 new String[] { // this test APK has both these permissions
1624                         android.Manifest.permission.ACCESS_WIFI_STATE,
1625                         android.Manifest.permission.ACCESS_NETWORK_STATE
1626                 });
1627         options.setRequireNoneOfPermissions(
1628                 new String[] { // test package does not have NETWORK_STACK
1629                         android.Manifest.permission.NETWORK_STACK
1630                 });
1631         mContext.sendBroadcast(new Intent(ResultReceiver.MOCK_ACTION), null,
1632                 options.toBundle());
1633 
1634         new PollingCheck(BROADCAST_TIMEOUT) {
1635             @Override
1636             protected boolean check() {
1637                 return receiver.hasReceivedBroadCast();
1638             }
1639         }.run();
1640     }
1641 
1642     /**
1643      * Verify the receiver will not get the broadcast since it has one of the excluded permissions.
1644      */
testSendBroadcastRequireNoneOfPermissions_receiverHasExcludedPermissions()1645     public void testSendBroadcastRequireNoneOfPermissions_receiverHasExcludedPermissions()
1646             throws Exception {
1647         final ResultReceiver receiver = new ResultReceiver();
1648 
1649         registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION));
1650         BroadcastOptions options = BroadcastOptions.makeBasic();
1651         options.setRequireAllOfPermissions(
1652                 new String[] { // this test APK has ACCESS_WIFI_STATE
1653                         android.Manifest.permission.ACCESS_WIFI_STATE
1654                 });
1655         options.setRequireNoneOfPermissions(
1656                 new String[] { // test package has ACCESS_NETWORK_STATE
1657                         android.Manifest.permission.ACCESS_NETWORK_STATE
1658                 });
1659         mContext.sendBroadcast(new Intent(ResultReceiver.MOCK_ACTION), null,
1660                 options.toBundle());
1661 
1662         Thread.sleep(BROADCAST_TIMEOUT);
1663         assertFalse(receiver.hasReceivedBroadCast());
1664     }
1665 
1666     /** The receiver should get the broadcast if it has all the permissions. */
testSendBroadcastWithMultiplePermissions_receiverHasAllPermissions()1667     public void testSendBroadcastWithMultiplePermissions_receiverHasAllPermissions()
1668             throws Exception {
1669         final ResultReceiver receiver = new ResultReceiver();
1670 
1671         registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION));
1672 
1673         mContext.sendBroadcastWithMultiplePermissions(
1674                 new Intent(ResultReceiver.MOCK_ACTION),
1675                 new String[] { // this test APK has both these permissions
1676                         android.Manifest.permission.ACCESS_WIFI_STATE,
1677                         android.Manifest.permission.ACCESS_NETWORK_STATE,
1678                 });
1679 
1680         new PollingCheck(BROADCAST_TIMEOUT) {
1681             @Override
1682             protected boolean check() {
1683                 return receiver.hasReceivedBroadCast();
1684             }
1685         }.run();
1686     }
1687 
1688     /** The receiver should not get the broadcast if it does not have all the permissions. */
testSendBroadcastWithMultiplePermissions_receiverHasSomePermissions()1689     public void testSendBroadcastWithMultiplePermissions_receiverHasSomePermissions()
1690             throws Exception {
1691         final ResultReceiver receiver = new ResultReceiver();
1692 
1693         registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION));
1694 
1695         mContext.sendBroadcastWithMultiplePermissions(
1696                 new Intent(ResultReceiver.MOCK_ACTION),
1697                 new String[] { // this test APK only has ACCESS_WIFI_STATE
1698                         android.Manifest.permission.ACCESS_WIFI_STATE,
1699                         android.Manifest.permission.NETWORK_STACK,
1700                 });
1701 
1702         Thread.sleep(BROADCAST_TIMEOUT);
1703         assertFalse(receiver.hasReceivedBroadCast());
1704     }
1705 
1706     /** The receiver should not get the broadcast if it has none of the permissions. */
testSendBroadcastWithMultiplePermissions_receiverHasNoPermissions()1707     public void testSendBroadcastWithMultiplePermissions_receiverHasNoPermissions()
1708             throws Exception {
1709         final ResultReceiver receiver = new ResultReceiver();
1710 
1711         registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION));
1712 
1713         mContext.sendBroadcastWithMultiplePermissions(
1714                 new Intent(ResultReceiver.MOCK_ACTION),
1715                 new String[] { // this test APK has neither of these permissions
1716                         android.Manifest.permission.NETWORK_SETTINGS,
1717                         android.Manifest.permission.NETWORK_STACK,
1718                 });
1719 
1720         Thread.sleep(BROADCAST_TIMEOUT);
1721         assertFalse(receiver.hasReceivedBroadCast());
1722     }
1723 
1724     /**
1725      * Starting from Android 13, a SecurityException is thrown for apps targeting this
1726      * release or later that do not specify {@link Context#RECEIVER_EXPORTED} or {@link
1727      * Context#RECEIVER_NOT_EXPORTED} when registering for non-system broadcasts.
1728      */
1729     // TODO(b/206699109): Re-enable test when instrumentation workaround is removed; without a flag
1730     // specified the instrumentation workaround automatically adds RECEIVER_EXPORTED.
1731     @Suppress
testRegisterReceiver_noFlags_exceptionThrown()1732     public void testRegisterReceiver_noFlags_exceptionThrown() throws Exception {
1733         try {
1734             final ResultReceiver receiver = new ResultReceiver();
1735 
1736             registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION), 0);
1737 
1738             fail("An app targeting Android 13 and registering a dynamic receiver for a "
1739                     + "non-system broadcast must receive a SecurityException if "
1740                     + "RECEIVER_EXPORTED or RECEIVER_NOT_EXPORTED is not specified");
1741         } catch (SecurityException expected) {
1742         }
1743     }
1744 
1745     /**
1746      * An app targeting Android 13 or later can register for system broadcasts without specifying
1747      * {@link Context#RECEIVER_EXPORTED} or {@link Context@RECEIVER_NOT_EXPORTED}.
1748      */
testRegisterReceiver_noFlagsProtectedBroadcast_noExceptionThrown()1749     public void testRegisterReceiver_noFlagsProtectedBroadcast_noExceptionThrown()
1750             throws Exception {
1751         final ResultReceiver receiver = new ResultReceiver();
1752 
1753         // Intent.ACTION_SCREEN_OFF is a system broadcast and thus should not require a flag
1754         // indicating whether the receiver is exported.
1755         registerBroadcastReceiver(receiver, new IntentFilter(Intent.ACTION_SCREEN_OFF), 0);
1756     }
1757 
1758     /**
1759      * An app targeting Android 13 or later can request a sticky broadcast via
1760      * {@code Context#registerReceiver} without specifying {@link Context#RECEIVER_EXPORTED} or
1761      * {@link Context#RECEIVER_NOT_EXPORTED}.
1762      */
testRegisterReceiver_noFlagsStickyBroadcast_noExceptionThrown()1763     public void testRegisterReceiver_noFlagsStickyBroadcast_noExceptionThrown() throws Exception {
1764         // If a null receiver is specified to Context#registerReceiver, it indicates the caller
1765         // is requesting a sticky broadcast without actually registering a receiver; a flag
1766         // must not be required in this case.
1767         mContext.registerReceiver(null, new IntentFilter(ResultReceiver.MOCK_ACTION), 0);
1768     }
1769 
1770     /**
1771      * Starting from Android 13, an app targeting this release or later must specify one of either
1772      * {@link Context#RECEIVER_EXPORTED} or {@link Context#RECEIVER_NOT_EXPORTED} when registering
1773      * a receiver for non-system broadcasts; however if both are specified then an
1774      * {@link IllegalArgumentException} should be thrown.
1775      */
testRegisterReceiver_bothFlags_exceptionThrown()1776     public void testRegisterReceiver_bothFlags_exceptionThrown() throws Exception {
1777         try {
1778             final ResultReceiver receiver = new ResultReceiver();
1779 
1780             registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION),
1781                     Context.RECEIVER_EXPORTED | Context.RECEIVER_NOT_EXPORTED);
1782 
1783             fail("An app invoke invoking Context#registerReceiver with both RECEIVER_EXPORTED and"
1784                     + " RECEIVER_NOT_EXPORTED set must receive an IllegalArgumentException");
1785         } catch (IllegalArgumentException expected) {
1786         }
1787     }
1788 
1789     /**
1790      * Verifies a receiver registered with {@link Context#RECEIVER_EXPORTED} can receive a
1791      * broadcast from an external app.
1792      *
1793      * <p>The broadcast is sent as a shell command since this most closely simulates sending a
1794      * broadcast from an external app; sending the broadcast via {@code
1795      * ShellIdentityUtils#invokeMethodWithShellPermissionsNoReturn} is still delivered even to
1796      * apps that use {@link Context#RECEIVER_NOT_EXPORTED}.
1797      */
testRegisterReceiver_exported_broadcastReceived()1798     public void testRegisterReceiver_exported_broadcastReceived() throws Exception {
1799         final ResultReceiver receiver = new ResultReceiver();
1800         registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION),
1801                 Context.RECEIVER_EXPORTED);
1802 
1803         SystemUtil.runShellCommand(EXTERNAL_APP_BROADCAST_COMMAND);
1804 
1805         new PollingCheck(BROADCAST_TIMEOUT, "The broadcast to the exported receiver"
1806                 + " was not received within the timeout window") {
1807             @Override
1808             protected boolean check() {
1809                 return receiver.hasReceivedBroadCast();
1810             }
1811         }.run();
1812     }
1813 
1814     /**
1815      * Verifies a receiver registered with {@link Context#RECEIVER_EXPORTED_UNAUDITED} can receive
1816      * a broadcast from an external app.
1817      *
1818      * <p>{@code Context#RECEIVER_EXPORTED_UNAUDITED} is only intended to be applied to receivers
1819      * that have not yet been audited to determine their intended exported state; this test ensures
1820      * this flag maintains the existing behavior of exporting the receiver until it can be
1821      * evaluated.
1822      */
testRegisterReceiver_exportedUnaudited_broadcastReceived()1823     public void testRegisterReceiver_exportedUnaudited_broadcastReceived() throws Exception {
1824         final ResultReceiver receiver = new ResultReceiver();
1825         registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION),
1826                 Context.RECEIVER_EXPORTED_UNAUDITED);
1827 
1828         SystemUtil.runShellCommand(EXTERNAL_APP_BROADCAST_COMMAND);
1829 
1830         new PollingCheck(BROADCAST_TIMEOUT, "The broadcast to the exported receiver"
1831                 + " was not received within the timeout window") {
1832             @Override
1833             protected boolean check() {
1834                 return receiver.hasReceivedBroadCast();
1835             }
1836         }.run();
1837     }
1838 
1839     /**
1840      * Verifies a receiver registered with {@link Context#RECEIVER_NOT_EXPORTED} does not receive
1841      * a broadcast from an external app.
1842      */
1843     // TODO(b/206699109): Re-enable this test once the skip for an external app sending a broadcast
1844     // to an unexported receiver is restored in BroadcastQueue.
1845     @Suppress
testRegisterReceiver_notExported_broadcastNotReceived()1846     public void testRegisterReceiver_notExported_broadcastNotReceived() throws Exception {
1847         final ResultReceiver receiver = new ResultReceiver();
1848         registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION),
1849                 Context.RECEIVER_NOT_EXPORTED);
1850 
1851         SystemUtil.runShellCommand(EXTERNAL_APP_BROADCAST_COMMAND);
1852 
1853         Thread.sleep(BROADCAST_TIMEOUT);
1854         assertFalse(
1855                 "An external app must not be able to send a broadcast to a dynamic receiver "
1856                         + "registered with RECEIVER_NOT_EXPORTED",
1857                 receiver.hasReceivedBroadCast());
1858     }
1859 
testEnforceCallingOrSelfUriPermission()1860     public void testEnforceCallingOrSelfUriPermission() {
1861         try {
1862             Uri uri = Uri.parse("content://ctstest");
1863             mContext.enforceCallingOrSelfUriPermission(uri,
1864                     Intent.FLAG_GRANT_WRITE_URI_PERMISSION,
1865                     "enforceCallingOrSelfUriPermission is not working without possessing an IPC.");
1866             fail("enforceCallingOrSelfUriPermission is not working without possessing an IPC.");
1867         } catch (SecurityException e) {
1868             // If the function is OK, it should throw a SecurityException here because currently no
1869             // IPC is handled by this process.
1870         }
1871     }
1872 
testGetAssets()1873     public void testGetAssets() {
1874         assertSame(mContext.getAssets(), mContext.getAssets());
1875     }
1876 
testGetResources()1877     public void testGetResources() {
1878         assertSame(mContext.getResources(), mContext.getResources());
1879     }
1880 
testStartInstrumentation()1881     public void testStartInstrumentation() {
1882         // Use wrong name
1883         ComponentName cn = new ComponentName("com.android",
1884                 "com.android.content.FalseLocalSampleInstrumentation");
1885         assertNotNull(cn);
1886         assertNotNull(mContext);
1887         // If the target instrumentation is wrong, the function should return false.
1888         assertFalse(mContext.startInstrumentation(cn, null, null));
1889     }
1890 
bindExpectResult(Context context, Intent service)1891     private void bindExpectResult(Context context, Intent service)
1892             throws InterruptedException {
1893         if (service == null) {
1894             fail("No service created!");
1895         }
1896         TestConnection conn = new TestConnection(true, false);
1897 
1898         context.bindService(service, conn, Context.BIND_AUTO_CREATE);
1899         context.startService(service);
1900 
1901         // Wait for a short time, so the service related operations could be
1902         // working.
1903         synchronized (this) {
1904             wait(2500);
1905         }
1906         // Test stop Service
1907         assertTrue(context.stopService(service));
1908         context.unbindService(conn);
1909 
1910         synchronized (this) {
1911             wait(1000);
1912         }
1913     }
1914 
1915     private interface Condition {
onCondition()1916         public boolean onCondition();
1917     }
1918 
waitForCondition(Condition con)1919     private synchronized void waitForCondition(Condition con) throws InterruptedException {
1920         // check the condition every 1 second until the condition is fulfilled
1921         // and wait for 3 seconds at most
1922         for (int i = 0; !con.onCondition() && i <= 3; i++) {
1923             wait(1000);
1924         }
1925     }
1926 
waitForReceiveBroadCast(final ResultReceiver receiver)1927     private void waitForReceiveBroadCast(final ResultReceiver receiver)
1928             throws InterruptedException {
1929         Condition con = new Condition() {
1930             public boolean onCondition() {
1931                 return receiver.hasReceivedBroadCast();
1932             }
1933         };
1934         waitForCondition(con);
1935     }
1936 
waitForFilteredIntent(Context context, final String action)1937     private void waitForFilteredIntent(Context context, final String action)
1938             throws InterruptedException {
1939         context.sendBroadcast(new Intent(action), null);
1940 
1941         synchronized (mLockObj) {
1942             mLockObj.wait(BROADCAST_TIMEOUT);
1943         }
1944     }
1945 
1946     private final class TestBroadcastReceiver extends BroadcastReceiver {
1947         boolean mHadReceivedBroadCast;
1948         boolean mIsOrderedBroadcasts;
1949 
1950         @Override
onReceive(Context context, Intent intent)1951         public void onReceive(Context context, Intent intent) {
1952             synchronized (this) {
1953                 if (mIsOrderedBroadcasts) {
1954                     setResultCode(3);
1955                     setResultData(ACTUAL_RESULT);
1956                 }
1957 
1958                 Bundle map = getResultExtras(false);
1959                 if (map != null) {
1960                     map.remove(KEY_REMOVED);
1961                     map.putString(KEY_ADDED, VALUE_ADDED);
1962                 }
1963                 mHadReceivedBroadCast = true;
1964                 this.notifyAll();
1965             }
1966 
1967             synchronized (mLockObj) {
1968                 mLockObj.notify();
1969             }
1970         }
1971 
hadReceivedBroadCast()1972         boolean hadReceivedBroadCast() {
1973             return mHadReceivedBroadCast;
1974         }
1975 
reset()1976         void reset(){
1977             mHadReceivedBroadCast = false;
1978         }
1979     }
1980 
1981     private class FilteredReceiver extends BroadcastReceiver {
1982         private boolean mHadReceivedBroadCast1 = false;
1983         private boolean mHadReceivedBroadCast2 = false;
1984 
onReceive(Context context, Intent intent)1985         public void onReceive(Context context, Intent intent) {
1986             String action = intent.getAction();
1987             if (MOCK_ACTION1.equals(action)) {
1988                 mHadReceivedBroadCast1 = true;
1989             } else if (MOCK_ACTION2.equals(action)) {
1990                 mHadReceivedBroadCast2 = true;
1991             }
1992 
1993             synchronized (mLockObj) {
1994                 mLockObj.notify();
1995             }
1996         }
1997 
hadReceivedBroadCast1()1998         public boolean hadReceivedBroadCast1() {
1999             return mHadReceivedBroadCast1;
2000         }
2001 
hadReceivedBroadCast2()2002         public boolean hadReceivedBroadCast2() {
2003             return mHadReceivedBroadCast2;
2004         }
2005 
reset()2006         public void reset(){
2007             mHadReceivedBroadCast1 = false;
2008             mHadReceivedBroadCast2 = false;
2009         }
2010     }
2011 
2012     private class TestConnection implements ServiceConnection {
TestConnection(boolean expectDisconnect, boolean setReporter)2013         public TestConnection(boolean expectDisconnect, boolean setReporter) {
2014         }
2015 
setMonitor(boolean v)2016         void setMonitor(boolean v) {
2017         }
2018 
onServiceConnected(ComponentName name, IBinder service)2019         public void onServiceConnected(ComponentName name, IBinder service) {
2020         }
2021 
onServiceDisconnected(ComponentName name)2022         public void onServiceDisconnected(ComponentName name) {
2023         }
2024     }
2025 
testOpenFileOutput_mustNotCreateWorldReadableFile()2026     public void testOpenFileOutput_mustNotCreateWorldReadableFile() throws Exception {
2027         try {
2028             mContext.openFileOutput("test.txt", Context.MODE_WORLD_READABLE);
2029             fail("Exception expected");
2030         } catch (SecurityException expected) {
2031         }
2032     }
2033 
testOpenFileOutput_mustNotCreateWorldWriteableFile()2034     public void testOpenFileOutput_mustNotCreateWorldWriteableFile() throws Exception {
2035         try {
2036             mContext.openFileOutput("test.txt", Context.MODE_WORLD_WRITEABLE);
2037             fail("Exception expected");
2038         } catch (SecurityException expected) {
2039         }
2040     }
2041 
testOpenFileOutput_mustNotWriteToParentDirectory()2042     public void testOpenFileOutput_mustNotWriteToParentDirectory() throws Exception {
2043         try {
2044             // Created files must be under the application's private directory.
2045             mContext.openFileOutput("../test.txt", Context.MODE_PRIVATE);
2046             fail("Exception expected");
2047         } catch (IllegalArgumentException expected) {
2048         }
2049     }
2050 
testOpenFileOutput_mustNotUseAbsolutePath()2051     public void testOpenFileOutput_mustNotUseAbsolutePath() throws Exception {
2052         try {
2053             // Created files must be under the application's private directory.
2054             mContext.openFileOutput("/tmp/test.txt", Context.MODE_PRIVATE);
2055             fail("Exception expected");
2056         } catch (IllegalArgumentException expected) {
2057         }
2058     }
2059 
isWallpaperSupported()2060     private boolean isWallpaperSupported() {
2061         return WallpaperManager.getInstance(mContext).isWallpaperSupported();
2062     }
2063 }
2064