/*
* 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();
}
}
}