1 /*
2  * Copyright (C) 2009 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 com.android.server.accounts;
18 
19 import static android.database.sqlite.SQLiteDatabase.deleteDatabase;
20 import static org.mockito.Matchers.any;
21 import static org.mockito.Matchers.anyBoolean;
22 import static org.mockito.Matchers.anyInt;
23 import static org.mockito.Matchers.anyString;
24 import static org.mockito.Matchers.eq;
25 import static org.mockito.Mockito.atLeast;
26 import static org.mockito.Mockito.never;
27 import static org.mockito.Mockito.nullable;
28 import static org.mockito.Mockito.times;
29 import static org.mockito.Mockito.verify;
30 import static org.mockito.Mockito.when;
31 
32 import android.accounts.Account;
33 import android.accounts.AccountManager;
34 import android.accounts.AccountManagerInternal;
35 import android.accounts.CantAddAccountActivity;
36 import android.accounts.IAccountManagerResponse;
37 import android.app.AppOpsManager;
38 import android.app.admin.DevicePolicyManager;
39 import android.app.admin.DevicePolicyManagerInternal;
40 import android.app.INotificationManager;
41 import android.content.BroadcastReceiver;
42 import android.content.ComponentName;
43 import android.content.Context;
44 import android.content.Intent;
45 import android.content.IntentFilter;
46 import android.content.ServiceConnection;
47 import android.content.pm.ActivityInfo;
48 import android.content.pm.ApplicationInfo;
49 import android.content.pm.PackageInfo;
50 import android.content.pm.PackageManager;
51 import android.content.pm.ResolveInfo;
52 import android.content.pm.Signature;
53 import android.content.pm.UserInfo;
54 import android.database.Cursor;
55 import android.database.DatabaseErrorHandler;
56 import android.database.sqlite.SQLiteDatabase;
57 import android.os.Bundle;
58 import android.os.Handler;
59 import android.os.IBinder;
60 import android.os.Looper;
61 import android.os.RemoteException;
62 import android.os.SystemClock;
63 import android.os.UserHandle;
64 import android.os.UserManager;
65 import android.test.AndroidTestCase;
66 import android.test.mock.MockContext;
67 import android.test.suitebuilder.annotation.SmallTest;
68 import android.util.Log;
69 
70 import com.android.frameworks.servicestests.R;
71 import com.android.server.LocalServices;
72 
73 import org.mockito.ArgumentCaptor;
74 import org.mockito.Captor;
75 import org.mockito.Mock;
76 import org.mockito.MockitoAnnotations;
77 
78 import java.io.File;
79 import java.security.GeneralSecurityException;
80 import java.util.ArrayList;
81 import java.util.Arrays;
82 import java.util.Collections;
83 import java.util.Comparator;
84 import java.util.HashMap;
85 import java.util.List;
86 import java.util.concurrent.CountDownLatch;
87 import java.util.concurrent.CyclicBarrier;
88 import java.util.concurrent.ExecutorService;
89 import java.util.concurrent.Executors;
90 import java.util.concurrent.TimeUnit;
91 import java.util.concurrent.atomic.AtomicLong;
92 
93 
94 /**
95  * Tests for {@link AccountManagerService}.
96  * <p>Run with:<pre>
97  * mmma -j40 frameworks/base/services/tests/servicestests
98  * adb install -r ${OUT}/data/app/FrameworksServicesTests/FrameworksServicesTests.apk
99  * adb shell am instrument -w -e package com.android.server.accounts \
100  * com.android.frameworks.servicestests\
101  * /android.support.test.runner.AndroidJUnitRunner
102  * </pre>
103  */
104 public class AccountManagerServiceTest extends AndroidTestCase {
105     private static final String TAG = AccountManagerServiceTest.class.getSimpleName();
106     private static final long ONE_DAY_IN_MILLISECOND = 86400000;
107 
108     @Mock private Context mMockContext;
109     @Mock private AppOpsManager mMockAppOpsManager;
110     @Mock private UserManager mMockUserManager;
111     @Mock private PackageManager mMockPackageManager;
112     @Mock private DevicePolicyManagerInternal mMockDevicePolicyManagerInternal;
113     @Mock private DevicePolicyManager mMockDevicePolicyManager;
114     @Mock private IAccountManagerResponse mMockAccountManagerResponse;
115     @Mock private IBinder mMockBinder;
116     @Mock private INotificationManager mMockNotificationManager;
117 
118     @Captor private ArgumentCaptor<Intent> mIntentCaptor;
119     @Captor private ArgumentCaptor<Bundle> mBundleCaptor;
120     private int mVisibleAccountsChangedBroadcasts;
121     private int mLoginAccountsChangedBroadcasts;
122     private int mAccountRemovedBroadcasts;
123 
124     private static final int LATCH_TIMEOUT_MS = 500;
125     private static final String PREN_DB = "pren.db";
126     private static final String DE_DB = "de.db";
127     private static final String CE_DB = "ce.db";
128     private PackageInfo mPackageInfo;
129     private AccountManagerService mAms;
130     private TestInjector mTestInjector;
131 
132     @Override
setUp()133     protected void setUp() throws Exception {
134         MockitoAnnotations.initMocks(this);
135 
136         when(mMockPackageManager.checkSignatures(anyInt(), anyInt()))
137                     .thenReturn(PackageManager.SIGNATURE_MATCH);
138         final UserInfo ui = new UserInfo(UserHandle.USER_SYSTEM, "user0", 0);
139         when(mMockUserManager.getUserInfo(eq(ui.id))).thenReturn(ui);
140         when(mMockContext.createPackageContextAsUser(
141                  anyString(), anyInt(), any(UserHandle.class))).thenReturn(mMockContext);
142         when(mMockContext.getPackageManager()).thenReturn(mMockPackageManager);
143 
144         mPackageInfo = new PackageInfo();
145         mPackageInfo.signatures = new Signature[1];
146         mPackageInfo.signatures[0] = new Signature(new byte[] {'a', 'b', 'c', 'd'});
147         mPackageInfo.applicationInfo = new ApplicationInfo();
148         mPackageInfo.applicationInfo.privateFlags = ApplicationInfo.PRIVATE_FLAG_PRIVILEGED;
149         when(mMockPackageManager.getPackageInfo(anyString(), anyInt())).thenReturn(mPackageInfo);
150         when(mMockContext.getSystemService(Context.APP_OPS_SERVICE)).thenReturn(mMockAppOpsManager);
151         when(mMockContext.getSystemService(Context.USER_SERVICE)).thenReturn(mMockUserManager);
152         when(mMockContext.getSystemServiceName(AppOpsManager.class)).thenReturn(
153                 Context.APP_OPS_SERVICE);
154         when(mMockContext.checkCallingOrSelfPermission(anyString())).thenReturn(
155                 PackageManager.PERMISSION_GRANTED);
156         Bundle bundle = new Bundle();
157         when(mMockUserManager.getUserRestrictions(any(UserHandle.class))).thenReturn(bundle);
158         when(mMockContext.getSystemService(Context.DEVICE_POLICY_SERVICE)).thenReturn(
159                 mMockDevicePolicyManager);
160         when(mMockAccountManagerResponse.asBinder()).thenReturn(mMockBinder);
161 
162         Context realTestContext = getContext();
163         MyMockContext mockContext = new MyMockContext(realTestContext, mMockContext);
164         setContext(mockContext);
165         mTestInjector = new TestInjector(realTestContext, mockContext, mMockNotificationManager);
166         mAms = new AccountManagerService(mTestInjector);
167     }
168 
169     @Override
tearDown()170     protected void tearDown() throws Exception {
171         // Let async logging tasks finish, otherwise they may crash due to db being removed
172         CountDownLatch cdl = new CountDownLatch(1);
173         mAms.mHandler.post(() -> {
174             deleteDatabase(new File(mTestInjector.getCeDatabaseName(UserHandle.USER_SYSTEM)));
175             deleteDatabase(new File(mTestInjector.getDeDatabaseName(UserHandle.USER_SYSTEM)));
176             deleteDatabase(new File(mTestInjector.getPreNDatabaseName(UserHandle.USER_SYSTEM)));
177             cdl.countDown();
178         });
179         cdl.await(1, TimeUnit.SECONDS);
180         super.tearDown();
181     }
182 
183     class AccountSorter implements Comparator<Account> {
compare(Account object1, Account object2)184         public int compare(Account object1, Account object2) {
185             if (object1 == object2) return 0;
186             if (object1 == null) return 1;
187             if (object2 == null) return -1;
188             int result = object1.type.compareTo(object2.type);
189             if (result != 0) return result;
190             return object1.name.compareTo(object2.name);
191         }
192     }
193 
194     @SmallTest
testCheckAddAccount()195     public void testCheckAddAccount() throws Exception {
196         unlockSystemUser();
197         Account a11 = new Account("account1", AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1);
198         Account a21 = new Account("account2", AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1);
199         Account a31 = new Account("account3", AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1);
200         Account a12 = new Account("account1", AccountManagerServiceTestFixtures.ACCOUNT_TYPE_2);
201         Account a22 = new Account("account2", AccountManagerServiceTestFixtures.ACCOUNT_TYPE_2);
202         Account a32 = new Account("account3", AccountManagerServiceTestFixtures.ACCOUNT_TYPE_2);
203         mAms.addAccountExplicitly(a11, "p11", null);
204         mAms.addAccountExplicitly(a12, "p12", null);
205         mAms.addAccountExplicitly(a21, "p21", null);
206         mAms.addAccountExplicitly(a22, "p22", null);
207         mAms.addAccountExplicitly(a31, "p31", null);
208         mAms.addAccountExplicitly(a32, "p32", null);
209 
210         String[] list = new String[]{AccountManagerServiceTestFixtures.CALLER_PACKAGE};
211         when(mMockPackageManager.getPackagesForUid(anyInt())).thenReturn(list);
212         Account[] accounts = mAms.getAccounts(null, mContext.getOpPackageName());
213         Arrays.sort(accounts, new AccountSorter());
214         assertEquals(6, accounts.length);
215         assertEquals(a11, accounts[0]);
216         assertEquals(a21, accounts[1]);
217         assertEquals(a31, accounts[2]);
218         assertEquals(a12, accounts[3]);
219         assertEquals(a22, accounts[4]);
220         assertEquals(a32, accounts[5]);
221 
222         accounts = mAms.getAccounts(AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
223                 mContext.getOpPackageName());
224         Arrays.sort(accounts, new AccountSorter());
225         assertEquals(3, accounts.length);
226         assertEquals(a11, accounts[0]);
227         assertEquals(a21, accounts[1]);
228         assertEquals(a31, accounts[2]);
229 
230         mAms.removeAccountInternal(a21);
231 
232         accounts = mAms.getAccounts(AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
233                 mContext.getOpPackageName());
234         Arrays.sort(accounts, new AccountSorter());
235         assertEquals(2, accounts.length);
236         assertEquals(a11, accounts[0]);
237         assertEquals(a31, accounts[1]);
238     }
239 
240     @SmallTest
testPasswords()241     public void testPasswords() throws Exception {
242         unlockSystemUser();
243         Account a11 = new Account("account1", AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1);
244         Account a12 = new Account("account1", AccountManagerServiceTestFixtures.ACCOUNT_TYPE_2);
245         mAms.addAccountExplicitly(a11, "p11", null);
246         mAms.addAccountExplicitly(a12, "p12", null);
247 
248         assertEquals("p11", mAms.getPassword(a11));
249         assertEquals("p12", mAms.getPassword(a12));
250 
251         mAms.setPassword(a11, "p11b");
252 
253         assertEquals("p11b", mAms.getPassword(a11));
254         assertEquals("p12", mAms.getPassword(a12));
255     }
256 
257     @SmallTest
testUserdata()258     public void testUserdata() throws Exception {
259         unlockSystemUser();
260         Account a11 = new Account("account1", AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1);
261         Bundle u11 = new Bundle();
262         u11.putString("a", "a_a11");
263         u11.putString("b", "b_a11");
264         u11.putString("c", "c_a11");
265         Account a12 = new Account("account1", AccountManagerServiceTestFixtures.ACCOUNT_TYPE_2);
266         Bundle u12 = new Bundle();
267         u12.putString("a", "a_a12");
268         u12.putString("b", "b_a12");
269         u12.putString("c", "c_a12");
270         mAms.addAccountExplicitly(a11, "p11", u11);
271         mAms.addAccountExplicitly(a12, "p12", u12);
272 
273         assertEquals("a_a11", mAms.getUserData(a11, "a"));
274         assertEquals("b_a11", mAms.getUserData(a11, "b"));
275         assertEquals("c_a11", mAms.getUserData(a11, "c"));
276         assertEquals("a_a12", mAms.getUserData(a12, "a"));
277         assertEquals("b_a12", mAms.getUserData(a12, "b"));
278         assertEquals("c_a12", mAms.getUserData(a12, "c"));
279 
280         mAms.setUserData(a11, "b", "b_a11b");
281         mAms.setUserData(a12, "c", null);
282 
283         assertEquals("a_a11", mAms.getUserData(a11, "a"));
284         assertEquals("b_a11b", mAms.getUserData(a11, "b"));
285         assertEquals("c_a11", mAms.getUserData(a11, "c"));
286         assertEquals("a_a12", mAms.getUserData(a12, "a"));
287         assertEquals("b_a12", mAms.getUserData(a12, "b"));
288         assertNull(mAms.getUserData(a12, "c"));
289     }
290 
291     @SmallTest
testAuthtokens()292     public void testAuthtokens() throws Exception {
293         unlockSystemUser();
294         Account a11 = new Account("account1", AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1);
295         Account a12 = new Account("account1", AccountManagerServiceTestFixtures.ACCOUNT_TYPE_2);
296         mAms.addAccountExplicitly(a11, "p11", null);
297         mAms.addAccountExplicitly(a12, "p12", null);
298 
299         mAms.setAuthToken(a11, "att1", "a11_att1");
300         mAms.setAuthToken(a11, "att2", "a11_att2");
301         mAms.setAuthToken(a11, "att3", "a11_att3");
302         mAms.setAuthToken(a12, "att1", "a12_att1");
303         mAms.setAuthToken(a12, "att2", "a12_att2");
304         mAms.setAuthToken(a12, "att3", "a12_att3");
305 
306         assertEquals("a11_att1", mAms.peekAuthToken(a11, "att1"));
307         assertEquals("a11_att2", mAms.peekAuthToken(a11, "att2"));
308         assertEquals("a11_att3", mAms.peekAuthToken(a11, "att3"));
309         assertEquals("a12_att1", mAms.peekAuthToken(a12, "att1"));
310         assertEquals("a12_att2", mAms.peekAuthToken(a12, "att2"));
311         assertEquals("a12_att3", mAms.peekAuthToken(a12, "att3"));
312 
313         mAms.setAuthToken(a11, "att3", "a11_att3b");
314         mAms.invalidateAuthToken(a12.type, "a12_att2");
315 
316         assertEquals("a11_att1", mAms.peekAuthToken(a11, "att1"));
317         assertEquals("a11_att2", mAms.peekAuthToken(a11, "att2"));
318         assertEquals("a11_att3b", mAms.peekAuthToken(a11, "att3"));
319         assertEquals("a12_att1", mAms.peekAuthToken(a12, "att1"));
320         assertNull(mAms.peekAuthToken(a12, "att2"));
321         assertEquals("a12_att3", mAms.peekAuthToken(a12, "att3"));
322 
323         assertNull(mAms.peekAuthToken(a12, "att2"));
324     }
325 
326     @SmallTest
testRemovedAccountSync()327     public void testRemovedAccountSync() throws Exception {
328         String[] list = new String[]{AccountManagerServiceTestFixtures.CALLER_PACKAGE};
329         when(mMockPackageManager.getPackagesForUid(anyInt())).thenReturn(list);
330         unlockSystemUser();
331         Account a1 = new Account("account1", AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1);
332         Account a2 = new Account("account2", AccountManagerServiceTestFixtures.ACCOUNT_TYPE_2);
333         mAms.addAccountExplicitly(a1, "p1", null);
334         mAms.addAccountExplicitly(a2, "p2", null);
335 
336         Context originalContext = ((MyMockContext)getContext()).mTestContext;
337         // create a separate instance of AMS. It initially assumes that user0 is locked
338         AccountManagerService ams2 = new AccountManagerService(mTestInjector);
339 
340         // Verify that account can be removed when user is locked
341         ams2.removeAccountInternal(a1);
342         Account[] accounts = ams2.getAccounts(UserHandle.USER_SYSTEM, mContext.getOpPackageName());
343         assertEquals(1, accounts.length);
344         assertEquals("Only a2 should be returned", a2, accounts[0]);
345 
346         // Verify that CE db file is unchanged and still has 2 accounts
347         String ceDatabaseName = mTestInjector.getCeDatabaseName(UserHandle.USER_SYSTEM);
348         int accountsNumber = readNumberOfAccountsFromDbFile(originalContext, ceDatabaseName);
349         assertEquals("CE database should still have 2 accounts", 2, accountsNumber);
350 
351         // Unlock the user and verify that db has been updated
352         ams2.onUserUnlocked(newIntentForUser(UserHandle.USER_SYSTEM));
353         accounts = ams2.getAccounts(UserHandle.USER_SYSTEM, mContext.getOpPackageName());
354         assertEquals(1, accounts.length);
355         assertEquals("Only a2 should be returned", a2, accounts[0]);
356         accountsNumber = readNumberOfAccountsFromDbFile(originalContext, ceDatabaseName);
357         assertEquals("CE database should now have 1 account", 1, accountsNumber);
358     }
359 
360     @SmallTest
testPreNDatabaseMigration()361     public void testPreNDatabaseMigration() throws Exception {
362         String preNDatabaseName = mTestInjector.getPreNDatabaseName(UserHandle.USER_SYSTEM);
363         Context originalContext = ((MyMockContext) getContext()).mTestContext;
364         PreNTestDatabaseHelper.createV4Database(originalContext, preNDatabaseName);
365         // Assert that database was created with 1 account
366         int n = readNumberOfAccountsFromDbFile(originalContext, preNDatabaseName);
367         assertEquals("pre-N database should have 1 account", 1, n);
368 
369         // Start testing
370         unlockSystemUser();
371         String[] list = new String[]{AccountManagerServiceTestFixtures.CALLER_PACKAGE};
372         when(mMockPackageManager.getPackagesForUid(anyInt())).thenReturn(list);
373         Account[] accounts = mAms.getAccounts(null, mContext.getOpPackageName());
374         assertEquals("1 account should be migrated", 1, accounts.length);
375         assertEquals(PreNTestDatabaseHelper.ACCOUNT_NAME, accounts[0].name);
376         assertEquals(PreNTestDatabaseHelper.ACCOUNT_PASSWORD, mAms.getPassword(accounts[0]));
377         assertEquals("Authtoken should be migrated",
378                 PreNTestDatabaseHelper.TOKEN_STRING,
379                 mAms.peekAuthToken(accounts[0], PreNTestDatabaseHelper.TOKEN_TYPE));
380 
381         assertFalse("pre-N database file should be removed but was found at " + preNDatabaseName,
382                 new File(preNDatabaseName).exists());
383 
384         // Verify that ce/de files are present
385         String deDatabaseName = mTestInjector.getDeDatabaseName(UserHandle.USER_SYSTEM);
386         String ceDatabaseName = mTestInjector.getCeDatabaseName(UserHandle.USER_SYSTEM);
387         assertTrue("DE database file should be created at " + deDatabaseName,
388                 new File(deDatabaseName).exists());
389         assertTrue("CE database file should be created at " + ceDatabaseName,
390                 new File(ceDatabaseName).exists());
391     }
392 
393     @SmallTest
testStartAddAccountSessionWithNullResponse()394     public void testStartAddAccountSessionWithNullResponse() throws Exception {
395         unlockSystemUser();
396         try {
397             mAms.startAddAccountSession(
398                 null, // response
399                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
400                 "authTokenType",
401                 null, // requiredFeatures
402                 true, // expectActivityLaunch
403                 null); // optionsIn
404             fail("IllegalArgumentException expected. But no exception was thrown.");
405         } catch (IllegalArgumentException e) {
406             // IllegalArgumentException is expected.
407         }
408     }
409 
410     @SmallTest
testStartAddAccountSessionWithNullAccountType()411     public void testStartAddAccountSessionWithNullAccountType() throws Exception {
412         unlockSystemUser();
413         try {
414             mAms.startAddAccountSession(
415                     mMockAccountManagerResponse, // response
416                     null, // accountType
417                     "authTokenType",
418                     null, // requiredFeatures
419                     true, // expectActivityLaunch
420                     null); // optionsIn
421             fail("IllegalArgumentException expected. But no exception was thrown.");
422         } catch (IllegalArgumentException e) {
423             // IllegalArgumentException is expected.
424         }
425     }
426 
427     @SmallTest
testStartAddAccountSessionUserCannotModifyAccountNoDPM()428     public void testStartAddAccountSessionUserCannotModifyAccountNoDPM() throws Exception {
429         unlockSystemUser();
430         Bundle bundle = new Bundle();
431         bundle.putBoolean(UserManager.DISALLOW_MODIFY_ACCOUNTS, true);
432         when(mMockUserManager.getUserRestrictions(any(UserHandle.class))).thenReturn(bundle);
433         LocalServices.removeServiceForTest(DevicePolicyManagerInternal.class);
434 
435         mAms.startAddAccountSession(
436                 mMockAccountManagerResponse, // response
437                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
438                 "authTokenType",
439                 null, // requiredFeatures
440                 true, // expectActivityLaunch
441                 null); // optionsIn
442         verify(mMockAccountManagerResponse).onError(
443                 eq(AccountManager.ERROR_CODE_USER_RESTRICTED), anyString());
444         verify(mMockContext).startActivityAsUser(mIntentCaptor.capture(), eq(UserHandle.SYSTEM));
445 
446         // verify the intent for default CantAddAccountActivity is sent.
447         Intent intent = mIntentCaptor.getValue();
448         assertEquals(intent.getComponent().getClassName(), CantAddAccountActivity.class.getName());
449         assertEquals(intent.getIntExtra(CantAddAccountActivity.EXTRA_ERROR_CODE, 0),
450                 AccountManager.ERROR_CODE_USER_RESTRICTED);
451     }
452 
453     @SmallTest
testStartAddAccountSessionUserCannotModifyAccountWithDPM()454     public void testStartAddAccountSessionUserCannotModifyAccountWithDPM() throws Exception {
455         unlockSystemUser();
456         Bundle bundle = new Bundle();
457         bundle.putBoolean(UserManager.DISALLOW_MODIFY_ACCOUNTS, true);
458         when(mMockUserManager.getUserRestrictions(any(UserHandle.class))).thenReturn(bundle);
459         LocalServices.removeServiceForTest(DevicePolicyManagerInternal.class);
460         LocalServices.addService(
461                 DevicePolicyManagerInternal.class, mMockDevicePolicyManagerInternal);
462         when(mMockDevicePolicyManagerInternal.createUserRestrictionSupportIntent(
463                 anyInt(), anyString())).thenReturn(new Intent());
464         when(mMockDevicePolicyManagerInternal.createShowAdminSupportIntent(
465                 anyInt(), anyBoolean())).thenReturn(new Intent());
466 
467         mAms.startAddAccountSession(
468                 mMockAccountManagerResponse, // response
469                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
470                 "authTokenType",
471                 null, // requiredFeatures
472                 true, // expectActivityLaunch
473                 null); // optionsIn
474 
475         verify(mMockAccountManagerResponse).onError(
476                 eq(AccountManager.ERROR_CODE_USER_RESTRICTED), anyString());
477         verify(mMockContext).startActivityAsUser(any(Intent.class), eq(UserHandle.SYSTEM));
478         verify(mMockDevicePolicyManagerInternal).createUserRestrictionSupportIntent(
479                 anyInt(), anyString());
480     }
481 
482     @SmallTest
testStartAddAccountSessionUserCannotModifyAccountForTypeNoDPM()483     public void testStartAddAccountSessionUserCannotModifyAccountForTypeNoDPM() throws Exception {
484         unlockSystemUser();
485         when(mMockDevicePolicyManager.getAccountTypesWithManagementDisabledAsUser(anyInt()))
486                 .thenReturn(new String[]{AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, "BBB"});
487         LocalServices.removeServiceForTest(DevicePolicyManagerInternal.class);
488 
489         mAms.startAddAccountSession(
490                 mMockAccountManagerResponse, // response
491                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
492                 "authTokenType",
493                 null, // requiredFeatures
494                 true, // expectActivityLaunch
495                 null); // optionsIn
496 
497         verify(mMockAccountManagerResponse).onError(
498                 eq(AccountManager.ERROR_CODE_MANAGEMENT_DISABLED_FOR_ACCOUNT_TYPE), anyString());
499         verify(mMockContext).startActivityAsUser(mIntentCaptor.capture(), eq(UserHandle.SYSTEM));
500 
501         // verify the intent for default CantAddAccountActivity is sent.
502         Intent intent = mIntentCaptor.getValue();
503         assertEquals(intent.getComponent().getClassName(), CantAddAccountActivity.class.getName());
504         assertEquals(intent.getIntExtra(CantAddAccountActivity.EXTRA_ERROR_CODE, 0),
505                 AccountManager.ERROR_CODE_MANAGEMENT_DISABLED_FOR_ACCOUNT_TYPE);
506     }
507 
508     @SmallTest
testStartAddAccountSessionUserCannotModifyAccountForTypeWithDPM()509     public void testStartAddAccountSessionUserCannotModifyAccountForTypeWithDPM() throws Exception {
510         unlockSystemUser();
511         when(mMockContext.getSystemService(Context.DEVICE_POLICY_SERVICE)).thenReturn(
512                 mMockDevicePolicyManager);
513         when(mMockDevicePolicyManager.getAccountTypesWithManagementDisabledAsUser(anyInt()))
514                 .thenReturn(new String[]{AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, "BBB"});
515 
516         LocalServices.removeServiceForTest(DevicePolicyManagerInternal.class);
517         LocalServices.addService(
518                 DevicePolicyManagerInternal.class, mMockDevicePolicyManagerInternal);
519         when(mMockDevicePolicyManagerInternal.createUserRestrictionSupportIntent(
520                 anyInt(), anyString())).thenReturn(new Intent());
521         when(mMockDevicePolicyManagerInternal.createShowAdminSupportIntent(
522                 anyInt(), anyBoolean())).thenReturn(new Intent());
523 
524         mAms.startAddAccountSession(
525                 mMockAccountManagerResponse, // response
526                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
527                 "authTokenType",
528                 null, // requiredFeatures
529                 true, // expectActivityLaunch
530                 null); // optionsIn
531 
532         verify(mMockAccountManagerResponse).onError(
533                 eq(AccountManager.ERROR_CODE_MANAGEMENT_DISABLED_FOR_ACCOUNT_TYPE), anyString());
534         verify(mMockContext).startActivityAsUser(any(Intent.class), eq(UserHandle.SYSTEM));
535         verify(mMockDevicePolicyManagerInternal).createShowAdminSupportIntent(
536                 anyInt(), anyBoolean());
537     }
538 
539     @SmallTest
testStartAddAccountSessionSuccessWithoutPasswordForwarding()540     public void testStartAddAccountSessionSuccessWithoutPasswordForwarding() throws Exception {
541         unlockSystemUser();
542         when(mMockContext.checkCallingOrSelfPermission(anyString())).thenReturn(
543                 PackageManager.PERMISSION_DENIED);
544 
545         final CountDownLatch latch = new CountDownLatch(1);
546         Response response = new Response(latch, mMockAccountManagerResponse);
547         Bundle options = createOptionsWithAccountName(
548                 AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS);
549         mAms.startAddAccountSession(
550                 response, // response
551                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
552                 "authTokenType",
553                 null, // requiredFeatures
554                 false, // expectActivityLaunch
555                 options); // optionsIn
556         waitForLatch(latch);
557         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
558         Bundle result = mBundleCaptor.getValue();
559         Bundle sessionBundle = result.getBundle(AccountManager.KEY_ACCOUNT_SESSION_BUNDLE);
560         assertNotNull(sessionBundle);
561         // Assert that session bundle is encrypted and hence data not visible.
562         assertNull(sessionBundle.getString(AccountManagerServiceTestFixtures.SESSION_DATA_NAME_1));
563         // Assert password is not returned
564         assertNull(result.getString(AccountManager.KEY_PASSWORD));
565         assertNull(result.getString(AccountManager.KEY_AUTHTOKEN, null));
566         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_STATUS_TOKEN,
567                 result.getString(AccountManager.KEY_ACCOUNT_STATUS_TOKEN));
568     }
569 
570     @SmallTest
testStartAddAccountSessionSuccessWithPasswordForwarding()571     public void testStartAddAccountSessionSuccessWithPasswordForwarding() throws Exception {
572         unlockSystemUser();
573         when(mMockContext.checkCallingOrSelfPermission(anyString())).thenReturn(
574                 PackageManager.PERMISSION_GRANTED);
575 
576         final CountDownLatch latch = new CountDownLatch(1);
577         Response response = new Response(latch, mMockAccountManagerResponse);
578         Bundle options = createOptionsWithAccountName(
579                 AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS);
580         mAms.startAddAccountSession(
581                 response, // response
582                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
583                 "authTokenType",
584                 null, // requiredFeatures
585                 false, // expectActivityLaunch
586                 options); // optionsIn
587 
588         waitForLatch(latch);
589         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
590         Bundle result = mBundleCaptor.getValue();
591         Bundle sessionBundle = result.getBundle(AccountManager.KEY_ACCOUNT_SESSION_BUNDLE);
592         assertNotNull(sessionBundle);
593         // Assert that session bundle is encrypted and hence data not visible.
594         assertNull(sessionBundle.getString(AccountManagerServiceTestFixtures.SESSION_DATA_NAME_1));
595         // Assert password is returned
596         assertEquals(result.getString(AccountManager.KEY_PASSWORD),
597                 AccountManagerServiceTestFixtures.ACCOUNT_PASSWORD);
598         assertNull(result.getString(AccountManager.KEY_AUTHTOKEN));
599         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_STATUS_TOKEN,
600                 result.getString(AccountManager.KEY_ACCOUNT_STATUS_TOKEN));
601     }
602 
603     @SmallTest
testStartAddAccountSessionReturnWithInvalidIntent()604     public void testStartAddAccountSessionReturnWithInvalidIntent() throws Exception {
605         unlockSystemUser();
606         ResolveInfo resolveInfo = new ResolveInfo();
607         resolveInfo.activityInfo = new ActivityInfo();
608         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
609         when(mMockPackageManager.resolveActivityAsUser(
610                 any(Intent.class), anyInt(), anyInt())).thenReturn(resolveInfo);
611         when(mMockPackageManager.checkSignatures(
612                 anyInt(), anyInt())).thenReturn(PackageManager.SIGNATURE_NO_MATCH);
613 
614         final CountDownLatch latch = new CountDownLatch(1);
615         Response response = new Response(latch, mMockAccountManagerResponse);
616         Bundle options = createOptionsWithAccountName(
617                 AccountManagerServiceTestFixtures.ACCOUNT_NAME_INTERVENE);
618 
619         mAms.startAddAccountSession(
620                 response, // response
621                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
622                 "authTokenType",
623                 null, // requiredFeatures
624                 true, // expectActivityLaunch
625                 options); // optionsIn
626         waitForLatch(latch);
627         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
628         verify(mMockAccountManagerResponse).onError(
629                 eq(AccountManager.ERROR_CODE_REMOTE_EXCEPTION), anyString());
630     }
631 
632     @SmallTest
testStartAddAccountSessionReturnWithValidIntent()633     public void testStartAddAccountSessionReturnWithValidIntent() throws Exception {
634         unlockSystemUser();
635         ResolveInfo resolveInfo = new ResolveInfo();
636         resolveInfo.activityInfo = new ActivityInfo();
637         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
638         when(mMockPackageManager.resolveActivityAsUser(
639                 any(Intent.class), anyInt(), anyInt())).thenReturn(resolveInfo);
640         when(mMockPackageManager.checkSignatures(
641                 anyInt(), anyInt())).thenReturn(PackageManager.SIGNATURE_MATCH);
642 
643         final CountDownLatch latch = new CountDownLatch(1);
644         Response response = new Response(latch, mMockAccountManagerResponse);
645         Bundle options = createOptionsWithAccountName(
646                 AccountManagerServiceTestFixtures.ACCOUNT_NAME_INTERVENE);
647 
648         mAms.startAddAccountSession(
649                 response, // response
650                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
651                 "authTokenType",
652                 null, // requiredFeatures
653                 true, // expectActivityLaunch
654                 options); // optionsIn
655         waitForLatch(latch);
656 
657         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
658         Bundle result = mBundleCaptor.getValue();
659         Intent intent = result.getParcelable(AccountManager.KEY_INTENT);
660         assertNotNull(intent);
661         assertNotNull(intent.getParcelableExtra(AccountManagerServiceTestFixtures.KEY_RESULT));
662         assertNotNull(intent.getParcelableExtra(AccountManagerServiceTestFixtures.KEY_CALLBACK));
663     }
664 
665     @SmallTest
testStartAddAccountSessionError()666     public void testStartAddAccountSessionError() throws Exception {
667         unlockSystemUser();
668         Bundle options = createOptionsWithAccountName(
669                 AccountManagerServiceTestFixtures.ACCOUNT_NAME_ERROR);
670         options.putInt(AccountManager.KEY_ERROR_CODE, AccountManager.ERROR_CODE_INVALID_RESPONSE);
671         options.putString(AccountManager.KEY_ERROR_MESSAGE,
672                 AccountManagerServiceTestFixtures.ERROR_MESSAGE);
673 
674         final CountDownLatch latch = new CountDownLatch(1);
675         Response response = new Response(latch, mMockAccountManagerResponse);
676         mAms.startAddAccountSession(
677                 response, // response
678                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
679                 "authTokenType",
680                 null, // requiredFeatures
681                 false, // expectActivityLaunch
682                 options); // optionsIn
683 
684         waitForLatch(latch);
685         verify(mMockAccountManagerResponse).onError(AccountManager.ERROR_CODE_INVALID_RESPONSE,
686                 AccountManagerServiceTestFixtures.ERROR_MESSAGE);
687         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
688     }
689 
690     @SmallTest
testStartUpdateCredentialsSessionWithNullResponse()691     public void testStartUpdateCredentialsSessionWithNullResponse() throws Exception {
692         unlockSystemUser();
693         try {
694             mAms.startUpdateCredentialsSession(
695                 null, // response
696                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
697                 "authTokenType",
698                 true, // expectActivityLaunch
699                 null); // optionsIn
700             fail("IllegalArgumentException expected. But no exception was thrown.");
701         } catch (IllegalArgumentException e) {
702             // IllegalArgumentException is expected.
703         }
704     }
705 
706     @SmallTest
testStartUpdateCredentialsSessionWithNullAccount()707     public void testStartUpdateCredentialsSessionWithNullAccount() throws Exception {
708         unlockSystemUser();
709         try {
710             mAms.startUpdateCredentialsSession(
711                 mMockAccountManagerResponse, // response
712                 null,
713                 "authTokenType",
714                 true, // expectActivityLaunch
715                 null); // optionsIn
716             fail("IllegalArgumentException expected. But no exception was thrown.");
717         } catch (IllegalArgumentException e) {
718             // IllegalArgumentException is expected.
719         }
720     }
721 
722     @SmallTest
testStartUpdateCredentialsSessionSuccessWithoutPasswordForwarding()723     public void testStartUpdateCredentialsSessionSuccessWithoutPasswordForwarding()
724             throws Exception {
725         unlockSystemUser();
726         when(mMockContext.checkCallingOrSelfPermission(anyString())).thenReturn(
727                 PackageManager.PERMISSION_DENIED);
728 
729         final CountDownLatch latch = new CountDownLatch(1);
730         Response response = new Response(latch, mMockAccountManagerResponse);
731         Bundle options = createOptionsWithAccountName(
732             AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS);
733         mAms.startUpdateCredentialsSession(
734                 response, // response
735                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
736                 "authTokenType",
737                 false, // expectActivityLaunch
738                 options); // optionsIn
739         waitForLatch(latch);
740         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
741         Bundle result = mBundleCaptor.getValue();
742         Bundle sessionBundle = result.getBundle(AccountManager.KEY_ACCOUNT_SESSION_BUNDLE);
743         assertNotNull(sessionBundle);
744         // Assert that session bundle is encrypted and hence data not visible.
745         assertNull(sessionBundle.getString(AccountManagerServiceTestFixtures.SESSION_DATA_NAME_1));
746         // Assert password is not returned
747         assertNull(result.getString(AccountManager.KEY_PASSWORD));
748         assertNull(result.getString(AccountManager.KEY_AUTHTOKEN, null));
749         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_STATUS_TOKEN,
750                 result.getString(AccountManager.KEY_ACCOUNT_STATUS_TOKEN));
751     }
752 
753     @SmallTest
testStartUpdateCredentialsSessionSuccessWithPasswordForwarding()754     public void testStartUpdateCredentialsSessionSuccessWithPasswordForwarding() throws Exception {
755         unlockSystemUser();
756         when(mMockContext.checkCallingOrSelfPermission(anyString())).thenReturn(
757                 PackageManager.PERMISSION_GRANTED);
758 
759         final CountDownLatch latch = new CountDownLatch(1);
760         Response response = new Response(latch, mMockAccountManagerResponse);
761         Bundle options = createOptionsWithAccountName(
762             AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS);
763         mAms.startUpdateCredentialsSession(
764                 response, // response
765                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
766                 "authTokenType",
767                 false, // expectActivityLaunch
768                 options); // optionsIn
769 
770         waitForLatch(latch);
771         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
772         Bundle result = mBundleCaptor.getValue();
773         Bundle sessionBundle = result.getBundle(AccountManager.KEY_ACCOUNT_SESSION_BUNDLE);
774         assertNotNull(sessionBundle);
775         // Assert that session bundle is encrypted and hence data not visible.
776         assertNull(sessionBundle.getString(AccountManagerServiceTestFixtures.SESSION_DATA_NAME_1));
777         // Assert password is returned
778         assertEquals(result.getString(AccountManager.KEY_PASSWORD),
779                 AccountManagerServiceTestFixtures.ACCOUNT_PASSWORD);
780         assertNull(result.getString(AccountManager.KEY_AUTHTOKEN));
781         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_STATUS_TOKEN,
782                 result.getString(AccountManager.KEY_ACCOUNT_STATUS_TOKEN));
783     }
784 
785     @SmallTest
testStartUpdateCredentialsSessionReturnWithInvalidIntent()786     public void testStartUpdateCredentialsSessionReturnWithInvalidIntent() throws Exception {
787         unlockSystemUser();
788         ResolveInfo resolveInfo = new ResolveInfo();
789         resolveInfo.activityInfo = new ActivityInfo();
790         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
791         when(mMockPackageManager.resolveActivityAsUser(
792                 any(Intent.class), anyInt(), anyInt())).thenReturn(resolveInfo);
793         when(mMockPackageManager.checkSignatures(
794                 anyInt(), anyInt())).thenReturn(PackageManager.SIGNATURE_NO_MATCH);
795 
796         final CountDownLatch latch = new CountDownLatch(1);
797         Response response = new Response(latch, mMockAccountManagerResponse);
798         Bundle options = createOptionsWithAccountName(
799                 AccountManagerServiceTestFixtures.ACCOUNT_NAME_INTERVENE);
800 
801         mAms.startUpdateCredentialsSession(
802                 response, // response
803                 AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE,
804                 "authTokenType",
805                 true,  // expectActivityLaunch
806                 options); // optionsIn
807 
808         waitForLatch(latch);
809         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
810         verify(mMockAccountManagerResponse).onError(
811                 eq(AccountManager.ERROR_CODE_REMOTE_EXCEPTION), anyString());
812     }
813 
814     @SmallTest
testStartUpdateCredentialsSessionReturnWithValidIntent()815     public void testStartUpdateCredentialsSessionReturnWithValidIntent() throws Exception {
816         unlockSystemUser();
817         ResolveInfo resolveInfo = new ResolveInfo();
818         resolveInfo.activityInfo = new ActivityInfo();
819         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
820         when(mMockPackageManager.resolveActivityAsUser(
821                 any(Intent.class), anyInt(), anyInt())).thenReturn(resolveInfo);
822         when(mMockPackageManager.checkSignatures(
823                 anyInt(), anyInt())).thenReturn(PackageManager.SIGNATURE_MATCH);
824 
825         final CountDownLatch latch = new CountDownLatch(1);
826         Response response = new Response(latch, mMockAccountManagerResponse);
827         Bundle options = createOptionsWithAccountName(
828                 AccountManagerServiceTestFixtures.ACCOUNT_NAME_INTERVENE);
829 
830         mAms.startUpdateCredentialsSession(
831                 response, // response
832                 AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE,
833                 "authTokenType",
834                 true,  // expectActivityLaunch
835                 options); // optionsIn
836 
837         waitForLatch(latch);
838 
839         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
840         Bundle result = mBundleCaptor.getValue();
841         Intent intent = result.getParcelable(AccountManager.KEY_INTENT);
842         assertNotNull(intent);
843         assertNotNull(intent.getParcelableExtra(AccountManagerServiceTestFixtures.KEY_RESULT));
844         assertNotNull(intent.getParcelableExtra(AccountManagerServiceTestFixtures.KEY_CALLBACK));
845     }
846 
847     @SmallTest
testStartUpdateCredentialsSessionError()848     public void testStartUpdateCredentialsSessionError() throws Exception {
849         unlockSystemUser();
850         Bundle options = createOptionsWithAccountName(
851                 AccountManagerServiceTestFixtures.ACCOUNT_NAME_ERROR);
852         options.putInt(AccountManager.KEY_ERROR_CODE, AccountManager.ERROR_CODE_INVALID_RESPONSE);
853         options.putString(AccountManager.KEY_ERROR_MESSAGE,
854                 AccountManagerServiceTestFixtures.ERROR_MESSAGE);
855 
856         final CountDownLatch latch = new CountDownLatch(1);
857         Response response = new Response(latch, mMockAccountManagerResponse);
858 
859         mAms.startUpdateCredentialsSession(
860                 response, // response
861                 AccountManagerServiceTestFixtures.ACCOUNT_ERROR,
862                 "authTokenType",
863                 true,  // expectActivityLaunch
864                 options); // optionsIn
865 
866         waitForLatch(latch);
867         verify(mMockAccountManagerResponse).onError(AccountManager.ERROR_CODE_INVALID_RESPONSE,
868                 AccountManagerServiceTestFixtures.ERROR_MESSAGE);
869         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
870     }
871 
872     @SmallTest
testFinishSessionAsUserWithNullResponse()873     public void testFinishSessionAsUserWithNullResponse() throws Exception {
874         unlockSystemUser();
875         try {
876             mAms.finishSessionAsUser(
877                 null, // response
878                 createEncryptedSessionBundle(
879                         AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS),
880                 false, // expectActivityLaunch
881                 createAppBundle(), // appInfo
882                 UserHandle.USER_SYSTEM);
883             fail("IllegalArgumentException expected. But no exception was thrown.");
884         } catch (IllegalArgumentException e) {
885             // IllegalArgumentException is expected.
886         }
887     }
888 
889     @SmallTest
testFinishSessionAsUserWithNullSessionBundle()890     public void testFinishSessionAsUserWithNullSessionBundle() throws Exception {
891         unlockSystemUser();
892         try {
893             mAms.finishSessionAsUser(
894                 mMockAccountManagerResponse, // response
895                 null, // sessionBundle
896                 false, // expectActivityLaunch
897                 createAppBundle(), // appInfo
898                 UserHandle.USER_SYSTEM);
899             fail("IllegalArgumentException expected. But no exception was thrown.");
900         } catch (IllegalArgumentException e) {
901             // IllegalArgumentException is expected.
902         }
903     }
904 
905     @SmallTest
testFinishSessionAsUserUserCannotModifyAccountNoDPM()906     public void testFinishSessionAsUserUserCannotModifyAccountNoDPM() throws Exception {
907         unlockSystemUser();
908         Bundle bundle = new Bundle();
909         bundle.putBoolean(UserManager.DISALLOW_MODIFY_ACCOUNTS, true);
910         when(mMockUserManager.getUserRestrictions(any(UserHandle.class))).thenReturn(bundle);
911         LocalServices.removeServiceForTest(DevicePolicyManagerInternal.class);
912 
913         mAms.finishSessionAsUser(
914             mMockAccountManagerResponse, // response
915             createEncryptedSessionBundle(AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS),
916             false, // expectActivityLaunch
917             createAppBundle(), // appInfo
918             2); // fake user id
919 
920         verify(mMockAccountManagerResponse).onError(
921                 eq(AccountManager.ERROR_CODE_USER_RESTRICTED), anyString());
922         verify(mMockContext).startActivityAsUser(mIntentCaptor.capture(), eq(UserHandle.of(2)));
923 
924         // verify the intent for default CantAddAccountActivity is sent.
925         Intent intent = mIntentCaptor.getValue();
926         assertEquals(intent.getComponent().getClassName(), CantAddAccountActivity.class.getName());
927         assertEquals(intent.getIntExtra(CantAddAccountActivity.EXTRA_ERROR_CODE, 0),
928                 AccountManager.ERROR_CODE_USER_RESTRICTED);
929     }
930 
931     @SmallTest
testFinishSessionAsUserUserCannotModifyAccountWithDPM()932     public void testFinishSessionAsUserUserCannotModifyAccountWithDPM() throws Exception {
933         unlockSystemUser();
934         Bundle bundle = new Bundle();
935         bundle.putBoolean(UserManager.DISALLOW_MODIFY_ACCOUNTS, true);
936         when(mMockUserManager.getUserRestrictions(any(UserHandle.class))).thenReturn(bundle);
937         LocalServices.removeServiceForTest(DevicePolicyManagerInternal.class);
938         LocalServices.addService(
939                 DevicePolicyManagerInternal.class, mMockDevicePolicyManagerInternal);
940         when(mMockDevicePolicyManagerInternal.createUserRestrictionSupportIntent(
941                 anyInt(), anyString())).thenReturn(new Intent());
942         when(mMockDevicePolicyManagerInternal.createShowAdminSupportIntent(
943                 anyInt(), anyBoolean())).thenReturn(new Intent());
944 
945         mAms.finishSessionAsUser(
946             mMockAccountManagerResponse, // response
947             createEncryptedSessionBundle(AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS),
948             false, // expectActivityLaunch
949             createAppBundle(), // appInfo
950             2); // fake user id
951 
952         verify(mMockAccountManagerResponse).onError(
953                 eq(AccountManager.ERROR_CODE_USER_RESTRICTED), anyString());
954         verify(mMockContext).startActivityAsUser(any(Intent.class), eq(UserHandle.of(2)));
955         verify(mMockDevicePolicyManagerInternal).createUserRestrictionSupportIntent(
956                 anyInt(), anyString());
957     }
958 
959     @SmallTest
testFinishSessionAsUserWithBadSessionBundle()960     public void testFinishSessionAsUserWithBadSessionBundle() throws Exception {
961         unlockSystemUser();
962 
963         Bundle badSessionBundle = new Bundle();
964         badSessionBundle.putString("any", "any");
965         mAms.finishSessionAsUser(
966             mMockAccountManagerResponse, // response
967             badSessionBundle, // sessionBundle
968             false, // expectActivityLaunch
969             createAppBundle(), // appInfo
970             2); // fake user id
971 
972         verify(mMockAccountManagerResponse).onError(
973                 eq(AccountManager.ERROR_CODE_BAD_REQUEST), anyString());
974     }
975 
976     @SmallTest
testFinishSessionAsUserWithBadAccountType()977     public void testFinishSessionAsUserWithBadAccountType() throws Exception {
978         unlockSystemUser();
979 
980         mAms.finishSessionAsUser(
981             mMockAccountManagerResponse, // response
982             createEncryptedSessionBundleWithNoAccountType(
983                     AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS),
984             false, // expectActivityLaunch
985             createAppBundle(), // appInfo
986             2); // fake user id
987 
988         verify(mMockAccountManagerResponse).onError(
989                 eq(AccountManager.ERROR_CODE_BAD_ARGUMENTS), anyString());
990     }
991 
992     @SmallTest
testFinishSessionAsUserUserCannotModifyAccountForTypeNoDPM()993     public void testFinishSessionAsUserUserCannotModifyAccountForTypeNoDPM() throws Exception {
994         unlockSystemUser();
995         when(mMockDevicePolicyManager.getAccountTypesWithManagementDisabledAsUser(anyInt()))
996                 .thenReturn(new String[]{AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, "BBB"});
997         LocalServices.removeServiceForTest(DevicePolicyManagerInternal.class);
998 
999         mAms.finishSessionAsUser(
1000             mMockAccountManagerResponse, // response
1001             createEncryptedSessionBundle(AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS),
1002             false, // expectActivityLaunch
1003             createAppBundle(), // appInfo
1004             2); // fake user id
1005 
1006         verify(mMockAccountManagerResponse).onError(
1007                 eq(AccountManager.ERROR_CODE_MANAGEMENT_DISABLED_FOR_ACCOUNT_TYPE), anyString());
1008         verify(mMockContext).startActivityAsUser(mIntentCaptor.capture(), eq(UserHandle.of(2)));
1009 
1010         // verify the intent for default CantAddAccountActivity is sent.
1011         Intent intent = mIntentCaptor.getValue();
1012         assertEquals(intent.getComponent().getClassName(), CantAddAccountActivity.class.getName());
1013         assertEquals(intent.getIntExtra(CantAddAccountActivity.EXTRA_ERROR_CODE, 0),
1014                 AccountManager.ERROR_CODE_MANAGEMENT_DISABLED_FOR_ACCOUNT_TYPE);
1015     }
1016 
1017     @SmallTest
testFinishSessionAsUserUserCannotModifyAccountForTypeWithDPM()1018     public void testFinishSessionAsUserUserCannotModifyAccountForTypeWithDPM() throws Exception {
1019         unlockSystemUser();
1020         when(mMockContext.getSystemService(Context.DEVICE_POLICY_SERVICE)).thenReturn(
1021                 mMockDevicePolicyManager);
1022         when(mMockDevicePolicyManager.getAccountTypesWithManagementDisabledAsUser(anyInt()))
1023                 .thenReturn(new String[]{AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, "BBB"});
1024 
1025         LocalServices.removeServiceForTest(DevicePolicyManagerInternal.class);
1026         LocalServices.addService(
1027                 DevicePolicyManagerInternal.class, mMockDevicePolicyManagerInternal);
1028         when(mMockDevicePolicyManagerInternal.createUserRestrictionSupportIntent(
1029                 anyInt(), anyString())).thenReturn(new Intent());
1030         when(mMockDevicePolicyManagerInternal.createShowAdminSupportIntent(
1031                 anyInt(), anyBoolean())).thenReturn(new Intent());
1032 
1033         mAms.finishSessionAsUser(
1034             mMockAccountManagerResponse, // response
1035             createEncryptedSessionBundle(AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS),
1036             false, // expectActivityLaunch
1037             createAppBundle(), // appInfo
1038             2); // fake user id
1039 
1040         verify(mMockAccountManagerResponse).onError(
1041                 eq(AccountManager.ERROR_CODE_MANAGEMENT_DISABLED_FOR_ACCOUNT_TYPE), anyString());
1042         verify(mMockContext).startActivityAsUser(any(Intent.class), eq(UserHandle.of(2)));
1043         verify(mMockDevicePolicyManagerInternal).createShowAdminSupportIntent(
1044                 anyInt(), anyBoolean());
1045     }
1046 
1047     @SmallTest
testFinishSessionAsUserSuccess()1048     public void testFinishSessionAsUserSuccess() throws Exception {
1049         unlockSystemUser();
1050         final CountDownLatch latch = new CountDownLatch(1);
1051         Response response = new Response(latch, mMockAccountManagerResponse);
1052         mAms.finishSessionAsUser(
1053             response, // response
1054             createEncryptedSessionBundle(AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS),
1055             false, // expectActivityLaunch
1056             createAppBundle(), // appInfo
1057             UserHandle.USER_SYSTEM);
1058 
1059         waitForLatch(latch);
1060         // Verify notification is cancelled
1061         verify(mMockNotificationManager).cancelNotificationWithTag(
1062                 anyString(), nullable(String.class), anyInt(), anyInt());
1063 
1064         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
1065         Bundle result = mBundleCaptor.getValue();
1066         Bundle sessionBundle = result.getBundle(AccountManager.KEY_ACCOUNT_SESSION_BUNDLE);
1067         assertNotNull(sessionBundle);
1068         // Assert that session bundle is decrypted and hence data is visible.
1069         assertEquals(AccountManagerServiceTestFixtures.SESSION_DATA_VALUE_1,
1070                 sessionBundle.getString(AccountManagerServiceTestFixtures.SESSION_DATA_NAME_1));
1071         // Assert finishSessionAsUser added calling uid and pid into the sessionBundle
1072         assertTrue(sessionBundle.containsKey(AccountManager.KEY_CALLER_UID));
1073         assertTrue(sessionBundle.containsKey(AccountManager.KEY_CALLER_PID));
1074         assertEquals(sessionBundle.getString(
1075                 AccountManager.KEY_ANDROID_PACKAGE_NAME), "APCT.package");
1076 
1077         // Verify response data
1078         assertNull(result.getString(AccountManager.KEY_AUTHTOKEN, null));
1079         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_NAME,
1080                 result.getString(AccountManager.KEY_ACCOUNT_NAME));
1081         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
1082                 result.getString(AccountManager.KEY_ACCOUNT_TYPE));
1083     }
1084 
1085     @SmallTest
testFinishSessionAsUserReturnWithInvalidIntent()1086     public void testFinishSessionAsUserReturnWithInvalidIntent() throws Exception {
1087         unlockSystemUser();
1088         ResolveInfo resolveInfo = new ResolveInfo();
1089         resolveInfo.activityInfo = new ActivityInfo();
1090         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
1091         when(mMockPackageManager.resolveActivityAsUser(
1092                 any(Intent.class), anyInt(), anyInt())).thenReturn(resolveInfo);
1093         when(mMockPackageManager.checkSignatures(
1094                 anyInt(), anyInt())).thenReturn(PackageManager.SIGNATURE_NO_MATCH);
1095 
1096         final CountDownLatch latch = new CountDownLatch(1);
1097         Response response = new Response(latch, mMockAccountManagerResponse);
1098 
1099         mAms.finishSessionAsUser(
1100             response, // response
1101             createEncryptedSessionBundle(AccountManagerServiceTestFixtures.ACCOUNT_NAME_INTERVENE),
1102             true, // expectActivityLaunch
1103             createAppBundle(), // appInfo
1104             UserHandle.USER_SYSTEM);
1105 
1106         waitForLatch(latch);
1107         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
1108         verify(mMockAccountManagerResponse).onError(
1109                 eq(AccountManager.ERROR_CODE_REMOTE_EXCEPTION), anyString());
1110     }
1111 
1112     @SmallTest
testFinishSessionAsUserReturnWithValidIntent()1113     public void testFinishSessionAsUserReturnWithValidIntent() throws Exception {
1114         unlockSystemUser();
1115         ResolveInfo resolveInfo = new ResolveInfo();
1116         resolveInfo.activityInfo = new ActivityInfo();
1117         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
1118         when(mMockPackageManager.resolveActivityAsUser(
1119                 any(Intent.class), anyInt(), anyInt())).thenReturn(resolveInfo);
1120         when(mMockPackageManager.checkSignatures(
1121                 anyInt(), anyInt())).thenReturn(PackageManager.SIGNATURE_MATCH);
1122 
1123         final CountDownLatch latch = new CountDownLatch(1);
1124         Response response = new Response(latch, mMockAccountManagerResponse);
1125 
1126         mAms.finishSessionAsUser(
1127             response, // response
1128             createEncryptedSessionBundle(AccountManagerServiceTestFixtures.ACCOUNT_NAME_INTERVENE),
1129             true, // expectActivityLaunch
1130             createAppBundle(), // appInfo
1131             UserHandle.USER_SYSTEM);
1132 
1133         waitForLatch(latch);
1134 
1135         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
1136         Bundle result = mBundleCaptor.getValue();
1137         Intent intent = result.getParcelable(AccountManager.KEY_INTENT);
1138         assertNotNull(intent);
1139         assertNotNull(intent.getParcelableExtra(AccountManagerServiceTestFixtures.KEY_RESULT));
1140         assertNotNull(intent.getParcelableExtra(AccountManagerServiceTestFixtures.KEY_CALLBACK));
1141     }
1142 
1143     @SmallTest
testFinishSessionAsUserError()1144     public void testFinishSessionAsUserError() throws Exception {
1145         unlockSystemUser();
1146         Bundle sessionBundle = createEncryptedSessionBundleWithError(
1147                 AccountManagerServiceTestFixtures.ACCOUNT_NAME_ERROR);
1148 
1149         final CountDownLatch latch = new CountDownLatch(1);
1150         Response response = new Response(latch, mMockAccountManagerResponse);
1151 
1152         mAms.finishSessionAsUser(
1153             response, // response
1154             sessionBundle,
1155             false, // expectActivityLaunch
1156             createAppBundle(), // appInfo
1157             UserHandle.USER_SYSTEM);
1158 
1159         waitForLatch(latch);
1160         verify(mMockAccountManagerResponse).onError(AccountManager.ERROR_CODE_INVALID_RESPONSE,
1161                 AccountManagerServiceTestFixtures.ERROR_MESSAGE);
1162         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
1163     }
1164 
1165     @SmallTest
testIsCredentialsUpdatedSuggestedWithNullResponse()1166     public void testIsCredentialsUpdatedSuggestedWithNullResponse() throws Exception {
1167         unlockSystemUser();
1168         try {
1169             mAms.isCredentialsUpdateSuggested(
1170                 null, // response
1171                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
1172                 AccountManagerServiceTestFixtures.ACCOUNT_STATUS_TOKEN);
1173             fail("IllegalArgumentException expected. But no exception was thrown.");
1174         } catch (IllegalArgumentException e) {
1175             // IllegalArgumentException is expected.
1176         }
1177     }
1178 
1179     @SmallTest
testIsCredentialsUpdatedSuggestedWithNullAccount()1180     public void testIsCredentialsUpdatedSuggestedWithNullAccount() throws Exception {
1181         unlockSystemUser();
1182         try {
1183             mAms.isCredentialsUpdateSuggested(
1184                 mMockAccountManagerResponse,
1185                 null, // account
1186                 AccountManagerServiceTestFixtures.ACCOUNT_STATUS_TOKEN);
1187             fail("IllegalArgumentException expected. But no exception was thrown.");
1188         } catch (IllegalArgumentException e) {
1189             // IllegalArgumentException is expected.
1190         }
1191     }
1192 
1193     @SmallTest
testIsCredentialsUpdatedSuggestedWithEmptyStatusToken()1194     public void testIsCredentialsUpdatedSuggestedWithEmptyStatusToken() throws Exception {
1195         unlockSystemUser();
1196         try {
1197             mAms.isCredentialsUpdateSuggested(
1198                 mMockAccountManagerResponse,
1199                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
1200                 null);
1201             fail("IllegalArgumentException expected. But no exception was thrown.");
1202         } catch (IllegalArgumentException e) {
1203             // IllegalArgumentException is expected.
1204         }
1205     }
1206 
1207     @SmallTest
testIsCredentialsUpdatedSuggestedError()1208     public void testIsCredentialsUpdatedSuggestedError() throws Exception {
1209         unlockSystemUser();
1210         final CountDownLatch latch = new CountDownLatch(1);
1211         Response response = new Response(latch, mMockAccountManagerResponse);
1212 
1213         mAms.isCredentialsUpdateSuggested(
1214             response,
1215             AccountManagerServiceTestFixtures.ACCOUNT_ERROR,
1216             AccountManagerServiceTestFixtures.ACCOUNT_STATUS_TOKEN);
1217 
1218         waitForLatch(latch);
1219         verify(mMockAccountManagerResponse).onError(AccountManager.ERROR_CODE_INVALID_RESPONSE,
1220                 AccountManagerServiceTestFixtures.ERROR_MESSAGE);
1221         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
1222     }
1223 
1224     @SmallTest
testIsCredentialsUpdatedSuggestedSuccess()1225     public void testIsCredentialsUpdatedSuggestedSuccess() throws Exception {
1226         unlockSystemUser();
1227         final CountDownLatch latch = new CountDownLatch(1);
1228         Response response = new Response(latch, mMockAccountManagerResponse);
1229 
1230         mAms.isCredentialsUpdateSuggested(
1231             response,
1232             AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
1233             AccountManagerServiceTestFixtures.ACCOUNT_STATUS_TOKEN);
1234 
1235         waitForLatch(latch);
1236         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
1237         Bundle result = mBundleCaptor.getValue();
1238         boolean needUpdate = result.getBoolean(AccountManager.KEY_BOOLEAN_RESULT);
1239         assertTrue(needUpdate);
1240     }
1241 
1242     @SmallTest
testHasFeaturesWithNullResponse()1243     public void testHasFeaturesWithNullResponse() throws Exception {
1244         unlockSystemUser();
1245         try {
1246             mAms.hasFeatures(
1247                 null, // response
1248                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
1249                 new String[] {"feature1", "feature2"}, // features
1250                 "testPackage"); // opPackageName
1251             fail("IllegalArgumentException expected. But no exception was thrown.");
1252         } catch (IllegalArgumentException e) {
1253             // IllegalArgumentException is expected.
1254         }
1255     }
1256 
1257     @SmallTest
testHasFeaturesWithNullAccount()1258     public void testHasFeaturesWithNullAccount() throws Exception {
1259         unlockSystemUser();
1260         try {
1261             mAms.hasFeatures(
1262                 mMockAccountManagerResponse, // response
1263                 null, // account
1264                 new String[] {"feature1", "feature2"}, // features
1265                 "testPackage"); // opPackageName
1266             fail("IllegalArgumentException expected. But no exception was thrown.");
1267         } catch (IllegalArgumentException e) {
1268             // IllegalArgumentException is expected.
1269         }
1270     }
1271 
1272     @SmallTest
testHasFeaturesWithNullFeature()1273     public void testHasFeaturesWithNullFeature() throws Exception {
1274         unlockSystemUser();
1275         try {
1276             mAms.hasFeatures(
1277                     mMockAccountManagerResponse, // response
1278                     AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, // account
1279                     null, // features
1280                     "testPackage"); // opPackageName
1281             fail("IllegalArgumentException expected. But no exception was thrown.");
1282         } catch (IllegalArgumentException e) {
1283             // IllegalArgumentException is expected.
1284         }
1285     }
1286 
1287     @SmallTest
testHasFeaturesReturnNullResult()1288     public void testHasFeaturesReturnNullResult() throws Exception {
1289         unlockSystemUser();
1290         final CountDownLatch latch = new CountDownLatch(1);
1291         Response response = new Response(latch, mMockAccountManagerResponse);
1292         mAms.hasFeatures(
1293                 response, // response
1294                 AccountManagerServiceTestFixtures.ACCOUNT_ERROR, // account
1295                 AccountManagerServiceTestFixtures.ACCOUNT_FEATURES, // features
1296                 "testPackage"); // opPackageName
1297         waitForLatch(latch);
1298         verify(mMockAccountManagerResponse).onError(
1299                 eq(AccountManager.ERROR_CODE_INVALID_RESPONSE), anyString());
1300         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
1301     }
1302 
1303     @SmallTest
testHasFeaturesSuccess()1304     public void testHasFeaturesSuccess() throws Exception {
1305         unlockSystemUser();
1306         final CountDownLatch latch = new CountDownLatch(1);
1307         Response response = new Response(latch, mMockAccountManagerResponse);
1308         mAms.hasFeatures(
1309                 response, // response
1310                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, // account
1311                 AccountManagerServiceTestFixtures.ACCOUNT_FEATURES, // features
1312                 "testPackage"); // opPackageName
1313         waitForLatch(latch);
1314         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
1315         Bundle result = mBundleCaptor.getValue();
1316         boolean hasFeatures = result.getBoolean(AccountManager.KEY_BOOLEAN_RESULT);
1317         assertTrue(hasFeatures);
1318     }
1319 
1320     @SmallTest
testRemoveAccountAsUserWithNullResponse()1321     public void testRemoveAccountAsUserWithNullResponse() throws Exception {
1322         unlockSystemUser();
1323         try {
1324             mAms.removeAccountAsUser(
1325                 null, // response
1326                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
1327                 true, // expectActivityLaunch
1328                 UserHandle.USER_SYSTEM);
1329             fail("IllegalArgumentException expected. But no exception was thrown.");
1330         } catch (IllegalArgumentException e) {
1331             // IllegalArgumentException is expected.
1332         }
1333     }
1334 
1335     @SmallTest
testRemoveAccountAsUserWithNullAccount()1336     public void testRemoveAccountAsUserWithNullAccount() throws Exception {
1337         unlockSystemUser();
1338         try {
1339             mAms.removeAccountAsUser(
1340                 mMockAccountManagerResponse, // response
1341                 null, // account
1342                 true, // expectActivityLaunch
1343                 UserHandle.USER_SYSTEM);
1344             fail("IllegalArgumentException expected. But no exception was thrown.");
1345         } catch (IllegalArgumentException e) {
1346             // IllegalArgumentException is expected.
1347         }
1348     }
1349 
1350     @SmallTest
testRemoveAccountAsUserAccountNotManagedByCaller()1351     public void testRemoveAccountAsUserAccountNotManagedByCaller() throws Exception {
1352         unlockSystemUser();
1353         when(mMockPackageManager.checkSignatures(anyInt(), anyInt()))
1354                     .thenReturn(PackageManager.SIGNATURE_NO_MATCH);
1355         try {
1356             mAms.removeAccountAsUser(
1357                 mMockAccountManagerResponse, // response
1358                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
1359                 true, // expectActivityLaunch
1360                 UserHandle.USER_SYSTEM);
1361             fail("SecurityException expected. But no exception was thrown.");
1362         } catch (SecurityException e) {
1363             // SecurityException is expected.
1364         }
1365     }
1366 
1367     @SmallTest
testRemoveAccountAsUserUserCannotModifyAccount()1368     public void testRemoveAccountAsUserUserCannotModifyAccount() throws Exception {
1369         unlockSystemUser();
1370         Bundle bundle = new Bundle();
1371         bundle.putBoolean(UserManager.DISALLOW_MODIFY_ACCOUNTS, true);
1372         when(mMockUserManager.getUserRestrictions(any(UserHandle.class))).thenReturn(bundle);
1373 
1374         final CountDownLatch latch = new CountDownLatch(1);
1375         Response response = new Response(latch, mMockAccountManagerResponse);
1376 
1377         mAms.removeAccountAsUser(
1378                 response, // response
1379                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
1380                 true, // expectActivityLaunch
1381                 UserHandle.USER_SYSTEM);
1382         waitForLatch(latch);
1383         verify(mMockAccountManagerResponse).onError(
1384                 eq(AccountManager.ERROR_CODE_USER_RESTRICTED), anyString());
1385         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
1386     }
1387 
1388     @SmallTest
testRemoveAccountAsUserUserCannotModifyAccountType()1389     public void testRemoveAccountAsUserUserCannotModifyAccountType() throws Exception {
1390         unlockSystemUser();
1391         when(mMockContext.getSystemService(Context.DEVICE_POLICY_SERVICE)).thenReturn(
1392                 mMockDevicePolicyManager);
1393         when(mMockDevicePolicyManager.getAccountTypesWithManagementDisabledAsUser(anyInt()))
1394                 .thenReturn(new String[]{AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, "BBB"});
1395 
1396         final CountDownLatch latch = new CountDownLatch(1);
1397         Response response = new Response(latch, mMockAccountManagerResponse);
1398 
1399         mAms.removeAccountAsUser(
1400                 response, // response
1401                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
1402                 true, // expectActivityLaunch
1403                 UserHandle.USER_SYSTEM);
1404         waitForLatch(latch);
1405         verify(mMockAccountManagerResponse).onError(
1406                 eq(AccountManager.ERROR_CODE_MANAGEMENT_DISABLED_FOR_ACCOUNT_TYPE), anyString());
1407         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
1408     }
1409 
1410     @SmallTest
testRemoveAccountAsUserRemovalAllowed()1411     public void testRemoveAccountAsUserRemovalAllowed() throws Exception {
1412         String[] list = new String[]{AccountManagerServiceTestFixtures.CALLER_PACKAGE};
1413         when(mMockPackageManager.getPackagesForUid(anyInt())).thenReturn(list);
1414 
1415         unlockSystemUser();
1416         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p1", null);
1417         Account[] addedAccounts =
1418                 mAms.getAccounts(UserHandle.USER_SYSTEM, mContext.getOpPackageName());
1419         assertEquals(1, addedAccounts.length);
1420 
1421         final CountDownLatch latch = new CountDownLatch(1);
1422         Response response = new Response(latch, mMockAccountManagerResponse);
1423 
1424         mAms.removeAccountAsUser(
1425                 response, // response
1426                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
1427                 true, // expectActivityLaunch
1428                 UserHandle.USER_SYSTEM);
1429         waitForLatch(latch);
1430 
1431         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
1432         Bundle result = mBundleCaptor.getValue();
1433         boolean allowed = result.getBoolean(AccountManager.KEY_BOOLEAN_RESULT);
1434         assertTrue(allowed);
1435         Account[] accounts = mAms.getAccounts(UserHandle.USER_SYSTEM, mContext.getOpPackageName());
1436         assertEquals(0, accounts.length);
1437     }
1438 
1439     @SmallTest
testRemoveAccountAsUserRemovalNotAllowed()1440     public void testRemoveAccountAsUserRemovalNotAllowed() throws Exception {
1441         unlockSystemUser();
1442 
1443         final CountDownLatch latch = new CountDownLatch(1);
1444         Response response = new Response(latch, mMockAccountManagerResponse);
1445 
1446         mAms.removeAccountAsUser(
1447                 response, // response
1448                 AccountManagerServiceTestFixtures.ACCOUNT_ERROR,
1449                 true, // expectActivityLaunch
1450                 UserHandle.USER_SYSTEM);
1451         waitForLatch(latch);
1452 
1453         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
1454         Bundle result = mBundleCaptor.getValue();
1455         boolean allowed = result.getBoolean(AccountManager.KEY_BOOLEAN_RESULT);
1456         assertFalse(allowed);
1457     }
1458 
1459     @SmallTest
testRemoveAccountAsUserReturnWithValidIntent()1460     public void testRemoveAccountAsUserReturnWithValidIntent() throws Exception {
1461         unlockSystemUser();
1462         ResolveInfo resolveInfo = new ResolveInfo();
1463         resolveInfo.activityInfo = new ActivityInfo();
1464         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
1465         when(mMockPackageManager.resolveActivityAsUser(
1466                 any(Intent.class), anyInt(), anyInt())).thenReturn(resolveInfo);
1467         when(mMockPackageManager.checkSignatures(
1468                 anyInt(), anyInt())).thenReturn(PackageManager.SIGNATURE_MATCH);
1469 
1470         final CountDownLatch latch = new CountDownLatch(1);
1471         Response response = new Response(latch, mMockAccountManagerResponse);
1472 
1473         mAms.removeAccountAsUser(
1474                 response, // response
1475                 AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE,
1476                 true, // expectActivityLaunch
1477                 UserHandle.USER_SYSTEM);
1478         waitForLatch(latch);
1479 
1480         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
1481         Bundle result = mBundleCaptor.getValue();
1482         Intent intent = result.getParcelable(AccountManager.KEY_INTENT);
1483         assertNotNull(intent);
1484     }
1485 
1486     @SmallTest
testGetAccountsByTypeForPackageWhenTypeIsNull()1487     public void testGetAccountsByTypeForPackageWhenTypeIsNull() throws Exception {
1488         unlockSystemUser();
1489         HashMap<String, Integer> visibility1 = new HashMap<>();
1490         visibility1.put(AccountManagerServiceTestFixtures.CALLER_PACKAGE,
1491             AccountManager.VISIBILITY_USER_MANAGED_VISIBLE);
1492 
1493         HashMap<String, Integer> visibility2 = new HashMap<>();
1494         visibility2.put(AccountManagerServiceTestFixtures.CALLER_PACKAGE,
1495             AccountManager.VISIBILITY_USER_MANAGED_NOT_VISIBLE);
1496 
1497         mAms.addAccountExplicitlyWithVisibility(
1498             AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "P11", null, visibility1);
1499         mAms.addAccountExplicitlyWithVisibility(
1500             AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE, "P12", null, visibility2);
1501 
1502         Account[] accounts = mAms.getAccountsByTypeForPackage(
1503             null, "otherPackageName",
1504             AccountManagerServiceTestFixtures.CALLER_PACKAGE);
1505         // Only get the USER_MANAGED_NOT_VISIBLE account.
1506         assertEquals(1, accounts.length);
1507         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS, accounts[0].name);
1508         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, accounts[0].type);
1509     }
1510 
1511     @SmallTest
testGetAuthTokenLabelWithNullAccountType()1512     public void testGetAuthTokenLabelWithNullAccountType() throws Exception {
1513         unlockSystemUser();
1514         try {
1515             mAms.getAuthTokenLabel(
1516                 mMockAccountManagerResponse, // response
1517                 null, // accountType
1518                 "authTokenType");
1519             fail("IllegalArgumentException expected. But no exception was thrown.");
1520         } catch (IllegalArgumentException e) {
1521             // IllegalArgumentException is expected.
1522         }
1523     }
1524 
1525     @SmallTest
testGetAuthTokenLabelWithNullAuthTokenType()1526     public void testGetAuthTokenLabelWithNullAuthTokenType() throws Exception {
1527         unlockSystemUser();
1528         try {
1529             mAms.getAuthTokenLabel(
1530                 mMockAccountManagerResponse, // response
1531                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
1532                 null); // authTokenType
1533             fail("IllegalArgumentException expected. But no exception was thrown.");
1534         } catch (IllegalArgumentException e) {
1535             // IllegalArgumentException is expected.
1536         }
1537     }
1538 
1539     @SmallTest
testGetAuthTokenWithNullResponse()1540     public void testGetAuthTokenWithNullResponse() throws Exception {
1541         unlockSystemUser();
1542         try {
1543             mAms.getAuthToken(
1544                     null, // response
1545                     AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
1546                     "authTokenType", // authTokenType
1547                     true, // notifyOnAuthFailure
1548                     true, // expectActivityLaunch
1549                     createGetAuthTokenOptions());
1550             fail("IllegalArgumentException expected. But no exception was thrown.");
1551         } catch (IllegalArgumentException e) {
1552             // IllegalArgumentException is expected.
1553         }
1554     }
1555 
1556     @SmallTest
testGetAuthTokenWithNullAccount()1557     public void testGetAuthTokenWithNullAccount() throws Exception {
1558         unlockSystemUser();
1559         final CountDownLatch latch = new CountDownLatch(1);
1560         Response response = new Response(latch, mMockAccountManagerResponse);
1561         mAms.getAuthToken(
1562                     response, // response
1563                     null, // account
1564                     "authTokenType", // authTokenType
1565                     true, // notifyOnAuthFailure
1566                     true, // expectActivityLaunch
1567                     createGetAuthTokenOptions());
1568         waitForLatch(latch);
1569 
1570         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
1571         verify(mMockAccountManagerResponse).onError(
1572                 eq(AccountManager.ERROR_CODE_BAD_ARGUMENTS), anyString());
1573     }
1574 
1575     @SmallTest
testGetAuthTokenWithNullAuthTokenType()1576     public void testGetAuthTokenWithNullAuthTokenType() throws Exception {
1577         unlockSystemUser();
1578         final CountDownLatch latch = new CountDownLatch(1);
1579         Response response = new Response(latch, mMockAccountManagerResponse);
1580         mAms.getAuthToken(
1581                     response, // response
1582                     AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
1583                     null, // authTokenType
1584                     true, // notifyOnAuthFailure
1585                     true, // expectActivityLaunch
1586                     createGetAuthTokenOptions());
1587         waitForLatch(latch);
1588 
1589         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
1590         verify(mMockAccountManagerResponse).onError(
1591                 eq(AccountManager.ERROR_CODE_BAD_ARGUMENTS), anyString());
1592     }
1593 
1594     @SmallTest
testGetAuthTokenWithInvalidPackage()1595     public void testGetAuthTokenWithInvalidPackage() throws Exception {
1596         unlockSystemUser();
1597         String[] list = new String[]{"test"};
1598         when(mMockPackageManager.getPackagesForUid(anyInt())).thenReturn(list);
1599         try {
1600             mAms.getAuthToken(
1601                     mMockAccountManagerResponse, // response
1602                     AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
1603                     "authTokenType", // authTokenType
1604                     true, // notifyOnAuthFailure
1605                     true, // expectActivityLaunch
1606                     createGetAuthTokenOptions());
1607             fail("SecurityException expected. But no exception was thrown.");
1608         } catch (SecurityException e) {
1609             // SecurityException is expected.
1610         }
1611     }
1612 
1613     @SmallTest
testGetAuthTokenFromInternal()1614     public void testGetAuthTokenFromInternal() throws Exception {
1615         unlockSystemUser();
1616         when(mMockContext.createPackageContextAsUser(
1617                  anyString(), anyInt(), any(UserHandle.class))).thenReturn(mMockContext);
1618         when(mMockContext.getPackageManager()).thenReturn(mMockPackageManager);
1619         String[] list = new String[]{AccountManagerServiceTestFixtures.CALLER_PACKAGE};
1620         when(mMockPackageManager.getPackagesForUid(anyInt())).thenReturn(list);
1621         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null);
1622 
1623         mAms.setAuthToken(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
1624                 "authTokenType", AccountManagerServiceTestFixtures.AUTH_TOKEN);
1625         final CountDownLatch latch = new CountDownLatch(1);
1626         Response response = new Response(latch, mMockAccountManagerResponse);
1627         mAms.getAuthToken(
1628                     response, // response
1629                     AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
1630                     "authTokenType", // authTokenType
1631                     true, // notifyOnAuthFailure
1632                     true, // expectActivityLaunch
1633                     createGetAuthTokenOptions());
1634         waitForLatch(latch);
1635 
1636         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
1637         Bundle result = mBundleCaptor.getValue();
1638         assertEquals(result.getString(AccountManager.KEY_AUTHTOKEN),
1639                 AccountManagerServiceTestFixtures.AUTH_TOKEN);
1640         assertEquals(result.getString(AccountManager.KEY_ACCOUNT_NAME),
1641                 AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS);
1642         assertEquals(result.getString(AccountManager.KEY_ACCOUNT_TYPE),
1643                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1);
1644     }
1645 
1646     @SmallTest
testGetAuthTokenSuccess()1647     public void testGetAuthTokenSuccess() throws Exception {
1648         unlockSystemUser();
1649         when(mMockContext.createPackageContextAsUser(
1650                  anyString(), anyInt(), any(UserHandle.class))).thenReturn(mMockContext);
1651         when(mMockContext.getPackageManager()).thenReturn(mMockPackageManager);
1652         String[] list = new String[]{AccountManagerServiceTestFixtures.CALLER_PACKAGE};
1653         when(mMockPackageManager.getPackagesForUid(anyInt())).thenReturn(list);
1654 
1655         final CountDownLatch latch = new CountDownLatch(1);
1656         Response response = new Response(latch, mMockAccountManagerResponse);
1657         mAms.getAuthToken(
1658                     response, // response
1659                     AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
1660                     "authTokenType", // authTokenType
1661                     true, // notifyOnAuthFailure
1662                     false, // expectActivityLaunch
1663                     createGetAuthTokenOptions());
1664         waitForLatch(latch);
1665 
1666         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
1667         Bundle result = mBundleCaptor.getValue();
1668         assertEquals(result.getString(AccountManager.KEY_AUTHTOKEN),
1669                 AccountManagerServiceTestFixtures.AUTH_TOKEN);
1670         assertEquals(result.getString(AccountManager.KEY_ACCOUNT_NAME),
1671                 AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS);
1672         assertEquals(result.getString(AccountManager.KEY_ACCOUNT_TYPE),
1673                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1);
1674     }
1675 
1676     @SmallTest
testGetAuthTokenReturnWithInvalidIntent()1677     public void testGetAuthTokenReturnWithInvalidIntent() throws Exception {
1678         unlockSystemUser();
1679         when(mMockContext.createPackageContextAsUser(
1680                  anyString(), anyInt(), any(UserHandle.class))).thenReturn(mMockContext);
1681         when(mMockContext.getPackageManager()).thenReturn(mMockPackageManager);
1682         String[] list = new String[]{AccountManagerServiceTestFixtures.CALLER_PACKAGE};
1683         when(mMockPackageManager.getPackagesForUid(anyInt())).thenReturn(list);
1684         ResolveInfo resolveInfo = new ResolveInfo();
1685         resolveInfo.activityInfo = new ActivityInfo();
1686         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
1687         when(mMockPackageManager.resolveActivityAsUser(
1688                 any(Intent.class), anyInt(), anyInt())).thenReturn(resolveInfo);
1689         when(mMockPackageManager.checkSignatures(
1690                 anyInt(), anyInt())).thenReturn(PackageManager.SIGNATURE_NO_MATCH);
1691 
1692         final CountDownLatch latch = new CountDownLatch(1);
1693         Response response = new Response(latch, mMockAccountManagerResponse);
1694         mAms.getAuthToken(
1695                     response, // response
1696                     AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE,
1697                     "authTokenType", // authTokenType
1698                     true, // notifyOnAuthFailure
1699                     false, // expectActivityLaunch
1700                     createGetAuthTokenOptions());
1701         waitForLatch(latch);
1702         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
1703         verify(mMockAccountManagerResponse).onError(
1704                 eq(AccountManager.ERROR_CODE_REMOTE_EXCEPTION), anyString());
1705     }
1706 
1707     @SmallTest
testGetAuthTokenReturnWithValidIntent()1708     public void testGetAuthTokenReturnWithValidIntent() throws Exception {
1709         unlockSystemUser();
1710         when(mMockContext.createPackageContextAsUser(
1711                  anyString(), anyInt(), any(UserHandle.class))).thenReturn(mMockContext);
1712         when(mMockContext.getPackageManager()).thenReturn(mMockPackageManager);
1713         String[] list = new String[]{AccountManagerServiceTestFixtures.CALLER_PACKAGE};
1714         when(mMockPackageManager.getPackagesForUid(anyInt())).thenReturn(list);
1715 
1716         ResolveInfo resolveInfo = new ResolveInfo();
1717         resolveInfo.activityInfo = new ActivityInfo();
1718         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
1719         when(mMockPackageManager.resolveActivityAsUser(
1720                 any(Intent.class), anyInt(), anyInt())).thenReturn(resolveInfo);
1721         when(mMockPackageManager.checkSignatures(
1722                 anyInt(), anyInt())).thenReturn(PackageManager.SIGNATURE_MATCH);
1723 
1724         final CountDownLatch latch = new CountDownLatch(1);
1725         Response response = new Response(latch, mMockAccountManagerResponse);
1726         mAms.getAuthToken(
1727                     response, // response
1728                     AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE,
1729                     "authTokenType", // authTokenType
1730                     false, // notifyOnAuthFailure
1731                     true, // expectActivityLaunch
1732                     createGetAuthTokenOptions());
1733         waitForLatch(latch);
1734         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
1735         Bundle result = mBundleCaptor.getValue();
1736         Intent intent = result.getParcelable(AccountManager.KEY_INTENT);
1737         assertNotNull(intent);
1738         assertNotNull(intent.getParcelableExtra(AccountManagerServiceTestFixtures.KEY_RESULT));
1739         assertNotNull(intent.getParcelableExtra(AccountManagerServiceTestFixtures.KEY_CALLBACK));
1740     }
1741 
1742     @SmallTest
testGetAuthTokenError()1743     public void testGetAuthTokenError() throws Exception {
1744         unlockSystemUser();
1745         when(mMockContext.createPackageContextAsUser(
1746                  anyString(), anyInt(), any(UserHandle.class))).thenReturn(mMockContext);
1747         when(mMockContext.getPackageManager()).thenReturn(mMockPackageManager);
1748         String[] list = new String[]{AccountManagerServiceTestFixtures.CALLER_PACKAGE};
1749         when(mMockPackageManager.getPackagesForUid(anyInt())).thenReturn(list);
1750         final CountDownLatch latch = new CountDownLatch(1);
1751         Response response = new Response(latch, mMockAccountManagerResponse);
1752         mAms.getAuthToken(
1753                     response, // response
1754                     AccountManagerServiceTestFixtures.ACCOUNT_ERROR,
1755                     "authTokenType", // authTokenType
1756                     true, // notifyOnAuthFailure
1757                     false, // expectActivityLaunch
1758                     createGetAuthTokenOptions());
1759         waitForLatch(latch);
1760         verify(mMockAccountManagerResponse).onError(AccountManager.ERROR_CODE_INVALID_RESPONSE,
1761                 AccountManagerServiceTestFixtures.ERROR_MESSAGE);
1762         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
1763 
1764     }
1765 
1766     @SmallTest
testAddAccountAsUserWithNullResponse()1767     public void testAddAccountAsUserWithNullResponse() throws Exception {
1768         unlockSystemUser();
1769         try {
1770             mAms.addAccountAsUser(
1771                 null, // response
1772                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
1773                 "authTokenType",
1774                 null, // requiredFeatures
1775                 true, // expectActivityLaunch
1776                 null, // optionsIn
1777                 UserHandle.USER_SYSTEM);
1778             fail("IllegalArgumentException expected. But no exception was thrown.");
1779         } catch (IllegalArgumentException e) {
1780             // IllegalArgumentException is expected.
1781         }
1782     }
1783 
1784     @SmallTest
testAddAccountAsUserWithNullAccountType()1785     public void testAddAccountAsUserWithNullAccountType() throws Exception {
1786         unlockSystemUser();
1787         try {
1788             mAms.addAccountAsUser(
1789                 mMockAccountManagerResponse, // response
1790                 null, // accountType
1791                 "authTokenType",
1792                 null, // requiredFeatures
1793                 true, // expectActivityLaunch
1794                 null, // optionsIn
1795                 UserHandle.USER_SYSTEM);
1796             fail("IllegalArgumentException expected. But no exception was thrown.");
1797         } catch (IllegalArgumentException e) {
1798             // IllegalArgumentException is expected.
1799         }
1800     }
1801 
1802     @SmallTest
testAddAccountAsUserUserCannotModifyAccountNoDPM()1803     public void testAddAccountAsUserUserCannotModifyAccountNoDPM() throws Exception {
1804         unlockSystemUser();
1805         Bundle bundle = new Bundle();
1806         bundle.putBoolean(UserManager.DISALLOW_MODIFY_ACCOUNTS, true);
1807         when(mMockUserManager.getUserRestrictions(any(UserHandle.class))).thenReturn(bundle);
1808         LocalServices.removeServiceForTest(DevicePolicyManagerInternal.class);
1809 
1810         mAms.addAccountAsUser(
1811                 mMockAccountManagerResponse, // response
1812                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
1813                 "authTokenType",
1814                 null, // requiredFeatures
1815                 true, // expectActivityLaunch
1816                 null, // optionsIn
1817                 UserHandle.USER_SYSTEM);
1818         verify(mMockAccountManagerResponse).onError(
1819                 eq(AccountManager.ERROR_CODE_USER_RESTRICTED), anyString());
1820         verify(mMockContext).startActivityAsUser(mIntentCaptor.capture(), eq(UserHandle.SYSTEM));
1821 
1822         // verify the intent for default CantAddAccountActivity is sent.
1823         Intent intent = mIntentCaptor.getValue();
1824         assertEquals(intent.getComponent().getClassName(), CantAddAccountActivity.class.getName());
1825         assertEquals(intent.getIntExtra(CantAddAccountActivity.EXTRA_ERROR_CODE, 0),
1826                 AccountManager.ERROR_CODE_USER_RESTRICTED);
1827     }
1828 
1829     @SmallTest
testAddAccountAsUserUserCannotModifyAccountWithDPM()1830     public void testAddAccountAsUserUserCannotModifyAccountWithDPM() throws Exception {
1831         unlockSystemUser();
1832         Bundle bundle = new Bundle();
1833         bundle.putBoolean(UserManager.DISALLOW_MODIFY_ACCOUNTS, true);
1834         when(mMockUserManager.getUserRestrictions(any(UserHandle.class))).thenReturn(bundle);
1835         LocalServices.removeServiceForTest(DevicePolicyManagerInternal.class);
1836         LocalServices.addService(
1837                 DevicePolicyManagerInternal.class, mMockDevicePolicyManagerInternal);
1838         when(mMockDevicePolicyManagerInternal.createUserRestrictionSupportIntent(
1839                 anyInt(), anyString())).thenReturn(new Intent());
1840         when(mMockDevicePolicyManagerInternal.createShowAdminSupportIntent(
1841                 anyInt(), anyBoolean())).thenReturn(new Intent());
1842 
1843         mAms.addAccountAsUser(
1844                 mMockAccountManagerResponse, // response
1845                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
1846                 "authTokenType",
1847                 null, // requiredFeatures
1848                 true, // expectActivityLaunch
1849                 null, // optionsIn
1850                 UserHandle.USER_SYSTEM);
1851 
1852         verify(mMockAccountManagerResponse).onError(
1853                 eq(AccountManager.ERROR_CODE_USER_RESTRICTED), anyString());
1854         verify(mMockContext).startActivityAsUser(any(Intent.class), eq(UserHandle.SYSTEM));
1855         verify(mMockDevicePolicyManagerInternal).createUserRestrictionSupportIntent(
1856                 anyInt(), anyString());
1857     }
1858 
1859     @SmallTest
testAddAccountAsUserUserCannotModifyAccountForTypeNoDPM()1860     public void testAddAccountAsUserUserCannotModifyAccountForTypeNoDPM() throws Exception {
1861         unlockSystemUser();
1862         when(mMockDevicePolicyManager.getAccountTypesWithManagementDisabledAsUser(anyInt()))
1863                 .thenReturn(new String[]{AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, "BBB"});
1864         LocalServices.removeServiceForTest(DevicePolicyManagerInternal.class);
1865 
1866         mAms.addAccountAsUser(
1867                 mMockAccountManagerResponse, // response
1868                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
1869                 "authTokenType",
1870                 null, // requiredFeatures
1871                 true, // expectActivityLaunch
1872                 null, // optionsIn
1873                 UserHandle.USER_SYSTEM);
1874 
1875         verify(mMockAccountManagerResponse).onError(
1876                 eq(AccountManager.ERROR_CODE_MANAGEMENT_DISABLED_FOR_ACCOUNT_TYPE), anyString());
1877         verify(mMockContext).startActivityAsUser(mIntentCaptor.capture(), eq(UserHandle.SYSTEM));
1878 
1879         // verify the intent for default CantAddAccountActivity is sent.
1880         Intent intent = mIntentCaptor.getValue();
1881         assertEquals(intent.getComponent().getClassName(), CantAddAccountActivity.class.getName());
1882         assertEquals(intent.getIntExtra(CantAddAccountActivity.EXTRA_ERROR_CODE, 0),
1883                 AccountManager.ERROR_CODE_MANAGEMENT_DISABLED_FOR_ACCOUNT_TYPE);
1884     }
1885 
1886     @SmallTest
testAddAccountAsUserUserCannotModifyAccountForTypeWithDPM()1887     public void testAddAccountAsUserUserCannotModifyAccountForTypeWithDPM() throws Exception {
1888         unlockSystemUser();
1889         when(mMockContext.getSystemService(Context.DEVICE_POLICY_SERVICE)).thenReturn(
1890                 mMockDevicePolicyManager);
1891         when(mMockDevicePolicyManager.getAccountTypesWithManagementDisabledAsUser(anyInt()))
1892                 .thenReturn(new String[]{AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, "BBB"});
1893 
1894         LocalServices.removeServiceForTest(DevicePolicyManagerInternal.class);
1895         LocalServices.addService(
1896                 DevicePolicyManagerInternal.class, mMockDevicePolicyManagerInternal);
1897         when(mMockDevicePolicyManagerInternal.createUserRestrictionSupportIntent(
1898                 anyInt(), anyString())).thenReturn(new Intent());
1899         when(mMockDevicePolicyManagerInternal.createShowAdminSupportIntent(
1900                 anyInt(), anyBoolean())).thenReturn(new Intent());
1901 
1902         mAms.addAccountAsUser(
1903                 mMockAccountManagerResponse, // response
1904                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
1905                 "authTokenType",
1906                 null, // requiredFeatures
1907                 true, // expectActivityLaunch
1908                 null, // optionsIn
1909                 UserHandle.USER_SYSTEM);
1910 
1911         verify(mMockAccountManagerResponse).onError(
1912                 eq(AccountManager.ERROR_CODE_MANAGEMENT_DISABLED_FOR_ACCOUNT_TYPE), anyString());
1913         verify(mMockContext).startActivityAsUser(any(Intent.class), eq(UserHandle.SYSTEM));
1914         verify(mMockDevicePolicyManagerInternal).createShowAdminSupportIntent(
1915                 anyInt(), anyBoolean());
1916     }
1917 
1918     @SmallTest
testAddAccountAsUserSuccess()1919     public void testAddAccountAsUserSuccess() throws Exception {
1920         unlockSystemUser();
1921         final CountDownLatch latch = new CountDownLatch(1);
1922         Response response = new Response(latch, mMockAccountManagerResponse);
1923         mAms.addAccountAsUser(
1924                 response, // response
1925                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
1926                 "authTokenType",
1927                 null, // requiredFeatures
1928                 true, // expectActivityLaunch
1929                 createAddAccountOptions(AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS),
1930                 UserHandle.USER_SYSTEM);
1931         waitForLatch(latch);
1932         // Verify notification is cancelled
1933         verify(mMockNotificationManager).cancelNotificationWithTag(
1934                 anyString(), nullable(String.class), anyInt(), anyInt());
1935 
1936         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
1937         Bundle result = mBundleCaptor.getValue();
1938         // Verify response data
1939         assertNull(result.getString(AccountManager.KEY_AUTHTOKEN, null));
1940         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS,
1941                 result.getString(AccountManager.KEY_ACCOUNT_NAME));
1942         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
1943                 result.getString(AccountManager.KEY_ACCOUNT_TYPE));
1944 
1945         Bundle optionBundle = result.getParcelable(
1946                 AccountManagerServiceTestFixtures.KEY_OPTIONS_BUNDLE);
1947         // Assert addAccountAsUser added calling uid and pid into the option bundle
1948         assertTrue(optionBundle.containsKey(AccountManager.KEY_CALLER_UID));
1949         assertTrue(optionBundle.containsKey(AccountManager.KEY_CALLER_PID));
1950     }
1951 
1952     @SmallTest
testAddAccountAsUserReturnWithInvalidIntent()1953     public void testAddAccountAsUserReturnWithInvalidIntent() throws Exception {
1954         unlockSystemUser();
1955         ResolveInfo resolveInfo = new ResolveInfo();
1956         resolveInfo.activityInfo = new ActivityInfo();
1957         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
1958         when(mMockPackageManager.resolveActivityAsUser(
1959                 any(Intent.class), anyInt(), anyInt())).thenReturn(resolveInfo);
1960         when(mMockPackageManager.checkSignatures(
1961                 anyInt(), anyInt())).thenReturn(PackageManager.SIGNATURE_NO_MATCH);
1962 
1963         final CountDownLatch latch = new CountDownLatch(1);
1964         Response response = new Response(latch, mMockAccountManagerResponse);
1965         mAms.addAccountAsUser(
1966                 response, // response
1967                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
1968                 "authTokenType",
1969                 null, // requiredFeatures
1970                 true, // expectActivityLaunch
1971                 createAddAccountOptions(AccountManagerServiceTestFixtures.ACCOUNT_NAME_INTERVENE),
1972                 UserHandle.USER_SYSTEM);
1973 
1974         waitForLatch(latch);
1975         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
1976         verify(mMockAccountManagerResponse).onError(
1977                 eq(AccountManager.ERROR_CODE_REMOTE_EXCEPTION), anyString());
1978     }
1979 
1980     @SmallTest
testAddAccountAsUserReturnWithValidIntent()1981     public void testAddAccountAsUserReturnWithValidIntent() throws Exception {
1982         unlockSystemUser();
1983         ResolveInfo resolveInfo = new ResolveInfo();
1984         resolveInfo.activityInfo = new ActivityInfo();
1985         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
1986         when(mMockPackageManager.resolveActivityAsUser(
1987                 any(Intent.class), anyInt(), anyInt())).thenReturn(resolveInfo);
1988         when(mMockPackageManager.checkSignatures(
1989                 anyInt(), anyInt())).thenReturn(PackageManager.SIGNATURE_MATCH);
1990 
1991         final CountDownLatch latch = new CountDownLatch(1);
1992         Response response = new Response(latch, mMockAccountManagerResponse);
1993 
1994         mAms.addAccountAsUser(
1995                 response, // response
1996                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
1997                 "authTokenType",
1998                 null, // requiredFeatures
1999                 true, // expectActivityLaunch
2000                 createAddAccountOptions(AccountManagerServiceTestFixtures.ACCOUNT_NAME_INTERVENE),
2001                 UserHandle.USER_SYSTEM);
2002 
2003         waitForLatch(latch);
2004 
2005         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
2006         Bundle result = mBundleCaptor.getValue();
2007         Intent intent = result.getParcelable(AccountManager.KEY_INTENT);
2008         assertNotNull(intent);
2009         assertNotNull(intent.getParcelableExtra(AccountManagerServiceTestFixtures.KEY_RESULT));
2010         assertNotNull(intent.getParcelableExtra(AccountManagerServiceTestFixtures.KEY_CALLBACK));
2011     }
2012 
2013     @SmallTest
testAddAccountAsUserError()2014     public void testAddAccountAsUserError() throws Exception {
2015         unlockSystemUser();
2016 
2017         final CountDownLatch latch = new CountDownLatch(1);
2018         Response response = new Response(latch, mMockAccountManagerResponse);
2019 
2020         mAms.addAccountAsUser(
2021                 response, // response
2022                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
2023                 "authTokenType",
2024                 null, // requiredFeatures
2025                 true, // expectActivityLaunch
2026                 createAddAccountOptions(AccountManagerServiceTestFixtures.ACCOUNT_NAME_ERROR),
2027                 UserHandle.USER_SYSTEM);
2028 
2029         waitForLatch(latch);
2030         verify(mMockAccountManagerResponse).onError(AccountManager.ERROR_CODE_INVALID_RESPONSE,
2031                 AccountManagerServiceTestFixtures.ERROR_MESSAGE);
2032         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
2033     }
2034 
2035     @SmallTest
testConfirmCredentialsAsUserWithNullResponse()2036     public void testConfirmCredentialsAsUserWithNullResponse() throws Exception {
2037         unlockSystemUser();
2038         try {
2039             mAms.confirmCredentialsAsUser(
2040                 null, // response
2041                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
2042                 new Bundle(), // options
2043                 false, // expectActivityLaunch
2044                 UserHandle.USER_SYSTEM);
2045             fail("IllegalArgumentException expected. But no exception was thrown.");
2046         } catch (IllegalArgumentException e) {
2047             // IllegalArgumentException is expected.
2048         }
2049     }
2050 
2051     @SmallTest
testConfirmCredentialsAsUserWithNullAccount()2052     public void testConfirmCredentialsAsUserWithNullAccount() throws Exception {
2053         unlockSystemUser();
2054         try {
2055             mAms.confirmCredentialsAsUser(
2056                 mMockAccountManagerResponse, // response
2057                 null, // account
2058                 new Bundle(), // options
2059                 false, // expectActivityLaunch
2060                 UserHandle.USER_SYSTEM);
2061             fail("IllegalArgumentException expected. But no exception was thrown.");
2062         } catch (IllegalArgumentException e) {
2063             // IllegalArgumentException is expected.
2064         }
2065     }
2066 
2067     @SmallTest
testConfirmCredentialsAsUserSuccess()2068     public void testConfirmCredentialsAsUserSuccess() throws Exception {
2069         unlockSystemUser();
2070         final CountDownLatch latch = new CountDownLatch(1);
2071         Response response = new Response(latch, mMockAccountManagerResponse);
2072         mAms.confirmCredentialsAsUser(
2073                 response, // response
2074                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
2075                 new Bundle(), // options
2076                 true, // expectActivityLaunch
2077                 UserHandle.USER_SYSTEM);
2078         waitForLatch(latch);
2079 
2080         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
2081         Bundle result = mBundleCaptor.getValue();
2082         // Verify response data
2083         assertTrue(result.getBoolean(AccountManager.KEY_BOOLEAN_RESULT));
2084         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS,
2085                 result.getString(AccountManager.KEY_ACCOUNT_NAME));
2086         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2087                 result.getString(AccountManager.KEY_ACCOUNT_TYPE));
2088     }
2089 
2090     @SmallTest
testConfirmCredentialsAsUserReturnWithInvalidIntent()2091     public void testConfirmCredentialsAsUserReturnWithInvalidIntent() throws Exception {
2092         unlockSystemUser();
2093         ResolveInfo resolveInfo = new ResolveInfo();
2094         resolveInfo.activityInfo = new ActivityInfo();
2095         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
2096         when(mMockPackageManager.resolveActivityAsUser(
2097                 any(Intent.class), anyInt(), anyInt())).thenReturn(resolveInfo);
2098         when(mMockPackageManager.checkSignatures(
2099                 anyInt(), anyInt())).thenReturn(PackageManager.SIGNATURE_NO_MATCH);
2100 
2101         final CountDownLatch latch = new CountDownLatch(1);
2102         Response response = new Response(latch, mMockAccountManagerResponse);
2103         mAms.confirmCredentialsAsUser(
2104                 response, // response
2105                 AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE,
2106                 new Bundle(), // options
2107                 true, // expectActivityLaunch
2108                 UserHandle.USER_SYSTEM);
2109         waitForLatch(latch);
2110 
2111         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
2112         verify(mMockAccountManagerResponse).onError(
2113                 eq(AccountManager.ERROR_CODE_REMOTE_EXCEPTION), anyString());
2114     }
2115 
2116     @SmallTest
testConfirmCredentialsAsUserReturnWithValidIntent()2117     public void testConfirmCredentialsAsUserReturnWithValidIntent() throws Exception {
2118         unlockSystemUser();
2119         ResolveInfo resolveInfo = new ResolveInfo();
2120         resolveInfo.activityInfo = new ActivityInfo();
2121         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
2122         when(mMockPackageManager.resolveActivityAsUser(
2123                 any(Intent.class), anyInt(), anyInt())).thenReturn(resolveInfo);
2124         when(mMockPackageManager.checkSignatures(
2125                 anyInt(), anyInt())).thenReturn(PackageManager.SIGNATURE_MATCH);
2126 
2127         final CountDownLatch latch = new CountDownLatch(1);
2128         Response response = new Response(latch, mMockAccountManagerResponse);
2129 
2130         mAms.confirmCredentialsAsUser(
2131                 response, // response
2132                 AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE,
2133                 new Bundle(), // options
2134                 true, // expectActivityLaunch
2135                 UserHandle.USER_SYSTEM);
2136 
2137         waitForLatch(latch);
2138 
2139         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
2140         Bundle result = mBundleCaptor.getValue();
2141         Intent intent = result.getParcelable(AccountManager.KEY_INTENT);
2142         assertNotNull(intent);
2143         assertNotNull(intent.getParcelableExtra(AccountManagerServiceTestFixtures.KEY_RESULT));
2144         assertNotNull(intent.getParcelableExtra(AccountManagerServiceTestFixtures.KEY_CALLBACK));
2145     }
2146 
2147     @SmallTest
testConfirmCredentialsAsUserError()2148     public void testConfirmCredentialsAsUserError() throws Exception {
2149         unlockSystemUser();
2150 
2151         final CountDownLatch latch = new CountDownLatch(1);
2152         Response response = new Response(latch, mMockAccountManagerResponse);
2153 
2154         mAms.confirmCredentialsAsUser(
2155                 response, // response
2156                 AccountManagerServiceTestFixtures.ACCOUNT_ERROR,
2157                 new Bundle(), // options
2158                 true, // expectActivityLaunch
2159                 UserHandle.USER_SYSTEM);
2160 
2161         waitForLatch(latch);
2162         verify(mMockAccountManagerResponse).onError(AccountManager.ERROR_CODE_INVALID_RESPONSE,
2163                 AccountManagerServiceTestFixtures.ERROR_MESSAGE);
2164         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
2165     }
2166 
2167     @SmallTest
testUpdateCredentialsWithNullResponse()2168     public void testUpdateCredentialsWithNullResponse() throws Exception {
2169         unlockSystemUser();
2170         try {
2171             mAms.updateCredentials(
2172                 null, // response
2173                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
2174                 "authTokenType",
2175                 false, // expectActivityLaunch
2176                 new Bundle()); // options
2177             fail("IllegalArgumentException expected. But no exception was thrown.");
2178         } catch (IllegalArgumentException e) {
2179             // IllegalArgumentException is expected.
2180         }
2181     }
2182 
2183     @SmallTest
testUpdateCredentialsWithNullAccount()2184     public void testUpdateCredentialsWithNullAccount() throws Exception {
2185         unlockSystemUser();
2186         try {
2187             mAms.updateCredentials(
2188                 mMockAccountManagerResponse, // response
2189                 null, // account
2190                 "authTokenType",
2191                 false, // expectActivityLaunch
2192                 new Bundle()); // options
2193             fail("IllegalArgumentException expected. But no exception was thrown.");
2194         } catch (IllegalArgumentException e) {
2195             // IllegalArgumentException is expected.
2196         }
2197     }
2198 
2199     @SmallTest
testUpdateCredentialsSuccess()2200     public void testUpdateCredentialsSuccess() throws Exception {
2201         unlockSystemUser();
2202         final CountDownLatch latch = new CountDownLatch(1);
2203         Response response = new Response(latch, mMockAccountManagerResponse);
2204 
2205         mAms.updateCredentials(
2206                 response, // response
2207                 AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS,
2208                 "authTokenType",
2209                 false, // expectActivityLaunch
2210                 new Bundle()); // options
2211 
2212         waitForLatch(latch);
2213 
2214         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
2215         Bundle result = mBundleCaptor.getValue();
2216         // Verify response data
2217         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS,
2218                 result.getString(AccountManager.KEY_ACCOUNT_NAME));
2219         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2220                 result.getString(AccountManager.KEY_ACCOUNT_TYPE));
2221     }
2222 
2223     @SmallTest
testUpdateCredentialsReturnWithInvalidIntent()2224     public void testUpdateCredentialsReturnWithInvalidIntent() throws Exception {
2225         unlockSystemUser();
2226         ResolveInfo resolveInfo = new ResolveInfo();
2227         resolveInfo.activityInfo = new ActivityInfo();
2228         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
2229         when(mMockPackageManager.resolveActivityAsUser(
2230                 any(Intent.class), anyInt(), anyInt())).thenReturn(resolveInfo);
2231         when(mMockPackageManager.checkSignatures(
2232                 anyInt(), anyInt())).thenReturn(PackageManager.SIGNATURE_NO_MATCH);
2233 
2234         final CountDownLatch latch = new CountDownLatch(1);
2235         Response response = new Response(latch, mMockAccountManagerResponse);
2236 
2237         mAms.updateCredentials(
2238                 response, // response
2239                 AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE,
2240                 "authTokenType",
2241                 true, // expectActivityLaunch
2242                 new Bundle()); // options
2243 
2244         waitForLatch(latch);
2245 
2246         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
2247         verify(mMockAccountManagerResponse).onError(
2248                 eq(AccountManager.ERROR_CODE_REMOTE_EXCEPTION), anyString());
2249     }
2250 
2251     @SmallTest
testUpdateCredentialsReturnWithValidIntent()2252     public void testUpdateCredentialsReturnWithValidIntent() throws Exception {
2253         unlockSystemUser();
2254         ResolveInfo resolveInfo = new ResolveInfo();
2255         resolveInfo.activityInfo = new ActivityInfo();
2256         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
2257         when(mMockPackageManager.resolveActivityAsUser(
2258                 any(Intent.class), anyInt(), anyInt())).thenReturn(resolveInfo);
2259         when(mMockPackageManager.checkSignatures(
2260                 anyInt(), anyInt())).thenReturn(PackageManager.SIGNATURE_MATCH);
2261 
2262         final CountDownLatch latch = new CountDownLatch(1);
2263         Response response = new Response(latch, mMockAccountManagerResponse);
2264 
2265         mAms.updateCredentials(
2266                 response, // response
2267                 AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE,
2268                 "authTokenType",
2269                 true, // expectActivityLaunch
2270                 new Bundle()); // options
2271 
2272         waitForLatch(latch);
2273 
2274         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
2275         Bundle result = mBundleCaptor.getValue();
2276         Intent intent = result.getParcelable(AccountManager.KEY_INTENT);
2277         assertNotNull(intent);
2278         assertNotNull(intent.getParcelableExtra(AccountManagerServiceTestFixtures.KEY_RESULT));
2279         assertNotNull(intent.getParcelableExtra(AccountManagerServiceTestFixtures.KEY_CALLBACK));
2280     }
2281 
2282     @SmallTest
testUpdateCredentialsError()2283     public void testUpdateCredentialsError() throws Exception {
2284         unlockSystemUser();
2285 
2286         final CountDownLatch latch = new CountDownLatch(1);
2287         Response response = new Response(latch, mMockAccountManagerResponse);
2288 
2289         mAms.updateCredentials(
2290                 response, // response
2291                 AccountManagerServiceTestFixtures.ACCOUNT_ERROR,
2292                 "authTokenType",
2293                 false, // expectActivityLaunch
2294                 new Bundle()); // options
2295 
2296         waitForLatch(latch);
2297         verify(mMockAccountManagerResponse).onError(AccountManager.ERROR_CODE_INVALID_RESPONSE,
2298                 AccountManagerServiceTestFixtures.ERROR_MESSAGE);
2299         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
2300     }
2301 
2302     @SmallTest
testEditPropertiesWithNullResponse()2303     public void testEditPropertiesWithNullResponse() throws Exception {
2304         unlockSystemUser();
2305         try {
2306             mAms.editProperties(
2307                 null, // response
2308                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2309                 false); // expectActivityLaunch
2310             fail("IllegalArgumentException expected. But no exception was thrown.");
2311         } catch (IllegalArgumentException e) {
2312             // IllegalArgumentException is expected.
2313         }
2314     }
2315 
2316     @SmallTest
testEditPropertiesWithNullAccountType()2317     public void testEditPropertiesWithNullAccountType() throws Exception {
2318         unlockSystemUser();
2319         try {
2320             mAms.editProperties(
2321                 mMockAccountManagerResponse, // response
2322                 null, // accountType
2323                 false); // expectActivityLaunch
2324             fail("IllegalArgumentException expected. But no exception was thrown.");
2325         } catch (IllegalArgumentException e) {
2326             // IllegalArgumentException is expected.
2327         }
2328     }
2329 
2330     @SmallTest
testEditPropertiesAccountNotManagedByCaller()2331     public void testEditPropertiesAccountNotManagedByCaller() throws Exception {
2332         unlockSystemUser();
2333         when(mMockPackageManager.checkSignatures(anyInt(), anyInt()))
2334                     .thenReturn(PackageManager.SIGNATURE_NO_MATCH);
2335         try {
2336             mAms.editProperties(
2337                 mMockAccountManagerResponse, // response
2338                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2339                 false); // expectActivityLaunch
2340             fail("SecurityException expected. But no exception was thrown.");
2341         } catch (SecurityException e) {
2342             // SecurityException is expected.
2343         }
2344     }
2345 
2346     @SmallTest
testEditPropertiesSuccess()2347     public void testEditPropertiesSuccess() throws Exception {
2348         unlockSystemUser();
2349         final CountDownLatch latch = new CountDownLatch(1);
2350         Response response = new Response(latch, mMockAccountManagerResponse);
2351 
2352         mAms.editProperties(
2353                 response, // response
2354                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2355                 false); // expectActivityLaunch
2356 
2357         waitForLatch(latch);
2358 
2359         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
2360         Bundle result = mBundleCaptor.getValue();
2361         // Verify response data
2362         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS,
2363                 result.getString(AccountManager.KEY_ACCOUNT_NAME));
2364         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2365                 result.getString(AccountManager.KEY_ACCOUNT_TYPE));
2366     }
2367 
2368     @SmallTest
testGetAccountByTypeAndFeaturesWithNullResponse()2369     public void testGetAccountByTypeAndFeaturesWithNullResponse() throws Exception {
2370         unlockSystemUser();
2371         try {
2372             mAms.getAccountByTypeAndFeatures(
2373                 null, // response
2374                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2375                 AccountManagerServiceTestFixtures.ACCOUNT_FEATURES,
2376                 "testpackage"); // opPackageName
2377             fail("IllegalArgumentException expected. But no exception was thrown.");
2378         } catch (IllegalArgumentException e) {
2379             // IllegalArgumentException is expected.
2380         }
2381     }
2382 
2383     @SmallTest
testGetAccountByTypeAndFeaturesWithNullAccountType()2384     public void testGetAccountByTypeAndFeaturesWithNullAccountType() throws Exception {
2385         unlockSystemUser();
2386         try {
2387             mAms.getAccountByTypeAndFeatures(
2388                 mMockAccountManagerResponse, // response
2389                 null, // accountType
2390                 AccountManagerServiceTestFixtures.ACCOUNT_FEATURES,
2391                 "testpackage"); // opPackageName
2392             fail("IllegalArgumentException expected. But no exception was thrown.");
2393         } catch (IllegalArgumentException e) {
2394             // IllegalArgumentException is expected.
2395         }
2396     }
2397 
2398     @SmallTest
testGetAccountByTypeAndFeaturesWithNoFeaturesAndNoAccount()2399     public void testGetAccountByTypeAndFeaturesWithNoFeaturesAndNoAccount() throws Exception {
2400         unlockSystemUser();
2401         mAms.getAccountByTypeAndFeatures(
2402             mMockAccountManagerResponse,
2403             AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2404             null,
2405             "testpackage");
2406         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
2407         Bundle result = mBundleCaptor.getValue();
2408         String accountName = result.getString(AccountManager.KEY_ACCOUNT_NAME);
2409         String accountType = result.getString(AccountManager.KEY_ACCOUNT_TYPE);
2410         assertEquals(null, accountName);
2411         assertEquals(null, accountType);
2412     }
2413 
2414     @SmallTest
testGetAccountByTypeAndFeaturesWithNoFeaturesAndOneVisibleAccount()2415     public void testGetAccountByTypeAndFeaturesWithNoFeaturesAndOneVisibleAccount()
2416         throws Exception {
2417         unlockSystemUser();
2418         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null);
2419         mAms.getAccountByTypeAndFeatures(
2420             mMockAccountManagerResponse,
2421             AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2422             null,
2423             "testpackage");
2424         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
2425         Bundle result = mBundleCaptor.getValue();
2426         String accountName = result.getString(AccountManager.KEY_ACCOUNT_NAME);
2427         String accountType = result.getString(AccountManager.KEY_ACCOUNT_TYPE);
2428         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS, accountName);
2429         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, accountType);
2430     }
2431 
2432     @SmallTest
testGetAccountByTypeAndFeaturesWithNoFeaturesAndOneNotVisibleAccount()2433     public void testGetAccountByTypeAndFeaturesWithNoFeaturesAndOneNotVisibleAccount()
2434         throws Exception {
2435         unlockSystemUser();
2436         HashMap<String, Integer> visibility = new HashMap<>();
2437         visibility.put(AccountManagerServiceTestFixtures.CALLER_PACKAGE,
2438             AccountManager.VISIBILITY_USER_MANAGED_NOT_VISIBLE);
2439         mAms.addAccountExplicitlyWithVisibility(
2440             AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null, visibility);
2441         mAms.getAccountByTypeAndFeatures(
2442             mMockAccountManagerResponse,
2443             AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2444             null,
2445             AccountManagerServiceTestFixtures.CALLER_PACKAGE);
2446         verify(mMockContext).startActivityAsUser(mIntentCaptor.capture(), eq(UserHandle.SYSTEM));
2447         Intent intent = mIntentCaptor.getValue();
2448         Account[] accounts = (Account[]) intent.getExtra(AccountManager.KEY_ACCOUNTS);
2449         assertEquals(1, accounts.length);
2450         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, accounts[0]);
2451     }
2452 
2453     @SmallTest
testGetAccountByTypeAndFeaturesWithNoFeaturesAndTwoAccounts()2454     public void testGetAccountByTypeAndFeaturesWithNoFeaturesAndTwoAccounts() throws Exception {
2455         unlockSystemUser();
2456         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null);
2457         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE, "p12", null);
2458 
2459         mAms.getAccountByTypeAndFeatures(
2460             mMockAccountManagerResponse,
2461             AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2462             null,
2463             "testpackage");
2464         verify(mMockContext).startActivityAsUser(mIntentCaptor.capture(), eq(UserHandle.SYSTEM));
2465         Intent intent = mIntentCaptor.getValue();
2466         Account[] accounts = (Account[]) intent.getExtra(AccountManager.KEY_ACCOUNTS);
2467         assertEquals(2, accounts.length);
2468         if (accounts[0].equals(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS)) {
2469             assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, accounts[0]);
2470             assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE, accounts[1]);
2471         } else {
2472             assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE, accounts[0]);
2473             assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, accounts[1]);
2474         }
2475     }
2476 
2477     @SmallTest
testGetAccountByTypeAndFeaturesWithFeaturesAndNoAccount()2478     public void testGetAccountByTypeAndFeaturesWithFeaturesAndNoAccount() throws Exception {
2479         unlockSystemUser();
2480         final CountDownLatch latch = new CountDownLatch(1);
2481         mAms.getAccountByTypeAndFeatures(
2482             mMockAccountManagerResponse,
2483             AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2484             AccountManagerServiceTestFixtures.ACCOUNT_FEATURES,
2485             "testpackage");
2486         waitForLatch(latch);
2487         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
2488         Bundle result = mBundleCaptor.getValue();
2489         String accountName = result.getString(AccountManager.KEY_ACCOUNT_NAME);
2490         String accountType = result.getString(AccountManager.KEY_ACCOUNT_TYPE);
2491         assertEquals(null, accountName);
2492         assertEquals(null, accountType);
2493     }
2494 
2495     @SmallTest
testGetAccountByTypeAndFeaturesWithFeaturesAndNoQualifiedAccount()2496     public void testGetAccountByTypeAndFeaturesWithFeaturesAndNoQualifiedAccount()
2497         throws Exception {
2498         unlockSystemUser();
2499         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE, "p12", null);
2500         final CountDownLatch latch = new CountDownLatch(1);
2501         mAms.getAccountByTypeAndFeatures(
2502             mMockAccountManagerResponse,
2503             AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2504             AccountManagerServiceTestFixtures.ACCOUNT_FEATURES,
2505             "testpackage");
2506         waitForLatch(latch);
2507         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
2508         Bundle result = mBundleCaptor.getValue();
2509         String accountName = result.getString(AccountManager.KEY_ACCOUNT_NAME);
2510         String accountType = result.getString(AccountManager.KEY_ACCOUNT_TYPE);
2511         assertEquals(null, accountName);
2512         assertEquals(null, accountType);
2513     }
2514 
2515     @SmallTest
testGetAccountByTypeAndFeaturesWithFeaturesAndOneQualifiedAccount()2516     public void testGetAccountByTypeAndFeaturesWithFeaturesAndOneQualifiedAccount()
2517         throws Exception {
2518         unlockSystemUser();
2519         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null);
2520         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE, "p12", null);
2521         final CountDownLatch latch = new CountDownLatch(1);
2522         mAms.getAccountByTypeAndFeatures(
2523             mMockAccountManagerResponse,
2524             AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2525             AccountManagerServiceTestFixtures.ACCOUNT_FEATURES,
2526             "testpackage");
2527         waitForLatch(latch);
2528         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
2529         Bundle result = mBundleCaptor.getValue();
2530         String accountName = result.getString(AccountManager.KEY_ACCOUNT_NAME);
2531         String accountType = result.getString(AccountManager.KEY_ACCOUNT_TYPE);
2532         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_NAME_SUCCESS, accountName);
2533         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, accountType);
2534     }
2535 
2536     @SmallTest
testGetAccountByTypeAndFeaturesWithFeaturesAndOneQualifiedNotVisibleAccount()2537     public void testGetAccountByTypeAndFeaturesWithFeaturesAndOneQualifiedNotVisibleAccount()
2538         throws Exception {
2539         unlockSystemUser();
2540         HashMap<String, Integer> visibility = new HashMap<>();
2541         visibility.put(AccountManagerServiceTestFixtures.CALLER_PACKAGE,
2542             AccountManager.VISIBILITY_USER_MANAGED_NOT_VISIBLE);
2543         mAms.addAccountExplicitlyWithVisibility(
2544             AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null, visibility);
2545         final CountDownLatch latch = new CountDownLatch(1);
2546         mAms.getAccountByTypeAndFeatures(
2547             mMockAccountManagerResponse,
2548             AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2549             AccountManagerServiceTestFixtures.ACCOUNT_FEATURES,
2550             AccountManagerServiceTestFixtures.CALLER_PACKAGE);
2551         waitForLatch(latch);
2552         verify(mMockContext).startActivityAsUser(mIntentCaptor.capture(), eq(UserHandle.SYSTEM));
2553         Intent intent = mIntentCaptor.getValue();
2554         Account[] accounts = (Account[]) intent.getExtra(AccountManager.KEY_ACCOUNTS);
2555         assertEquals(1, accounts.length);
2556         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, accounts[0]);
2557     }
2558 
2559     @SmallTest
testGetAccountByTypeAndFeaturesWithFeaturesAndTwoQualifiedAccount()2560     public void testGetAccountByTypeAndFeaturesWithFeaturesAndTwoQualifiedAccount()
2561         throws Exception {
2562         unlockSystemUser();
2563         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null);
2564         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS_2, "p12", null);
2565         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE, "p13", null);
2566         final CountDownLatch latch = new CountDownLatch(1);
2567         mAms.getAccountByTypeAndFeatures(
2568             mMockAccountManagerResponse,
2569             AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2570             AccountManagerServiceTestFixtures.ACCOUNT_FEATURES,
2571             "testpackage");
2572         waitForLatch(latch);
2573         verify(mMockContext).startActivityAsUser(mIntentCaptor.capture(), eq(UserHandle.SYSTEM));
2574         Intent intent = mIntentCaptor.getValue();
2575         Account[] accounts = (Account[]) intent.getExtra(AccountManager.KEY_ACCOUNTS);
2576         assertEquals(2, accounts.length);
2577         if (accounts[0].equals(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS)) {
2578             assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, accounts[0]);
2579             assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS_2, accounts[1]);
2580         } else {
2581             assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS_2, accounts[0]);
2582             assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, accounts[1]);
2583         }
2584     }
2585 
2586     @SmallTest
testGetAccountsByFeaturesWithNullResponse()2587     public void testGetAccountsByFeaturesWithNullResponse() throws Exception {
2588         unlockSystemUser();
2589         try {
2590             mAms.getAccountsByFeatures(
2591                 null, // response
2592                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1,
2593                 AccountManagerServiceTestFixtures.ACCOUNT_FEATURES,
2594                 "testpackage"); // opPackageName
2595             fail("IllegalArgumentException expected. But no exception was thrown.");
2596         } catch (IllegalArgumentException e) {
2597             // IllegalArgumentException is expected.
2598         }
2599     }
2600 
2601     @SmallTest
testGetAccountsByFeaturesWithNullAccountType()2602     public void testGetAccountsByFeaturesWithNullAccountType() throws Exception {
2603         unlockSystemUser();
2604         try {
2605             mAms.getAccountsByFeatures(
2606                 mMockAccountManagerResponse, // response
2607                 null, // accountType
2608                 AccountManagerServiceTestFixtures.ACCOUNT_FEATURES,
2609                 "testpackage"); // opPackageName
2610             fail("IllegalArgumentException expected. But no exception was thrown.");
2611         } catch (IllegalArgumentException e) {
2612             // IllegalArgumentException is expected.
2613         }
2614     }
2615 
2616     @SmallTest
testGetAccountsByFeaturesAccountNotVisible()2617     public void testGetAccountsByFeaturesAccountNotVisible() throws Exception {
2618         unlockSystemUser();
2619 
2620         when(mMockContext.checkCallingOrSelfPermission(anyString())).thenReturn(
2621                 PackageManager.PERMISSION_DENIED);
2622         when(mMockPackageManager.checkSignatures(anyInt(), anyInt()))
2623                     .thenReturn(PackageManager.SIGNATURE_NO_MATCH);
2624 
2625         final CountDownLatch latch = new CountDownLatch(1);
2626         Response response = new Response(latch, mMockAccountManagerResponse);
2627         mAms.getAccountsByFeatures(
2628                 response, // response
2629                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
2630                 AccountManagerServiceTestFixtures.ACCOUNT_FEATURES,
2631                 "testpackage"); // opPackageName
2632         waitForLatch(latch);
2633 
2634         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
2635         Bundle result = mBundleCaptor.getValue();
2636         Account[] accounts = (Account[]) result.getParcelableArray(AccountManager.KEY_ACCOUNTS);
2637         assertTrue(accounts.length == 0);
2638     }
2639 
2640     @SmallTest
testGetAccountsByFeaturesNullFeatureReturnsAllAccounts()2641     public void testGetAccountsByFeaturesNullFeatureReturnsAllAccounts() throws Exception {
2642         unlockSystemUser();
2643 
2644         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null);
2645         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE, "p12", null);
2646 
2647         final CountDownLatch latch = new CountDownLatch(1);
2648         Response response = new Response(latch, mMockAccountManagerResponse);
2649         mAms.getAccountsByFeatures(
2650                 response, // response
2651                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
2652                 null, // features
2653                 "testpackage"); // opPackageName
2654         waitForLatch(latch);
2655 
2656         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
2657         Bundle result = mBundleCaptor.getValue();
2658         Account[] accounts = (Account[]) result.getParcelableArray(AccountManager.KEY_ACCOUNTS);
2659         Arrays.sort(accounts, new AccountSorter());
2660         assertEquals(2, accounts.length);
2661         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE, accounts[0]);
2662         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, accounts[1]);
2663     }
2664 
2665     @SmallTest
testGetAccountsByFeaturesReturnsAccountsWithFeaturesOnly()2666     public void testGetAccountsByFeaturesReturnsAccountsWithFeaturesOnly() throws Exception {
2667         unlockSystemUser();
2668 
2669         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null);
2670         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE, "p12", null);
2671 
2672         final CountDownLatch latch = new CountDownLatch(1);
2673         Response response = new Response(latch, mMockAccountManagerResponse);
2674         mAms.getAccountsByFeatures(
2675                 response, // response
2676                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
2677                 AccountManagerServiceTestFixtures.ACCOUNT_FEATURES,
2678                 "testpackage"); // opPackageName
2679         waitForLatch(latch);
2680 
2681         verify(mMockAccountManagerResponse).onResult(mBundleCaptor.capture());
2682         Bundle result = mBundleCaptor.getValue();
2683         Account[] accounts = (Account[]) result.getParcelableArray(AccountManager.KEY_ACCOUNTS);
2684         assertEquals(1, accounts.length);
2685         assertEquals(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, accounts[0]);
2686     }
2687 
2688     @SmallTest
testGetAccountsByFeaturesError()2689     public void testGetAccountsByFeaturesError() throws Exception {
2690         unlockSystemUser();
2691         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null);
2692         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_ERROR, "p12", null);
2693 
2694         final CountDownLatch latch = new CountDownLatch(1);
2695         Response response = new Response(latch, mMockAccountManagerResponse);
2696         mAms.getAccountsByFeatures(
2697                 response, // response
2698                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1, // accountType
2699                 AccountManagerServiceTestFixtures.ACCOUNT_FEATURES,
2700                 "testpackage"); // opPackageName
2701         waitForLatch(latch);
2702 
2703         verify(mMockAccountManagerResponse).onError(
2704                 eq(AccountManager.ERROR_CODE_INVALID_RESPONSE), anyString());
2705         verify(mMockAccountManagerResponse, never()).onResult(any(Bundle.class));
2706     }
2707 
2708     @SmallTest
testRegisterAccountListener()2709     public void testRegisterAccountListener() throws Exception {
2710         unlockSystemUser();
2711         mAms.registerAccountListener(
2712             new String [] {AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1},
2713             "testpackage"); // opPackageName
2714 
2715         mAms.registerAccountListener(
2716             null, //accountTypes
2717             "testpackage"); // opPackageName
2718 
2719         // Check that two previously registered receivers can be unregistered successfully.
2720         mAms.unregisterAccountListener(
2721             new String [] {AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1},
2722             "testpackage"); // opPackageName
2723 
2724         mAms.unregisterAccountListener(
2725              null, //accountTypes
2726             "testpackage"); // opPackageName
2727     }
2728 
2729     @SmallTest
testRegisterAccountListenerAndAddAccount()2730     public void testRegisterAccountListenerAndAddAccount() throws Exception {
2731         unlockSystemUser();
2732         mAms.registerAccountListener(
2733             new String [] {AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1},
2734             "testpackage"); // opPackageName
2735 
2736         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null);
2737         // Notification about new account
2738         updateBroadcastCounters(2);
2739         assertEquals(mVisibleAccountsChangedBroadcasts, 1);
2740         assertEquals(mLoginAccountsChangedBroadcasts, 1);
2741     }
2742 
2743     @SmallTest
testRegisterAccountListenerAndAddAccountOfDifferentType()2744     public void testRegisterAccountListenerAndAddAccountOfDifferentType() throws Exception {
2745         unlockSystemUser();
2746         mAms.registerAccountListener(
2747             new String [] {AccountManagerServiceTestFixtures.ACCOUNT_TYPE_2},
2748             "testpackage"); // opPackageName
2749 
2750         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null);
2751         mAms.addAccountExplicitly(
2752             AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE, "p11", null);
2753         // Notification about new account
2754 
2755         updateBroadcastCounters(2);
2756         assertEquals(mVisibleAccountsChangedBroadcasts, 0); // broadcast was not sent
2757         assertEquals(mLoginAccountsChangedBroadcasts, 2);
2758     }
2759 
2760     @SmallTest
testRegisterAccountListenerWithAddingTwoAccounts()2761     public void testRegisterAccountListenerWithAddingTwoAccounts() throws Exception {
2762         unlockSystemUser();
2763 
2764         HashMap<String, Integer> visibility = new HashMap<>();
2765         visibility.put(AccountManagerServiceTestFixtures.CALLER_PACKAGE,
2766             AccountManager.VISIBILITY_USER_MANAGED_VISIBLE);
2767 
2768         mAms.registerAccountListener(
2769             new String [] {AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1},
2770             AccountManagerServiceTestFixtures.CALLER_PACKAGE);
2771         mAms.addAccountExplicitlyWithVisibility(
2772             AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null, visibility);
2773         mAms.unregisterAccountListener(
2774             new String [] {AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1},
2775             AccountManagerServiceTestFixtures.CALLER_PACKAGE);
2776 
2777         addAccountRemovedReceiver(AccountManagerServiceTestFixtures.CALLER_PACKAGE);
2778         mAms.addAccountExplicitlyWithVisibility(
2779             AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE, "p11", null, visibility);
2780 
2781         updateBroadcastCounters(3);
2782         assertEquals(mVisibleAccountsChangedBroadcasts, 1);
2783         assertEquals(mLoginAccountsChangedBroadcasts, 2);
2784         assertEquals(mAccountRemovedBroadcasts, 0);
2785 
2786         mAms.removeAccountInternal(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS);
2787         mAms.registerAccountListener( null /* accountTypes */,
2788             AccountManagerServiceTestFixtures.CALLER_PACKAGE);
2789         mAms.removeAccountInternal(AccountManagerServiceTestFixtures.ACCOUNT_INTERVENE);
2790 
2791         updateBroadcastCounters(8);
2792         assertEquals(mVisibleAccountsChangedBroadcasts, 2);
2793         assertEquals(mLoginAccountsChangedBroadcasts, 4);
2794         assertEquals(mAccountRemovedBroadcasts, 2);
2795     }
2796 
2797     @SmallTest
testRegisterAccountListenerForThreePackages()2798     public void testRegisterAccountListenerForThreePackages() throws Exception {
2799         unlockSystemUser();
2800 
2801         addAccountRemovedReceiver("testpackage1");
2802         HashMap<String, Integer> visibility = new HashMap<>();
2803         visibility.put("testpackage1", AccountManager.VISIBILITY_USER_MANAGED_VISIBLE);
2804         visibility.put("testpackage2", AccountManager.VISIBILITY_USER_MANAGED_VISIBLE);
2805         visibility.put("testpackage3", AccountManager.VISIBILITY_USER_MANAGED_VISIBLE);
2806 
2807         mAms.registerAccountListener(
2808             new String [] {AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1},
2809             "testpackage1"); // opPackageName
2810         mAms.registerAccountListener(
2811             new String [] {AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1},
2812             "testpackage2"); // opPackageName
2813         mAms.registerAccountListener(
2814             new String [] {AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1},
2815             "testpackage3"); // opPackageName
2816         mAms.addAccountExplicitlyWithVisibility(
2817             AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null, visibility);
2818         updateBroadcastCounters(4);
2819         assertEquals(mVisibleAccountsChangedBroadcasts, 3);
2820         assertEquals(mLoginAccountsChangedBroadcasts, 1);
2821 
2822         mAms.unregisterAccountListener(
2823             new String [] {AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1},
2824             "testpackage3"); // opPackageName
2825         // Remove account with 2 active listeners.
2826         mAms.removeAccountInternal(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS);
2827         updateBroadcastCounters(8);
2828         assertEquals(mVisibleAccountsChangedBroadcasts, 5);
2829         assertEquals(mLoginAccountsChangedBroadcasts, 2); // 3 add, 2 remove
2830         assertEquals(mAccountRemovedBroadcasts, 1);
2831 
2832         // Add account of another type.
2833         mAms.addAccountExplicitly(
2834             AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS_TYPE_2, "p11", null);
2835 
2836         updateBroadcastCounters(8);
2837         assertEquals(mVisibleAccountsChangedBroadcasts, 5);
2838         assertEquals(mLoginAccountsChangedBroadcasts, 3);
2839         assertEquals(mAccountRemovedBroadcasts, 1);
2840     }
2841 
2842     @SmallTest
testRegisterAccountListenerForAddingAccountWithVisibility()2843     public void testRegisterAccountListenerForAddingAccountWithVisibility() throws Exception {
2844         unlockSystemUser();
2845 
2846         HashMap<String, Integer> visibility = new HashMap<>();
2847         visibility.put("testpackage1", AccountManager.VISIBILITY_NOT_VISIBLE);
2848         visibility.put("testpackage2", AccountManager.VISIBILITY_USER_MANAGED_NOT_VISIBLE);
2849         visibility.put("testpackage3", AccountManager.VISIBILITY_USER_MANAGED_VISIBLE);
2850 
2851         addAccountRemovedReceiver("testpackage1");
2852         mAms.registerAccountListener(
2853             new String [] {AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1},
2854             "testpackage1"); // opPackageName
2855         mAms.registerAccountListener(
2856             new String [] {AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1},
2857             "testpackage2"); // opPackageName
2858         mAms.registerAccountListener(
2859             new String [] {AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1},
2860             "testpackage3"); // opPackageName
2861         mAms.addAccountExplicitlyWithVisibility(
2862             AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null, visibility);
2863 
2864         updateBroadcastCounters(2);
2865         assertEquals(mVisibleAccountsChangedBroadcasts, 1);
2866         assertEquals(mLoginAccountsChangedBroadcasts, 1);
2867 
2868         mAms.removeAccountInternal(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS);
2869 
2870         updateBroadcastCounters(4);
2871         assertEquals(mVisibleAccountsChangedBroadcasts, 2);
2872         assertEquals(mLoginAccountsChangedBroadcasts, 2);
2873         assertEquals(mAccountRemovedBroadcasts, 0); // account was never visible.
2874     }
2875 
2876     @SmallTest
testRegisterAccountListenerCredentialsUpdate()2877     public void testRegisterAccountListenerCredentialsUpdate() throws Exception {
2878         unlockSystemUser();
2879         mAms.registerAccountListener(
2880             new String [] {AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1},
2881             "testpackage"); // opPackageName
2882         mAms.addAccountExplicitly(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "p11", null);
2883         mAms.setPassword(AccountManagerServiceTestFixtures.ACCOUNT_SUCCESS, "pwd");
2884         updateBroadcastCounters(4);
2885         assertEquals(mVisibleAccountsChangedBroadcasts, 2);
2886         assertEquals(mLoginAccountsChangedBroadcasts, 2);
2887     }
2888 
2889     @SmallTest
testUnregisterAccountListenerNotRegistered()2890     public void testUnregisterAccountListenerNotRegistered() throws Exception {
2891         unlockSystemUser();
2892         try {
2893             mAms.unregisterAccountListener(
2894                 new String [] {AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1},
2895                 "testpackage"); // opPackageName
2896             fail("IllegalArgumentException expected. But no exception was thrown.");
2897         } catch (IllegalArgumentException e) {
2898             // IllegalArgumentException is expected.
2899         }
2900     }
2901 
updateBroadcastCounters(int expectedBroadcasts)2902     private void updateBroadcastCounters (int expectedBroadcasts){
2903         mVisibleAccountsChangedBroadcasts = 0;
2904         mLoginAccountsChangedBroadcasts = 0;
2905         mAccountRemovedBroadcasts = 0;
2906         ArgumentCaptor<Intent> captor = ArgumentCaptor.forClass(Intent.class);
2907         verify(mMockContext, atLeast(expectedBroadcasts)).sendBroadcastAsUser(captor.capture(),
2908             any(UserHandle.class));
2909         for (Intent intent : captor.getAllValues()) {
2910             if (AccountManager.ACTION_VISIBLE_ACCOUNTS_CHANGED.equals(intent.getAction())) {
2911                 mVisibleAccountsChangedBroadcasts++;
2912             } else if (AccountManager.LOGIN_ACCOUNTS_CHANGED_ACTION.equals(intent.getAction())) {
2913                 mLoginAccountsChangedBroadcasts++;
2914             } else if (AccountManager.ACTION_ACCOUNT_REMOVED.equals(intent.getAction())) {
2915                 mAccountRemovedBroadcasts++;
2916             }
2917         }
2918     }
2919 
addAccountRemovedReceiver(String packageName)2920     private void addAccountRemovedReceiver(String packageName) {
2921         ResolveInfo resolveInfo = new ResolveInfo();
2922         resolveInfo.activityInfo = new ActivityInfo();
2923         resolveInfo.activityInfo.applicationInfo =  new ApplicationInfo();
2924         resolveInfo.activityInfo.applicationInfo.packageName = packageName;
2925 
2926         List<ResolveInfo> accountRemovedReceivers = new ArrayList<>();
2927         accountRemovedReceivers.add(resolveInfo);
2928         when(mMockPackageManager.queryBroadcastReceiversAsUser(any(Intent.class), anyInt(),
2929             anyInt())).thenReturn(accountRemovedReceivers);
2930     }
2931 
2932     @SmallTest
testConcurrencyReadWrite()2933     public void testConcurrencyReadWrite() throws Exception {
2934         // Test 2 threads calling getAccounts and 1 thread setAuthToken
2935         unlockSystemUser();
2936         String[] list = new String[]{AccountManagerServiceTestFixtures.CALLER_PACKAGE};
2937         when(mMockPackageManager.getPackagesForUid(anyInt())).thenReturn(list);
2938 
2939         Account a1 = new Account("account1",
2940                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1);
2941         mAms.addAccountExplicitly(a1, "p1", null);
2942         List<String> errors = Collections.synchronizedList(new ArrayList<>());
2943         int readerCount = 2;
2944         ExecutorService es = Executors.newFixedThreadPool(readerCount + 1);
2945         AtomicLong readTotalTime = new AtomicLong(0);
2946         AtomicLong writeTotalTime = new AtomicLong(0);
2947         final CyclicBarrier cyclicBarrier = new CyclicBarrier(readerCount + 1);
2948 
2949         final int loopSize = 20;
2950         for (int t = 0; t < readerCount; t++) {
2951             es.submit(() -> {
2952                 for (int i = 0; i < loopSize; i++) {
2953                     String logPrefix = Thread.currentThread().getName() + " " + i;
2954                     waitForCyclicBarrier(cyclicBarrier);
2955                     cyclicBarrier.reset();
2956                     SystemClock.sleep(1); // Ensure that writer wins
2957                     Log.d(TAG, logPrefix + " getAccounts started");
2958                     long ti = System.currentTimeMillis();
2959                     try {
2960                         Account[] accounts = mAms.getAccounts(null, mContext.getOpPackageName());
2961                         if (accounts == null || accounts.length != 1
2962                                 || !AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1.equals(
2963                                 accounts[0].type)) {
2964                             String msg = logPrefix + ": Unexpected accounts: " + Arrays
2965                                     .toString(accounts);
2966                             Log.e(TAG, "    " + msg);
2967                             errors.add(msg);
2968                         }
2969                         Log.d(TAG, logPrefix + " getAccounts done");
2970                     } catch (Exception e) {
2971                         String msg = logPrefix + ": getAccounts failed " + e;
2972                         Log.e(TAG, msg, e);
2973                         errors.add(msg);
2974                     }
2975                     ti = System.currentTimeMillis() - ti;
2976                     readTotalTime.addAndGet(ti);
2977                 }
2978             });
2979         }
2980 
2981         es.submit(() -> {
2982             for (int i = 0; i < loopSize; i++) {
2983                 String logPrefix = Thread.currentThread().getName() + " " + i;
2984                 waitForCyclicBarrier(cyclicBarrier);
2985                 long ti = System.currentTimeMillis();
2986                 Log.d(TAG, logPrefix + " setAuthToken started");
2987                 try {
2988                     mAms.setAuthToken(a1, "t1", "v" + i);
2989                     Log.d(TAG, logPrefix + " setAuthToken done");
2990                 } catch (Exception e) {
2991                     errors.add(logPrefix + ": setAuthToken failed: " + e);
2992                 }
2993                 ti = System.currentTimeMillis() - ti;
2994                 writeTotalTime.addAndGet(ti);
2995             }
2996         });
2997         es.shutdown();
2998         assertTrue("Time-out waiting for jobs to finish",
2999                 es.awaitTermination(10, TimeUnit.SECONDS));
3000         es.shutdownNow();
3001         assertTrue("Errors: " + errors, errors.isEmpty());
3002         Log.i(TAG, "testConcurrencyReadWrite: readTotalTime=" + readTotalTime + " avg="
3003                 + (readTotalTime.doubleValue() / readerCount / loopSize));
3004         Log.i(TAG, "testConcurrencyReadWrite: writeTotalTime=" + writeTotalTime + " avg="
3005                 + (writeTotalTime.doubleValue() / loopSize));
3006     }
3007 
3008     @SmallTest
testConcurrencyRead()3009     public void testConcurrencyRead() throws Exception {
3010         // Test 2 threads calling getAccounts
3011         unlockSystemUser();
3012         String[] list = new String[]{AccountManagerServiceTestFixtures.CALLER_PACKAGE};
3013         when(mMockPackageManager.getPackagesForUid(anyInt())).thenReturn(list);
3014 
3015         Account a1 = new Account("account1",
3016                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1);
3017         mAms.addAccountExplicitly(a1, "p1", null);
3018         List<String> errors = Collections.synchronizedList(new ArrayList<>());
3019         int readerCount = 2;
3020         ExecutorService es = Executors.newFixedThreadPool(readerCount + 1);
3021         AtomicLong readTotalTime = new AtomicLong(0);
3022 
3023         final int loopSize = 20;
3024         for (int t = 0; t < readerCount; t++) {
3025             es.submit(() -> {
3026                 for (int i = 0; i < loopSize; i++) {
3027                     String logPrefix = Thread.currentThread().getName() + " " + i;
3028                     Log.d(TAG, logPrefix + " getAccounts started");
3029                     long ti = System.currentTimeMillis();
3030                     try {
3031                         Account[] accounts = mAms.getAccounts(null, mContext.getOpPackageName());
3032                         if (accounts == null || accounts.length != 1
3033                                 || !AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1.equals(
3034                                 accounts[0].type)) {
3035                             String msg = logPrefix + ": Unexpected accounts: " + Arrays
3036                                     .toString(accounts);
3037                             Log.e(TAG, "    " + msg);
3038                             errors.add(msg);
3039                         }
3040                         Log.d(TAG, logPrefix + " getAccounts done");
3041                     } catch (Exception e) {
3042                         String msg = logPrefix + ": getAccounts failed " + e;
3043                         Log.e(TAG, msg, e);
3044                         errors.add(msg);
3045                     }
3046                     ti = System.currentTimeMillis() - ti;
3047                     readTotalTime.addAndGet(ti);
3048                 }
3049             });
3050         }
3051         es.shutdown();
3052         assertTrue("Time-out waiting for jobs to finish",
3053                 es.awaitTermination(10, TimeUnit.SECONDS));
3054         es.shutdownNow();
3055         assertTrue("Errors: " + errors, errors.isEmpty());
3056         Log.i(TAG, "testConcurrencyRead: readTotalTime=" + readTotalTime + " avg="
3057                 + (readTotalTime.doubleValue() / readerCount / loopSize));
3058     }
3059 
waitForCyclicBarrier(CyclicBarrier cyclicBarrier)3060     private void waitForCyclicBarrier(CyclicBarrier cyclicBarrier) {
3061         try {
3062             cyclicBarrier.await(LATCH_TIMEOUT_MS, TimeUnit.MILLISECONDS);
3063         } catch (Exception e) {
3064             throw new IllegalStateException("Should not throw " + e, e);
3065         }
3066     }
3067 
waitForLatch(CountDownLatch latch)3068     private void waitForLatch(CountDownLatch latch) {
3069         try {
3070             latch.await(LATCH_TIMEOUT_MS, TimeUnit.MILLISECONDS);
3071         } catch (InterruptedException e) {
3072             throw new IllegalStateException("Should not throw an InterruptedException", e);
3073         }
3074     }
3075 
createAddAccountOptions(String accountName)3076     private Bundle createAddAccountOptions(String accountName) {
3077         Bundle options = new Bundle();
3078         options.putString(AccountManagerServiceTestFixtures.KEY_ACCOUNT_NAME, accountName);
3079         return options;
3080     }
3081 
createGetAuthTokenOptions()3082     private Bundle createGetAuthTokenOptions() {
3083         Bundle options = new Bundle();
3084         options.putString(AccountManager.KEY_ANDROID_PACKAGE_NAME,
3085                 AccountManagerServiceTestFixtures.CALLER_PACKAGE);
3086         options.putLong(AccountManagerServiceTestFixtures.KEY_TOKEN_EXPIRY,
3087                 System.currentTimeMillis() + ONE_DAY_IN_MILLISECOND);
3088         return options;
3089     }
3090 
encryptBundleWithCryptoHelper(Bundle sessionBundle)3091     private Bundle encryptBundleWithCryptoHelper(Bundle sessionBundle) {
3092         Bundle encryptedBundle = null;
3093         try {
3094             CryptoHelper cryptoHelper = CryptoHelper.getInstance();
3095             encryptedBundle = cryptoHelper.encryptBundle(sessionBundle);
3096         } catch (GeneralSecurityException e) {
3097             throw new IllegalStateException("Failed to encrypt session bundle.", e);
3098         }
3099         return encryptedBundle;
3100     }
3101 
createEncryptedSessionBundle(final String accountName)3102     private Bundle createEncryptedSessionBundle(final String accountName) {
3103         Bundle sessionBundle = new Bundle();
3104         sessionBundle.putString(AccountManagerServiceTestFixtures.KEY_ACCOUNT_NAME, accountName);
3105         sessionBundle.putString(
3106                 AccountManagerServiceTestFixtures.SESSION_DATA_NAME_1,
3107                 AccountManagerServiceTestFixtures.SESSION_DATA_VALUE_1);
3108         sessionBundle.putString(AccountManager.KEY_ACCOUNT_TYPE,
3109                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1);
3110         sessionBundle.putString(AccountManager.KEY_ANDROID_PACKAGE_NAME, "APCT.session.package");
3111         return encryptBundleWithCryptoHelper(sessionBundle);
3112     }
3113 
createEncryptedSessionBundleWithError(final String accountName)3114     private Bundle createEncryptedSessionBundleWithError(final String accountName) {
3115         Bundle sessionBundle = new Bundle();
3116         sessionBundle.putString(AccountManagerServiceTestFixtures.KEY_ACCOUNT_NAME, accountName);
3117         sessionBundle.putString(
3118                 AccountManagerServiceTestFixtures.SESSION_DATA_NAME_1,
3119                 AccountManagerServiceTestFixtures.SESSION_DATA_VALUE_1);
3120         sessionBundle.putString(AccountManager.KEY_ACCOUNT_TYPE,
3121                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1);
3122         sessionBundle.putString(AccountManager.KEY_ANDROID_PACKAGE_NAME, "APCT.session.package");
3123         sessionBundle.putInt(
3124                 AccountManager.KEY_ERROR_CODE, AccountManager.ERROR_CODE_INVALID_RESPONSE);
3125         sessionBundle.putString(AccountManager.KEY_ERROR_MESSAGE,
3126                 AccountManagerServiceTestFixtures.ERROR_MESSAGE);
3127         return encryptBundleWithCryptoHelper(sessionBundle);
3128     }
3129 
createEncryptedSessionBundleWithNoAccountType(final String accountName)3130     private Bundle createEncryptedSessionBundleWithNoAccountType(final String accountName) {
3131         Bundle sessionBundle = new Bundle();
3132         sessionBundle.putString(AccountManagerServiceTestFixtures.KEY_ACCOUNT_NAME, accountName);
3133         sessionBundle.putString(
3134                 AccountManagerServiceTestFixtures.SESSION_DATA_NAME_1,
3135                 AccountManagerServiceTestFixtures.SESSION_DATA_VALUE_1);
3136         sessionBundle.putString(AccountManager.KEY_ANDROID_PACKAGE_NAME, "APCT.session.package");
3137         return encryptBundleWithCryptoHelper(sessionBundle);
3138     }
3139 
createAppBundle()3140     private Bundle createAppBundle() {
3141         Bundle appBundle = new Bundle();
3142         appBundle.putString(AccountManager.KEY_ANDROID_PACKAGE_NAME, "APCT.package");
3143         return appBundle;
3144     }
3145 
createOptionsWithAccountName(final String accountName)3146     private Bundle createOptionsWithAccountName(final String accountName) {
3147         Bundle sessionBundle = new Bundle();
3148         sessionBundle.putString(
3149                 AccountManagerServiceTestFixtures.SESSION_DATA_NAME_1,
3150                 AccountManagerServiceTestFixtures.SESSION_DATA_VALUE_1);
3151         sessionBundle.putString(AccountManager.KEY_ACCOUNT_TYPE,
3152                 AccountManagerServiceTestFixtures.ACCOUNT_TYPE_1);
3153         Bundle options = new Bundle();
3154         options.putString(AccountManagerServiceTestFixtures.KEY_ACCOUNT_NAME, accountName);
3155         options.putBundle(AccountManagerServiceTestFixtures.KEY_ACCOUNT_SESSION_BUNDLE,
3156                 sessionBundle);
3157         options.putString(AccountManagerServiceTestFixtures.KEY_ACCOUNT_PASSWORD,
3158                 AccountManagerServiceTestFixtures.ACCOUNT_PASSWORD);
3159         return options;
3160     }
3161 
readNumberOfAccountsFromDbFile(Context context, String dbName)3162     private int readNumberOfAccountsFromDbFile(Context context, String dbName) {
3163         SQLiteDatabase ceDb = context.openOrCreateDatabase(dbName, 0, null);
3164         try (Cursor cursor = ceDb.rawQuery("SELECT count(*) FROM accounts", null)) {
3165             assertTrue(cursor.moveToNext());
3166             return cursor.getInt(0);
3167         }
3168     }
3169 
unlockSystemUser()3170     private void unlockSystemUser() {
3171         mAms.onUserUnlocked(newIntentForUser(UserHandle.USER_SYSTEM));
3172     }
3173 
newIntentForUser(int userId)3174     private static Intent newIntentForUser(int userId) {
3175         Intent intent = new Intent();
3176         intent.putExtra(Intent.EXTRA_USER_HANDLE, userId);
3177         return intent;
3178     }
3179 
3180     static class MyMockContext extends MockContext {
3181         private Context mTestContext;
3182         private Context mMockContext;
3183 
MyMockContext(Context testContext, Context mockContext)3184         MyMockContext(Context testContext, Context mockContext) {
3185             this.mTestContext = testContext;
3186             this.mMockContext = mockContext;
3187         }
3188 
3189         @Override
checkCallingOrSelfPermission(final String permission)3190         public int checkCallingOrSelfPermission(final String permission) {
3191             return mMockContext.checkCallingOrSelfPermission(permission);
3192         }
3193 
3194         @Override
bindServiceAsUser(Intent service, ServiceConnection conn, int flags, UserHandle user)3195         public boolean bindServiceAsUser(Intent service, ServiceConnection conn, int flags,
3196                 UserHandle user) {
3197             return mTestContext.bindServiceAsUser(service, conn, flags, user);
3198         }
3199 
3200         @Override
unbindService(ServiceConnection conn)3201         public void unbindService(ServiceConnection conn) {
3202             mTestContext.unbindService(conn);
3203         }
3204 
3205         @Override
getPackageManager()3206         public PackageManager getPackageManager() {
3207             return mMockContext.getPackageManager();
3208         }
3209 
3210         @Override
getPackageName()3211         public String getPackageName() {
3212             return mTestContext.getPackageName();
3213         }
3214 
3215         @Override
getSystemService(String name)3216         public Object getSystemService(String name) {
3217             return mMockContext.getSystemService(name);
3218         }
3219 
3220         @Override
getSystemServiceName(Class<?> serviceClass)3221         public String getSystemServiceName(Class<?> serviceClass) {
3222             return mMockContext.getSystemServiceName(serviceClass);
3223         }
3224 
3225         @Override
startActivityAsUser(Intent intent, UserHandle user)3226         public void startActivityAsUser(Intent intent, UserHandle user) {
3227             mMockContext.startActivityAsUser(intent, user);
3228         }
3229 
3230         @Override
registerReceiver(BroadcastReceiver receiver, IntentFilter filter)3231         public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
3232             return mMockContext.registerReceiver(receiver, filter);
3233         }
3234 
3235         @Override
registerReceiverAsUser(BroadcastReceiver receiver, UserHandle user, IntentFilter filter, String broadcastPermission, Handler scheduler)3236         public Intent registerReceiverAsUser(BroadcastReceiver receiver, UserHandle user,
3237                 IntentFilter filter, String broadcastPermission, Handler scheduler) {
3238             return mMockContext.registerReceiverAsUser(
3239                     receiver, user, filter, broadcastPermission, scheduler);
3240         }
3241 
3242         @Override
openOrCreateDatabase(String file, int mode, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler)3243         public SQLiteDatabase openOrCreateDatabase(String file, int mode,
3244                 SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler) {
3245             return mTestContext.openOrCreateDatabase(file, mode, factory,errorHandler);
3246         }
3247 
3248         @Override
getDatabasePath(String name)3249         public File getDatabasePath(String name) {
3250             return mTestContext.getDatabasePath(name);
3251         }
3252 
3253         @Override
sendBroadcastAsUser(Intent intent, UserHandle user)3254         public void sendBroadcastAsUser(Intent intent, UserHandle user) {
3255             mMockContext.sendBroadcastAsUser(intent, user);
3256         }
3257 
3258         @Override
getOpPackageName()3259         public String getOpPackageName() {
3260             return mMockContext.getOpPackageName();
3261         }
3262 
3263         @Override
createPackageContextAsUser(String packageName, int flags, UserHandle user)3264         public Context createPackageContextAsUser(String packageName, int flags, UserHandle user)
3265                 throws PackageManager.NameNotFoundException {
3266             return mMockContext.createPackageContextAsUser(packageName, flags, user);
3267         }
3268     }
3269 
3270     static class TestAccountAuthenticatorCache extends AccountAuthenticatorCache {
TestAccountAuthenticatorCache(Context realContext)3271         public TestAccountAuthenticatorCache(Context realContext) {
3272             super(realContext);
3273         }
3274 
3275         @Override
getUserSystemDirectory(int userId)3276         protected File getUserSystemDirectory(int userId) {
3277             return new File(mContext.getCacheDir(), "authenticator");
3278         }
3279     }
3280 
3281     static class TestInjector extends AccountManagerService.Injector {
3282         private Context mRealContext;
3283         private INotificationManager mMockNotificationManager;
TestInjector(Context realContext, Context mockContext, INotificationManager mockNotificationManager)3284         TestInjector(Context realContext,
3285                 Context mockContext,
3286                 INotificationManager mockNotificationManager) {
3287             super(mockContext);
3288             mRealContext = realContext;
3289             mMockNotificationManager = mockNotificationManager;
3290         }
3291 
3292         @Override
getMessageHandlerLooper()3293         Looper getMessageHandlerLooper() {
3294             return Looper.getMainLooper();
3295         }
3296 
3297         @Override
addLocalService(AccountManagerInternal service)3298         void addLocalService(AccountManagerInternal service) {
3299         }
3300 
3301         @Override
getAccountAuthenticatorCache()3302         IAccountAuthenticatorCache getAccountAuthenticatorCache() {
3303             return new TestAccountAuthenticatorCache(mRealContext);
3304         }
3305 
3306         @Override
getCeDatabaseName(int userId)3307         protected String getCeDatabaseName(int userId) {
3308             return new File(mRealContext.getCacheDir(), CE_DB).getPath();
3309         }
3310 
3311         @Override
getDeDatabaseName(int userId)3312         protected String getDeDatabaseName(int userId) {
3313             return new File(mRealContext.getCacheDir(), DE_DB).getPath();
3314         }
3315 
3316         @Override
getPreNDatabaseName(int userId)3317         String getPreNDatabaseName(int userId) {
3318             return new File(mRealContext.getCacheDir(), PREN_DB).getPath();
3319         }
3320 
3321         @Override
getNotificationManager()3322         INotificationManager getNotificationManager() {
3323             return mMockNotificationManager;
3324         }
3325     }
3326 
3327     class Response extends IAccountManagerResponse.Stub {
3328         private CountDownLatch mLatch;
3329         private IAccountManagerResponse mMockResponse;
Response(CountDownLatch latch, IAccountManagerResponse mockResponse)3330         public Response(CountDownLatch latch, IAccountManagerResponse mockResponse) {
3331             mLatch = latch;
3332             mMockResponse = mockResponse;
3333         }
3334 
3335         @Override
onResult(Bundle bundle)3336         public void onResult(Bundle bundle) {
3337             try {
3338                 mMockResponse.onResult(bundle);
3339             } catch (RemoteException e) {
3340             }
3341             mLatch.countDown();
3342         }
3343 
3344         @Override
onError(int code, String message)3345         public void onError(int code, String message) {
3346             try {
3347                 mMockResponse.onError(code, message);
3348             } catch (RemoteException e) {
3349             }
3350             mLatch.countDown();
3351         }
3352     }
3353 }
3354