android/email/LegacyConversionsTests.java

/*
 * 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 com.android.email.mail.Address;
import com.android.email.mail.Body;
import com.android.email.mail.BodyPart;
import com.android.email.mail.Flag;
import com.android.email.mail.Folder;
import com.android.email.mail.Folder.OpenMode;
import com.android.email.mail.Message;
import com.android.email.mail.Message.RecipientType;
import com.android.email.mail.MessageTestUtils;
import com.android.email.mail.MessageTestUtils.MessageBuilder;
import com.android.email.mail.MessageTestUtils.MultipartBuilder;
import com.android.email.mail.MessagingException;
import com.android.email.mail.Part;
import com.android.email.mail.internet.MimeBodyPart;
import com.android.email.mail.internet.MimeHeader;
import com.android.email.mail.internet.MimeMessage;
import com.android.email.mail.internet.MimeUtility;
import com.android.email.mail.internet.TextBody;
import com.android.email.mail.store.LocalStore;
import com.android.email.mail.store.LocalStoreUnitTests;
import com.android.email.provider.EmailContent;
import com.android.email.provider.EmailContent.Attachment;
import com.android.email.provider.EmailContent.Mailbox;
import com.android.email.provider.EmailProvider;
import com.android.email.provider.ProviderTestUtils;

import android.content.ContentUris;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.test.ProviderTestCase2;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;

/**
 * Tests of the Legacy Conversions code (used by MessagingController).
 *
 * NOTE:  It would probably make sense to rewrite this using a MockProvider, instead of the
 * ProviderTestCase (which is a real provider running on a temp database).  This would be more of
 * a true "unit test".
 *
 * You can run this entire test case with:
 *   runtest -c com.android.email.LegacyConversionsTests email
 */
public class LegacyConversionsTests extends ProviderTestCase2<EmailProvider> {

    private static final String UID = "UID.12345678";
    private static final String SENDER = "sender@android.com";
    private static final String RECIPIENT_TO = "recipient-to@android.com";
    private static final String RECIPIENT_CC = "recipient-cc@android.com";
    private static final String RECIPIENT_BCC = "recipient-bcc@android.com";
    private static final String REPLY_TO = "reply-to@android.com";
    private static final String SUBJECT = "This is the subject";
    private static final String MESSAGE_ID = "Test-Message-ID";
    private static final String MESSAGE_ID_2 = "Test-Message-ID-Second";

    EmailProvider mProvider;
    Context mProviderContext;
    Context mContext;
    Account mLegacyAccount = null;
    Preferences mPreferences = null;

    public LegacyConversionsTests() {
        super(EmailProvider.class, EmailProvider.EMAIL_AUTHORITY);
    }

    @Override
    public void setUp() throws Exception {
        super.setUp();
        mProviderContext = getMockContext();
        mContext = getContext();
    }

    @Override
    public void tearDown() throws Exception {
        super.tearDown();
        if (mLegacyAccount != null) {
            mLegacyAccount.delete(mPreferences);
        }
    }

    /**
     * TODO: basic Legacy -> Provider Message conversions
     * TODO: basic Legacy -> Provider Body conversions
     * TODO: rainy day tests of all kinds
     */

    /**
     * Test basic conversion from Store message to Provider message
     *
     * TODO: Not a complete test of all fields, and some fields need special tests (e.g. flags)
     * TODO: There are many special cases in the tested function, that need to be
     * tested here as well.
     */
    public void testUpdateMessageFields() throws MessagingException {
        MimeMessage message = buildTestMessage(RECIPIENT_TO, RECIPIENT_CC, RECIPIENT_BCC,
                REPLY_TO, SENDER, SUBJECT, null);
        EmailContent.Message localMessage = new EmailContent.Message();

        boolean result = LegacyConversions.updateMessageFields(localMessage, message, 1, 1);
        assertTrue(result);
        checkProviderMessage("testUpdateMessageFields", message, localMessage);
    }

    /**
     * Test basic conversion from Store message to Provider message, when the provider message
     * does not have a proper message-id.
     */
    public void testUpdateMessageFieldsNoMessageId() throws MessagingException {
        MimeMessage message = buildTestMessage(RECIPIENT_TO, RECIPIENT_CC, RECIPIENT_BCC,
                REPLY_TO, SENDER, SUBJECT, null);
        EmailContent.Message localMessage = new EmailContent.Message();

        // If the source message-id is null, the target should be left as-is
        localMessage.mMessageId = MESSAGE_ID_2;
        message.removeHeader("Message-ID");

        boolean result = LegacyConversions.updateMessageFields(localMessage, message, 1, 1);
        assertTrue(result);
        assertEquals(MESSAGE_ID_2, localMessage.mMessageId);
    }

    /**
     * Build a lightweight Store message with simple field population
     */
    private MimeMessage buildTestMessage(String to, String cc, String bcc, String replyTo,
            String sender, String subject, String content) throws MessagingException {
        MimeMessage message = new MimeMessage();

        if (to != null) {
            Address[] addresses = Address.parse(to);
            message.setRecipients(RecipientType.TO, addresses);
        }
        if (cc != null) {
            Address[] addresses = Address.parse(cc);
            message.setRecipients(RecipientType.CC, addresses);
        }
        if (bcc != null) {
            Address[] addresses = Address.parse(bcc);
            message.setRecipients(RecipientType.BCC, addresses);
        }
        if (replyTo != null) {
            Address[] addresses = Address.parse(replyTo);
            message.setReplyTo(addresses);
        }
        if (sender != null) {
            Address[] addresses = Address.parse(sender);
            message.setFrom(addresses[0]);
        }
        if (subject != null) {
            message.setSubject(subject);
        }
        if (content != null) {
            TextBody body = new TextBody(content);
            message.setBody(body);
        }

        message.setUid(UID);
        message.setSentDate(new Date());
        message.setInternalDate(new Date());
        message.setMessageId(MESSAGE_ID);
        return message;
    }

    /**
     * Basic test of body parts conversion from Store message to Provider message.
     * This tests that a null body part simply results in null text, and does not crash
     * or return "null".
     *
     * TODO very incomplete, there are many permutations to be explored
     */
    public void testUpdateBodyFieldsNullText() throws MessagingException {
        EmailContent.Body localBody = new EmailContent.Body();
        EmailContent.Message localMessage = new EmailContent.Message();
        ArrayList<Part> viewables = new ArrayList<Part>();
        Part emptyTextPart = new MimeBodyPart(null, "text/plain");
        viewables.add(emptyTextPart);

        // a "null" body part of type text/plain should result in a null mTextContent
        boolean result = LegacyConversions.updateBodyFields(localBody, localMessage, viewables);
        assertTrue(result);
        assertNull(localBody.mTextContent);
    }

    /**
     * Sunny day test of adding attachments from an IMAP/POP message.
     */
    public void testAddAttachments() throws MessagingException, IOException {
        // Prepare a local message to add the attachments to
        final long accountId = 1;
        final long mailboxId = 1;

        // test 1: legacy message using content-type:name style for name
        final EmailContent.Message localMessage = ProviderTestUtils.setupMessage(
                "local-message", accountId, mailboxId, false, true, mProviderContext);
        final Message legacyMessage = prepareLegacyMessageWithAttachments(2, false, false);
        convertAndCheckcheckAddedAttachments(localMessage, legacyMessage);

        // test 2: legacy message using content-disposition:filename style for name
        final EmailContent.Message localMessage2 = ProviderTestUtils.setupMessage(
                "local-message", accountId, mailboxId, false, true, mProviderContext);
        final Message legacyMessage2 = prepareLegacyMessageWithAttachments(2, false, true);
        convertAndCheckcheckAddedAttachments(localMessage2, legacyMessage2);
    }

    /**
     * Helper for testAddAttachments
     */
    private void convertAndCheckcheckAddedAttachments(final EmailContent.Message localMessage,
            final Message legacyMessage) throws MessagingException, IOException {
        // Now, convert from legacy to provider and see what happens
        ArrayList<Part> viewables = new ArrayList<Part>();
        ArrayList<Part> attachments = new ArrayList<Part>();
        MimeUtility.collectParts(legacyMessage, viewables, attachments);
        LegacyConversions.updateAttachments(mProviderContext, localMessage, attachments, false);

        // Read back all attachments for message and check field values
        Uri uri = ContentUris.withAppendedId(Attachment.MESSAGE_ID_URI, localMessage.mId);
        Cursor c = mProviderContext.getContentResolver().query(uri, Attachment.CONTENT_PROJECTION,
                null, null, null);
        try {
            assertEquals(2, c.getCount());
            while (c.moveToNext()) {
                Attachment attachment = Attachment.getContent(c, Attachment.class);
                if ("101".equals(attachment.mLocation)) {
                    checkAttachment("attachment1Part", attachments.get(0), attachment,
                            localMessage.mAccountKey);
                } else if ("102".equals(attachment.mLocation)) {
                    checkAttachment("attachment2Part", attachments.get(1), attachment,
                            localMessage.mAccountKey);
                } else {
                    fail("Unexpected attachment with location " + attachment.mLocation);
                }
            }
        } finally {
            c.close();
        }
    }

    /**
     * Test that attachments aren't re-added in the DB.  This supports the "partial download"
     * nature of POP messages.
     */
    public void testAddDuplicateAttachments() throws MessagingException, IOException {
        // Prepare a local message to add the attachments to
        final long accountId = 1;
        final long mailboxId = 1;
        final EmailContent.Message localMessage = ProviderTestUtils.setupMessage(
                "local-message", accountId, mailboxId, false, true, mProviderContext);

        // Prepare a legacy message with attachments
        Message legacyMessage = prepareLegacyMessageWithAttachments(2, false, false);

        // Now, convert from legacy to provider and see what happens
        ArrayList<Part> viewables = new ArrayList<Part>();
        ArrayList<Part> attachments = new ArrayList<Part>();
        MimeUtility.collectParts(legacyMessage, viewables, attachments);
        LegacyConversions.updateAttachments(mProviderContext, localMessage, attachments, false);

        // Confirm two attachment objects created
        Uri uri = ContentUris.withAppendedId(Attachment.MESSAGE_ID_URI, localMessage.mId);
        assertEquals(2, EmailContent.count(mProviderContext, uri, null, null));

        // Now add the attachments again and confirm there are still only two
        LegacyConversions.updateAttachments(mProviderContext, localMessage, attachments, false);
        assertEquals(2, EmailContent.count(mProviderContext, uri, null, null));

        // Now add a 3rd & 4th attachment and make sure the total is 4, not 2 or 6
        legacyMessage = prepareLegacyMessageWithAttachments(4, false, false);
        viewables = new ArrayList<Part>();
        attachments = new ArrayList<Part>();
        MimeUtility.collectParts(legacyMessage, viewables, attachments);
        LegacyConversions.updateAttachments(mProviderContext, localMessage, attachments, false);
        assertEquals(4, EmailContent.count(mProviderContext, uri, null, null));
    }

    /**
     * Sunny day test of adding attachments in "local account upgrade" mode
     */
    public void testLocalUpgradeAttachments() throws MessagingException, IOException {
        // Prepare a local message to add the attachments to
        final long accountId = 1;
        final long mailboxId = 1;
        final EmailContent.Message localMessage = ProviderTestUtils.setupMessage(
                "local-upgrade", accountId, mailboxId, false, true, mProviderContext);

        // Prepare a legacy message with attachments
        final Message legacyMessage = prepareLegacyMessageWithAttachments(2, true, false);

        // Now, convert from legacy to provider and see what happens
        ArrayList<Part> viewables = new ArrayList<Part>();
        ArrayList<Part> attachments = new ArrayList<Part>();
        MimeUtility.collectParts(legacyMessage, viewables, attachments);
        LegacyConversions.updateAttachments(mProviderContext, localMessage, attachments, true);

        // Read back all attachments for message and check field values
        Uri uri = ContentUris.withAppendedId(Attachment.MESSAGE_ID_URI, localMessage.mId);
        Cursor c = mProviderContext.getContentResolver().query(uri, Attachment.CONTENT_PROJECTION,
                null, null, null);
        try {
            assertEquals(2, c.getCount());
            while (c.moveToNext()) {
                Attachment attachment = Attachment.getContent(c, Attachment.class);
                // This attachment should look as if created by modern (provider) MessageCompose.
                // 1. find the original that it was created from
                Part fromPart = null;
                for (Part from : attachments) {
                    String contentType = MimeUtility.unfoldAndDecode(from.getContentType());
                    String name = MimeUtility.getHeaderParameter(contentType, "name");
                    if (name.equals(attachment.mFileName)) {
                        fromPart = from;
                        break;
                    }
                }
                assertTrue(fromPart != null);
                // 2. Check values
                checkAttachment(attachment.mFileName, fromPart, attachment, accountId);
            }
        } finally {
            c.close();
        }
    }

    /**
     * Prepare a legacy message with 1+ attachments
     * @param numAttachments how many attachments to add
     * @param localData if true, attachments are "local" data.  false = "remote" (from server)
     * @param filenameInDisposition False: attachment names are sent as content-type:name.  True:
     *          attachment names are sent as content-disposition:filename.
     */
    private Message prepareLegacyMessageWithAttachments(int numAttachments, boolean localData,
            boolean filenameInDisposition) throws MessagingException {
        // First, build one or more attachment parts
        MultipartBuilder mpBuilder = new MultipartBuilder("multipart/mixed");
        for (int i = 1; i <= numAttachments; ++i) {
            // construct parameter parts for content-type:name or content-disposition:filename.
            String name = "";
            String filename = "";
            String quotedName = "\"test-attachment-" + i + "\"";
            if (filenameInDisposition) {
                filename = ";\n filename=" + quotedName;
            } else {
                name = ";\n name=" + quotedName;
            }
            if (localData) {
                // generate an attachment that was generated by legacy code (e.g. donut)
                // for test of upgrading accounts in place
                // This creator models the code in legacy MessageCompose
                Uri uri = Uri.parse("content://test/attachment/" + i);
                MimeBodyPart bp = new MimeBodyPart(
                        new LocalStore.LocalAttachmentBody(uri, mProviderContext));
                bp.setHeader(MimeHeader.HEADER_CONTENT_TYPE, "image/jpg" + name);
                bp.setHeader(MimeHeader.HEADER_CONTENT_TRANSFER_ENCODING, "base64");
                bp.setHeader(MimeHeader.HEADER_CONTENT_DISPOSITION, "attachment" + filename);
                mpBuilder.addBodyPart(bp);
            } else {
                // generate an attachment that came from a server
                BodyPart attachmentPart = MessageTestUtils.bodyPart("image/jpg", null);

                // name=attachmentN size=N00 location=10N
                attachmentPart.setHeader(MimeHeader.HEADER_CONTENT_TYPE, "image/jpg" + name);
                attachmentPart.setHeader(MimeHeader.HEADER_CONTENT_TRANSFER_ENCODING, "base64");
                attachmentPart.setHeader(MimeHeader.HEADER_CONTENT_DISPOSITION,
                        "attachment" + filename +  ";\n size=" + i + "00");
                attachmentPart.setHeader(MimeHeader.HEADER_ANDROID_ATTACHMENT_STORE_DATA, "10" + i);

                mpBuilder.addBodyPart(attachmentPart);
            }
        }

        // Now build a message with them
        final Message legacyMessage = new MessageBuilder()
            .setBody(new MultipartBuilder("multipart/mixed")
                     .addBodyPart(MessageTestUtils.bodyPart("text/html", null))
                     .addBodyPart(mpBuilder.buildBodyPart())
                     .build())
                .build();

        return legacyMessage;
    }

    /**
     * Test the stringInequal helper
     */
    public void testStringInequal() {
        // Pairs that are "equal"
        assertFalse(LegacyConversions.stringNotEqual(null, null));
        assertFalse(LegacyConversions.stringNotEqual(null, ""));
        assertFalse(LegacyConversions.stringNotEqual("", null));
        assertFalse(LegacyConversions.stringNotEqual("", ""));
        assertFalse(LegacyConversions.stringNotEqual("string-equal", "string-equal"));
        // Pairs that are "inequal"
        assertTrue(LegacyConversions.stringNotEqual(null, "string-inequal"));
        assertTrue(LegacyConversions.stringNotEqual("", "string-inequal"));
        assertTrue(LegacyConversions.stringNotEqual("string-inequal", null));
        assertTrue(LegacyConversions.stringNotEqual("string-inequal", ""));
        assertTrue(LegacyConversions.stringNotEqual("string-inequal-a", "string-inequal-b"));
    }

    /**
     * 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
     */
    private void checkAttachment(String tag, Part expected, EmailContent.Attachment actual,
            long accountKey) throws MessagingException {
        String contentType = MimeUtility.unfoldAndDecode(expected.getContentType());
        String contentTypeName = MimeUtility.getHeaderParameter(contentType, "name");
        assertEquals(tag, expected.getMimeType(), actual.mMimeType);
        String disposition = expected.getDisposition();
        String sizeString = MimeUtility.getHeaderParameter(disposition, "size");
        String dispositionFilename = MimeUtility.getHeaderParameter(disposition, "filename");
        long expectedSize = (sizeString != null) ? Long.parseLong(sizeString) : 0;
        assertEquals(tag, expectedSize, actual.mSize);
        assertEquals(tag, expected.getContentId(), actual.mContentId);

        // filename is either content-type:name or content-disposition:filename
        String expectedName = (contentTypeName != null) ? contentTypeName : dispositionFilename;
        assertEquals(tag, expectedName, actual.mFileName);

        // content URI either both null or both matching
        String expectedUriString = null;
        Body body = expected.getBody();
        if (body instanceof LocalStore.LocalAttachmentBody) {
            LocalStore.LocalAttachmentBody localBody = (LocalStore.LocalAttachmentBody) body;
            Uri contentUri = localBody.getContentUri();
            if (contentUri != null) {
                expectedUriString = contentUri.toString();
            }
        }
        assertEquals(tag, expectedUriString, actual.mContentUri);

        assertTrue(tag, 0 != actual.mMessageKey);

        // location is either both null or both matching
        String expectedPartId = null;
        String[] storeData = expected.getHeader(MimeHeader.HEADER_ANDROID_ATTACHMENT_STORE_DATA);
        if (storeData != null && storeData.length > 0) {
            expectedPartId = storeData[0];
        }
        assertEquals(tag, expectedPartId, actual.mLocation);
        assertEquals(tag, "B", actual.mEncoding);
        assertEquals(tag, accountKey, actual.mAccountKey);
    }

    /**
     * TODO: Sunny day test of adding attachments from a POP message.
     */

    /**
     * Sunny day tests of converting an original message to a legacy message
     */
    public void testMakeLegacyMessage() throws MessagingException {
        // Set up and store a message in the provider
        long account1Id = 1;
        long mailbox1Id = 1;

        // Test message 1: No body
        EmailContent.Message localMessage1 = ProviderTestUtils.setupMessage("make-legacy",
                account1Id, mailbox1Id, false, true, mProviderContext);
        Message getMessage1 = LegacyConversions.makeMessage(mProviderContext, localMessage1);
        checkLegacyMessage("no body", localMessage1, getMessage1);

        // Test message 2: Simple body
        EmailContent.Message localMessage2 = ProviderTestUtils.setupMessage("make-legacy",
                account1Id, mailbox1Id, true, false, mProviderContext);
        localMessage2.mTextReply = null;
        localMessage2.mHtmlReply = null;
        localMessage2.mIntroText = null;
        localMessage2.mFlags &= ~EmailContent.Message.FLAG_TYPE_MASK;
        localMessage2.save(mProviderContext);
        Message getMessage2 = LegacyConversions.makeMessage(mProviderContext, localMessage2);
        checkLegacyMessage("simple body", localMessage2, getMessage2);

        // Test message 3: Body + replied-to text
        EmailContent.Message localMessage3 = ProviderTestUtils.setupMessage("make-legacy",
                account1Id, mailbox1Id, true, false, mProviderContext);
        localMessage3.mFlags &= ~EmailContent.Message.FLAG_TYPE_MASK;
        localMessage3.mFlags |= EmailContent.Message.FLAG_TYPE_REPLY;
        localMessage3.save(mProviderContext);
        Message getMessage3 = LegacyConversions.makeMessage(mProviderContext, localMessage3);
        checkLegacyMessage("reply-to", localMessage3, getMessage3);

        // Test message 4: Body + forwarded text
        EmailContent.Message localMessage4 = ProviderTestUtils.setupMessage("make-legacy",
                account1Id, mailbox1Id, true, false, mProviderContext);
        localMessage4.mFlags &= ~EmailContent.Message.FLAG_TYPE_MASK;
        localMessage4.mFlags |= EmailContent.Message.FLAG_TYPE_FORWARD;
        localMessage4.save(mProviderContext);
        Message getMessage4 = LegacyConversions.makeMessage(mProviderContext, localMessage4);
        checkLegacyMessage("forwarding", localMessage4, getMessage4);
    }

    /**
     * Check equality of a pair of converted messages
     */
    private void checkProviderMessage(String tag, Message expect, EmailContent.Message actual)
            throws MessagingException {
        assertEquals(tag, expect.getUid(), actual.mServerId);
        assertEquals(tag, expect.getSubject(), actual.mSubject);
        assertEquals(tag, Address.pack(expect.getFrom()), actual.mFrom);
        assertEquals(tag, expect.getSentDate().getTime(), actual.mTimeStamp);
        assertEquals(tag, Address.pack(expect.getRecipients(RecipientType.TO)), actual.mTo);
        assertEquals(tag, Address.pack(expect.getRecipients(RecipientType.CC)), actual.mCc);
        assertEquals(tag, ((MimeMessage)expect).getMessageId(), actual.mMessageId);
        assertEquals(tag, expect.isSet(Flag.SEEN), actual.mFlagRead);
        assertEquals(tag, expect.isSet(Flag.FLAGGED), actual.mFlagFavorite);
    }

    /**
     * Check equality of a pair of converted messages
     */
    private void checkLegacyMessage(String tag, EmailContent.Message expect, Message actual)
            throws MessagingException {
        assertEquals(tag, expect.mServerId, actual.getUid());
        assertEquals(tag, expect.mServerTimeStamp, actual.getInternalDate().getTime());
        assertEquals(tag, expect.mSubject, actual.getSubject());
        assertEquals(tag, expect.mFrom, Address.pack(actual.getFrom()));
        assertEquals(tag, expect.mTimeStamp, actual.getSentDate().getTime());
        assertEquals(tag, expect.mTo, Address.pack(actual.getRecipients(RecipientType.TO)));
        assertEquals(tag, expect.mCc, Address.pack(actual.getRecipients(RecipientType.CC)));
        assertEquals(tag, expect.mBcc, Address.pack(actual.getRecipients(RecipientType.BCC)));
        assertEquals(tag, expect.mReplyTo, Address.pack(actual.getReplyTo()));
        assertEquals(tag, expect.mMessageId, ((MimeMessage)actual).getMessageId());
        // check flags
        assertEquals(tag, expect.mFlagRead, actual.isSet(Flag.SEEN));
        assertEquals(tag, expect.mFlagFavorite, actual.isSet(Flag.FLAGGED));

        // Check the body of the message
        ArrayList<Part> viewables = new ArrayList<Part>();
        ArrayList<Part> attachments = new ArrayList<Part>();
        MimeUtility.collectParts(actual, viewables, attachments);
        String get1Text = null;
        String get1Html = null;
        String get1TextReply = null;
        String get1HtmlReply = null;
        String get1TextIntro = null;
        for (Part viewable : viewables) {
            String text = MimeUtility.getTextFromPart(viewable);
            boolean isHtml = viewable.getMimeType().equalsIgnoreCase("text/html");
            String[] headers = viewable.getHeader(MimeHeader.HEADER_ANDROID_BODY_QUOTED_PART);
            if (headers != null) {
                String header = headers[0];
                boolean isReply = LegacyConversions.BODY_QUOTED_PART_REPLY.equalsIgnoreCase(header);
                boolean isFwd = LegacyConversions.BODY_QUOTED_PART_FORWARD.equalsIgnoreCase(header);
                boolean isIntro = LegacyConversions.BODY_QUOTED_PART_INTRO.equalsIgnoreCase(header);
                if (isReply || isFwd) {
                    if (isHtml) {
                        get1HtmlReply = text;
                    } else {
                        get1TextReply = text;
                    }
                } else if (isIntro) {
                    get1TextIntro = text;
                }
                // Check flags
                int replyTypeFlags = expect.mFlags & EmailContent.Message.FLAG_TYPE_MASK;
                if (isReply) {
                    assertEquals(tag, EmailContent.Message.FLAG_TYPE_REPLY, replyTypeFlags);
                }
                if (isFwd) {
                    assertEquals(tag, EmailContent.Message.FLAG_TYPE_FORWARD, replyTypeFlags);
                }
            } else {
                if (isHtml) {
                    get1Html = text;
                } else {
                    get1Text = text;
                }
            }
        }
        assertEquals(tag, expect.mText, get1Text);
        assertEquals(tag, expect.mHtml, get1Html);
        assertEquals(tag, expect.mTextReply, get1TextReply);
        assertEquals(tag, expect.mHtmlReply, get1HtmlReply);
        assertEquals(tag, expect.mIntroText, get1TextIntro);

        // TODO Check the attachments

//      cv.put("attachment_count", attachments.size());
    }

    /**
     * Test conversion of a legacy account to a provider account
     */
    public void testMakeProviderAccount() throws MessagingException {

        setupLegacyAccount("testMakeProviderAccount", true);
        EmailContent.Account toAccount =
            LegacyConversions.makeAccount(mProviderContext, mLegacyAccount);
        checkProviderAccount("testMakeProviderAccount", mLegacyAccount, toAccount);
    }

    /**
     * Test conversion of a provider account to a legacy account
     */
    public void testMakeLegacyAccount() throws MessagingException {
        EmailContent.Account fromAccount = ProviderTestUtils.setupAccount("convert-to-legacy",
                false, mProviderContext);
        fromAccount.mHostAuthRecv =
            ProviderTestUtils.setupHostAuth("legacy-recv", 0, false, mProviderContext);
        fromAccount.mHostAuthSend =
            ProviderTestUtils.setupHostAuth("legacy-send", 0, false, mProviderContext);
        fromAccount.save(mProviderContext);

        Account toAccount = LegacyConversions.makeLegacyAccount(mProviderContext, fromAccount);
        checkLegacyAccount("testMakeLegacyAccount", fromAccount, toAccount);
    }

    /**
     * Setup a legacy account in mLegacyAccount with many fields prefilled.
     */
    private void setupLegacyAccount(String name, boolean saveIt) {
        // prefs & legacy account are saved for cleanup (it's stored in the real prefs file)
        mPreferences = Preferences.getPreferences(mProviderContext);
        mLegacyAccount = new Account(mProviderContext);

        // fill in useful fields
        mLegacyAccount.mUuid = "test-uid-" + name;
        mLegacyAccount.mStoreUri = "store://test/" + name;
        mLegacyAccount.mLocalStoreUri = "local://localhost/" + name;
        mLegacyAccount.mSenderUri = "sender://test/" + name;
        mLegacyAccount.mDescription = "description " + name;
        mLegacyAccount.mName = "name " + name;
        mLegacyAccount.mEmail = "email " + name;
        mLegacyAccount.mAutomaticCheckIntervalMinutes = 100;
        mLegacyAccount.mLastAutomaticCheckTime = 200;
        mLegacyAccount.mNotifyNewMail = true;
        mLegacyAccount.mDraftsFolderName = "drafts " + name;
        mLegacyAccount.mSentFolderName = "sent " + name;
        mLegacyAccount.mTrashFolderName = "trash " + name;
        mLegacyAccount.mOutboxFolderName = "outbox " + name;
        mLegacyAccount.mAccountNumber = 300;
        mLegacyAccount.mVibrate = true;
        mLegacyAccount.mVibrateWhenSilent = false;
        mLegacyAccount.mRingtoneUri = "ringtone://test/" + name;
        mLegacyAccount.mSyncWindow = 400;
        mLegacyAccount.mBackupFlags = 0;
        mLegacyAccount.mDeletePolicy = Account.DELETE_POLICY_NEVER;
        mLegacyAccount.mSecurityFlags = 500;
        mLegacyAccount.mSignature = "signature " + name;

        if (saveIt) {
            mLegacyAccount.save(mPreferences);
        }
    }

    /**
     * Compare a provider account to the legacy account it was created from
     */
    private void checkProviderAccount(String tag, Account expect, EmailContent.Account actual)
            throws MessagingException {
        assertEquals(tag + " description", expect.getDescription(), actual.mDisplayName);
        assertEquals(tag + " email", expect.getEmail(), actual.mEmailAddress);
        assertEquals(tag + " sync key", null, actual.mSyncKey);
        assertEquals(tag + " lookback", expect.getSyncWindow(), actual.mSyncLookback);
        assertEquals(tag + " sync intvl", expect.getAutomaticCheckIntervalMinutes(),
                actual.mSyncInterval);
        // These asserts are checking mHostAuthKeyRecv & mHostAuthKeySend
        assertEquals(tag + " store", expect.getStoreUri(), actual.getStoreUri(mProviderContext));
        assertEquals(tag + " sender", expect.getSenderUri(), actual.getSenderUri(mProviderContext));
        // Synthesize & check flags
        int expectFlags = 0;
        if (expect.mNotifyNewMail) expectFlags |= EmailContent.Account.FLAGS_NOTIFY_NEW_MAIL;
        if (expect.mVibrate) expectFlags |= EmailContent.Account.FLAGS_VIBRATE_ALWAYS;
        if (expect.mVibrateWhenSilent)
            expectFlags |= EmailContent.Account.FLAGS_VIBRATE_WHEN_SILENT;
        expectFlags |=
            (expect.mDeletePolicy << EmailContent.Account.FLAGS_DELETE_POLICY_SHIFT)
                & EmailContent.Account.FLAGS_DELETE_POLICY_MASK;
        assertEquals(tag + " flags", expectFlags, actual.mFlags);
        assertEquals(tag + " default", false, actual.mIsDefault);
        assertEquals(tag + " uuid", expect.getUuid(), actual.mCompatibilityUuid);
        assertEquals(tag + " name", expect.getName(), actual.mSenderName);
        assertEquals(tag + " ringtone", expect.getRingtone(), actual.mRingtoneUri);
        assertEquals(tag + " proto vers", expect.mProtocolVersion, actual.mProtocolVersion);
        assertEquals(tag + " new count", 0, actual.mNewMessageCount);
        assertEquals(tag + " security", expect.mSecurityFlags, actual.mSecurityFlags);
        assertEquals(tag + " sec sync key", null, actual.mSecuritySyncKey);
        assertEquals(tag + " signature", expect.mSignature, actual.mSignature);
    }

    /**
     * Compare a legacy account to the provider account it was created from
     */
    private void checkLegacyAccount(String tag, EmailContent.Account expect, Account actual)
            throws MessagingException {
        int expectFlags = expect.getFlags();

        assertEquals(tag + " uuid", expect.mCompatibilityUuid, actual.mUuid);
        assertEquals(tag + " store", expect.getStoreUri(mProviderContext), actual.mStoreUri);
        assertTrue(actual.mLocalStoreUri.startsWith("local://localhost"));
        assertEquals(tag + " sender", expect.getSenderUri(mProviderContext), actual.mSenderUri);
        assertEquals(tag + " description", expect.getDisplayName(), actual.mDescription);
        assertEquals(tag + " name", expect.getSenderName(), actual.mName);
        assertEquals(tag + " email", expect.getEmailAddress(), actual.mEmail);
        assertEquals(tag + " checkintvl", expect.getSyncInterval(),
                actual.mAutomaticCheckIntervalMinutes);
        assertEquals(tag + " checktime", 0, actual.mLastAutomaticCheckTime);
        assertEquals(tag + " notify",
                (expectFlags & EmailContent.Account.FLAGS_NOTIFY_NEW_MAIL) != 0,
                actual.mNotifyNewMail);
        assertEquals(tag + " drafts", null, actual.mDraftsFolderName);
        assertEquals(tag + " sent", null, actual.mSentFolderName);
        assertEquals(tag + " trash", null, actual.mTrashFolderName);
        assertEquals(tag + " outbox", null, actual.mOutboxFolderName);
        assertEquals(tag + " acct #", -1, actual.mAccountNumber);
        assertEquals(tag + " vibrate",
                (expectFlags & EmailContent.Account.FLAGS_VIBRATE_ALWAYS) != 0,
                actual.mVibrate);
        assertEquals(tag + " vibrateSilent",
                (expectFlags & EmailContent.Account.FLAGS_VIBRATE_WHEN_SILENT) != 0,
                actual.mVibrateWhenSilent);
        assertEquals(tag + " ", expect.getRingtone(), actual.mRingtoneUri);
        assertEquals(tag + " sync window", expect.getSyncLookback(), actual.mSyncWindow);
        assertEquals(tag + " backup flags", 0, actual.mBackupFlags);
        assertEquals(tag + " proto vers", expect.mProtocolVersion, actual.mProtocolVersion);
        assertEquals(tag + " delete policy", expect.getDeletePolicy(), actual.getDeletePolicy());
        assertEquals(tag + " security", expect.mSecurityFlags, actual.mSecurityFlags);
        assertEquals(tag + " signature", expect.mSignature, actual.mSignature);
    }

    /**
     * Test conversion of a legacy mailbox to a provider mailbox
     */
    public void testMakeProviderMailbox() throws MessagingException {
        EmailContent.Account toAccount = ProviderTestUtils.setupAccount("convert-mailbox",
                true, mProviderContext);
        Folder fromFolder = buildTestFolder("INBOX");
        Mailbox toMailbox = LegacyConversions.makeMailbox(mProviderContext, toAccount, fromFolder);

        // Now test fields in created mailbox
        assertEquals("INBOX", toMailbox.mDisplayName);
        assertNull(toMailbox.mServerId);
        assertNull(toMailbox.mParentServerId);
        assertEquals(toAccount.mId, toMailbox.mAccountKey);
        assertEquals(Mailbox.TYPE_INBOX, toMailbox.mType);
        assertEquals(0, toMailbox.mDelimiter);
        assertNull(toMailbox.mSyncKey);
        assertEquals(0, toMailbox.mSyncLookback);
        assertEquals(0, toMailbox.mSyncInterval);
        assertEquals(0, toMailbox.mSyncTime);
        assertTrue(toMailbox.mFlagVisible);
        assertEquals(0, toMailbox.mFlags);
        assertEquals(Email.VISIBLE_LIMIT_DEFAULT, toMailbox.mVisibleLimit);
        assertNull(toMailbox.mSyncStatus);
    }

    /**
     * Build a lightweight Store Folder with simple field population.  The folder is "open"
     * and should be closed by the caller.
     */
    private Folder buildTestFolder(String folderName) throws MessagingException {
        String localStoreUri =
            "local://localhost/" + mProviderContext.getDatabasePath(LocalStoreUnitTests.DB_NAME);
        LocalStore store = (LocalStore) LocalStore.newInstance(localStoreUri, getContext(), null);
        LocalStore.LocalFolder folder = (LocalStore.LocalFolder) store.getFolder(folderName);
        folder.open(OpenMode.READ_WRITE, null);     // this will create it

        // set a few fields to test values
        // folder.getName - set by getFolder()
        folder.setUnreadMessageCount(100);

        return folder;
    }
}