Merge "Seeding CTS tests for ContactsContract." into eclair
diff --git a/tests/tests/accounts/AndroidManifest.xml b/tests/tests/accounts/AndroidManifest.xml
index 623e1ad..a54d423 100644
--- a/tests/tests/accounts/AndroidManifest.xml
+++ b/tests/tests/accounts/AndroidManifest.xml
@@ -22,12 +22,13 @@
<uses-permission android:name="android.permission.MANAGE_ACCOUNTS" />
<uses-permission android:name="android.permission.AUTHENTICATE_ACCOUNTS" />
<uses-permission android:name="android.permission.GET_ACCOUNTS" />
+ <uses-permission android:name="android.permission.USE_CREDENTIALS" />
<application>
<uses-library android:name="android.test.runner" />
<service android:name="MockAccountService" android:exported="true"
- android:process="android.accounts.cts">
+ android:process="android.accounts.cts">
<intent-filter>
<action android:name="android.accounts.AccountAuthenticator" />
</intent-filter>
diff --git a/tests/tests/accounts/res/drawable/ic_cts_minitab_selected.png b/tests/tests/accounts/res/drawable/ic_cts_minitab_selected.png
index 73b0b38..c730050 100644
--- a/tests/tests/accounts/res/drawable/ic_cts_minitab_selected.png
+++ b/tests/tests/accounts/res/drawable/ic_cts_minitab_selected.png
Binary files differ
diff --git a/tests/tests/accounts/res/drawable/ic_cts_selected.png b/tests/tests/accounts/res/drawable/ic_cts_selected.png
index 0af7914..72a065c 100644
--- a/tests/tests/accounts/res/drawable/ic_cts_selected.png
+++ b/tests/tests/accounts/res/drawable/ic_cts_selected.png
Binary files differ
diff --git a/tests/tests/accounts/res/values/strings.xml b/tests/tests/accounts/res/values/strings.xml
index 6f12b72..442669b 100644
--- a/tests/tests/accounts/res/values/strings.xml
+++ b/tests/tests/accounts/res/values/strings.xml
@@ -19,5 +19,5 @@
<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
<!-- Label for this package -->
- <string name="label">Android CTS</string>
+ <string name="label">Android CTS - Account</string>
</resources>
\ No newline at end of file
diff --git a/tests/tests/accounts/src/android/accounts/cts/AccountManagerTest.java b/tests/tests/accounts/src/android/accounts/cts/AccountManagerTest.java
index 0a86a5e..d625b06 100644
--- a/tests/tests/accounts/src/android/accounts/cts/AccountManagerTest.java
+++ b/tests/tests/accounts/src/android/accounts/cts/AccountManagerTest.java
@@ -16,49 +16,1105 @@
package android.accounts.cts;
-import dalvik.annotation.KnownFailure;
-
import android.accounts.Account;
import android.accounts.AccountManager;
+import android.accounts.AccountManagerCallback;
import android.accounts.AccountManagerFuture;
+import android.accounts.AuthenticatorDescription;
+import android.accounts.AuthenticatorException;
+import android.accounts.OnAccountsUpdateListener;
+import android.accounts.OperationCanceledException;
+import android.app.Activity;
+import android.content.Context;
import android.os.Bundle;
+import android.os.Handler;
import android.test.AndroidTestCase;
+import java.io.IOException;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
public class AccountManagerTest extends AndroidTestCase {
- @KnownFailure(value="failure removing account bug 2342468")
- public void testAddAndRemoveAccount() throws Exception {
- AccountManager am = AccountManager.get(getContext());
+ public static final String ACCOUNT_NAME = "android.accounts.cts.account.name";
+ public static final String ACCOUNT_NAME_OTHER = "android.accounts.cts.account.name.other";
+ public static final String ACCOUNT_TYPE = "android.accounts.cts.account.type";
+ public static final String ACCOUNT_TYPE_OTHER = "android.accounts.cts.account.type.other";
+
+ public static final String ACCOUNT_PASSWORD = "android.accounts.cts.account.password";
+
+ public static final String AUTH_TOKEN = "mockAuthToken";
+ public static final String AUTH_TOKEN_TYPE = "mockAuthTokenType";
+ public static final String AUTH_TOKEN_LABEL = "mockAuthTokenLabel";
+
+ public static final String FEATURE_1 = "feature.1";
+ public static final String FEATURE_2 = "feature.2";
+ public static final String NON_EXISTING_FEATURE = "feature.3";
+
+ public static final String OPTION_NAME_1 = "option.name.1";
+ public static final String OPTION_VALUE_1 = "option.value.1";
+
+ public static final String OPTION_NAME_2 = "option.name.2";
+ public static final String OPTION_VALUE_2 = "option.value.2";
+
+ public static final String[] REQUIRED_FEATURES = new String[] { FEATURE_1, FEATURE_2 };
+
+ public static final Activity ACTIVITY = new Activity();
+ public static final Bundle OPTIONS_BUNDLE = new Bundle();
+
+ public static final Bundle USERDATA_BUNDLE = new Bundle();
+
+ public static final String USERDATA_NAME_1 = "user.data.name.1";
+ public static final String USERDATA_NAME_2 = "user.data.name.2";
+ public static final String USERDATA_VALUE_1 = "user.data.value.1";
+ public static final String USERDATA_VALUE_2 = "user.data.value.2";
+
+ public static final Account ACCOUNT = new Account(ACCOUNT_NAME, ACCOUNT_TYPE);
+ public static final Account ACCOUNT_SAME_TYPE = new Account(ACCOUNT_NAME_OTHER, ACCOUNT_TYPE);
+
+ private static MockAccountAuthenticator mockAuthenticator;
+ private static final int LATCH_TIMEOUT_MS = 500;
+ private static AccountManager am;
+
+ public synchronized static MockAccountAuthenticator getMockAuthenticator(Context context) {
+ if (null == mockAuthenticator) {
+ mockAuthenticator = new MockAccountAuthenticator(context);
+ }
+ return mockAuthenticator;
+ }
+
+ @Override
+ public void setUp() throws Exception {
+ super.setUp();
+
+ OPTIONS_BUNDLE.putString(OPTION_NAME_1, OPTION_VALUE_1);
+ OPTIONS_BUNDLE.putString(OPTION_NAME_2, OPTION_VALUE_2);
+
+ USERDATA_BUNDLE.putString(USERDATA_NAME_1, USERDATA_VALUE_1);
+
+ getMockAuthenticator(getContext());
+
+ am = AccountManager.get(getContext());
+ }
+
+ @Override
+ public void tearDown() throws Exception, AuthenticatorException, OperationCanceledException {
+ mockAuthenticator.clearData();
+
+ // Need to clean up created account
+ assertTrue(removeAccount(am, ACCOUNT, null /* callback */));
+ assertTrue(removeAccount(am, ACCOUNT_SAME_TYPE, null /* callback */));
+
+ // need to clean up the authenticator cached data
+ mockAuthenticator.clearData();
+
+ super.tearDown();
+ }
+
+ private void validateNonNullResult(Bundle result) {
+ assertEquals(ACCOUNT_NAME, result.get(AccountManager.KEY_ACCOUNT_NAME));
+ assertEquals(ACCOUNT_TYPE, result.get(AccountManager.KEY_ACCOUNT_TYPE));
+ assertEquals(AUTH_TOKEN, result.get(AccountManager.KEY_AUTHTOKEN));
+ }
+
+ private void validateNullResult(Bundle resultBundle) {
+ assertNull(resultBundle.get(AccountManager.KEY_ACCOUNT_NAME));
+ assertNull(resultBundle.get(AccountManager.KEY_ACCOUNT_TYPE));
+ assertNull(resultBundle.get(AccountManager.KEY_AUTHTOKEN));
+ }
+
+ private void validateAccountAndAuthTokenType() {
+ assertEquals(ACCOUNT_TYPE, mockAuthenticator.getAccountType());
+ assertEquals(AUTH_TOKEN_TYPE, mockAuthenticator.getAuthTokenType());
+ }
+
+ private void validateFeatures() {
+ assertEquals(REQUIRED_FEATURES[0], mockAuthenticator.getRequiredFeatures()[0]);
+ assertEquals(REQUIRED_FEATURES[1], mockAuthenticator.getRequiredFeatures()[1]);
+ }
+
+ private void validateOptions() {
+ assertNotNull(mockAuthenticator.getOptions());
+ assertEquals(OPTION_VALUE_1, mockAuthenticator.getOptions().get(OPTION_NAME_1));
+ assertEquals(OPTION_VALUE_2, mockAuthenticator.getOptions().get(OPTION_NAME_2));
+ }
+
+ private void validateCredentials() {
+ assertEquals(ACCOUNT, mockAuthenticator.getAccount());
+
+ assertEquals(OPTION_VALUE_1, mockAuthenticator.getOptions().get(OPTION_NAME_1));
+ assertEquals(OPTION_VALUE_2, mockAuthenticator.getOptions().get(OPTION_NAME_2));
+ }
+
+ private int getAccountsCount() {
Account[] accounts = am.getAccounts();
assertNotNull(accounts);
- final int accountsCount = accounts.length;
+ return accounts.length;
+ }
+
+ private Bundle addAccount(AccountManager am, String accountType, String authTokenType,
+ String[] requiredFeatures, Bundle options, Activity activity,
+ AccountManagerCallback<Bundle> callback, Handler handler) throws
+ IOException, AuthenticatorException, OperationCanceledException {
AccountManagerFuture<Bundle> futureBundle = am.addAccount(
- MockAccountAuthenticator.MOCK_ACCOUNT_TYPE,
- MockAccountAuthenticator.MOCK_AUTH_TOKEN_TYPE,
- null, null, null, null, null);
+ accountType,
+ authTokenType,
+ requiredFeatures,
+ options,
+ activity,
+ callback,
+ handler);
Bundle resultBundle = futureBundle.getResult();
assertTrue(futureBundle.isDone());
assertNotNull(resultBundle);
- assertEquals(MockAccountAuthenticator.MOCK_ACCOUNT_NAME,
- resultBundle.get(AccountManager.KEY_ACCOUNT_NAME));
- assertEquals(MockAccountAuthenticator.MOCK_ACCOUNT_TYPE,
- resultBundle.get(AccountManager.KEY_ACCOUNT_TYPE));
- assertNotNull(resultBundle.get(AccountManager.KEY_AUTHTOKEN));
- accounts = am.getAccounts();
- assertNotNull(accounts);
- assertEquals(1 + accountsCount, accounts.length);
+ return resultBundle;
+ }
- AccountManagerFuture<Boolean> futureBoolean = am.removeAccount(accounts[0], null, null);
+ private boolean removeAccount(AccountManager am, Account account,
+ AccountManagerCallback<Boolean> callback) throws IOException, AuthenticatorException,
+ OperationCanceledException {
+
+ AccountManagerFuture<Boolean> futureBoolean = am.removeAccount(account,
+ callback,
+ null /* handler */);
Boolean resultBoolean = futureBoolean.getResult();
assertTrue(futureBoolean.isDone());
- assertNotNull(resultBoolean);
+ return resultBoolean;
+ }
+
+ private void addAccountExplicitly(Account account, String password, Bundle userdata) {
+ assertTrue(am.addAccountExplicitly(account, password, userdata));
+ }
+
+ private Bundle getAuthTokenByFeature(String[] features, Activity activity)
+ throws IOException, AuthenticatorException, OperationCanceledException {
+
+ AccountManagerFuture<Bundle> futureBundle = am.getAuthTokenByFeatures(ACCOUNT_TYPE,
+ AUTH_TOKEN_TYPE,
+ features,
+ activity,
+ OPTIONS_BUNDLE,
+ OPTIONS_BUNDLE,
+ null /* no callback */,
+ null /* no handler */
+ );
+
+ Bundle resultBundle = futureBundle.getResult();
+
+ assertTrue(futureBundle.isDone());
+ assertNotNull(resultBundle);
+
+ return resultBundle;
+ }
+
+ private boolean isAccountPresent(Account[] accounts, Account accountToCheck) {
+ if (null == accounts || null == accountToCheck) {
+ return false;
+ }
+ boolean result = false;
+ int length = accounts.length;
+ for (int n=0; n<length; n++) {
+ if(accountToCheck.equals(accounts[n])) {
+ result = true;
+ break;
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Test singleton
+ */
+ public void testGet() {
+ assertNotNull(AccountManager.get(getContext()));
+ }
+
+ /**
+ * Test a basic addAccount()
+ */
+ public void testAddAccount() throws IOException, AuthenticatorException,
+ OperationCanceledException {
+
+ Bundle resultBundle = addAccount(am,
+ ACCOUNT_TYPE,
+ AUTH_TOKEN_TYPE,
+ REQUIRED_FEATURES,
+ OPTIONS_BUNDLE,
+ ACTIVITY,
+ null /* callback */,
+ null /* handler */);
+
+ // Assert parameters has been passed correctly
+ validateAccountAndAuthTokenType();
+ validateFeatures();
+ validateOptions();
+
+ // Assert returned result
+ validateNonNullResult(resultBundle);
+ }
+
+ /**
+ * Test addAccount() with callback and handler
+ */
+ public void testAddAccountWithCallbackAndHandler() throws IOException,
+ AuthenticatorException, OperationCanceledException {
+
+ testAddAccountWithCallbackAndHandler(null /* handler */);
+ testAddAccountWithCallbackAndHandler(new Handler());
+ }
+
+ private void testAddAccountWithCallbackAndHandler(Handler handler) throws IOException,
+ AuthenticatorException, OperationCanceledException {
+
+ final CountDownLatch latch = new CountDownLatch(1);
+
+ AccountManagerCallback<Bundle> callback = new AccountManagerCallback<Bundle>() {
+ public void run(AccountManagerFuture<Bundle> bundleFuture) {
+ Bundle resultBundle = null;
+ try {
+ resultBundle = bundleFuture.getResult();
+ } catch (OperationCanceledException e) {
+ fail("should not throw an OperationCanceledException");
+ } catch (IOException e) {
+ fail("should not throw an IOException");
+ } catch (AuthenticatorException e) {
+ fail("should not throw an AuthenticatorException");
+ }
+
+ // Assert parameters has been passed correctly
+ validateAccountAndAuthTokenType();
+ validateFeatures();
+ validateOptions();
+
+ // Assert return result
+ validateNonNullResult(resultBundle);
+
+ latch.countDown();
+ }
+ };
+
+ Bundle resultBundle = addAccount(am,
+ ACCOUNT_TYPE,
+ AUTH_TOKEN_TYPE,
+ REQUIRED_FEATURES,
+ OPTIONS_BUNDLE,
+ ACTIVITY,
+ callback,
+ handler);
+
+ // Wait with timeout for the callback to do its work
+ try {
+ latch.await(LATCH_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+ } catch (InterruptedException e) {
+ fail("should not throw an InterruptedException");
+ }
+ }
+
+ /**
+ * Test addAccountExplicitly() and removeAccount()
+ */
+ public void testAddAccountExplicitlyAndRemoveAccount() throws IOException,
+ AuthenticatorException, OperationCanceledException {
+
+ final int accountsCount = getAccountsCount();
+
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ // Assert that we have one more account
+ Account[] accounts = am.getAccounts();
+ assertNotNull(accounts);
+ assertEquals(1 + accountsCount, accounts.length);
+ assertTrue(isAccountPresent(am.getAccounts(), ACCOUNT));
+
+ // Need to clean up
+ assertTrue(removeAccount(am, ACCOUNT, null /* callback */));
+
+ // and verify that we go back to the initial state
accounts = am.getAccounts();
assertNotNull(accounts);
assertEquals(accountsCount, accounts.length);
}
+
+ /**
+ * Test getAccounts() and getAccountsByType()
+ */
+ public void testGetAccountsAndGetAccountsByType() throws IOException, AuthenticatorException,
+ OperationCanceledException {
+
+ assertEquals(false, isAccountPresent(am.getAccounts(), ACCOUNT));
+ assertEquals(false, isAccountPresent(am.getAccounts(), ACCOUNT_SAME_TYPE));
+
+ final int accountsCount = getAccountsCount();
+
+ // Add a first account
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ // Check that we have the new account
+ Account[] accounts = am.getAccounts();
+ assertEquals(1 + accountsCount, accounts.length);
+ assertEquals(true, isAccountPresent(accounts, ACCOUNT));
+
+ // Add another account
+ addAccountExplicitly(ACCOUNT_SAME_TYPE, ACCOUNT_PASSWORD, null /* userData */);
+
+ // Check that we have one more account again
+ accounts = am.getAccounts();
+ assertEquals(2 + accountsCount, accounts.length);
+ assertEquals(true, isAccountPresent(accounts, ACCOUNT_SAME_TYPE));
+
+ // Check if we have one from first type
+ accounts = am.getAccountsByType(ACCOUNT_TYPE);
+ assertEquals(2, accounts.length);
+
+ // Check if we dont have any account from the other type
+ accounts = am.getAccountsByType(ACCOUNT_TYPE_OTHER);
+ assertEquals(0, accounts.length);
+ }
+
+ /**
+ * Test getAuthenticatorTypes()
+ */
+ public void testGetAuthenticatorTypes() {
+ AuthenticatorDescription[] types = am.getAuthenticatorTypes();
+ for(AuthenticatorDescription description: types) {
+ if (description.type.equals(ACCOUNT_TYPE)) {
+ return;
+ }
+ }
+ fail("should have found Authenticator type: " + ACCOUNT_TYPE);
+ }
+
+ /**
+ * Test setPassword() and getPassword()
+ */
+ public void testSetAndGetAndClearPassword() {
+ // Add a first account
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ // Check that the password is the one we defined
+ assertEquals(ACCOUNT_PASSWORD, am.getPassword(ACCOUNT));
+
+ // Clear the password and check that it is cleared
+ am.clearPassword(ACCOUNT);
+ assertNull(am.getPassword(ACCOUNT));
+
+ // Reset the password
+ am.setPassword(ACCOUNT, ACCOUNT_PASSWORD);
+
+ // Check that the password is the one we defined
+ assertEquals(ACCOUNT_PASSWORD, am.getPassword(ACCOUNT));
+ }
+
+ /**
+ * Test setUserData() and getUserData()
+ */
+ public void testSetAndGetUserData() {
+ // Add a first account
+ boolean result = am.addAccountExplicitly(ACCOUNT,
+ ACCOUNT_PASSWORD,
+ USERDATA_BUNDLE);
+
+ assertTrue(result);
+
+ // Check that the UserData is the one we defined
+ assertEquals(USERDATA_VALUE_1, am.getUserData(ACCOUNT, USERDATA_NAME_1));
+
+ am.setUserData(ACCOUNT, USERDATA_NAME_2, USERDATA_VALUE_2);
+
+ // Check that the UserData is the one we defined
+ assertEquals(USERDATA_VALUE_2, am.getUserData(ACCOUNT, USERDATA_NAME_2));
+ }
+
+ /**
+ * Test getAccountsByTypeAndFeatures()
+ */
+ public void testGetAccountsByTypeAndFeatures() throws IOException,
+ AuthenticatorException, OperationCanceledException {
+
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ AccountManagerFuture<Account[]> futureAccounts = am.getAccountsByTypeAndFeatures(
+ ACCOUNT_TYPE, REQUIRED_FEATURES, null, null);
+
+ Account[] accounts = futureAccounts.getResult();
+
+ assertNotNull(accounts);
+ assertEquals(1, accounts.length);
+ assertEquals(true, isAccountPresent(accounts, ACCOUNT));
+
+ futureAccounts = am.getAccountsByTypeAndFeatures(ACCOUNT_TYPE,
+ new String[] { NON_EXISTING_FEATURE },
+ null /* callback*/,
+ null /* handler */);
+ accounts = futureAccounts.getResult();
+
+ assertNotNull(accounts);
+ assertEquals(0, accounts.length);
+ }
+
+ /**
+ * Test getAccountsByTypeAndFeatures() with callback and handler
+ */
+ public void testGetAccountsByTypeAndFeaturesWithCallbackAndHandler() throws IOException,
+ AuthenticatorException, OperationCanceledException {
+
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ testGetAccountsByTypeAndFeaturesWithCallbackAndHandler(null /* handler */);
+ testGetAccountsByTypeAndFeaturesWithCallbackAndHandler(new Handler());
+ }
+
+ private void testGetAccountsByTypeAndFeaturesWithCallbackAndHandler(Handler handler) throws
+ IOException, AuthenticatorException, OperationCanceledException {
+
+ final CountDownLatch latch1 = new CountDownLatch(1);
+
+ AccountManagerCallback<Account[]> callback1 = new AccountManagerCallback<Account[]>() {
+ public void run(AccountManagerFuture<Account[]> accountsFuture) {
+ try {
+ Account[] accounts = accountsFuture.getResult();
+ assertNotNull(accounts);
+ assertEquals(1, accounts.length);
+ assertEquals(true, isAccountPresent(accounts, ACCOUNT));
+ } catch (OperationCanceledException e) {
+ fail("should not throw an OperationCanceledException");
+ } catch (IOException e) {
+ fail("should not throw an IOException");
+ } catch (AuthenticatorException e) {
+ fail("should not throw an AuthenticatorException");
+ } finally {
+ latch1.countDown();
+ }
+ }
+ };
+
+ AccountManagerFuture<Account[]> futureAccounts = am.getAccountsByTypeAndFeatures(
+ ACCOUNT_TYPE,
+ REQUIRED_FEATURES,
+ callback1,
+ handler);
+
+ Account[] accounts = futureAccounts.getResult();
+
+ assertNotNull(accounts);
+ assertEquals(1, accounts.length);
+ assertEquals(true, isAccountPresent(accounts, ACCOUNT));
+
+ // Wait with timeout for the callback to do its work
+ try {
+ latch1.await(LATCH_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+ } catch (InterruptedException e) {
+ fail("should not throw an InterruptedException");
+ }
+
+ final CountDownLatch latch2 = new CountDownLatch(1);
+
+ AccountManagerCallback<Account[]> callback2 = new AccountManagerCallback<Account[]>() {
+ public void run(AccountManagerFuture<Account[]> accountsFuture) {
+ try {
+ Account[] accounts = accountsFuture.getResult();
+ assertNotNull(accounts);
+ assertEquals(0, accounts.length);
+ } catch (OperationCanceledException e) {
+ fail("should not throw an OperationCanceledException");
+ } catch (IOException e) {
+ fail("should not throw an IOException");
+ } catch (AuthenticatorException e) {
+ fail("should not throw an AuthenticatorException");
+ } finally {
+ latch2.countDown();
+ }
+ }
+ };
+
+ accounts = null;
+
+ futureAccounts = am.getAccountsByTypeAndFeatures(ACCOUNT_TYPE,
+ new String[] { NON_EXISTING_FEATURE },
+ callback2,
+ handler);
+
+ accounts = futureAccounts.getResult();
+ assertNotNull(accounts);
+ assertEquals(0, accounts.length);
+
+ // Wait with timeout for the callback to do its work
+ try {
+ latch2.await(LATCH_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+ } catch (InterruptedException e) {
+ fail("should not throw an InterruptedException");
+ }
+ }
+
+ /**
+ * Test setAuthToken() and peekAuthToken()
+ */
+ public void testSetAndPeekAndInvalidateAuthToken() {
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ am.setAuthToken(ACCOUNT, AUTH_TOKEN_TYPE, AUTH_TOKEN);
+
+ // Ask for the AuthToken
+ String token = am.peekAuthToken(ACCOUNT, AUTH_TOKEN_TYPE);
+ assertNotNull(token);
+ assertEquals(AUTH_TOKEN, token);
+
+ am.invalidateAuthToken(ACCOUNT_TYPE, AUTH_TOKEN);
+ token = am.peekAuthToken(ACCOUNT, AUTH_TOKEN_TYPE);
+ assertNull(token);
+ }
+
+ /**
+ * Test blockingGetAuthToken()
+ */
+ public void testBlockingGetAuthToken() throws IOException, AuthenticatorException,
+ OperationCanceledException {
+
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null);
+
+ String token = am.blockingGetAuthToken(ACCOUNT,
+ AUTH_TOKEN_TYPE,
+ false /* no failure notification */);
+
+ // Ask for the AuthToken
+ assertNotNull(token);
+ assertEquals(AUTH_TOKEN, token);
+ }
+
+ /**
+ * Test getAuthToken()
+ */
+ public void testGetAuthToken() throws IOException, AuthenticatorException,
+ OperationCanceledException {
+
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ AccountManagerFuture<Bundle> futureBundle = am.getAuthToken(ACCOUNT,
+ AUTH_TOKEN_TYPE,
+ false /* no failure notification */,
+ null /* no callback */,
+ null /* no handler */
+ );
+
+ Bundle resultBundle = futureBundle.getResult();
+
+ assertTrue(futureBundle.isDone());
+ assertNotNull(resultBundle);
+
+ // Assert returned result
+ validateNonNullResult(resultBundle);
+ }
+
+ /**
+ * Test getAuthToken() with callback and handler
+ */
+ public void testGetAuthTokenWithCallbackAndHandler() throws IOException, AuthenticatorException,
+ OperationCanceledException {
+
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ testGetAuthTokenWithCallbackAndHandler(null /* handler */);
+ testGetAuthTokenWithCallbackAndHandler(new Handler());
+ }
+
+ private void testGetAuthTokenWithCallbackAndHandler(Handler handler) throws IOException,
+ AuthenticatorException, OperationCanceledException {
+
+ final CountDownLatch latch = new CountDownLatch(1);
+
+ AccountManagerCallback<Bundle> callback = new AccountManagerCallback<Bundle>() {
+ public void run(AccountManagerFuture<Bundle> bundleFuture) {
+
+ Bundle resultBundle = null;
+ try {
+ resultBundle = bundleFuture.getResult();
+
+ // Assert returned result
+ validateNonNullResult(resultBundle);
+
+ } catch (OperationCanceledException e) {
+ fail("should not throw an OperationCanceledException");
+ } catch (IOException e) {
+ fail("should not throw an IOException");
+ } catch (AuthenticatorException e) {
+ fail("should not throw an AuthenticatorException");
+ }
+ finally {
+ latch.countDown();
+ }
+ }
+ };
+
+ AccountManagerFuture<Bundle> futureBundle = am.getAuthToken(ACCOUNT,
+ AUTH_TOKEN_TYPE,
+ false /* no failure notification */,
+ callback,
+ handler
+ );
+
+ Bundle resultBundle = futureBundle.getResult();
+
+ assertTrue(futureBundle.isDone());
+ assertNotNull(resultBundle);
+
+ // Wait with timeout for the callback to do its work
+ try {
+ latch.await(LATCH_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+ } catch (InterruptedException e) {
+ fail("should not throw an InterruptedException");
+ }
+ }
+
+ /**
+ * test getAuthToken() with options
+ */
+ public void testGetAuthTokenWithOptions() throws IOException, AuthenticatorException,
+ OperationCanceledException {
+
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ AccountManagerFuture<Bundle> futureBundle = am.getAuthToken(ACCOUNT,
+ AUTH_TOKEN_TYPE,
+ OPTIONS_BUNDLE,
+ ACTIVITY,
+ null /* no callback */,
+ null /* no handler */
+ );
+
+ Bundle resultBundle = futureBundle.getResult();
+
+ assertTrue(futureBundle.isDone());
+ assertNotNull(resultBundle);
+
+ // Assert returned result
+ validateNonNullResult(resultBundle);
+
+ validateOptions();
+ }
+
+ /**
+ * test getAuthToken() with options and callback and handler
+ */
+ public void testGetAuthTokenWithOptionsAndCallback() throws IOException,
+ AuthenticatorException, OperationCanceledException {
+
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ testGetAuthTokenWithOptionsAndCallbackAndHandler(null /* handler */);
+ testGetAuthTokenWithOptionsAndCallbackAndHandler(new Handler());
+ }
+
+ private void testGetAuthTokenWithOptionsAndCallbackAndHandler(Handler handler) throws
+ IOException, AuthenticatorException, OperationCanceledException {
+
+ final CountDownLatch latch = new CountDownLatch(1);
+
+ AccountManagerCallback<Bundle> callback = new AccountManagerCallback<Bundle>() {
+ public void run(AccountManagerFuture<Bundle> bundleFuture) {
+
+ Bundle resultBundle = null;
+ try {
+ resultBundle = bundleFuture.getResult();
+
+ // Assert returned result
+ validateNonNullResult(resultBundle);
+
+ } catch (OperationCanceledException e) {
+ fail("should not throw an OperationCanceledException");
+ } catch (IOException e) {
+ fail("should not throw an IOException");
+ } catch (AuthenticatorException e) {
+ fail("should not throw an AuthenticatorException");
+ }
+ finally {
+ latch.countDown();
+ }
+ }
+ };
+
+ AccountManagerFuture<Bundle> futureBundle = am.getAuthToken(ACCOUNT,
+ AUTH_TOKEN_TYPE,
+ OPTIONS_BUNDLE,
+ ACTIVITY,
+ callback,
+ handler
+ );
+
+ Bundle resultBundle = futureBundle.getResult();
+
+ assertTrue(futureBundle.isDone());
+ assertNotNull(resultBundle);
+
+ // Wait with timeout for the callback to do its work
+ try {
+ latch.await(LATCH_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+ } catch (InterruptedException e) {
+ fail("should not throw an InterruptedException");
+ }
+ }
+
+ /**
+ * Test getAuthTokenByFeatures()
+ */
+ public void testGetAuthTokenByFeatures() throws IOException, AuthenticatorException,
+ OperationCanceledException {
+
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ Bundle resultBundle = getAuthTokenByFeature(
+ new String[] { NON_EXISTING_FEATURE },
+ null /* activity */
+ );
+
+ // Assert returned result
+ validateNullResult(resultBundle);
+
+ assertNull(mockAuthenticator.getOptions());
+ mockAuthenticator.clearData();
+
+ // Now test with existing features and an activity
+ resultBundle = getAuthTokenByFeature(
+ new String[] { NON_EXISTING_FEATURE },
+ ACTIVITY
+ );
+
+ // Assert returned result
+ validateNonNullResult(resultBundle);
+
+ validateOptions();
+ mockAuthenticator.clearData();
+
+ // Now test with existing features and no activity
+ resultBundle = getAuthTokenByFeature(
+ REQUIRED_FEATURES,
+ null /* activity */
+ );
+
+ // Assert returned result
+ validateNonNullResult(resultBundle);
+
+ assertNull(mockAuthenticator.getOptions());
+ mockAuthenticator.clearData();
+
+ // Now test with existing features and an activity
+ resultBundle = getAuthTokenByFeature(
+ REQUIRED_FEATURES,
+ ACTIVITY
+ );
+
+ // Assert returned result
+ validateNonNullResult(resultBundle);
+
+ assertNull(mockAuthenticator.getOptions());
+ }
+
+ /**
+ * Test confirmCredentials()
+ */
+ public void testConfirmCredentials() throws IOException, AuthenticatorException,
+ OperationCanceledException {
+
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ AccountManagerFuture<Bundle> futureBundle = am.confirmCredentials(ACCOUNT,
+ OPTIONS_BUNDLE,
+ ACTIVITY,
+ null /* callback*/,
+ null /* handler */);
+
+ futureBundle.getResult();
+
+ // Assert returned result
+ validateCredentials();
+ }
+
+ /**
+ * Test confirmCredentials() with callback
+ */
+ public void testConfirmCredentialsWithCallbackAndHandler() throws IOException,
+ AuthenticatorException, OperationCanceledException {
+
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ testConfirmCredentialsWithCallbackAndHandler(null /* handler */);
+ testConfirmCredentialsWithCallbackAndHandler(new Handler());
+ }
+
+ private void testConfirmCredentialsWithCallbackAndHandler(Handler handler) throws IOException,
+ AuthenticatorException, OperationCanceledException {
+
+ final CountDownLatch latch = new CountDownLatch(1);
+
+ AccountManagerCallback<Bundle> callback = new AccountManagerCallback<Bundle>() {
+ public void run(AccountManagerFuture<Bundle> bundleFuture) {
+
+ Bundle resultBundle = null;
+ try {
+ resultBundle = bundleFuture.getResult();
+
+ // Assert returned result
+ validateCredentials();
+
+ } catch (OperationCanceledException e) {
+ fail("should not throw an OperationCanceledException");
+ } catch (IOException e) {
+ fail("should not throw an IOException");
+ } catch (AuthenticatorException e) {
+ fail("should not throw an AuthenticatorException");
+ }
+ finally {
+ latch.countDown();
+ }
+ }
+ };
+
+ AccountManagerFuture<Bundle> futureBundle = am.confirmCredentials(ACCOUNT,
+ OPTIONS_BUNDLE,
+ ACTIVITY,
+ callback,
+ handler);
+
+ futureBundle.getResult();
+
+ // Wait with timeout for the callback to do its work
+ try {
+ latch.await(LATCH_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+ } catch (InterruptedException e) {
+ fail("should not throw an InterruptedException");
+ }
+ }
+
+ /**
+ * Test updateCredentials()
+ */
+ public void testUpdateCredentials() throws IOException, AuthenticatorException,
+ OperationCanceledException {
+
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ AccountManagerFuture<Bundle> futureBundle = am.updateCredentials(ACCOUNT,
+ AUTH_TOKEN_TYPE,
+ OPTIONS_BUNDLE,
+ ACTIVITY,
+ null /* callback*/,
+ null /* handler */);
+
+ futureBundle.getResult();
+
+ // Assert returned result
+ validateCredentials();
+ }
+
+ /**
+ * Test updateCredentials() with callback and handler
+ */
+ public void testUpdateCredentialsWithCallbackAndHandler() throws IOException,
+ AuthenticatorException, OperationCanceledException {
+
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ testUpdateCredentialsWithCallbackAndHandler(null /* handler */);
+ testUpdateCredentialsWithCallbackAndHandler(new Handler());
+ }
+
+ private void testUpdateCredentialsWithCallbackAndHandler(Handler handler) throws IOException,
+ AuthenticatorException, OperationCanceledException {
+
+ final CountDownLatch latch = new CountDownLatch(1);
+
+ AccountManagerCallback<Bundle> callback = new AccountManagerCallback<Bundle>() {
+ public void run(AccountManagerFuture<Bundle> bundleFuture) {
+
+ Bundle resultBundle = null;
+ try {
+ resultBundle = bundleFuture.getResult();
+
+ // Assert returned result
+ validateCredentials();
+
+ } catch (OperationCanceledException e) {
+ fail("should not throw an OperationCanceledException");
+ } catch (IOException e) {
+ fail("should not throw an IOException");
+ } catch (AuthenticatorException e) {
+ fail("should not throw an AuthenticatorException");
+ }
+ finally {
+ latch.countDown();
+ }
+ }
+ };
+
+ AccountManagerFuture<Bundle> futureBundle = am.updateCredentials(ACCOUNT,
+ AUTH_TOKEN_TYPE,
+ OPTIONS_BUNDLE,
+ ACTIVITY,
+ callback,
+ handler);
+
+ futureBundle.getResult();
+
+ // Wait with timeout for the callback to do its work
+ try {
+ latch.await(LATCH_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+ } catch (InterruptedException e) {
+ fail("should not throw an InterruptedException");
+ }
+ }
+
+ /**
+ * Test editProperties()
+ */
+ public void testEditProperties() throws IOException, AuthenticatorException,
+ OperationCanceledException {
+
+ AccountManagerFuture<Bundle> futureBundle = am.editProperties(ACCOUNT_TYPE,
+ ACTIVITY,
+ null /* callback */,
+ null /* handler*/);
+
+ futureBundle.getResult();
+
+ // Assert returned result
+ assertEquals(ACCOUNT_TYPE, mockAuthenticator.getAccountType());
+ }
+
+ /**
+ * Test editProperties() with callback and handler
+ */
+ public void testEditPropertiesWithCallbackAndHandler() {
+ testEditPropertiesWithCallbackAndHandler(null /* handler */);
+ testEditPropertiesWithCallbackAndHandler(new Handler());
+ }
+
+ private void testEditPropertiesWithCallbackAndHandler(Handler handler) {
+ final CountDownLatch latch = new CountDownLatch(1);
+
+ AccountManagerCallback<Bundle> callback = new AccountManagerCallback<Bundle>() {
+ public void run(AccountManagerFuture<Bundle> bundleFuture) {
+ try {
+ // Assert returned result
+ assertEquals(ACCOUNT_TYPE, mockAuthenticator.getAccountType());
+ }
+ finally {
+ latch.countDown();
+ }
+ }
+ };
+
+ AccountManagerFuture<Bundle> futureBundle = am.editProperties(ACCOUNT_TYPE,
+ ACTIVITY,
+ callback,
+ handler);
+
+ // Wait with timeout for the callback to do its work
+ try {
+ latch.await(LATCH_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+ } catch (InterruptedException e) {
+ fail("should not throw an InterruptedException");
+ }
+ }
+
+ /**
+ * Test addOnAccountsUpdatedListener() with handler
+ */
+ public void testAddOnAccountsUpdatedListenerWithHandler() throws IOException,
+ AuthenticatorException, OperationCanceledException {
+
+ testAddOnAccountsUpdatedListenerWithHandler(null /* handler */,
+ false /* updateImmediately */);
+
+ // Need to cleanup intermediate state
+ assertTrue(removeAccount(am, ACCOUNT, null /* callback */));
+
+ testAddOnAccountsUpdatedListenerWithHandler(null /* handler */,
+ true /* updateImmediately */);
+
+ // Need to cleanup intermediate state
+ assertTrue(removeAccount(am, ACCOUNT, null /* callback */));
+
+ testAddOnAccountsUpdatedListenerWithHandler(new Handler(),
+ false /* updateImmediately */);
+
+ // Need to cleanup intermediate state
+ assertTrue(removeAccount(am, ACCOUNT, null /* callback */));
+
+ testAddOnAccountsUpdatedListenerWithHandler(new Handler(),
+ true /* updateImmediately */);
+ }
+
+ private void testAddOnAccountsUpdatedListenerWithHandler(Handler handler,
+ boolean updateImmediately) {
+
+ final CountDownLatch latch = new CountDownLatch(1);
+
+ OnAccountsUpdateListener listener = new OnAccountsUpdateListener() {
+ public void onAccountsUpdated(Account[] accounts) {
+ latch.countDown();
+ }
+ };
+
+ // Add a listener
+ am.addOnAccountsUpdatedListener(listener,
+ handler,
+ updateImmediately);
+
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ // Wait with timeout for the callback to do its work
+ try {
+ latch.await(LATCH_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+ } catch (InterruptedException e) {
+ fail("should not throw an InterruptedException");
+ }
+
+ // Cleanup
+ am.removeOnAccountsUpdatedListener(listener);
+ }
+
+ /**
+ * Test removeOnAccountsUpdatedListener() with handler
+ */
+ public void testRemoveOnAccountsUpdatedListener() throws IOException, AuthenticatorException,
+ OperationCanceledException {
+
+ testRemoveOnAccountsUpdatedListenerWithHandler(null /* handler */);
+
+ // Need to cleanup intermediate state
+ assertTrue(removeAccount(am, ACCOUNT, null /* callback */));
+
+ testRemoveOnAccountsUpdatedListenerWithHandler(new Handler());
+ }
+
+ private void testRemoveOnAccountsUpdatedListenerWithHandler(Handler handler) {
+ final CountDownLatch latch = new CountDownLatch(1);
+
+ OnAccountsUpdateListener listener = new OnAccountsUpdateListener() {
+ public void onAccountsUpdated(Account[] accounts) {
+ fail("should not be called");
+ }
+ };
+
+ // First add a listener
+ am.addOnAccountsUpdatedListener(listener,
+ handler,
+ false /* updateImmediately */);
+
+ // Then remove the listener
+ am.removeOnAccountsUpdatedListener(listener);
+
+ addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+ // Wait with timeout for the callback to do its work
+ try {
+ latch.await(LATCH_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+ } catch (InterruptedException e) {
+ fail("should not throw an InterruptedException");
+ }
+ }
}
diff --git a/tests/tests/accounts/src/android/accounts/cts/MockAccountAuthenticator.java b/tests/tests/accounts/src/android/accounts/cts/MockAccountAuthenticator.java
index 19d9f57..9843385 100644
--- a/tests/tests/accounts/src/android/accounts/cts/MockAccountAuthenticator.java
+++ b/tests/tests/accounts/src/android/accounts/cts/MockAccountAuthenticator.java
@@ -16,61 +16,84 @@
package android.accounts.cts;
-import android.accounts.*;
+import android.accounts.AbstractAccountAuthenticator;
+import android.accounts.Account;
+import android.accounts.AccountAuthenticatorResponse;
+import android.accounts.AccountManager;
+import android.accounts.NetworkErrorException;
import android.content.Context;
import android.os.Bundle;
import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
/**
* A simple Mock Account Authenticator
*/
public class MockAccountAuthenticator extends AbstractAccountAuthenticator {
- public static final String MOCK_ACCOUNT_NAME = "android.accounts.cts.account.name";
- public static final String MOCK_ACCOUNT_TYPE = "android.accounts.cts.account.type";
- public static final String MOCK_ACCOUNT_PASSWORD = "android.accounts.cts.account.password";
- public static final String MOCK_AUTH_TOKEN = "mockAuthToken";
- public static final String MOCK_AUTH_TOKEN_TYPE = "mockAuthTokenType";
- public static final String MOCK_AUTH_TOKEN_LABEL = "mockAuthTokenLabel";
-
- public static final int ERROR_CODE_ACCOUNT_TYPE = 11;
- public static final String ERROR_MESSAGE_ACCOUNT_TYPE = "Account Type Unknown";
-
- public static final int ERROR_CODE_ACCOUNT_CANNOT_ADD = 12;
- public static final String ERROR_MESSAGE_ACCOUNT_CANNOT_ADD = "Cannot add account explicitely";
-
- public static final int ERROR_CODE_ACCOUNT_UNKNOWN = 13;
- public static final String ERROR_MESSAGE_ACCOUNT_UNKNOWN = "Account Unknown";
-
- public static final int ERROR_CODE_AUTH_TOKEN_TYPE = 21;
- public static final String ERROR_MESSAGE_AUTH_TOKEN_TYPE = "Auth Token Unknown";
-
- public static final int ERROR_CODE_FEATURE_UNKNOWN = 31;
- public static final String ERROR_MESSAGE_FEATURE_UNKNOWN = "Feature Unknown";
-
- public static final String MOCK_FEATURE_1 = "feature1";
- public static final String MOCK_FEATURE_2 = "feature2";
-
- private final Map<String, Map<Integer, Account>> accountMapByType;
- private final Context mContext;
+ private AccountAuthenticatorResponse mResponse;
+ private String mAccountType;
+ private String mAuthTokenType;
+ private String[] mRequiredFeatures;
+ private Bundle mOptions;
+ private Account mAccount;
+ private String[] mFeatures;
private final ArrayList<String> mockFeatureList = new ArrayList<String>();
public MockAccountAuthenticator(Context context) {
super(context);
- accountMapByType = new HashMap<String, Map<Integer, Account>>();
+ // Create some mock features
+ mockFeatureList.add(AccountManagerTest.FEATURE_1);
+ mockFeatureList.add(AccountManagerTest.FEATURE_2);
+ }
- // we need the Context and AbstractAccountAuthenticator doe not provide
- // access to it even if it stores it, so just duplicate it
- mContext = context;
+ public AccountAuthenticatorResponse getResponse() {
+ return mResponse;
+ }
- // create some mock features
- mockFeatureList.add(MOCK_FEATURE_1);
- mockFeatureList.add(MOCK_FEATURE_2);
+ public String getAccountType() {
+ return mAccountType;
+ }
+
+ public String getAuthTokenType() {
+ return mAuthTokenType;
+ }
+
+ public String[] getRequiredFeatures() {
+ return mRequiredFeatures;
+ }
+
+ public Bundle getOptions() {
+ return mOptions;
+ }
+
+ public Account getAccount() {
+ return mAccount;
+ }
+
+ public String[] getFeatures() {
+ return mFeatures;
+ }
+
+ public void clearData() {
+ mResponse = null;
+ mAccountType = null;
+ mAuthTokenType = null;
+ mRequiredFeatures = null;
+ mOptions = null;
+ mAccount = null;
+ mFeatures = null;
+ }
+
+ private Bundle createResultBundle() {
+ Bundle result = new Bundle();
+ result.putString(AccountManager.KEY_ACCOUNT_NAME, AccountManagerTest.ACCOUNT_NAME);
+ result.putString(AccountManager.KEY_ACCOUNT_TYPE, AccountManagerTest.ACCOUNT_TYPE);
+ result.putString(AccountManager.KEY_AUTHTOKEN, AccountManagerTest.AUTH_TOKEN);
+
+ return result;
}
/**
@@ -81,52 +104,13 @@
String authTokenType, String[] requiredFeatures, Bundle options)
throws NetworkErrorException {
- if(null == response) {
- throw new IllegalArgumentException("response cannot be null");
- }
- if(null == accountType) {
- throw new IllegalArgumentException("accountType cannot be null");
- }
- if(null == authTokenType) {
- throw new IllegalArgumentException("authTokenType cannot be null");
- }
+ this.mResponse = response;
+ this.mAccountType = accountType;
+ this.mAuthTokenType = authTokenType;
+ this.mRequiredFeatures = requiredFeatures;
+ this.mOptions = options;
- Bundle result = new Bundle();
-
- if (accountType.equals(MOCK_ACCOUNT_TYPE)) {
- Account account = new Account(MOCK_ACCOUNT_NAME, MOCK_ACCOUNT_TYPE);
- // Add the account in the DB
- if(AccountManager.get(mContext).addAccountExplicitly(account,
- MOCK_ACCOUNT_PASSWORD,
- null)) {
- getAccountMapByType(accountType).put(account.hashCode(), account);
-
- result.putString(AccountManager.KEY_ACCOUNT_NAME, account.name);
- result.putString(AccountManager.KEY_ACCOUNT_TYPE, account.type);
- result.putString(AccountManager.KEY_AUTHTOKEN, getAuthTokenForAccount(account));
- }
- else {
- result.putInt(AccountManager.KEY_ERROR_CODE , ERROR_CODE_ACCOUNT_CANNOT_ADD);
- result.putString(AccountManager.KEY_ERROR_MESSAGE , ERROR_MESSAGE_ACCOUNT_CANNOT_ADD);
- }
-
- } else {
- result.putInt(AccountManager.KEY_ERROR_CODE , ERROR_CODE_ACCOUNT_TYPE);
- result.putString(AccountManager.KEY_ERROR_MESSAGE , ERROR_MESSAGE_ACCOUNT_TYPE);
- }
-
- return result;
- }
-
- private Map<Integer, Account> getAccountMapByType(String accountType) {
- String type = (null != accountType) ? accountType : "";
-
- Map<Integer, Account> map = accountMapByType.get(type);
- if(null == map) {
- map = new HashMap<Integer, Account>();
- }
-
- return map;
+ return createResultBundle();
}
/**
@@ -136,45 +120,12 @@
public Bundle updateCredentials(AccountAuthenticatorResponse response, Account account,
String authTokenType, Bundle options) throws NetworkErrorException {
- if(null == response) {
- throw new IllegalArgumentException("response cannot be null");
- }
- if(null == account) {
- throw new IllegalArgumentException("account cannot be null");
- }
+ this.mResponse = response;
+ this.mAccount = account;
+ this.mAuthTokenType = authTokenType;
+ this.mOptions = options;
- Bundle result = new Bundle();
-
- Account accountInMap = getAccountMapByType(account.type).get(account.hashCode());
- if(null == accountInMap) {
- result.putInt(AccountManager.KEY_ERROR_CODE , ERROR_CODE_ACCOUNT_UNKNOWN);
- result.putString(AccountManager.KEY_ERROR_MESSAGE , ERROR_MESSAGE_ACCOUNT_UNKNOWN);
- }
-
- if(authTokenType.equals(MOCK_AUTH_TOKEN_TYPE)) {
- result.putString(AccountManager.KEY_ACCOUNT_NAME, account.name);
- result.putString(AccountManager.KEY_ACCOUNT_TYPE, account.type);
- result.putString(AccountManager.KEY_AUTHTOKEN, getAuthTokenForAccount(account));
- } else {
- result.putInt(AccountManager.KEY_ERROR_CODE , ERROR_CODE_AUTH_TOKEN_TYPE);
- result.putString(AccountManager.KEY_ERROR_MESSAGE , ERROR_MESSAGE_AUTH_TOKEN_TYPE);
- }
-
- return result;
- }
-
- private String getAuthTokenForAccount(Account account) {
- StringBuilder sb = new StringBuilder(MOCK_AUTH_TOKEN);
- sb.append(":");
- if(null != account) {
- sb.append(account.name);
- }
- sb.append(":");
- if(null != account) {
- sb.append(account.type);
- }
-
- return sb.toString();
+ return createResultBundle();
}
/**
@@ -184,7 +135,11 @@
*/
@Override
public Bundle editProperties(AccountAuthenticatorResponse response, String accountType) {
- throw new UnsupportedOperationException();
+
+ this.mResponse = response;
+ this.mAccountType = accountType;
+
+ return createResultBundle();
}
/**
@@ -194,24 +149,13 @@
public Bundle confirmCredentials(AccountAuthenticatorResponse response, Account account,
Bundle options) throws NetworkErrorException {
- if(null == response) {
- throw new IllegalArgumentException("response cannot be null");
- }
- if(null == account) {
- throw new IllegalArgumentException("account cannot be null");
- }
+ this.mResponse = response;
+ this.mAccount = account;
+ this.mOptions = options;
Bundle result = new Bundle();
+ result.putBoolean(AccountManager.KEY_BOOLEAN_RESULT, true);
- Account accountInMap = getAccountMapByType(account.type).get(account.hashCode());
- if(null == accountInMap) {
- result.putInt(AccountManager.KEY_ERROR_CODE , ERROR_CODE_ACCOUNT_UNKNOWN);
- result.putString(AccountManager.KEY_ERROR_MESSAGE , ERROR_MESSAGE_ACCOUNT_UNKNOWN);
- }
- else {
- result.putBoolean(AccountManager.KEY_BOOLEAN_RESULT, true);
- }
-
return result;
}
@@ -222,36 +166,12 @@
public Bundle getAuthToken(AccountAuthenticatorResponse response, Account account,
String authTokenType, Bundle options) throws NetworkErrorException {
- if(null == response) {
- throw new IllegalArgumentException("response cannot be null");
- }
- if(null == account) {
- throw new IllegalArgumentException("account cannot be null");
- }
- if(null == authTokenType) {
- throw new IllegalArgumentException("authTokenType cannot be null");
- }
+ this.mResponse = response;
+ this.mAccount = account;
+ this.mAuthTokenType = authTokenType;
+ this.mOptions = options;
- Bundle result = new Bundle();
-
- Account accountInMap = getAccountMapByType(account.type).get(account.hashCode());
- if(null == accountInMap) {
- result.putInt(AccountManager.KEY_ERROR_CODE , ERROR_CODE_ACCOUNT_UNKNOWN);
- result.putString(AccountManager.KEY_ERROR_MESSAGE , ERROR_MESSAGE_ACCOUNT_UNKNOWN);
- }
- else {
- if(authTokenType.equals(MOCK_AUTH_TOKEN_TYPE)) {
- result.putString(AccountManager.KEY_ACCOUNT_NAME, account.name);
- result.putString(AccountManager.KEY_ACCOUNT_TYPE, account.type);
- result.putString(AccountManager.KEY_AUTHTOKEN, getAuthTokenForAccount(account));
- }
- else {
- result.putInt(AccountManager.KEY_ERROR_CODE , ERROR_CODE_AUTH_TOKEN_TYPE);
- result.putString(AccountManager.KEY_ERROR_MESSAGE , ERROR_MESSAGE_AUTH_TOKEN_TYPE);
- }
- }
-
- return result;
+ return createResultBundle();
}
/**
@@ -259,14 +179,9 @@
*/
@Override
public String getAuthTokenLabel(String authTokenType) {
- if(null == authTokenType) {
- throw new IllegalArgumentException("authTokenType cannot be null");
- }
- if(! authTokenType.equals(MOCK_AUTH_TOKEN_TYPE)) {
- throw new IllegalArgumentException("unknown authTokenType: " + authTokenType);
- }
+ this.mAuthTokenType = authTokenType;
- return MOCK_AUTH_TOKEN_LABEL;
+ return AccountManagerTest.AUTH_TOKEN_LABEL;
}
/**
@@ -276,33 +191,24 @@
public Bundle hasFeatures(AccountAuthenticatorResponse response, Account account,
String[] features) throws NetworkErrorException {
- if(null == response) {
- throw new IllegalArgumentException("response cannot be null");
- }
- if(null == account) {
- throw new IllegalArgumentException("account cannot be null");
- }
- if(null == features) {
- throw new IllegalArgumentException("featues cannot be null");
- }
+ this.mResponse = response;
+ this.mAccount = account;
+ this.mFeatures = features;
Bundle result = new Bundle();
-
- Account accountInMap = getAccountMapByType(account.type).get(account.hashCode());
- if(null == accountInMap) {
- result.putInt(AccountManager.KEY_ERROR_CODE , ERROR_CODE_ACCOUNT_UNKNOWN);
- result.putString(AccountManager.KEY_ERROR_MESSAGE , ERROR_MESSAGE_ACCOUNT_UNKNOWN);
- }
- else {
- for(String featureName: features) {
- if(! mockFeatureList.contains(featureName)) {
- result.putBoolean(AccountManager.KEY_BOOLEAN_RESULT, false);
- return result;
- }
- }
+ if (null == features) {
result.putBoolean(AccountManager.KEY_BOOLEAN_RESULT, true);
}
-
+ else {
+ boolean booleanResult = true;
+ for (String feature: features) {
+ if (!mockFeatureList.contains(feature)) {
+ booleanResult = false;
+ break;
+ }
+ }
+ result.putBoolean(AccountManager.KEY_BOOLEAN_RESULT, booleanResult);
+ }
return result;
}
}
\ No newline at end of file
diff --git a/tests/tests/accounts/src/android/accounts/cts/MockAccountService.java b/tests/tests/accounts/src/android/accounts/cts/MockAccountService.java
index bde2042..a52f580 100644
--- a/tests/tests/accounts/src/android/accounts/cts/MockAccountService.java
+++ b/tests/tests/accounts/src/android/accounts/cts/MockAccountService.java
@@ -25,15 +25,8 @@
*/
public class MockAccountService extends Service {
- private MockAccountAuthenticator mAuthenticator;
-
@Override
public IBinder onBind(Intent intent) {
- return mAuthenticator.getIBinder();
- }
-
- @Override
- public void onCreate() {
- mAuthenticator = new MockAccountAuthenticator(this);
+ return AccountManagerTest.getMockAuthenticator(this).getIBinder();
}
}
diff --git a/tests/tests/text/src/android/text/format/cts/TimeTest.java b/tests/tests/text/src/android/text/format/cts/TimeTest.java
index 45dcfed..a8f2acd 100644
--- a/tests/tests/text/src/android/text/format/cts/TimeTest.java
+++ b/tests/tests/text/src/android/text/format/cts/TimeTest.java
@@ -17,6 +17,7 @@
package android.text.format.cts;
import java.util.Calendar;
+import java.util.TimeZone;
import android.test.AndroidTestCase;
import android.text.format.Time;
@@ -653,7 +654,7 @@
public void testSet0() throws Exception {
Time t = new Time(Time.TIMEZONE_UTC);
long time = System.currentTimeMillis();
- Calendar date = Calendar.getInstance();
+ Calendar date = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
date.setTimeInMillis(time);
t.set(time);
assertEquals(date.get(Calendar.YEAR), t.year);
diff --git a/tests/tests/view/src/android/view/cts/KeyEventTest.java b/tests/tests/view/src/android/view/cts/KeyEventTest.java
index 6da754f..dc1696c6 100644
--- a/tests/tests/view/src/android/view/cts/KeyEventTest.java
+++ b/tests/tests/view/src/android/view/cts/KeyEventTest.java
@@ -532,35 +532,6 @@
@TestTargetNew(
level = TestLevel.COMPLETE,
- notes = "Test {@link KeyEvent#getMatch(char[], int)}",
- method = "getMatch",
- args = {char[].class, int.class}
- )
- @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete, " +
- "should add NPE description in javadoc.")
- public void testGetMatch2() {
- char[] codes1 = { '0', '1', '2' };
- assertEquals('\0', mKeyEvent.getMatch(codes1, KeyEvent.KEYCODE_SHIFT_LEFT));
-
- char[] codes2 = { 'A', 'B', 'C' };
- assertEquals('\0', mKeyEvent.getMatch(codes2, KeyEvent.KEYCODE_SHIFT_LEFT));
- assertEquals('\0', mKeyEvent.getMatch(codes2, 0));
-
- char[] codes3 = { '2', 's' };
- mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_S);
- assertEquals('\0', mKeyEvent.getMatch(codes3, KeyEvent.KEYCODE_ALT_LEFT));
- assertEquals('s', mKeyEvent.getMatch(codes3, 0));
-
- try {
- mKeyEvent.getMatch(null, 0);
- fail("Should throw NullPointerException ");
- } catch (NullPointerException e) {
- // empty
- }
- }
-
- @TestTargetNew(
- level = TestLevel.COMPLETE,
notes = "Test {@link KeyEvent#getAction()}",
method = "getAction",
args = {}
