ADHOC
/
replicant-packages_apps_Email
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Get Email units to compile 

Change-Id: I171a0e2421c5006d9862ad94f886932146547020
This commit is contained in:
Jerry Xie 2013-11-26 20:41:53 -08:00
parent a702a7bbd8
commit 17d3a29c9d
64 changed files with 991 additions and 6342 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
emailcommon/src/com/android/emailcommon/VendorPolicyLoader.java
View File

@ -99,7 +99,7 @@ public class VendorPolicyLoader {
* Constructor for testing, where we need to use an alternate package/class name, and skip
* the system apk check.
*/
/* package */ VendorPolicyLoader(Context context, String apkPackageName, String className,
public VendorPolicyLoader(Context context, String apkPackageName, String className,
boolean allowNonSystemApk) {
if (!allowNonSystemApk && !isSystemPackage(context, apkPackageName)) {
mPolicyMethod = null;
@ -127,7 +127,7 @@ public class VendorPolicyLoader {
}
// Not private for testing
/* package */ static boolean isSystemPackage(Context context, String packageName) {
public static boolean isSystemPackage(Context context, String packageName) {
try {
ApplicationInfo ai = context.getPackageManager().getApplicationInfo(packageName, 0);
return (ai.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
@ -142,7 +142,7 @@ public class VendorPolicyLoader {
* getPolicy returns null).
*/
// Not private for testing
/* package */ Bundle getPolicy(String policy, Bundle args) {
public Bundle getPolicy(String policy, Bundle args) {
Bundle ret = null;
if (mPolicyMethod != null) {
try {

14
emailcommon/src/com/android/emailcommon/utility/AttachmentUtilities.java
View File

@ -151,6 +151,20 @@ public class AttachmentUtilities {
.build();
}
// exposed for testing
public static Uri getAttachmentThumbnailUri(long accountId, long id, long width, long height) {
if (sUri == null) {
sUri = Uri.parse(Attachment.ATTACHMENT_PROVIDER_URI_PREFIX);
}
return sUri.buildUpon()
.appendPath(Long.toString(accountId))
.appendPath(Long.toString(id))
.appendPath(FORMAT_THUMBNAIL)
.appendPath(Long.toString(width))
.appendPath(Long.toString(height))
.build();
}
/**
* Return the filename for a given attachment. This should be used by any code that is
* going to *write* attachments.

2
src/com/android/email/NotificationController.java
View File

@ -89,7 +89,7 @@ public class NotificationController {
private ContentObserver mAccountObserver;
/** Constructor */
private NotificationController(Context context, Clock clock) {
protected NotificationController(Context context, Clock clock) {
mContext = context.getApplicationContext();
EmailContent.init(context);
mNotificationManager = (NotificationManager) context.getSystemService(

2
src/com/android/email/activity/setup/AccountSettingsUtils.java
View File

@ -178,7 +178,7 @@ public class AccountSettingsUtils {
* part (i.e. substring demarcated by a period, '.')
*/
@VisibleForTesting
static boolean matchProvider(String testDomain, String providerDomain) {
public static boolean matchProvider(String testDomain, String providerDomain) {
String[] testParts = testDomain.split(DOMAIN_SEPARATOR);
String[] providerParts = providerDomain.split(DOMAIN_SEPARATOR);
if (testParts.length != providerParts.length) {

2
src/com/android/email/mail/transport/MailTransport.java
View File

@ -55,7 +55,7 @@ public class MailTransport {
private final String mDebugLabel;
private final Context mContext;
private final HostAuth mHostAuth;
protected final HostAuth mHostAuth;
private Socket mSocket;
private InputStream mIn;

2
src/com/android/email/mail/transport/SmtpSender.java
View File

@ -75,7 +75,7 @@ public class SmtpSender extends Sender {
* up and ready to use. Do not use for real code.
* @param testTransport The Transport to inject and use for all future communication.
*/
/* package */ void setTransport(MailTransport testTransport) {
public void setTransport(MailTransport testTransport) {
mTransport = testTransport;
}

28
src/com/android/email/provider/EmailProvider.java
View File

@ -150,8 +150,10 @@ public class EmailProvider extends ContentProvider {
public static String EMAIL_APP_MIME_TYPE;
private static final String DATABASE_NAME = "EmailProvider.db";
private static final String BODY_DATABASE_NAME = "EmailProviderBody.db";
// exposed for testing
public static final String DATABASE_NAME = "EmailProvider.db";
public static final String BODY_DATABASE_NAME = "EmailProviderBody.db";
private static final String BACKUP_DATABASE_NAME = "EmailProviderBackup.db";
/**
@ -342,7 +344,9 @@ public class EmailProvider extends ContentProvider {
return match;
}
private static Uri INTEGRITY_CHECK_URI;
// exposed for testing
public static Uri INTEGRITY_CHECK_URI;
public static Uri ACCOUNT_BACKUP_URI;
private static Uri FOLDER_STATUS_URI;
@ -369,13 +373,14 @@ public class EmailProvider extends ContentProvider {
/**
* Orphan record deletion utility. Generates a sqlite statement like:
* delete from <table> where <column> not in (select <foreignColumn> from <foreignTable>)
* Exposed for testing.
* @param db the EmailProvider database
* @param table the table whose orphans are to be removed
* @param column the column deletion will be based on
* @param foreignColumn the column in the foreign table whose absence will trigger the deletion
* @param foreignTable the foreign table
*/
private static void deleteUnlinked(SQLiteDatabase db, String table, String column,
public static void deleteUnlinked(SQLiteDatabase db, String table, String column,
String foreignColumn, String foreignTable) {
int count = db.delete(table, column + " not in (select " + foreignColumn + " from " +
foreignTable + ")", null);
@ -425,8 +430,8 @@ public class EmailProvider extends ContentProvider {
}
private SQLiteDatabase getDatabase(Context context) {
// exposed for testing
public SQLiteDatabase getDatabase(Context context) {
synchronized (sDatabaseLock) {
// Always return the cached database, if we've got one
if (mDatabase != null) {
@ -519,7 +524,8 @@ public class EmailProvider extends ContentProvider {
}
}
private static void deleteMessageOrphans(SQLiteDatabase database, String tableName) {
// exposed for testing
public static void deleteMessageOrphans(SQLiteDatabase database, String tableName) {
if (database != null) {
// We'll look at all of the items in the table; there won't be many typically
Cursor c = database.query(tableName, ORPHANS_PROJECTION, null, null, null, null, null);
@ -2133,7 +2139,13 @@ public class EmailProvider extends ContentProvider {
AttachmentDownloadService.attachmentChanged(context, id, flags);
}
};
private final AttachmentService mAttachmentService = DEFAULT_ATTACHMENT_SERVICE;
private AttachmentService mAttachmentService = DEFAULT_ATTACHMENT_SERVICE;
// exposed for testing
public void injectAttachmentService(AttachmentService attachmentService) {
mAttachmentService =
attachmentService == null ? DEFAULT_ATTACHMENT_SERVICE : attachmentService;
}
private Cursor notificationQuery(final Uri uri) {
final SQLiteDatabase db = getDatabase(getContext());

34
tests/oldAndroid.mk
View File

@ -1,34 +0,0 @@
# Copyright 2008, The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
# We only want this apk build for tests.
LOCAL_MODULE_TAGS := tests
LOCAL_JAVA_LIBRARIES := android.test.runner
# Include all test java files.
LOCAL_SRC_FILES := $(call all-java-files-under, src)
# Notice that we don't have to include the src files of Email because, by
# running the tests using an instrumentation targeting Email, we
# automatically get all of its classes loaded into our environment.
LOCAL_PACKAGE_NAME := EmailTests
LOCAL_INSTRUMENTATION_FOR := Email
include $(BUILD_PACKAGE)

476
tests/src/com/android/email/ControllerProviderOpsTests.java
View File

@ -1,17 +1,17 @@
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.android.email;
@ -44,11 +44,8 @@ import java.util.concurrent.ExecutionException;
* runtest -c com.android.email.ControllerProviderOpsTests email
*/
public class ControllerProviderOpsTests extends ProviderTestCase2<EmailProvider> {
private Context mProviderContext;
private Context mContext;
private TestController mTestController;
public ControllerProviderOpsTests() {
super(EmailProvider.class, EmailContent.AUTHORITY);
@ -59,7 +56,6 @@ public class ControllerProviderOpsTests extends ProviderTestCase2<EmailProvider>
super.setUp();
mProviderContext = getMockContext();
mContext = getContext();
mTestController = new TestController(mProviderContext, mContext);
// Invalidate all caches, since we reset the database for each test
ContentCache.invalidateAllCaches();
}
@ -67,460 +63,36 @@ public class ControllerProviderOpsTests extends ProviderTestCase2<EmailProvider>
@Override
public void tearDown() throws Exception {
super.tearDown();
mTestController.cleanupForTest();
}
/**
* Lightweight subclass of the Controller class allows injection of mock context
*/
public static class TestController extends Controller {
protected TestController(Context providerContext, Context systemContext) {
super(systemContext);
setProviderContext(providerContext);
}
}
/**
* These are strings that should not change per locale.
*/
public void testGetMailboxServerName() {
assertEquals("", Controller.getMailboxServerName(mContext, -1));
try {
Mailbox.getSystemMailboxName(mContext, -1);
fail("Mailbox.getSystemMailboxName(mContext, -1) succeeded without an exception");
} catch (IllegalArgumentException e) {
// we expect an exception, so do nothing
}
assertEquals("Inbox", Controller.getMailboxServerName(mContext, Mailbox.TYPE_INBOX));
assertEquals("Outbox", Controller.getMailboxServerName(mContext, Mailbox.TYPE_OUTBOX));
assertEquals("Trash", Controller.getMailboxServerName(mContext, Mailbox.TYPE_TRASH));
assertEquals("Sent", Controller.getMailboxServerName(mContext, Mailbox.TYPE_SENT));
assertEquals("Junk", Controller.getMailboxServerName(mContext, Mailbox.TYPE_JUNK));
assertEquals("Inbox", Mailbox.getSystemMailboxName(mContext, Mailbox.TYPE_INBOX));
assertEquals("Outbox", Mailbox.getSystemMailboxName(mContext, Mailbox.TYPE_OUTBOX));
assertEquals("Trash", Mailbox.getSystemMailboxName(mContext, Mailbox.TYPE_TRASH));
assertEquals("Sent", Mailbox.getSystemMailboxName(mContext, Mailbox.TYPE_SENT));
assertEquals("Junk", Mailbox.getSystemMailboxName(mContext, Mailbox.TYPE_JUNK));
// Now try again with translation
Locale savedLocale = Locale.getDefault();
Locale.setDefault(Locale.FRANCE);
assertEquals("Inbox", Controller.getMailboxServerName(mContext, Mailbox.TYPE_INBOX));
assertEquals("Outbox", Controller.getMailboxServerName(mContext, Mailbox.TYPE_OUTBOX));
assertEquals("Trash", Controller.getMailboxServerName(mContext, Mailbox.TYPE_TRASH));
assertEquals("Sent", Controller.getMailboxServerName(mContext, Mailbox.TYPE_SENT));
assertEquals("Junk", Controller.getMailboxServerName(mContext, Mailbox.TYPE_JUNK));
assertEquals("Inbox", Mailbox.getSystemMailboxName(mContext, Mailbox.TYPE_INBOX));
assertEquals("Outbox", Mailbox.getSystemMailboxName(mContext, Mailbox.TYPE_OUTBOX));
assertEquals("Trash", Mailbox.getSystemMailboxName(mContext, Mailbox.TYPE_TRASH));
assertEquals("Sent", Mailbox.getSystemMailboxName(mContext, Mailbox.TYPE_SENT));
assertEquals("Junk", Mailbox.getSystemMailboxName(mContext, Mailbox.TYPE_JUNK));
Locale.setDefault(savedLocale);
}
/**
* Test of Controller.createMailbox().
* Sunny day test only - creates a mailbox that does not exist.
* Does not test duplication, bad accountID, or any other bad input.
*/
public void testCreateMailbox() {
// safety check that system mailboxes don't exist ...
assertEquals(Mailbox.NO_MAILBOX,
Mailbox.findMailboxOfType(mProviderContext, 1L, Mailbox.TYPE_DRAFTS));
assertEquals(Mailbox.NO_MAILBOX,
Mailbox.findMailboxOfType(mProviderContext, 1L, Mailbox.TYPE_SENT));
long testMailboxId;
Mailbox testMailbox;
// Test creating "drafts" mailbox
mTestController.createMailbox(1L, Mailbox.TYPE_DRAFTS);
testMailboxId = Mailbox.findMailboxOfType(mProviderContext, 1L, Mailbox.TYPE_DRAFTS);
assertTrue(testMailboxId != Mailbox.NO_MAILBOX);
testMailbox = Mailbox.restoreMailboxWithId(mProviderContext, testMailboxId);
assertNotNull(testMailbox);
assertEquals(8, testMailbox.mFlags); // Flags should be "holds mail"
assertEquals(-1L, testMailbox.mParentKey); // Parent is off the top-level
// Test creating "sent" mailbox; same as drafts
mTestController.createMailbox(1L, Mailbox.TYPE_SENT);
testMailboxId = Mailbox.findMailboxOfType(mProviderContext, 1L, Mailbox.TYPE_SENT);
assertTrue(testMailboxId != Mailbox.NO_MAILBOX);
testMailbox = Mailbox.restoreMailboxWithId(mProviderContext, testMailboxId);
assertNotNull(testMailbox);
assertEquals(8, testMailbox.mFlags); // Flags should be "holds mail"
assertEquals(-1L, testMailbox.mParentKey); // Parent is off the top-level
}
/**
* Test of Controller.findOrCreateMailboxOfType().
* Checks:
* - finds correctly the ID of existing mailbox
* - creates non-existing mailbox
* - creates only once a new mailbox
* - when accountId or mailboxType are -1, returns NO_MAILBOX
*/
public void testFindOrCreateMailboxOfType() {
Account account = ProviderTestUtils.setupAccount("mailboxid", true, mProviderContext);
long accountId = account.mId;
Mailbox box = ProviderTestUtils.setupMailbox("box", accountId, false, mProviderContext);
final int boxType = Mailbox.TYPE_TRASH;
box.mType = boxType;
box.save(mProviderContext);
long boxId = box.mId;
long testBoxId = mTestController.findOrCreateMailboxOfType(accountId, boxType);
// check it found the right mailbox id
assertEquals(boxId, testBoxId);
long boxId2 = mTestController.findOrCreateMailboxOfType(accountId, Mailbox.TYPE_DRAFTS);
assertTrue("mailbox created", boxId2 != Mailbox.NO_MAILBOX);
assertTrue("with different id", testBoxId != boxId2);
// check it doesn't create twice when existing
long boxId3 = mTestController.findOrCreateMailboxOfType(accountId, Mailbox.TYPE_DRAFTS);
assertEquals("don't create if exists", boxId3, boxId2);
// check invalid aruments
assertEquals(Mailbox.NO_MAILBOX,
mTestController.findOrCreateMailboxOfType(-1, Mailbox.TYPE_DRAFTS));
assertEquals(Mailbox.NO_MAILBOX, mTestController.findOrCreateMailboxOfType(accountId, -1));
}
/**
* Test the "move message" function.
*/
public void testMoveMessage() throws InterruptedException, ExecutionException {
Account account1 = ProviderTestUtils.setupAccount("message-move", true, mProviderContext);
long account1Id = account1.mId;
Mailbox box1 = ProviderTestUtils.setupMailbox("box1", account1Id, true, mProviderContext);
long box1Id = box1.mId;
Mailbox box2 = ProviderTestUtils.setupMailbox("box2", account1Id, true, mProviderContext);
long box2Id = box2.mId;
Mailbox boxDest = ProviderTestUtils.setupMailbox("d", account1Id, true, mProviderContext);
long boxDestId = boxDest.mId;
Message message1 = ProviderTestUtils.setupMessage("message1", account1Id, box1Id, false,
true, mProviderContext);
Message message2 = ProviderTestUtils.setupMessage("message2", account1Id, box2Id, false,
true, mProviderContext);
long message1Id = message1.mId;
long message2Id = message2.mId;
// Because moveMessage runs asynchronously, call get() to force it to complete
mTestController.moveMessages(new long[] { message1Id, message2Id }, boxDestId).get();
// now read back a fresh copy and confirm it's in the trash
assertEquals(boxDestId, EmailContent.Message.restoreMessageWithId(mProviderContext,
message1Id).mMailboxKey);
assertEquals(boxDestId, EmailContent.Message.restoreMessageWithId(mProviderContext,
message2Id).mMailboxKey);
}
/**
* Test the "delete message" function. Sunny day:
* - message/mailbox/account all exist
* - trash mailbox exists
*/
public void testDeleteMessage() {
Account account1 = ProviderTestUtils.setupAccount("message-delete", true, mProviderContext);
long account1Id = account1.mId;
Mailbox box = ProviderTestUtils.setupMailbox("box1", account1Id, true, mProviderContext);
long boxId = box.mId;
Mailbox trashBox = ProviderTestUtils.setupMailbox("box2", account1Id, false,
mProviderContext);
trashBox.mType = Mailbox.TYPE_TRASH;
trashBox.save(mProviderContext);
long trashBoxId = trashBox.mId;
Mailbox draftBox = ProviderTestUtils.setupMailbox("box3", account1Id, false,
mProviderContext);
draftBox.mType = Mailbox.TYPE_DRAFTS;
draftBox.save(mProviderContext);
long draftBoxId = draftBox.mId;
{
// Case 1: Message in a regular mailbox, account known.
Message message = ProviderTestUtils.setupMessage("message1", account1Id, boxId, false,
true, mProviderContext);
long messageId = message.mId;
mTestController.deleteMessageSync(messageId);
// now read back a fresh copy and confirm it's in the trash
Message restored = EmailContent.Message.restoreMessageWithId(mProviderContext,
messageId);
assertEquals(trashBoxId, restored.mMailboxKey);
}
{
// Case 2: Already in trash
Message message = ProviderTestUtils.setupMessage("message3", account1Id, trashBoxId,
false, true, mProviderContext);
long messageId = message.mId;
mTestController.deleteMessageSync(messageId);
// Message should be deleted.
assertNull(EmailContent.Message.restoreMessageWithId(mProviderContext, messageId));
}
{
// Case 3: Draft
Message message = ProviderTestUtils.setupMessage("message3", account1Id, draftBoxId,
false, true, mProviderContext);
long messageId = message.mId;
mTestController.deleteMessageSync(messageId);
// Message should be deleted.
assertNull(EmailContent.Message.restoreMessageWithId(mProviderContext, messageId));
}
}
/**
* Test deleting message when there is no trash mailbox
*/
public void testDeleteMessageNoTrash() {
Account account1 =
ProviderTestUtils.setupAccount("message-delete-notrash", true, mProviderContext);
long account1Id = account1.mId;
Mailbox box1 = ProviderTestUtils.setupMailbox("box1", account1Id, true, mProviderContext);
long box1Id = box1.mId;
Message message1 =
ProviderTestUtils.setupMessage("message1", account1Id, box1Id, false, true,
mProviderContext);
long message1Id = message1.mId;
mTestController.deleteMessageSync(message1Id);
// now read back a fresh copy and confirm it's in the trash
Message message1get =
EmailContent.Message.restoreMessageWithId(mProviderContext, message1Id);
// check the new mailbox and see if it looks right
assertFalse(-1 == message1get.mMailboxKey);
assertFalse(box1Id == message1get.mMailboxKey);
Mailbox mailbox2get = Mailbox.restoreMailboxWithId(mProviderContext,
message1get.mMailboxKey);
assertEquals(Mailbox.TYPE_TRASH, mailbox2get.mType);
}
/**
* Test read/unread flag
*/
public void testReadUnread() throws InterruptedException, ExecutionException {
Account account1 = ProviderTestUtils.setupAccount("read-unread", false, mProviderContext);
account1.mHostAuthRecv
= ProviderTestUtils.setupHostAuth("read-unread", 0, false, mProviderContext);
account1.save(mProviderContext);
long account1Id = account1.mId;
long box1Id = 2;
Message message1 =
ProviderTestUtils.setupMessage("message1", account1Id, box1Id, false, true,
mProviderContext);
long message1Id = message1.mId;
// test setting to "read"
mTestController.setMessageRead(message1Id, true).get();
Message message1get = Message.restoreMessageWithId(mProviderContext, message1Id);
assertTrue(message1get.mFlagRead);
// test setting to "unread"
mTestController.setMessageRead(message1Id, false).get();
message1get = Message.restoreMessageWithId(mProviderContext, message1Id);
assertFalse(message1get.mFlagRead);
// test setting to "read"
mTestController.setMessageRead(message1Id, true).get();
message1get = Message.restoreMessageWithId(mProviderContext, message1Id);
assertTrue(message1get.mFlagRead);
}
/**
* Test favorites flag
*/
public void testFavorites() throws InterruptedException, ExecutionException {
Account account1 = ProviderTestUtils.setupAccount("favorites", false, mProviderContext);
account1.mHostAuthRecv
= ProviderTestUtils.setupHostAuth("favorites", 0, false, mProviderContext);
account1.save(mProviderContext);
long account1Id = account1.mId;
long box1Id = 2;
Message message1 =
ProviderTestUtils.setupMessage("message1", account1Id, box1Id, false, true,
mProviderContext);
long message1Id = message1.mId;
// test setting to "favorite"
mTestController.setMessageFavorite(message1Id, true).get();
Message message1get = Message.restoreMessageWithId(mProviderContext, message1Id);
assertTrue(message1get.mFlagFavorite);
// test setting to "not favorite"
mTestController.setMessageFavorite(message1Id, false).get();
message1get = Message.restoreMessageWithId(mProviderContext, message1Id);
assertFalse(message1get.mFlagFavorite);
// test setting to "favorite"
mTestController.setMessageFavorite(message1Id, true).get();
message1get = Message.restoreMessageWithId(mProviderContext, message1Id);
assertTrue(message1get.mFlagFavorite);
}
public void testGetAndDeleteAttachmentMailbox() {
Mailbox box = mTestController.getAttachmentMailbox();
assertNotNull(box);
Mailbox anotherBox = mTestController.getAttachmentMailbox();
assertNotNull(anotherBox);
// We should always get back the same Mailbox row
assertEquals(box.mId, anotherBox.mId);
// Add two messages to this mailbox
ProviderTestUtils.setupMessage("message1", 0, box.mId, false, true,
mProviderContext);
ProviderTestUtils.setupMessage("message2", 0, box.mId, false, true,
mProviderContext);
// Make sure we can find them where they are expected
assertEquals(2, EmailContent.count(mProviderContext, Message.CONTENT_URI,
Message.MAILBOX_KEY + "=?", new String[] {Long.toString(box.mId)}));
// Delete them
mTestController.deleteAttachmentMessages();
// Make sure they're gone
assertEquals(0, EmailContent.count(mProviderContext, Message.CONTENT_URI,
Message.MAILBOX_KEY + "=?", new String[] {Long.toString(box.mId)}));
}
/**
* Test wiping an account's synced data. Everything should go, but account & empty inbox.
* Also ensures that the remaining account and the remaining inbox have cleared their
* server sync keys, to force refresh eventually.
*/
public void testWipeSyncedData() {
Account account1 = ProviderTestUtils.setupAccount("wipe-synced-1", false, mProviderContext);
account1.mSyncKey = "account-1-sync-key";
account1.save(mProviderContext);
long account1Id = account1.mId;
Mailbox box1 = ProviderTestUtils.setupMailbox("box1", account1Id, false, mProviderContext);
box1.mType = Mailbox.TYPE_INBOX;
box1.mSyncKey = "box-1-sync-key";
box1.save(mProviderContext);
long box1Id = box1.mId;
Mailbox box2 = ProviderTestUtils.setupMailbox("box2", account1Id, true, mProviderContext);
long box2Id = box2.mId;
Account account2 = ProviderTestUtils.setupAccount("wipe-synced-2", false, mProviderContext);
account2.mSyncKey = "account-2-sync-key";
account2.save(mProviderContext);
long account2Id = account2.mId;
Mailbox box3 = ProviderTestUtils.setupMailbox("box3", account2Id, false, mProviderContext);
box3.mSyncKey = "box-3-sync-key";
box3.mType = Mailbox.TYPE_INBOX;
box3.save(mProviderContext);
long box3Id = box3.mId;
Mailbox box4 = ProviderTestUtils.setupMailbox("box4", account2Id, true, mProviderContext);
long box4Id = box4.mId;
// Now populate the 4 non-account boxes with messages
Message message = ProviderTestUtils.setupMessage("message1", account1Id, box1Id, false,
true, mProviderContext);
long message1Id = message.mId;
message = ProviderTestUtils.setupMessage("message2", account1Id, box2Id, false,
true, mProviderContext);
long message2Id = message.mId;
message = ProviderTestUtils.setupMessage("message3", account2Id, box3Id, false,
true, mProviderContext);
long message3Id = message.mId;
message = ProviderTestUtils.setupMessage("message4", account2Id, box4Id, false,
true, mProviderContext);
long message4Id = message.mId;
// Now wipe account 1's data
mTestController.deleteSyncedDataSync(account1Id);
// Confirm: Mailboxes gone (except account box), all messages gone, account survives
assertNull(Mailbox.restoreMailboxWithId(mProviderContext, box1Id));
assertNull(Mailbox.restoreMailboxWithId(mProviderContext, box2Id));
assertNull(Message.restoreMessageWithId(mProviderContext, message1Id));
assertNull(Message.restoreMessageWithId(mProviderContext, message2Id));
account1 = Account.restoreAccountWithId(mProviderContext, account1Id);
assertNotNull(account1);
assertNull(account1.mSyncKey);
// Confirm: Other account survived
assertNotNull(Mailbox.restoreMailboxWithId(mProviderContext, box3Id));
assertNotNull(Mailbox.restoreMailboxWithId(mProviderContext, box4Id));
assertNotNull(Message.restoreMessageWithId(mProviderContext, message3Id));
assertNotNull(Message.restoreMessageWithId(mProviderContext, message4Id));
assertNotNull(Account.restoreAccountWithId(mProviderContext, account2Id));
}
public void testLoadMessageFromUri() throws Exception {
// Create a simple message
Message msg = new Message();
String text = "This is some text";
msg.mText = text;
String sender = "sender@host.com";
msg.mFrom = sender;
// Save this away
msg.save(mProviderContext);
Uri fileUri = ProviderTestUtils.createTempEmlFile(mProviderContext, msg,
mContext.getFilesDir());
// Load the message via Controller and a Uri
Message loadedMsg = mTestController.loadMessageFromUri(fileUri);
// Check server id, mailbox key, account key, and from
assertNotNull(loadedMsg);
assertTrue(loadedMsg.mServerId.startsWith(Controller.ATTACHMENT_MESSAGE_UID_PREFIX));
Mailbox box = mTestController.getAttachmentMailbox();
assertNotNull(box);
assertEquals(box.mId, loadedMsg.mMailboxKey);
assertEquals(0, loadedMsg.mAccountKey);
assertEquals(loadedMsg.mFrom, sender);
// Check body text
String loadedMsgText = Body.restoreBodyTextWithMessageId(mProviderContext, loadedMsg.mId);
assertEquals(text, loadedMsgText);
}
/**
* Create a simple HostAuth with protocol
*/
private HostAuth setupSimpleHostAuth(String protocol) {
HostAuth hostAuth = new HostAuth();
hostAuth.mProtocol = protocol;
return hostAuth;
}
public void testIsMessagingController() {
Account account1 = ProviderTestUtils.setupAccount("account1", false,
mProviderContext);
account1.mHostAuthRecv = setupSimpleHostAuth("eas");
account1.save(mProviderContext);
assertFalse(mTestController.isMessagingController(account1));
Account account2 = ProviderTestUtils.setupAccount("account2", false,
mProviderContext);
account2.mHostAuthRecv = setupSimpleHostAuth("imap");
account2.save(mProviderContext);
assertTrue(mTestController.isMessagingController(account2));
Account account3 = ProviderTestUtils.setupAccount("account3", false,
mProviderContext);
account3.mHostAuthRecv = setupSimpleHostAuth("pop3");
account3.save(mProviderContext);
assertTrue(mTestController.isMessagingController(account3));
Account account4 = ProviderTestUtils.setupAccount("account4", false,
mProviderContext);
account4.mHostAuthRecv = setupSimpleHostAuth("smtp");
account4.save(mProviderContext);
assertFalse(mTestController.isMessagingController(account4));
// There should be values for all of these accounts in the legacy map
assertNotNull(mTestController.mLegacyControllerMap.get(account1.mId));
assertNotNull(mTestController.mLegacyControllerMap.get(account2.mId));
assertNotNull(mTestController.mLegacyControllerMap.get(account3.mId));
assertNotNull(mTestController.mLegacyControllerMap.get(account4.mId));
// The map should have the expected values
assertFalse(mTestController.mLegacyControllerMap.get(account1.mId));
assertTrue(mTestController.mLegacyControllerMap.get(account2.mId));
assertTrue(mTestController.mLegacyControllerMap.get(account3.mId));
assertFalse(mTestController.mLegacyControllerMap.get(account4.mId));
// This second pass should pull values from the cache
assertFalse(mTestController.isMessagingController(account1));
assertTrue(mTestController.isMessagingController(account2));
assertTrue(mTestController.isMessagingController(account3));
assertFalse(mTestController.isMessagingController(account4));
}
/**
* TODO: releasing associated data (e.g. attachments, embedded images)
*/

14
tests/src/com/android/email/DBTestHelper.java
View File

@ -16,12 +16,6 @@
package com.android.email;
import com.android.email.provider.AttachmentProvider;
import com.android.email.provider.ContentCache;
import com.android.email.provider.EmailProvider;
import com.android.emailcommon.provider.EmailContent;
import com.android.emailcommon.utility.AttachmentUtilities;
import android.content.ContentProvider;
import android.content.ContentResolver;
import android.content.ContentValues;
@ -37,6 +31,12 @@ import android.test.mock.MockContentResolver;
import android.test.mock.MockContext;
import android.test.mock.MockCursor;
import com.android.email.provider.AttachmentProvider;
import com.android.email.provider.ContentCache;
import com.android.email.provider.EmailProvider;
import com.android.emailcommon.provider.EmailContent;
import com.android.emailcommon.provider.EmailContent.Attachment;
import java.io.File;
/**
@ -238,7 +238,7 @@ public final class DBTestHelper {
final AttachmentProvider ap = new AttachmentProvider();
ap.attachInfo(providerContext, null);
resolver.addProvider(AttachmentUtilities.AUTHORITY, ap);
resolver.addProvider(Attachment.ATTACHMENT_PROVIDER_LEGACY_URI_PREFIX, ap);
ContentCache.invalidateAllCaches();

181
tests/src/com/android/email/FolderPropertiesTests.java
View File

@ -1,181 +0,0 @@
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email;
import com.android.emailcommon.provider.EmailContent.MailboxColumns;
import com.android.emailcommon.provider.Mailbox;
import android.content.Context;
import android.database.Cursor;
import android.database.MatrixCursor;
import android.graphics.drawable.Drawable;
import android.test.AndroidTestCase;
import java.util.HashSet;
import java.util.Set;
public class FolderPropertiesTests extends AndroidTestCase {
private static Cursor buildCursor(String[] columns, Object... values) {
MatrixCursor c = new MatrixCursorWithCachedColumns(columns, 1);
c.addRow(values);
c.moveToFirst();
return c;
}
/**
* Tests of the syncronization of array and types of the display folder names
*/
public void testGetDisplayName() {
Context context = getContext();
FolderProperties fp = FolderProperties.getInstance(context);
assertEquals(
context.getString(R.string.mailbox_name_display_inbox),
fp.getDisplayName(Mailbox.TYPE_INBOX, 0, "ignored"));
assertEquals(
"*name*",
fp.getDisplayName(Mailbox.TYPE_MAIL, 0, "*name*"));
assertEquals(
"*name2*",
fp.getDisplayName(Mailbox.TYPE_PARENT, 0, "*name2*"));
assertEquals(
context.getString(R.string.mailbox_name_display_drafts),
fp.getDisplayName(Mailbox.TYPE_DRAFTS, 0, "ignored"));
assertEquals(
context.getString(R.string.mailbox_name_display_outbox),
fp.getDisplayName(Mailbox.TYPE_OUTBOX, 0, "ignored"));
assertEquals(
context.getString(R.string.mailbox_name_display_sent),
fp.getDisplayName(Mailbox.TYPE_SENT, 0, "ignored"));
assertEquals(
context.getString(R.string.mailbox_name_display_trash),
fp.getDisplayName(Mailbox.TYPE_TRASH, 0, "ignored"));
assertEquals(
context.getString(R.string.mailbox_name_display_junk),
fp.getDisplayName(Mailbox.TYPE_JUNK, 0, "ignored"));
// Testing illegal index
assertEquals(
"some name",
fp.getDisplayName(8, 12345678890L, "some name"));
// Combined mailboxes
assertEquals(
context.getString(R.string.account_folder_list_summary_inbox),
fp.getDisplayName(0, Mailbox.QUERY_ALL_INBOXES, "ignored"));
assertEquals(
context.getString(R.string.account_folder_list_summary_starred),
fp.getDisplayName(0, Mailbox.QUERY_ALL_FAVORITES, "ignored"));
assertEquals(
context.getString(R.string.account_folder_list_summary_drafts),
fp.getDisplayName(0, Mailbox.QUERY_ALL_DRAFTS, "ignored"));
assertEquals(
context.getString(R.string.account_folder_list_summary_outbox),
fp.getDisplayName(0, Mailbox.QUERY_ALL_OUTBOX, "ignored"));
}
public void testGetDisplayNameWithCursor() {
Context context = getContext();
FolderProperties fp = FolderProperties.getInstance(context);
String[] columns = new String[] {MailboxColumns.ID, MailboxColumns.TYPE,
MailboxColumns.DISPLAY_NAME};
assertEquals(
context.getString(R.string.mailbox_name_display_inbox),
fp.getDisplayName(buildCursor(columns, 1, Mailbox.TYPE_INBOX, "ignored"))
);
assertEquals(
"name",
fp.getDisplayName(buildCursor(columns, 1, Mailbox.TYPE_MAIL, "name"))
);
}
/**
* Confirm that all of the special icons are available and unique
*/
public void testSpecialIcons() {
FolderProperties fp = FolderProperties.getInstance(mContext);
// Make sure they're available
Drawable inbox = fp.getIcon(Mailbox.TYPE_INBOX, -1, 0);
Drawable mail = fp.getIcon(Mailbox.TYPE_MAIL, -1, 0);
Drawable parent = fp.getIcon(Mailbox.TYPE_PARENT, -1, 0);
Drawable drafts = fp.getIcon(Mailbox.TYPE_DRAFTS, -1, 0);
Drawable outbox = fp.getIcon(Mailbox.TYPE_OUTBOX, -1, 0);
Drawable sent = fp.getIcon(Mailbox.TYPE_SENT, -1, 0);
Drawable trash = fp.getIcon(Mailbox.TYPE_TRASH, -1, 0);
Drawable junk = fp.getIcon(Mailbox.TYPE_JUNK, -1, 0);
// Make sure they're unique
Set<Drawable> set = new HashSet<Drawable>();
set.add(inbox);
set.add(parent);
set.add(drafts);
set.add(outbox);
set.add(sent);
set.add(trash);
set.add(junk);
assertEquals(7, set.size());
assertNull(mail);
}
public void testGetMessageCountWithCursor() {
Context context = getContext();
FolderProperties fp = FolderProperties.getInstance(context);
String[] columns = new String[] {MailboxColumns.TYPE, MailboxColumns.UNREAD_COUNT,
MailboxColumns.MESSAGE_COUNT};
assertEquals(
1,
fp.getMessageCount(buildCursor(columns, Mailbox.TYPE_INBOX, 1, 2))
);
assertEquals(
1,
fp.getMessageCount(buildCursor(columns, Mailbox.TYPE_MAIL, 1, 2))
);
assertEquals(
2,
fp.getMessageCount(buildCursor(columns, Mailbox.TYPE_DRAFTS, 1, 2))
);
assertEquals(
2,
fp.getMessageCount(buildCursor(columns, Mailbox.TYPE_OUTBOX, 1, 2))
);
assertEquals(
0,
fp.getMessageCount(buildCursor(columns, Mailbox.TYPE_TRASH, 1, 2))
);
assertEquals(
0,
fp.getMessageCount(buildCursor(columns, Mailbox.TYPE_SENT, 1, 2))
);
}
}

77
tests/src/com/android/email/GroupMessagingListenerUnitTests.java
View File

@ -1,77 +0,0 @@
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email;
import android.test.suitebuilder.annotation.SmallTest;
import junit.framework.TestCase;
/**
* This is a series of unit tests for the GroupMessagingListener class.
*/
@SmallTest
public class GroupMessagingListenerUnitTests extends TestCase {
/**
* Tests adding and removing elements from the listener
*/
public void testAddRemove() {
GroupMessagingListener groupListener = new GroupMessagingListener();
MessagingListener listener1 = new MessagingListener();
MessagingListener listener2 = new MessagingListener();
groupListener.addListener(listener1);
groupListener.addListener(listener2);
groupListener.removeListener(listener1);
groupListener.removeListener(listener2);
}
/**
* Tests isActiveListener()
*/
public void testIsActiveListener() {
GroupMessagingListener groupListener = new GroupMessagingListener();
MessagingListener listener1 = new MessagingListener();
MessagingListener listener2 = new MessagingListener();
assertFalse(groupListener.isActiveListener(listener1));
assertFalse(groupListener.isActiveListener(listener2));
groupListener.addListener(listener1);
assertTrue(groupListener.isActiveListener(listener1));
assertFalse(groupListener.isActiveListener(listener2));
groupListener.addListener(listener2);
assertTrue(groupListener.isActiveListener(listener1));
assertTrue(groupListener.isActiveListener(listener2));
groupListener.removeListener(listener1);
assertFalse(groupListener.isActiveListener(listener1));
assertTrue(groupListener.isActiveListener(listener2));
groupListener.removeListener(listener2);
assertFalse(groupListener.isActiveListener(listener1));
assertFalse(groupListener.isActiveListener(listener2));
}
/**
* TODO: Test that if you add a set of listeners, they will be called
*/
}

17
tests/src/com/android/email/LegacyConversionsTests.java
View File

@ -16,6 +16,12 @@
package com.android.email;
import android.content.ContentUris;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.test.ProviderTestCase2;
import com.android.email.provider.EmailProvider;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.internet.MimeBodyPart;
@ -36,12 +42,7 @@ import com.android.emailcommon.mail.Part;
import com.android.emailcommon.provider.EmailContent;
import com.android.emailcommon.provider.EmailContent.Attachment;
import com.android.emailcommon.utility.ConversionUtilities;
import android.content.ContentUris;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.test.ProviderTestCase2;
import com.android.emailcommon.utility.ConversionUtilities.BodyFieldData;
import java.io.IOException;
import java.util.ArrayList;
@ -410,7 +411,7 @@ public class LegacyConversionsTests extends ProviderTestCase2<EmailProvider> {
/**
* Compare attachment that was converted from Part (expected) to Provider Attachment (actual)
*
*
* TODO content URI should only be set if we also saved a file
* TODO other data encodings
*/
@ -431,7 +432,7 @@ public class LegacyConversionsTests extends ProviderTestCase2<EmailProvider> {
assertEquals(tag, expectedName, actual.mFileName);
// content URI should be null
assertNull(tag, actual.mContentUri);
assertNull(tag, actual.getContentUri());
assertTrue(tag, 0 != actual.mMessageKey);

54
tests/src/com/android/email/MessageListContextTests.java
View File

@ -1,54 +0,0 @@
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email;
import android.os.Parcel;
import android.test.AndroidTestCase;
import com.android.emailcommon.service.SearchParams;
public class MessageListContextTests extends AndroidTestCase {
public void testParcellingMailboxes() {
long accountId = 123;
long mailboxId = 456;
MessageListContext original = MessageListContext.forMailbox(accountId, mailboxId);
Parcel parcel = Parcel.obtain();
original.writeToParcel(parcel, 0);
parcel.setDataPosition(0);
MessageListContext read = MessageListContext.CREATOR.createFromParcel(parcel);
assertEquals(original, read);
parcel.recycle();
}
public void testParcellingSearches() {
long accountId = 123;
long mailboxId = 456;
SearchParams params = new SearchParams(mailboxId, "search terms");
MessageListContext original = MessageListContext.forSearch(accountId, mailboxId, params);
Parcel parcel = Parcel.obtain();
original.writeToParcel(parcel, 0);
parcel.setDataPosition(0);
MessageListContext read = MessageListContext.CREATOR.createFromParcel(parcel);
assertEquals(original, read);
parcel.recycle();
}
}

2
tests/src/com/android/email/MockSharedPreferences.java
View File

@ -16,7 +16,7 @@
package com.android.email;
import com.google.android.collect.Maps;
import com.google.common.collect.Maps;
import android.content.SharedPreferences;

2
tests/src/com/android/email/MockVendorPolicy.java
View File

@ -19,6 +19,8 @@ package com.android.email;
import android.content.Context;
import android.os.Bundle;
import com.android.emailcommon.VendorPolicyLoader;
public class MockVendorPolicy {
public static String passedPolicy;
public static Bundle passedBundle;

171
tests/src/com/android/email/NotificationControllerTest.java
View File

@ -16,17 +16,9 @@
package com.android.email;
import android.app.Notification;
import android.content.Context;
import android.media.AudioManager;
import android.net.Uri;
import android.test.AndroidTestCase;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.EmailContent.Message;
import com.android.emailcommon.provider.Mailbox;
/**
* Test for {@link NotificationController}.
*
@ -42,15 +34,10 @@ public class NotificationControllerTest extends AndroidTestCase {
/**
* Subclass {@link NotificationController} to override un-mockable operations.
*/
private class NotificationControllerForTest extends NotificationController {
protected class NotificationControllerForTest extends NotificationController {
NotificationControllerForTest(Context context) {
super(context, mMockClock);
}
@Override
int getRingerMode() {
return mRingerMode;
}
}
@Override
@ -60,157 +47,7 @@ public class NotificationControllerTest extends AndroidTestCase {
mTarget = new NotificationControllerForTest(mProviderContext);
}
public void testSetupSoundAndVibration() {
final Context c = mProviderContext;
final Account a1 = ProviderTestUtils.setupAccount("a1", true, c);
final Notification.Builder nb = new Notification.Builder(c);
final Uri expectedRingtone = Uri.parse(a1.mRingtoneUri);
Notification n;
// === Ringer mode change ===
mRingerMode = AudioManager.RINGER_MODE_NORMAL;
// VIBRATE, with a ringer tone
a1.mFlags = Account.FLAGS_VIBRATE;
nb.setDefaults(0);
nb.setSound(null);
mTarget.setupSoundAndVibration(nb, a1);
n = nb.getNotification();
assertEquals(expectedRingtone, n.sound);
assertTrue((n.defaults & Notification.DEFAULT_VIBRATE) != 0);
assertTrue((n.flags & Notification.FLAG_SHOW_LIGHTS) != 0); // always set
assertTrue((n.defaults & Notification.DEFAULT_LIGHTS) != 0); // always set
// No VIBRATE flags, with a ringer tone
a1.mFlags = 0;
nb.setDefaults(0);
nb.setSound(null);
mTarget.setupSoundAndVibration(nb, a1);
n = nb.getNotification();
assertEquals(expectedRingtone, n.sound);
assertFalse((n.defaults & Notification.DEFAULT_VIBRATE) != 0); // no vibe
assertTrue((n.flags & Notification.FLAG_SHOW_LIGHTS) != 0); // always set
assertTrue((n.defaults & Notification.DEFAULT_LIGHTS) != 0); // always set
// === Ringer mode change ===
mRingerMode = AudioManager.RINGER_MODE_VIBRATE;
// VIBRATE, with a ringer tone
a1.mFlags = Account.FLAGS_VIBRATE;
nb.setDefaults(0);
nb.setSound(null);
mTarget.setupSoundAndVibration(nb, a1);
n = nb.getNotification();
assertEquals(expectedRingtone, n.sound);
assertTrue((n.defaults & Notification.DEFAULT_VIBRATE) != 0);
assertTrue((n.flags & Notification.FLAG_SHOW_LIGHTS) != 0); // always set
assertTrue((n.defaults & Notification.DEFAULT_LIGHTS) != 0); // always set
// No VIBRATE flags, with a ringer tone
a1.mFlags = 0;
nb.setDefaults(0);
nb.setSound(null);
mTarget.setupSoundAndVibration(nb, a1);
n = nb.getNotification();
assertEquals(expectedRingtone, n.sound);
assertFalse((n.defaults & Notification.DEFAULT_VIBRATE) != 0); // no vibe
assertTrue((n.flags & Notification.FLAG_SHOW_LIGHTS) != 0); // always set
assertTrue((n.defaults & Notification.DEFAULT_LIGHTS) != 0); // always set
// === Ringer mode change ===
mRingerMode = AudioManager.RINGER_MODE_SILENT;
// VIBRATE, with a ringer tone
a1.mFlags = Account.FLAGS_VIBRATE;
nb.setDefaults(0);
nb.setSound(null);
mTarget.setupSoundAndVibration(nb, a1);
n = nb.getNotification();
assertEquals(expectedRingtone, n.sound);
assertTrue((n.defaults & Notification.DEFAULT_VIBRATE) != 0);
assertTrue((n.flags & Notification.FLAG_SHOW_LIGHTS) != 0); // always set
assertTrue((n.defaults & Notification.DEFAULT_LIGHTS) != 0); // always set
// No VIBRATE flags, with a ringer tone
a1.mFlags = 0;
nb.setDefaults(0);
nb.setSound(null);
mTarget.setupSoundAndVibration(nb, a1);
n = nb.getNotification();
assertEquals(expectedRingtone, n.sound);
assertFalse((n.defaults & Notification.DEFAULT_VIBRATE) != 0); // no vibe
assertTrue((n.flags & Notification.FLAG_SHOW_LIGHTS) != 0); // always set
assertTrue((n.defaults & Notification.DEFAULT_LIGHTS) != 0); // always set
// No ringer tone
a1.mRingtoneUri = null;
nb.setDefaults(0);
nb.setSound(null);
mTarget.setupSoundAndVibration(nb, a1);
n = nb.getNotification();
assertNull(n.sound);
}
public void testCreateNewMessageNotification() {
final Context c = mProviderContext;
Notification n;
// Case 1: 1 account, 1 unseen message
Account a1 = ProviderTestUtils.setupAccount("a1", true, c);
Mailbox b1 = ProviderTestUtils.setupMailbox("inbox", a1.mId, true, c, Mailbox.TYPE_INBOX);
Message m1 = ProviderTestUtils.setupMessage("message", a1.mId, b1.mId, true, true, c);
n = mTarget.createNewMessageNotification(a1.mId, b1.mId, m1.mId, 1, 1);
assertEquals(R.drawable.stat_notify_email_generic, n.icon);
assertEquals(mMockClock.mTime, n.when);
assertNotNull(n.largeIcon);
assertEquals(0, n.number);
// TODO Check content -- how?
// Case 2: 1 account, 2 unseen message
n = mTarget.createNewMessageNotification(a1.mId, b1.mId, m1.mId, 2, 2);
assertEquals(R.drawable.stat_notify_email_generic, n.icon);
assertEquals(mMockClock.mTime, n.when);
assertNotNull(n.largeIcon);
assertEquals(2, n.number);
// TODO Check content -- how?
// TODO Add 2 account test, if we find a way to check content
}
public void testCreateNewMessageNotificationWithEmptyFrom() {
final Context c = mProviderContext;
Notification n;
// Message with no from fields.
Account a1 = ProviderTestUtils.setupAccount("a1", true, c);
Mailbox b1 = ProviderTestUtils.setupMailbox("inbox", a1.mId, true, c, Mailbox.TYPE_INBOX);
Message m1 = ProviderTestUtils.setupMessage("message", a1.mId, b1.mId, true, false, c);
m1.mFrom = null;
m1.save(c);
// This shouldn't crash.
n = mTarget.createNewMessageNotification(a1.mId, b1.mId, m1.mId, 1, 1);
// Minimum test for the result
assertEquals(R.drawable.stat_notify_email_generic, n.icon);
}
// the ringtone and vibration flags are depracated and the method that we use
// to test notification has been removed in
// https://googleplex-android-review.googlesource.com/#/c/271237/
}

508
tests/src/com/android/email/RefreshManagerTest.java
View File

@ -1,508 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.Logging;
import com.android.emailcommon.mail.MessagingException;
import com.android.emailcommon.provider.Account;
import android.content.Context;
import android.test.InstrumentationTestCase;
import android.test.suitebuilder.annotation.LargeTest;
import junit.framework.Assert;
@LargeTest
public class RefreshManagerTest extends InstrumentationTestCase {
private static final int WAIT_UNTIL_TIMEOUT_SECONDS = 15;
private MockClock mClock;
private MockController mController;
private RefreshManager mTarget;
private RefreshListener mListener;
private Context mContext;
// Isolated Context for providers.
private Context mProviderContext;
private static final MessagingException EXCEPTION = new MessagingException("test");
// Looks silly, but it'll make it more readable.
private static final long ACCOUNT_1 = 1;
private static final long ACCOUNT_2 = 2;
private static final long MAILBOX_1 = 3;
private static final long MAILBOX_2 = 4;
@Override
protected void setUp() throws Exception {
super.setUp();
mClock = new MockClock();
mContext = getInstrumentation().getTargetContext();
mController = new MockController(mContext);
mListener = new RefreshListener();
mProviderContext = DBTestHelper.ProviderContextSetupHelper.getProviderContext(mContext);
mTarget = new RefreshManager(mProviderContext, mController, mClock, null);
mTarget.registerListener(mListener);
}
@Override
protected void tearDown() throws Exception {
super.tearDown();
mController.cleanupForTest();
}
public void testRegisterUnregisterListener() {
// mListener is already registered
assertEquals(1, mTarget.getListenersForTest().size());
mTarget.unregisterListener(mListener);
assertEquals(0, mTarget.getListenersForTest().size());
}
public void testRefreshStatus() {
RefreshManager.Status s = new RefreshManager.Status();
assertFalse(s.isRefreshing());
assertTrue(s.canRefresh());
assertEquals(0, s.getLastRefreshTime());
// Request refresh
s.onRefreshRequested();
assertTrue(s.isRefreshing());
assertFalse(s.canRefresh());
assertEquals(0, s.getLastRefreshTime());
// Refresh start
s.onCallback(null, 0, mClock);
assertTrue(s.isRefreshing());
assertFalse(s.canRefresh());
assertEquals(0, s.getLastRefreshTime());
// Refresh 50% done -- nothing changes
s.onCallback(null, 50, mClock);
assertTrue(s.isRefreshing());
assertFalse(s.canRefresh());
assertEquals(0, s.getLastRefreshTime());
// Refresh finish
s.onCallback(null, 100, mClock);
assertFalse(s.isRefreshing());
assertTrue(s.canRefresh());
assertEquals(mClock.mTime, s.getLastRefreshTime());
// Refresh start without request
s.onCallback(null, 0, mClock);
assertTrue(s.isRefreshing());
assertFalse(s.canRefresh());
assertEquals(mClock.mTime, s.getLastRefreshTime());
mClock.advance();
// Refresh finish with error.
s.onCallback(EXCEPTION, 0, mClock);
assertFalse(s.isRefreshing());
assertTrue(s.canRefresh());
assertEquals(mClock.mTime, s.getLastRefreshTime());
}
public void testRefreshMailboxList() {
// request refresh for account 1
assertTrue(mTarget.refreshMailboxList(ACCOUNT_1));
assertTrue(mListener.mCalledOnRefreshStatusChanged);
assertFalse(mListener.mCalledOnConnectionError);
assertEquals(ACCOUNT_1, mListener.mAccountId);
assertEquals(-1, mListener.mMailboxId);
mListener.reset();
assertTrue(mController.mCalledUpdateMailboxList);
assertEquals(ACCOUNT_1, mController.mAccountId);
assertEquals(-1, mController.mMailboxId);
mController.reset();
assertTrue(mTarget.isMailboxListRefreshing(ACCOUNT_1));
assertTrue(mTarget.isRefreshingAnyMailboxListForTest());
// Request again -- shouldn't be accepted.
assertFalse(mTarget.refreshMailboxList(ACCOUNT_1));
assertFalse(mListener.mCalledOnRefreshStatusChanged);
assertFalse(mListener.mCalledOnConnectionError);
mListener.reset();
assertFalse(mController.mCalledUpdateMailboxList);
mController.reset();
// request refresh for account 2
assertTrue(mTarget.refreshMailboxList(ACCOUNT_2));
assertTrue(mListener.mCalledOnRefreshStatusChanged);
assertFalse(mListener.mCalledOnConnectionError);
assertEquals(ACCOUNT_2, mListener.mAccountId);
assertEquals(-1, mListener.mMailboxId);
mListener.reset();
assertTrue(mController.mCalledUpdateMailboxList);
assertEquals(ACCOUNT_2, mController.mAccountId);
assertEquals(-1, mController.mMailboxId);
mController.reset();
assertTrue(mTarget.isMailboxListRefreshing(ACCOUNT_2));
assertTrue(mTarget.isRefreshingAnyMailboxListForTest());
// Refreshing for account 1...
mController.mListener.updateMailboxListCallback(null, ACCOUNT_1, 0);
assertTrue(mListener.mCalledOnRefreshStatusChanged);
assertFalse(mListener.mCalledOnConnectionError);
assertEquals(ACCOUNT_1, mListener.mAccountId);
assertEquals(-1, mListener.mMailboxId);
mListener.reset();
assertTrue(mTarget.isMailboxListRefreshing(ACCOUNT_1));
assertEquals(0, mTarget.getMailboxListStatusForTest(ACCOUNT_1).getLastRefreshTime());
// Done.
LogUtils.w(Logging.LOG_TAG, "" + mController.mListener.getClass());
mController.mListener.updateMailboxListCallback(null, ACCOUNT_1, 100);
assertTrue(mListener.mCalledOnRefreshStatusChanged);
assertFalse(mListener.mCalledOnConnectionError);
assertEquals(ACCOUNT_1, mListener.mAccountId);
assertEquals(-1, mListener.mMailboxId);
mListener.reset();
assertFalse(mTarget.isMailboxListRefreshing(ACCOUNT_1));
assertEquals(mClock.mTime, mTarget.getMailboxListStatusForTest(ACCOUNT_1)
.getLastRefreshTime());
// Check "any" method.
assertTrue(mTarget.isRefreshingAnyMailboxListForTest()); // still refreshing account 2
// Refreshing for account 2...
mClock.advance();
mController.mListener.updateMailboxListCallback(null, ACCOUNT_2, 0);
assertTrue(mListener.mCalledOnRefreshStatusChanged);
assertFalse(mListener.mCalledOnConnectionError);
assertEquals(ACCOUNT_2, mListener.mAccountId);
assertEquals(-1, mListener.mMailboxId);
mListener.reset();
assertTrue(mTarget.isMailboxListRefreshing(ACCOUNT_2));
assertEquals(0, mTarget.getMailboxListStatusForTest(ACCOUNT_2).getLastRefreshTime());
// Done with exception.
mController.mListener.updateMailboxListCallback(EXCEPTION, ACCOUNT_2, 0);
assertTrue(mListener.mCalledOnRefreshStatusChanged);
assertTrue(mListener.mCalledOnConnectionError);
assertEquals(ACCOUNT_2, mListener.mAccountId);
assertEquals(-1, mListener.mMailboxId);
assertEquals(MessagingExceptionStrings.getErrorString(mContext, EXCEPTION),
mListener.mMessage);
mListener.reset();
assertFalse(mTarget.isMailboxListRefreshing(ACCOUNT_2));
assertEquals(mClock.mTime, mTarget.getMailboxListStatusForTest(ACCOUNT_2)
.getLastRefreshTime());
// Check "any" method.
assertFalse(mTarget.isRefreshingAnyMailboxListForTest());
}
public void testRefreshMessageList() {
// request refresh mailbox 1
assertTrue(mTarget.refreshMessageList(ACCOUNT_1, MAILBOX_1, false));
assertTrue(mListener.mCalledOnRefreshStatusChanged);
assertFalse(mListener.mCalledOnConnectionError);
assertEquals(ACCOUNT_1, mListener.mAccountId);
assertEquals(MAILBOX_1, mListener.mMailboxId);
mListener.reset();
assertTrue(mController.mCalledUpdateMailbox);
assertEquals(ACCOUNT_1, mController.mAccountId);
assertEquals(MAILBOX_1, mController.mMailboxId);
mController.reset();
assertTrue(mTarget.isMessageListRefreshing(MAILBOX_1));
assertTrue(mTarget.isRefreshingAnyMessageListForTest());
// Request again -- shouldn't be accepted.
assertFalse(mTarget.refreshMessageList(ACCOUNT_1, MAILBOX_1, false));
assertFalse(mListener.mCalledOnRefreshStatusChanged);
assertFalse(mListener.mCalledOnConnectionError);
mListener.reset();
assertFalse(mController.mCalledUpdateMailbox);
mController.reset();
// request refresh mailbox 2
assertTrue(mTarget.refreshMessageList(ACCOUNT_2, MAILBOX_2, false));
assertTrue(mListener.mCalledOnRefreshStatusChanged);
assertFalse(mListener.mCalledOnConnectionError);
assertEquals(ACCOUNT_2, mListener.mAccountId);
assertEquals(MAILBOX_2, mListener.mMailboxId);
mListener.reset();
assertTrue(mController.mCalledUpdateMailbox);
assertEquals(ACCOUNT_2, mController.mAccountId);
assertEquals(MAILBOX_2, mController.mMailboxId);
mController.reset();
assertTrue(mTarget.isMessageListRefreshing(MAILBOX_2));
assertTrue(mTarget.isRefreshingAnyMessageListForTest());
// Refreshing mailbox 1...
mController.mListener.updateMailboxCallback(null, ACCOUNT_1, MAILBOX_1, 0, 0, null);
assertTrue(mListener.mCalledOnRefreshStatusChanged);
assertFalse(mListener.mCalledOnConnectionError);
assertEquals(ACCOUNT_1, mListener.mAccountId);
assertEquals(MAILBOX_1, mListener.mMailboxId);
mListener.reset();
assertTrue(mTarget.isMessageListRefreshing(MAILBOX_1));
assertEquals(0, mTarget.getMessageListStatusForTest(MAILBOX_1).getLastRefreshTime());
// Done.
LogUtils.w(Logging.LOG_TAG, "" + mController.mListener.getClass());
mController.mListener.updateMailboxCallback(null, ACCOUNT_1, MAILBOX_1, 100, 0, null);
assertTrue(mListener.mCalledOnRefreshStatusChanged);
assertFalse(mListener.mCalledOnConnectionError);
assertEquals(ACCOUNT_1, mListener.mAccountId);
assertEquals(MAILBOX_1, mListener.mMailboxId);
mListener.reset();
assertFalse(mTarget.isMessageListRefreshing(MAILBOX_1));
assertEquals(mClock.mTime, mTarget.getMessageListStatusForTest(MAILBOX_1)
.getLastRefreshTime());
// Check "any" method.
assertTrue(mTarget.isRefreshingAnyMessageListForTest()); // still refreshing mailbox 2
// Refreshing mailbox 2...
mClock.advance();
mController.mListener.updateMailboxCallback(null, ACCOUNT_2, MAILBOX_2, 0, 0, null);
assertTrue(mListener.mCalledOnRefreshStatusChanged);
assertFalse(mListener.mCalledOnConnectionError);
assertEquals(ACCOUNT_2, mListener.mAccountId);
assertEquals(MAILBOX_2, mListener.mMailboxId);
mListener.reset();
assertTrue(mTarget.isMessageListRefreshing(MAILBOX_2));
assertEquals(0, mTarget.getMessageListStatusForTest(MAILBOX_2).getLastRefreshTime());
// Done with exception.
mController.mListener.updateMailboxCallback(EXCEPTION, ACCOUNT_2, MAILBOX_2, 0, 0, null);
assertTrue(mListener.mCalledOnRefreshStatusChanged);
assertTrue(mListener.mCalledOnConnectionError);
assertEquals(ACCOUNT_2, mListener.mAccountId);
assertEquals(MAILBOX_2, mListener.mMailboxId);
assertEquals(MessagingExceptionStrings.getErrorString(mContext, EXCEPTION),
mListener.mMessage);
mListener.reset();
assertFalse(mTarget.isMessageListRefreshing(MAILBOX_2));
assertEquals(mClock.mTime, mTarget.getMessageListStatusForTest(MAILBOX_2)
.getLastRefreshTime());
// Check "any" method.
assertFalse(mTarget.isRefreshingAnyMessageListForTest());
}
public void testSendPendingMessages() {
// request sending for account 1
assertTrue(mTarget.sendPendingMessages(ACCOUNT_1));
assertTrue(mListener.mCalledOnRefreshStatusChanged);
assertFalse(mListener.mCalledOnConnectionError);
assertEquals(ACCOUNT_1, mListener.mAccountId);
assertEquals(-1, mListener.mMailboxId);
mListener.reset();
assertTrue(mController.mCalledSendPendingMessages);
assertEquals(ACCOUNT_1, mController.mAccountId);
assertEquals(-1, mController.mMailboxId);
mController.reset();
// request sending for account 2
assertTrue(mTarget.sendPendingMessages(ACCOUNT_2));
assertFalse(mListener.mCalledOnConnectionError);
assertEquals(ACCOUNT_2, mListener.mAccountId);
assertEquals(-1, mListener.mMailboxId);
mListener.reset();
assertTrue(mController.mCalledSendPendingMessages);
assertEquals(ACCOUNT_2, mController.mAccountId);
assertEquals(-1, mController.mMailboxId);
mController.reset();
// Sending start for account 1...
// batch send start. (message id == -1, progress == 0)
mController.mListener.sendMailCallback(null, ACCOUNT_1, -1, 0);
assertFalse(mListener.mCalledOnConnectionError);
mListener.reset();
// Per message callback
mController.mListener.sendMailCallback(null, ACCOUNT_1, 100, 0);
mController.mListener.sendMailCallback(null, ACCOUNT_1, 101, 0);
assertFalse(mListener.mCalledOnConnectionError);
mListener.reset();
// Exception -- first error will be reported.
mController.mListener.sendMailCallback(EXCEPTION, ACCOUNT_1, 102, 0);
assertTrue(mListener.mCalledOnConnectionError);
assertEquals(MessagingExceptionStrings.getErrorString(mContext, EXCEPTION),
mListener.mMessage);
mListener.reset();
// Exception again -- no more error callbacks
mController.mListener.sendMailCallback(null, ACCOUNT_1, 103, 0);
mController.mListener.sendMailCallback(EXCEPTION, ACCOUNT_1, 104, 0);
assertFalse(mListener.mCalledOnConnectionError);
mListener.reset();
// Done.
LogUtils.w(Logging.LOG_TAG, "" + mController.mListener.getClass());
mController.mListener.sendMailCallback(null, ACCOUNT_1, -1, 100);
assertFalse(mListener.mCalledOnConnectionError);
mListener.reset();
}
public void testSendPendingMessagesForAllAccounts() throws Throwable {
Account acct1 = ProviderTestUtils.setupAccount("acct1", true, mProviderContext);
Account acct2 = ProviderTestUtils.setupAccount("acct2", true, mProviderContext);
// AsyncTask needs to be created on the UI thread.
runTestOnUiThread(new Runnable() {
@Override
public void run() {
mTarget.sendPendingMessagesForAllAccounts();
}
});
// sendPendingMessagesForAllAccounts uses Utility.ForEachAccount, which has it's own test,
// so we don't really have to check everything.
// Here, we just check if sendPendingMessages() has been called at least for once,
// which is a enough check.
TestUtils.waitUntil(new TestUtils.Condition() {
@Override
public boolean isMet() {
// The write to this is done on the UI thread, but we're checking it here
// on the test thread, so mCalledSendPendingMessages needs to be volatile.
return mController.mCalledSendPendingMessages;
}
}, WAIT_UNTIL_TIMEOUT_SECONDS);
}
public void testLoadMoreMessages() {
final long ACCOUNT_ID = 123;
final long MAILBOX_ID = 456;
mTarget.loadMoreMessages(ACCOUNT_ID, MAILBOX_ID);
assertTrue(mController.mCalledLoadMoreMessages);
assertEquals(mController.mMailboxId, MAILBOX_ID);
assertFalse(mController.mCalledUpdateMailbox);
}
// volatile is necessary for testSendPendingMessagesForAllAccounts().
// (Not all of them are actually necessary, but added for consistency.)
private static class MockController extends Controller {
public volatile long mAccountId = -1;
public volatile long mMailboxId = -1;
public volatile boolean mCalledSendPendingMessages;
public volatile boolean mCalledUpdateMailbox;
public volatile boolean mCalledUpdateMailboxList;
public volatile boolean mCalledLoadMoreMessages;
public volatile Result mListener;
protected MockController(Context context) {
super(context);
}
public void reset() {
mAccountId = -1;
mMailboxId = -1;
mCalledSendPendingMessages = false;
mCalledUpdateMailbox = false;
mCalledUpdateMailboxList = false;
}
@Override
public void sendPendingMessages(long accountId) {
mCalledSendPendingMessages = true;
mAccountId = accountId;
}
@Override
public void updateMailbox(long accountId, long mailboxId, boolean userRequest) {
mCalledUpdateMailbox = true;
mAccountId = accountId;
mMailboxId = mailboxId;
}
@Override
public void updateMailboxList(long accountId) {
mCalledUpdateMailboxList = true;
mAccountId = accountId;
}
@Override
public void loadMoreMessages(long mailboxId) {
mCalledLoadMoreMessages = true;
mAccountId = -1;
mMailboxId = mailboxId;
}
@Override
public void addResultCallback(Result listener) {
Assert.assertTrue(mListener == null);
mListener = listener;
// Let it call listener.setRegistered(). Otherwise callbacks won't fire.
super.addResultCallback(listener);
}
}
private static class RefreshListener implements RefreshManager.Listener {
public long mAccountId = -1;
public long mMailboxId = -1;
public String mMessage;
public boolean mCalledOnConnectionError;
public boolean mCalledOnRefreshStatusChanged;
public void reset() {
mAccountId = -1;
mMailboxId = -1;
mMessage = null;
mCalledOnConnectionError = false;
mCalledOnRefreshStatusChanged = false;
}
@Override
public void onRefreshStatusChanged(long accountId, long mailboxId) {
mAccountId = accountId;
mMailboxId = mailboxId;
mCalledOnRefreshStatusChanged = true;
}
@Override
public void onMessagingError(long accountId, long mailboxId, String message) {
mAccountId = accountId;
mMailboxId = mailboxId;
mMessage = message;
mCalledOnConnectionError = true;
}
}
}

103
tests/src/com/android/email/SecurityPolicyTests.java
View File

@ -58,7 +58,6 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
mMockContext = new MockContext2(getMockContext(), mContext);
// Invalidate all caches, since we reset the database for each test
ContentCache.invalidateAllCaches();
Controller.getInstance(mMockContext).markForTest(true);
}
/**
@ -66,7 +65,6 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
*/
@Override
protected void tearDown() throws Exception {
Controller.getInstance(mMockContext).markForTest(false);
super.tearDown();
}
@ -142,7 +140,7 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
Account a3 = ProviderTestUtils.setupAccount("sec-3", true, mMockContext);
Policy p3ain = setupPolicy(10, Policy.PASSWORD_MODE_SIMPLE, 0, 0, false, 0, 0, 0,
false, false);
Policy.setAccountPolicy(mMockContext, a3, p3ain, null);
SecurityPolicy.setAccountPolicy(mMockContext, a3, p3ain, null);
Policy p3aout = mSecurityPolicy.computeAggregatePolicy();
assertNotNull(p3aout);
assertEquals(p3ain, p3aout);
@ -150,7 +148,7 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
// Repeat that test with fully-populated policies
Policy p3bin = setupPolicy(10, Policy.PASSWORD_MODE_SIMPLE, 15, 16, false, 6, 2, 3,
false, false);
Policy.setAccountPolicy(mMockContext, a3, p3bin, null);
SecurityPolicy.setAccountPolicy(mMockContext, a3, p3bin, null);
Policy p3bout = mSecurityPolicy.computeAggregatePolicy();
assertNotNull(p3bout);
assertEquals(p3bin, p3bout);
@ -166,7 +164,7 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
Policy p4in = setupPolicy(20, Policy.PASSWORD_MODE_STRONG, 25, 26, false, 0, 5, 7,
false, true);
Account a4 = ProviderTestUtils.setupAccount("sec-4", true, mMockContext);
Policy.setAccountPolicy(mMockContext, a4, p4in, null);
SecurityPolicy.setAccountPolicy(mMockContext, a4, p4in, null);
Policy p4out = mSecurityPolicy.computeAggregatePolicy();
assertNotNull(p4out);
assertEquals(20, p4out.mPasswordMinLength);
@ -192,7 +190,7 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
Policy p5in = setupPolicy(4, Policy.PASSWORD_MODE_SIMPLE, 5, 6, true, 1, 0, 0,
true, false);
Account a5 = ProviderTestUtils.setupAccount("sec-5", true, mMockContext);
Policy.setAccountPolicy(mMockContext, a5, p5in, null);
SecurityPolicy.setAccountPolicy(mMockContext, a5, p5in, null);
Policy p5out = mSecurityPolicy.computeAggregatePolicy();
assertNotNull(p5out);
assertEquals(20, p5out.mPasswordMinLength);
@ -236,17 +234,17 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
long accountId = account.mId;
Policy initial = setupPolicy(10, Policy.PASSWORD_MODE_SIMPLE, 0, 0, false, 0, 0, 0,
false, false);
Policy.setAccountPolicy(mMockContext, accountId, initial, null);
SecurityPolicy.setAccountPolicy(mMockContext, account, initial, null);
long oldKey = assertAccountPolicyConsistent(account.mId, 0);
Policy updated = setupPolicy(10, Policy.PASSWORD_MODE_SIMPLE, 0, 0, false, 0, 0, 0,
false, false);
Policy.setAccountPolicy(mMockContext, accountId, updated, null);
SecurityPolicy.setAccountPolicy(mMockContext, account, updated, null);
oldKey = assertAccountPolicyConsistent(account.mId, oldKey);
// Remove the policy
Policy.clearAccountPolicy(
SecurityPolicy.clearAccountPolicy(
mMockContext, Account.restoreAccountWithId(mMockContext, accountId));
assertNull("old policy not cleaned up",
Policy.restorePolicyWithId(mMockContext, oldKey));
@ -275,28 +273,21 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
* Test the API to set/clear policy hold flags in an account
*/
public void testSetClearHoldFlag() {
Account a1 = ProviderTestUtils.setupAccount("holdflag-1", false, mMockContext);
a1.mFlags = Account.FLAGS_NOTIFY_NEW_MAIL;
a1.save(mMockContext);
Account a2 = ProviderTestUtils.setupAccount("holdflag-2", false, mMockContext);
a2.mFlags = Account.FLAGS_VIBRATE_ALWAYS | Account.FLAGS_SECURITY_HOLD;
a2.mFlags = Account.FLAGS_SYNC_DISABLED | Account.FLAGS_SECURITY_HOLD;
a2.save(mMockContext);
// confirm clear until set
Account a1a = Account.restoreAccountWithId(mMockContext, a1.mId);
assertEquals(Account.FLAGS_NOTIFY_NEW_MAIL, a1a.mFlags);
SecurityPolicy.setAccountHoldFlag(mMockContext, a1, true);
assertEquals(Account.FLAGS_NOTIFY_NEW_MAIL | Account.FLAGS_SECURITY_HOLD, a1.mFlags);
Account a1b = Account.restoreAccountWithId(mMockContext, a1.mId);
assertEquals(Account.FLAGS_NOTIFY_NEW_MAIL | Account.FLAGS_SECURITY_HOLD, a1b.mFlags);
// confirm set until cleared
Account a2a = Account.restoreAccountWithId(mMockContext, a2.mId);
assertEquals(Account.FLAGS_VIBRATE_ALWAYS | Account.FLAGS_SECURITY_HOLD, a2a.mFlags);
assertEquals(Account.FLAGS_SYNC_DISABLED | Account.FLAGS_SECURITY_HOLD, a2a.mFlags);
// set account hold flag off
SecurityPolicy.setAccountHoldFlag(mMockContext, a2, false);
assertEquals(Account.FLAGS_VIBRATE_ALWAYS, a2.mFlags);
assertEquals(Account.FLAGS_SYNC_DISABLED, a2.mFlags);
// confirm account hold flag set
Account a2b = Account.restoreAccountWithId(mMockContext, a2.mId);
assertEquals(Account.FLAGS_VIBRATE_ALWAYS, a2b.mFlags);
assertEquals(Account.FLAGS_SYNC_DISABLED, a2b.mFlags);
}
/**
@ -306,15 +297,15 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
Account a1 = ProviderTestUtils.setupAccount("disable-1", true, mMockContext);
Policy p1 = setupPolicy(10, Policy.PASSWORD_MODE_SIMPLE, 0, 0, false, 0, 0, 0,
false, false);
Policy.setAccountPolicy(mMockContext, a1, p1, "security-sync-key-1");
SecurityPolicy.setAccountPolicy(mMockContext, a1, p1, "security-sync-key-1");
Account a2 = ProviderTestUtils.setupAccount("disable-2", true, mMockContext);
Policy p2 = setupPolicy(20, Policy.PASSWORD_MODE_STRONG, 25, 26, false, 0, 0, 0,
false, false);
Policy.setAccountPolicy(mMockContext, a2, p2, "security-sync-key-2");
SecurityPolicy.setAccountPolicy(mMockContext, a2, p2, "security-sync-key-2");
Account a3 = ProviderTestUtils.setupAccount("disable-3", true, mMockContext);
Policy.clearAccountPolicy(mMockContext, a3);
SecurityPolicy.clearAccountPolicy(mMockContext, a3);
mSecurityPolicy = SecurityPolicy.getInstance(mMockContext);
@ -359,7 +350,7 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
ProviderTestUtils.setupAccount("expiring-2", true, mMockContext);
Policy p2 = setupPolicy(20, Policy.PASSWORD_MODE_STRONG, 25, 26, false, 30, 0, 0,
false, true);
Policy.setAccountPolicy(mMockContext, a2, p2, null);
SecurityPolicy.setAccountPolicy(mMockContext, a2, p2, null);
// The expiring account should be returned
nextExpiringAccountId = SecurityPolicy.findShortestExpiration(mMockContext);
@ -369,7 +360,7 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
Account a3 = ProviderTestUtils.setupAccount("expiring-3", true, mMockContext);
Policy p3 = setupPolicy(20, Policy.PASSWORD_MODE_STRONG, 25, 26, false, 60, 0, 0,
false, true);
Policy.setAccountPolicy(mMockContext, a3, p3, null);
SecurityPolicy.setAccountPolicy(mMockContext, a3, p3, null);
// The original expiring account (a2) should be returned
nextExpiringAccountId = SecurityPolicy.findShortestExpiration(mMockContext);
@ -379,37 +370,25 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
Account a4 = ProviderTestUtils.setupAccount("expiring-4", true, mMockContext);
Policy p4 = setupPolicy(20, Policy.PASSWORD_MODE_STRONG, 25, 26, false, 15, 0, 0,
false, true);
Policy.setAccountPolicy(mMockContext, a4, p4, null);
SecurityPolicy.setAccountPolicy(mMockContext, a4, p4, null);
// The new expiring account (a4) should be returned
nextExpiringAccountId = SecurityPolicy.findShortestExpiration(mMockContext);
assertEquals(a4.mId, nextExpiringAccountId);
}
/**
* Lightweight subclass of the Controller class allows injection of mock context
*/
public static class TestController extends Controller {
protected TestController(Context providerContext, Context systemContext) {
super(systemContext);
setProviderContext(providerContext);
markForTest(true);
}
}
/**
* Test the scanner that wipes expiring accounts
*/
public void testWipeExpiringAccounts() {
mSecurityPolicy = SecurityPolicy.getInstance(mMockContext);
TestController testController = new TestController(mMockContext, getContext());
// Two accounts - a1 is normal, a2 has security (but no expiration)
Account a1 = ProviderTestUtils.setupAccount("expired-1", true, mMockContext);
Account a2 = ProviderTestUtils.setupAccount("expired-2", true, mMockContext);
Policy p2 = setupPolicy(20, Policy.PASSWORD_MODE_STRONG, 25, 26, false, 0, 0, 0,
false, true);
Policy.setAccountPolicy(mMockContext, a2, p2, null);
SecurityPolicy.setAccountPolicy(mMockContext, a2, p2, null);
// Add a mailbox & messages to each account
long account1Id = a1.mId;
@ -424,7 +403,7 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
ProviderTestUtils.setupMessage("message4", account2Id, box2Id, false, true, mMockContext);
// Run the expiration code - should do nothing
boolean wiped = SecurityPolicy.wipeExpiredAccounts(mMockContext, testController);
boolean wiped = SecurityPolicy.wipeExpiredAccounts(mMockContext);
assertFalse(wiped);
// check mailboxes & messages not wiped
assertEquals(2, EmailContent.count(mMockContext, Account.CONTENT_URI));
@ -435,7 +414,7 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
Account a3 = ProviderTestUtils.setupAccount("expired-3", true, mMockContext);
Policy p3 = setupPolicy(20, Policy.PASSWORD_MODE_STRONG, 25, 26, false, 30, 0, 0,
false, true);
Policy.setAccountPolicy(mMockContext, a3, p3, null);
SecurityPolicy.setAccountPolicy(mMockContext, a3, p3, null);
// Add mailbox & messages to 3rd account
long account3Id = a3.mId;
@ -450,7 +429,7 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
assertEquals(6, EmailContent.count(mMockContext, Message.CONTENT_URI));
// Run the expiration code - wipe acct #3
wiped = SecurityPolicy.wipeExpiredAccounts(mMockContext, testController);
wiped = SecurityPolicy.wipeExpiredAccounts(mMockContext);
assertTrue(wiped);
// check new counts - account survives but data is wiped
assertEquals(3, EmailContent.count(mMockContext, Account.CONTENT_URI));
@ -466,38 +445,6 @@ public class SecurityPolicyTests extends ProviderTestCase2<EmailProvider> {
assertEquals(Account.FLAGS_SECURITY_HOLD, account.mFlags & Account.FLAGS_SECURITY_HOLD);
}
/**
* Test the code that clears unsupported policies
* TODO inject a mock DPM so we can directly control & test all cases, no matter what device
*/
public void testClearUnsupportedPolicies() {
Policy p1 =
setupPolicy(1, Policy.PASSWORD_MODE_STRONG, 3, 4, true, 7, 8, 9, false, false);
Policy p2 =
setupPolicy(1, Policy.PASSWORD_MODE_STRONG, 3, 4, true, 7, 8, 9, true, false);
mSecurityPolicy = SecurityPolicy.getInstance(mMockContext);
DevicePolicyManager dpm = mSecurityPolicy.getDPM();
boolean hasEncryption =
dpm.getStorageEncryptionStatus() != DevicePolicyManager.ENCRYPTION_STATUS_UNSUPPORTED;
Policy p1Result = mSecurityPolicy.clearUnsupportedPolicies(p1);
Policy p2Result = mSecurityPolicy.clearUnsupportedPolicies(p2);
// No changes expected when encryptionRequested was false
assertEquals(p1, p1Result);
if (hasEncryption) {
// No changes expected
assertEquals(p2, p2Result);
} else {
// If encryption is unsupported, encryption policy bits are cleared
Policy policyExpect =
setupPolicy(1, Policy.PASSWORD_MODE_STRONG, 3, 4, true, 7, 8, 9, false,
false);
assertEquals(policyExpect, p2Result);
}
}
/**
* Test the code that converts from exchange-style quality to DPM/Lockscreen style quality.
*/

16
tests/src/com/android/email/SingleRunningTaskTest.java
View File

@ -25,7 +25,7 @@ import junit.framework.TestCase;
public class SingleRunningTaskTest extends TestCase {
private static class NormalTask extends SingleRunningTask<Void> {
/*private static class NormalTask extends SingleRunningTask<Void> {
// # of times the task has actually run.
public final AtomicInteger mCalledCount = new AtomicInteger(0);
@ -71,12 +71,12 @@ public class SingleRunningTaskTest extends TestCase {
protected void runInternal(Void param) {
throw new RuntimeException("Intentional exception");
}
}
}*/
/**
* Run 3 tasks sequentially.
*/
public void testSequential() {
/*public void testSequential() {
final NormalTask e = new NormalTask();
e.run(null);
@ -84,12 +84,12 @@ public class SingleRunningTaskTest extends TestCase {
e.run(null);
assertEquals(3, e.mCalledCount.get());
}
}*/
/**
* Run 2 tasks in parallel, and then another call.
*/
public void testParallel() {
/*public void testParallel() {
final NormalTask e = new NormalTask();
// Block the first task
@ -133,12 +133,12 @@ public class SingleRunningTaskTest extends TestCase {
e.run(null);
assertEquals(2, e.mCalledCount.get());
}
}*/
/**
* If a task throws, isRunning should become false.
*/
public void testException() {
/*public void testException() {
final FailTask e = new FailTask();
try {
@ -147,5 +147,5 @@ public class SingleRunningTaskTest extends TestCase {
} catch (RuntimeException expected) {
}
assertFalse(e.isRunningForTest());
}
}*/
}

5
tests/src/com/android/email/TestUtils.java
View File

@ -16,8 +16,6 @@
package com.android.email;
import com.android.emailcommon.Logging;
import android.app.KeyguardManager;
import android.content.Context;
import android.os.PowerManager;
@ -26,6 +24,9 @@ import android.test.suitebuilder.annotation.LargeTest;
import android.view.View;
import android.view.ViewParent;
import com.android.emailcommon.Logging;
import com.android.mail.utils.LogUtils;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;

1
tests/src/com/android/email/ThrottleTest.java
View File

@ -21,6 +21,7 @@ import android.os.Message;
import android.test.AndroidTestCase;
import com.android.mail.utils.Clock;
import com.android.mail.utils.Throttle;
import java.util.Timer;
import java.util.TimerTask;

5
tests/src/com/android/email/VendorPolicyLoaderTest.java
View File

@ -16,12 +16,13 @@
package com.android.email;
import com.android.email.activity.setup.AccountSettingsUtils.Provider;
import android.content.Context;
import android.os.Bundle;
import android.test.AndroidTestCase;
import com.android.emailcommon.VendorPolicyLoader;
import com.android.emailcommon.VendorPolicyLoader.Provider;
public class VendorPolicyLoaderTest extends AndroidTestCase {
private String mTestApkPackageName;

185
tests/src/com/android/email/activity/AccountSelectorAdapterTest.java
View File

@ -1,185 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email.activity;
import com.android.email.DBTestHelper;
import com.android.email.FolderProperties;
import com.android.email.R;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.Mailbox;
import android.content.Context;
import android.content.Loader;
import android.database.Cursor;
import android.database.MatrixCursor;
import android.test.LoaderTestCase;
/**
* Tests for {@link AccountSelectorAdapter.AccountsLoader}.
*
* TODO add more tests.
*/
public class AccountSelectorAdapterTest extends LoaderTestCase {
private Context mProviderContext;
@Override
protected void setUp() throws Exception {
super.setUp();
mProviderContext = DBTestHelper.ProviderContextSetupHelper.getProviderContext(mContext);
}
/**
* - Confirm that AccountsLoader adds the combined view row, iif there is more than 1 account.
* - Confirm that AccountsLoader doesn't add recent mailboxes.
*
* two-pane version.
*
* TODO add one-pane version
*/
public void testCombinedViewRow_twoPane() {
final Account a1 = ProviderTestUtils.setupAccount("a1", true, mProviderContext);
{
// Only 1 account -- no combined view row.
Loader<Cursor> l = new AccountSelectorAdapter.AccountsLoader(mProviderContext, 0L,
0L, true);
AccountSelectorAdapter.CursorWithExtras result =
(AccountSelectorAdapter.CursorWithExtras) getLoaderResultSynchronously(l);
assertEquals(1, result.getAccountCount());
assertEquals(2, result.getCount()); // +1 as the cursor has the header row
assertEquals(0, result.getRecentMailboxCount()); // No recent on two-pane.
}
final Account a2 = ProviderTestUtils.setupAccount("a2", true, mProviderContext);
{
// 2 accounts -- with combined view row, so returns 3 account rows.
Loader<Cursor> l = new AccountSelectorAdapter.AccountsLoader(mProviderContext, 0L,
0L, true);
AccountSelectorAdapter.CursorWithExtras result =
(AccountSelectorAdapter.CursorWithExtras) getLoaderResultSynchronously(l);
assertEquals(3, result.getAccountCount());
assertEquals(4, result.getCount()); // +1 as the cursor has the header row
assertEquals(0, result.getRecentMailboxCount()); // No recent on two-pane.
}
}
private static AccountSelectorAdapter.CursorWithExtras createCursorWithExtras() {
final MatrixCursor m = new MatrixCursorWithCachedColumns(new String[] {"column"});
return new AccountSelectorAdapter.CursorWithExtras(m.getColumnNames(), m);
}
public void testCursorWithExtras_setAccountMailboxInfo() {
final Context context = mProviderContext;
final Account a1 = ProviderTestUtils.setupAccount("a1", true, context);
final Account a2 = ProviderTestUtils.setupAccount("a2", true, context);
final Mailbox m1 = ProviderTestUtils.setupMailbox("Inbox", a1.mId, true, context,
Mailbox.TYPE_INBOX);
final Mailbox m2 = ProviderTestUtils.setupMailbox("box2", a2.mId, true, context,
Mailbox.TYPE_MAIL);
addMessage(m1, true, false);
addMessage(m2, false, false);
addMessage(m2, false, false);
addMessage(m2, true, true);
// Account 1 - no mailbox
AccountSelectorAdapter.CursorWithExtras c = createCursorWithExtras();
c.setAccountMailboxInfo(context, a1.mId, Mailbox.NO_MAILBOX);
assertTrue(c.accountExists());
assertEquals(a1.mId, c.getAccountId());
assertEquals("a1", c.getAccountDisplayName());
assertEquals(Mailbox.NO_MAILBOX, c.getMailboxId());
assertNull(c.getMailboxDisplayName());
assertEquals(0, c.getMailboxMessageCount());
// Account 1 - inbox
c = createCursorWithExtras();
c.setAccountMailboxInfo(context, a1.mId, m1.mId);
assertTrue(c.accountExists());
assertEquals(a1.mId, c.getAccountId());
assertEquals("a1", c.getAccountDisplayName());
assertEquals(m1.mId, c.getMailboxId());
assertEquals("Inbox", c.getMailboxDisplayName());
assertEquals(1, c.getMailboxMessageCount());
// Account 2 - regular mailbox
c = createCursorWithExtras();
c.setAccountMailboxInfo(context, a2.mId, m2.mId);
assertTrue(c.accountExists());
assertEquals(a2.mId, c.getAccountId());
assertEquals("a2", c.getAccountDisplayName());
assertEquals(m2.mId, c.getMailboxId());
assertEquals("box2", c.getMailboxDisplayName());
assertEquals(2, c.getMailboxMessageCount());
// combined - no mailbox
c = createCursorWithExtras();
c.setAccountMailboxInfo(context, Account.ACCOUNT_ID_COMBINED_VIEW, Mailbox.NO_MAILBOX);
assertTrue(c.accountExists());
assertEquals(Account.ACCOUNT_ID_COMBINED_VIEW, c.getAccountId());
assertEquals(getContext().getString(R.string.mailbox_list_account_selector_combined_view),
c.getAccountDisplayName());
assertEquals(Mailbox.NO_MAILBOX, c.getMailboxId());
assertNull(c.getMailboxDisplayName());
assertEquals(0, c.getMailboxMessageCount());
// combined - all inbox
c = createCursorWithExtras();
c.setAccountMailboxInfo(context, Account.ACCOUNT_ID_COMBINED_VIEW,
Mailbox.QUERY_ALL_INBOXES);
assertTrue(c.accountExists());
assertEquals(Account.ACCOUNT_ID_COMBINED_VIEW, c.getAccountId());
assertEquals(getContext().getString(R.string.mailbox_list_account_selector_combined_view),
c.getAccountDisplayName());
assertEquals(Mailbox.QUERY_ALL_INBOXES, c.getMailboxId());
assertEquals(getContext().getString(R.string.account_folder_list_summary_inbox),
c.getMailboxDisplayName());
// (message count = 1, because account 2 doesn't have inbox)
// TODO For some reason getMailboxMessageCount returns 0 in tests. Investigate it.
// assertEquals(1, c.getMailboxMessageCount());
// Account 1 - all starred
// Special case; it happens when you open "starred" on a normal account's mailbox list
// on two-pane.
c = createCursorWithExtras();
c.setAccountMailboxInfo(context, a1.mId, Mailbox.QUERY_ALL_FAVORITES);
assertTrue(c.accountExists());
assertEquals(a1.mId, c.getAccountId());
assertEquals("a1", c.getAccountDisplayName());
assertEquals(Mailbox.QUERY_ALL_FAVORITES, c.getMailboxId());
assertEquals(getContext().getString(R.string.account_folder_list_summary_starred),
c.getMailboxDisplayName());
// assertEquals(2, c.getMailboxMessageCount());
// Invalid id
c = createCursorWithExtras();
c.setAccountMailboxInfo(context, 123456, 1232456); // no such account / mailbox
assertFalse(c.accountExists());
}
private void addMessage(Mailbox m, boolean starred, boolean read) {
ProviderTestUtils.setupMessage("a", m.mAccountKey, m.mId, false, true, mProviderContext,
starred, read);
}
}

315
tests/src/com/android/email/activity/FindParentMailboxTaskTest.java
View File

@ -1,315 +0,0 @@
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email.activity;
import com.android.email.DBTestHelper;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.Mailbox;
import android.content.Context;
import android.test.AndroidTestCase;
/**
* Unit tests for {@link MailboxListFragment.FindParentMailboxTask}.
*/
public class FindParentMailboxTaskTest extends AndroidTestCase {
private Context mProviderContext;
/** ID of the account created by {@link #setUpMailboxes}. */
private long mAccountId;
/**
* IDs for the mailboxes created by {@link #setUpMailboxes}.
*
* Mailbox hierarchy:
* <pre>
* |-Inbox
* |-Parent
* |-Child1
* |-Child2
* |-GrandChild1
* |-GrandChild2
* </pre>
*/
private long mIdInbox;
private long mIdParent;
private long mIdChild1;
private long mIdChild2;
private long mIdGrandChild1;
private long mIdGrandChild2;
@Override
protected void setUp() throws Exception {
super.setUp();
mProviderContext = DBTestHelper.ProviderContextSetupHelper.getProviderContext(
getContext());
setUpMailboxes();
}
/**
* Set up a test account and mailboxes.
*/
private void setUpMailboxes() {
Account a = ProviderTestUtils.setupAccount("a", true, mProviderContext);
mAccountId = a.mId;
mIdInbox = createMailboxAndGetId("Inbox", a, Mailbox.TYPE_INBOX, Mailbox.NO_MAILBOX);
mIdParent = createMailboxAndGetId("P", a, Mailbox.TYPE_MAIL, Mailbox.NO_MAILBOX);
mIdChild1 = createMailboxAndGetId("C1", a, Mailbox.TYPE_MAIL, mIdParent);
mIdChild2 = createMailboxAndGetId("C2", a, Mailbox.TYPE_MAIL, mIdParent);
mIdGrandChild1 = createMailboxAndGetId("G1", a, Mailbox.TYPE_MAIL, mIdChild2);
mIdGrandChild2 = createMailboxAndGetId("G2", a, Mailbox.TYPE_MAIL, mIdChild2);
}
private long createMailboxAndGetId(String name, Account account, int type,
long parentMailboxId) {
Mailbox m = ProviderTestUtils.setupMailbox(name, account.mId, false, mProviderContext,
type);
m.mParentKey = parentMailboxId;
m.save(mProviderContext);
return m.mId;
}
/**
* Tests for two-pane. (highlighting is enabled)
*/
public void testWithHighlight() {
/*
* In the comments below, [MAILBOX] indicates "highlighted", and MAILBOX* indicates
* "selected".
*/
/*
* from:
* - [Child2]
* - GChild1
* - GChild2
*
* to:
* - Parent
* - Child1
* - [Child2]*
*/
doCheckWithHighlight(
mIdChild2, // Current parent
mIdChild2, // Current highlighted
mIdParent, // Next root
mIdChild2, // Next highlighted
mIdChild2 // Next selected
);
/*
* from:
* - Child2
* - [GChild1]
* - GChild2
*
* to:
* - [Parent]*
* - Child1
* - Child2
*/
doCheckWithHighlight(
mIdChild2, // Current parent
mIdGrandChild1, // Current highlighted
mIdParent, // Next root
mIdParent, // Next highlighted
mIdParent // Next selected
);
/*
* from:
* - [Parent]
* - Child1
* - Child2
*
* to:
* - Inbox
* - [Parent]*
*/
doCheckWithHighlight(
mIdParent, // Current parent
mIdParent, // Current highlighted
Mailbox.NO_MAILBOX, // Next root
mIdParent, // Next highlighted
mIdParent // Next selected
);
/*
* from:
* - Parent
* - [Child1]
* - Child2
*
* to:
* - [Inbox]*
* - Parent
*/
doCheckWithHighlight(
mIdParent, // Current parent
mIdChild1, // Current highlighted
Mailbox.NO_MAILBOX, // Next root
mIdInbox, // Next highlighted
mIdInbox // Next selected
);
/*
* Special case.
* Up from root view, with "Parent" highlighted. "Up" will be disabled in this case, but
* if we were to run the task, it'd work as if the current parent mailbox is gone.
* i.e. just show the top level mailboxes, with Inbox highlighted.
*
* from:
* - Inbox
* - [Parent]
*
* to:
* - [Inbox]
* - Parent
*/
doCheckWithHighlight(
Mailbox.NO_MAILBOX, // Current parent
mIdParent, // Current highlighted
Mailbox.NO_MAILBOX, // Next root
mIdInbox, // Next highlighted
mIdInbox // Next selected
);
/*
* Special case.
* Current parent mailbox is gone. The result should be same as the above.
*
* from:
* (current mailbox just removed)
*
* to:
* - [Inbox]
* - Parent
*/
doCheckWithHighlight(
12312234234L, // Current parent
mIdParent, // Current highlighted
Mailbox.NO_MAILBOX, // Next root
mIdInbox, // Next highlighted
mIdInbox // Next selected
);
}
private void doCheckWithHighlight(
long parentMailboxId, long highlightedMailboxId,
long expectedNextParent, long expectedNextHighlighted, long expectedNextSelected) {
doCheck(true, parentMailboxId, highlightedMailboxId,
expectedNextParent, expectedNextHighlighted, expectedNextSelected);
}
/**
* Tests for one-pane. (highlighting is disable)
*/
public void testWithNoHighlight() {
/*
* from:
* - Child2
* - GChild1
* - GChild2
*
* to:
* - Parent
* - Child1
* - Child2
*/
doCheckWithNoHighlight(
mIdChild2, // Current parent
mIdParent // Next root
);
/*
* from:
* - Parent
* - Child1
* - Child2
*
* to:
* - Inbox
* - Parent
*/
doCheckWithNoHighlight(
mIdParent, // Current parent
Mailbox.NO_MAILBOX // Next root
);
/*
* Special case.
* Current parent mailbox is gone. The top-level mailboxes should be shown.
*
* from:
* (current mailbox just removed)
*
* to:
* - Inbox
* - Parent
*/
doCheckWithNoHighlight(
12312234234L, // Current parent
Mailbox.NO_MAILBOX // Next root
);
}
private void doCheckWithNoHighlight(long parentMailboxId, long expectedNextParent) {
doCheck(false, parentMailboxId, Mailbox.NO_MAILBOX,
expectedNextParent, Mailbox.NO_MAILBOX,
expectedNextParent /* parent should always be selected */);
}
private void doCheck(boolean enableHighlight,
long parentMailboxId, long highlightedMailboxId,
long expectedNextParent, long expectedNextHighlighted, long expectedNextSelected) {
ResultCallback result = new ResultCallback();
MailboxListFragment.FindParentMailboxTask task
= new MailboxListFragment.FindParentMailboxTask(
mProviderContext, null, mAccountId, enableHighlight, parentMailboxId,
highlightedMailboxId, result);
// Can't execute an async task on the test thread, so emulate execution...
task.onSuccess(task.doInBackground((Void[]) null));
assertEquals("parent", expectedNextParent, result.mNextParentMailboxId);
assertEquals("highlighted", expectedNextHighlighted, result.mNextHighlightedMailboxId);
assertEquals("selected", expectedNextSelected, result.mNextSelectedMailboxId);
}
private static class ResultCallback
implements MailboxListFragment.FindParentMailboxTask.ResultCallback {
public long mNextParentMailboxId;
public long mNextHighlightedMailboxId;
public long mNextSelectedMailboxId;
@Override
public void onResult(long nextParentMailboxId, long nextHighlightedMailboxId,
long nextSelectedMailboxId) {
mNextParentMailboxId = nextParentMailboxId;
mNextHighlightedMailboxId = nextHighlightedMailboxId;
mNextSelectedMailboxId = nextSelectedMailboxId;
}
}
}

454
tests/src/com/android/email/activity/MailboxFinderTest.java
View File

@ -1,454 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email.activity;
import android.content.Context;
import android.test.InstrumentationTestCase;
import android.test.ProviderTestCase2;
import android.test.suitebuilder.annotation.LargeTest;
import com.android.email.Controller;
import com.android.email.DBTestHelper;
import com.android.email.Email;
import com.android.email.TestUtils;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.mail.MessagingException;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.Mailbox;
/**
* Test case for {@link MailboxFinder}.
*
* We need to use {@link InstrumentationTestCase} so that we can create AsyncTasks on the UI thread
* using {@link InstrumentationTestCase#runTestOnUiThread}. This class also needs an isolated
* context, which is provided by {@link ProviderTestCase2}. We can't derive from two classes,
* so we just copy the code for an isolate context to here.
*/
@LargeTest
public class MailboxFinderTest extends InstrumentationTestCase {
private static final int TIMEOUT = 10; // in seconds
// Test target
private MailboxFinder mMailboxFinder;
// Isolted Context for providers.
private Context mProviderContext;
// Mock to track callback invocations.
private MockController mMockController;
private MockCallback mCallback;
private Context getContext() {
return getInstrumentation().getTargetContext();
}
@Override
protected void setUp() throws Exception {
super.setUp();
mProviderContext = DBTestHelper.ProviderContextSetupHelper.getProviderContext(
getInstrumentation().getTargetContext());
mCallback = new MockCallback();
mMockController = new MockController(getContext());
Controller.injectMockControllerForTest(mMockController);
assertEquals(0, mMockController.getResultCallbacksForTest().size());
}
@Override
protected void tearDown() throws Exception {
super.tearDown();
if (mMailboxFinder != null) {
mMailboxFinder.cancel();
// MailboxFinder should unregister its listener when closed.
checkControllerResultRemoved(mMockController);
}
mMockController.cleanupForTest();
Controller.injectMockControllerForTest(null);
}
/**
* Make sure no {@link MailboxFinder.Callback} is left registered to the controller.
*/
private static void checkControllerResultRemoved(Controller controller) {
for (Controller.Result callback : controller.getResultCallbacksForTest()) {
assertFalse(callback instanceof MailboxFinder.Callback);
}
}
/**
* Create an account and returns the ID.
*/
private long createAccount(boolean securityHold) {
Account acct = ProviderTestUtils.setupAccount("acct1", false, mProviderContext);
if (securityHold) {
acct.mFlags |= Account.FLAGS_SECURITY_HOLD;
}
acct.save(mProviderContext);
return acct.mId;
}
/**
* Create a mailbox and return the ID.
*/
private long createMailbox(long accountId, int mailboxType) {
Mailbox box = new Mailbox();
box.mServerId = box.mDisplayName = "mailbox";
box.mAccountKey = accountId;
box.mType = mailboxType;
box.mFlagVisible = true;
box.mVisibleLimit = Email.VISIBLE_LIMIT_DEFAULT;
box.save(mProviderContext);
return box.mId;
}
/**
* Create a {@link MailboxFinder} and kick it.
*/
private void createAndStartFinder(final long accountId, final int mailboxType)
throws Throwable {
runTestOnUiThread(new Runnable() {
@Override
public void run() {
mMailboxFinder = new MailboxFinder(mProviderContext, accountId, mailboxType,
mCallback);
mMailboxFinder.startLookup();
assertTrue(mMailboxFinder.isStartedForTest());
}
});
}
/**
* Wait until any of the {@link MailboxFinder.Callback} method or
* {@link Controller#updateMailboxList} is called.
*/
private void waitUntilCallbackCalled() {
TestUtils.waitUntil("", new TestUtils.Condition() {
@Override
public boolean isMet() {
return mCallback.isAnyMethodCalled() || mMockController.mCalledUpdateMailboxList;
}
}, TIMEOUT);
}
/**
* Test: Account is on security hold.
*/
public void testSecurityHold() throws Throwable {
final long accountId = createAccount(true);
createAndStartFinder(accountId, Mailbox.TYPE_INBOX);
waitUntilCallbackCalled();
assertFalse(mCallback.mCalledAccountNotFound);
assertTrue(mCallback.mCalledAccountSecurityHold);
assertFalse(mCallback.mCalledMailboxFound);
assertFalse(mCallback.mCalledMailboxNotFound);
assertFalse(mMockController.mCalledUpdateMailboxList);
assertTrue(mMailboxFinder.isReallyClosedForTest());
}
/**
* Test: Account does not exist.
*/
public void testAccountNotFound() throws Throwable {
createAndStartFinder(123456, Mailbox.TYPE_INBOX); // No such account.
waitUntilCallbackCalled();
assertTrue(mCallback.mCalledAccountNotFound);
assertFalse(mCallback.mCalledAccountSecurityHold);
assertFalse(mCallback.mCalledMailboxFound);
assertFalse(mCallback.mCalledMailboxNotFound);
assertFalse(mMockController.mCalledUpdateMailboxList);
assertTrue(mMailboxFinder.isReallyClosedForTest());
}
/**
* Test: Mailbox found
*/
public void testMailboxFound() throws Throwable {
final long accountId = createAccount(false);
final long mailboxId = createMailbox(accountId, Mailbox.TYPE_INBOX);
createAndStartFinder(accountId, Mailbox.TYPE_INBOX);
waitUntilCallbackCalled();
assertFalse(mCallback.mCalledAccountNotFound);
assertFalse(mCallback.mCalledAccountSecurityHold);
assertTrue(mCallback.mCalledMailboxFound);
assertFalse(mCallback.mCalledMailboxNotFound);
assertFalse(mMockController.mCalledUpdateMailboxList);
assertEquals(accountId, mCallback.mAccountId);
assertEquals(mailboxId, mCallback.mMailboxId);
assertTrue(mMailboxFinder.isReallyClosedForTest());
}
/**
* Common initialization for tests that involves network-lookup.
*/
private void prepareForNetworkLookupTest(final long accountId) throws Throwable {
// Look for non-existing mailbox.
createAndStartFinder(accountId, Mailbox.TYPE_INBOX);
waitUntilCallbackCalled();
// Mailbox not found, so the finder should try network-looking up.
assertFalse(mCallback.mCalledAccountNotFound);
assertFalse(mCallback.mCalledAccountSecurityHold);
assertFalse(mCallback.mCalledMailboxFound);
assertFalse(mCallback.mCalledMailboxNotFound);
// Controller.updateMailboxList() should have been called, with the account id.
assertTrue(mMockController.mCalledUpdateMailboxList);
assertEquals(accountId, mMockController.mPassedAccountId);
mMockController.reset();
assertFalse(mMailboxFinder.isReallyClosedForTest()); // Not closed yet
}
/**
* Test: Account exists, but mailbox doesn't -> Get {@link Controller} to update the mailbox
* list -> mailbox still doesn't exist.
*/
public void testMailboxNotFound() throws Throwable {
final long accountId = createAccount(false);
prepareForNetworkLookupTest(accountId);
// Imitate the mCallback...
runTestOnUiThread(new Runnable() {
@Override
public void run() {
mMailboxFinder.getControllerResultsForTest().updateMailboxListCallback(
null, accountId, 100);
}
});
// Task should have started, so wait for the response...
waitUntilCallbackCalled();
assertFalse(mCallback.mCalledAccountNotFound);
assertFalse(mCallback.mCalledAccountSecurityHold);
assertFalse(mCallback.mCalledMailboxFound);
assertTrue(mCallback.mCalledMailboxNotFound);
assertFalse(mMockController.mCalledUpdateMailboxList);
assertTrue(mMailboxFinder.isReallyClosedForTest());
}
/**
* Test: Account exists, but mailbox doesn't -> Get {@link Controller} to update the mailbox
* list -> found mailbox this time.
*/
public void testMailboxFoundOnNetwork() throws Throwable {
final long accountId = createAccount(false);
prepareForNetworkLookupTest(accountId);
// Create mailbox at this point.
final long mailboxId = createMailbox(accountId, Mailbox.TYPE_INBOX);
// Imitate the mCallback...
runTestOnUiThread(new Runnable() {
@Override
public void run() {
mMailboxFinder.getControllerResultsForTest().updateMailboxListCallback(
null, accountId, 100);
}
});
// Task should have started, so wait for the response...
waitUntilCallbackCalled();
assertFalse(mCallback.mCalledAccountNotFound);
assertFalse(mCallback.mCalledAccountSecurityHold);
assertTrue(mCallback.mCalledMailboxFound);
assertFalse(mCallback.mCalledMailboxNotFound);
assertFalse(mMockController.mCalledUpdateMailboxList);
assertEquals(accountId, mCallback.mAccountId);
assertEquals(mailboxId, mCallback.mMailboxId);
assertTrue(mMailboxFinder.isReallyClosedForTest());
}
/**
* Test: Account exists, but mailbox doesn't -> Get {@link Controller} to update the mailbox
* list -> network error.
*/
public void testMailboxNotFoundNetworkError() throws Throwable {
final long accountId = createAccount(false);
prepareForNetworkLookupTest(accountId);
// Imitate the mCallback...
runTestOnUiThread(new Runnable() {
@Override
public void run() {
// network error.
mMailboxFinder.getControllerResultsForTest().updateMailboxListCallback(
new MessagingException("Network error"), accountId, 0);
}
});
assertFalse(mCallback.mCalledAccountNotFound);
assertFalse(mCallback.mCalledAccountSecurityHold);
assertFalse(mCallback.mCalledMailboxFound);
assertTrue(mCallback.mCalledMailboxNotFound);
assertFalse(mMockController.mCalledUpdateMailboxList);
assertTrue(mMailboxFinder.isReallyClosedForTest());
}
/**
* Test: updateMailboxListCallback won't respond to update of a non-target account.
*/
public void testUpdateMailboxListCallbackNonTarget() throws Throwable {
final long accountId = createAccount(false);
prepareForNetworkLookupTest(accountId);
// Callback from Controller, but for a different account.
runTestOnUiThread(new Runnable() {
@Override
public void run() {
long nonTargetAccountId = accountId + 1;
mMailboxFinder.getControllerResultsForTest().updateMailboxListCallback(
new MessagingException("Network error"), nonTargetAccountId, 0);
}
});
// Nothing happened.
assertFalse(mCallback.mCalledAccountNotFound);
assertFalse(mCallback.mCalledAccountSecurityHold);
assertFalse(mCallback.mCalledMailboxFound);
assertFalse(mCallback.mCalledMailboxNotFound);
assertFalse(mMockController.mCalledUpdateMailboxList);
assertFalse(mMailboxFinder.isReallyClosedForTest()); // Not closed yet
}
/**
* Test: Mailbox not found (mailbox of different type exists)
*/
public void testMailboxNotFound2() throws Throwable {
final long accountId = createAccount(false);
final long mailboxId = createMailbox(accountId, Mailbox.TYPE_DRAFTS);
createAndStartFinder(accountId, Mailbox.TYPE_INBOX);
waitUntilCallbackCalled();
assertFalse(mCallback.mCalledAccountNotFound);
assertFalse(mCallback.mCalledAccountSecurityHold);
assertFalse(mCallback.mCalledMailboxFound);
assertFalse(mCallback.mCalledMailboxNotFound);
assertTrue(mMockController.mCalledUpdateMailboxList);
assertFalse(mMailboxFinder.isReallyClosedForTest()); // Not closed yet -- network lookup.
}
/**
* Test: Call {@link MailboxFinder#startLookup()} twice, which should throw an ISE.
*/
public void testRunTwice() throws Throwable {
final long accountId = createAccount(true);
createAndStartFinder(accountId, Mailbox.TYPE_INBOX);
try {
mMailboxFinder.startLookup();
fail("Expected exception not thrown");
} catch (IllegalStateException ok) {
}
}
public void testCancel() throws Throwable {
final long accountId = createAccount(true);
createAndStartFinder(accountId, Mailbox.TYPE_INBOX);
mMailboxFinder.cancel();
assertTrue(mMailboxFinder.isReallyClosedForTest());
}
/**
* A {@link Controller} that remembers if updateMailboxList has been called.
*/
private static class MockController extends Controller {
public volatile long mPassedAccountId;
public volatile boolean mCalledUpdateMailboxList;
public void reset() {
mPassedAccountId = -1;
mCalledUpdateMailboxList = false;
}
protected MockController(Context context) {
super(context);
}
@Override
public void updateMailboxList(long accountId) {
mCalledUpdateMailboxList = true;
mPassedAccountId = accountId;
}
}
/**
* Callback that logs what method is called with what arguments.
*/
private static class MockCallback implements MailboxFinder.Callback {
public volatile boolean mCalledAccountNotFound;
public volatile boolean mCalledAccountSecurityHold;
public volatile boolean mCalledMailboxFound;
public volatile boolean mCalledMailboxNotFound;
public volatile long mAccountId = -1;
public volatile long mMailboxId = -1;
public boolean isAnyMethodCalled() {
return mCalledAccountNotFound || mCalledAccountSecurityHold || mCalledMailboxFound
|| mCalledMailboxNotFound;
}
@Override
public void onAccountNotFound() {
mCalledAccountNotFound = true;
}
@Override
public void onAccountSecurityHold(long accountId) {
mCalledAccountSecurityHold = true;
mAccountId = accountId;
}
@Override
public void onMailboxFound(long accountId, long mailboxId) {
mCalledMailboxFound = true;
mAccountId = accountId;
mMailboxId = mailboxId;
}
@Override
public void onMailboxNotFound(long accountId) {
mCalledMailboxNotFound = true;
mAccountId = accountId;
}
}
}

125
tests/src/com/android/email/activity/MailboxFragmentAdapterTest.java
View File

@ -1,125 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email.activity;
import com.android.email.provider.EmailProvider;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.EmailContent;
import com.android.emailcommon.provider.EmailContent.Message;
import com.android.emailcommon.provider.Mailbox;
import android.content.Context;
import android.database.Cursor;
import android.test.ProviderTestCase2;
import junit.framework.Assert;
public class MailboxFragmentAdapterTest extends ProviderTestCase2<EmailProvider> {
private Context mMockContext;
public MailboxFragmentAdapterTest() {
super(EmailProvider.class, EmailContent.AUTHORITY);
}
@Override
public void setUp() throws Exception {
super.setUp();
mMockContext = getMockContext();
}
public void testBuildCombinedMailboxes() {
final Context c = mMockContext;
// Prepare test data
Account a1 = ProviderTestUtils.setupAccount("a1", true, c);
Account a2 = ProviderTestUtils.setupAccount("a2", true, c);
Account a3 = ProviderTestUtils.setupAccount("a3", true, c);
Mailbox b1i = ProviderTestUtils.setupMailbox("box1i", a1.mId, true, c, Mailbox.TYPE_INBOX);
Mailbox b2i = ProviderTestUtils.setupMailbox("box2i", a2.mId, true, c, Mailbox.TYPE_INBOX);
Mailbox b3i = ProviderTestUtils.setupMailbox("box3i", a3.mId, true, c, Mailbox.TYPE_INBOX);
Mailbox b1o = ProviderTestUtils.setupMailbox("box1i", a1.mId, true, c, Mailbox.TYPE_OUTBOX);
Mailbox b2o = ProviderTestUtils.setupMailbox("box2i", a2.mId, true, c, Mailbox.TYPE_OUTBOX);
Mailbox b1d = ProviderTestUtils.setupMailbox("box1d", a1.mId, true, c, Mailbox.TYPE_DRAFTS);
Mailbox b2d = ProviderTestUtils.setupMailbox("box2d", a2.mId, true, c, Mailbox.TYPE_DRAFTS);
Mailbox b1t = ProviderTestUtils.setupMailbox("box1t", a1.mId, true, c, Mailbox.TYPE_TRASH);
Mailbox b2t = ProviderTestUtils.setupMailbox("box2t", a2.mId, true, c, Mailbox.TYPE_TRASH);
createMessage(c, b1i, false, false, Message.FLAG_LOADED_COMPLETE);
createMessage(c, b2i, true, true, Message.FLAG_LOADED_COMPLETE);
createMessage(c, b2i, true, false, Message.FLAG_LOADED_COMPLETE);
// "unloaded" messages will not affect 'favorite' message count
createMessage(c, b3i, true, true, Message.FLAG_LOADED_UNLOADED);
createMessage(c, b1o, true, true, Message.FLAG_LOADED_COMPLETE);
createMessage(c, b2o, false, true, Message.FLAG_LOADED_COMPLETE);
createMessage(c, b1d, false, true, Message.FLAG_LOADED_COMPLETE);
createMessage(c, b2d, false, true, Message.FLAG_LOADED_COMPLETE);
createMessage(c, b2d, false, true, Message.FLAG_LOADED_COMPLETE);
createMessage(c, b2d, false, true, Message.FLAG_LOADED_COMPLETE);
// Starred message in trash; All Starred excludes it.
createMessage(c, b2t, true, true, Message.FLAG_LOADED_UNLOADED);
// Kick the method
Cursor cursor = MailboxFragmentAdapter.CombinedMailboxLoader.buildCombinedMailboxes(c,
null);
// Check the result
assertEquals(4, cursor.getCount());
// Row 1 -- combined inbox (with unread count)
assertTrue(cursor.moveToFirst());
checkSpecialMailboxRow(cursor, Mailbox.QUERY_ALL_INBOXES, Mailbox.TYPE_INBOX, 2);
// Row 2 -- all starred (with total count)
assertTrue(cursor.moveToNext());
checkSpecialMailboxRow(cursor, Mailbox.QUERY_ALL_FAVORITES, Mailbox.TYPE_MAIL, 3);
// Row 3 -- all drafts (with total count)
assertTrue(cursor.moveToNext());
checkSpecialMailboxRow(cursor, Mailbox.QUERY_ALL_DRAFTS, Mailbox.TYPE_DRAFTS, 4);
// Row 4 -- combined outbox (with total count)
assertTrue(cursor.moveToNext());
checkSpecialMailboxRow(cursor, Mailbox.QUERY_ALL_OUTBOX, Mailbox.TYPE_OUTBOX, 2);
}
private static Message createMessage(Context c, Mailbox b, boolean starred, boolean read,
int flagLoaded) {
Message message = ProviderTestUtils.setupMessage(
"1", b.mAccountKey, b.mId, true, false, c, starred, read);
message.mFlagLoaded = flagLoaded;
message.save(c);
return message;
}
private static void checkSpecialMailboxRow(Cursor cursor, long id, int type,
int count) {
// _id must always be >= 0; otherwise ListView gets confused.
Assert.assertTrue(cursor.getLong(cursor.getColumnIndex("_id")) >= 0);
Assert.assertEquals(id, MailboxFragmentAdapter.getId(cursor));
Assert.assertEquals(type, MailboxFragmentAdapter.getType(cursor));
Assert.assertEquals(count, MailboxFragmentAdapter.getMessageCount(cursor));
Assert.assertEquals(count, MailboxFragmentAdapter.getUnreadCount(cursor));
Assert.assertEquals(Account.ACCOUNT_ID_COMBINED_VIEW,
MailboxFragmentAdapter.getAccountId(cursor));
}
}

1020
tests/src/com/android/email/activity/MessageComposeTests.java
View File

File diff suppressed because it is too large Load Diff

92
tests/src/com/android/email/activity/MessageFileViewTest.java
View File

@ -1,92 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email.activity;
import com.android.email.DBTestHelper;
import com.android.email.TestUtils;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.provider.EmailContent.Message;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.test.ActivityInstrumentationTestCase2;
/**
* Test case for {@link MessageFileView}.
*
* TODO Add more tests. Any good way to test fragment??
*/
public class MessageFileViewTest extends ActivityInstrumentationTestCase2<MessageFileView> {
private static int TIMEOUT = 10; // in seconds
private Context mProviderContext;
public MessageFileViewTest() {
super(MessageFileView.class);
}
@Override
protected void setUp() throws Exception {
super.setUp();
mProviderContext = DBTestHelper.ProviderContextSetupHelper.getProviderContext(
getInstrumentation().getTargetContext());
}
private void setUpIntent(Uri uri) {
final Intent i = new Intent(getInstrumentation().getTargetContext(), MessageFileView.class);
i.setData(uri);
setActivityIntent(i);
}
private Uri createEmlFile() throws Exception {
// Create a simple message
Message msg = new Message();
String text = "This is some text";
msg.mText = text;
String sender = "sender@host.com";
msg.mFrom = sender;
// Save this away
msg.save(mProviderContext);
return ProviderTestUtils.createTempEmlFile(mProviderContext, msg,
getInstrumentation().getContext().getFilesDir());
}
/**
* Set up an EML file, and open it in the activity.
*
* Expected: Message opens.
*/
public void testOpenMessage() throws Exception {
setUpIntent(createEmlFile());
final MessageFileView activity = getActivity();
TestUtils.waitUntil(new TestUtils.Condition() {
@Override
public boolean isMet() {
MessageFileViewFragment f = activity.getFragment();
return f != null && f.isMessageLoadedForTest();
}
}, TIMEOUT);
// TODO Check UI elements, once our UI is settled.
}
}

64
tests/src/com/android/email/activity/MessageListTests.java
View File

@ -1,64 +0,0 @@
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email.activity;
import com.android.email.DBTestHelper;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.provider.Account;
import android.content.Context;
import android.content.Intent;
import android.test.AndroidTestCase;
public class MessageListTests extends AndroidTestCase {
private Context mMockContext;
public MessageListTests() {
}
@Override
public void setUp() throws Exception {
super.setUp();
// ProviderTestCase2 can't be used. It creates a mock context that doesn't support
// some methods we need here, such as getPackageName.
mMockContext = DBTestHelper.ProviderContextSetupHelper.getProviderContext(
getContext());
}
public void testGetAccountFromIntent() {
final Context c = mMockContext;
final Account a1 = ProviderTestUtils.setupAccount("a1", true, c);
final Account a2 = ProviderTestUtils.setupAccount("a2", true, c);
assertEquals(a1.mId, MessageList.getAccountFromIntent(c,
MessageList.createFroyoIntent(c, a1)));
assertEquals(a2.mId, MessageList.getAccountFromIntent(c,
MessageList.createFroyoIntent(c, a2)));
// Mixed -- UUID in the URI doesn't match the account ID in extra.
// It's a test for shortcuts for restored accounts.
final Intent i = MessageList.createFroyoIntent(c, a2);
i.putExtra(MessageList.EXTRA_ACCOUNT_ID, 12345);
assertEquals(a2.mId, MessageList.getAccountFromIntent(c, i));
// Invalid intent -- no extra, no URI.
assertEquals(Account.NO_ACCOUNT, MessageList.getAccountFromIntent(c,
new Intent(c, MessageList.class)));
}
}

402
tests/src/com/android/email/activity/MessageOrderManagerTest.java
View File

@ -1,402 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email.activity;
import android.content.Context;
import android.database.AbstractCursor;
import android.database.Cursor;
import android.os.Handler;
import android.test.ProviderTestCase2;
import android.test.suitebuilder.annotation.SmallTest;
import com.android.email.MessageListContext;
import com.android.email.provider.EmailProvider;
import com.android.emailcommon.provider.EmailContent;
import com.android.emailcommon.utility.DelayedOperations;
import junit.framework.Assert;
@SmallTest
public class MessageOrderManagerTest extends ProviderTestCase2<EmailProvider> {
private MyCallback mCallback;
@Override protected void setUp() throws Exception {
super.setUp();
mCallback = new MyCallback();
}
public MessageOrderManagerTest() {
super(EmailProvider.class, EmailContent.AUTHORITY);
}
private static void assertCanMove(MessageOrderManager mom, boolean newer, boolean older) {
Assert.assertEquals(older, mom.canMoveToOlder());
Assert.assertEquals(newer, mom.canMoveToNewer());
}
public void testBasic() {
MessageOrderManagerForTest mom = new MessageOrderManagerForTest(getContext(), 1, mCallback);
mom.assertStartQueryCalledAndReset();
// moveTo not called, so it returns -1
assertEquals(-1, mom.getCurrentMessageId());
// Task not finished, so all returns false.
assertCanMove(mom, false, false);
assertFalse(mom.moveToNewer());
assertFalse(mom.moveToOlder());
// Set current message
mom.moveTo(54);
assertEquals(54, mom.getCurrentMessageId());
// Task still not finished, so all returns false.
assertCanMove(mom, false, false);
assertFalse(mom.moveToNewer());
assertFalse(mom.moveToOlder());
// Both callbacks shouldn't have called.
mCallback.assertCallbacksCalled(false, false);
// Cursor not open yet, so these are both 0.
assertEquals(0, mom.getCurrentPosition());
assertEquals(0, mom.getTotalMessageCount());
}
/**
* Test with actual message list.
*
* In this test, {@link MessageOrderManager#moveTo} is called AFTER the cursor opens.
*/
public void testWithList() {
MessageOrderManagerForTest mom = new MessageOrderManagerForTest(getContext(), 1, mCallback);
mom.assertStartQueryCalledAndReset();
// Callback not called yet.
mCallback.assertCallbacksCalled(false, false);
// Inject mock cursor. (Imitate async query done.)
MyCursor cursor = new MyCursor(11, 22, 33, 44); // Newer to older
mom.onCursorOpenDone(cursor);
assertEquals(0, mom.getCurrentPosition());
assertEquals(4, mom.getTotalMessageCount());
// Current message id not set yet, so callback should have called yet.
mCallback.assertCallbacksCalled(false, false);
// Set current message id -- now onMessagesChanged() should get called.
mom.moveTo(22);
assertEquals(1, mom.getCurrentPosition());
mCallback.assertCallbacksCalled(true, false);
assertEquals(22, mom.getCurrentMessageId());
assertCanMove(mom, true, true);
// Move to row 1
assertTrue(mom.moveToNewer());
assertEquals(0, mom.getCurrentPosition());
assertEquals(11, mom.getCurrentMessageId());
assertCanMove(mom, false, true);
mCallback.assertCallbacksCalled(true, false);
// Try to move to newer, but no newer messages
assertFalse(mom.moveToNewer());
assertEquals(0, mom.getCurrentPosition());
assertEquals(11, mom.getCurrentMessageId()); // Still row 1
mCallback.assertCallbacksCalled(false, false);
// Move to row 2
assertTrue(mom.moveToOlder());
assertEquals(1, mom.getCurrentPosition());
assertEquals(22, mom.getCurrentMessageId());
assertCanMove(mom, true, true);
mCallback.assertCallbacksCalled(true, false);
// Move to row 3
assertTrue(mom.moveToOlder());
assertEquals(2, mom.getCurrentPosition());
assertEquals(33, mom.getCurrentMessageId());
assertCanMove(mom, true, true);
mCallback.assertCallbacksCalled(true, false);
// Move to row 4
assertTrue(mom.moveToOlder());
assertEquals(3, mom.getCurrentPosition());
assertEquals(44, mom.getCurrentMessageId());
assertCanMove(mom, true, false);
mCallback.assertCallbacksCalled(true, false);
// Try to move older, but no Older messages
assertFalse(mom.moveToOlder());
assertEquals(3, mom.getCurrentPosition());
mCallback.assertCallbacksCalled(false, false);
// Move to row 3
assertTrue(mom.moveToNewer());
assertEquals(2, mom.getCurrentPosition());
assertEquals(33, mom.getCurrentMessageId());
assertCanMove(mom, true, true);
mCallback.assertCallbacksCalled(true, false);
}
/**
* Test with actual message list.
*
* In this test, {@link MessageOrderManager#moveTo} is called BEFORE the cursor opens.
*/
public void testWithList2() {
MessageOrderManagerForTest mom = new MessageOrderManagerForTest(getContext(), 1, mCallback);
mom.assertStartQueryCalledAndReset();
// Callback not called yet.
mCallback.assertCallbacksCalled(false, false);
mom.moveTo(22);
mCallback.assertCallbacksCalled(false, false); // Cursor not open, callback not called yet.
assertEquals(22, mom.getCurrentMessageId());
// cursor not open yet
assertEquals(0, mom.getCurrentPosition());
assertEquals(0, mom.getTotalMessageCount());
// Inject mock cursor. (Imitate async query done.)
MyCursor cursor = new MyCursor(11, 22, 33, 44); // Newer to older
mom.onCursorOpenDone(cursor);
// As soon as the cursor opens, callback gets called.
mCallback.assertCallbacksCalled(true, false);
assertEquals(22, mom.getCurrentMessageId());
assertEquals(1, mom.getCurrentPosition());
assertEquals(4, mom.getTotalMessageCount());
}
public void testContentChanged() {
MessageOrderManagerForTest mom = new MessageOrderManagerForTest(getContext(), 1, mCallback);
// Inject mock cursor. (Imitate async query done.)
MyCursor cursor = new MyCursor(11, 22, 33, 44); // Newer to older
mom.onCursorOpenDone(cursor);
// Move to 22
mom.moveTo(22);
mCallback.assertCallbacksCalled(true, false);
assertEquals(22, mom.getCurrentMessageId());
assertCanMove(mom, true, true);
// Delete 33
mom.updateMessageList(11, 22, 44);
mCallback.assertCallbacksCalled(true, false);
assertEquals(22, mom.getCurrentMessageId());
assertCanMove(mom, true, true);
// Delete 44
mom.updateMessageList(11, 22);
mCallback.assertCallbacksCalled(true, false);
assertEquals(22, mom.getCurrentMessageId());
assertCanMove(mom, true, false); // Can't move to older
// Append 55
mom.updateMessageList(11, 22, 55);
mCallback.assertCallbacksCalled(true, false);
assertEquals(22, mom.getCurrentMessageId());
assertCanMove(mom, true, true);
// Delete 11
mom.updateMessageList(22, 55);
mCallback.assertCallbacksCalled(true, false);
assertEquals(22, mom.getCurrentMessageId());
assertCanMove(mom, false, true);
// Delete 55
mom.updateMessageList(22);
mCallback.assertCallbacksCalled(true, false);
assertEquals(22, mom.getCurrentMessageId());
assertCanMove(mom, false, false); // Can't move either way
// Delete 22 -- no messages left.
mom.updateMessageList();
mCallback.assertCallbacksCalled(false, true);
// Test for the case where list is not empty, but the current message is gone.
// First, set up a list with 22 as the current message.
mom.updateMessageList(11, 22, 33, 44);
mom.moveTo(22);
assertEquals(22, mom.getCurrentMessageId());
mCallback.assertCallbacksCalled(true, false);
// Then remove the current message.
mom.updateMessageList(11, 33, 44);
mCallback.assertCallbacksCalled(false, true);
}
/**
* Test using the actual {@link MessageOrderManager} rather than
* {@link MessageOrderManagerForTest}.
*/
public void testWithActualClass() {
// There are not many things we can test synchronously.
// Just open & close just to make sure it won't crash.
MessageOrderManager mom = new MessageOrderManager(
getContext(), MessageListContext.forMailbox(1, 1), new MyCallback());
mom.moveTo(123);
mom.close();
}
private static class MyCallback implements MessageOrderManager.Callback {
public boolean mCalledOnMessageNotFound;
public boolean mCalledOnMessagesChanged;
@Override public void onMessagesChanged() {
mCalledOnMessagesChanged = true;
}
@Override public void onMessageNotFound() {
mCalledOnMessageNotFound = true;
}
/**
* Asserts that the callbacks have/have not been called, and reset the flags.
*/
public void assertCallbacksCalled(boolean messagesChanged, boolean messageNotFound) {
assertEquals(messagesChanged, mCalledOnMessagesChanged);
assertEquals(messageNotFound, mCalledOnMessageNotFound);
mCalledOnMessagesChanged = false;
mCalledOnMessageNotFound = false;
}
}
/**
* "Non" delayed operation -- runs the runnable immediately
*/
private static final class NonDelayedOperations extends DelayedOperations {
public NonDelayedOperations() {
super(new Handler());
}
@Override
public void post(Runnable r) {
r.run();
}
}
/**
* MessageOrderManager for test. Overrides {@link #startQuery}
*/
private static class MessageOrderManagerForTest extends MessageOrderManager {
private Cursor mLastCursor;
public boolean mStartQueryCalled;
public MessageOrderManagerForTest(Context context, long mailboxId, Callback callback) {
super(context, MessageListContext.forMailbox(1, mailboxId),
callback, new NonDelayedOperations());
}
@Override void startQuery() {
// To make tests synchronous, we replace this method.
mStartQueryCalled = true;
}
@Override /* package */ Handler getHandlerForContentObserver() {
return null;
}
@Override void onCursorOpenDone(Cursor cursor) {
super.onCursorOpenDone(cursor);
mLastCursor = cursor;
}
/**
* Utility method to emulate data set changed.
*/
public void updateMessageList(long... idList) {
assertNotNull(mLastCursor); // Make sure a cursor is set.
// Notify dataset change -- it should end up startQuery() gets called.
((MyCursor) mLastCursor).notifyChanged();
assertStartQueryCalledAndReset(); // Start
// Set a new cursor with a new list.
onCursorOpenDone(new MyCursor(idList));
}
public void assertStartQueryCalledAndReset() {
assertTrue(mStartQueryCalled);
mStartQueryCalled = false;
}
}
private static class MyCursor extends AbstractCursor {
private final long[] mList;
public MyCursor(long... idList) {
mList = (idList == null) ? new long[0] : idList;
}
public void notifyChanged() {
onChange(false);
}
@Override public int getColumnCount() {
return 1;
}
@Override public int getCount() {
return mList.length;
}
@Override public String[] getColumnNames() {
return new String[] {EmailContent.RECORD_ID};
}
@Override public long getLong(int columnIndex) {
Assert.assertEquals(EmailContent.ID_PROJECTION_COLUMN, columnIndex);
return mList[mPos];
}
@Override public double getDouble(int column) {
throw new junit.framework.AssertionFailedError();
}
@Override public float getFloat(int column) {
throw new junit.framework.AssertionFailedError();
}
@Override public int getInt(int column) {
throw new junit.framework.AssertionFailedError();
}
@Override public short getShort(int column) {
throw new junit.framework.AssertionFailedError();
}
@Override public String getString(int column) {
throw new junit.framework.AssertionFailedError();
}
@Override public boolean isNull(int column) {
throw new junit.framework.AssertionFailedError();
}
}
}

151
tests/src/com/android/email/activity/MessagesAdapterTests.java
View File

@ -1,151 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email.activity;
import android.content.Context;
import android.test.LoaderTestCase;
import com.android.email.DBTestHelper;
import com.android.email.MessageListContext;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.Mailbox;
public class MessagesAdapterTests extends LoaderTestCase {
// Account ID that's probably not in the database.
private static final long NO_SUCH_ACCOUNT_ID = 1234567890123L;
// Mailbox ID that's probably not in the database.
private static final long NO_SUCH_MAILBOX_ID = 1234567890123L;
// Isolated Context for providers.
private Context mProviderContext;
@Override
protected void setUp() throws Exception {
mProviderContext = DBTestHelper.ProviderContextSetupHelper.getProviderContext(getContext());
}
private long createAccount(boolean isEas) {
Account acct = ProviderTestUtils.setupAccount("acct1", false, mProviderContext);
String proto = isEas ? "eas" : "non-eas";
acct.mHostAuthRecv =
ProviderTestUtils.setupHostAuth(proto, "hostauth", true, mProviderContext);
acct.mHostAuthKeyRecv = acct.mHostAuthRecv.mId;
acct.save(mProviderContext);
return acct.mId;
}
private long createMailbox(long accountId, int type) {
Mailbox box = ProviderTestUtils.setupMailbox("name", accountId, false, mProviderContext);
box.mType = type;
box.save(mProviderContext);
return box.mId;
}
private MessagesAdapter.MessagesCursor getLoaderResult(long accountId, long mailboxId) {
return (MessagesAdapter.MessagesCursor) getLoaderResultSynchronously(
MessagesAdapter.createLoader(
mProviderContext,
MessageListContext.forMailbox(accountId, mailboxId)));
}
/**
* Test for normal case. (account, mailbox found)
*/
public void testLoad() {
final long accountId = createAccount(false);
final long mailboxId = createMailbox(accountId, Mailbox.TYPE_MAIL);
MessagesAdapter.MessagesCursor result = getLoaderResult(accountId, mailboxId);
assertTrue(result.mIsFound);
assertEquals(accountId, result.mAccount.mId);
assertEquals(mailboxId, result.mMailbox.mId);
assertFalse(result.mIsEasAccount);
assertTrue(result.mIsRefreshable);
}
/**
* Load -- isEas = true
*/
public void testLoadEas() {
final long accountId = createAccount(true);
final long mailboxId = createMailbox(accountId, Mailbox.TYPE_MAIL);
MessagesAdapter.MessagesCursor result = getLoaderResult(accountId, mailboxId);
assertTrue(result.mIsFound);
assertEquals(accountId, result.mAccount.mId);
assertEquals(mailboxId, result.mMailbox.mId);
assertTrue(result.mIsEasAccount);
assertTrue(result.mIsRefreshable);
}
/**
* Load -- drafts, not refreshable.
*/
public void testLoadNotRefreshable() {
final long accountId = createAccount(false);
final long mailboxId = createMailbox(accountId, Mailbox.TYPE_DRAFTS);
MessagesAdapter.MessagesCursor result = getLoaderResult(accountId, mailboxId);
assertTrue(result.mIsFound);
assertEquals(accountId, result.mAccount.mId);
assertEquals(mailboxId, result.mMailbox.mId);
assertFalse(result.mIsEasAccount);
assertFalse(result.mIsRefreshable);
}
/**
* Mailbox not found.
*/
public void testMailboxNotFound() {
MessagesAdapter.MessagesCursor result = getLoaderResult(
createAccount(false), NO_SUCH_MAILBOX_ID);
assertFalse(result.mIsFound);
assertNull(result.mAccount);
assertNull(result.mMailbox);
assertFalse(result.mIsEasAccount);
assertFalse(result.mIsRefreshable);
}
/**
* Account not found.
*/
public void testAccountNotFound() {
final long mailboxId = createMailbox(NO_SUCH_ACCOUNT_ID, Mailbox.TYPE_MAIL);
MessagesAdapter.MessagesCursor result = getLoaderResult(NO_SUCH_ACCOUNT_ID, mailboxId);
assertFalse(result.mIsFound);
assertNull(result.mAccount);
assertNull(result.mMailbox);
assertFalse(result.mIsEasAccount);
assertFalse(result.mIsRefreshable);
}
/**
* Magic mailbox. (always found)
*/
public void testMagicMailbox() {
MessagesAdapter.MessagesCursor result = getLoaderResult(
Account.ACCOUNT_ID_COMBINED_VIEW, Mailbox.QUERY_ALL_INBOXES);
assertTrue(result.mIsFound);
assertNull(result.mAccount);
assertNull(result.mMailbox);
assertFalse(result.mIsEasAccount);
assertFalse(result.mIsRefreshable);
}
}

253
tests/src/com/android/email/activity/RecentMailboxManagerTest.java
View File

@ -1,253 +0,0 @@
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email.activity;
import android.content.ContentValues;
import android.content.Context;
import android.test.AndroidTestCase;
import android.test.suitebuilder.annotation.MediumTest;
import com.android.email.Controller;
import com.android.email.DBTestHelper;
import com.android.email.MockClock;
import com.android.email.provider.ContentCache;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.provider.EmailContent.MailboxColumns;
import com.android.emailcommon.provider.Mailbox;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
/**
* Tests for the recent mailbox manager.
*
* You can run this entire test case with:
* runtest -c com.android.email.activity.RecentMailboxManagerTest email
*/
@MediumTest
public class RecentMailboxManagerTest extends AndroidTestCase {
private Context mMockContext;
private MockClock mMockClock;
private RecentMailboxManager mManager;
private Mailbox[] mMailboxArray;
public RecentMailboxManagerTest() {
}
@Override
public void setUp() throws Exception {
super.setUp();
mMockContext = DBTestHelper.ProviderContextSetupHelper.getProviderContext(
getContext());
mMockClock = new MockClock();
RecentMailboxManager.sClock = mMockClock;
mManager = RecentMailboxManager.getInstance(mMockContext);
Controller.getInstance(mMockContext).setProviderContext(mMockContext);
mMailboxArray = new Mailbox[] {
ProviderTestUtils.setupMailbox("inbox", 1L, true, mMockContext, Mailbox.TYPE_INBOX),
ProviderTestUtils.setupMailbox("drafts", 1L, true, mMockContext, Mailbox.TYPE_DRAFTS),
ProviderTestUtils.setupMailbox("outbox", 1L, true, mMockContext, Mailbox.TYPE_OUTBOX),
ProviderTestUtils.setupMailbox("sent", 1L, true, mMockContext, Mailbox.TYPE_SENT),
ProviderTestUtils.setupMailbox("trash", 1L, true, mMockContext, Mailbox.TYPE_TRASH),
ProviderTestUtils.setupMailbox("junk", 1L, true, mMockContext, Mailbox.TYPE_JUNK),
ProviderTestUtils.setupMailbox("abbott", 1L, true, mMockContext, Mailbox.TYPE_MAIL),
ProviderTestUtils.setupMailbox("costello", 1L, true, mMockContext, Mailbox.TYPE_MAIL),
ProviderTestUtils.setupMailbox("bud_lou", 1L, true, mMockContext, Mailbox.TYPE_MAIL),
ProviderTestUtils.setupMailbox("laurel", 1L, true, mMockContext, Mailbox.TYPE_MAIL),
ProviderTestUtils.setupMailbox("hardy", 1L, true, mMockContext, Mailbox.TYPE_MAIL)
};
// Invalidate all caches, since we reset the database for each test
ContentCache.invalidateAllCaches();
}
@Override
protected void tearDown() throws Exception {
RecentMailboxManager.sInstance = null;
super.tearDown();
}
public void testTouch() throws Exception {
Set<Integer> defaultRecents = new HashSet<Integer>() {{
for (int type : RecentMailboxManager.DEFAULT_RECENT_TYPES) {
add(type);
}
}};
// Ensure all accounts can be touched
for (Mailbox mailbox : mMailboxArray) {
// Safety ... default touch time
Mailbox untouchedMailbox = Mailbox.restoreMailboxWithId(mMockContext, mailbox.mId);
if (!defaultRecents.contains(mailbox.mType)) {
assertEquals(0L, untouchedMailbox.mLastTouchedTime);
}
// Touch the mailbox
mManager.touch(1L, mailbox.mId).get();
// Touch time is actually set
Mailbox touchedMailbox = Mailbox.restoreMailboxWithId(mMockContext, mailbox.mId);
assertEquals(mMockClock.getTime(), touchedMailbox.mLastTouchedTime);
mMockClock.advance(1000L);
}
// Now ensure touching one didn't affect the others
long touchTime = MockClock.DEFAULT_TIME;
for (Mailbox mailbox : mMailboxArray) {
// Touch time is actually set
Mailbox touchedMailbox = Mailbox.restoreMailboxWithId(mMockContext, mailbox.mId);
assertEquals(touchTime, touchedMailbox.mLastTouchedTime);
touchTime += 1000L;
}
}
/** Test default list */
public void testGetMostRecent01() throws Exception {
ArrayList<Long> testList;
// test default list
// With exclusions
testList = mManager.getMostRecent(1L, true);
assertEquals("w/ exclusions", 0, testList.size());
// Without exclusions -- we'll get "default" list.
testList = mManager.getMostRecent(1L, false);
assertEquals("w/o exclusions", 2, testList.size());
assertEquals(mMailboxArray[1].mId, (long) testList.get(0)); // Drafts
assertEquals(mMailboxArray[3].mId, (long) testList.get(1)); // Sent
}
/** Test recent list not full */
public void testGetMostRecent02() throws Exception {
ArrayList<Long> testList;
// need to wait for the last one to ensure getMostRecent() has something to work on
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[7].mId).get(); // costello
// test recent list not full, so is padded with default mailboxes
testList = mManager.getMostRecent(1L, false);
assertEquals(3, testList.size());
assertEquals(mMailboxArray[7].mId, (long) testList.get(0)); // costello
assertEquals(mMailboxArray[1].mId, (long) testList.get(1)); // Drafts
assertEquals(mMailboxArray[3].mId, (long) testList.get(2)); // Sent
testList = mManager.getMostRecent(1L, true);
assertEquals(1, testList.size());
assertEquals(mMailboxArray[7].mId, (long) testList.get(0));
}
/** Test full recent list */
public void testGetMostRecent03() throws Exception {
ArrayList<Long> testList;
// touch some more mailboxes
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[3].mId); // sent
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[4].mId); // trash
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[2].mId); // outbox
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[8].mId); // bud_lou
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[7].mId); // costello
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[9].mId).get(); // laurel
// test full recent list
testList = mManager.getMostRecent(1L, false);
assertEquals(5, testList.size());
assertEquals(mMailboxArray[8].mId, (long) testList.get(0)); // bud_lou
assertEquals(mMailboxArray[7].mId, (long) testList.get(1)); // costello
assertEquals(mMailboxArray[9].mId, (long) testList.get(2)); // laurel
assertEquals(mMailboxArray[2].mId, (long) testList.get(3)); // outbox
assertEquals(mMailboxArray[4].mId, (long) testList.get(4)); // trash
testList = mManager.getMostRecent(1L, true);
assertEquals(3, testList.size());
assertEquals(mMailboxArray[8].mId, (long) testList.get(0));
assertEquals(mMailboxArray[7].mId, (long) testList.get(1));
assertEquals(mMailboxArray[9].mId, (long) testList.get(2));
}
/** Test limit for system mailboxes */
public void testGetMostRecent04() throws Exception {
ArrayList<Long> testList;
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[0].mId); // inbox
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[1].mId); // drafts
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[2].mId); // outbox
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[3].mId); // sent
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[4].mId).get(); // trash
// nothing but system mailboxes, but inbox is never included
testList = mManager.getMostRecent(1L, false);
assertEquals(4, testList.size());
assertEquals(mMailboxArray[1].mId, (long) testList.get(0));
assertEquals(mMailboxArray[2].mId, (long) testList.get(1));
assertEquals(mMailboxArray[3].mId, (long) testList.get(2));
assertEquals(mMailboxArray[4].mId, (long) testList.get(3));
testList = mManager.getMostRecent(1L, true);
assertEquals(0, testList.size());
}
/** Test limit for user mailboxes */
public void testGetMostRecent05() throws Exception {
ArrayList<Long> testList;
// test limit for the filtered list
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[6].mId); // abbott
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[7].mId); // costello
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[8].mId); // bud_lou
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[9].mId); // laurel
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[10].mId); // hardy
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[1].mId); // drafts
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[2].mId); // outbox
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[3].mId); // sent
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[4].mId); // trash
mMockClock.advance(1000L); mManager.touch(1L, mMailboxArray[5].mId).get(); // junk
// nothing but user mailboxes
testList = mManager.getMostRecent(1L, false);
assertEquals(5, testList.size());
assertEquals(mMailboxArray[1].mId, (long) testList.get(0));
assertEquals(mMailboxArray[5].mId, (long) testList.get(1));
assertEquals(mMailboxArray[2].mId, (long) testList.get(2));
assertEquals(mMailboxArray[3].mId, (long) testList.get(3));
assertEquals(mMailboxArray[4].mId, (long) testList.get(4));
testList = mManager.getMostRecent(1L, true);
assertEquals(5, testList.size());
assertEquals(mMailboxArray[6].mId, (long) testList.get(0));
assertEquals(mMailboxArray[8].mId, (long) testList.get(1));
assertEquals(mMailboxArray[7].mId, (long) testList.get(2));
assertEquals(mMailboxArray[10].mId, (long) testList.get(3));
assertEquals(mMailboxArray[9].mId, (long) testList.get(4));
}
public void testDoesNotIncludeExtraMailboxes() throws Exception {
ArrayList<Long> testList;
// The search mailbox should not be visible.
Mailbox searchMailbox = ProviderTestUtils.setupMailbox(
"search", 1L, true, mMockContext, Mailbox.TYPE_SEARCH);
ContentValues cv = new ContentValues();
cv.put(MailboxColumns.FLAG_VISIBLE, false);
searchMailbox.mFlagVisible = false;
searchMailbox.update(mMockContext, cv);
mMockClock.advance(1000L); mManager.touch(1L, searchMailbox.mId).get();
// Ensure search mailbox isn't returned
testList = mManager.getMostRecent(1L, false);
assertFalse(testList.contains(searchMailbox.mId));
testList = mManager.getMostRecent(1L, true);
assertFalse(testList.contains(searchMailbox.mId));
}
}

190
tests/src/com/android/email/activity/UIControllerTwoPaneRefreshTaskTest.java
View File

@ -1,190 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email.activity;
import com.android.mail.utils.Clock;
import com.android.email.Controller;
import com.android.email.MockClock;
import com.android.email.RefreshManager;
import android.content.Context;
import android.os.Handler;
import android.test.AndroidTestCase;
import android.test.suitebuilder.annotation.SmallTest;
import junit.framework.Assert;
/**
* Tests for {@link UIControllerTwoPane.RefreshTask}.
*
* TOOD Add more tests.
* Right now, it only has tests for the "shouldXxx" methods, because it's hard to notice when
* they're subtly broken. (And the spec may change.)
*/
@SmallTest
public class UIControllerTwoPaneRefreshTaskTest extends AndroidTestCase {
private MockClock mClock = new MockClock();
private MockRefreshManager mRefreshManager;
@Override
protected void setUp() throws Exception {
super.setUp();
mRefreshManager = new MockRefreshManager(getContext(), Controller.getInstance(getContext()),
mClock, null);
}
@Override
protected void tearDown() throws Exception {
super.tearDown();
mRefreshManager.cleanUpForTest();
}
public void testShouldRefreshMailboxList() {
final long ACCOUNT_ID = 5;
final long MAILBOX_ID = 10;
UIControllerTwoPane.RefreshTask task = new UIControllerTwoPane.RefreshTask(null,
getContext(), ACCOUNT_ID, MAILBOX_ID, mClock, mRefreshManager);
mRefreshManager.mExpectedAccountId = ACCOUNT_ID;
mClock.mTime = 123456789;
// Not refreshing, never refreshed == should sync
mRefreshManager.mIsMailboxListRefreshing = false;
mRefreshManager.mLastMailboxListRefresTime = 0;
assertTrue(task.shouldRefreshMailboxList());
// IS refreshing, never refreshed == should NOT sync
mRefreshManager.mIsMailboxListRefreshing = true;
mRefreshManager.mLastMailboxListRefresTime = 0;
assertFalse(task.shouldRefreshMailboxList());
// Not refreshing, just refreshed == should NOT sync
mRefreshManager.mIsMailboxListRefreshing = false;
mRefreshManager.mLastMailboxListRefresTime = 1234567890;
mClock.mTime = mRefreshManager.mLastMailboxListRefresTime;
assertFalse(task.shouldRefreshMailboxList());
// Not refreshing, refreshed 1 ms ago == should NOT sync
mRefreshManager.mLastMailboxListRefresTime = 1234567890;
mClock.mTime = mRefreshManager.mLastMailboxListRefresTime + 1;
assertFalse(task.shouldRefreshMailboxList());
// Not refreshing, refreshed TIMEOUT-1 ago == should NOT sync
mRefreshManager.mLastMailboxListRefresTime = 1234567890;
mClock.mTime = mRefreshManager.mLastMailboxListRefresTime
+ UIControllerTwoPane.MAILBOX_REFRESH_MIN_INTERVAL - 1;
assertFalse(task.shouldRefreshMailboxList());
// 1 ms laster... should sync.
mClock.advance();
assertTrue(task.shouldRefreshMailboxList());
}
public void testShouldAutoRefreshInbox() {
final long ACCOUNT_ID = 5;
final long MAILBOX_ID = 10;
UIControllerTwoPane.RefreshTask task = new UIControllerTwoPane.RefreshTask(null,
getContext(), ACCOUNT_ID, MAILBOX_ID, mClock, mRefreshManager);
mRefreshManager.mExpectedAccountId = ACCOUNT_ID;
mClock.mTime = 123456789;
// Current mailbox != inbox, not refreshing, never refreshed == should sync
mRefreshManager.mIsMessageListRefreshing = false;
mRefreshManager.mLastMessageListRefresTime = 0;
task.mInboxId = MAILBOX_ID + 1;
mRefreshManager.mExpectedMailboxId = MAILBOX_ID + 1;
assertTrue(task.shouldAutoRefreshInbox());
// Current mailbox == inbox should NOT sync.
task.mInboxId = MAILBOX_ID;
mRefreshManager.mExpectedMailboxId = MAILBOX_ID;
assertFalse(task.shouldAutoRefreshInbox());
// Fron here, Current mailbox != inbox
task.mInboxId = MAILBOX_ID + 1;
mRefreshManager.mExpectedMailboxId = MAILBOX_ID + 1;
// IS refreshing, never refreshed == should NOT sync
mRefreshManager.mIsMessageListRefreshing = true;
mRefreshManager.mLastMessageListRefresTime = 0;
assertFalse(task.shouldAutoRefreshInbox());
// Not refreshing, just refreshed == should NOT sync
mRefreshManager.mIsMessageListRefreshing = false;
mRefreshManager.mLastMessageListRefresTime = 1234567890;
mClock.mTime = mRefreshManager.mLastMessageListRefresTime;
assertFalse(task.shouldAutoRefreshInbox());
// Not refreshing, refreshed 1 ms ago == should NOT sync
mRefreshManager.mLastMessageListRefresTime = 1234567890;
mClock.mTime = mRefreshManager.mLastMessageListRefresTime + 1;
assertFalse(task.shouldAutoRefreshInbox());
// Not refreshing, refreshed TIMEOUT-1 ago == should NOT sync
mRefreshManager.mLastMessageListRefresTime = 1234567890;
mClock.mTime = mRefreshManager.mLastMessageListRefresTime
+ UIControllerTwoPane.INBOX_AUTO_REFRESH_MIN_INTERVAL - 1;
assertFalse(task.shouldAutoRefreshInbox());
// 1 ms laster... should sync.
mClock.advance();
assertTrue(task.shouldAutoRefreshInbox());
}
private static class MockRefreshManager extends RefreshManager {
public long mExpectedAccountId;
public long mExpectedMailboxId;
public boolean mIsMailboxListRefreshing;
public long mLastMailboxListRefresTime;
public boolean mIsMessageListRefreshing;
public long mLastMessageListRefresTime;
protected MockRefreshManager(
Context context, Controller controller, Clock clock, Handler handler) {
super(context, controller, clock, handler);
}
@Override
public boolean isMailboxListRefreshing(long accountId) {
Assert.assertEquals(mExpectedAccountId, accountId);
return mIsMailboxListRefreshing;
}
@Override
public long getLastMailboxListRefreshTime(long accountId) {
Assert.assertEquals(mExpectedAccountId, accountId);
return mLastMailboxListRefresTime;
}
@Override
public boolean isMessageListRefreshing(long mailboxId) {
Assert.assertEquals(mExpectedMailboxId, mailboxId);
return mIsMessageListRefreshing;
}
@Override
public long getLastMessageListRefreshTime(long mailboxId) {
Assert.assertEquals(mExpectedMailboxId, mailboxId);
return mLastMessageListRefresTime;
}
}
}

64
tests/src/com/android/email/activity/WelcomeTests.java
View File

@ -1,64 +0,0 @@
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.email.activity;
import com.android.email.DBTestHelper;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.provider.Account;
import android.content.Context;
import android.test.AndroidTestCase;
public class WelcomeTests extends AndroidTestCase {
private Context mProviderContext;
@Override
protected void setUp() throws Exception {
super.setUp();
mProviderContext = DBTestHelper.ProviderContextSetupHelper.getProviderContext(
getContext());
}
public void testResolveAccountId() {
final Context c = mProviderContext;
final Account account1 = ProviderTestUtils.setupAccount("account-1", true, c);
final long id1 = account1.mId;
final Account account2 = ProviderTestUtils.setupAccount("account-2", true, c);
final long id2 = account2.mId;
final Account account3 = ProviderTestUtils.setupAccount("account-3", true, c);
final long id3 = account3.mId;
// Make sure the last one created (account 3) is the default.
assertTrue(Account.getDefaultAccountId(c) == id3);
// No account specified -- should return the default account.
assertEquals(id3, Welcome.resolveAccountId(c, -1, null));
// Invalid account id -- should return the default account.
assertEquals(id3, Welcome.resolveAccountId(c, 12345, null));
// Valid ID
assertEquals(id1, Welcome.resolveAccountId(c, id1, null));
// Invalid UUID -- should return the default account.
assertEquals(id3, Welcome.resolveAccountId(c, -1, "xxx"));
// Valid UUID
assertEquals(id1, Welcome.resolveAccountId(c, -1, account1.mCompatibilityUuid));
}
}

4
tests/src/com/android/email/activity/setup/AccountSettingsTests.java
View File

@ -25,6 +25,7 @@ import android.preference.PreferenceFragment;
import android.test.ActivityInstrumentationTestCase2;
import android.test.suitebuilder.annotation.MediumTest;
import com.android.email.activity.setup.AccountSettings;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.HostAuth;
@ -162,7 +163,8 @@ public class AccountSettingsTests extends ActivityInstrumentationTestCase2<Accou
mAccount.save(mContext);
mAccountId = mAccount.mId;
return AccountSettings.createAccountSettingsIntent(mContext, mAccountId, null);
// accountId, loginWarningAccountName, loginWarningReason
return AccountSettings.createAccountSettingsIntent(mAccountId, null, null);
}
}

33
tests/src/com/android/email/activity/setup/AccountSettingsUtilsTests.java
View File

@ -20,7 +20,8 @@ import android.content.Context;
import android.test.InstrumentationTestCase;
import android.test.suitebuilder.annotation.SmallTest;
import com.android.email.activity.setup.AccountSettingsUtils.Provider;
import com.android.emailcommon.VendorPolicyLoader.Provider;
import com.android.email.activity.setup.AccountSettingsUtils;
import com.android.email.tests.R;
/**
@ -50,17 +51,27 @@ public class AccountSettingsUtilsTests extends InstrumentationTestCase {
* TBD: Are there any useful defaults for exchange?
*/
public void testGuessServerName() {
assertEquals("foo.x.y.z", AccountSettingsUtils.inferServerName("x.y.z", "foo", null));
assertEquals("Pop.y.z", AccountSettingsUtils.inferServerName("Pop.y.z", "foo", null));
assertEquals("poP3.y.z", AccountSettingsUtils.inferServerName("poP3.y.z", "foo", null));
assertEquals("iMAp.y.z", AccountSettingsUtils.inferServerName("iMAp.y.z", "foo", null));
assertEquals("MaiL.y.z", AccountSettingsUtils.inferServerName("MaiL.y.z", "foo", null));
assertEquals("foo.x.y.z", AccountSettingsUtils.inferServerName(mTestContext, "x.y.z",
"foo", null));
assertEquals("Pop.y.z", AccountSettingsUtils.inferServerName(mTestContext, "Pop.y.z",
"foo", null));
assertEquals("poP3.y.z", AccountSettingsUtils.inferServerName(mTestContext, "poP3.y.z",
"foo", null));
assertEquals("iMAp.y.z", AccountSettingsUtils.inferServerName(mTestContext, "iMAp.y.z",
"foo", null));
assertEquals("MaiL.y.z", AccountSettingsUtils.inferServerName(mTestContext, "MaiL.y.z",
"foo", null));
assertEquals("bar.x.y.z", AccountSettingsUtils.inferServerName("x.y.z", null, "bar"));
assertEquals("bar.y.z", AccountSettingsUtils.inferServerName("Pop.y.z", null, "bar"));
assertEquals("bar.y.z", AccountSettingsUtils.inferServerName("poP3.y.z", null, "bar"));
assertEquals("bar.y.z", AccountSettingsUtils.inferServerName("iMAp.y.z", null, "bar"));
assertEquals("MaiL.y.z", AccountSettingsUtils.inferServerName("MaiL.y.z", null, "bar"));
assertEquals("bar.x.y.z", AccountSettingsUtils.inferServerName(mTestContext, "x.y.z",
null, "bar"));
assertEquals("bar.y.z", AccountSettingsUtils.inferServerName(mTestContext, "Pop.y.z",
null, "bar"));
assertEquals("bar.y.z", AccountSettingsUtils.inferServerName(mTestContext, "poP3.y.z",
null, "bar"));
assertEquals("bar.y.z", AccountSettingsUtils.inferServerName(mTestContext, "iMAp.y.z",
null, "bar"));
assertEquals("MaiL.y.z", AccountSettingsUtils.inferServerName(mTestContext, "MaiL.y.z",
null, "bar"));
}
public void testFindProviderForDomain() {

233
tests/src/com/android/email/activity/setup/AccountSetupExchangeTests.java
View File

@ -1,36 +1,23 @@
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.android.email.activity.setup;
import android.content.Context;
import android.content.Intent;
import android.test.ActivityInstrumentationTestCase2;
import android.test.UiThreadTest;
import android.test.AndroidTestCase;
import android.test.suitebuilder.annotation.MediumTest;
import android.view.View;
import android.widget.CheckBox;
import android.widget.EditText;
import com.android.email.R;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.HostAuth;
import java.net.URISyntaxException;
/**
* Tests of the basic UI logic in the Account Setup Incoming (IMAP / POP3) screen.
@ -38,204 +25,6 @@ import java.net.URISyntaxException;
* runtest -c com.android.email.activity.setup.AccountSetupExchangeTests email
*/
@MediumTest
public class AccountSetupExchangeTests extends
ActivityInstrumentationTestCase2<AccountSetupExchange> {
//EXCHANGE-REMOVE-SECTION-START
private AccountSetupExchange mActivity;
private AccountSetupExchangeFragment mFragment;
private EditText mServerView;
private EditText mPasswordView;
private CheckBox mSslRequiredCheckbox;
private CheckBox mTrustAllCertificatesCheckbox;
//EXCHANGE-REMOVE-SECTION-END
public AccountSetupExchangeTests() {
super(AccountSetupExchange.class);
}
//EXCHANGE-REMOVE-SECTION-START
/**
* Common setup code for all tests. Sets up a default launch intent, which some tests
* will use (others will override).
*/
@Override
protected void setUp() throws Exception {
super.setUp();
// This sets up a default URI which can be used by any of the test methods below.
// Individual test methods can replace this with a custom URI if they wish
// (except those that run on the UI thread - for them, it's too late to change it.)
Intent i = getTestIntent("eas://user:password@server.com");
setActivityIntent(i);
}
/**
* Test processing with a complete, good URI -> good fields
*/
public void testGoodUri() throws URISyntaxException {
Intent i = getTestIntent("eas://user:password@server.com");
setActivityIntent(i);
getActivityAndFields();
assertTrue(mActivity.mNextButtonEnabled);
}
// TODO Add tests for valid usernames in eas
// They would be <name> or <name>\<domain> or <name>/<domain> or a valid email address
/**
* No user is not OK - not enabled
*/
public void testBadUriNoUser() throws URISyntaxException {
Intent i = getTestIntent("eas://:password@server.com");
setActivityIntent(i);
getActivityAndFields();
assertFalse(mActivity.mNextButtonEnabled);
}
/**
* No password is not OK - not enabled
*/
public void testBadUriNoPassword() throws URISyntaxException {
Intent i = getTestIntent("eas://user@server.com");
setActivityIntent(i);
getActivityAndFields();
assertFalse(mActivity.mNextButtonEnabled);
}
/**
* Test for non-standard but OK server names
*/
@UiThreadTest
public void testGoodServerVariants() {
getActivityAndFields();
assertTrue(mActivity.mNextButtonEnabled);
mServerView.setText(" server.com ");
assertTrue(mActivity.mNextButtonEnabled);
}
/**
* Test for non-empty but non-OK server names
*/
@UiThreadTest
public void testBadServerVariants() {
getActivityAndFields();
assertTrue(mActivity.mNextButtonEnabled);
mServerView.setText(" ");
assertFalse(mActivity.mNextButtonEnabled);
mServerView.setText("serv$er.com");
assertFalse(mActivity.mNextButtonEnabled);
}
/**
* Test to confirm that passwords with leading or trailing spaces are accepted verbatim.
*/
@UiThreadTest
public void testPasswordNoTrim() {
getActivityAndFields();
// Clear the password - should disable
checkPassword(null, false);
// Various combinations of spaces should be OK
checkPassword(" leading", true);
checkPassword("trailing ", true);
checkPassword("em bedded", true);
checkPassword(" ", true);
}
/**
* Check password field for a given password. Should be called in UI thread. Confirms that
* the password has not been trimmed.
*
* @param password the password to test with
* @param expectNext true if expected that this password will enable the "next" button
*/
private void checkPassword(String password, boolean expectNext) {
mPasswordView.setText(password);
if (expectNext) {
assertTrue(mActivity.mNextButtonEnabled);
} else {
assertFalse(mActivity.mNextButtonEnabled);
}
}
/**
* Test aspects of loadSettings()
*
* TODO: More cases
*/
@UiThreadTest
public void testLoadSettings() {
// The default URI has no SSL and no "trust"
getActivityAndFields();
assertFalse(mSslRequiredCheckbox.isChecked());
assertFalse(mTrustAllCertificatesCheckbox.isChecked());
assertFalse(mTrustAllCertificatesCheckbox.getVisibility() == View.VISIBLE);
// Setup host auth with variants of SSL enabled and check. This also enables the
// "trust certificates" checkbox (not checked, but visible now).
Account account =
ProviderTestUtils.setupAccount("account", false, mActivity.getBaseContext());
account.mHostAuthRecv = ProviderTestUtils.setupHostAuth(
"eas", "hostauth", false, mActivity.getBaseContext());
account.mHostAuthRecv.mFlags |= HostAuth.FLAG_SSL;
account.mHostAuthRecv.mFlags &= ~HostAuth.FLAG_TRUST_ALL;
mActivity.mFragment.mLoaded = false;
boolean loadResult = mActivity.mFragment.loadSettings(account);
assertTrue(loadResult);
assertTrue(mSslRequiredCheckbox.isChecked());
assertFalse(mTrustAllCertificatesCheckbox.isChecked());
assertTrue(mTrustAllCertificatesCheckbox.getVisibility() == View.VISIBLE);
// Setup host auth with variants of SSL enabled and check. This also enables the
// "trust certificates" checkbox (not checked, but visible now).
account.mHostAuthRecv.mFlags |= HostAuth.FLAG_TRUST_ALL;
mActivity.mFragment.mLoaded = false;
loadResult = mActivity.mFragment.loadSettings(account);
assertTrue(loadResult);
assertTrue(mSslRequiredCheckbox.isChecked());
assertTrue(mTrustAllCertificatesCheckbox.isChecked());
assertTrue(mTrustAllCertificatesCheckbox.getVisibility() == View.VISIBLE);
// A simple test of an incomplete account, which will fail validation
account.mHostAuthRecv.mPassword = "";
mActivity.mFragment.mLoaded = false;
loadResult = mActivity.mFragment.loadSettings(account);
assertFalse(loadResult);
}
/**
* TODO: Directly test validateFields() checking boolean result
*/
/**
* Get the activity (which causes it to be started, using our intent) and get the UI fields
*/
private void getActivityAndFields() {
mActivity = getActivity();
mFragment = mActivity.mFragment;
mServerView = (EditText) mActivity.findViewById(R.id.account_server);
mPasswordView = (EditText) mActivity.findViewById(R.id.account_password);
mSslRequiredCheckbox = (CheckBox) mActivity.findViewById(R.id.account_ssl);
mTrustAllCertificatesCheckbox =
(CheckBox) mActivity.findViewById(R.id.account_trust_certificates);
}
/**
* Create an intent with the Account in it
*/
private Intent getTestIntent(String storeUriString) throws URISyntaxException {
Account account = new Account();
Context context = getInstrumentation().getTargetContext();
HostAuth auth = account.getOrCreateHostAuthRecv(context);
HostAuth.setHostAuthFromString(auth, storeUriString);
Intent i = new Intent(Intent.ACTION_MAIN);
SetupData.init(SetupData.FLOW_MODE_NORMAL, account);
SetupData.setAllowAutodiscover(false);
return i;
}
//EXCHANGE-REMOVE-SECTION-END
public class AccountSetupExchangeTests extends AndroidTestCase {
// TODO: Remove this class because AccountSetupExchange no longer exists
}

24
tests/src/com/android/email/activity/setup/AccountSetupIncomingTests.java
View File

@ -16,17 +16,21 @@
package com.android.email.activity.setup;
import com.android.email.R;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.HostAuth;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.test.ActivityInstrumentationTestCase2;
import android.test.UiThreadTest;
import android.test.suitebuilder.annotation.MediumTest;
import android.widget.EditText;
import com.android.email.R;
import com.android.email.activity.setup.AccountSetupIncoming;
import com.android.email.activity.setup.AccountSetupIncomingFragment;
import com.android.email.activity.setup.SetupData;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.HostAuth;
import java.net.URISyntaxException;
/**
@ -176,7 +180,7 @@ public class AccountSetupIncomingTests extends
*/
private void getActivityAndFields() {
mActivity = getActivity();
mFragment = mActivity.mFragment;
mFragment = (AccountSetupIncomingFragment) mActivity.mFragment;
mServerView = (EditText) mActivity.findViewById(R.id.account_server);
mPasswordView = (EditText) mActivity.findViewById(R.id.account_password);
}
@ -190,8 +194,14 @@ public class AccountSetupIncomingTests extends
Context context = getInstrumentation().getTargetContext();
HostAuth auth = account.getOrCreateHostAuthRecv(context);
HostAuth.setHostAuthFromString(auth, storeUriString);
SetupData.init(SetupData.FLOW_MODE_NORMAL, account);
return new Intent(Intent.ACTION_MAIN);
Bundle extras = new Bundle();
extras.putParcelable(SetupData.EXTRA_SETUP_DATA, new SetupData(SetupData.FLOW_MODE_NORMAL, account));
Intent intent = new Intent(Intent.ACTION_MAIN);
intent.putExtras(extras);
return intent;
}
}

4
tests/src/com/android/email/activity/setup/AccountSetupOptionsTests.java
View File

@ -51,7 +51,7 @@ public class AccountSetupOptionsTests
/**
* Test that POP accounts aren't displayed with a push option
*/
public void testPushOptionPOP()
public void testPushOptionPOP()
throws URISyntaxException {
Intent i = getTestIntent("Name", "pop3://user:password@server.com");
this.setActivityIntent(i);
@ -169,7 +169,7 @@ public class AccountSetupOptionsTests
Context context = getInstrumentation().getTargetContext();
HostAuth auth = account.getOrCreateHostAuthRecv(context);
HostAuth.setHostAuthFromString(auth, storeUri);
SetupData.init(SetupData.FLOW_MODE_NORMAL, account);
SetupData setupData = new SetupData(SetupData.FLOW_MODE_NORMAL, account);
return new Intent(Intent.ACTION_MAIN);
}

16
tests/src/com/android/email/activity/setup/AccountSetupOutgoingTests.java
View File

@ -16,10 +16,6 @@
package com.android.email.activity.setup;
import com.android.email.R;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.HostAuth;
import android.content.Context;
import android.content.Intent;
import android.test.ActivityInstrumentationTestCase2;
@ -27,6 +23,13 @@ import android.test.UiThreadTest;
import android.test.suitebuilder.annotation.MediumTest;
import android.widget.EditText;
import com.android.email.R;
import com.android.email.activity.setup.AccountSetupOutgoing;
import com.android.email.activity.setup.AccountSetupOutgoingFragment;
import com.android.email.activity.setup.SetupData;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.HostAuth;
import java.net.URISyntaxException;
/**
@ -174,7 +177,7 @@ public class AccountSetupOutgoingTests extends
mActivity = getActivity();
mFragment = mActivity.mFragment;
mServerView = (EditText) mActivity.findViewById(R.id.account_server);
mPasswordView = (EditText) mActivity.findViewById(R.id.account_password);
mPasswordView = (EditText) mActivity.findViewById(R.id.account_server);
}
/**
@ -186,7 +189,8 @@ public class AccountSetupOutgoingTests extends
Context context = getInstrumentation().getTargetContext();
HostAuth auth = account.getOrCreateHostAuthSend(context);
HostAuth.setHostAuthFromString(auth, senderUriString);
SetupData.init(SetupData.FLOW_MODE_NORMAL, account);
// TODO: we need to do something with this SetupData, add it as an extra in the intent?
SetupData setupData = new SetupData(SetupData.FLOW_MODE_NORMAL, account);
return new Intent(Intent.ACTION_MAIN);
}

10
tests/src/com/android/email/mail/store/ImapStoreUnitTests.java
View File

@ -29,13 +29,12 @@ import android.test.suitebuilder.annotation.SmallTest;
import com.android.email.DBTestHelper;
import com.android.email.MockSharedPreferences;
import com.android.email.MockVendorPolicy;
import com.android.email.VendorPolicyLoader;
import com.android.email.mail.Transport;
import com.android.email.mail.store.ImapStore.ImapMessage;
import com.android.email.mail.store.imap.ImapResponse;
import com.android.email.mail.store.imap.ImapTestUtils;
import com.android.email.mail.transport.MockTransport;
import com.android.emailcommon.TempDirectory;
import com.android.emailcommon.VendorPolicyLoader;
import com.android.emailcommon.internet.MimeBodyPart;
import com.android.emailcommon.internet.MimeMultipart;
import com.android.emailcommon.internet.MimeUtility;
@ -95,6 +94,7 @@ public class ImapStoreUnitTests extends InstrumentationTestCase {
private ImapStore mStore = null;
private ImapFolder mFolder = null;
private Context mTestContext;
private HostAuth mHostAuth;
/** The tag for the current IMAP command; used for mock transport responses */
private int mTag;
@ -204,7 +204,7 @@ public class ImapStoreUnitTests extends InstrumentationTestCase {
*/
public void testTlsOpen() throws MessagingException {
MockTransport mockTransport = openAndInjectMockTransport(Transport.CONNECTION_SECURITY_TLS,
MockTransport mockTransport = openAndInjectMockTransport(HostAuth.FLAG_TLS,
false);
// try to open it, with STARTTLS
@ -544,7 +544,7 @@ public class ImapStoreUnitTests extends InstrumentationTestCase {
* Set up a basic MockTransport. open it, and inject it into mStore
*/
private MockTransport openAndInjectMockTransport() {
return openAndInjectMockTransport(Transport.CONNECTION_SECURITY_NONE, false);
return openAndInjectMockTransport(HostAuth.FLAG_NONE, false);
}
/**
@ -553,7 +553,7 @@ public class ImapStoreUnitTests extends InstrumentationTestCase {
private MockTransport openAndInjectMockTransport(int connectionSecurity,
boolean trustAllCertificates) {
// Create mock transport and inject it into the ImapStore that's already set up
MockTransport mockTransport = new MockTransport();
MockTransport mockTransport = MockTransport.createMockTransport(mTestContext);
mockTransport.setSecurity(connectionSecurity, trustAllCertificates);
mockTransport.setHost("mock.server.com");
mStore.setTransportForTest(mockTransport);

17
tests/src/com/android/email/mail/store/Pop3StoreUnitTests.java
View File

@ -20,9 +20,7 @@ import android.content.Context;
import android.test.AndroidTestCase;
import android.test.suitebuilder.annotation.SmallTest;
import com.android.email.Controller;
import com.android.email.DBTestHelper;
import com.android.email.mail.Transport;
import com.android.email.mail.transport.MockTransport;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.TempDirectory;
@ -54,6 +52,7 @@ public class Pop3StoreUnitTests extends AndroidTestCase {
private Pop3Store.Pop3Folder mFolder = null;
private Context mMockContext;
private HostAuth mHostAuth;
/**
* Setup code. We generate a lightweight Pop3Store and Pop3Store.Pop3Folder.
@ -63,19 +62,17 @@ public class Pop3StoreUnitTests extends AndroidTestCase {
super.setUp();
mMockContext = DBTestHelper.ProviderContextSetupHelper.getProviderContext(
getContext());
Controller.getInstance(mMockContext).setProviderContext(mMockContext);
Controller.getInstance(mMockContext).markForTest(true);
// Use the target's (i.e. the Email application) context
TempDirectory.setTempDirectory(mMockContext);
// These are needed so we can get at the inner classes
HostAuth testAuth = new HostAuth();
mHostAuth = new HostAuth();
Account testAccount = ProviderTestUtils.setupAccount("acct1", false, mMockContext);
testAuth.setLogin("user", "password");
testAuth.setConnection("pop3", "server", 999);
testAccount.mHostAuthRecv = testAuth;
mHostAuth.setLogin("user", "password");
mHostAuth.setConnection("pop3", "server", 999);
testAccount.mHostAuthRecv = mHostAuth;
testAccount.save(mMockContext);
mStore = (Pop3Store) Pop3Store.newInstance(testAccount, mMockContext);
mFolder = (Pop3Store.Pop3Folder) mStore.getFolder("INBOX");
@ -872,8 +869,8 @@ public class Pop3StoreUnitTests extends AndroidTestCase {
*/
private MockTransport openAndInjectMockTransport() {
// Create mock transport and inject it into the POP3Store that's already set up
MockTransport mockTransport = new MockTransport();
mockTransport.setSecurity(Transport.CONNECTION_SECURITY_NONE, false);
MockTransport mockTransport = new MockTransport(mContext, mHostAuth);
mockTransport.setSecurity(HostAuth.FLAG_NONE, false);
mStore.setTransport(mockTransport);
return mockTransport;
}

27
tests/src/com/android/email/mail/store/imap/ImapUtilityTests.java
View File

@ -16,14 +16,11 @@
package com.android.email.mail.store.imap;
import com.android.email.mail.store.imap.ImapUtility;
import android.test.AndroidTestCase;
import android.test.MoreAsserts;
import libcore.util.EmptyArray;
public class ImapUtilityTests extends AndroidTestCase {
public static final String[] EmptyArrayString = new String[0];
/**
* Tests of the IMAP quoting rules function.
@ -75,19 +72,19 @@ public class ImapUtilityTests extends AndroidTestCase {
MoreAsserts.assertEquals(expected, actual);
// Test invalid sets
expected = EmptyArray.STRING;
expected = EmptyArrayString;
actual = ImapUtility.getImapSequenceValues("");
MoreAsserts.assertEquals(expected, actual);
expected = EmptyArray.STRING;
expected = EmptyArrayString;
actual = ImapUtility.getImapSequenceValues(null);
MoreAsserts.assertEquals(expected, actual);
expected = EmptyArray.STRING;
expected = EmptyArrayString;
actual = ImapUtility.getImapSequenceValues("a");
MoreAsserts.assertEquals(expected, actual);
expected = EmptyArray.STRING;
expected = EmptyArrayString;
actual = ImapUtility.getImapSequenceValues("1:x");
MoreAsserts.assertEquals(expected, actual);
}
@ -109,31 +106,31 @@ public class ImapUtilityTests extends AndroidTestCase {
MoreAsserts.assertEquals(expected, actual);
// Test in-valid ranges
expected = EmptyArray.STRING;
expected = EmptyArrayString;
actual = ImapUtility.getImapRangeValues("");
MoreAsserts.assertEquals(expected, actual);
expected = EmptyArray.STRING;
expected = EmptyArrayString;
actual = ImapUtility.getImapRangeValues(null);
MoreAsserts.assertEquals(expected, actual);
expected = EmptyArray.STRING;
expected = EmptyArrayString;
actual = ImapUtility.getImapRangeValues("a");
MoreAsserts.assertEquals(expected, actual);
expected = EmptyArray.STRING;
expected = EmptyArrayString;
actual = ImapUtility.getImapRangeValues("6");
MoreAsserts.assertEquals(expected, actual);
expected = EmptyArray.STRING;
expected = EmptyArrayString;
actual = ImapUtility.getImapRangeValues("1:3,6");
MoreAsserts.assertEquals(expected, actual);
expected = EmptyArray.STRING;
expected = EmptyArrayString;
actual = ImapUtility.getImapRangeValues("1:x");
MoreAsserts.assertEquals(expected, actual);
expected = EmptyArray.STRING;
expected = EmptyArrayString;
actual = ImapUtility.getImapRangeValues("1:*");
MoreAsserts.assertEquals(expected, actual);
}

118
tests/src/com/android/email/mail/transport/MockTransport.java
View File

@ -1,22 +1,27 @@
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.android.email.mail.transport;
import com.android.email.mail.Transport;
import android.content.Context;
import com.android.emailcommon.provider.HostAuth;
import com.android.mail.utils.LogUtils;
import junit.framework.Assert;
import java.io.IOException;
import java.io.InputStream;
@ -26,12 +31,10 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.regex.Pattern;
import junit.framework.Assert;
/**
* This is a mock Transport that is used to test protocols that use MailTransport.
*/
public class MockTransport implements Transport {
public class MockTransport extends MailTransport {
// All flags defining debug or development code settings must be FALSE
// when code is checked in or released.
@ -45,9 +48,6 @@ public class MockTransport implements Transport {
private boolean mOpen;
private boolean mInputOpen;
private int mConnectionSecurity;
private boolean mTrustCertificates;
private String mHost;
private InetAddress mLocalAddress;
private ArrayList<String> mQueuedInput = new ArrayList<String>();
@ -93,12 +93,20 @@ public class MockTransport implements Transport {
private ArrayList<Transaction> mPairs = new ArrayList<Transaction>();
public static MockTransport createMockTransport(Context context) {
return new MockTransport(context, new HostAuth());
}
public MockTransport(Context context, HostAuth hostAuth) {
super(context, LOG_TAG, hostAuth);
}
/**
* Give the mock a pattern to wait for. No response will be sent.
* @param pattern Java RegEx to wait for
*/
public void expect(String pattern) {
expect(pattern, (String[])null);
expect(pattern, (String[]) null);
}
/**
@ -107,7 +115,7 @@ public class MockTransport implements Transport {
* @param response String to reply with, or null to acccept string but not respond to it
*/
public void expect(String pattern, String response) {
expect(pattern, (response == null) ? null : new String[] { response });
expect(pattern, (response == null) ? null : new String[] {response});
}
/**
@ -160,21 +168,6 @@ public class MockTransport implements Transport {
}
}
@Override
public boolean canTrySslSecurity() {
return (mConnectionSecurity == CONNECTION_SECURITY_SSL);
}
@Override
public boolean canTryTlsSecurity() {
return (mConnectionSecurity == Transport.CONNECTION_SECURITY_TLS);
}
@Override
public boolean canTrustAllCertificates() {
return mTrustCertificates;
}
/**
* Check that TLS was started
*/
@ -205,16 +198,6 @@ public class MockTransport implements Transport {
mPairs.clear();
}
@Override
public void setHost(String host) {
mHost = host;
}
@Override
public String getHost() {
return mHost;
}
public void setMockLocalAddress(InetAddress address) {
mLocalAddress = address;
}
@ -231,8 +214,8 @@ public class MockTransport implements Transport {
* don't have to worry about dealing with test metadata like the expects list or socket state.
*/
@Override
public Transport clone() {
return this;
public MockTransport clone() {
return this;
}
@Override
@ -241,21 +224,6 @@ public class MockTransport implements Transport {
return new MockOutputStream();
}
@Override
public void setPort(int port) {
SmtpSenderUnitTests.fail("setPort() not implemented");
}
@Override
public int getPort() {
SmtpSenderUnitTests.fail("getPort() not implemented");
return 0;
}
@Override
public int getSecurity() {
return mConnectionSecurity;
}
@Override
public boolean isOpen() {
@ -263,7 +231,10 @@ public class MockTransport implements Transport {
}
@Override
public void open() /* throws MessagingException, CertificateValidationException */ {
public void open() /*
* throws MessagingException,
* CertificateValidationException
*/{
mOpen = true;
mInputOpen = true;
}
@ -278,13 +249,13 @@ public class MockTransport implements Transport {
*
* Logs the read text if DEBUG_LOG_STREAMS is true.
*/
@Override
public String readLine() throws IOException {
SmtpSenderUnitTests.assertTrue(mOpen);
if (!mInputOpen) {
throw new IOException("Reading from MockTransport with closed input");
}
// if there's nothing to read, see if we can find a null-pattern response
// if there's nothing to read, see if we can find a null-pattern
// response
if ((mQueuedInput.size() == 0) && (mPairs.size() > 0)) {
Transaction pair = mPairs.get(0);
if (pair.mPattern == null) {
@ -308,22 +279,24 @@ public class MockTransport implements Transport {
}
@Override
public void reopenTls() /* throws MessagingException */ {
public void reopenTls() /* throws MessagingException */{
SmtpSenderUnitTests.assertTrue(mOpen);
Transaction expect = mPairs.remove(0);
SmtpSenderUnitTests.assertTrue(expect.mAction == Transaction.ACTION_START_TLS);
mTlsStarted = true;
}
@Override
public void setSecurity(int connectionSecurity, boolean trustAllCertificates) {
mConnectionSecurity = connectionSecurity;
mTrustCertificates = trustAllCertificates;
mHostAuth.mFlags =
connectionSecurity & (trustAllCertificates ? HostAuth.FLAG_TRUST_ALL : 0xff);
}
public void setHost(String address) {
mHostAuth.mAddress = address;
}
@Override
public void setSoTimeout(int timeoutMilliseconds) /* throws SocketException */ {
}
public void setSoTimeout(int timeoutMilliseconds) /* throws SocketException */{}
/**
* Accepts a single string (command or text) that was written by the code under test.
@ -340,15 +313,14 @@ public class MockTransport implements Transport {
LogUtils.d(LOG_TAG, ">>> " + s);
}
SmtpSenderUnitTests.assertTrue(mOpen);
SmtpSenderUnitTests.assertTrue("Overflow writing to MockTransport: Getting " + s,
0 != mPairs.size());
SmtpSenderUnitTests.assertTrue(
"Overflow writing to MockTransport: Getting " + s, 0 != mPairs.size());
Transaction pair = mPairs.remove(0);
if (pair.mAction == Transaction.ACTION_IO_EXCEPTION) {
throw new IOException("Expected IOException.");
}
SmtpSenderUnitTests.assertTrue("Unexpected string written to MockTransport: Actual=" + s
+ " Expected=" + pair.mPattern,
pair.mPattern != null && s.matches(pair.mPattern));
+ " Expected=" + pair.mPattern, pair.mPattern != null && s.matches(pair.mPattern));
if (pair.mResponses != null) {
sendResponse(pair);
}
@ -408,7 +380,7 @@ public class MockTransport implements Transport {
} else if (oneByte == '\n') {
// swallow it
} else {
sb.append((char)oneByte);
sb.append((char) oneByte);
}
}
}

19
tests/src/com/android/email/mail/transport/SmtpSenderUnitTests.java
View File

@ -21,7 +21,6 @@ import android.test.AndroidTestCase;
import android.test.suitebuilder.annotation.SmallTest;
import com.android.email.DBTestHelper;
import com.android.email.mail.Transport;
import com.android.email.provider.EmailProvider;
import com.android.emailcommon.mail.Address;
import com.android.emailcommon.mail.MessagingException;
@ -48,6 +47,7 @@ public class SmtpSenderUnitTests extends AndroidTestCase {
EmailProvider mProvider;
Context mProviderContext;
Context mContext;
HostAuth mHostAuth;
private static final String LOCAL_ADDRESS = "1.2.3.4";
/* These values are provided by setUp() */
@ -67,12 +67,12 @@ public class SmtpSenderUnitTests extends AndroidTestCase {
getContext());
mContext = getContext();
HostAuth testAuth = new HostAuth();
mHostAuth = new HostAuth();
Account testAccount = new Account();
testAuth.setLogin("user", "password");
testAuth.setConnection("smtp", "server", 999);
testAccount.mHostAuthSend = testAuth;
mHostAuth.setLogin("user", "password");
mHostAuth.setConnection("smtp", "server", 999);
testAccount.mHostAuthSend = mHostAuth;
mSender = (SmtpSender) SmtpSender.newInstance(testAccount, mProviderContext);
}
@ -195,7 +195,7 @@ public class SmtpSenderUnitTests extends AndroidTestCase {
attachment.mMimeType = "image/jpg";
attachment.mSize = 0;
attachment.mContentId = null;
attachment.mContentUri = "content://com.android.email/1/1";
attachment.setContentUri("content://com.android.email/1/1");
attachment.mMessageKey = messageId;
attachment.mLocation = null;
attachment.mEncoding = null;
@ -214,7 +214,8 @@ public class SmtpSenderUnitTests extends AndroidTestCase {
mockTransport.expect(" filename=\"" + attachment.mFileName + "\";");
mockTransport.expect(" size=" + Long.toString(attachment.mSize));
mockTransport.expect("");
if (attachment.mContentUri != null && attachment.mContentUri.startsWith("file://")) {
String attachmentContentUri = attachment.getContentUri();
if (attachmentContentUri != null && attachmentContentUri.startsWith("file://")) {
mockTransport.expect(TEST_STRING_BASE64);
}
}
@ -248,8 +249,8 @@ public class SmtpSenderUnitTests extends AndroidTestCase {
*/
private MockTransport openAndInjectMockTransport() throws UnknownHostException {
// Create mock transport and inject it into the SmtpSender that's already set up
MockTransport mockTransport = new MockTransport();
mockTransport.setSecurity(Transport.CONNECTION_SECURITY_NONE, false);
MockTransport mockTransport = new MockTransport(mContext, mHostAuth);
mockTransport.setSecurity(HostAuth.FLAG_NONE, false);
mSender.setTransport(mockTransport);
mockTransport.setMockLocalAddress(InetAddress.getByName(LOCAL_ADDRESS));
return mockTransport;

4
tests/src/com/android/email/provider/AccountBackupRestoreTests.java
View File

@ -62,9 +62,7 @@ public class AccountBackupRestoreTests extends ProviderTestCase2<EmailProvider>
assertEquals(" mSyncLookback", expect.mSyncLookback, actual.mSyncLookback);
assertEquals(" mSyncInterval", expect.mSyncInterval, actual.mSyncInterval);
assertEquals(" mFlags", expect.mFlags, actual.mFlags);
assertEquals(" mIsDefault", expect.mIsDefault, actual.mIsDefault);
assertEquals(" mSenderName", expect.mSenderName, actual.mSenderName);
assertEquals(" mRingtoneUri", expect.mRingtoneUri, actual.mRingtoneUri);
assertEquals(" mProtocolVersion", expect.mProtocolVersion,
actual.mProtocolVersion);
assertEquals(" mNewMessageCount", expect.mNewMessageCount,
@ -88,7 +86,6 @@ public class AccountBackupRestoreTests extends ProviderTestCase2<EmailProvider>
ProviderTestUtils.setupHostAuth("legacy-recv", 0, false, mMockContext);
saved1.mHostAuthSend =
ProviderTestUtils.setupHostAuth("legacy-send", 0, false, mMockContext);
saved1.setDefaultAccount(true);
saved1.save(mMockContext);
Account saved2 =
ProviderTestUtils.setupAccount("testBackup2", false, mMockContext);
@ -96,7 +93,6 @@ public class AccountBackupRestoreTests extends ProviderTestCase2<EmailProvider>
ProviderTestUtils.setupHostAuth("legacy-recv", 0, false, mMockContext);
saved2.mHostAuthSend =
ProviderTestUtils.setupHostAuth("legacy-send", 0, false, mMockContext);
saved2.setDefaultAccount(false);
saved2.save(mMockContext);
// Make sure they're in the database
assertEquals(2, EmailContent.count(mMockContext, Account.CONTENT_URI));

36
tests/src/com/android/email/provider/AttachmentProviderTests.java
View File

@ -54,7 +54,7 @@ public class AttachmentProviderTests extends ProviderTestCase2<AttachmentProvide
ContentResolver mMockResolver;
public AttachmentProviderTests() {
super(AttachmentProvider.class, AttachmentUtilities.AUTHORITY);
super(AttachmentProvider.class, Attachment.ATTACHMENT_PROVIDER_LEGACY_URI_PREFIX);
}
@Override
@ -71,18 +71,6 @@ public class AttachmentProviderTests extends ProviderTestCase2<AttachmentProvide
.addProvider(EmailContent.AUTHORITY, mEmailProvider);
}
/**
* test delete() - should do nothing
* test update() - should do nothing
* test insert() - should do nothing
*/
public void testUnimplemented() {
assertEquals(0, mMockResolver.delete(AttachmentUtilities.CONTENT_URI, null, null));
assertEquals(0, mMockResolver.update(AttachmentUtilities.CONTENT_URI, null, null,
null));
assertEquals(null, mMockResolver.insert(AttachmentUtilities.CONTENT_URI, null));
}
/**
* test query()
* - item found
@ -117,22 +105,22 @@ public class AttachmentProviderTests extends ProviderTestCase2<AttachmentProvide
// sample the files, so we won't bother creating the files
Attachment newAttachment1 = ProviderTestUtils.setupAttachment(message1Id, "file1", 100,
false, mMockContext);
newAttachment1.mContentUri =
AttachmentUtilities.getAttachmentUri(account1.mId, attachment1Id).toString();
newAttachment1.setContentUri(
AttachmentUtilities.getAttachmentUri(account1.mId, attachment1Id).toString());
attachment1Id = addAttachmentToDb(account1, newAttachment1);
assertEquals("Broken test: Unexpected id assignment", 1, attachment1Id);
Attachment newAttachment2 = ProviderTestUtils.setupAttachment(message1Id, "file2", 200,
false, mMockContext);
newAttachment2.mContentUri =
AttachmentUtilities.getAttachmentUri(account1.mId, attachment2Id).toString();
newAttachment2.setContentUri(
AttachmentUtilities.getAttachmentUri(account1.mId, attachment2Id).toString());
attachment2Id = addAttachmentToDb(account1, newAttachment2);
assertEquals("Broken test: Unexpected id assignment", 2, attachment2Id);
Attachment newAttachment3 = ProviderTestUtils.setupAttachment(message1Id, "file3", 300,
false, mMockContext);
newAttachment3.mContentUri =
AttachmentUtilities.getAttachmentUri(account1.mId, attachment3Id).toString();
newAttachment3.setContentUri(
AttachmentUtilities.getAttachmentUri(account1.mId, attachment3Id).toString());
attachment3Id = addAttachmentToDb(account1, newAttachment3);
assertEquals("Broken test: Unexpected id assignment", 3, attachment3Id);
@ -381,9 +369,9 @@ public class AttachmentProviderTests extends ProviderTestCase2<AttachmentProvide
Attachment newAttachment2 = ProviderTestUtils.setupAttachment(message1Id, "file", 100,
false, mMockContext);
newAttachment2.mContentId = null;
newAttachment2.mContentUri =
newAttachment2.setContentUri(
AttachmentUtilities.getAttachmentUri(account1.mId, attachment2Id)
.toString();
.toString());
newAttachment2.mMimeType = "image/png";
attachment2Id = addAttachmentToDb(account1, newAttachment2);
assertEquals("Broken test: Unexpected id assignment", 2, attachment2Id);
@ -440,9 +428,9 @@ public class AttachmentProviderTests extends ProviderTestCase2<AttachmentProvide
Attachment newAttachment2 = ProviderTestUtils.setupAttachment(message1Id, "file", 100,
false, mMockContext);
newAttachment2.mContentId = null;
newAttachment2.mContentUri =
newAttachment2.setContentUri(
AttachmentUtilities.getAttachmentUri(account1.mId, attachment2Id)
.toString();
.toString());
newAttachment2.mMimeType = "image/png";
attachment2Id = addAttachmentToDb(account1, newAttachment2);
assertEquals("Broken test: Unexpected id assignment", 2, attachment2Id);
@ -458,7 +446,7 @@ public class AttachmentProviderTests extends ProviderTestCase2<AttachmentProvide
// Add an attachment entry.
Attachment newAttachment = ProviderTestUtils.setupAttachment(messageId, "file", 100,
false, mMockContext);
newAttachment.mContentUri = contentUriStr;
newAttachment.setContentUri(contentUriStr);
long attachmentId = addAttachmentToDb(account, newAttachment);
Uri attachmentUri = AttachmentUtilities.getAttachmentUri(account.mId, attachmentId);
return attachmentUri;

15
tests/src/com/android/email/provider/ContentCacheTests.java
View File

@ -16,13 +16,6 @@
package com.android.email.provider;
import com.android.email.provider.ContentCache.CacheToken;
import com.android.email.provider.ContentCache.CachedCursor;
import com.android.email.provider.ContentCache.TokenList;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.EmailContent;
import com.android.emailcommon.provider.Mailbox;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
@ -32,6 +25,14 @@ import android.database.MatrixCursor;
import android.net.Uri;
import android.test.ProviderTestCase2;
import com.android.email.provider.ContentCache.CacheToken;
import com.android.email.provider.ContentCache.CachedCursor;
import com.android.email.provider.ContentCache.TokenList;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.EmailContent;
import com.android.emailcommon.provider.Mailbox;
import com.android.mail.utils.MatrixCursorWithCachedColumns;
/**
* Tests of ContentCache
*

21
tests/src/com/android/email/provider/PolicyTests.java
View File

@ -16,6 +16,12 @@
package com.android.email.provider;
import android.content.Context;
import android.os.Parcel;
import android.test.ProviderTestCase2;
import android.test.suitebuilder.annotation.MediumTest;
import com.android.email.SecurityPolicy;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.EmailContent;
import com.android.emailcommon.provider.EmailContent.Attachment;
@ -24,11 +30,6 @@ import com.android.emailcommon.provider.EmailContent.Message;
import com.android.emailcommon.provider.Mailbox;
import com.android.emailcommon.provider.Policy;
import android.content.Context;
import android.os.Parcel;
import android.test.ProviderTestCase2;
import android.test.suitebuilder.annotation.MediumTest;
import java.util.ArrayList;
/**
@ -68,10 +69,10 @@ public class PolicyTests extends ProviderTestCase2<EmailProvider> {
// Setup two accounts with policies
Account account1 = ProviderTestUtils.setupAccount("acct1", true, mMockContext);
Policy policy1 = new Policy();
Policy.setAccountPolicy(mMockContext, account1, policy1, securitySyncKey);
SecurityPolicy.setAccountPolicy(mMockContext, account1, policy1, securitySyncKey);
Account account2 = ProviderTestUtils.setupAccount("acct2", true, mMockContext);
Policy policy2 = new Policy();
Policy.setAccountPolicy(mMockContext, account2, policy2, securitySyncKey);
SecurityPolicy.setAccountPolicy(mMockContext, account2, policy2, securitySyncKey);
// Get the accounts back from the database
account1.refresh(mMockContext);
account2.refresh(mMockContext);
@ -92,7 +93,7 @@ public class PolicyTests extends ProviderTestCase2<EmailProvider> {
assertEquals(0, account.mPolicyKey);
assertEquals(0, EmailContent.count(mMockContext, Policy.CONTENT_URI));
Policy policy = new Policy();
Policy.setAccountPolicy(mMockContext, account, policy, securitySyncKey);
SecurityPolicy.setAccountPolicy(mMockContext, account, policy, securitySyncKey);
account.refresh(mMockContext);
// We should have a policyKey now
assertTrue(account.mPolicyKey > 0);
@ -103,7 +104,7 @@ public class PolicyTests extends ProviderTestCase2<EmailProvider> {
assertEquals(policy, dbPolicy);
// The account should have the security sync key set
assertEquals(securitySyncKey, account.mSecuritySyncKey);
Policy.clearAccountPolicy(mMockContext, account);
SecurityPolicy.clearAccountPolicy(mMockContext, account);
account.refresh(mMockContext);
// Make sure policyKey is cleared and policy is deleted
assertEquals(0, account.mPolicyKey);
@ -122,7 +123,7 @@ public class PolicyTests extends ProviderTestCase2<EmailProvider> {
Account acct = ProviderTestUtils.setupAccount("acct1", true, mMockContext);
Policy policy1 = new Policy();
policy1.mDontAllowAttachments = true;
Policy.setAccountPolicy(mMockContext, acct, policy1, null);
SecurityPolicy.setAccountPolicy(mMockContext, acct, policy1, null);
Mailbox box = ProviderTestUtils.setupMailbox("box1", acct.mId, true, mMockContext);
Message msg1 = ProviderTestUtils.setupMessage("message1", acct.mId, box.mId, false, false,
mMockContext);

50
tests/src/com/android/email/provider/ProviderTestUtils.java
View File

@ -58,10 +58,8 @@ public class ProviderTestUtils extends Assert {
account.mHostAuthKeyRecv = 0;
account.mHostAuthKeySend = 0;
account.mFlags = 4;
account.mIsDefault = true;
account.mCompatibilityUuid = "test-uid-" + name;
account.mSenderName = name;
account.mRingtoneUri = "content://ringtone-" + name;
account.mProtocolVersion = "2.5" + name;
account.mNewMessageCount = 5 + name.length();
account.mPolicyKey = 0;
@ -143,7 +141,6 @@ public class ProviderTestUtils extends Assert {
box.mSyncTime = 3;
box.mFlagVisible = true;
box.mFlags = 5;
box.mVisibleLimit = 6;
if (saveIt) {
box.save(context);
@ -171,6 +168,7 @@ public class ProviderTestUtils extends Assert {
message.mTimeStamp = 100 + name.length();
message.mSubject = "subject " + name;
message.mFlagRead = read;
message.mFlagSeen = read;
message.mFlagLoaded = Message.FLAG_LOADED_UNLOADED;
message.mFlagFavorite = starred;
message.mFlagAttachment = true;
@ -178,7 +176,6 @@ public class ProviderTestUtils extends Assert {
message.mServerId = "serverid " + name;
message.mServerTimeStamp = 300 + name.length();
message.mClientId = "clientid " + name;
message.mMessageId = "messageid " + name;
message.mMailboxKey = mailboxId;
@ -220,12 +217,9 @@ public class ProviderTestUtils extends Assert {
boolean saveIt, Context context) {
Body body = new Body();
body.mMessageKey = messageId;
body.mTextContent = textContent;
body.mHtmlContent = htmlContent;
body.mTextReply = "text reply " + messageId;
body.mHtmlReply = "html reply " + messageId;
body.mTextContent = textContent;
body.mSourceKey = messageId + 0x1000;
body.mIntroText = "intro text " + messageId;
if (saveIt) {
body.save(context);
}
@ -249,7 +243,7 @@ public class ProviderTestUtils extends Assert {
att.mSize = length;
att.mFileName = fileName;
att.mContentId = "contentId " + fileName;
att.mContentUri = "contentUri " + fileName;
att.setContentUri("contentUri " + fileName);
att.mMessageKey = messageId;
att.mMimeType = "mimeType " + fileName;
att.mLocation = "location " + fileName;
@ -310,19 +304,18 @@ public class ProviderTestUtils extends Assert {
assertEquals(caller + " mHostAuthKeySend", expect.mHostAuthKeySend,
actual.mHostAuthKeySend);
assertEquals(caller + " mFlags", expect.mFlags, actual.mFlags);
assertEquals(caller + " mIsDefault", expect.mIsDefault, actual.mIsDefault);
assertEquals(caller + " mCompatibilityUuid", expect.mCompatibilityUuid,
actual.mCompatibilityUuid);
assertEquals(caller + " mSenderName", expect.mSenderName, actual.mSenderName);
assertEquals(caller + " mRingtoneUri", expect.mRingtoneUri, actual.mRingtoneUri);
assertEquals(caller + " mProtocolVersion", expect.mProtocolVersion,
actual.mProtocolVersion);
assertEquals(caller + " mNewMessageCount", expect.mNewMessageCount,
actual.mNewMessageCount);
assertEquals(caller + " mPolicyKey", expect.mPolicyKey, actual.mPolicyKey);
assertEquals(caller + " mSecuritySyncKey", expect.mSecuritySyncKey,
actual.mSecuritySyncKey);
assertEquals(caller + " mSignature", expect.mSignature, actual.mSignature);
assertEquals(caller + " mPolicyKey", expect.mPolicyKey, actual.mPolicyKey);
assertEquals(caller + " mPingDuration", expect.mPingDuration, actual.mPingDuration);
}
/**
@ -373,8 +366,13 @@ public class ProviderTestUtils extends Assert {
assertEquals(caller + " mSyncInterval", expect.mSyncInterval, actual.mSyncInterval);
assertEquals(caller + " mSyncTime", expect.mSyncTime, actual.mSyncTime);
assertEquals(caller + " mFlagVisible", expect.mFlagVisible, actual.mFlagVisible);
assertEquals(caller + " mFlags", expect.mFlags, actual.mFlags);
assertEquals(caller + " mVisibleLimit", expect.mVisibleLimit, actual.mVisibleLimit);
assertEquals(caller + " mSyncStatus", expect.mSyncStatus, actual.mSyncStatus);
assertEquals(caller + " mLastTouchedTime", expect.mLastTouchedTime, actual.mLastTouchedTime);
assertEquals(caller + " mUiSyncStatus", expect.mUiSyncStatus, actual.mUiSyncStatus);
assertEquals(caller + " mUiLastSyncResult", expect.mUiLastSyncResult, actual.mUiLastSyncResult);
assertEquals(caller + " mTotalCount", expect.mTotalCount, actual.mTotalCount);
assertEquals(caller + " mHierarchicalName", expect.mHierarchicalName, actual.mHierarchicalName);
assertEquals(caller + " mLastFullSyncTime", expect.mLastFullSyncTime, actual.mLastFullSyncTime);
}
/**
@ -393,6 +391,7 @@ public class ProviderTestUtils extends Assert {
assertEquals(caller + " mTimeStamp", expect.mTimeStamp, actual.mTimeStamp);
assertEquals(caller + " mSubject", expect.mSubject, actual.mSubject);
assertEquals(caller + " mFlagRead = false", expect.mFlagRead, actual.mFlagRead);
assertEquals(caller + " mFlagRead = false", expect.mFlagSeen, actual.mFlagSeen);
assertEquals(caller + " mFlagLoaded", expect.mFlagLoaded, actual.mFlagLoaded);
assertEquals(caller + " mFlagFavorite", expect.mFlagFavorite, actual.mFlagFavorite);
assertEquals(caller + " mFlagAttachment", expect.mFlagAttachment, actual.mFlagAttachment);
@ -400,11 +399,12 @@ public class ProviderTestUtils extends Assert {
assertEquals(caller + " mServerId", expect.mServerId, actual.mServerId);
assertEquals(caller + " mServerTimeStamp", expect.mServerTimeStamp,actual.mServerTimeStamp);
assertEquals(caller + " mClientId", expect.mClientId, actual.mClientId);
assertEquals(caller + " mDraftInfo", expect.mDraftInfo,actual.mDraftInfo);
assertEquals(caller + " mMessageId", expect.mMessageId, actual.mMessageId);
assertEquals(caller + " mMailboxKey", expect.mMailboxKey, actual.mMailboxKey);
assertEquals(caller + " mAccountKey", expect.mAccountKey, actual.mAccountKey);
assertEquals(caller + " mMainMailboxKey", expect.mMainMailboxKey, actual.mMainMailboxKey);
assertEquals(caller + " mFrom", expect.mFrom, actual.mFrom);
assertEquals(caller + " mTo", expect.mTo, actual.mTo);
@ -416,12 +416,21 @@ public class ProviderTestUtils extends Assert {
assertEquals(caller + " mSnippet", expect.mSnippet, actual.mSnippet);
assertEquals(caller + " mProtocolSearchInfo", expect.mProtocolSearchInfo, actual.mProtocolSearchInfo);
assertEquals(caller + " mThreadTopic", expect.mThreadTopic, actual.mThreadTopic);
assertEquals(caller + " mSyncData", expect.mSyncData, actual.mSyncData);
assertEquals(caller + " mSyncData", expect.mServerConversationId, actual.mServerConversationId);
assertEquals(caller + " mText", expect.mText, actual.mText);
assertEquals(caller + " mHtml", expect.mHtml, actual.mHtml);
assertEquals(caller + " mTextReply", expect.mTextReply, actual.mTextReply);
assertEquals(caller + " mHtmlReply", expect.mHtmlReply, actual.mHtmlReply);
assertEquals(caller + " mSourceKey", expect.mSourceKey, actual.mSourceKey);
assertEquals(caller + " mIntroText", expect.mIntroText, actual.mIntroText);
assertEquals(caller + " mQuotedTextStartPos", expect.mQuotedTextStartPos, actual.mQuotedTextStartPos);
}
/**
@ -435,12 +444,13 @@ public class ProviderTestUtils extends Assert {
}
assertEmailContentEqual(caller, expect, actual);
assertEquals(caller + " mSize", expect.mSize, actual.mSize);
assertEquals(caller + " mFileName", expect.mFileName, actual.mFileName);
assertEquals(caller + " mContentId", expect.mContentId, actual.mContentId);
assertEquals(caller + " mContentUri", expect.mContentUri, actual.mContentUri);
assertEquals(caller + " mMessageKey", expect.mMessageKey, actual.mMessageKey);
assertEquals(caller + " mMimeType", expect.mMimeType, actual.mMimeType);
assertEquals(caller + " mSize", expect.mSize, actual.mSize);
assertEquals(caller + " mContentId", expect.mContentId, actual.mContentId);
assertEquals(caller + " mContentUri", expect.getContentUri(), actual.getContentUri());
assertEquals(caller + " mCachedFileUri", expect.getCachedFileUri(), actual.getCachedFileUri());
assertEquals(caller + " mMessageKey", expect.mMessageKey, actual.mMessageKey);
assertEquals(caller + " mLocation", expect.mLocation, actual.mLocation);
assertEquals(caller + " mEncoding", expect.mEncoding, actual.mEncoding);
assertEquals(caller + " mContent", expect.mContent, actual.mContent);
@ -459,7 +469,7 @@ public class ProviderTestUtils extends Assert {
File outputFile = File.createTempFile("message", "tmp", directory);
assertNotNull(outputFile);
FileOutputStream outputStream = new FileOutputStream(outputFile);
Rfc822Output.writeTo(context, msg.mId, outputStream, true, false);
Rfc822Output.writeTo(context, msg, outputStream, true, false, null);
outputStream.close();
return Uri.fromFile(outputFile);

1291
tests/src/com/android/email/provider/ProviderTests.java
View File

File diff suppressed because it is too large Load Diff

7
tests/src/com/android/email/service/AttachmentDownloadServiceTests.java
View File

@ -17,14 +17,12 @@
package com.android.email.service;
import android.content.Context;
import android.content.Intent;
import com.android.email.AccountTestCase;
import com.android.email.EmailConnectivityManager;
import com.android.email.provider.ProviderTestUtils;
import com.android.email.service.AttachmentDownloadService.DownloadRequest;
import com.android.email.service.AttachmentDownloadService.DownloadSet;
import com.android.email.service.EmailServiceUtils.NullEmailService;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.EmailContent.Attachment;
import com.android.emailcommon.provider.EmailContent.Message;
@ -70,8 +68,9 @@ public class AttachmentDownloadServiceTests extends AccountTestCase {
// Use the NullEmailService so that the loadAttachment calls become no-ops
mService = new AttachmentDownloadService();
mService.mContext = mMockContext;
mService.addServiceIntentForTest(mAccountId, new Intent(mContext,
NullEmailService.class));
// there's no NullEmailService class
/*mService.addServiceIntentForTest(mAccountId, new Intent(mContext,
NullEmailService.class));*/
mAccountManagerStub = new AttachmentDownloadService.AccountManagerStub(null);
mService.mAccountManagerStub = mAccountManagerStub;
mService.mConnectivityManager = new MockConnectivityManager(mContext, "mock");

13
tests/src/com/android/email/service/EmailBroadcastProcessorServiceTests.java
View File

@ -135,17 +135,4 @@ public class EmailBroadcastProcessorServiceTests extends AccountTestCase {
assertEquals(0x00000008, accountFlags6);
}
public void testNoopRemover() {
final Map<String, String> protocolMap = Maps.newHashMap();
protocolMap.put("imap", "imap");
protocolMap.put("pop3", "gPop3");
EmailBroadcastProcessorService.removeNoopUpgrades(protocolMap);
final Map<String, String> protocolMapExpected = Maps.newHashMap();
protocolMapExpected.put("pop3", "gPop3");
assertEquals(protocolMap, protocolMapExpected);
}
}

31
tests/src/com/android/email/service/MailServiceTests.java
View File

@ -25,11 +25,9 @@ import android.content.Context;
import android.content.pm.PackageManager;
import com.android.email.AccountTestCase;
import com.android.email.Controller;
import com.android.email.provider.AccountReconciler;
import com.android.email.provider.EmailProvider;
import com.android.email.provider.ProviderTestUtils;
import com.android.email.service.MailService.AccountSyncReport;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.EmailContent;
import com.android.emailcommon.provider.HostAuth;
@ -46,7 +44,7 @@ import java.util.List;
*/
public class MailServiceTests extends AccountTestCase {
EmailProvider mProvider;
/*EmailProvider mProvider;
Context mMockContext;
public MailServiceTests() {
@ -71,13 +69,13 @@ public class MailServiceTests extends AccountTestCase {
super.tearDown();
// Delete any test accounts we might have created earlier
deleteTemporaryAccountManagerAccounts();
}
}*/
/**
* Confirm that the test below is functional (and non-destructive) when there are
* prexisting (non-test) accounts in the account manager.
*/
public void testTestReconcileAccounts() {
/*public void testTestReconcileAccounts() {
Account firstAccount = null;
final String TEST_USER_ACCOUNT = "__user_account_test_1";
Context context = getContext();
@ -106,13 +104,13 @@ public class MailServiceTests extends AccountTestCase {
assertTrue(firstAccountFound);
}
}
}
}*/
/**
* Note, there is some inherent risk in this test, as it creates *real* accounts in the
* system (it cannot use the mock context with the Account Manager).
*/
public void testReconcileAccounts() {
/*public void testReconcileAccounts() {
// Note that we can't use mMockContext for AccountManager interactions, as it isn't a fully
// functional Context.
Context context = getContext();
@ -165,32 +163,32 @@ public class MailServiceTests extends AccountTestCase {
assertEquals(1, accountManagerAccounts.length);
// ... and it should be account "3"
assertEquals(getTestAccountEmailAddress("3"), accountManagerAccounts[0].name);
}
}*/
/**
* Lightweight subclass of the Controller class allows injection of mock context
*/
public static class TestController extends Controller {
/*public static class TestController extends Controller {
protected TestController(Context providerContext, Context systemContext) {
super(systemContext);
setProviderContext(providerContext);
}
}
}*/
/**
* Create a simple HostAuth with protocol
*/
private HostAuth setupSimpleHostAuth(String protocol) {
/*private HostAuth setupSimpleHostAuth(String protocol) {
HostAuth hostAuth = new HostAuth();
hostAuth.mProtocol = protocol;
return hostAuth;
}
}*/
/**
* Initial testing on setupSyncReportsLocked, making sure that EAS accounts aren't scheduled
*/
public void testSetupSyncReportsLocked() {
/*public void testSetupSyncReportsLocked() {
// TODO Test other functionality within setupSyncReportsLocked
// Setup accounts of each type, all with manual sync at different intervals
Account easAccount = ProviderTestUtils.setupAccount("account1", false, mMockContext);
@ -243,13 +241,13 @@ public class MailServiceTests extends AccountTestCase {
} finally {
mailService.mController.cleanupForTest();
}
}
}*/
/**
* Test that setupSyncReports will skip over poorly-formed accounts which can be left
* over after unit tests.
*/
public void testSetupSyncReportsWithBadAccounts() {
/*public void testSetupSyncReportsWithBadAccounts() {
// Setup accounts that trigger each skip-over case
// 1: no email address
Account account1 = ProviderTestUtils.setupAccount("account1", false, mMockContext);
@ -282,6 +280,5 @@ public class MailServiceTests extends AccountTestCase {
} finally {
mailService.mController.cleanupForTest();
}
}
}*/
}

2
tests/src/com/android/emailcommon/DeviceTests.java
View File

@ -21,6 +21,8 @@ import android.content.Context;
import android.telephony.TelephonyManager;
import android.test.AndroidTestCase;
import com.android.mail.utils.LogUtils;
public class DeviceTests extends AndroidTestCase {
public void testGetConsistentDeviceId() {

70
tests/src/com/android/emailcommon/internet/Rfc822OutputTests.java
View File

@ -128,7 +128,7 @@ public class Rfc822OutputTests extends ProviderTestCase2<EmailProvider> {
Body body1 = createTestBody(message1);
String[] bodyParts;
bodyParts = Rfc822Output.buildBodyText(body1, message1.mFlags, false);
bodyParts = Rfc822Output.buildBodyText(body1, false);
assertEquals(REPLY_INTRO_TEXT + ">" + REPLY_TEXT_BODY, bodyParts[0]);
message1.mId = -1; // Changing the message; need to reset the id
@ -136,7 +136,7 @@ public class Rfc822OutputTests extends ProviderTestCase2<EmailProvider> {
message1.save(mMockContext);
body1 = createTestBody(message1);
bodyParts = Rfc822Output.buildBodyText(body1, message1.mFlags, false);
bodyParts = Rfc822Output.buildBodyText(body1, false);
assertEquals(TEXT + REPLY_INTRO_TEXT + ">" + REPLY_TEXT_BODY, bodyParts[0]);
// We have an HTML reply and no text reply; use the HTML reply
@ -145,7 +145,7 @@ public class Rfc822OutputTests extends ProviderTestCase2<EmailProvider> {
message1.save(mMockContext);
body1 = createTestBody(message1);
bodyParts = Rfc822Output.buildBodyText(body1, message1.mFlags, false);
bodyParts = Rfc822Output.buildBodyText(body1, false);
assertEquals(TEXT + REPLY_INTRO_TEXT + BODY_TEXT_REPLY_HTML, bodyParts[0]);
// We have no HTML or text reply; use nothing
@ -154,14 +154,14 @@ public class Rfc822OutputTests extends ProviderTestCase2<EmailProvider> {
message1.save(mMockContext);
body1 = createTestBody(message1);
bodyParts = Rfc822Output.buildBodyText(body1, message1.mFlags, false);
bodyParts = Rfc822Output.buildBodyText(body1, false);
assertEquals(TEXT + REPLY_INTRO_TEXT, bodyParts[0]);
// Test sending a message *with* using smart reply
Message message2 = createTestMessage("", true);
Body body2 = createTestBody(message2);
bodyParts = Rfc822Output.buildBodyText(body2, message2.mFlags, true);
bodyParts = Rfc822Output.buildBodyText(body2, true);
assertEquals(REPLY_INTRO_TEXT, bodyParts[0]);
message2.mId = -1; // Changing the message; need to reset the id
@ -169,7 +169,7 @@ public class Rfc822OutputTests extends ProviderTestCase2<EmailProvider> {
message2.save(mMockContext);
body2 = createTestBody(message2);
bodyParts = Rfc822Output.buildBodyText(body2, message2.mFlags, true);
bodyParts = Rfc822Output.buildBodyText(body2, true);
assertEquals(TEXT + REPLY_INTRO_TEXT, bodyParts[0]);
// We have an HTML reply and no text reply; use nothing (smart reply)
@ -178,7 +178,7 @@ public class Rfc822OutputTests extends ProviderTestCase2<EmailProvider> {
message2.save(mMockContext);
body2 = createTestBody(message2);
bodyParts = Rfc822Output.buildBodyText(body2, message2.mFlags, true);
bodyParts = Rfc822Output.buildBodyText(body2, true);
assertEquals(TEXT + REPLY_INTRO_TEXT, bodyParts[0]);
// We have no HTML or text reply; use nothing
@ -188,7 +188,7 @@ public class Rfc822OutputTests extends ProviderTestCase2<EmailProvider> {
message2.save(mMockContext);
body2 = createTestBody(message2);
bodyParts = Rfc822Output.buildBodyText(body2, message2.mFlags, true);
bodyParts = Rfc822Output.buildBodyText(body2, true);
assertEquals(TEXT + REPLY_INTRO_TEXT, bodyParts[0]);
}
@ -208,7 +208,7 @@ public class Rfc822OutputTests extends ProviderTestCase2<EmailProvider> {
msg.mIntroText = mForwardIntro;
msg.save(mMockContext);
Body body = createTestBody(msg);
String[] bodyParts = Rfc822Output.buildBodyText(body, msg.mFlags, false);
String[] bodyParts = Rfc822Output.buildBodyText(body, false);
assertEquals(TEXT + mForwardIntro + REPLY_TEXT_BODY, bodyParts[0]);
}
@ -222,7 +222,7 @@ public class Rfc822OutputTests extends ProviderTestCase2<EmailProvider> {
// Write out an Rfc822 message
ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
Rfc822Output.writeTo(mMockContext, msg.mId, byteStream, true, false);
Rfc822Output.writeTo(mMockContext, msg, byteStream, true, false, null);
// Get the message and create a mime4j message from it
// We'll take advantage of its parsing capabilities
@ -256,7 +256,7 @@ public class Rfc822OutputTests extends ProviderTestCase2<EmailProvider> {
// Write out an Rfc822 message
ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
Rfc822Output.writeTo(mMockContext, msg.mId, byteStream, true, false);
Rfc822Output.writeTo(mMockContext, msg, byteStream, true, false, null);
// Get the message and create a mime4j message from it
// We'll take advantage of its parsing capabilities
@ -300,7 +300,7 @@ public class Rfc822OutputTests extends ProviderTestCase2<EmailProvider> {
// Write out an Rfc822 message
ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
Rfc822Output.writeTo(mMockContext, msg.mId, byteStream, true, false);
Rfc822Output.writeTo(mMockContext, msg, byteStream, true, false, null);
// Get the message and create a mime4j message from it
// We'll take advantage of its parsing capabilities
@ -340,52 +340,6 @@ public class Rfc822OutputTests extends ProviderTestCase2<EmailProvider> {
assertEquals(HTML_NO_BODY_RESULT, actual);
}
/**
* Tests that the entire HTML alternate string is valid for text entered by
* the user. We don't test all permutations of forwarded HTML here because
* that is verified by testGetHtmlBody().
*/
public void testGetHtmlAlternate() {
Message message = createTestMessage(TEXT, true);
Body body = createTestBody(message);
String html;
// Generic case
html = Rfc822Output.getHtmlAlternate(body, false);
assertEquals(TEXT + REPLY_INTRO_HTML + BODY_HTML_REPLY, html);
// "smart reply" enabled; html body should not be added
html = Rfc822Output.getHtmlAlternate(body, true);
assertEquals(TEXT + REPLY_INTRO_HTML, html);
// HTML special characters; dependent upon TextUtils#htmlEncode()
message.mId = -1; // Changing the message; need to reset the id
message.mText = "<>&'\"";
message.save(mMockContext);
body = createTestBody(message);
html = Rfc822Output.getHtmlAlternate(body, false);
assertEquals("&lt;&gt;&amp;&apos;&quot;" + REPLY_INTRO_HTML + BODY_HTML_REPLY, html);
// Newlines in user text
message.mId = -1; // Changing the message; need to reset the id
message.mText = "dos\r\nunix\nthree\r\n\n\n";
message.save(mMockContext);
body = createTestBody(message);
html = Rfc822Output.getHtmlAlternate(body, false);
assertEquals("dos<br>unix<br>three<br><br><br>" + REPLY_INTRO_HTML + BODY_HTML_REPLY, html);
// Null HTML reply
message.mId = -1; // Changing the message; need to reset the id
message.mHtmlReply = null;
message.save(mMockContext);
body = createTestBody(message);
html = Rfc822Output.getHtmlAlternate(body, false);
assertNull(html);
}
/**
* Test the boundary digit. We modify it indirectly.
*/

10
tests/src/com/android/emailcommon/mail/MockFolder.java
View File

@ -126,4 +126,14 @@ public class MockFolder extends Folder {
return null;
}
/* (non-Javadoc)
* @see com.android.emailcommon.mail.Folder#getMessages(long, long,
* com.android.emailcommon.mail.Folder.MessageRetrievalListener)
*/
@Override
public Message[] getMessages(long startDate, long endDate, MessageRetrievalListener listener)
throws MessagingException {
return null;
}
}

54
tests/src/com/android/emailcommon/provider/MailboxTests.java
View File

@ -333,9 +333,6 @@ public class MailboxTests extends ProviderTestCase2<EmailProvider> {
* {@link EmailProvider#recalculateMessageCount}.
*
* It also covers:
* - {@link Mailbox#getMessageCountByMailboxType(Context, int)}
* - {@link Mailbox#getUnreadCountByAccountAndMailboxType(Context, long, int)}
* - {@link Mailbox#getUnreadCountByMailboxType(Context, int)}
* - {@link Message#getFavoriteMessageCount(Context)}
* - {@link Message#getFavoriteMessageCount(Context, long)}
*/
@ -364,24 +361,6 @@ public class MailboxTests extends ProviderTestCase2<EmailProvider> {
assertEquals(0, Message.getFavoriteMessageCount(c));
assertEquals(0, Message.getFavoriteMessageCount(c, a1.mId));
assertEquals(0, Message.getFavoriteMessageCount(c, a2.mId));
assertEquals(0, Mailbox.getUnreadCountByMailboxType(c, Mailbox.TYPE_INBOX));
assertEquals(0, Mailbox.getUnreadCountByMailboxType(c, Mailbox.TYPE_OUTBOX));
assertEquals(0, Mailbox.getMessageCountByMailboxType(c, Mailbox.TYPE_INBOX));
assertEquals(0, Mailbox.getMessageCountByMailboxType(c, Mailbox.TYPE_OUTBOX));
assertEquals(0, Mailbox.getMessageCountByMailboxType(c, Mailbox.TYPE_TRASH));
assertEquals(0, Mailbox.getUnreadCountByAccountAndMailboxType(c,
a1.mId, Mailbox.TYPE_INBOX));
assertEquals(0, Mailbox.getUnreadCountByAccountAndMailboxType(c,
a1.mId, Mailbox.TYPE_OUTBOX));
assertEquals(0, Mailbox.getUnreadCountByAccountAndMailboxType(c,
a1.mId, Mailbox.TYPE_TRASH));
assertEquals(0, Mailbox.getUnreadCountByAccountAndMailboxType(c,
a2.mId, Mailbox.TYPE_INBOX));
assertEquals(0, Mailbox.getUnreadCountByAccountAndMailboxType(c,
a2.mId, Mailbox.TYPE_OUTBOX));
assertEquals(0, Mailbox.getUnreadCountByAccountAndMailboxType(c,
a2.mId, Mailbox.TYPE_TRASH));
// 1. Test for insert triggers.
@ -416,24 +395,6 @@ public class MailboxTests extends ProviderTestCase2<EmailProvider> {
assertEquals(3, Message.getFavoriteMessageCount(c)); // excludes starred in trash
assertEquals(2, Message.getFavoriteMessageCount(c, a1.mId));
assertEquals(1, Message.getFavoriteMessageCount(c, a2.mId)); // excludes starred in trash
assertEquals(3, Mailbox.getUnreadCountByMailboxType(c, Mailbox.TYPE_INBOX));
assertEquals(1, Mailbox.getUnreadCountByMailboxType(c, Mailbox.TYPE_OUTBOX));
assertEquals(4, Mailbox.getMessageCountByMailboxType(c, Mailbox.TYPE_INBOX));
assertEquals(2, Mailbox.getMessageCountByMailboxType(c, Mailbox.TYPE_OUTBOX));
assertEquals(3, Mailbox.getMessageCountByMailboxType(c, Mailbox.TYPE_TRASH));
assertEquals(1, Mailbox.getUnreadCountByAccountAndMailboxType(c,
a1.mId, Mailbox.TYPE_INBOX));
assertEquals(1, Mailbox.getUnreadCountByAccountAndMailboxType(c,
a1.mId, Mailbox.TYPE_OUTBOX));
assertEquals(0, Mailbox.getUnreadCountByAccountAndMailboxType(c,
a1.mId, Mailbox.TYPE_TRASH));
assertEquals(2, Mailbox.getUnreadCountByAccountAndMailboxType(c,
a2.mId, Mailbox.TYPE_INBOX));
assertEquals(0, Mailbox.getUnreadCountByAccountAndMailboxType(c,
a2.mId, Mailbox.TYPE_OUTBOX));
assertEquals(3, Mailbox.getUnreadCountByAccountAndMailboxType(c,
a2.mId, Mailbox.TYPE_TRASH));
// 2. Check the "move mailbox" trigger.
@ -464,15 +425,6 @@ public class MailboxTests extends ProviderTestCase2<EmailProvider> {
assertEquals(1, getMessageCount(b2.mId));
assertEquals(2, getMessageCount(b3.mId));
assertEquals(1, getMessageCount(b4.mId));
// No such mailbox type.
assertEquals(0, Mailbox.getMessageCountByMailboxType(c, 99999));
assertEquals(0, Mailbox.getUnreadCountByAccountAndMailboxType(c, a1.mId, 99999));
assertEquals(0, Mailbox.getUnreadCountByMailboxType(c, 99999));
// No such account
assertEquals(0, Mailbox.getUnreadCountByAccountAndMailboxType(c,
99999, Mailbox.TYPE_INBOX));
}
private Mailbox buildTestMailbox(String serverId) {
@ -480,11 +432,9 @@ public class MailboxTests extends ProviderTestCase2<EmailProvider> {
}
private Mailbox buildTestMailbox(String serverId, String name) {
name = (name == null) ? TEST_DISPLAY_NAME : name;
Mailbox testMailbox = new Mailbox();
testMailbox.mServerId = serverId;
testMailbox.mDisplayName = name;
testMailbox.mDisplayName = (name == null) ? TEST_DISPLAY_NAME : name;
testMailbox.mParentServerId = TEST_PARENT_SERVER_ID;
testMailbox.mSyncKey = TEST_SYNC_KEY;
testMailbox.mSyncStatus = TEST_SYNC_STATUS;
@ -497,8 +447,6 @@ public class MailboxTests extends ProviderTestCase2<EmailProvider> {
testMailbox.mSyncLookback = 5;
testMailbox.mSyncTime = 6L;
testMailbox.mType = 7;
testMailbox.mVisibleLimit = 8;
testMailbox.mLastSeenMessageKey = 9L;
testMailbox.mLastTouchedTime = 10L;
return testMailbox;

22
tests/src/com/android/emailcommon/provider/QuickResponseTests.java
View File

@ -44,27 +44,5 @@ public class QuickResponseTests extends ProviderTestCase2<EmailProvider> {
// Invalidate all caches, since we reset the database for each test
ContentCache.invalidateAllCaches();
}
// This class no longer has any content
public void brokenTestParcelling() {
QuickResponse original = new QuickResponse(7, "quick response text");
Parcel p = Parcel.obtain();
original.writeToParcel(p, 0);
// Reset.
p.setDataPosition(0);
QuickResponse unparcelled = QuickResponse.CREATOR.createFromParcel(p);
assert(original.equals(unparcelled));
QuickResponse phony = new QuickResponse(17, "quick response text");
assert(!(phony.equals(unparcelled)));
QuickResponse phony2 = new QuickResponse(7, "different text");
assert(!(phony2.equals(unparcelled)));
p.recycle();
}
}

16
tests/src/com/android/emailcommon/utility/AttachmentUtilitiesTests.java
View File

@ -101,22 +101,6 @@ public class AttachmentUtilitiesTests extends AndroidTestCase {
assertEquals(TEXT_PLAIN, AttachmentUtilities.inferMimeType("", TEXT_PLAIN));
}
public void testInferMimeTypeForUri() {
String type;
// Test for content URI
type = AttachmentUtilities.inferMimeTypeForUri(getContext(), EmailContent.Body.CONTENT_URI);
assertEquals("vnd.android.cursor.dir/email-body", type);
// Test for file URI
type = AttachmentUtilities.inferMimeTypeForUri(getContext(),
Uri.fromFile(new File("a.png")));
assertEquals("image/png", type);
type = AttachmentUtilities.inferMimeTypeForUri(getContext(),
Uri.fromFile(new File("/a/b/c/d.png")));
assertEquals("image/png", type);
}
/**
* Text extension extractor
*/

2
tests/src/com/android/emailcommon/utility/SSLUtilsTest.java
View File

@ -48,8 +48,6 @@ public class SSLUtilsTest extends AndroidTestCase {
assertSchemeNameValid(SSLUtils.escapeForSchemeName("name with spaces"));
assertSchemeNameValid(SSLUtils.escapeForSchemeName("odd * & characters"));
assertSchemeNameValid(SSLUtils.escapeForSchemeName("f3v!l;891023-47 +"));
assertSchemeNameValid(
SSLUtils.escapeForSchemeName("\u304d\u307f\u3092\u611b\u3057\u3066\u308b"));
}
private static final char[] RANDOM_DICT = new char[] {

2
tests/src/com/android/emailcommon/utility/UtilityMediumTests.java
View File

@ -127,7 +127,7 @@ public class UtilityMediumTests extends ProviderTestCase2<EmailProvider> {
writer.write("Foo");
writer.flush();
writer.close();
attachment.mContentUri = "file://" + file.getAbsolutePath();
attachment.setContentUri("file://" + file.getAbsolutePath());
// Now, this should return true
assertTrue(Utility.attachmentExists(mMockContext, attachment));
}

145
tests/src/com/android/emailcommon/utility/UtilityUnitTests.java
View File

@ -16,22 +16,9 @@
package com.android.emailcommon.utility;
import com.android.email.DBTestHelper;
import com.android.email.R;
import com.android.email.TestUtils;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.EmailContent.Attachment;
import com.android.emailcommon.provider.EmailContent.MailboxColumns;
import com.android.emailcommon.provider.EmailContent.Message;
import com.android.emailcommon.provider.Mailbox;
import com.android.emailcommon.utility.Utility.NewFileCreator;
import android.content.Context;
import android.database.Cursor;
import android.database.CursorWrapper;
import android.database.MatrixCursor;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.Environment;
import android.test.AndroidTestCase;
@ -41,6 +28,17 @@ import android.text.SpannableStringBuilder;
import android.text.TextUtils;
import android.widget.TextView;
import com.android.email.DBTestHelper;
import com.android.email.TestUtils;
import com.android.email.provider.ProviderTestUtils;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.EmailContent.Attachment;
import com.android.emailcommon.provider.EmailContent.MailboxColumns;
import com.android.emailcommon.provider.EmailContent.Message;
import com.android.emailcommon.provider.Mailbox;
import com.android.emailcommon.utility.Utility.NewFileCreator;
import com.android.mail.utils.MatrixCursorWithCachedColumns;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
@ -308,127 +306,6 @@ public class UtilityUnitTests extends AndroidTestCase {
assertEquals(lastPathSegment, Utility.getContentFileName(providerContext, notExistUri));
}
private long getLastUpdateKey(Context mockContext, long mailboxId) {
return Utility.getFirstRowLong(mockContext, Mailbox.CONTENT_URI,
new String[] { MailboxColumns.LAST_SEEN_MESSAGE_KEY }, MailboxColumns.ID + "=?",
new String[] { Long.toString(mailboxId) }, null, 0, -1L);
}
public void testUpdateLastSeenMessageKey() throws Exception {
Context mockContext = DBTestHelper.ProviderContextSetupHelper.getProviderContext(mContext);
// Setup account & message stuff
Account account1 = ProviderTestUtils.setupAccount("account1", true, mockContext);
Account account2 = ProviderTestUtils.setupAccount("account2", true, mockContext);
Account account3 = ProviderTestUtils.setupAccount("account3", true, mockContext);
Account account4 = ProviderTestUtils.setupAccount("account4", true, mockContext);
Mailbox mailbox1_1 = ProviderTestUtils.setupMailbox("mbox1_1", account1.mId, true,
mockContext, Mailbox.TYPE_INBOX);
Mailbox mailbox1_2 = ProviderTestUtils.setupMailbox("mbox1_2", account1.mId, true,
mockContext, Mailbox.TYPE_MAIL);
Mailbox mailbox1_3 = ProviderTestUtils.setupMailbox("mbox1_3", account1.mId, true,
mockContext, Mailbox.TYPE_DRAFTS);
Mailbox mailbox1_4 = ProviderTestUtils.setupMailbox("mbox1_4", account1.mId, true,
mockContext, Mailbox.TYPE_OUTBOX);
Mailbox mailbox1_5 = ProviderTestUtils.setupMailbox("mbox1_5", account1.mId, true,
mockContext, Mailbox.TYPE_TRASH);
Mailbox mailbox2_1 = ProviderTestUtils.setupMailbox("mbox2_1", account2.mId, true,
mockContext, Mailbox.TYPE_MAIL);
Mailbox mailbox3_1 = ProviderTestUtils.setupMailbox("mbox3_1", account3.mId, true,
mockContext, Mailbox.TYPE_MAIL);
Mailbox mailbox3_2 = ProviderTestUtils.setupMailbox("mbox3_2", account3.mId, true,
mockContext, Mailbox.TYPE_INBOX);
Mailbox mailbox4_1 = ProviderTestUtils.setupMailbox("mbox4_1", account4.mId, true,
mockContext, Mailbox.TYPE_INBOX);
Message message1_1_1 = ProviderTestUtils.setupMessage("message_1_1_1", account1.mId,
mailbox1_1.mId, false, true, mockContext);
Message message1_1_2 = ProviderTestUtils.setupMessage("message_1_1_2", account1.mId,
mailbox1_1.mId, false, true, mockContext);
Message message1_1_3 = ProviderTestUtils.setupMessage("message_1_1_3", account1.mId,
mailbox1_1.mId, false, true, mockContext);
Message message1_2_1 = ProviderTestUtils.setupMessage("message_1_2_1", account1.mId,
mailbox1_2.mId, false, true, mockContext);
Message message1_3_1 = ProviderTestUtils.setupMessage("message_1_3_1", account1.mId,
mailbox1_3.mId, false, true, mockContext);
Message message1_4_1 = ProviderTestUtils.setupMessage("message_1_4_1", account1.mId,
mailbox1_4.mId, false, true, mockContext);
Message message1_5_1 = ProviderTestUtils.setupMessage("message_1_5_1", account1.mId,
mailbox1_5.mId, false, true, mockContext);
Message message2_1_1 = ProviderTestUtils.setupMessage("message_2_1_1", account2.mId,
mailbox2_1.mId, false, true, mockContext);
Message message2_1_2 = ProviderTestUtils.setupMessage("message_2_1_2", account2.mId,
mailbox2_1.mId, false, true, mockContext);
Message message3_1_1 = ProviderTestUtils.setupMessage("message_3_1_1", account3.mId,
mailbox3_1.mId, false, true, mockContext);
Message message4_1_1 = ProviderTestUtils.setupMessage("message_4_1_1", account4.mId,
mailbox4_1.mId, false, true, mockContext);
Message message4_1_2 = ProviderTestUtils.setupMessage("message_4_1_2", account4.mId,
mailbox4_1.mId, false, true, mockContext);
Message message4_1_3 = ProviderTestUtils.setupMessage("message_4_1_3", account4.mId,
mailbox4_1.mId, false, true, mockContext);
Message message4_1_4 = ProviderTestUtils.setupMessage("message_4_1_4", account4.mId,
mailbox4_1.mId, false, true, mockContext);
// Verify the default case
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_1.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_2.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_3.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_4.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_5.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox2_1.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox3_1.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox3_2.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox4_1.mId));
// Test account; only INBOX is modified
Utility.updateLastSeenMessageKey(mockContext, account1.mId).get();
assertEquals(message1_1_3.mId, getLastUpdateKey(mockContext, mailbox1_1.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_2.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_3.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_4.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_5.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox2_1.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox3_1.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox3_2.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox4_1.mId));
// Missing INBOX
Utility.updateLastSeenMessageKey(mockContext, account2.mId).get();
assertEquals(message1_1_3.mId, getLastUpdateKey(mockContext, mailbox1_1.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_2.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_3.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_4.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_5.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox2_1.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox3_1.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox3_2.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox4_1.mId));
// No messages in mailbox
Utility.updateLastSeenMessageKey(mockContext, account3.mId).get();
assertEquals(message1_1_3.mId, getLastUpdateKey(mockContext, mailbox1_1.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_2.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_3.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_4.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_5.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox2_1.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox3_1.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox3_2.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox4_1.mId));
// Test combined accounts
Utility.updateLastSeenMessageKey(mockContext, 0x1000000000000000L).get();
assertEquals(message1_1_3.mId, getLastUpdateKey(mockContext, mailbox1_1.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_2.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_3.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_4.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox1_5.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox2_1.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox3_1.mId));
assertEquals(0L, getLastUpdateKey(mockContext, mailbox3_2.mId));
assertEquals(message4_1_4.mId, getLastUpdateKey(mockContext, mailbox4_1.mId));
}
// used by testToPrimitiveLongArray
private static Collection<Long> createLongCollection(long... values) {
ArrayList<Long> ret = new ArrayList<Long>();