Home | History | Annotate | Download | only in contacts
      1 /*
      2  * Copyright (C) 2009 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.contacts;
     18 
     19 import static android.content.ContentProviderOperation.TYPE_DELETE;
     20 import static android.content.ContentProviderOperation.TYPE_INSERT;
     21 import static android.content.ContentProviderOperation.TYPE_UPDATE;
     22 
     23 import android.content.ContentProviderOperation;
     24 import android.content.ContentValues;
     25 import android.net.Uri;
     26 import android.os.Bundle;
     27 import android.provider.ContactsContract;
     28 import android.provider.ContactsContract.CommonDataKinds.Email;
     29 import android.provider.ContactsContract.CommonDataKinds.Event;
     30 import android.provider.ContactsContract.CommonDataKinds.Im;
     31 import android.provider.ContactsContract.CommonDataKinds.Organization;
     32 import android.provider.ContactsContract.CommonDataKinds.Phone;
     33 import android.provider.ContactsContract.CommonDataKinds.StructuredName;
     34 import android.provider.ContactsContract.CommonDataKinds.StructuredPostal;
     35 import android.provider.ContactsContract.Data;
     36 import android.provider.ContactsContract.Intents.Insert;
     37 import android.provider.ContactsContract.RawContacts;
     38 import android.test.AndroidTestCase;
     39 import android.test.suitebuilder.annotation.LargeTest;
     40 
     41 import com.android.contacts.common.model.AccountTypeManager;
     42 import com.android.contacts.model.RawContact;
     43 import com.android.contacts.model.RawContactDelta;
     44 import com.android.contacts.common.model.ValuesDelta;
     45 import com.android.contacts.model.RawContactDeltaList;
     46 import com.android.contacts.model.RawContactModifier;
     47 import com.android.contacts.common.model.account.AccountType;
     48 import com.android.contacts.common.model.account.AccountType.EditType;
     49 import com.android.contacts.common.model.account.ExchangeAccountType;
     50 import com.android.contacts.common.model.account.GoogleAccountType;
     51 import com.android.contacts.common.model.dataitem.DataKind;
     52 import com.android.contacts.common.test.mocks.ContactsMockContext;
     53 import com.android.contacts.tests.mocks.MockAccountTypeManager;
     54 import com.android.contacts.common.test.mocks.MockContentProvider;
     55 import com.google.common.collect.Lists;
     56 
     57 import java.util.ArrayList;
     58 import java.util.List;
     59 
     60 /**
     61  * Tests for {@link RawContactModifier} to verify that {@link AccountType}
     62  * constraints are being enforced correctly.
     63  */
     64 @LargeTest
     65 public class RawContactModifierTests extends AndroidTestCase {
     66     public static final String TAG = "EntityModifierTests";
     67 
     68     public static final long VER_FIRST = 100;
     69 
     70     private static final long TEST_ID = 4;
     71     private static final String TEST_PHONE = "218-555-1212";
     72     private static final String TEST_NAME = "Adam Young";
     73     private static final String TEST_NAME2 = "Breanne Duren";
     74     private static final String TEST_IM = "example (at) example.com";
     75     private static final String TEST_POSTAL = "1600 Amphitheatre Parkway";
     76 
     77     private static final String TEST_ACCOUNT_NAME = "unittest (at) example.com";
     78     private static final String TEST_ACCOUNT_TYPE = "com.example.unittest";
     79 
     80     private static final String EXCHANGE_ACCT_TYPE = "com.android.exchange";
     81 
     82     @Override
     83     public void setUp() {
     84         mContext = getContext();
     85     }
     86 
     87     public static class MockContactsSource extends AccountType {
     88 
     89         MockContactsSource() {
     90             try {
     91                 this.accountType = TEST_ACCOUNT_TYPE;
     92 
     93                 final DataKind nameKind = new DataKind(StructuredName.CONTENT_ITEM_TYPE,
     94                         R.string.nameLabelsGroup, -1, true);
     95                 nameKind.typeOverallMax = 1;
     96                 addKind(nameKind);
     97 
     98                 // Phone allows maximum 2 home, 1 work, and unlimited other, with
     99                 // constraint of 5 numbers maximum.
    100                 final DataKind phoneKind = new DataKind(
    101                         Phone.CONTENT_ITEM_TYPE, -1, 10, true);
    102 
    103                 phoneKind.typeOverallMax = 5;
    104                 phoneKind.typeColumn = Phone.TYPE;
    105                 phoneKind.typeList = Lists.newArrayList();
    106                 phoneKind.typeList.add(new EditType(Phone.TYPE_HOME, -1).setSpecificMax(2));
    107                 phoneKind.typeList.add(new EditType(Phone.TYPE_WORK, -1).setSpecificMax(1));
    108                 phoneKind.typeList.add(new EditType(Phone.TYPE_FAX_WORK, -1).setSecondary(true));
    109                 phoneKind.typeList.add(new EditType(Phone.TYPE_OTHER, -1));
    110 
    111                 phoneKind.fieldList = Lists.newArrayList();
    112                 phoneKind.fieldList.add(new EditField(Phone.NUMBER, -1, -1));
    113                 phoneKind.fieldList.add(new EditField(Phone.LABEL, -1, -1));
    114 
    115                 addKind(phoneKind);
    116 
    117                 // Email is unlimited
    118                 final DataKind emailKind = new DataKind(Email.CONTENT_ITEM_TYPE, -1, 10, true);
    119                 emailKind.typeOverallMax = -1;
    120                 emailKind.fieldList = Lists.newArrayList();
    121                 emailKind.fieldList.add(new EditField(Email.DATA, -1, -1));
    122                 addKind(emailKind);
    123 
    124                 // IM is only one
    125                 final DataKind imKind = new DataKind(Im.CONTENT_ITEM_TYPE, -1, 10, true);
    126                 imKind.typeOverallMax = 1;
    127                 imKind.fieldList = Lists.newArrayList();
    128                 imKind.fieldList.add(new EditField(Im.DATA, -1, -1));
    129                 addKind(imKind);
    130 
    131                 // Organization is only one
    132                 final DataKind orgKind = new DataKind(Organization.CONTENT_ITEM_TYPE, -1, 10, true);
    133                 orgKind.typeOverallMax = 1;
    134                 orgKind.fieldList = Lists.newArrayList();
    135                 orgKind.fieldList.add(new EditField(Organization.COMPANY, -1, -1));
    136                 orgKind.fieldList.add(new EditField(Organization.TITLE, -1, -1));
    137                 addKind(orgKind);
    138             } catch (DefinitionException e) {
    139                 throw new RuntimeException(e);
    140             }
    141         }
    142 
    143         @Override
    144         public boolean isGroupMembershipEditable() {
    145             return false;
    146         }
    147 
    148         @Override
    149         public boolean areContactsWritable() {
    150             return true;
    151         }
    152     }
    153 
    154     /**
    155      * Build a {@link AccountType} that has various odd constraints for
    156      * testing purposes.
    157      */
    158     protected AccountType getAccountType() {
    159         return new MockContactsSource();
    160     }
    161 
    162     /**
    163      * Build {@link AccountTypeManager} instance.
    164      */
    165     protected AccountTypeManager getAccountTypes(AccountType... types) {
    166         return new MockAccountTypeManager(types, null);
    167     }
    168 
    169     /**
    170      * Build an {@link RawContact} with the requested set of phone numbers.
    171      */
    172     protected RawContactDelta getRawContact(Long existingId, ContentValues... entries) {
    173         final ContentValues contact = new ContentValues();
    174         if (existingId != null) {
    175             contact.put(RawContacts._ID, existingId);
    176         }
    177         contact.put(RawContacts.ACCOUNT_NAME, TEST_ACCOUNT_NAME);
    178         contact.put(RawContacts.ACCOUNT_TYPE, TEST_ACCOUNT_TYPE);
    179 
    180         final RawContact before = new RawContact(contact);
    181         for (ContentValues values : entries) {
    182             before.addDataItemValues(values);
    183         }
    184         return RawContactDelta.fromBefore(before);
    185     }
    186 
    187     /**
    188      * Assert this {@link List} contains the given {@link Object}.
    189      */
    190     protected void assertContains(List<?> list, Object object) {
    191         assertTrue("Missing expected value", list.contains(object));
    192     }
    193 
    194     /**
    195      * Assert this {@link List} does not contain the given {@link Object}.
    196      */
    197     protected void assertNotContains(List<?> list, Object object) {
    198         assertFalse("Contained unexpected value", list.contains(object));
    199     }
    200 
    201     /**
    202      * Insert various rows to test
    203      * {@link RawContactModifier#getValidTypes(RawContactDelta, DataKind, EditType)}
    204      */
    205     public void testValidTypes() {
    206         // Build a source and pull specific types
    207         final AccountType source = getAccountType();
    208         final DataKind kindPhone = source.getKindForMimetype(Phone.CONTENT_ITEM_TYPE);
    209         final EditType typeHome = RawContactModifier.getType(kindPhone, Phone.TYPE_HOME);
    210         final EditType typeWork = RawContactModifier.getType(kindPhone, Phone.TYPE_WORK);
    211         final EditType typeOther = RawContactModifier.getType(kindPhone, Phone.TYPE_OTHER);
    212 
    213         List<EditType> validTypes;
    214 
    215         // Add first home, first work
    216         final RawContactDelta state = getRawContact(TEST_ID);
    217         RawContactModifier.insertChild(state, kindPhone, typeHome);
    218         RawContactModifier.insertChild(state, kindPhone, typeWork);
    219 
    220         // Expecting home, other
    221         validTypes = RawContactModifier.getValidTypes(state, kindPhone, null);
    222         assertContains(validTypes, typeHome);
    223         assertNotContains(validTypes, typeWork);
    224         assertContains(validTypes, typeOther);
    225 
    226         // Add second home
    227         RawContactModifier.insertChild(state, kindPhone, typeHome);
    228 
    229         // Expecting other
    230         validTypes = RawContactModifier.getValidTypes(state, kindPhone, null);
    231         assertNotContains(validTypes, typeHome);
    232         assertNotContains(validTypes, typeWork);
    233         assertContains(validTypes, typeOther);
    234 
    235         // Add third and fourth home (invalid, but possible)
    236         RawContactModifier.insertChild(state, kindPhone, typeHome);
    237         RawContactModifier.insertChild(state, kindPhone, typeHome);
    238 
    239         // Expecting none
    240         validTypes = RawContactModifier.getValidTypes(state, kindPhone, null);
    241         assertNotContains(validTypes, typeHome);
    242         assertNotContains(validTypes, typeWork);
    243         assertNotContains(validTypes, typeOther);
    244     }
    245 
    246     /**
    247      * Test {@link RawContactModifier#canInsert(RawContactDelta, DataKind)} by
    248      * inserting various rows.
    249      */
    250     public void testCanInsert() {
    251         // Build a source and pull specific types
    252         final AccountType source = getAccountType();
    253         final DataKind kindPhone = source.getKindForMimetype(Phone.CONTENT_ITEM_TYPE);
    254         final EditType typeHome = RawContactModifier.getType(kindPhone, Phone.TYPE_HOME);
    255         final EditType typeWork = RawContactModifier.getType(kindPhone, Phone.TYPE_WORK);
    256         final EditType typeOther = RawContactModifier.getType(kindPhone, Phone.TYPE_OTHER);
    257 
    258         // Add first home, first work
    259         final RawContactDelta state = getRawContact(TEST_ID);
    260         RawContactModifier.insertChild(state, kindPhone, typeHome);
    261         RawContactModifier.insertChild(state, kindPhone, typeWork);
    262         assertTrue("Unable to insert", RawContactModifier.canInsert(state, kindPhone));
    263 
    264         // Add two other, which puts us just under "5" overall limit
    265         RawContactModifier.insertChild(state, kindPhone, typeOther);
    266         RawContactModifier.insertChild(state, kindPhone, typeOther);
    267         assertTrue("Unable to insert", RawContactModifier.canInsert(state, kindPhone));
    268 
    269         // Add second home, which should push to snug limit
    270         RawContactModifier.insertChild(state, kindPhone, typeHome);
    271         assertFalse("Able to insert", RawContactModifier.canInsert(state, kindPhone));
    272     }
    273 
    274     /**
    275      * Test
    276      * {@link RawContactModifier#getBestValidType(RawContactDelta, DataKind, boolean, int)}
    277      * by asserting expected best options in various states.
    278      */
    279     public void testBestValidType() {
    280         // Build a source and pull specific types
    281         final AccountType source = getAccountType();
    282         final DataKind kindPhone = source.getKindForMimetype(Phone.CONTENT_ITEM_TYPE);
    283         final EditType typeHome = RawContactModifier.getType(kindPhone, Phone.TYPE_HOME);
    284         final EditType typeWork = RawContactModifier.getType(kindPhone, Phone.TYPE_WORK);
    285         final EditType typeFaxWork = RawContactModifier.getType(kindPhone, Phone.TYPE_FAX_WORK);
    286         final EditType typeOther = RawContactModifier.getType(kindPhone, Phone.TYPE_OTHER);
    287 
    288         EditType suggested;
    289 
    290         // Default suggestion should be home
    291         final RawContactDelta state = getRawContact(TEST_ID);
    292         suggested = RawContactModifier.getBestValidType(state, kindPhone, false, Integer.MIN_VALUE);
    293         assertEquals("Unexpected suggestion", typeHome, suggested);
    294 
    295         // Add first home, should now suggest work
    296         RawContactModifier.insertChild(state, kindPhone, typeHome);
    297         suggested = RawContactModifier.getBestValidType(state, kindPhone, false, Integer.MIN_VALUE);
    298         assertEquals("Unexpected suggestion", typeWork, suggested);
    299 
    300         // Add work fax, should still suggest work
    301         RawContactModifier.insertChild(state, kindPhone, typeFaxWork);
    302         suggested = RawContactModifier.getBestValidType(state, kindPhone, false, Integer.MIN_VALUE);
    303         assertEquals("Unexpected suggestion", typeWork, suggested);
    304 
    305         // Add other, should still suggest work
    306         RawContactModifier.insertChild(state, kindPhone, typeOther);
    307         suggested = RawContactModifier.getBestValidType(state, kindPhone, false, Integer.MIN_VALUE);
    308         assertEquals("Unexpected suggestion", typeWork, suggested);
    309 
    310         // Add work, now should suggest other
    311         RawContactModifier.insertChild(state, kindPhone, typeWork);
    312         suggested = RawContactModifier.getBestValidType(state, kindPhone, false, Integer.MIN_VALUE);
    313         assertEquals("Unexpected suggestion", typeOther, suggested);
    314     }
    315 
    316     public void testIsEmptyEmpty() {
    317         final AccountType source = getAccountType();
    318         final DataKind kindPhone = source.getKindForMimetype(Phone.CONTENT_ITEM_TYPE);
    319 
    320         // Test entirely empty row
    321         final ContentValues after = new ContentValues();
    322         final ValuesDelta values = ValuesDelta.fromAfter(after);
    323 
    324         assertTrue("Expected empty", RawContactModifier.isEmpty(values, kindPhone));
    325     }
    326 
    327     public void testIsEmptyDirectFields() {
    328         final AccountType source = getAccountType();
    329         final DataKind kindPhone = source.getKindForMimetype(Phone.CONTENT_ITEM_TYPE);
    330         final EditType typeHome = RawContactModifier.getType(kindPhone, Phone.TYPE_HOME);
    331 
    332         // Test row that has type values, but core fields are empty
    333         final RawContactDelta state = getRawContact(TEST_ID);
    334         final ValuesDelta values = RawContactModifier.insertChild(state, kindPhone, typeHome);
    335 
    336         assertTrue("Expected empty", RawContactModifier.isEmpty(values, kindPhone));
    337 
    338         // Insert some data to trigger non-empty state
    339         values.put(Phone.NUMBER, TEST_PHONE);
    340 
    341         assertFalse("Expected non-empty", RawContactModifier.isEmpty(values, kindPhone));
    342     }
    343 
    344     public void testTrimEmptySingle() {
    345         final AccountType source = getAccountType();
    346         final DataKind kindPhone = source.getKindForMimetype(Phone.CONTENT_ITEM_TYPE);
    347         final EditType typeHome = RawContactModifier.getType(kindPhone, Phone.TYPE_HOME);
    348 
    349         // Test row that has type values, but core fields are empty
    350         final RawContactDelta state = getRawContact(TEST_ID);
    351         RawContactModifier.insertChild(state, kindPhone, typeHome);
    352 
    353         // Build diff, expecting insert for data row and update enforcement
    354         final ArrayList<ContentProviderOperation> diff = Lists.newArrayList();
    355         state.buildDiff(diff);
    356         assertEquals("Unexpected operations", 3, diff.size());
    357         {
    358             final ContentProviderOperation oper = diff.get(0);
    359             assertEquals("Expected aggregation mode change", TYPE_UPDATE, oper.getType());
    360             assertEquals("Incorrect target", RawContacts.CONTENT_URI, oper.getUri());
    361         }
    362         {
    363             final ContentProviderOperation oper = diff.get(1);
    364             assertEquals("Incorrect type", TYPE_INSERT, oper.getType());
    365             assertEquals("Incorrect target", Data.CONTENT_URI, oper.getUri());
    366         }
    367         {
    368             final ContentProviderOperation oper = diff.get(2);
    369             assertEquals("Expected aggregation mode change", TYPE_UPDATE, oper.getType());
    370             assertEquals("Incorrect target", RawContacts.CONTENT_URI, oper.getUri());
    371         }
    372 
    373         // Trim empty rows and try again, expecting delete of overall contact
    374         RawContactModifier.trimEmpty(state, source);
    375         diff.clear();
    376         state.buildDiff(diff);
    377         assertEquals("Unexpected operations", 1, diff.size());
    378         {
    379             final ContentProviderOperation oper = diff.get(0);
    380             assertEquals("Incorrect type", TYPE_DELETE, oper.getType());
    381             assertEquals("Incorrect target", RawContacts.CONTENT_URI, oper.getUri());
    382         }
    383     }
    384 
    385     public void testTrimEmptySpaces() {
    386         final AccountType source = getAccountType();
    387         final DataKind kindPhone = source.getKindForMimetype(Phone.CONTENT_ITEM_TYPE);
    388         final EditType typeHome = RawContactModifier.getType(kindPhone, Phone.TYPE_HOME);
    389 
    390         // Test row that has type values, but values are spaces
    391         final RawContactDelta state = RawContactDeltaListTests.buildBeforeEntity(mContext, TEST_ID,
    392                 VER_FIRST);
    393         final ValuesDelta values = RawContactModifier.insertChild(state, kindPhone, typeHome);
    394         values.put(Phone.NUMBER, "   ");
    395 
    396         // Build diff, expecting insert for data row and update enforcement
    397         RawContactDeltaListTests.assertDiffPattern(state,
    398                 RawContactDeltaListTests.buildAssertVersion(VER_FIRST),
    399                 RawContactDeltaListTests.buildUpdateAggregationSuspended(),
    400                 RawContactDeltaListTests.buildOper(Data.CONTENT_URI, TYPE_INSERT,
    401                         RawContactDeltaListTests.buildDataInsert(values, TEST_ID)),
    402                 RawContactDeltaListTests.buildUpdateAggregationDefault());
    403 
    404         // Trim empty rows and try again, expecting delete of overall contact
    405         RawContactModifier.trimEmpty(state, source);
    406         RawContactDeltaListTests.assertDiffPattern(state,
    407                 RawContactDeltaListTests.buildAssertVersion(VER_FIRST),
    408                 RawContactDeltaListTests.buildDelete(RawContacts.CONTENT_URI));
    409     }
    410 
    411     public void testTrimLeaveValid() {
    412         final AccountType source = getAccountType();
    413         final DataKind kindPhone = source.getKindForMimetype(Phone.CONTENT_ITEM_TYPE);
    414         final EditType typeHome = RawContactModifier.getType(kindPhone, Phone.TYPE_HOME);
    415 
    416         // Test row that has type values with valid number
    417         final RawContactDelta state = RawContactDeltaListTests.buildBeforeEntity(mContext, TEST_ID,
    418                 VER_FIRST);
    419         final ValuesDelta values = RawContactModifier.insertChild(state, kindPhone, typeHome);
    420         values.put(Phone.NUMBER, TEST_PHONE);
    421 
    422         // Build diff, expecting insert for data row and update enforcement
    423         RawContactDeltaListTests.assertDiffPattern(state,
    424                 RawContactDeltaListTests.buildAssertVersion(VER_FIRST),
    425                 RawContactDeltaListTests.buildUpdateAggregationSuspended(),
    426                 RawContactDeltaListTests.buildOper(Data.CONTENT_URI, TYPE_INSERT,
    427                         RawContactDeltaListTests.buildDataInsert(values, TEST_ID)),
    428                 RawContactDeltaListTests.buildUpdateAggregationDefault());
    429 
    430         // Trim empty rows and try again, expecting no differences
    431         RawContactModifier.trimEmpty(state, source);
    432         RawContactDeltaListTests.assertDiffPattern(state,
    433                 RawContactDeltaListTests.buildAssertVersion(VER_FIRST),
    434                 RawContactDeltaListTests.buildUpdateAggregationSuspended(),
    435                 RawContactDeltaListTests.buildOper(Data.CONTENT_URI, TYPE_INSERT,
    436                         RawContactDeltaListTests.buildDataInsert(values, TEST_ID)),
    437                 RawContactDeltaListTests.buildUpdateAggregationDefault());
    438     }
    439 
    440     public void testTrimEmptyUntouched() {
    441         final AccountType source = getAccountType();
    442         final DataKind kindPhone = source.getKindForMimetype(Phone.CONTENT_ITEM_TYPE);
    443         RawContactModifier.getType(kindPhone, Phone.TYPE_HOME);
    444 
    445         // Build "before" that has empty row
    446         final RawContactDelta state = getRawContact(TEST_ID);
    447         final ContentValues before = new ContentValues();
    448         before.put(Data._ID, TEST_ID);
    449         before.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);
    450         state.addEntry(ValuesDelta.fromBefore(before));
    451 
    452         // Build diff, expecting no changes
    453         final ArrayList<ContentProviderOperation> diff = Lists.newArrayList();
    454         state.buildDiff(diff);
    455         assertEquals("Unexpected operations", 0, diff.size());
    456 
    457         // Try trimming existing empty, which we shouldn't touch
    458         RawContactModifier.trimEmpty(state, source);
    459         diff.clear();
    460         state.buildDiff(diff);
    461         assertEquals("Unexpected operations", 0, diff.size());
    462     }
    463 
    464     public void testTrimEmptyAfterUpdate() {
    465         final AccountType source = getAccountType();
    466         final DataKind kindPhone = source.getKindForMimetype(Phone.CONTENT_ITEM_TYPE);
    467         final EditType typeHome = RawContactModifier.getType(kindPhone, Phone.TYPE_HOME);
    468 
    469         // Build "before" that has row with some phone number
    470         final ContentValues before = new ContentValues();
    471         before.put(Data._ID, TEST_ID);
    472         before.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);
    473         before.put(kindPhone.typeColumn, typeHome.rawValue);
    474         before.put(Phone.NUMBER, TEST_PHONE);
    475         final RawContactDelta state = getRawContact(TEST_ID, before);
    476 
    477         // Build diff, expecting no changes
    478         final ArrayList<ContentProviderOperation> diff = Lists.newArrayList();
    479         state.buildDiff(diff);
    480         assertEquals("Unexpected operations", 0, diff.size());
    481 
    482         // Now update row by changing number to empty string, expecting single update
    483         final ValuesDelta child = state.getEntry(TEST_ID);
    484         child.put(Phone.NUMBER, "");
    485         diff.clear();
    486         state.buildDiff(diff);
    487         assertEquals("Unexpected operations", 3, diff.size());
    488         {
    489             final ContentProviderOperation oper = diff.get(0);
    490             assertEquals("Expected aggregation mode change", TYPE_UPDATE, oper.getType());
    491             assertEquals("Incorrect target", RawContacts.CONTENT_URI, oper.getUri());
    492         }
    493         {
    494             final ContentProviderOperation oper = diff.get(1);
    495             assertEquals("Incorrect type", TYPE_UPDATE, oper.getType());
    496             assertEquals("Incorrect target", Data.CONTENT_URI, oper.getUri());
    497         }
    498         {
    499             final ContentProviderOperation oper = diff.get(2);
    500             assertEquals("Expected aggregation mode change", TYPE_UPDATE, oper.getType());
    501             assertEquals("Incorrect target", RawContacts.CONTENT_URI, oper.getUri());
    502         }
    503 
    504         // Now run trim, which should turn that update into delete
    505         RawContactModifier.trimEmpty(state, source);
    506         diff.clear();
    507         state.buildDiff(diff);
    508         assertEquals("Unexpected operations", 1, diff.size());
    509         {
    510             final ContentProviderOperation oper = diff.get(0);
    511             assertEquals("Incorrect type", TYPE_DELETE, oper.getType());
    512             assertEquals("Incorrect target", RawContacts.CONTENT_URI, oper.getUri());
    513         }
    514     }
    515 
    516     public void testTrimInsertEmpty() {
    517         final AccountType accountType = getAccountType();
    518         final AccountTypeManager accountTypes = getAccountTypes(accountType);
    519         final DataKind kindPhone = accountType.getKindForMimetype(Phone.CONTENT_ITEM_TYPE);
    520         RawContactModifier.getType(kindPhone, Phone.TYPE_HOME);
    521 
    522         // Try creating a contact without any child entries
    523         final RawContactDelta state = getRawContact(null);
    524         final RawContactDeltaList set = new RawContactDeltaList();
    525         set.add(state);
    526 
    527 
    528         // Build diff, expecting single insert
    529         final ArrayList<ContentProviderOperation> diff = Lists.newArrayList();
    530         state.buildDiff(diff);
    531         assertEquals("Unexpected operations", 2, diff.size());
    532         {
    533             final ContentProviderOperation oper = diff.get(0);
    534             assertEquals("Incorrect type", TYPE_INSERT, oper.getType());
    535             assertEquals("Incorrect target", RawContacts.CONTENT_URI, oper.getUri());
    536         }
    537 
    538         // Trim empty rows and try again, expecting no insert
    539         RawContactModifier.trimEmpty(set, accountTypes);
    540         diff.clear();
    541         state.buildDiff(diff);
    542         assertEquals("Unexpected operations", 0, diff.size());
    543     }
    544 
    545     public void testTrimInsertInsert() {
    546         final AccountType accountType = getAccountType();
    547         final AccountTypeManager accountTypes = getAccountTypes(accountType);
    548         final DataKind kindPhone = accountType.getKindForMimetype(Phone.CONTENT_ITEM_TYPE);
    549         final EditType typeHome = RawContactModifier.getType(kindPhone, Phone.TYPE_HOME);
    550 
    551         // Try creating a contact with single empty entry
    552         final RawContactDelta state = getRawContact(null);
    553         RawContactModifier.insertChild(state, kindPhone, typeHome);
    554         final RawContactDeltaList set = new RawContactDeltaList();
    555         set.add(state);
    556 
    557         // Build diff, expecting two insert operations
    558         final ArrayList<ContentProviderOperation> diff = Lists.newArrayList();
    559         state.buildDiff(diff);
    560         assertEquals("Unexpected operations", 3, diff.size());
    561         {
    562             final ContentProviderOperation oper = diff.get(0);
    563             assertEquals("Incorrect type", TYPE_INSERT, oper.getType());
    564             assertEquals("Incorrect target", RawContacts.CONTENT_URI, oper.getUri());
    565         }
    566         {
    567             final ContentProviderOperation oper = diff.get(1);
    568             assertEquals("Incorrect type", TYPE_INSERT, oper.getType());
    569             assertEquals("Incorrect target", Data.CONTENT_URI, oper.getUri());
    570         }
    571 
    572         // Trim empty rows and try again, expecting silence
    573         RawContactModifier.trimEmpty(set, accountTypes);
    574         diff.clear();
    575         state.buildDiff(diff);
    576         assertEquals("Unexpected operations", 0, diff.size());
    577     }
    578 
    579     public void testTrimUpdateRemain() {
    580         final AccountType accountType = getAccountType();
    581         final AccountTypeManager accountTypes = getAccountTypes(accountType);
    582         final DataKind kindPhone = accountType.getKindForMimetype(Phone.CONTENT_ITEM_TYPE);
    583         final EditType typeHome = RawContactModifier.getType(kindPhone, Phone.TYPE_HOME);
    584 
    585         // Build "before" with two phone numbers
    586         final ContentValues first = new ContentValues();
    587         first.put(Data._ID, TEST_ID);
    588         first.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);
    589         first.put(kindPhone.typeColumn, typeHome.rawValue);
    590         first.put(Phone.NUMBER, TEST_PHONE);
    591 
    592         final ContentValues second = new ContentValues();
    593         second.put(Data._ID, TEST_ID);
    594         second.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);
    595         second.put(kindPhone.typeColumn, typeHome.rawValue);
    596         second.put(Phone.NUMBER, TEST_PHONE);
    597 
    598         final RawContactDelta state = getRawContact(TEST_ID, first, second);
    599         final RawContactDeltaList set = new RawContactDeltaList();
    600         set.add(state);
    601 
    602         // Build diff, expecting no changes
    603         final ArrayList<ContentProviderOperation> diff = Lists.newArrayList();
    604         state.buildDiff(diff);
    605         assertEquals("Unexpected operations", 0, diff.size());
    606 
    607         // Now update row by changing number to empty string, expecting single update
    608         final ValuesDelta child = state.getEntry(TEST_ID);
    609         child.put(Phone.NUMBER, "");
    610         diff.clear();
    611         state.buildDiff(diff);
    612         assertEquals("Unexpected operations", 3, diff.size());
    613         {
    614             final ContentProviderOperation oper = diff.get(0);
    615             assertEquals("Expected aggregation mode change", TYPE_UPDATE, oper.getType());
    616             assertEquals("Incorrect target", RawContacts.CONTENT_URI, oper.getUri());
    617         }
    618         {
    619             final ContentProviderOperation oper = diff.get(1);
    620             assertEquals("Incorrect type", TYPE_UPDATE, oper.getType());
    621             assertEquals("Incorrect target", Data.CONTENT_URI, oper.getUri());
    622         }
    623         {
    624             final ContentProviderOperation oper = diff.get(2);
    625             assertEquals("Expected aggregation mode change", TYPE_UPDATE, oper.getType());
    626             assertEquals("Incorrect target", RawContacts.CONTENT_URI, oper.getUri());
    627         }
    628 
    629         // Now run trim, which should turn that update into delete
    630         RawContactModifier.trimEmpty(set, accountTypes);
    631         diff.clear();
    632         state.buildDiff(diff);
    633         assertEquals("Unexpected operations", 3, diff.size());
    634         {
    635             final ContentProviderOperation oper = diff.get(0);
    636             assertEquals("Expected aggregation mode change", TYPE_UPDATE, oper.getType());
    637             assertEquals("Incorrect target", RawContacts.CONTENT_URI, oper.getUri());
    638         }
    639         {
    640             final ContentProviderOperation oper = diff.get(1);
    641             assertEquals("Incorrect type", TYPE_DELETE, oper.getType());
    642             assertEquals("Incorrect target", Data.CONTENT_URI, oper.getUri());
    643         }
    644         {
    645             final ContentProviderOperation oper = diff.get(2);
    646             assertEquals("Expected aggregation mode change", TYPE_UPDATE, oper.getType());
    647             assertEquals("Incorrect target", RawContacts.CONTENT_URI, oper.getUri());
    648         }
    649     }
    650 
    651     public void testTrimUpdateUpdate() {
    652         final AccountType accountType = getAccountType();
    653         final AccountTypeManager accountTypes = getAccountTypes(accountType);
    654         final DataKind kindPhone = accountType.getKindForMimetype(Phone.CONTENT_ITEM_TYPE);
    655         final EditType typeHome = RawContactModifier.getType(kindPhone, Phone.TYPE_HOME);
    656 
    657         // Build "before" with two phone numbers
    658         final ContentValues first = new ContentValues();
    659         first.put(Data._ID, TEST_ID);
    660         first.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);
    661         first.put(kindPhone.typeColumn, typeHome.rawValue);
    662         first.put(Phone.NUMBER, TEST_PHONE);
    663 
    664         final RawContactDelta state = getRawContact(TEST_ID, first);
    665         final RawContactDeltaList set = new RawContactDeltaList();
    666         set.add(state);
    667 
    668         // Build diff, expecting no changes
    669         final ArrayList<ContentProviderOperation> diff = Lists.newArrayList();
    670         state.buildDiff(diff);
    671         assertEquals("Unexpected operations", 0, diff.size());
    672 
    673         // Now update row by changing number to empty string, expecting single update
    674         final ValuesDelta child = state.getEntry(TEST_ID);
    675         child.put(Phone.NUMBER, "");
    676         diff.clear();
    677         state.buildDiff(diff);
    678         assertEquals("Unexpected operations", 3, diff.size());
    679         {
    680             final ContentProviderOperation oper = diff.get(0);
    681             assertEquals("Expected aggregation mode change", TYPE_UPDATE, oper.getType());
    682             assertEquals("Incorrect target", RawContacts.CONTENT_URI, oper.getUri());
    683         }
    684         {
    685             final ContentProviderOperation oper = diff.get(1);
    686             assertEquals("Incorrect type", TYPE_UPDATE, oper.getType());
    687             assertEquals("Incorrect target", Data.CONTENT_URI, oper.getUri());
    688         }
    689         {
    690             final ContentProviderOperation oper = diff.get(2);
    691             assertEquals("Expected aggregation mode change", TYPE_UPDATE, oper.getType());
    692             assertEquals("Incorrect target", RawContacts.CONTENT_URI, oper.getUri());
    693         }
    694 
    695         // Now run trim, which should turn into deleting the whole contact
    696         RawContactModifier.trimEmpty(set, accountTypes);
    697         diff.clear();
    698         state.buildDiff(diff);
    699         assertEquals("Unexpected operations", 1, diff.size());
    700         {
    701             final ContentProviderOperation oper = diff.get(0);
    702             assertEquals("Incorrect type", TYPE_DELETE, oper.getType());
    703             assertEquals("Incorrect target", RawContacts.CONTENT_URI, oper.getUri());
    704         }
    705     }
    706 
    707     public void testParseExtrasExistingName() {
    708         final AccountType accountType = getAccountType();
    709 
    710         // Build "before" name
    711         final ContentValues first = new ContentValues();
    712         first.put(Data._ID, TEST_ID);
    713         first.put(Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE);
    714         first.put(StructuredName.GIVEN_NAME, TEST_NAME);
    715 
    716         // Parse extras, making sure we keep single name
    717         final RawContactDelta state = getRawContact(TEST_ID, first);
    718         final Bundle extras = new Bundle();
    719         extras.putString(Insert.NAME, TEST_NAME2);
    720         RawContactModifier.parseExtras(mContext, accountType, state, extras);
    721 
    722         final int nameCount = state.getMimeEntriesCount(StructuredName.CONTENT_ITEM_TYPE, true);
    723         assertEquals("Unexpected names", 1, nameCount);
    724     }
    725 
    726     public void testParseExtrasIgnoreLimit() {
    727         final AccountType accountType = getAccountType();
    728 
    729         // Build "before" IM
    730         final ContentValues first = new ContentValues();
    731         first.put(Data._ID, TEST_ID);
    732         first.put(Data.MIMETYPE, Im.CONTENT_ITEM_TYPE);
    733         first.put(Im.DATA, TEST_IM);
    734 
    735         final RawContactDelta state = getRawContact(TEST_ID, first);
    736         final int beforeCount = state.getMimeEntries(Im.CONTENT_ITEM_TYPE).size();
    737 
    738         // We should ignore data that doesn't fit account type rules, since account type
    739         // only allows single Im
    740         final Bundle extras = new Bundle();
    741         extras.putInt(Insert.IM_PROTOCOL, Im.PROTOCOL_GOOGLE_TALK);
    742         extras.putString(Insert.IM_HANDLE, TEST_IM);
    743         RawContactModifier.parseExtras(mContext, accountType, state, extras);
    744 
    745         final int afterCount = state.getMimeEntries(Im.CONTENT_ITEM_TYPE).size();
    746         assertEquals("Broke account type rules", beforeCount, afterCount);
    747     }
    748 
    749     public void testParseExtrasIgnoreUnhandled() {
    750         final AccountType accountType = getAccountType();
    751         final RawContactDelta state = getRawContact(TEST_ID);
    752 
    753         // We should silently ignore types unsupported by account type
    754         final Bundle extras = new Bundle();
    755         extras.putString(Insert.POSTAL, TEST_POSTAL);
    756         RawContactModifier.parseExtras(mContext, accountType, state, extras);
    757 
    758         assertNull("Broke accoun type rules",
    759                 state.getMimeEntries(StructuredPostal.CONTENT_ITEM_TYPE));
    760     }
    761 
    762     public void testParseExtrasJobTitle() {
    763         final AccountType accountType = getAccountType();
    764         final RawContactDelta state = getRawContact(TEST_ID);
    765 
    766         // Make sure that we create partial Organizations
    767         final Bundle extras = new Bundle();
    768         extras.putString(Insert.JOB_TITLE, TEST_NAME);
    769         RawContactModifier.parseExtras(mContext, accountType, state, extras);
    770 
    771         final int count = state.getMimeEntries(Organization.CONTENT_ITEM_TYPE).size();
    772         assertEquals("Expected to create organization", 1, count);
    773     }
    774 
    775     public void testMigrateWithDisplayNameFromGoogleToExchange1() {
    776         AccountType oldAccountType = new GoogleAccountType(getContext(), "");
    777         AccountType newAccountType = new ExchangeAccountType(getContext(), "", EXCHANGE_ACCT_TYPE);
    778         DataKind kind = newAccountType.getKindForMimetype(StructuredName.CONTENT_ITEM_TYPE);
    779 
    780         ContactsMockContext context = new ContactsMockContext(getContext());
    781 
    782         RawContactDelta oldState = new RawContactDelta();
    783         ContentValues mockNameValues = new ContentValues();
    784         mockNameValues.put(Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE);
    785         mockNameValues.put(StructuredName.PREFIX, "prefix");
    786         mockNameValues.put(StructuredName.GIVEN_NAME, "given");
    787         mockNameValues.put(StructuredName.MIDDLE_NAME, "middle");
    788         mockNameValues.put(StructuredName.FAMILY_NAME, "family");
    789         mockNameValues.put(StructuredName.SUFFIX, "suffix");
    790         mockNameValues.put(StructuredName.PHONETIC_FAMILY_NAME, "PHONETIC_FAMILY");
    791         mockNameValues.put(StructuredName.PHONETIC_MIDDLE_NAME, "PHONETIC_MIDDLE");
    792         mockNameValues.put(StructuredName.PHONETIC_GIVEN_NAME, "PHONETIC_GIVEN");
    793         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
    794 
    795         RawContactDelta newState = new RawContactDelta();
    796         RawContactModifier.migrateStructuredName(context, oldState, newState, kind);
    797         List<ValuesDelta> list = newState.getMimeEntries(StructuredName.CONTENT_ITEM_TYPE);
    798         assertEquals(1, list.size());
    799 
    800         ContentValues output = list.get(0).getAfter();
    801         assertEquals("prefix", output.getAsString(StructuredName.PREFIX));
    802         assertEquals("given", output.getAsString(StructuredName.GIVEN_NAME));
    803         assertEquals("middle", output.getAsString(StructuredName.MIDDLE_NAME));
    804         assertEquals("family", output.getAsString(StructuredName.FAMILY_NAME));
    805         assertEquals("suffix", output.getAsString(StructuredName.SUFFIX));
    806         // Phonetic middle name isn't supported by Exchange.
    807         assertEquals("PHONETIC_FAMILY", output.getAsString(StructuredName.PHONETIC_FAMILY_NAME));
    808         assertEquals("PHONETIC_GIVEN", output.getAsString(StructuredName.PHONETIC_GIVEN_NAME));
    809     }
    810 
    811     public void testMigrateWithDisplayNameFromGoogleToExchange2() {
    812         AccountType oldAccountType = new GoogleAccountType(getContext(), "");
    813         AccountType newAccountType = new ExchangeAccountType(getContext(), "", EXCHANGE_ACCT_TYPE);
    814         DataKind kind = newAccountType.getKindForMimetype(StructuredName.CONTENT_ITEM_TYPE);
    815 
    816         ContactsMockContext context = new ContactsMockContext(getContext());
    817         MockContentProvider provider = context.getContactsProvider();
    818 
    819         String inputDisplayName = "prefix given middle family suffix";
    820         // The method will ask the provider to split/join StructuredName.
    821         Uri uriForBuildDisplayName =
    822                 ContactsContract.AUTHORITY_URI
    823                         .buildUpon()
    824                         .appendPath("complete_name")
    825                         .appendQueryParameter(StructuredName.DISPLAY_NAME, inputDisplayName)
    826                         .build();
    827         provider.expectQuery(uriForBuildDisplayName)
    828                 .returnRow("prefix", "given", "middle", "family", "suffix")
    829                 .withProjection(StructuredName.PREFIX, StructuredName.GIVEN_NAME,
    830                         StructuredName.MIDDLE_NAME, StructuredName.FAMILY_NAME,
    831                         StructuredName.SUFFIX);
    832 
    833         RawContactDelta oldState = new RawContactDelta();
    834         ContentValues mockNameValues = new ContentValues();
    835         mockNameValues.put(Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE);
    836         mockNameValues.put(StructuredName.DISPLAY_NAME, inputDisplayName);
    837         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
    838 
    839         RawContactDelta newState = new RawContactDelta();
    840         RawContactModifier.migrateStructuredName(context, oldState, newState, kind);
    841         List<ValuesDelta> list = newState.getMimeEntries(StructuredName.CONTENT_ITEM_TYPE);
    842         assertEquals(1, list.size());
    843 
    844         ContentValues outputValues = list.get(0).getAfter();
    845         assertEquals("prefix", outputValues.getAsString(StructuredName.PREFIX));
    846         assertEquals("given", outputValues.getAsString(StructuredName.GIVEN_NAME));
    847         assertEquals("middle", outputValues.getAsString(StructuredName.MIDDLE_NAME));
    848         assertEquals("family", outputValues.getAsString(StructuredName.FAMILY_NAME));
    849         assertEquals("suffix", outputValues.getAsString(StructuredName.SUFFIX));
    850     }
    851 
    852     public void testMigrateWithStructuredNameFromExchangeToGoogle() {
    853         AccountType oldAccountType = new ExchangeAccountType(getContext(), "", EXCHANGE_ACCT_TYPE);
    854         AccountType newAccountType = new GoogleAccountType(getContext(), "");
    855         DataKind kind = newAccountType.getKindForMimetype(StructuredName.CONTENT_ITEM_TYPE);
    856 
    857         ContactsMockContext context = new ContactsMockContext(getContext());
    858         MockContentProvider provider = context.getContactsProvider();
    859 
    860         // The method will ask the provider to split/join StructuredName.
    861         Uri uriForBuildDisplayName =
    862                 ContactsContract.AUTHORITY_URI
    863                         .buildUpon()
    864                         .appendPath("complete_name")
    865                         .appendQueryParameter(StructuredName.PREFIX, "prefix")
    866                         .appendQueryParameter(StructuredName.GIVEN_NAME, "given")
    867                         .appendQueryParameter(StructuredName.MIDDLE_NAME, "middle")
    868                         .appendQueryParameter(StructuredName.FAMILY_NAME, "family")
    869                         .appendQueryParameter(StructuredName.SUFFIX, "suffix")
    870                         .build();
    871         provider.expectQuery(uriForBuildDisplayName)
    872                 .returnRow("prefix given middle family suffix")
    873                 .withProjection(StructuredName.DISPLAY_NAME);
    874 
    875         RawContactDelta oldState = new RawContactDelta();
    876         ContentValues mockNameValues = new ContentValues();
    877         mockNameValues.put(Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE);
    878         mockNameValues.put(StructuredName.PREFIX, "prefix");
    879         mockNameValues.put(StructuredName.GIVEN_NAME, "given");
    880         mockNameValues.put(StructuredName.MIDDLE_NAME, "middle");
    881         mockNameValues.put(StructuredName.FAMILY_NAME, "family");
    882         mockNameValues.put(StructuredName.SUFFIX, "suffix");
    883         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
    884 
    885         RawContactDelta newState = new RawContactDelta();
    886         RawContactModifier.migrateStructuredName(context, oldState, newState, kind);
    887 
    888         List<ValuesDelta> list = newState.getMimeEntries(StructuredName.CONTENT_ITEM_TYPE);
    889         assertNotNull(list);
    890         assertEquals(1, list.size());
    891         ContentValues outputValues = list.get(0).getAfter();
    892         assertEquals("prefix given middle family suffix",
    893                 outputValues.getAsString(StructuredName.DISPLAY_NAME));
    894     }
    895 
    896     public void testMigratePostalFromGoogleToExchange() {
    897         AccountType oldAccountType = new GoogleAccountType(getContext(), "");
    898         AccountType newAccountType = new ExchangeAccountType(getContext(), "", EXCHANGE_ACCT_TYPE);
    899         DataKind kind = newAccountType.getKindForMimetype(StructuredPostal.CONTENT_ITEM_TYPE);
    900 
    901         RawContactDelta oldState = new RawContactDelta();
    902         ContentValues mockNameValues = new ContentValues();
    903         mockNameValues.put(Data.MIMETYPE, StructuredPostal.CONTENT_ITEM_TYPE);
    904         mockNameValues.put(StructuredPostal.FORMATTED_ADDRESS, "formatted_address");
    905         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
    906 
    907         RawContactDelta newState = new RawContactDelta();
    908         RawContactModifier.migratePostal(oldState, newState, kind);
    909 
    910         List<ValuesDelta> list = newState.getMimeEntries(StructuredPostal.CONTENT_ITEM_TYPE);
    911         assertNotNull(list);
    912         assertEquals(1, list.size());
    913         ContentValues outputValues = list.get(0).getAfter();
    914         // FORMATTED_ADDRESS isn't supported by Exchange.
    915         assertNull(outputValues.getAsString(StructuredPostal.FORMATTED_ADDRESS));
    916         assertEquals("formatted_address", outputValues.getAsString(StructuredPostal.STREET));
    917     }
    918 
    919     public void testMigratePostalFromExchangeToGoogle() {
    920         AccountType oldAccountType = new ExchangeAccountType(getContext(), "", EXCHANGE_ACCT_TYPE);
    921         AccountType newAccountType = new GoogleAccountType(getContext(), "");
    922         DataKind kind = newAccountType.getKindForMimetype(StructuredPostal.CONTENT_ITEM_TYPE);
    923 
    924         RawContactDelta oldState = new RawContactDelta();
    925         ContentValues mockNameValues = new ContentValues();
    926         mockNameValues.put(Data.MIMETYPE, StructuredPostal.CONTENT_ITEM_TYPE);
    927         mockNameValues.put(StructuredPostal.COUNTRY, "country");
    928         mockNameValues.put(StructuredPostal.POSTCODE, "postcode");
    929         mockNameValues.put(StructuredPostal.REGION, "region");
    930         mockNameValues.put(StructuredPostal.CITY, "city");
    931         mockNameValues.put(StructuredPostal.STREET, "street");
    932         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
    933 
    934         RawContactDelta newState = new RawContactDelta();
    935         RawContactModifier.migratePostal(oldState, newState, kind);
    936 
    937         List<ValuesDelta> list = newState.getMimeEntries(StructuredPostal.CONTENT_ITEM_TYPE);
    938         assertNotNull(list);
    939         assertEquals(1, list.size());
    940         ContentValues outputValues = list.get(0).getAfter();
    941 
    942         // Check FORMATTED_ADDRESS contains all info.
    943         String formattedAddress = outputValues.getAsString(StructuredPostal.FORMATTED_ADDRESS);
    944         assertNotNull(formattedAddress);
    945         assertTrue(formattedAddress.contains("country"));
    946         assertTrue(formattedAddress.contains("postcode"));
    947         assertTrue(formattedAddress.contains("region"));
    948         assertTrue(formattedAddress.contains("postcode"));
    949         assertTrue(formattedAddress.contains("city"));
    950         assertTrue(formattedAddress.contains("street"));
    951     }
    952 
    953     public void testMigrateEventFromGoogleToExchange1() {
    954         testMigrateEventCommon(new GoogleAccountType(getContext(), ""),
    955                 new ExchangeAccountType(getContext(), "", EXCHANGE_ACCT_TYPE));
    956     }
    957 
    958     public void testMigrateEventFromExchangeToGoogle() {
    959         testMigrateEventCommon(new ExchangeAccountType(getContext(), "", EXCHANGE_ACCT_TYPE),
    960                 new GoogleAccountType(getContext(), ""));
    961     }
    962 
    963     private void testMigrateEventCommon(AccountType oldAccountType, AccountType newAccountType) {
    964         DataKind kind = newAccountType.getKindForMimetype(Event.CONTENT_ITEM_TYPE);
    965 
    966         RawContactDelta oldState = new RawContactDelta();
    967         ContentValues mockNameValues = new ContentValues();
    968         mockNameValues.put(Data.MIMETYPE, Event.CONTENT_ITEM_TYPE);
    969         mockNameValues.put(Event.START_DATE, "1972-02-08");
    970         mockNameValues.put(Event.TYPE, Event.TYPE_BIRTHDAY);
    971         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
    972 
    973         RawContactDelta newState = new RawContactDelta();
    974         RawContactModifier.migrateEvent(oldState, newState, kind, 1990);
    975 
    976         List<ValuesDelta> list = newState.getMimeEntries(Event.CONTENT_ITEM_TYPE);
    977         assertNotNull(list);
    978         assertEquals(1, list.size());  // Anniversary should be dropped.
    979         ContentValues outputValues = list.get(0).getAfter();
    980 
    981         assertEquals("1972-02-08", outputValues.getAsString(Event.START_DATE));
    982         assertEquals(Event.TYPE_BIRTHDAY, outputValues.getAsInteger(Event.TYPE).intValue());
    983     }
    984 
    985     public void testMigrateEventFromGoogleToExchange2() {
    986         AccountType oldAccountType = new GoogleAccountType(getContext(), "");
    987         AccountType newAccountType = new ExchangeAccountType(getContext(), "", EXCHANGE_ACCT_TYPE);
    988         DataKind kind = newAccountType.getKindForMimetype(Event.CONTENT_ITEM_TYPE);
    989 
    990         RawContactDelta oldState = new RawContactDelta();
    991         ContentValues mockNameValues = new ContentValues();
    992         mockNameValues.put(Data.MIMETYPE, Event.CONTENT_ITEM_TYPE);
    993         // No year format is not supported by Exchange.
    994         mockNameValues.put(Event.START_DATE, "--06-01");
    995         mockNameValues.put(Event.TYPE, Event.TYPE_BIRTHDAY);
    996         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
    997         mockNameValues = new ContentValues();
    998         mockNameValues.put(Data.MIMETYPE, Event.CONTENT_ITEM_TYPE);
    999         mockNameValues.put(Event.START_DATE, "1980-08-02");
   1000         // Anniversary is not supported by Exchange
   1001         mockNameValues.put(Event.TYPE, Event.TYPE_ANNIVERSARY);
   1002         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
   1003 
   1004         RawContactDelta newState = new RawContactDelta();
   1005         RawContactModifier.migrateEvent(oldState, newState, kind, 1990);
   1006 
   1007         List<ValuesDelta> list = newState.getMimeEntries(Event.CONTENT_ITEM_TYPE);
   1008         assertNotNull(list);
   1009         assertEquals(1, list.size());  // Anniversary should be dropped.
   1010         ContentValues outputValues = list.get(0).getAfter();
   1011 
   1012         // Default year should be used.
   1013         assertEquals("1990-06-01", outputValues.getAsString(Event.START_DATE));
   1014         assertEquals(Event.TYPE_BIRTHDAY, outputValues.getAsInteger(Event.TYPE).intValue());
   1015     }
   1016 
   1017     public void testMigrateEmailFromGoogleToExchange() {
   1018         AccountType oldAccountType = new GoogleAccountType(getContext(), "");
   1019         AccountType newAccountType = new ExchangeAccountType(getContext(), "", EXCHANGE_ACCT_TYPE);
   1020         DataKind kind = newAccountType.getKindForMimetype(Email.CONTENT_ITEM_TYPE);
   1021 
   1022         RawContactDelta oldState = new RawContactDelta();
   1023         ContentValues mockNameValues = new ContentValues();
   1024         mockNameValues.put(Data.MIMETYPE, Email.CONTENT_ITEM_TYPE);
   1025         mockNameValues.put(Email.TYPE, Email.TYPE_CUSTOM);
   1026         mockNameValues.put(Email.LABEL, "custom_type");
   1027         mockNameValues.put(Email.ADDRESS, "address1");
   1028         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
   1029         mockNameValues = new ContentValues();
   1030         mockNameValues.put(Data.MIMETYPE, Email.CONTENT_ITEM_TYPE);
   1031         mockNameValues.put(Email.TYPE, Email.TYPE_HOME);
   1032         mockNameValues.put(Email.ADDRESS, "address2");
   1033         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
   1034         mockNameValues = new ContentValues();
   1035         mockNameValues.put(Data.MIMETYPE, Email.CONTENT_ITEM_TYPE);
   1036         mockNameValues.put(Email.TYPE, Email.TYPE_WORK);
   1037         mockNameValues.put(Email.ADDRESS, "address3");
   1038         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
   1039         // Exchange can have up to 3 email entries. This 4th entry should be dropped.
   1040         mockNameValues = new ContentValues();
   1041         mockNameValues.put(Data.MIMETYPE, Email.CONTENT_ITEM_TYPE);
   1042         mockNameValues.put(Email.TYPE, Email.TYPE_OTHER);
   1043         mockNameValues.put(Email.ADDRESS, "address4");
   1044         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
   1045 
   1046         RawContactDelta newState = new RawContactDelta();
   1047         RawContactModifier.migrateGenericWithTypeColumn(oldState, newState, kind);
   1048 
   1049         List<ValuesDelta> list = newState.getMimeEntries(Email.CONTENT_ITEM_TYPE);
   1050         assertNotNull(list);
   1051         assertEquals(3, list.size());
   1052 
   1053         ContentValues outputValues = list.get(0).getAfter();
   1054         assertEquals(Email.TYPE_CUSTOM, outputValues.getAsInteger(Email.TYPE).intValue());
   1055         assertEquals("custom_type", outputValues.getAsString(Email.LABEL));
   1056         assertEquals("address1", outputValues.getAsString(Email.ADDRESS));
   1057 
   1058         outputValues = list.get(1).getAfter();
   1059         assertEquals(Email.TYPE_HOME, outputValues.getAsInteger(Email.TYPE).intValue());
   1060         assertEquals("address2", outputValues.getAsString(Email.ADDRESS));
   1061 
   1062         outputValues = list.get(2).getAfter();
   1063         assertEquals(Email.TYPE_WORK, outputValues.getAsInteger(Email.TYPE).intValue());
   1064         assertEquals("address3", outputValues.getAsString(Email.ADDRESS));
   1065     }
   1066 
   1067     public void testMigrateImFromGoogleToExchange() {
   1068         AccountType oldAccountType = new GoogleAccountType(getContext(), "");
   1069         AccountType newAccountType = new ExchangeAccountType(getContext(), "", EXCHANGE_ACCT_TYPE);
   1070         DataKind kind = newAccountType.getKindForMimetype(Im.CONTENT_ITEM_TYPE);
   1071 
   1072         RawContactDelta oldState = new RawContactDelta();
   1073         ContentValues mockNameValues = new ContentValues();
   1074         mockNameValues.put(Data.MIMETYPE, Im.CONTENT_ITEM_TYPE);
   1075         // Exchange doesn't support TYPE_HOME
   1076         mockNameValues.put(Im.TYPE, Im.TYPE_HOME);
   1077         mockNameValues.put(Im.PROTOCOL, Im.PROTOCOL_JABBER);
   1078         mockNameValues.put(Im.DATA, "im1");
   1079         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
   1080 
   1081         mockNameValues = new ContentValues();
   1082         mockNameValues.put(Data.MIMETYPE, Im.CONTENT_ITEM_TYPE);
   1083         // Exchange doesn't support TYPE_WORK
   1084         mockNameValues.put(Im.TYPE, Im.TYPE_WORK);
   1085         mockNameValues.put(Im.PROTOCOL, Im.PROTOCOL_YAHOO);
   1086         mockNameValues.put(Im.DATA, "im2");
   1087         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
   1088 
   1089         mockNameValues = new ContentValues();
   1090         mockNameValues.put(Data.MIMETYPE, Im.CONTENT_ITEM_TYPE);
   1091         mockNameValues.put(Im.TYPE, Im.TYPE_OTHER);
   1092         mockNameValues.put(Im.PROTOCOL, Im.PROTOCOL_CUSTOM);
   1093         mockNameValues.put(Im.CUSTOM_PROTOCOL, "custom_protocol");
   1094         mockNameValues.put(Im.DATA, "im3");
   1095         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
   1096 
   1097         // Exchange can have up to 3 IM entries. This 4th entry should be dropped.
   1098         mockNameValues = new ContentValues();
   1099         mockNameValues.put(Data.MIMETYPE, Im.CONTENT_ITEM_TYPE);
   1100         mockNameValues.put(Im.TYPE, Im.TYPE_OTHER);
   1101         mockNameValues.put(Im.PROTOCOL, Im.PROTOCOL_GOOGLE_TALK);
   1102         mockNameValues.put(Im.DATA, "im4");
   1103         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
   1104 
   1105         RawContactDelta newState = new RawContactDelta();
   1106         RawContactModifier.migrateGenericWithTypeColumn(oldState, newState, kind);
   1107 
   1108         List<ValuesDelta> list = newState.getMimeEntries(Im.CONTENT_ITEM_TYPE);
   1109         assertNotNull(list);
   1110         assertEquals(3, list.size());
   1111 
   1112         assertNotNull(kind.defaultValues.getAsInteger(Im.TYPE));
   1113 
   1114         int defaultType = kind.defaultValues.getAsInteger(Im.TYPE);
   1115 
   1116         ContentValues outputValues = list.get(0).getAfter();
   1117         // HOME should become default type.
   1118         assertEquals(defaultType, outputValues.getAsInteger(Im.TYPE).intValue());
   1119         assertEquals(Im.PROTOCOL_JABBER, outputValues.getAsInteger(Im.PROTOCOL).intValue());
   1120         assertEquals("im1", outputValues.getAsString(Im.DATA));
   1121 
   1122         outputValues = list.get(1).getAfter();
   1123         assertEquals(defaultType, outputValues.getAsInteger(Im.TYPE).intValue());
   1124         assertEquals(Im.PROTOCOL_YAHOO, outputValues.getAsInteger(Im.PROTOCOL).intValue());
   1125         assertEquals("im2", outputValues.getAsString(Im.DATA));
   1126 
   1127         outputValues = list.get(2).getAfter();
   1128         assertEquals(defaultType, outputValues.getAsInteger(Im.TYPE).intValue());
   1129         assertEquals(Im.PROTOCOL_CUSTOM, outputValues.getAsInteger(Im.PROTOCOL).intValue());
   1130         assertEquals("custom_protocol", outputValues.getAsString(Im.CUSTOM_PROTOCOL));
   1131         assertEquals("im3", outputValues.getAsString(Im.DATA));
   1132     }
   1133 
   1134     public void testMigratePhoneFromGoogleToExchange() {
   1135         AccountType oldAccountType = new GoogleAccountType(getContext(), "");
   1136         AccountType newAccountType = new ExchangeAccountType(getContext(), "", EXCHANGE_ACCT_TYPE);
   1137         DataKind kind = newAccountType.getKindForMimetype(Phone.CONTENT_ITEM_TYPE);
   1138 
   1139         // Create 5 numbers.
   1140         // - "1" -- HOME
   1141         // - "2" -- WORK
   1142         // - "3" -- CUSTOM
   1143         // - "4" -- WORK
   1144         // - "5" -- WORK_MOBILE
   1145         // Then we convert it to Exchange account type.
   1146         // - "1" -- HOME
   1147         // - "2" -- WORK
   1148         // - "3" -- Because CUSTOM is not supported, it'll be changed to the default, MOBILE
   1149         // - "4" -- WORK
   1150         // - "5" -- WORK_MOBILE not suppoted again, so will be MOBILE.
   1151         // But then, Exchange doesn't support multiple MOBILE numbers, so "5" will be removed.
   1152         // i.e. the result will be:
   1153         // - "1" -- HOME
   1154         // - "2" -- WORK
   1155         // - "3" -- MOBILE
   1156         // - "4" -- WORK
   1157 
   1158         RawContactDelta oldState = new RawContactDelta();
   1159         ContentValues mockNameValues = new ContentValues();
   1160         mockNameValues.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);
   1161         mockNameValues.put(Phone.TYPE, Phone.TYPE_HOME);
   1162         mockNameValues.put(Phone.NUMBER, "1");
   1163         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
   1164         mockNameValues = new ContentValues();
   1165         mockNameValues.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);
   1166         mockNameValues.put(Phone.TYPE, Phone.TYPE_WORK);
   1167         mockNameValues.put(Phone.NUMBER, "2");
   1168         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
   1169         mockNameValues = new ContentValues();
   1170         mockNameValues.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);
   1171         // Exchange doesn't support this type. Default to MOBILE
   1172         mockNameValues.put(Phone.TYPE, Phone.TYPE_CUSTOM);
   1173         mockNameValues.put(Phone.LABEL, "custom_type");
   1174         mockNameValues.put(Phone.NUMBER, "3");
   1175         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
   1176         mockNameValues = new ContentValues();
   1177         mockNameValues.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);
   1178         mockNameValues.put(Phone.TYPE, Phone.TYPE_WORK);
   1179         mockNameValues.put(Phone.NUMBER, "4");
   1180         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
   1181         mockNameValues = new ContentValues();
   1182 
   1183         mockNameValues.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);
   1184         mockNameValues.put(Phone.TYPE, Phone.TYPE_WORK_MOBILE);
   1185         mockNameValues.put(Phone.NUMBER, "5");
   1186         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
   1187 
   1188         RawContactDelta newState = new RawContactDelta();
   1189         RawContactModifier.migrateGenericWithTypeColumn(oldState, newState, kind);
   1190 
   1191         List<ValuesDelta> list = newState.getMimeEntries(Phone.CONTENT_ITEM_TYPE);
   1192         assertNotNull(list);
   1193         assertEquals(4, list.size());
   1194 
   1195         int defaultType = Phone.TYPE_MOBILE;
   1196 
   1197         ContentValues outputValues = list.get(0).getAfter();
   1198         assertEquals(Phone.TYPE_HOME, outputValues.getAsInteger(Phone.TYPE).intValue());
   1199         assertEquals("1", outputValues.getAsString(Phone.NUMBER));
   1200         outputValues = list.get(1).getAfter();
   1201         assertEquals(Phone.TYPE_WORK, outputValues.getAsInteger(Phone.TYPE).intValue());
   1202         assertEquals("2", outputValues.getAsString(Phone.NUMBER));
   1203         outputValues = list.get(2).getAfter();
   1204         assertEquals(defaultType, outputValues.getAsInteger(Phone.TYPE).intValue());
   1205         assertNull(outputValues.getAsInteger(Phone.LABEL));
   1206         assertEquals("3", outputValues.getAsString(Phone.NUMBER));
   1207         outputValues = list.get(3).getAfter();
   1208         assertEquals(Phone.TYPE_WORK, outputValues.getAsInteger(Phone.TYPE).intValue());
   1209         assertEquals("4", outputValues.getAsString(Phone.NUMBER));
   1210     }
   1211 
   1212     public void testMigrateOrganizationFromGoogleToExchange() {
   1213         AccountType oldAccountType = new GoogleAccountType(getContext(), "");
   1214         AccountType newAccountType = new ExchangeAccountType(getContext(), "", EXCHANGE_ACCT_TYPE);
   1215         DataKind kind = newAccountType.getKindForMimetype(Organization.CONTENT_ITEM_TYPE);
   1216 
   1217         RawContactDelta oldState = new RawContactDelta();
   1218         ContentValues mockNameValues = new ContentValues();
   1219         mockNameValues.put(Data.MIMETYPE, Organization.CONTENT_ITEM_TYPE);
   1220         mockNameValues.put(Organization.COMPANY, "company1");
   1221         mockNameValues.put(Organization.DEPARTMENT, "department1");
   1222         oldState.addEntry(ValuesDelta.fromAfter(mockNameValues));
   1223 
   1224         RawContactDelta newState = new RawContactDelta();
   1225         RawContactModifier.migrateGenericWithoutTypeColumn(oldState, newState, kind);
   1226 
   1227         List<ValuesDelta> list = newState.getMimeEntries(Organization.CONTENT_ITEM_TYPE);
   1228         assertNotNull(list);
   1229         assertEquals(1, list.size());
   1230 
   1231         ContentValues outputValues = list.get(0).getAfter();
   1232         assertEquals("company1", outputValues.getAsString(Organization.COMPANY));
   1233         assertEquals("department1", outputValues.getAsString(Organization.DEPARTMENT));
   1234     }
   1235 }
   1236