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