Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2014 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 | package com.android.contacts.common.model.dataitem; |
| 17 | |
| 18 | import android.content.ContentValues; |
Paul Soulos | a69518c | 2014-07-28 14:12:23 -0700 | [diff] [blame] | 19 | import android.provider.ContactsContract.CommonDataKinds.Email; |
| 20 | import android.provider.ContactsContract.CommonDataKinds.Event; |
| 21 | import android.provider.ContactsContract.CommonDataKinds.Im; |
| 22 | import android.provider.ContactsContract.CommonDataKinds.Nickname; |
| 23 | import android.provider.ContactsContract.CommonDataKinds.Note; |
| 24 | import android.provider.ContactsContract.CommonDataKinds.Organization; |
| 25 | import android.provider.ContactsContract.CommonDataKinds.Phone; |
| 26 | import android.provider.ContactsContract.CommonDataKinds.Relation; |
| 27 | import android.provider.ContactsContract.CommonDataKinds.SipAddress; |
| 28 | import android.provider.ContactsContract.CommonDataKinds.StructuredName; |
| 29 | import android.provider.ContactsContract.CommonDataKinds.StructuredPostal; |
| 30 | import android.provider.ContactsContract.CommonDataKinds.Website; |
Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 31 | import android.provider.ContactsContract.Contacts.Data; |
Paul Soulos | a69518c | 2014-07-28 14:12:23 -0700 | [diff] [blame] | 32 | import android.provider.ContactsContract.Contacts.Entity; |
Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 33 | import android.test.AndroidTestCase; |
Walter Jang | 7e79b52 | 2016-08-23 09:33:41 -0700 | [diff] [blame] | 34 | import android.test.suitebuilder.annotation.SmallTest; |
Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 35 | |
| 36 | import com.android.contacts.common.Collapser; |
Paul Soulos | a69518c | 2014-07-28 14:12:23 -0700 | [diff] [blame] | 37 | import com.android.contacts.common.model.account.AccountType.EditType; |
Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 38 | import com.android.contacts.common.model.account.BaseAccountType; |
Paul Soulos | a69518c | 2014-07-28 14:12:23 -0700 | [diff] [blame] | 39 | import com.android.contacts.common.model.account.GoogleAccountType; |
Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 40 | import com.android.contacts.common.model.dataitem.DataItem; |
| 41 | import com.android.contacts.common.model.dataitem.DataKind; |
| 42 | |
Paul Soulos | a69518c | 2014-07-28 14:12:23 -0700 | [diff] [blame] | 43 | import java.lang.Math; |
Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 44 | import java.util.ArrayList; |
Paul Soulos | a69518c | 2014-07-28 14:12:23 -0700 | [diff] [blame] | 45 | import java.util.List; |
Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 46 | |
| 47 | /** |
| 48 | * Test case for {@link DataItem}. |
| 49 | */ |
Walter Jang | 7e79b52 | 2016-08-23 09:33:41 -0700 | [diff] [blame] | 50 | @SmallTest |
Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 51 | public class DataItemTests extends AndroidTestCase { |
| 52 | |
Paul Soulos | a69518c | 2014-07-28 14:12:23 -0700 | [diff] [blame] | 53 | private ContentValues mValues1; |
| 54 | private ContentValues mValues2; |
| 55 | private ContentValues mValues3; |
| 56 | private ContentValues mValues4; |
| 57 | private GoogleAccountType mGoogleAccountType; |
Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 58 | |
Paul Soulos | a69518c | 2014-07-28 14:12:23 -0700 | [diff] [blame] | 59 | @Override |
| 60 | protected void setUp() { |
| 61 | mValues1 = new ContentValues(); |
| 62 | mValues2 = new ContentValues(); |
| 63 | mValues3 = new ContentValues(); |
| 64 | mValues4 = new ContentValues(); |
Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 65 | |
Paul Soulos | a69518c | 2014-07-28 14:12:23 -0700 | [diff] [blame] | 66 | mValues1.put(Data._ID, 1); |
| 67 | mValues2.put(Data._ID, 2); |
| 68 | mValues3.put(Data._ID, 3); |
| 69 | mValues4.put(Data._ID, 4); |
Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 70 | |
Paul Soulos | a69518c | 2014-07-28 14:12:23 -0700 | [diff] [blame] | 71 | mGoogleAccountType = new GoogleAccountType(getContext(), "packageName"); |
| 72 | } |
Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 73 | |
Paul Soulos | a69518c | 2014-07-28 14:12:23 -0700 | [diff] [blame] | 74 | private List<DataItem> createDataItemsAndCollapse(DataKind kind, ContentValues... values) { |
| 75 | final List<DataItem> dataList = new ArrayList<>(values.length); |
| 76 | for (ContentValues value : values) { |
| 77 | final DataItem data = DataItem.createFrom(value); |
| 78 | data.setDataKind(kind); |
| 79 | dataList.add(data); |
| 80 | } |
Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 81 | Collapser.collapseList(dataList, getContext()); |
Paul Soulos | a69518c | 2014-07-28 14:12:23 -0700 | [diff] [blame] | 82 | return dataList; |
| 83 | } |
| 84 | |
| 85 | public void testDataItemCollapsing_genericDataItemFields() { |
| 86 | mValues1.put(Data.IS_SUPER_PRIMARY, 1); |
| 87 | mValues2.put(Data.IS_PRIMARY, 0); |
| 88 | |
| 89 | mValues1.put(Entity.TIMES_USED, 5); |
| 90 | mValues2.put(Entity.TIMES_USED, 4); |
| 91 | |
| 92 | mValues1.put(Entity.LAST_TIME_USED, 555); |
| 93 | mValues2.put(Entity.LAST_TIME_USED, 999); |
| 94 | |
| 95 | final DataKind kind = new DataKind("test.mimetype", 0, 0, false); |
| 96 | kind.actionBody = new BaseAccountType.SimpleInflater(0); |
| 97 | kind.typeList = new ArrayList<>(); |
| 98 | kind.typeList.add(new EditType(1, -1)); |
| 99 | kind.typeList.add(new EditType(2, -1)); |
| 100 | kind.typeColumn = Data.DATA2; |
| 101 | |
| 102 | mValues1.put(kind.typeColumn, 2); |
| 103 | mValues2.put(kind.typeColumn, 1); |
| 104 | |
| 105 | final List<DataItem> dataList = createDataItemsAndCollapse(kind, mValues1, mValues2); |
Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 106 | |
| 107 | assertEquals(1, dataList.size()); |
| 108 | assertEquals(true, dataList.get(0).isSuperPrimary()); |
| 109 | assertEquals(true, dataList.get(0).isPrimary()); |
Paul Soulos | a69518c | 2014-07-28 14:12:23 -0700 | [diff] [blame] | 110 | assertEquals(9, (int) dataList.get(0).getTimesUsed()); |
| 111 | assertEquals(999L, (long) dataList.get(0).getLastTimeUsed()); |
| 112 | assertEquals(1, dataList.get(0).getKindTypeColumn(kind)); |
| 113 | } |
| 114 | |
| 115 | public void testDataItemCollapsing_email() { |
| 116 | final String email1 = "email1@google.com"; |
| 117 | final String email2 = "email2@google.com"; |
| 118 | |
| 119 | mValues1.put(Data.MIMETYPE, Email.CONTENT_ITEM_TYPE); |
| 120 | mValues2.put(Data.MIMETYPE, Email.CONTENT_ITEM_TYPE); |
| 121 | mValues3.put(Data.MIMETYPE, Email.CONTENT_ITEM_TYPE); |
| 122 | |
| 123 | mValues1.put(Email.ADDRESS, email1); |
| 124 | mValues2.put(Email.ADDRESS, email1); |
| 125 | mValues3.put(Email.ADDRESS, email2); |
| 126 | |
| 127 | mValues1.put(Email.TYPE, Email.TYPE_MOBILE); |
| 128 | mValues2.put(Email.TYPE, Email.TYPE_HOME); |
| 129 | mValues3.put(Email.TYPE, Email.TYPE_WORK); |
| 130 | |
| 131 | final DataKind kind = mGoogleAccountType.getKindForMimetype(Email.CONTENT_ITEM_TYPE); |
| 132 | |
| 133 | final List<DataItem> dataList = |
| 134 | createDataItemsAndCollapse(kind, mValues1, mValues2, mValues3); |
| 135 | |
| 136 | assertEquals(2, dataList.size()); |
| 137 | assertEquals(email1, ((EmailDataItem) dataList.get(0)).getAddress()); |
| 138 | assertEquals(email2, ((EmailDataItem) dataList.get(1)).getAddress()); |
| 139 | assertEquals(Math.min(Email.TYPE_MOBILE, Email.TYPE_HOME), |
| 140 | ((EmailDataItem) dataList.get(0)).getKindTypeColumn(kind)); |
| 141 | } |
| 142 | |
| 143 | public void testDataItemCollapsing_event() { |
| 144 | final String date1 = "2014-01-01"; |
| 145 | final String date2 = "2014-02-02"; |
| 146 | final String customLabel1 = "custom label1"; |
| 147 | final String customLabel2 = "custom label2"; |
| 148 | |
| 149 | mValues1.put(Data.MIMETYPE, Event.CONTENT_ITEM_TYPE); |
| 150 | mValues2.put(Data.MIMETYPE, Event.CONTENT_ITEM_TYPE); |
| 151 | mValues3.put(Data.MIMETYPE, Event.CONTENT_ITEM_TYPE); |
| 152 | mValues4.put(Data.MIMETYPE, Event.CONTENT_ITEM_TYPE); |
| 153 | |
| 154 | mValues1.put(Event.START_DATE, date1); |
| 155 | mValues2.put(Event.START_DATE, date1); |
| 156 | mValues3.put(Event.START_DATE, date1); |
| 157 | mValues4.put(Event.START_DATE, date2); |
| 158 | |
| 159 | mValues1.put(Event.TYPE, Event.TYPE_CUSTOM); |
| 160 | mValues2.put(Event.TYPE, Event.TYPE_CUSTOM); |
| 161 | mValues3.put(Event.TYPE, Event.TYPE_CUSTOM); |
| 162 | mValues4.put(Event.TYPE, Event.TYPE_ANNIVERSARY); |
| 163 | |
| 164 | mValues1.put(Event.LABEL, customLabel1); |
| 165 | mValues2.put(Event.LABEL, customLabel1); |
| 166 | mValues3.put(Event.LABEL, customLabel2); |
| 167 | |
| 168 | final DataKind kind = mGoogleAccountType.getKindForMimetype(Event.CONTENT_ITEM_TYPE); |
| 169 | |
| 170 | final List<DataItem> dataList = |
| 171 | createDataItemsAndCollapse(kind, mValues1, mValues2, mValues3, mValues4); |
| 172 | |
| 173 | assertEquals(3, dataList.size()); |
| 174 | assertEquals(customLabel1, ((EventDataItem) dataList.get(0)).getLabel()); |
| 175 | assertEquals(customLabel2, ((EventDataItem) dataList.get(1)).getLabel()); |
| 176 | assertEquals(date2, ((EventDataItem) dataList.get(2)).getStartDate()); |
| 177 | } |
| 178 | |
| 179 | public void testDataItemCollapsing_im() { |
| 180 | final String address1 = "address 1"; |
| 181 | final String address2 = "address 2"; |
| 182 | final String customProtocol1 = "custom 1"; |
| 183 | final String customProtocol2 = "custom 2"; |
| 184 | |
| 185 | mValues1.put(Data.MIMETYPE, Im.CONTENT_ITEM_TYPE); |
| 186 | mValues2.put(Data.MIMETYPE, Im.CONTENT_ITEM_TYPE); |
| 187 | mValues3.put(Data.MIMETYPE, Im.CONTENT_ITEM_TYPE); |
| 188 | mValues4.put(Data.MIMETYPE, Im.CONTENT_ITEM_TYPE); |
| 189 | |
| 190 | mValues1.put(Im.DATA, address1); |
| 191 | mValues2.put(Im.DATA, address1); |
| 192 | mValues3.put(Im.DATA, address1); |
| 193 | mValues4.put(Im.DATA, address2); |
| 194 | |
| 195 | mValues1.put(Im.PROTOCOL, Im.PROTOCOL_CUSTOM); |
| 196 | mValues2.put(Im.PROTOCOL, Im.PROTOCOL_CUSTOM); |
| 197 | mValues3.put(Im.PROTOCOL, Im.PROTOCOL_CUSTOM); |
| 198 | mValues4.put(Im.PROTOCOL, Im.PROTOCOL_AIM); |
| 199 | |
| 200 | mValues1.put(Im.CUSTOM_PROTOCOL, customProtocol1); |
| 201 | mValues2.put(Im.CUSTOM_PROTOCOL, customProtocol1); |
| 202 | mValues3.put(Im.CUSTOM_PROTOCOL, customProtocol2); |
| 203 | |
| 204 | final DataKind kind = mGoogleAccountType.getKindForMimetype(Im.CONTENT_ITEM_TYPE); |
| 205 | |
| 206 | final List<DataItem> dataList = |
| 207 | createDataItemsAndCollapse(kind, mValues1, mValues2, mValues3, mValues4); |
| 208 | |
| 209 | assertEquals(3, dataList.size()); |
| 210 | assertEquals(address1, ((ImDataItem) dataList.get(0)).getData()); |
| 211 | assertEquals(address1, ((ImDataItem) dataList.get(1)).getData()); |
| 212 | assertEquals(address2, ((ImDataItem) dataList.get(2)).getData()); |
| 213 | |
| 214 | assertEquals(customProtocol1, ((ImDataItem) dataList.get(0)).getCustomProtocol()); |
| 215 | assertEquals(customProtocol2, ((ImDataItem) dataList.get(1)).getCustomProtocol()); |
| 216 | assertEquals(Im.PROTOCOL_AIM, (int) ((ImDataItem) dataList.get(2)).getProtocol()); |
| 217 | } |
| 218 | |
| 219 | public void testDataItemCollapsing_nickname() { |
| 220 | final String nickname1 = "nickname 1"; |
| 221 | final String nickname2 = "nickname 2"; |
| 222 | |
| 223 | mValues1.put(Data.MIMETYPE, Nickname.CONTENT_ITEM_TYPE); |
| 224 | mValues2.put(Data.MIMETYPE, Nickname.CONTENT_ITEM_TYPE); |
| 225 | mValues3.put(Data.MIMETYPE, Nickname.CONTENT_ITEM_TYPE); |
| 226 | |
| 227 | mValues1.put(Nickname.NAME, nickname1); |
| 228 | mValues2.put(Nickname.NAME, nickname1); |
| 229 | mValues3.put(Nickname.NAME, nickname2); |
| 230 | |
| 231 | final DataKind kind = mGoogleAccountType.getKindForMimetype(Nickname.CONTENT_ITEM_TYPE); |
| 232 | |
| 233 | final List<DataItem> dataList = |
| 234 | createDataItemsAndCollapse(kind, mValues1, mValues2, mValues3); |
| 235 | |
| 236 | assertEquals(2, dataList.size()); |
| 237 | assertEquals(nickname1, ((NicknameDataItem) dataList.get(0)).getName()); |
| 238 | assertEquals(nickname2, ((NicknameDataItem) dataList.get(1)).getName()); |
| 239 | } |
| 240 | |
| 241 | public void testDataItemCollapsing_note() { |
| 242 | final String note1 = "note 1"; |
| 243 | final String note2 = "note 2"; |
| 244 | |
| 245 | mValues1.put(Data.MIMETYPE, Note.CONTENT_ITEM_TYPE); |
| 246 | mValues2.put(Data.MIMETYPE, Note.CONTENT_ITEM_TYPE); |
| 247 | mValues3.put(Data.MIMETYPE, Note.CONTENT_ITEM_TYPE); |
| 248 | |
| 249 | mValues1.put(Note.NOTE, note1); |
| 250 | mValues2.put(Note.NOTE, note1); |
| 251 | mValues3.put(Note.NOTE, note2); |
| 252 | |
| 253 | DataKind kind = mGoogleAccountType.getKindForMimetype(Note.CONTENT_ITEM_TYPE); |
| 254 | |
| 255 | final List<DataItem> dataList = |
| 256 | createDataItemsAndCollapse(kind, mValues1, mValues2, mValues3); |
| 257 | |
| 258 | assertEquals(2, dataList.size()); |
| 259 | assertEquals(note1, ((NoteDataItem) dataList.get(0)).getNote()); |
| 260 | assertEquals(note2, ((NoteDataItem) dataList.get(1)).getNote()); |
| 261 | } |
| 262 | |
| 263 | public void testDataItemCollapsing_organization() { |
| 264 | final String company1 = "company1"; |
| 265 | final String company2 = "company2"; |
| 266 | final String title1 = "title1"; |
| 267 | final String title2 = "title2"; |
| 268 | |
| 269 | mValues1.put(Data.MIMETYPE, Organization.CONTENT_ITEM_TYPE); |
| 270 | mValues2.put(Data.MIMETYPE, Organization.CONTENT_ITEM_TYPE); |
| 271 | mValues3.put(Data.MIMETYPE, Organization.CONTENT_ITEM_TYPE); |
| 272 | mValues4.put(Data.MIMETYPE, Organization.CONTENT_ITEM_TYPE); |
| 273 | |
| 274 | mValues1.put(Organization.COMPANY, company1); |
| 275 | mValues2.put(Organization.COMPANY, company1); |
| 276 | mValues3.put(Organization.COMPANY, company1); |
| 277 | mValues4.put(Organization.COMPANY, company2); |
| 278 | |
| 279 | mValues1.put(Organization.TITLE, title1); |
| 280 | mValues2.put(Organization.TITLE, title1); |
| 281 | mValues3.put(Organization.TITLE, title2); |
| 282 | mValues4.put(Organization.TITLE, title1); |
| 283 | |
| 284 | final DataKind kind = |
| 285 | mGoogleAccountType.getKindForMimetype(Organization.CONTENT_ITEM_TYPE); |
| 286 | |
| 287 | final List<DataItem> dataList = |
| 288 | createDataItemsAndCollapse(kind, mValues1, mValues2, mValues3, mValues4); |
| 289 | |
| 290 | assertEquals(3, dataList.size()); |
| 291 | assertEquals(company1, ((OrganizationDataItem) dataList.get(0)).getCompany()); |
| 292 | assertEquals(company1, ((OrganizationDataItem) dataList.get(1)).getCompany()); |
| 293 | assertEquals(company2, ((OrganizationDataItem) dataList.get(2)).getCompany()); |
| 294 | |
| 295 | assertEquals(title1, ((OrganizationDataItem) dataList.get(0)).getTitle()); |
| 296 | assertEquals(title2, ((OrganizationDataItem) dataList.get(1)).getTitle()); |
| 297 | } |
| 298 | |
| 299 | public void testDataItemCollapsing_phone() { |
| 300 | final String phone1 = "111-111-1111"; |
| 301 | final String phone1a = "1111111111"; |
| 302 | final String phone2 = "222-222-2222"; |
| 303 | |
| 304 | mValues1.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE); |
| 305 | mValues2.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE); |
| 306 | mValues3.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE); |
| 307 | |
| 308 | mValues1.put(Phone.NUMBER, phone1); |
| 309 | mValues2.put(Phone.NUMBER, phone1a); |
| 310 | mValues3.put(Phone.NUMBER, phone2); |
| 311 | |
| 312 | mValues1.put(Phone.TYPE, Phone.TYPE_MOBILE); |
| 313 | mValues2.put(Phone.TYPE, Phone.TYPE_HOME); |
| 314 | mValues3.put(Phone.TYPE, Phone.TYPE_WORK); |
| 315 | |
| 316 | final DataKind kind = mGoogleAccountType.getKindForMimetype(Phone.CONTENT_ITEM_TYPE); |
| 317 | |
| 318 | final List<DataItem> dataList = |
| 319 | createDataItemsAndCollapse(kind, mValues1, mValues2, mValues3); |
| 320 | assertEquals(2, dataList.size()); |
| 321 | assertEquals(phone1, ((PhoneDataItem) dataList.get(0)).getNumber()); |
| 322 | assertEquals(phone2, ((PhoneDataItem) dataList.get(1)).getNumber()); |
| 323 | assertEquals(Phone.TYPE_MOBILE, |
| 324 | ((PhoneDataItem) dataList.get(0)).getKindTypeColumn(kind)); |
| 325 | } |
| 326 | |
| 327 | public void testDataItemCollapsing_relation() { |
| 328 | final String name1 = "name1"; |
| 329 | final String name2 = "name2"; |
| 330 | final String customRelation1 = "custom relation 1"; |
| 331 | final String customRelation2 = "custom relation 2"; |
| 332 | |
| 333 | mValues1.put(Data.MIMETYPE, Relation.CONTENT_ITEM_TYPE); |
| 334 | mValues2.put(Data.MIMETYPE, Relation.CONTENT_ITEM_TYPE); |
| 335 | mValues3.put(Data.MIMETYPE, Relation.CONTENT_ITEM_TYPE); |
| 336 | mValues4.put(Data.MIMETYPE, Relation.CONTENT_ITEM_TYPE); |
| 337 | |
| 338 | mValues1.put(Relation.NAME, name1); |
| 339 | mValues2.put(Relation.NAME, name1); |
| 340 | mValues3.put(Relation.NAME, name1); |
| 341 | mValues4.put(Relation.NAME, name2); |
| 342 | |
| 343 | mValues1.put(Relation.TYPE, Relation.TYPE_CUSTOM); |
| 344 | mValues2.put(Relation.TYPE, Relation.TYPE_CUSTOM); |
| 345 | mValues3.put(Relation.TYPE, Relation.TYPE_CUSTOM); |
| 346 | mValues4.put(Relation.TYPE, Relation.TYPE_BROTHER); |
| 347 | |
| 348 | mValues1.put(Relation.LABEL, customRelation1); |
| 349 | mValues2.put(Relation.LABEL, customRelation1); |
| 350 | mValues3.put(Relation.LABEL, customRelation2); |
| 351 | |
| 352 | final DataKind kind = mGoogleAccountType.getKindForMimetype(Relation.CONTENT_ITEM_TYPE); |
| 353 | |
| 354 | final List<DataItem> dataList = |
| 355 | createDataItemsAndCollapse(kind, mValues1, mValues2, mValues3, mValues4); |
| 356 | |
| 357 | assertEquals(3, dataList.size()); |
| 358 | assertEquals(name1, ((RelationDataItem) dataList.get(0)).getName()); |
| 359 | assertEquals(name2, ((RelationDataItem) dataList.get(2)).getName()); |
| 360 | |
| 361 | assertEquals(customRelation1, ((RelationDataItem) dataList.get(0)).getLabel()); |
| 362 | assertEquals(customRelation2, ((RelationDataItem) dataList.get(1)).getLabel()); |
| 363 | } |
| 364 | |
| 365 | public void testDataItemCollapsing_sip() { |
| 366 | final String sip1 = "sip 1"; |
| 367 | final String sip2 = "sip 2"; |
| 368 | |
| 369 | mValues1.put(Data.MIMETYPE, SipAddress.CONTENT_ITEM_TYPE); |
| 370 | mValues2.put(Data.MIMETYPE, SipAddress.CONTENT_ITEM_TYPE); |
| 371 | mValues3.put(Data.MIMETYPE, SipAddress.CONTENT_ITEM_TYPE); |
| 372 | |
| 373 | mValues1.put(SipAddress.SIP_ADDRESS, sip1); |
| 374 | mValues2.put(SipAddress.SIP_ADDRESS, sip1); |
| 375 | mValues3.put(SipAddress.SIP_ADDRESS, sip2); |
| 376 | |
| 377 | mValues1.put(SipAddress.TYPE, SipAddress.TYPE_WORK); |
| 378 | mValues2.put(SipAddress.TYPE, SipAddress.TYPE_HOME); |
| 379 | mValues3.put(SipAddress.TYPE, SipAddress.TYPE_WORK); |
| 380 | |
| 381 | final DataKind kind = mGoogleAccountType.getKindForMimetype(SipAddress.CONTENT_ITEM_TYPE); |
| 382 | |
| 383 | final List<DataItem> dataList = |
| 384 | createDataItemsAndCollapse(kind, mValues1, mValues2, mValues3); |
| 385 | |
| 386 | assertEquals(2, dataList.size()); |
| 387 | assertEquals(sip1, ((SipAddressDataItem) dataList.get(0)).getSipAddress()); |
| 388 | assertEquals(sip2, ((SipAddressDataItem) dataList.get(1)).getSipAddress()); |
| 389 | } |
| 390 | |
| 391 | public void testDataItemCollapsing_structuredName() { |
| 392 | final String displayName1 = "Display Name 1"; |
| 393 | final String displayName2 = "Display Name 2"; |
| 394 | |
| 395 | mValues1.put(Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE); |
| 396 | mValues2.put(Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE); |
| 397 | mValues3.put(Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE); |
| 398 | |
| 399 | mValues1.put(StructuredName.DISPLAY_NAME, displayName1); |
| 400 | mValues2.put(StructuredName.DISPLAY_NAME, displayName1); |
| 401 | mValues3.put(StructuredName.DISPLAY_NAME, displayName2); |
| 402 | |
| 403 | final DataKind kind = |
| 404 | mGoogleAccountType.getKindForMimetype(StructuredName.CONTENT_ITEM_TYPE); |
| 405 | |
| 406 | final List<DataItem> dataList = |
| 407 | createDataItemsAndCollapse(kind, mValues1, mValues2, mValues3); |
| 408 | |
| 409 | assertEquals(2, dataList.size()); |
| 410 | assertEquals(displayName1, ((StructuredNameDataItem) dataList.get(0)).getDisplayName()); |
| 411 | assertEquals(displayName2, ((StructuredNameDataItem) dataList.get(1)).getDisplayName()); |
| 412 | } |
| 413 | |
| 414 | public void testDataItemCollapsing_structuredPostal() { |
| 415 | final String formattedAddress1 = "Formatted Address 1"; |
| 416 | final String formattedAddress2 = "Formatted Address 2"; |
| 417 | |
| 418 | mValues1.put(Data.MIMETYPE, StructuredPostal.CONTENT_ITEM_TYPE); |
| 419 | mValues2.put(Data.MIMETYPE, StructuredPostal.CONTENT_ITEM_TYPE); |
| 420 | mValues3.put(Data.MIMETYPE, StructuredPostal.CONTENT_ITEM_TYPE); |
| 421 | |
| 422 | mValues1.put(StructuredPostal.FORMATTED_ADDRESS, formattedAddress1); |
| 423 | mValues2.put(StructuredPostal.FORMATTED_ADDRESS, formattedAddress1); |
| 424 | mValues3.put(StructuredPostal.FORMATTED_ADDRESS, formattedAddress2); |
| 425 | |
| 426 | final DataKind kind = |
| 427 | mGoogleAccountType.getKindForMimetype(StructuredPostal.CONTENT_ITEM_TYPE); |
| 428 | |
| 429 | final List<DataItem> dataList = |
| 430 | createDataItemsAndCollapse(kind, mValues1, mValues2, mValues3); |
| 431 | |
| 432 | assertEquals(2, dataList.size()); |
| 433 | assertEquals(formattedAddress1, |
| 434 | ((StructuredPostalDataItem) dataList.get(0)).getFormattedAddress()); |
| 435 | assertEquals(formattedAddress2, |
| 436 | ((StructuredPostalDataItem) dataList.get(1)).getFormattedAddress()); |
| 437 | } |
| 438 | |
| 439 | public void testDataItemCollapsing_website() { |
| 440 | final String url1 = "www.url1.com"; |
| 441 | final String url2 = "www.url2.com"; |
| 442 | |
| 443 | mValues1.put(Data.MIMETYPE, Website.CONTENT_ITEM_TYPE); |
| 444 | mValues2.put(Data.MIMETYPE, Website.CONTENT_ITEM_TYPE); |
| 445 | mValues3.put(Data.MIMETYPE, Website.CONTENT_ITEM_TYPE); |
| 446 | |
| 447 | mValues1.put(Website.URL, url1); |
| 448 | mValues2.put(Website.URL, url1); |
| 449 | mValues3.put(Website.URL, url2); |
| 450 | |
| 451 | final DataKind kind = mGoogleAccountType.getKindForMimetype(Website.CONTENT_ITEM_TYPE); |
| 452 | |
| 453 | final List<DataItem> dataList = |
| 454 | createDataItemsAndCollapse(kind, mValues1, mValues2, mValues3); |
| 455 | |
| 456 | assertEquals(2, dataList.size()); |
| 457 | assertEquals(url1, ((WebsiteDataItem) dataList.get(0)).getUrl()); |
| 458 | assertEquals(url2, ((WebsiteDataItem) dataList.get(1)).getUrl()); |
Paul Soulos | 856820d | 2014-07-18 14:41:34 -0700 | [diff] [blame] | 459 | } |
| 460 | } |