1/*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16import dataShare from '@ohos.data.dataShare';
17import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it} from 'deccjsunit/index'
18
19import common from './common.js';
20
21const URI_CONTACTS = "datashare:///com.ohos.contactsdataability";
22const contactUri = "datashare:///com.ohos.contactsdataability/contacts/contact";
23const rawContactUri = "datashare:///com.ohos.contactsdataability/contacts/raw_contact";
24const contactDataUri = "datashare:///com.ohos.contactsdataability/contacts/contact_data";
25const groupUri = "datashare:///com.ohos.contactsdataability/contacts/groups";
26const contactBlocklistUri = "datashare:///com.ohos.contactsdataability/contacts/contact_blocklist";
27const deletedRawContactUri = "datashare:///com.ohos.contactsdataability/contacts/deleted_raw_contact";
28const searchContactUri = "datashare:///com.ohos.contactsdataability/contacts/search_contact";
29const deletedUri = "datashare:///com.ohos.contactsdataability/contacts/deleted_raw_contact";
30const deleted_raw_contact_record = "datashare:///com.ohos.contactsdataability/contacts/deleted_raw_contact_record";
31
32describe('ContactsTest', function() {
33    console.info("-------ContactsTest is starting!--------");
34
35    var sleep_two = 2000;
36    var sleep_one = 1000;
37    var array_two = 2;
38    var array_three = 3;
39    var array_four = 4;
40
41    function sleep(numberMillis)
42    {
43        var now = new Date();
44        var exitTime = now.getTime() + numberMillis;
45        while (true) {
46            now = new Date();
47            if (now.getTime() > exitTime)
48                return;
49        }
50    }
51
52    async function contactsQuery(map, tag, uri)
53    {
54        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
55        console.info(tag + ': contactsQuery start ! dataShareHelper = ' + dataShareHelper);
56        var resultColumns = [];
57        let condition = new dataShare.DataSharePredicates();
58        condition.equalTo("id", map.get("id"));
59        try {
60            var resultSet = await dataShareHelper.query(uri, resultColumns, condition);
61            sleep(sleep_two);
62            if (resultSet.rowCount > 0) {
63                if (resultSet.goToFirstRow()) {
64                    do {
65                        for (var [key, value] of map) {
66                            let dbresult = resultSet.getString(resultSet.getColumnIndex(key));
67                            console.info(tag + ' :logMessage contactsQuery key = ' + key + ' dbresult :' + dbresult +
68                                         ' value : ' + value);
69                            expect(value == dbresult).assertEqual(true);
70                        }
71                    } while (resultSet.goToNextRow());
72                }
73            }
74            resultSet.close();
75        } catch (error) {
76            console.info(tag + "logMessage contactsQuery: error = " + error);
77        }
78    }
79
80    async function queryBatch(map, tag, size)
81    {
82        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
83        console.info(tag + ': queryBatch start ! dataShareHelper = ' + dataShareHelper);
84        var resultColumns = [];
85        let condition = new dataShare.DataSharePredicates();
86        condition.equalTo("raw_contact_id", map.get("raw_contact_id"));
87        try {
88            var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
89            sleep(sleep_one);
90            console.info(tag + ': queryBatch start ! resultSet.rowCount = ' + resultSet.rowCount);
91            expect(resultSet.rowCount == size).assertEqual(true);
92            resultSet.close();
93        } catch (error) {
94            console.info(tag + "logMessage resultSet.rowCount: error = " + error);
95        }
96    }
97
98    async function queryIdForDelete(map, tag, uri)
99    {
100        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
101        console.info(tag + ': queryIdForDelete start ! dataShareHelper = ' + dataShareHelper);
102        let resultColumns = common.getCallLogResultColumns();
103        let condition = new dataShare.DataSharePredicates();
104        condition.equalTo("id", map.get("id"));
105        try {
106            var resultSet = await dataShareHelper.query(uri, resultColumns, condition);
107            sleep(sleep_one);
108            expect(resultSet.goToFirstRow() == false).assertTrue();
109            console.info(tag + " :logMessage queryIdForDelete: goToFirstRow " + resultSet.goToFirstRow());
110            resultSet.close();
111        } catch (error) {
112            console.info(tag + " :logMessage queryIdForDelete: error = " + error);
113        }
114    }
115
116    async function deleteAll(uri, tag)
117    {
118        try {
119            let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
120            let condition = new dataShare.DataSharePredicates();
121            condition.greaterThan("id", "0");
122            var deleteCode = await dataShareHelper.delete(uri, condition);
123            console.info(tag + ': deleteAll deleteCode = ' + deleteCode);
124            expect(deleteCode == 0).assertTrue();
125        } catch (error) {
126            console.info(tag + ': deleteAll error = ' + error);
127        }
128    }
129
130    async function deleteRawContact(tag)
131    {
132        try {
133            let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
134            let condition = new dataShare.DataSharePredicates();
135            condition.greaterThan("id", "0");
136            condition.and();
137            condition.equalTo("is_deleted", "0");
138            var deleteCode = await dataShareHelper.delete(rawContactUri, condition);
139            console.info(tag + ': deleteRawContact deleteCode = ' + deleteCode);
140            expect(deleteCode == 0).assertTrue();
141            sleep(sleep_one);
142            var conditionAll = new dataShare.DataSharePredicates();
143            conditionAll.greaterThan("id", "0");
144            var code = await dataShareHelper.delete(deletedUri, conditionAll);
145            console.info(tag + ': Completely delete code = ' + code);
146            expect(code == 0).assertTrue();
147        } catch (error) {
148            console.info(tag + ': deleteRawContact error = ' + error);
149        }
150    }
151
152    async function insertData(rawContactId, type, value, position)
153    {
154        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
155        var contactDataValues1 =
156            {"raw_contact_id" : rawContactId, "content_type" : type, "detail_info" : value, "position" : position};
157        try {
158            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues1);
159            console.info("logMessage : contactDataId1 " + contactDataId1);
160            expect(contactDataId > 0).assertTrue();
161        } catch (error) {
162            console.info("logMessage : contact_data name insert error = " + error);
163        }
164        return contactDataId;
165    }
166
167    /**
168     * @tc.number  contact_insert_test_100
169     * @tc.name    Insert contact data
170     * @tc.desc    Function test
171     */
172    it("contact_insert_test_100", 0, async function(done) {
173        console.info("------logMessage contact_insert_test_100 is starting!-----");
174        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
175        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
176        try {
177            var rawContactId = await dataShareHelper.insert(rawContactUri, common.getProfileRawContact());
178            sleep(sleep_one);
179            console.info('logMessage contact_insert_test_100: rawContactId = ' + rawContactId);
180            expect(rawContactId > 0).assertTrue();
181            var map = common.getProfileRawContactMap();
182            map.set("id", rawContactId.toString());
183            await contactsQuery(map, "contact_insert_test_100", rawContactUri);
184            await deleteRawContact("contact_insert_test_100");
185            done();
186        } catch (error) {
187            console.info('logMessage contact_insert_test_100: insert error = ' + error);
188            done();
189        }
190    });
191
192    /**
193     * @tc.number  contact_insert_test_400
194     * @tc.name    Insert contact details (name, company, position, mobile phone number)
195     * @tc.desc    Function test
196     */
197    it("contact_insert_test_400", 0, async function(done) {
198        console.info("------logMessage contact_insert_test_400 is starting!-----");
199        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
200        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
201
202        var insertRawContactValues = {
203            "display_name" : "xiaocheng",
204        };
205        try {
206            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
207            console.info("logMessage contact_insert_test_400: rawContactId = " + rawContactId);
208            expect(rawContactId > 0).assertTrue();
209            await dataNameInsert(dataShareHelper, rawContactId);
210            await dataCompanyInsert(dataShareHelper, rawContactId);
211            await dataPhoneInsert(dataShareHelper, rawContactId);
212            await deleteRawContact("contact_insert_test_400");
213            await deleteAll(contactDataUri, "contact_insert_test_400");
214            done();
215        } catch (error) {
216            console.info("logMessage contact_insert_test_400: raw_contact insert error = " + error);
217            done();
218        }
219    });
220
221    async function dataNameInsert(dataShareHelper, rawContactId)
222    {
223        var contactDataValues1 = {
224            "raw_contact_id" : rawContactId,
225            "content_type" : "name",
226            "detail_info" : "xiaocheng"
227        };
228        try {
229            var contactDataId1 = await dataShareHelper.insert(contactDataUri, contactDataValues1);
230            console.info("logMessage contact_insert_test_400: contactDataId1 " + contactDataId1);
231            expect(contactDataId1 > 0).assertTrue();
232            var map = new Map();
233            map.set("id", contactDataId1.toString());
234            map.set("detail_info", "xiaocheng");
235            map.set("raw_contact_id", rawContactId.toString());
236            await contactsQuery(map, "contact_insert_test_400", contactDataUri);
237        } catch (error) {
238            console.info("logMessage contact_insert_test_400: contact_data name insert error = " + error);
239            done();
240        }
241    }
242
243    async function dataCompanyInsert(dataShareHelper, rawContactId)
244    {
245        var contactDataValues2 = {
246            "raw_contact_id" : rawContactId,
247            "content_type" : "organization",
248            "detail_info" : "TT",
249            "position" : "developer"
250        };
251        try {
252            var contactDataId2 = await dataShareHelper.insert(contactDataUri, contactDataValues2);
253            console.info("logMessage contact_insert_test_400: contactDataId2 " + contactDataId2);
254            expect(contactDataId2 > 0).assertTrue();
255            var map = new Map();
256            map.set("id", contactDataId2.toString());
257            map.set("detail_info", "TT");
258            map.set("position", "developer");
259            contactsQuery(map, "contact_insert_test_400", contactDataUri);
260        } catch (error) {
261            console.info("logMessage contact_insert_test_400: contact_data company insert error = " + error);
262            done();
263        }
264    }
265
266    async function dataPhoneInsert(dataShareHelper, rawContactId)
267    {
268        var contactDataValues3 = {
269            "raw_contact_id" : rawContactId,
270            "content_type" : "phone",
271            "detail_info" : "12345678"
272        };
273        try {
274            var contactDataId3 = await dataShareHelper.insert(contactDataUri, contactDataValues3);
275            sleep(sleep_one);
276            console.info("logMessage contact_insert_test_400: contactDataId3 " + contactDataId3);
277            expect(contactDataId3 > 0).assertTrue();
278            var map = new Map();
279            map.set("id", contactDataId3.toString());
280            map.set("detail_info", "12345678");
281            await contactsQuery(map, "contact_insert_test_400", contactDataUri);
282        } catch (error) {
283            console.info("logMessage contact_insert_test_400: contact_data phone insert error = " + error);
284            done();
285        }
286    }
287
288    /**
289     * @tc.number  contact_insert_test_500
290     * @tc.name    Insert contact details (nickname, email, home)
291     * @tc.desc    Function test
292     */
293    it("contact_insert_test_500", 0, async function(done) {
294        console.info("------logMessage contact_insert_test_500 is starting!-----");
295        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
296        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
297
298        var insertRawContactValues = {
299            "display_name" : "xiaocheng",
300        };
301        try {
302            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
303            console.info("logMessage contact_insert_test_500: rawContactId = " + rawContactId);
304            expect(rawContactId > 0).assertTrue();
305            await dataEmailInsert(dataShareHelper, rawContactId);
306            await dataNickNameInsert(dataShareHelper, rawContactId);
307            await dataPostalAddressInsert(dataShareHelper, rawContactId);
308            await deleteRawContact("contact_insert_test_500");
309            await deleteAll(contactDataUri, "contact_insert_test_500");
310            done();
311        } catch (error) {
312            console.info("logMessage contact_insert_test_500: raw_contact insert error = " + error);
313            done();
314        }
315    });
316
317    async function dataEmailInsert(dataShareHelper, rawContactId)
318    {
319        var contactDataValues1 = {
320            "raw_contact_id" : rawContactId,
321            "content_type" : "email",
322            "detail_info" : "166@163.com"
323        };
324        try {
325            var contactDataId1 = await dataShareHelper.insert(contactDataUri, contactDataValues1);
326            sleep(sleep_one);
327            console.info("logMessage contact_insert_test_500: contactDataId1 " + contactDataId1);
328            expect(contactDataId1 > 0).assertTrue();
329            var map = new Map();
330            map.set("id", contactDataId1.toString());
331            map.set("detail_info", "166@163.com");
332            await contactsQuery(map, "contact_insert_test_500_1", contactDataUri);
333        } catch (error) {
334            console.info("logMessage contact_insert_test_500: contact_data email insert error = " + error);
335        }
336    }
337
338    async function dataNickNameInsert(dataShareHelper, rawContactId)
339    {
340        var contactDataValues2 = {
341            "raw_contact_id" : rawContactId,
342            "content_type" : "nickname",
343            "detail_info" : "xiaocheng"
344        };
345        try {
346            var contactDataId2 = await dataShareHelper.insert(contactDataUri, contactDataValues2);
347            console.info("logMessage contact_insert_test_500: contactDataId2 " + contactDataId2);
348            expect(contactDataId2 > 0).assertTrue();
349            var map = new Map();
350            map.set("id", contactDataId2.toString());
351            map.set("detail_info", "xiaocheng");
352            await contactsQuery(map, "contact_insert_test_500_2", contactDataUri);
353        } catch (error) {
354            console.info("logMessage contact_insert_test_500: contact_data nickname insert error = " + error);
355        }
356    }
357
358    async function dataPostalAddressInsert(dataShareHelper, rawContactId)
359    {
360        var contactDataValues3 = {
361            "raw_contact_id" : rawContactId,
362            "content_type" : "postal_address",
363            "detail_info" : "NanJingSoftRoad"
364        };
365        try {
366            var contactDataId3 = await dataShareHelper.insert(contactDataUri, contactDataValues3);
367            console.info("logMessage contact_insert_test_500: contactDataId3 " + contactDataId3);
368            expect(contactDataId3 > 0).assertTrue();
369            var map = new Map();
370            map.set("id", contactDataId3.toString());
371            map.set("detail_info", "NanJingSoftRoad");
372            await contactsQuery(map, "contact_insert_test_500_3", contactDataUri);
373        } catch (error) {
374            console.info("logMessage contact_insert_test_500: contact_data postal_address insert error = " + error);
375        }
376    }
377
378    /**
379     * @tc.number  contact_insert_test_600
380     * @tc.name    Insert contact details (remarks, AIM, birthday)
381     * @tc.desc    Function test
382     */
383    it("contact_insert_test_600", 0, async function(done) {
384        console.info("------logMessage contact_insert_test_600 is starting!-----");
385        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
386        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
387
388        var insertRawContactValues = {
389            "display_name" : "xiaocheng",
390        };
391        try {
392            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues)
393            console.info("logMessage contact_insert_test_600: rawContactId = " + rawContactId);
394            expect(rawContactId > 0).assertTrue();
395            await dataNoteInsert(dataShareHelper, rawContactId);
396            await dataAimInsert(dataShareHelper, rawContactId);
397            await dataEventInsert(dataShareHelper, rawContactId);
398            await deleteRawContact("contact_insert_test_600");
399            await deleteAll(contactDataUri, "contact_insert_test_600");
400            done();
401        } catch (error) {
402            console.info("logMessage contact_insert_test_600: raw_contact insert error = " + error);
403            done();
404        }
405    });
406
407    async function dataNoteInsert(dataShareHelper, rawContactId)
408    {
409        var contactDataValues1 = {
410            "raw_contact_id" : rawContactId,
411            "content_type" : "note",
412            "detail_info" : "javaGangster"
413        };
414        try {
415            var contactDataId1 = await dataShareHelper.insert(contactDataUri, contactDataValues1);
416            console.info("logMessage contact_insert_test_600: contactDataId1 " + contactDataId1);
417            expect(contactDataId1 > 0).assertTrue();
418            var map = new Map();
419            map.set("id", contactDataId1.toString());
420            map.set("detail_info", "javaGangster");
421            await contactsQuery(map, "contact_insert_test_600_1", contactDataUri);
422        } catch (error) {
423            console.info("logMessage contact_insert_test_600: contact_data note insert error = " + error);
424            done();
425        }
426    }
427
428    async function dataAimInsert(dataShareHelper, rawContactId)
429    {
430        var contactDataValues2 = {"raw_contact_id" : rawContactId, "content_type" : "im", "detail_info" : "aaaaa"};
431        try {
432            var contactDataId2 = await dataShareHelper.insert(contactDataUri, contactDataValues2);
433            console.info("logMessage contact_insert_test_600: contactDataId2 " + contactDataId2);
434            expect(contactDataId2 > 0).assertTrue();
435            var map = new Map();
436            map.set("id", contactDataId1.toString());
437            map.set("detail_info", "aaaaa");
438            await contactsQuery(map, "contact_insert_test_600_2", contactDataUri);
439        } catch (error) {
440            console.info("logMessage contact_insert_test_600: contact_data aim insert error = " + error);
441        }
442    }
443
444    async function dataEventInsert(dataShareHelper, rawContactId)
445    {
446        var contactDataValues3 = {
447            "raw_contact_id" : rawContactId,
448            "content_type" : "contact_event",
449            "detail_info" : "19960229"
450        };
451        try {
452            var contactDataId3 = await dataShareHelper.insert(contactDataUri, contactDataValues3);
453            console.info("logMessage contact_insert_test_600: contactDataId3 " + contactDataId3);
454            expect(contactDataId3 > 0).assertTrue();
455            var map = new Map();
456            map.set("id", contactDataId1.toString());
457            map.set("detail_info", "19960229");
458            await contactsQuery(map, "contact_insert_test_600_3", contactDataUri);
459        } catch (error) {
460            console.info("logMessage contact_insert_test_600: contact_data event insert error = " + error);
461        }
462    }
463
464    /**
465     * @tc.number  contact_insert_test_700
466     * @tc.name    Insert contact details (URL, assistant, group)
467     * @tc.desc    Function test
468     */
469    it("contact_insert_test_700", 0, async function(done) {
470        console.info("------logMessage contact_insert_test_700 is starting!-----");
471        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
472        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
473
474        var insertRawContactValues = {
475            "display_name" : "xiaocheng",
476        };
477        try {
478            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
479            console.info("logMessage contact_insert_test_700: rawContactId = " + rawContactId);
480            expect(rawContactId > 0).assertTrue();
481            await dataWebsiteInsert(dataShareHelper, rawContactId);
482            await dataRelationInsert(dataShareHelper, rawContactId);
483            await dataWebsiteInsert(dataShareHelper, rawContactId);
484            await deleteRawContact("contact_insert_test_700");
485            await deleteAll(contactDataUri, "contact_insert_test_700");
486            done();
487        } catch (error) {
488            console.info("logMessage contact_insert_test_700: raw_contact insert error = " + error);
489            done();
490        }
491    });
492
493    async function dataWebsiteInsert(dataShareHelper, rawContactId)
494    {
495        var contactDataValues1 = {
496            "raw_contact_id" : rawContactId,
497            "content_type" : "website",
498            "detail_info" : "www.com"
499        };
500        try {
501            var contactDataId1 = await dataShareHelper.insert(contactDataUri, contactDataValues1);
502            sleep(sleep_one);
503            console.info("logMessage contact_insert_test_700: contactDataId1 " + contactDataId1);
504            expect(contactDataId1 > 0).assertTrue();
505            var map = new Map();
506            map.set("id", contactDataId1.toString());
507            map.set("detail_info", "www.com");
508            await contactsQuery(map, "contact_insert_test_700_1", contactDataUri);
509            await ContactDataRelationInsert();
510        } catch (error) {
511            console.info("logMessage contact_insert_test_700: contact_data website insert error = " + error);
512        }
513    }
514
515    async function dataRelationInsert(dataShareHelper, rawContactId)
516    {
517        var contactDataValues2 = {
518            "raw_contact_id" : rawContactId,
519            "content_type" : "relation",
520            "detail_info" : "Secretary"
521        };
522        try {
523            var contactDataId2 = await dataShareHelper.insert(contactDataUri, contactDataValues2);
524            sleep(sleep_one);
525            console.info("logMessage contact_insert_test_700: contactDataId2 " + contactDataId2);
526            expect(contactDataId2 > 0).assertTrue();
527            var map = new Map();
528            map.set("id", contactDataId2.toString());
529            map.set("detail_info", "Secretary");
530            await contactsQuery(map, "contact_insert_test_700_2", contactDataUri);
531            await ContactDataGroupInsert();
532        } catch (error) {
533            console.info("logMessage contact_insert_test_700: contact_data relation insert error = " + error);
534        }
535    }
536
537    async function dataGroupInsert(dataShareHelper, rawContactId)
538    {
539        var contactDataValues3 = {
540            "raw_contact_id" : rawContactId,
541            "content_type" : "group_membership",
542            "detail_info" : "1"
543        };
544        try {
545            var contactDataId3 = await dataShareHelper.insert(contactDataUri, contactDataValues3);
546            sleep(sleep_one);
547            console.info("logMessage contact_insert_test_700: contactDataId3 " + contactDataId3);
548            expect(contactDataId3 > 0).assertTrue();
549            var map = new Map();
550            map.set("id", contactDataId3.toString());
551            map.set("detail_info", "1");
552            await contactsQuery(map, "contact_insert_test_700_3", contactDataUri);
553            done();
554        } catch (error) {
555            console.info("logMessage contact_insert_test_700: contact_data group insert error = " + error);
556        }
557    }
558
559    /**
560     * @tc.number  contact_insert_test_800
561     * @tc.name    Insert contact details (phone ringtone)
562     * @tc.desc    Function test
563     */
564    it("contact_insert_test_800", 0, async function(done) {
565        console.info("------logMessage contact_insert_test_800 is starting!-----");
566        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
567        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
568
569        var insertRawContactValues = {
570            "display_name" : "xiaocheng",
571        };
572        try {
573            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
574            console.info("logMessage contact_insert_test_800: rawContactId = " + rawContactId);
575            expect(rawContactId > 0).assertTrue();
576            await dataMiscInsert(dataShareHelper, rawContactId);
577            await deleteRawContact("contact_insert_test_800");
578            await deleteAll(contactDataUri, "contact_insert_test_800");
579            done();
580        } catch (error) {
581            console.info("logMessage contact_insert_test_800: raw_contact insert error = " + error);
582            done();
583        }
584    });
585
586    async function dataMiscInsert(dataShareHelper, rawContactId)
587    {
588        var contactDataValues1 = {
589            "raw_contact_id" : rawContactId,
590            "content_type" : "contact_misc",
591            "detail_info" : "1234"
592        };
593        try {
594            var contactDataId1 = await dataShareHelper.insert(contactDataUri, contactDataValues1);
595            sleep(sleep_one);
596            console.info("logMessage contact_insert_test_800: contactDataId1 " + contactDataId1);
597            expect(contactDataId1 > 0).assertTrue();
598            var map = new Map();
599            map.set("id", contactDataId1.toString());
600            map.set("detail_info", "1234");
601            await contactsQuery(map, "contact_insert_test_800_1", contactDataUri);
602        } catch (error) {
603            console.info("logMessage contact_insert_test_800: contact_data misc insert error = " + error);
604        }
605    }
606
607    /**
608     * @tc.number  contact_update_test_900
609     * @tc.name    Update contact data
610     * @tc.desc    Function test
611     */
612    it("contact_update_test_900", 0, async function(done) {
613        console.info("------logMessage contact_update_test_900 is starting!-----");
614        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
615        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
616
617        var insertRawContactValues = {
618            "display_name" : "licheng",
619            "company" : "TT",
620            "position" : "developer",
621            "favorite" : 1,
622            "phonetic_name" : "licheng||lc"
623        };
624        try {
625            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
626            console.info("logMessage contact_update_test_900: rawContactId = " + rawContactId);
627            expect(rawContactId > 0).assertTrue();
628            await rawContactUpdate(dataShareHelper, rawContactId);
629            await deleteRawContact("contact_update_test_900");
630            await deleteAll(contactDataUri, "contact_update_test_900");
631            done();
632        } catch (error) {
633            console.info("logMessage contact_update_test_900: raw_contact insert error = " + error);
634            done();
635        }
636    });
637
638    async function rawContactUpdate(dataShareHelper, rawContactId)
639    {
640        var updateValues = {
641            "display_name" : "dacheng",
642            "company" : "oo",
643            "position" : "Testers",
644            "favorite" : 0,
645            "phonetic_name" : "dacheng||dc"
646        };
647        let condition = new dataShare.DataSharePredicates();
648        condition.equalTo("id", rawContactId.toString());
649        try {
650            var updateCode = await dataShareHelper.update(rawContactUri, updateValues, condition);
651            sleep(sleep_one);
652            console.info('logMessage contact_update_test_900: updateCode = ' + updateCode);
653            expect(updateCode == 0).assertTrue();
654            var map = new Map();
655            map.set("id", rawContactId.toString());
656            map.set("display_name", "dacheng");
657            map.set("company", "oo");
658            map.set("position", "Testers");
659            map.set("favorite", "0");
660            map.set("phonetic_name", "dacheng||dc");
661            await contactsQuery(map, "contact_update_test_900", rawContactUri);
662        } catch (error) {
663            console.info('logMessage contact_update_test_900: raw_contact update error = ' + error);
664        }
665    }
666
667    /**
668     * @tc.number  contact_update_test_1200
669     * @tc.name    Update contact details (name)
670     * @tc.desc    Function test
671     */
672    it("contact_update_test_1200", 0, async function(done) {
673        console.info("------logMessage contact_update_test_1200 is starting!-----");
674        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
675        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
676        var insertRawContactValues = {"display_name" : "xiaoyuan"};
677        try {
678            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
679            console.info("logMessage contact_update_test_1200: rawContactId = " + rawContactId);
680            expect(rawContactId > 0).assertTrue();
681            await beforedataNameInsert(dataShareHelper, rawContactId);
682            await dataNameUpdate(dataShareHelper, rawContactId);
683            await deleteRawContact("contact_update_test_1200");
684            await deleteAll(contactDataUri, "contact_update_test_1200");
685            done();
686        } catch (error) {
687            console.info('logMessage contact_update_test_1200: raw_contact insert error = ' + error);
688            done();
689        }
690    });
691
692    async function beforedataNameInsert(dataShareHelper, rawContactId)
693    {
694        var contactDataValues = {"raw_contact_id" : rawContactId, "content_type" : "name", "detail_info" : "xiaoyuan"};
695        try {
696            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
697            sleep(sleep_one);
698            console.info('logMessage contact_update_test_1200: contactDataId = ' + contactDataId);
699            expect(contactDataId > 0).assertTrue();
700        } catch (error) {
701            console.info('logMessage contact_update_test_1200: contact_data insert error = ' + error);
702        }
703    }
704
705    async function dataNameUpdate(dataShareHelper, rawContactId)
706    {
707        var updateValues = {"detail_info" : "dayuan"};
708        let condition = new dataShare.DataSharePredicates();
709        condition.equalTo("raw_contact_id", rawContactId.toString());
710        try {
711            var updateCode = await dataShareHelper.update(contactDataUri, updateValues, condition);
712            sleep(sleep_one);
713            console.info('logMessage contact_update_test_1200: updateCode = ' + updateCode);
714            expect(updateCode == 0).assertTrue();
715            var map = new Map();
716            map.set("id", rawContactId.toString());
717            map.set("display_name", "dayuan");
718            await contactsQuery(map, "contact_update_test_1200", rawContactUri);
719        } catch (error) {
720            console.info('logMessage contact_update_test_1200: contact_data update error = ' + error);
721        }
722    }
723
724    /**
725     * @tc.number  contact_update_test_1300
726     * @tc.name    Update contact details (company, position)
727     * @tc.desc    Function test
728     */
729    it("contact_update_test_1300", 0, async function(done) {
730        console.info("------logMessage contact_update_test_1300 is starting!-----");
731        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
732        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
733        var insertRawContactValues = {"display_name" : "xiaoyuan"};
734        try {
735            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
736            console.info("logMessage contact_update_test_1300: rawContactId = " + rawContactId);
737            expect(rawContactId > 0).assertTrue();
738            await beforedataCompanyInsert(dataShareHelper, rawContactId);
739            await dataCompanyUpdate(dataShareHelper, rawContactId);
740            await deleteRawContact("contact_update_test_1300");
741            await deleteAll(contactDataUri, "contact_update_test_1300");
742            done();
743        } catch (error) {
744            console.info('logMessage contact_update_test_1300: raw_contact insert error = ' + error);
745            done();
746        }
747    });
748
749    async function beforedataCompanyInsert(dataShareHelper, rawContactId)
750    {
751        var contactDataValues = {
752            "raw_contact_id" : rawContactId,
753            "content_type" : "organization",
754            "detail_info" : "TT",
755            "position" : "Testers",
756        };
757        try {
758            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
759            sleep(sleep_one);
760            console.info('logMessage contact_update_test_1300: contactDataId = ' + contactDataId);
761            expect(contactDataId > 0).assertTrue();
762        } catch (error) {
763            console.info('logMessage contact_update_test_1300: contact_data insert error = ' + error);
764        }
765    }
766
767    async function dataCompanyUpdate(dataShareHelper, rawContactId)
768    {
769        var updateValues = {"detail_info" : "OOOO", "position" : "developer"};
770        let condition = new dataShare.DataSharePredicates();
771        condition.equalTo("raw_contact_id", rawContactId.toString());
772        try {
773            var updateCode = await dataShareHelper.update(contactDataUri, updateValues, condition);
774            sleep(sleep_one);
775            console.info('logMessage contact_update_test_1300: updateCode = ' + updateCode);
776            expect(updateCode == 0).assertTrue();
777            var map = new Map();
778            map.set("id", rawContactId.toString());
779            map.set("company", "OOOO");
780            map.set("position", "developer");
781            await contactsQuery(map, "contact_update_test_1300", rawContactUri);
782        } catch (error) {
783            console.info('logMessage contact_update_test_1300: contact_data update error = ' + error);
784        }
785    }
786
787    /**
788     * @tc.number  contact_update_test_1400
789     * @tc.name    Update contact details (mobile phone number)
790     * @tc.desc    Function test
791     */
792    it("contact_update_test_1400", 0, async function(done) {
793        console.info("------logMessage contact_update_test_1400 is starting!-----");
794        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
795        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
796        var insertRawContactValues = {"display_name" : "xiaoyuan"};
797        try {
798            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
799            console.info("logMessage contact_update_test_1400: rawContactId = " + rawContactId);
800            expect(rawContactId > 0).assertTrue();
801            await beforeDataPhoneInsert(dataShareHelper, rawContactId);
802            await dataPhoneUpdate(dataShareHelper, rawContactId);
803            await deleteRawContact("contact_update_test_1400");
804            await deleteAll(contactDataUri, "contact_update_test_1400");
805            done();
806        } catch (error) {
807            console.info('logMessage contact_update_test_1400: raw_contact insert error = ' + error);
808            done();
809        }
810    });
811
812    async function beforeDataPhoneInsert(dataShareHelper, rawContactId)
813    {
814        var contactDataValues = {"raw_contact_id" : rawContactId, "content_type" : "phone", "detail_info" : "123456"};
815        try {
816            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
817            sleep(sleep_one);
818            console.info('logMessage contact_update_test_1400: contactDataId = ' + contactDataId);
819            expect(contactDataId > 0).assertTrue();
820        } catch (error) {
821            console.info('logMessage contact_update_test_1400: contact_data insert error = ' + error);
822        }
823    }
824
825    async function dataPhoneUpdate(dataShareHelper, rawContactId)
826    {
827        var updateValues = {"detail_info" : "99663355"};
828        let condition = new dataShare.DataSharePredicates();
829        condition.equalTo("raw_contact_id", rawContactId.toString());
830        try {
831            var updateCode = await dataShareHelper.update(contactDataUri, updateValues, condition);
832            sleep(sleep_one);
833            console.info('logMessage contact_update_test_1400: updateCode = ' + updateCode);
834            expect(updateCode == 0).assertTrue();
835            var map = new Map();
836            map.set("id", contactDataId.toString());
837            map.set("detail_info", "99663355");
838            await contactsQuery(map, "contact_update_test_1400", contactDataUri);
839        } catch (error) {
840            console.info('logMessage contact_update_test_1400: contact_data update error = ' + error);
841        }
842    }
843
844    /**
845     * @tc.number  contact_update_test_1500
846     * @tc.name    Update contact details (nickname)
847     * @tc.desc    Function test
848     */
849    it("contact_update_test_1500", 0, async function(done) {
850        console.info("------logMessage contact_update_test_1500 is starting!-----");
851        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
852        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
853
854        var insertRawContactValues = {"display_name" : "xiaoyuan"};
855        try {
856            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
857            console.info("logMessage contact_update_test_1500: rawContactId = " + rawContactId);
858            expect(rawContactId > 0).assertTrue();
859            await beforedataNickNameInsert(dataShareHelper, rawContactId);
860            await dataNickNameUpdate(dataShareHelper, rawContactId);
861            await deleteRawContact("contact_update_test_1500");
862            await deleteAll(contactDataUri, "contact_update_test_1500");
863            done();
864        } catch (error) {
865            console.info('logMessage contact_update_test_1500: raw_contact insert error = ' + error);
866            done();
867        }
868    });
869
870    async function beforedataNickNameInsert(dataShareHelper, rawContactId)
871    {
872        var contactDataValues = {
873            "raw_contact_id" : rawContactId,
874            "content_type" : "nickname",
875            "detail_info" : "xiaoyuan"
876        };
877        try {
878            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
879            sleep(sleep_one);
880            console.info('logMessage contact_update_test_1500: contactDataId = ' + contactDataId);
881            expect(contactDataId > 0).assertTrue();
882        } catch (error) {
883            console.info('logMessage contact_update_test_1500: contact_data insert error = ' + error);
884        }
885    }
886
887    async function dataNickNameUpdate(dataShareHelper, rawContactId)
888    {
889        var updateValues = {"detail_info" : "fengyuan"};
890        let condition = new dataShare.DataSharePredicates();
891        condition.equalTo("raw_contact_id", rawContactId.toString());
892        try {
893            var updateCode = await dataShareHelper.update(contactDataUri, updateValues, condition);
894            sleep(sleep_one);
895            console.info('logMessage contact_update_test_1500: updateCode = ' + updateCode);
896            expect(updateCode == 0).assertTrue();
897            var map = new Map();
898            map.set("id", contactDataId.toString());
899            map.set("detail_info", "fengyuan");
900            await contactsQuery(map, "contact_update_test_1500", contactDataUri);
901        } catch (error) {
902            console.info('logMessage contact_update_test_1500: contact_data update error = ' + error);
903        }
904    }
905
906    /**
907     * @tc.number  contact_update_test_1600
908     * @tc.name    Update contact details (email)
909     * @tc.desc    Function test
910     */
911    it("contact_update_test_1600", 0, async function(done) {
912        console.info("------logMessage contact_update_test_1600 is starting!-----");
913        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
914        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
915
916        var insertRawContactValues = {"display_name" : "xiaoyuan"};
917        try {
918            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
919            console.info("logMessage contact_update_test_1600: rawContactId = " + rawContactId);
920            expect(rawContactId > 0).assertTrue();
921            await beforeDataEmailInsert(dataShareHelper, rawContactId);
922            await dataEmailUpdate(dataShareHelper, rawContactId);
923            await deleteRawContact("contact_update_test_1600");
924            await deleteAll(contactDataUri, "contact_update_test_1600");
925            done();
926        } catch (error) {
927            console.info("logMessage contact_update_test_1600: raw_contact insert error = " + error);
928            done();
929        }
930    });
931
932    async function beforeDataEmailInsert(dataShareHelper, rawContactId)
933    {
934        var contactDataValues = {
935            "raw_contact_id" : rawContactId,
936            "content_type" : "email",
937            "detail_info" : "166@163.com"
938        };
939        try {
940            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
941            sleep(sleep_one);
942            console.info('logMessage contact_update_test_1600: contactDataId = ' + contactDataId);
943            expect(contactDataId > 0).assertTrue();
944        } catch (error) {
945            console.info('logMessage contact_update_test_1600: contact_data insert error = ' + error);
946        }
947    }
948
949    async function dataEmailUpdate(dataShareHelper, rawContactId)
950    {
951        var updateValues = {"detail_info" : "199@163.com"};
952        let condition = new dataShare.DataSharePredicates();
953        condition.equalTo("raw_contact_id", rawContactId.toString());
954        try {
955            var updateCode = await dataShareHelper.update(contactDataUri, updateValues, condition)
956            sleep(sleep_one);
957            console.info('logMessage contact_update_test_1600: updateCode = ' + updateCode);
958            expect(updateCode == 0).assertTrue();
959            var map = new Map();
960            map.set("id", contactDataId.toString());
961            map.set("detail_info", "199@163.com");
962            await contactsQuery(map, "contact_update_test_1600", contactDataUri);
963        } catch (error) {
964            console.info('logMessage contact_update_test_1600: update error = ' + error);
965        }
966    }
967
968    /**
969     * @tc.number  contact_update_test_1700
970     * @tc.name    Update Contact Details (Residential)
971     * @tc.desc    Function test
972     */
973    it("contact_update_test_1700", 0, async function(done) {
974        console.info("------logMessage contact_update_test_1700 is starting!-----");
975        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
976        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
977
978        var insertRawContactValues = {"display_name" : "xiaoyuan"};
979        try {
980            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
981            console.info("logMessage contact_update_test_1700: rawContactId = " + rawContactId);
982            expect(rawContactId > 0).assertTrue();
983            await beforeDataPostalInsert(dataShareHelper, rawContactId);
984            await dataPostalUpdate();
985            await deleteRawContact("contact_update_test_1700");
986            await deleteAll(contactDataUri, "contact_update_test_1700");
987            done();
988        } catch (error) {
989            console.info("logMessage contact_update_test_1700: raw_contact insert error = " + error);
990            done();
991        }
992    });
993
994    async function beforeDataPostalInsert(dataShareHelper, rawContactId)
995    {
996        var contactDataValues = {
997            "raw_contact_id" : rawContactId,
998            "content_type" : "postal_address",
999            "detail_info" : "NanJing"
1000        };
1001        try {
1002            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
1003            sleep(sleep_one);
1004            console.info('logMessage contact_update_test_1700: contactDataId = ' + contactDataId);
1005            expect(contactDataId > 0).assertTrue();
1006        } catch (error) {
1007            console.info("logMessage contact_update_test_1700: contact_data insert error = " + error);
1008        }
1009    }
1010
1011    async function dataPostalUpdate(dataShareHelper, rawContactId)
1012    {
1013        var updateValues = {"detail_info" : "BeiJing"};
1014        let condition = new dataShare.DataSharePredicates();
1015        condition.equalTo("raw_contact_id", rawContactId.toString());
1016        try {
1017            var updateCode = await dataShareHelper.update(contactDataUri, updateValues, condition);
1018            sleep(sleep_one);
1019            console.info('logMessage contact_update_test_1700: updateCode = ' + updateCode);
1020            expect(updateCode == 0).assertTrue();
1021            var map = new Map();
1022            map.set("id", contactDataId.toString());
1023            map.set("detail_info", "BeiJing");
1024            await contactsQuery(map, "contact_update_test_1700", contactDataUri);
1025        } catch (error) {
1026            console.info('logMessage contact_update_test_1700: update error = ' + error);
1027        }
1028    }
1029
1030    /**
1031     * @tc.number  contact_update_test_1800
1032     * @tc.name    Update contact details (remarks)
1033     * @tc.desc    Function test
1034     */
1035    it("contact_update_test_1800", 0, async function(done) {
1036        console.info("------logMessage contact_update_test_1800 is starting!-----");
1037        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1038        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1039
1040        var insertRawContactValues = {"display_name" : "xiaoyuan"};
1041        try {
1042            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
1043            console.info("logMessage contact_update_test_1800: rawContactId = " + rawContactId);
1044            expect(rawContactId > 0).assertTrue();
1045            await beforedataNoteInsert(dataShareHelper, rawContactId);
1046            await dataNoteUpdate(dataShareHelper, rawContactId);
1047            await deleteRawContact("contact_update_test_1800");
1048            await deleteAll(contactDataUri, "contact_update_test_1800");
1049            done();
1050        } catch (error) {
1051            console.info("logMessage contact_update_test_1800: raw_contact insert error = " + error);
1052            done();
1053        }
1054    });
1055
1056    async function beforedataNoteInsert(dataShareHelper, rawContactId)
1057    {
1058        var contactDataValues = {"raw_contact_id" : rawContactId, "content_type" : "note", "detail_info" : "Gangster"};
1059        try {
1060            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
1061            sleep(sleep_one);
1062            console.info('logMessage contact_update_test_1800: contactDataId = ' + contactDataId);
1063            expect(contactDataId > 0).assertTrue();
1064        } catch (error) {
1065            console.info('logMessage contact_update_test_1800: contact_data insert error = ' + error);
1066        }
1067    }
1068
1069    async function dataNoteUpdate(dataShareHelper, rawContactId)
1070    {
1071        var updateValues = {"detail_info" : "God"};
1072        let condition = new dataShare.DataSharePredicates();
1073        condition.equalTo("raw_contact_id", rawContactId.toString());
1074        try {
1075            var updateCode = await dataShareHelper.update(contactDataUri, updateValues, condition);
1076            sleep(sleep_one);
1077            console.info('logMessage contact_update_test_1800: updateCode = ' + updateCode);
1078            expect(updateCode == 0).assertTrue();
1079            var map = new Map();
1080            map.set("id", contactDataId.toString());
1081            map.set("detail_info", "God");
1082            await contactsQuery(map, "contact_update_test_1800", contactDataUri);
1083        } catch (error) {
1084            console.info('logMessage contact_update_test_1800: update error = ' + error);
1085        }
1086    }
1087
1088    /**
1089     * @tc.number  contact_update_test_1900
1090     * @tc.name    Update Contact Details (AIM)
1091     * @tc.desc    Function test
1092     */
1093    it("contact_update_test_1900", 0, async function(done) {
1094        console.info("------logMessage contact_update_test_1900 is starting!-----");
1095        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1096        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1097
1098        var insertRawContactValues = {"display_name" : "xiaoyuan"};
1099        try {
1100            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues)
1101            console.info("logMessage contact_update_test_1900: rawContactId = " + rawContactId);
1102            expect(rawContactId > 0).assertTrue();
1103            await beforeDataAimInsert(dataShareHelper, rawContactId);
1104            await dataAimUpdate(dataShareHelper, rawContactId);
1105            await deleteRawContact("contact_update_test_1900");
1106            await deleteAll(contactDataUri, "contact_update_test_1900");
1107            done();
1108        } catch (error) {
1109            console.info("logMessage contact_update_test_1900: raw_contact insert error = " + error);
1110            done();
1111        }
1112    });
1113
1114    async function beforeDataAimInsert(dataShareHelper, rawContactId)
1115    {
1116        var contactDataValues = {"raw_contact_id" : rawContactId, "content_type" : "im", "detail_info" : "aaaaa"};
1117        try {
1118            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
1119            sleep(sleep_one);
1120            console.info('logMessage contact_update_test_1900: contactDataId = ' + contactDataId);
1121            expect(contactDataId > 0).assertTrue();
1122        } catch (error) {
1123            console.info("logMessage contact_update_test_1900: contact_data insert error = " + error);
1124        }
1125    }
1126
1127    async function dataAimUpdate(dataShareHelper, rawContactId)
1128    {
1129        var updateValues = {"detail_info" : "bbbbb"};
1130        let condition = new dataShare.DataSharePredicates();
1131        condition.equalTo("raw_contact_id", rawContactId.toString());
1132        try {
1133            var updateCode = await dataShareHelper.update(contactDataUri, updateValues, condition);
1134            sleep(sleep_one);
1135            console.info('logMessage contact_update_test_1900: updateCode = ' + updateCode);
1136            expect(updateCode == 0).assertTrue();
1137            var map = new Map();
1138            map.set("id", contactDataId.toString());
1139            map.set("detail_info", "bbbbb");
1140            await contactsQuery(map, "contact_update_test_1900", contactDataUri);
1141        } catch (error) {
1142            console.info('logMessage contact_update_test_1900: update error = ' + error);
1143        }
1144    }
1145
1146    /**
1147     * @tc.number  contact_update_test_2000
1148     * @tc.name    Update Contact Details (Birthday)
1149     * @tc.desc    Function test
1150     */
1151    it("contact_update_test_2000", 0, async function(done) {
1152        console.info("------logMessage contact_update_test_2000 is starting!-----");
1153        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1154        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1155
1156        var insertRawContactValues = {"display_name" : "xiaoyuan"};
1157        try {
1158            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
1159            console.info("logMessage contact_update_test_2000: rawContactId = " + rawContactId);
1160            expect(rawContactId > 0).assertTrue();
1161            await beforeDataEventInsert(dataShareHelper, rawContactId);
1162            await dataEventUpdate(dataShareHelper, rawContactId);
1163            await deleteRawContact("contact_update_test_2000");
1164            await deleteAll(contactDataUri, "contact_update_test_2000");
1165            done();
1166        } catch (error) {
1167            console.info("logMessage contact_update_test_2000: raw_contact insert error = " + error);
1168            done();
1169        }
1170    });
1171
1172    async function beforeDataEventInsert(dataShareHelper, rawContactId)
1173    {
1174        var contactDataValues1 = {
1175            "raw_contact_id" : rawContactId,
1176            "content_type" : "contact_event",
1177            "detail_info" : "19960229"
1178        };
1179        try {
1180            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues1);
1181            sleep(sleep_one);
1182            console.info('logMessage contact_update_test_2000: contactDataId = ' + contactDataId);
1183            expect(contactDataId > 0).assertTrue();
1184        } catch (error) {
1185            console.info('logMessage contact_update_test_2000: contact_data insert error = ' + error);
1186        }
1187    }
1188
1189    async function dataEventUpdate(dataShareHelper, rawContactId)
1190    {
1191        var updateValues = {"detail_info" : "19971021"};
1192        let condition = new dataShare.DataSharePredicates();
1193        condition.equalTo("raw_contact_id", rawContactId.toString());
1194        try {
1195            var updateCode = await dataShareHelper.update(contactDataUri, updateValues, condition);
1196            sleep(sleep_one);
1197            console.info('logMessage contact_update_test_2000: updateCode = ' + updateCode);
1198            expect(updateCode == 0).assertTrue();
1199            var map = new Map();
1200            map.set("id", contactDataId.toString());
1201            map.set("detail_info", "19971021");
1202            await contactsQuery(map, "contact_update_test_2000", contactDataUri);
1203        } catch (error) {
1204            console.info('logMessage contact_update_test_2000: update error = ' + error);
1205        }
1206    }
1207
1208    /**
1209     * @tc.number  contact_update_test_2100
1210     * @tc.name    Update contact details (website)
1211     * @tc.desc    Function test
1212     */
1213    it("contact_update_test_2100", 0, async function(done) {
1214        console.info("------logMessage contact_update_test_2100 is starting!-----");
1215        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1216        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1217
1218        var insertRawContactValues = {"display_name" : "xiaoyuan"};
1219        try {
1220            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
1221            console.info("logMessage contact_update_test_2100: rawContactId = " + rawContactId);
1222            expect(rawContactId > 0).assertTrue();
1223            await beforeDataWebsiteInsert(dataShareHelper, rawContactId);
1224            await dataWebsiteUpdate(dataShareHelper, rawContactId);
1225            await deleteRawContact("contact_update_test_2100");
1226            await deleteAll(contactDataUri, "contact_update_test_2100");
1227            done();
1228        } catch (error) {
1229            console.info("logMessage contact_update_test_2100: raw_contact insert error = " + error);
1230            done();
1231        }
1232    });
1233
1234    async function beforeDataWebsiteInsert(dataShareHelper, rawContactId)
1235    {
1236        var contactDataValues1 = {
1237            "raw_contact_id" : rawContactId,
1238            "content_type" : "website",
1239            "detail_info" : "www.com"
1240        };
1241        try {
1242            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues1);
1243            sleep(sleep_one);
1244            console.info('logMessage contact_update_test_2100: contactDataId = ' + contactDataId);
1245            expect(contactDataId > 0).assertTrue();
1246        } catch (error) {
1247            console.info('logMessage contact_update_test_2100: contact_data insert error = ' + error);
1248        }
1249    }
1250
1251    async function dataWebsiteUpdate(dataShareHelper, rawContactId)
1252    {
1253        var updateValues = {"detail_info" : "www.123.com"};
1254        let condition = new dataShare.DataSharePredicates();
1255        condition.equalTo("raw_contact_id", rawContactId.toString());
1256        try {
1257            var updateCode = await dataShareHelper.update(contactDataUri, updateValues, condition);
1258            sleep(sleep_one);
1259            console.info('logMessage contact_update_test_2100: updateCode = ' + updateCode);
1260            expect(updateCode == 0).assertTrue();
1261            var map = new Map();
1262            map.set("id", contactDataId.toString());
1263            map.set("detail_info", "www.123.com");
1264            await contactsQuery(map, "contact_update_test_2100", contactDataUri);
1265        } catch (error) {
1266            console.info('logMessage contact_update_test_2100: update error = ' + error);
1267        }
1268    }
1269
1270    /**
1271     * @tc.number  contact_update_test_2200
1272     * @tc.name    Update contact details (assistant)
1273     * @tc.desc    Function test
1274     */
1275    it("contact_update_test_2200", 0, async function(done) {
1276        console.info("------logMessage contact_update_test_2200 is starting!-----");
1277        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1278        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1279
1280        var insertRawContactValues = {"display_name" : "xiaoyuan"};
1281        try {
1282            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
1283            console.info("logMessage contact_update_test_2200: rawContactId = " + rawContactId);
1284            expect(rawContactId > 0).assertTrue();
1285            await beforeDataRelationInsert(dataShareHelper, rawContactId);
1286            await dataRelationUpdate(dataShareHelper, rawContactId);
1287            await deleteRawContact("contact_update_test_2200");
1288            await deleteAll(contactDataUri, "contact_update_test_2200");
1289            done();
1290        } catch (error) {
1291            console.info("logMessage contact_update_test_2200: raw_contact insert error = " + error);
1292            done();
1293        }
1294    });
1295
1296    async function beforeDataRelationInsert(dataShareHelper, rawContactId)
1297    {
1298        var contactDataValues = {
1299            "raw_contact_id" : rawContactId,
1300            "content_type" : "relation",
1301            "detail_info" : "Secretary"
1302        };
1303        try {
1304            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
1305            console.info('logMessage contact_update_test_2200: contactDataId = ' + contactDataId);
1306            expect(contactDataId > 0).assertTrue();
1307        } catch (error) {
1308            console.info('logMessage contact_update_test_2200: contact_data insert error = ' + error);
1309        }
1310    }
1311
1312    async function dataRelationUpdate(dataShareHelper, rawContactId)
1313    {
1314        var updateValues = {"detail_info" : "spouse"};
1315        let condition = new dataShare.DataSharePredicates();
1316        condition.equalTo("raw_contact_id", rawContactId.toString());
1317        try {
1318            var updateCode = await dataShareHelper.update(contactDataUri, updateValues, condition);
1319            sleep(sleep_one);
1320            console.info('logMessage contact_update_test_2200: updateCode = ' + updateCode);
1321            expect(updateCode == 0).assertTrue();
1322            var map = new Map();
1323            map.set("id", contactDataId.toString());
1324            map.set("detail_info", "spouse");
1325            await contactsQuery(map, "contact_update_test_2200", contactDataUri);
1326        } catch (error) {
1327            console.info('logMessage contact_update_test_2200: update error = ' + error);
1328        }
1329    }
1330
1331    /**
1332     * @tc.number  contact_update_test_2300
1333     * @tc.name    Update contact detail data table (group)
1334     * @tc.desc    Function test
1335     */
1336    it("contact_update_test_2300", 0, async function(done) {
1337        console.info("------logMessage contact_update_test_2300 is starting!-----");
1338        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1339        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1340
1341        var insertRawContactValues = {"display_name" : "xiaoyuan"};
1342        try {
1343            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
1344            console.info("logMessage contact_update_test_2300: rawContactId = " + rawContactId);
1345            expect(rawContactId > 0).assertTrue();
1346            await beforeDataGroupInsert(dataShareHelper, rawContactId);
1347            await dataGroupUpdate(dataShareHelper, rawContactId);
1348            await deleteRawContact("contact_update_test_2300");
1349            await deleteAll(contactDataUri, "contact_update_test_2300");
1350            done();
1351        } catch (error) {
1352            console.info("logMessage contact_update_test_2300: raw_contact insert error = " + error);
1353            done();
1354        }
1355    });
1356
1357    async function beforeDataGroupInsert(dataShareHelper, rawContactId)
1358    {
1359        var contactDataValues = {
1360            "raw_contact_id" : rawContactId,
1361            "content_type" : "group_membership",
1362            "detail_info" : "2"
1363        };
1364        try {
1365            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
1366            sleep(sleep_one);
1367            console.info('logMessage contact_update_test_2300: contactDataId = ' + contactDataId);
1368            expect(contactDataId > 0).assertTrue();
1369        } catch (error) {
1370            console.info('logMessage contact_update_test_2300: contact_data insert error = ' + error);
1371        }
1372    }
1373
1374    async function dataGroupUpdate(dataShareHelper, rawContactId)
1375    {
1376        var updateValues = {"detail_info" : "7"};
1377        let condition = new dataShare.DataSharePredicates();
1378        condition.equalTo("raw_contact_id", rawContactId.toString());
1379        try {
1380            var updateCode = await dataShareHelper.update(contactDataUri, updateValues, condition);
1381            sleep(sleep_one);
1382            console.info('logMessage contact_update_test_2300: updateCode = ' + updateCode);
1383            expect(updateCode == 0).assertTrue();
1384            var map = new Map();
1385            map.set("id", contactDataId.toString());
1386            map.set("detail_info", "3");
1387            await contactsQuery(map, "contact_update_test_2300", contactDataUri);
1388        } catch (error) {
1389            console.info('logMessage contact_update_test_2300: update error = ' + error);
1390        }
1391    }
1392
1393    /**
1394     * @tc.number  contact_update_test_2400
1395     * @tc.name    Update contact detail data table (phone ringtone)
1396     * @tc.desc    Function test
1397     */
1398    it("contact_update_test_2400", 0, async function(done) {
1399        console.info("------logMessage contact_update_test_2400 is starting!-----");
1400        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1401        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1402
1403        var insertRawContactValues = {"display_name" : "xiaoyuan"};
1404        try {
1405            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
1406            sleep(sleep_one);
1407            console.info("logMessage contact_update_test_2400: rawContactId = " + rawContactId);
1408            expect(rawContactId > 0).assertTrue();
1409            await beforeDataMiscInsert(dataShareHelper, rawContactId);
1410            await dataMiscUpdate(dataShareHelper, rawContactId);
1411            await deleteRawContact("contact_update_test_2400");
1412            await deleteAll(contactDataUri, "contact_update_test_2400");
1413            done();
1414        } catch (error) {
1415            console.info("logMessage contact_update_test_2400: raw_contact insert error = " + error);
1416            done();
1417        }
1418    });
1419
1420    async function beforeDataMiscInsert(dataShareHelper, rawContactId)
1421    {
1422        var contactDataValues1 = {
1423            "raw_contact_id" : rawContactId,
1424            "content_type" : "contact_misc",
1425            "detail_info" : "1234"
1426        };
1427        try {
1428            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues1);
1429            sleep(sleep_one);
1430            console.info('logMessage contact_update_test_2400: contactDataId = ' + contactDataId);
1431            expect(contactDataId > 0).assertTrue();
1432        } catch (error) {
1433            console.info('logMessage contact_update_test_2400: contact_data insert error = ' + error);
1434        }
1435    }
1436
1437    async function dataMiscUpdate(dataShareHelper, rawContactId)
1438    {
1439        var updateValues = {"detail_info" : "999"};
1440        let condition = new dataShare.DataSharePredicates();
1441        condition.equalTo("raw_contact_id", rawContactId.toString());
1442        try {
1443            var updateCode = await dataShareHelper.update(contactDataUri, updateValues, condition);
1444            sleep(sleep_one);
1445            console.info('logMessage contact_update_test_2400: updateCode = ' + updateCode);
1446            expect(updateCode == 0).assertTrue();
1447            var map = new Map();
1448            map.set("id", contactDataId.toString());
1449            map.set("detail_info", "999");
1450            await contactsQuery(map, "contact_update_test_2400", contactDataUri);
1451        } catch (error) {
1452            console.info('logMessage contact_update_test_2400: update error = ' + error);
1453        }
1454    }
1455
1456    /**
1457     * @tc.number  contact_favorite_test_2500
1458     * @tc.name    Favorite contacts
1459     * @tc.desc    Function test
1460     */
1461    it("contact_favorite_test_2500", 0, async function(done) {
1462        console.info("-------logMessage contact_favorite_test_2500 is starting!------");
1463        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1464        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1465
1466        var rawContactValues = {"display_name" : "xiaocai", "company" : "TT", "position" : "Testers"};
1467        try {
1468            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues)
1469            console.info('logMessage contact_favorite_test_2500: rawContactId = ' + rawContactId);
1470            expect(rawContactId > 0).assertTrue();
1471            await updateFavorite(dataShareHelper, rawContactId);
1472            await deleteRawContact("contact_favorite_test_2500");
1473            done();
1474        } catch (error) {
1475            console.info('logMessage contact_favorite_test_2500: raw_contact insert error = ' + error);
1476            done();
1477        }
1478    });
1479
1480    async function updateFavorite(dataShareHelper, rawContactId)
1481    {
1482        var updateValues = {"favorite" : 1};
1483        let condition = new dataShare.DataSharePredicates();
1484        condition.equalTo("id", rawContactId.toString());
1485        try {
1486            var updateCode = await dataShareHelper.update(rawContactUri, updateValues, condition);
1487            sleep(sleep_one);
1488            console.info("logMessage contact_favorite_test_2500: updateCode = " + updateCode);
1489            expect(updateCode == 0).assertTrue();
1490            var map = new Map();
1491            map.set("id", rawContactId.toString());
1492            map.set("display_name", "xiaocai");
1493            map.set("company", "TT");
1494            map.set("position", "Testers");
1495            map.set("favorite", "1");
1496            await contactsQuery(map, "contact_favorite_test_2500", rawContactUri);
1497        } catch (error) {
1498            console.info('logMessage contact_favorite_test_2500: update error = ' + error);
1499        }
1500    }
1501
1502    /**
1503     * @tc.number  contact_unfavorite_test_2600
1504     * @tc.name    Unfavorite contacts
1505     * @tc.desc    Function test
1506     */
1507    it("contact_unfavorite_test_2600", 0, async function(done) {
1508        console.info("-------logMessage contact_unfavorite_test_2600 is starting!------");
1509        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1510        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1511        var rawContactValues = {"display_name" : "xiaohong", "company" : "TT", "position" : "Testers", "favorite" : 1};
1512        try {
1513            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
1514            console.info('logMessage contact_unfavorite_test_2600: rawContactId = ' + rawContactId);
1515            expect(rawContactId > 0).assertTrue();
1516            await updateUnFavorite(dataShareHelper, rawContactId);
1517            await deleteRawContact("contact_unfavorite_test_2600");
1518            done();
1519        } catch (error) {
1520            console.info('logMessage contact_unfavorite_test_2600: raw_contact insert error = ' + error);
1521            done();
1522        }
1523    });
1524
1525    async function updateUnFavorite(dataShareHelper, rawContactId)
1526    {
1527        var updateValues = {"favorite" : 0};
1528        let condition = new dataShare.DataSharePredicates();
1529        condition.equalTo("id", rawContactId.toString());
1530        try {
1531            var updateCode = await dataShareHelper.update(rawContactUri, updateValues, condition);
1532            sleep(sleep_one);
1533            console.info("logMessage contact_unfavorite_test_2600: updateCode = " + updateCode);
1534            expect(updateCode == 0).assertTrue();
1535            var map = new Map();
1536            map.set("id", rawContactId.toString());
1537            map.set("display_name", "xiaohong");
1538            map.set("company", "TT");
1539            map.set("position", "Testers");
1540            map.set("favorite", "0");
1541            await contactsQuery(map, "contact_favorite_test_2500", rawContactUri);
1542        } catch (error) {
1543            console.info("logMessage contact_unfavorite_test_2600: update error = " + error);
1544        }
1545    }
1546
1547    /**
1548     * @tc.number  contact_insert_test_2700
1549     * @tc.name    Insert contact blocklist
1550     * @tc.desc    Function test
1551     */
1552    it("contact_insert_test_2700", 0, async function(done) {
1553        console.info("-------logMessage contact_insert_test_2700 is starting!------");
1554        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1555        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1556        try {
1557            var blocklistId = await dataShareHelper.insert(contactBlocklistUri, common.getProfileBlockList());
1558            sleep(sleep_one);
1559            console.info('logMessage contact_insert_test_2700: blocklistId = ' + blocklistId);
1560            expect(blocklistId > 0).assertTrue();
1561            var map = common.getProfileBlockListMap();
1562            map.set("id", blocklistId.toString());
1563            await contactsQuery(map, "contact_insert_test_2700", contactBlocklistUri);
1564            await deleteAll(contactBlocklistUri, "contact_insert_test_2700");
1565            done();
1566        } catch (error) {
1567            console.info('logMessage contact_insert_test_2700: blocklist insert error = ' + error);
1568            done();
1569        }
1570    });
1571
1572    /**
1573     * @tc.number  contact_delete_test_2800
1574     * @tc.name    Delete contact blocklist
1575     * @tc.desc    Function test
1576     */
1577    it("contact_delete_test_2800", 0, async function(done) {
1578        console.info("-------logMessage contact_delete_test_2800 is starting!------");
1579        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1580        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1581        try {
1582            var blocklistId = await dataShareHelper.insert(contactBlocklistUri, common.getProfileBlockList());
1583            sleep(sleep_one);
1584            console.info('logMessage contact_delete_test_2800: blocklistId = ' + blocklistId);
1585            expect(blocklistId > 0).assertTrue();
1586            await BlocklistDelete();
1587            done();
1588        } catch (error) {
1589            console.info('logMessage contact_delete_test_2800: blocklist insert error = ' + error);
1590            done();
1591        }
1592
1593        async function BlocklistDelete()
1594        {
1595            let condition = new dataShare.DataSharePredicates();
1596            condition.equalTo("id", blocklistId.toString());
1597            try {
1598                var deleteCode = await dataShareHelper.delete(contactBlocklistUri, condition);
1599                sleep(sleep_one);
1600                console.info("logMessage contact_delete_test_2800: deleteCode = " + deleteCode);
1601                expect(deleteCode == 0).assertTrue();
1602                var map = new Map();
1603                map.set("id", blocklistId.toString());
1604                await queryIdForDelete(map, "contact_delete_test_2800", contactBlocklistUri);
1605            } catch (error) {
1606                console.info('logMessage contact_delete_test_2800: delete error = ' + error);
1607                done();
1608            }
1609        }
1610    });
1611
1612    /**
1613     * @tc.number  contact_insert_test_2900
1614     * @tc.name    Insert contact group
1615     * @tc.desc    Function test
1616     */
1617    it("contact_insert_test_2900", 0, async function(done) {
1618        console.info("-------logMessage contact_insert_test_2900 is starting!-------");
1619        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1620        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1621
1622        var groupValues = {"group_name" : "TestersThird"};
1623        try {
1624            var groupId = await dataShareHelper.insert(groupUri, groupValues);
1625            sleep(sleep_one);
1626            console.info("logMessage contact_insert_test_2900: groupId =" + groupId);
1627            expect(groupId > 0).assertTrue();
1628            await groupRawContactInsert(dataShareHelper);
1629            await deleteRawContact("contact_insert_test_2900");
1630            await deleteAll(groupUri, "contact_insert_test_2900");
1631            await deleteAll(contactDataUri, "contact_insert_test_2900");
1632            done();
1633        } catch (error) {
1634            console.info("logMessage contact_insert_test_2900: group insert error =" + error);
1635            done();
1636        }
1637    });
1638
1639    async function groupRawContactInsert(dataShareHelper)
1640    {
1641        var rawContactValues = {"display_name" : "liyu"};
1642        try {
1643            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
1644            sleep(sleep_one);
1645            console.info("logMessage contact_insert_test_2900: rawContactId =" + rawContactId);
1646            expect(rawContactId > 0).assertTrue();
1647            await groupDataInsert(dataShareHelper, rawContactId);
1648        } catch (error) {
1649            console.info("logMessage contact_insert_test_2900: raw_contact insert error =" + error);
1650        }
1651    }
1652
1653    async function groupDataInsert(dataShareHelper, rawContactId)
1654    {
1655        var contactDataValues = {
1656            "raw_contact_id" : rawContactId,
1657            "content_type" : "group_membership",
1658            "detail_info" : groupId.toString()
1659        };
1660        try {
1661            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues)
1662            sleep(sleep_one);
1663            console.info("logMessage contact_insert_test_2900: contactDataId =" + contactDataId);
1664            expect(contactDataId > 0).assertTrue();
1665            var map = new Map();
1666            map.set("id", contactDataId);
1667            map.set("raw_contact_id", rawContactId.toString());
1668            map.set("detail_info", groupId.toString());
1669            await contactsQuery(map, "contact_insert_test_2900", contactDataUri);
1670        } catch (error) {
1671            console.info("logMessage contact_insert_test_2900: contact_data insert error =" + error);
1672        }
1673    }
1674
1675    /**
1676     * @tc.number  contact_delete_test_3000
1677     * @tc.name    Delete contact group
1678     * @tc.desc    Function test
1679     */
1680    it("contact_delete_test_3000", 0, async function(done) {
1681        console.info("-------logMessage contact_delete_test_3000 is starting!-------");
1682        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1683        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1684
1685        var groupValues = {"group_name" : "TestersFourth"};
1686        try {
1687            var groupId = await dataShareHelper.insert(groupUri, groupValues);
1688            sleep(sleep_one);
1689            console.info("logMessage contact_delete_test_3000: groupId =" + groupId);
1690            expect(groupId > 0).assertTrue();
1691            await groupAfterRawContactInsert(dataShareHelper);
1692            await deleteRawContact("contact_delete_test_3000");
1693            await deleteAll(groupUri, "contact_delete_test_3000");
1694            await deleteAll(contactDataUri, "contact_delete_test_3000");
1695            done();
1696        } catch (error) {
1697            console.info("logMessage contact_delete_test_3000: group insert error =" + error);
1698            done();
1699        }
1700    });
1701
1702    async function groupAfterRawContactInsert(dataShareHelper)
1703    {
1704        var rawContactValues = {"display_name" : "liyuchen"};
1705        try {
1706            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
1707            sleep(sleep_one);
1708            console.info("logMessage contact_delete_test_3000: rawContactId =" + rawContactId);
1709            expect(rawContactId > 0).assertTrue();
1710            await deleteGroupContactDataInsert(dataShareHelper, rawContactId);
1711        } catch (error) {
1712            console.info("logMessage contact_delete_test_3000: raw_contact insert error =" + error);
1713        }
1714    }
1715
1716    async function deleteGroupContactDataInsert(dataShareHelper, rawContactId)
1717    {
1718        var contactDataValues = {
1719            "raw_contact_id" : rawContactId,
1720            "content_type" : "group_membership",
1721            "detail_info" : groupId.toString()
1722        };
1723        try {
1724            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
1725            console.info("logMessage contact_delete_test_3000: contactDataId =" + contactDataId);
1726            expect(contactDataId > 0).assertTrue();
1727            await deleteGroup(dataShareHelper, contactDataId);
1728        } catch (error) {
1729            console.info("logMessage contact_delete_test_3000: contact_data insert error =" + error);
1730        }
1731    }
1732
1733    async function deleteGroup(dataShareHelper, contactDataId)
1734    {
1735        let condition = new dataShare.DataSharePredicates();
1736        condition.equalTo("id", contactDataId.toString());
1737        try {
1738            var deleteCode = await dataShareHelper.delete(contactDataUri, condition);
1739            sleep(sleep_one);
1740            console.info("logMessage contact_delete_test_3000: deleteCode =" + deleteCode);
1741            expect(deleteCode == 0).assertTrue();
1742            var map = new Map();
1743            map.set("id", contactDataId.toString());
1744            await queryIdForDelete(map, "contact_delete_test_3000", contactDataUri);
1745        } catch (error) {
1746            console.info("logMessage contact_delete_test_3000: delete error =" + error);
1747        }
1748    }
1749
1750    /**
1751     * @tc.number  contact_query_test_3100
1752     * @tc.name    Query basic information of a single contact
1753     * @tc.desc    Function test
1754     */
1755    it("contact_query_test_3100", 0, async function(done) {
1756        console.info("-----------logMessage contact_query_test_3100 is starting!------------");
1757        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1758        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1759
1760        var rawContactValues = {"display_name" : "xiaoyu"};
1761        try {
1762            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
1763            sleep(sleep_one);
1764            console.info("logMessage contact_query_test_3100: rawContactId = " + rawContactId);
1765            expect(rawContactId > 0).assertTrue();
1766            await RawContactQuery(dataShareHelper, rawContactId);
1767            await deleteRawContact("contact_query_test_3100");
1768            done();
1769        } catch (error) {
1770            console.info("logMessage contact_query_test_3100: raw_contact insert error = " + error);
1771            done();
1772        }
1773    });
1774
1775    async function RawContactQuery(dataShareHelper, rawContactId)
1776    {
1777        var resultColumns = [ "id", "display_name" ];
1778        let condition = new dataShare.DataSharePredicates();
1779        condition.equalTo("id", rawContactId.toString());
1780        try {
1781            var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
1782            sleep(sleep_two);
1783            if (resultSet.goToFirstRow()) {
1784                do {
1785                    console.info('logMessage contact_query_test_3100: id = ' + resultSet.getString(0));
1786                    expect(resultSet.getString(0) == rawContactId).assertEqual(true);
1787                    console.info('logMessage contact_query_test_3100: display_name = ' + resultSet.getString(1));
1788                    expect(resultSet.getString(1) == "xiaoyu").assertEqual(true);
1789                } while (resultSet.goToNextRow());
1790            }
1791            resultSet.close();
1792        } catch (error) {
1793            console.info("logMessage contact_query_test_3100: query error = " + error);
1794        }
1795    }
1796
1797    /**
1798     * @tc.number  contact_query_test_3200
1799     * @tc.name    Query basic information of multiple contacts
1800     * @tc.desc    Function test
1801     */
1802    it("contact_query_test_3200", 0, async function(done) {
1803        console.info("-----------logMessage contact_query_test_3200 is starting!------------");
1804        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1805        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1806
1807        var rawContactValues1 = {"display_name" : "xiaoyu"};
1808        try {
1809            var rawContactIdOne = await dataShareHelper.insert(rawContactUri, rawContactValues1);
1810            sleep(sleep_one);
1811            console.info("logMessage contact_query_test_3200: rawContactId = " + rawContactIdOne);
1812            expect(rawContactIdOne > 0).assertTrue();
1813        } catch (error) {
1814            console.info("logMessage contact_query_test_3200: raw_contact_1 insert error = " + error);
1815            done();
1816        }
1817
1818        var rawContactValues2 = {"display_name" : "xiaohong"};
1819        try {
1820            var rawContactIdTwo = await dataShareHelper.insert(rawContactUri, rawContactValues2);
1821            sleep(sleep_one);
1822            console.info("logMessage contact_query_test_3200: rawContactId = " + rawContactIdTwo);
1823            expect(rawContactIdTwo > 0).assertTrue();
1824            await queryTwoRaw(dataShareHelper, rawContactIdOne, rawContactIdTwo);
1825            await deleteRawContact("contact_query_test_3200");
1826            done();
1827        } catch (error) {
1828            console.info("logMessage contact_query_test_3200: raw_contact_2 insert error = " + error);
1829            done();
1830        }
1831    });
1832
1833    async function queryTwoRaw(dataShareHelper, rawContactIdOne, rawContactIdTwo)
1834    {
1835        var resultColumns = [ "id", "display_name" ];
1836        let condition = new dataShare.DataSharePredicates();
1837        condition.equalTo("id", rawContactIdOne.toString());
1838        condition.or();
1839        condition.equalTo("id", rawContactIdTwo.toString());
1840        try {
1841            var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
1842            sleep(sleep_one);
1843            console.info('logMessage contact_query_test_3200: goToFirstRow' + resultSet.goToFirstRow());
1844            expect(resultSet.goToFirstRow()).assertEqual(true);
1845            if (resultSet.goToFirstRow()) {
1846                do {
1847                    console.info("logMessage contact_query_test_3200: columnNames :" + resultSet.columnNames);
1848                    console.info("logMessage contact_query_test_3200: columnCount:" + resultSet.columnCount);
1849                    console.info('logMessage contact_query_test_3200: id = ' + resultSet.getString(0));
1850                    console.info('logMessage contact_query_test_3200: display_name = ' + resultSet.getString(1));
1851                } while (resultSet.goToNextRow());
1852            }
1853            resultSet.close();
1854        } catch (error) {
1855            console.info('logMessage contact_query_test_3200: query error' + error);
1856        }
1857    }
1858
1859    /**
1860     * @tc.number  contact_query_test_3300
1861     * @tc.name    Query basic information of all contacts
1862     * @tc.desc    Function test
1863     */
1864    it("contact_query_test_3300", 0, async function(done) {
1865        console.info("-----------logMessage contact_query_test_3300 is starting!------------");
1866        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1867        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1868
1869        var rawContactValues1 = {"display_name" : "xiaoyu"};
1870        try {
1871            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues1);
1872            sleep(sleep_one);
1873            console.info("logMessage contact_query_test_3300: rawContactId = " + rawContactId);
1874            expect(rawContactId > 0).assertTrue();
1875        } catch (error) {
1876            console.info("logMessage contact_query_test_3300: raw_contact_1 insert error = " + error);
1877            done();
1878        }
1879        var resultColumns = [ "id", "display_name" ];
1880        let condition = new dataShare.DataSharePredicates();
1881        condition.greaterThan("id", "0");
1882        try {
1883            var resultSet = await dataShareHelper.query(profileRawContactUri, resultColumns, condition);
1884            sleep(sleep_one);
1885            if (resultSet.goToFirstRow()) {
1886                do {
1887                    console.info('logMessage contact_query_test_3300: id = ' + resultSet.getString(0));
1888                    expect(resultSet.getString(0) == rawContactId.toString()).assertEqual(true);
1889                    console.info('logMessage contact_query_test_3300: display_name = ' + resultSet.getString(1));
1890                    expect(resultSet.getString(1) == "xiaoyu").assertEqual(true);
1891                } while (resultSet.goToNextRow());
1892            }
1893            resultSet.close();
1894            await deleteRawContact("contact_query_test_3300");
1895            done();
1896        } catch (error) {
1897            console.info("logMessage contact_query_test_3300: query error = " + error);
1898            done();
1899        }
1900    });
1901
1902    /**
1903     * @tc.number  contact_query_test_3400
1904     * @tc.name    Query all information of a single contact
1905     * @tc.desc    Function test
1906     */
1907    it("contact_query_test_3400", 0, async function(done) {
1908        console.info("-----------logMessage contact_query_test_3400 is starting!------------");
1909        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1910        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1911
1912        var rawContactValues = {
1913            "display_name" : "xiaoyuzhou",
1914            "company" : "TT",
1915            "position" : "Testers",
1916            "favorite" : 1,
1917            "phonetic_name" : "xiaoyu||xy"
1918        };
1919        try {
1920            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
1921            sleep(sleep_one);
1922            console.info("logMessage contact_query_test_3400: rawContactId = " + rawContactId);
1923            expect(rawContactId > 0).assertTrue();
1924            await queryAllInformation(dataShareHelper, rawContactId);
1925            await deleteRawContact("contact_query_test_3400");
1926            done();
1927        } catch (error) {
1928            console.info("logMessage contact_query_test_3400: raw_contact insert error = " + error);
1929            done();
1930        }
1931    });
1932
1933    async function queryAllInformation(dataShareHelper, rawContactId)
1934    {
1935        var resultColumns = [];
1936        let condition = new dataShare.DataSharePredicates();
1937        condition.equalTo("id", rawContactId.toString());
1938        try {
1939            var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
1940            sleep(sleep_one);
1941            if (resultSet.goToFirstRow()) {
1942                do {
1943                    var id = resultSet.getString(resultSet.getColumnIndex("id"));
1944                    console.info('logMessage contact_query_test_3400: id = ' + id);
1945                    expect(id == rawContactId).assertEqual(true);
1946                    var favorite = resultSet.getString(resultSet.getColumnIndex("favorite"));
1947                    console.info('logMessage contact_query_test_3400: favorite = ' + favorite);
1948                    expect(favorite == "1").assertEqual(true);
1949                    var phonetic_name = resultSet.getString(resultSet.getColumnIndex("phonetic_name"));
1950                    console.info('logMessage contact_query_test_3400: phonetic_name = ' + phonetic_name);
1951                    expect(phonetic_name == "xiaoyu||xy").assertEqual(true);
1952                    var company = resultSet.getString(resultSet.getColumnIndex("company"));
1953                    console.info('logMessage contact_query_test_3400: company = ' + company);
1954                    expect(company == "TT").assertEqual(true);
1955                    var display_name = resultSet.getString(resultSet.getColumnIndex("display_name"));
1956                    console.info('logMessage contact_query_test_3400: display_name = ' + display_name);
1957                    expect(display_name == "xiaoyuzhou").assertEqual(true);
1958                } while (resultSet.goToNextRow());
1959            }
1960            resultSet.close();
1961        } catch (error) {
1962            console.info('logMessage contact_query_test_3400: query error = ' + error);
1963        }
1964    }
1965
1966    /**
1967     * @tc.number  contact_query_test_3500
1968     * @tc.name    Query group member ability
1969     * @tc.desc    Function test
1970     */
1971    it("contact_query_test_3500", 0, async function(done) {
1972        console.info("-----------logMessage contact_query_test_3500 is starting!------------");
1973        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
1974        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
1975        var rawContactValues = {"display_name" : "xiaoyuzhou"};
1976        try {
1977            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
1978            sleep(sleep_one);
1979            console.info("logMessage contact_query_test_3500: rawContactId = " + rawContactId);
1980            expect(rawContactId > 0).assertTrue();
1981        } catch (error) {
1982            console.info("logMessage contact_query_test_3500: raw_contact insert error = " + error);
1983            done();
1984        }
1985        var groupValues = {"group_name" : "BossBoard3500"};
1986        try {
1987            var groupId = await dataShareHelper.insert(groupUri, groupValues);
1988            sleep(sleep_one);
1989            console.info("logMessage contact_query_test_3500: groupId = " + groupId);
1990            expect(groupId > 0).assertTrue();
1991        } catch (error) {
1992            console.info("logMessage contact_query_test_3500: group insert error = " + error);
1993            done();
1994        }
1995        await groupBossBoardInsert(dataShareHelper, rawContactId, groupId);
1996        await deleteRawContact("contact_query_test_3500");
1997        await deleteAll(groupUri, "contact_query_test_3500");
1998        await deleteAll(contactDataUri, "contact_query_test_3500");
1999        done();
2000    });
2001
2002    async function groupBossBoardInsert(dataShareHelper, rawContactId, groupId)
2003    {
2004        var contactDataValues = {
2005            "raw_contact_id" : rawContactId,
2006            "content_type" : "group_membership",
2007            "detail_info" : groupId.toString()
2008        };
2009        try {
2010            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
2011            sleep(sleep_one);
2012            console.info("logMessage contact_query_test_3500: contactDataId = " + contactDataId);
2013            expect(contactDataId > 0).assertTrue();
2014            await groupBossBoardQuery(dataShareHelper, rawContactId, groupId);
2015        } catch (error) {
2016            console.info("logMessage contact_query_test_3500: query error = " + error);
2017        }
2018    }
2019
2020    async function groupBossBoardQuery(dataShareHelper, rawContactId, groupId)
2021    {
2022        var resultColumns = [ "raw_contact_id", "detail_info" ];
2023        let condition = new dataShare.DataSharePredicates();
2024        // type_id = 9 data is group
2025        condition.equalTo("type_id", "9");
2026        condition.and();
2027        condition.equalTo("detail_info", groupId.toString());
2028        try {
2029            var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
2030            sleep(sleep_one);
2031            if (resultSet.goToFirstRow()) {
2032                do {
2033                    console.info('logMessage contact_query_test_3500: raw_contact_id = ' + resultSet.getString(0));
2034                    expect(resultSet.getString(0) == rawContactId).assertEqual(true);
2035                    console.info('logMessage contact_query_test_3500: detail_info = ' + resultSet.getString(1));
2036                    expect(resultSet.getString(1) == groupId.toString()).assertEqual(true);
2037                } while (resultSet.goToNextRow());
2038            }
2039            resultSet.close();
2040        } catch (error) {
2041            console.info("logMessage contact_query_test_3500: query error :" + error);
2042        }
2043    }
2044
2045    /**
2046     * @tc.number  contact_query_test_3600
2047     * @tc.name    Query favorite contacts
2048     * @tc.desc    Function test
2049     */
2050    it("contact_query_test_3600", 0, async function(done) {
2051        console.info("-----------logMessage contact_query_test_3600 is starting!------------");
2052        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
2053        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
2054        var rawContactValues = {"display_name" : "xiaoyuzhou", "favorite" : 1};
2055        try {
2056            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
2057            sleep(sleep_one);
2058            console.info("logMessage contact_query_test_3600: rawContactId = " + rawContactId);
2059            expect(rawContactId > 0).assertTrue();
2060            await queryFavorite();
2061            await deleteRawContact("contact_query_test_3600");
2062            done();
2063        } catch (error) {
2064            console.info("logMessage contact_query_test_3600: raw_contact insert error = " + error);
2065            done();
2066        }
2067
2068        async function queryFavorite()
2069        {
2070            var resultColumns = [ "id", "display_name" ];
2071            let condition = new dataShare.DataSharePredicates();
2072            condition.equalTo("favorite", "1");
2073            condition.and();
2074            condition.equalTo("is_deleted", "0");
2075            try {
2076                var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
2077                sleep(sleep_one);
2078                if (resultSet.goToFirstRow()) {
2079                    do {
2080                        console.info('logMessage contact_query_test_3600: id = ' + resultSet.getString(0));
2081                        expect(resultSet.getString(0) == rawContactId.toString()).assertTrue();
2082                        console.info('logMessage contact_query_test_3600: display_name = ' + resultSet.getString(1));
2083                        expect(resultSet.getString(1) == "xiaoyuzhou").assertTrue();
2084                    } while (resultSet.goToNextRow());
2085                }
2086                resultSet.close();
2087            } catch (error) {
2088                console.info("logMessage contact_query_test_3600: query error :" + error);
2089                done();
2090            }
2091        }
2092    });
2093
2094    /**
2095     * @tc.number  contact_query_test_3700
2096     * @tc.name    Query recent contact ability
2097     * @tc.desc    Function test
2098     */
2099    it("contact_query_test_3700", 0, async function(done) {
2100        console.info("-----------logMessage contact_query_test_3700 is starting!------------");
2101        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
2102        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
2103        var rawContactValues = {"display_name" : "xiaoyuzhou", "lastest_contacted_time" : 60};
2104        try {
2105            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
2106            sleep(sleep_one);
2107            console.info("logMessage contact_query_test_3700: rawContactId = " + rawContactId);
2108            expect(rawContactId > 0).assertTrue();
2109            await queryContacted();
2110            await deleteRawContact("contact_query_test_3700");
2111            done();
2112        } catch (error) {
2113            console.info("logMessage contact_query_test_3700: raw_contact insert error = " + error);
2114            done();
2115        }
2116
2117        async function queryContacted()
2118        {
2119            var resultColumns = [ "id", "display_name" ];
2120            let condition = new dataShare.DataSharePredicates();
2121            condition.lessThan("lastest_contacted_time", "100");
2122            condition.and();
2123            condition.equalTo("is_deleted", "0");
2124            try {
2125                var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
2126                sleep(sleep_one);
2127                if (resultSet.goToFirstRow()) {
2128                    do {
2129                        console.info('logMessage contact_query_test_3700: id = ' + resultSet.getString(0));
2130                        expect(resultSet.getString(0) == rawContactId.toString()).assertTrue();
2131                        console.info('logMessage contact_query_test_3700: display_name = ' + resultSet.getString(1));
2132                        expect(resultSet.getString(1) == "xiaoyuzhou").assertTrue();
2133                    } while (resultSet.goToNextRow());
2134                }
2135                resultSet.close();
2136            } catch (error) {
2137                console.info('logMessage contact_query_test_3700: query error' + error);
2138                done();
2139            }
2140        }
2141    });
2142
2143    /**
2144     * @tc.number  contact_query_test_3800
2145     * @tc.name    Query recently deleted contacts
2146     * @tc.desc    Function test
2147     */
2148    it("contact_query_test_3800", 0, async function(done) {
2149        console.info("-----------logMessage contact_query_test_3800 is starting!------------");
2150        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
2151        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
2152        var rawContactValues = {"display_name" : "xiaocai"};
2153        try {
2154            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
2155            sleep(sleep_one);
2156            console.info("logMessage contact_query_test_3800: rawContactId = " + rawContactId);
2157            expect(rawContactId > 0).assertTrue();
2158            await rawContactDelete(dataShareHelper, rawContactId);
2159            await deletedRawContactQuery(dataShareHelper, rawContactId);
2160            await deleteAll(deletedUri, "contact_query_test_3800")
2161            done();
2162        } catch (error) {
2163            console.info("logMessage contact_query_test_3800: raw_contact insert error = " + error);
2164            done();
2165        }
2166    });
2167
2168    async function rawContactDelete(dataShareHelper, rawContactId)
2169    {
2170        var condition1 = new dataShare.DataSharePredicates();
2171        condition1.equalTo("id", rawContactId.toString());
2172        try {
2173            var deleteCode = await dataShareHelper.delete(rawContactUri, condition1);
2174            sleep(sleep_one);
2175            console.info('logMessage contact_query_test_3800: deleteCode = ' + deleteCode);
2176            expect(deleteCode == 0).assertTrue();
2177        } catch (error) {
2178            console.info("logMessage contact_query_test_3800: raw_contact delete error = " + error);
2179            done();
2180        }
2181    }
2182
2183    async function deletedRawContactQuery(dataShareHelper, rawContactId)
2184    {
2185        var resultColumns = [ "id", "raw_contact_id", "display_name", "is_deleted" ];
2186        var condition2 = new dataShare.DataSharePredicates();
2187        condition2.equalTo("raw_contact_id", rawContactId.toString());
2188        try {
2189            var resultSet = await dataShareHelper.query(deletedRawContactUri, resultColumns, condition2);
2190            sleep(sleep_one);
2191            if (resultSet.goToFirstRow()) {
2192                console.info('logMessage contact_query_test_3800: id = ' + resultSet.getString(0));
2193                console.info('logMessage contact_query_test_3800: raw_contact_id = ' + resultSet.getString(1));
2194                expect(resultSet.getString(1) == rawContactId.toString()).assertTrue();
2195                console.info('logMessage contact_query_test_3800: display_name = ' + resultSet.getString(array_two));
2196                expect(resultSet.getString(array_two) == "xiaocai").assertTrue();
2197                console.info('logMessage contact_query_test_3800: is_deleted = ' + resultSet.getString(array_three));
2198                expect(resultSet.getString(array_three) == "1").assertTrue();
2199            }
2200            resultSet.close();
2201        } catch (error) {
2202            console.info("logMessage contact_query_test_3800: query error :" + error);
2203            done();
2204        }
2205    }
2206
2207    /**
2208     * @tc.number  contact_query_test_3900
2209     * @tc.name    Query all mobile phone numbers
2210     * @tc.desc    Function test
2211     */
2212    it("contact_query_test_3900", 0, async function(done) {
2213        console.info("-----------logMessage contact_query_test_3900 is starting!------------");
2214        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
2215        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
2216        var rawContactValues = {"display_name" : "xiaocai"};
2217        try {
2218            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
2219            sleep(sleep_one);
2220            console.info("logMessage contact_query_test_3900: rawContactId = " + rawContactId);
2221            expect(rawContactId > 0).assertTrue();
2222            await queryPhoneInsert();
2223            await phoneQuery(rawContactId);
2224            await deleteRawContact("contact_query_test_3900");
2225            await deleteAll(contactDataUri, "contact_query_test_3900");
2226            done();
2227        } catch (error) {
2228            console.info("logMessage contact_query_test_3900: raw_contact insert error = " + error);
2229            done();
2230        }
2231    });
2232
2233    async function queryPhoneInsert(dataShareHelper, rawContactId)
2234    {
2235        var contactDataValues = {
2236            "raw_contact_id" : rawContactId,
2237            "content_type" : "phone",
2238            "detail_info" : "1853696321"
2239        };
2240        try {
2241            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
2242            sleep(sleep_one);
2243            console.info("logMessage contact_query_test_3900: contactDataId = " + contactDataId);
2244            expect(contactDataId > 0).assertTrue();
2245        } catch (error) {
2246            console.info("logMessage contact_query_test_3900: contact_data insert error = " + error);
2247        }
2248    }
2249
2250    async function phoneQuery(dataShareHelper, rawContactId)
2251    {
2252        var resultColumns = [ "raw_contact_id", "detail_info" ];
2253        let condition = new dataShare.DataSharePredicates();
2254        // type_id = 5 data is phone
2255        condition.equalTo("content_type", "phone");
2256        try {
2257            var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
2258            sleep(sleep_one);
2259            if (resultSet.goToFirstRow()) {
2260                do {
2261                    console.info('logMessage contact_query_test_3900: raw_contact_id = ' + resultSet.getString(0));
2262                    expect(resultSet.getString(0) == rawContactId.toString()).assertTrue();
2263                    console.info('logMessage contact_query_test_3900: detail_info = ' + resultSet.getString(1));
2264                    expect(resultSet.getString(1) == "1853696321").assertTrue();
2265                } while (resultSet.goToNextRow());
2266            }
2267            resultSet.close();
2268        } catch (error) {
2269            console.info('logMessage contact_query_test_3900: query error' + error);
2270        }
2271    }
2272
2273    /**
2274     * @tc.number  contact_query_test_4000
2275     * @tc.name    Query all mailbox capabilities
2276     * @tc.desc    Function test
2277     */
2278    it("contact_query_test_4000", 0, async function(done) {
2279        console.info("-----------logMessage contact_query_test_4000 is starting!------------");
2280
2281        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
2282        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
2283
2284        var rawContactValues = {"display_name" : "xiaoyu"};
2285        try {
2286            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
2287            sleep(sleep_one);
2288            console.info("logMessage contact_query_test_4000: rawContactId = " + rawContactId);
2289            expect(rawContactId > 0).assertTrue();
2290            await queryEmailInsert(dataShareHelper, rawContactId);
2291            await emailQuery(dataShareHelper, contactDataId, rawContactId);
2292            await deleteRawContact("contact_query_test_4000");
2293            await deleteAll(contactDataUri, "contact_query_test_4000");
2294            done();
2295        } catch (error) {
2296            console.info("logMessage contact_query_test_4000: raw_contact insert error = " + error);
2297            done();
2298        }
2299    });
2300
2301    async function queryEmailInsert(dataShareHelper, rawContactId)
2302    {
2303        var contactDataValues = {
2304            "raw_contact_id" : rawContactId,
2305            "content_type" : "email",
2306            "detail_info" : "16658@163.com"
2307        };
2308        try {
2309            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
2310            sleep(sleep_one);
2311            console.info("logMessage contact_query_test_4000: contactDataId = " + contactDataId);
2312            expect(contactDataId > 0).assertTrue();
2313        } catch (error) {
2314            console.info("logMessage contact_query_test_4000: contact_data insert error = " + error);
2315        }
2316    }
2317
2318    async function emailQuery(dataShareHelper, contactDataId, rawContactId)
2319    {
2320        var resultColumns = [ "id", "raw_contact_id", "detail_info" ];
2321        let condition = new dataShare.DataSharePredicates();
2322        // type_id = 1 data content_type is  email
2323        condition.equalTo("type_id", "1").limitAs(array_three).orderByDesc("id");
2324        try {
2325            var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
2326            sleep(sleep_one);
2327            if (resultSet.goToFirstRow()) {
2328                do {
2329                    console.info('logMessage contact_query_test_4000: id = ' + resultSet.getString(0));
2330                    expect(resultSet.getString(0) == contactDataId.toString()).assertTrue();
2331                    console.info('logMessage contact_query_test_4000: raw_contact_id = ' + resultSet.getString(1));
2332                    expect(resultSet.getString(1) == rawContactId.toString()).assertTrue();
2333                    console.info('logMessage contact_query_test_4000: detail_info = ' + resultSet.getString(array_two));
2334                    expect(resultSet.getString(array_two) == "16658@163.com").assertTrue();
2335                } while (resultSet.goToNextRow());
2336            }
2337            resultSet.close();
2338        } catch (error) {
2339            console.info("logMessage contact_query_test_4000: query error :" + error);
2340        }
2341    }
2342
2343    /**
2344     * @tc.number  contact_query_test_4100
2345     * @tc.name    Query data information of a single contact
2346     * @tc.desc    Function test
2347     */
2348    it("contact_query_test_4100", 0, async function(done) {
2349        console.info("-----------logMessage contact_query_test_4100 is starting!------------");
2350        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
2351        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
2352
2353        var rawContactValues = {"display_name" : "xiaoyu"};
2354        try {
2355            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
2356            sleep(sleep_one);
2357            console.info("logMessage contact_query_test_4100: rawContactId = " + rawContactId);
2358            expect(rawContactId > 0).assertTrue();
2359            await queryTwoDataInsert(dataShareHelper, rawContactId);
2360            await queryTwoDataInsertCompany(dataShareHelper, rawContactId);
2361            await queryTwo(dataShareHelper, rawContactId);
2362            await deleteRawContact("contact_query_test_4100");
2363            await deleteAll(contactDataUri, "contact_query_test_4100");
2364            del
2365            done();
2366        } catch (error) {
2367            console.info("logMessage contact_query_test_4100: raw_contact insert error = " + error);
2368            done();
2369        }
2370    });
2371
2372    async function queryTwoDataInsert(dataShareHelper, rawContactId)
2373    {
2374        var contactDataValues = {"raw_contact_id" : rawContactId, "content_type" : "name", "detail_info" : "xiaoyu"};
2375        try {
2376            var contactDataId1 = await dataShareHelper.insert(contactDataUri, contactDataValues);
2377            sleep(sleep_one);
2378            console.info("logMessage contact_query_test_4100: contactDataId = " + contactDataId1);
2379            expect(contactDataId1 > 0).assertTrue();
2380        } catch (error) {
2381            console.info("logMessage contact_query_test_4100: contact_data name insert error = " + error);
2382        }
2383    }
2384
2385    async function queryTwoDataInsertCompany(dataShareHelper, rawContactId)
2386    {
2387        var contactDataValues = {
2388            "raw_contact_id" : rawContactId,
2389            "content_type" : "organization",
2390            "detail_info" : "OOOO",
2391            "position" : "Testers"
2392        };
2393        try {
2394            var contactDataId2 = await dataShareHelper.insert(contactDataUri, contactDataValues);
2395            console.info("logMessage contact_query_test_4100: contactDataId = " + contactDataId2);
2396            expect(contactDataId2 > 0).assertTrue();
2397        } catch (error) {
2398            console.info("logMessage contact_query_test_4100: contact_data company insert error = " + error);
2399        }
2400    }
2401
2402    async function queryTwo(dataShareHelper, rawContactId)
2403    {
2404        var resultColumns = [ "id", "raw_contact_id", "detail_info", "position" ];
2405        let condition = new dataShare.DataSharePredicates();
2406        condition.equalTo("raw_contact_id", rawContactId.toString());
2407        try {
2408            var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
2409            sleep(sleep_one);
2410            var array = [ {detail_info : "xiaoyu", position : ""}, {detail_info : "OOOO", position : "Testers"} ];
2411            var i = 0;
2412            if (resultSet.goToFirstRow()) {
2413                do {
2414                    console.info("logMessage contact_query_test_4100: columnNames :" + resultSet.columnNames);
2415                    console.info("logMessage contact_query_test_4100: columnCount:" + resultSet.columnCount);
2416                    console.info('logMessage contact_query_test_4100: id = ' + resultSet.getString(0));
2417                    console.info('logMessage contact_query_test_4100: raw_contact_id = ' + resultSet.getString(1));
2418                    expect(resultSet.getString(1) == rawContactId.toString()).assertEqual(true);
2419                    console.info('logMessage contact_query_test_4100: detail_info = ' + resultSet.getString(array_two));
2420                    expect(resultSet.getString(array_two) == array[i].detail_info).assertEqual(true);
2421                    console.info('logMessage contact_query_test_4100: position = ' + resultSet.getString(array_three));
2422                    expect(resultSet.getString(array_three) == array[i].position).assertEqual(true);
2423                    i++;
2424                } while (resultSet.goToNextRow());
2425            }
2426            resultSet.close();
2427        } catch (error) {
2428            console.info("logMessage contact_query_test_4100: query error :" + error);
2429        }
2430    }
2431
2432    /**
2433     * @tc.number  contact_delete_test_4400
2434     * @tc.name    Delete the basic raw data of the contact and record the deleted basic raw data
2435     * @tc.desc    Function test
2436     */
2437    it("contact_delete_test_4400", 0, async function(done) {
2438        console.info("-------logMessage contact_delete_test_4400 is starting!-------");
2439        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
2440        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
2441
2442        var insertRawContactValues = {"display_name" : "xiaoming"};
2443        try {
2444            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
2445            sleep(sleep_one);
2446            console.info("logMessage contact_delete_test_4400: rawContactId = " + rawContactId);
2447            expect(rawContactId > 0).assertTrue();
2448            await deleteRaw(dataShareHelper, rawContactId);
2449            await queryDelete(dataShareHelper, rawContactId);
2450            done();
2451        } catch (error) {
2452            console.info("logMessage contact_delete_test_4400: raw_contact insert error :" + error);
2453            done();
2454        }
2455    });
2456
2457    async function deleteRaw(dataShareHelper, rawContactId)
2458    {
2459        var condition1 = new dataShare.DataSharePredicates();
2460        condition1.equalTo("id", rawContactId.toString());
2461        try {
2462            var deleteCode = await dataShareHelper.delete(rawContactUri, condition1);
2463            sleep(sleep_one);
2464            console.info("logMessage contact_delete_test_4400: deleteCode = " + deleteCode);
2465            expect(deleteCode == 0).assertTrue();
2466        } catch (error) {
2467            console.info("logMessage contact_delete_test_4400: delete error = " + error);
2468        }
2469    }
2470
2471    async function queryDelete(dataShareHelper, rawContactId)
2472    {
2473        var resultColumns = [ "id", "delete_time", "display_name" ];
2474        var condition2 = new dataShare.DataSharePredicates();
2475        condition2.equalTo("raw_contact_id", rawContactId.toString());
2476        try {
2477            var resultSet = await dataShareHelper.query(deletedRawContactUri, resultColumns, condition2);
2478            sleep(sleep_one);
2479            if (resultSet.goToFirstRow()) {
2480                console.info("logMessage contact_delete_test_4400: columnNames:" + resultSet.columnNames);
2481                console.info("logMessage contact_delete_test_4400: columnCount:" + resultSet.columnCount);
2482                console.info('logMessage contact_delete_test_4400: id = ' + resultSet.getString(0));
2483                console.info('logMessage contact_delete_test_4400: delete_time = ' + resultSet.getString(1));
2484                console.info('logMessage contact_delete_test_4400: display_name = ' + resultSet.getString(array_two));
2485                expect(resultSet.getString(array_two) == "xiaoming").assertTrue();
2486            }
2487            resultSet.close();
2488        } catch (error) {
2489            console.info("logMessage contact_delete_test_4400: query error:" + error);
2490        }
2491    }
2492
2493    /**
2494     * @tc.number  contact_delete_test_4700
2495     * @tc.name    Delete detailed contact data and record detailed data
2496     * @tc.desc    Function test
2497     */
2498    it("contact_delete_test_4700", 0, async function(done) {
2499        console.info("-------logMessage contact_delete_test_4700 is starting!-------");
2500        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
2501        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
2502
2503        var insertRawContactValues = {"display_name" : "xiaozhang", "company" : "OOOO", "position" : "TestManager"};
2504        try {
2505            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
2506            sleep(sleep_one);
2507            console.info("logMessage contact_delete_test_4700: rawContactId = " + rawContactId);
2508            expect(rawContactId > 0).assertTrue();
2509            await queryDeleteCompanyData(dataShareHelper, rawContactId);
2510            await rawContactDelete(dataShareHelper, rawContactId);
2511            await companyRawContactDeleteQuery(dataShareHelper, rawContactId);
2512            await deleteAll(contactDataUri, "contact_delete_test_4700");
2513            done();
2514        } catch (error) {
2515            console.info("logMessage contact_delete_test_4700: raw_contact insert error:" + error);
2516            done();
2517        }
2518    });
2519
2520    async function queryDeleteCompanyData(dataShareHelper, rawContactId)
2521    {
2522        var contactDataValues = {
2523            "raw_contact_id" : rawContactId,
2524            "content_type" : "organization",
2525            "detail_info" : "OOOO",
2526            "position" : "TestManager"
2527        };
2528        try {
2529            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
2530            sleep(sleep_one);
2531            console.info("logMessage contact_delete_test_4700: contactDataId = " + contactDataId);
2532            expect(contactDataId > 0).assertTrue();
2533        } catch (error) {
2534            console.info("logMessage contact_delete_test_4700: contact_data insert error:" + error);
2535        }
2536    }
2537
2538    async function rawContactDelete(dataShareHelper, rawContactId)
2539    {
2540        var condition1 = new dataShare.DataSharePredicates();
2541        condition1.equalTo("id", rawContactId.toString());
2542        try {
2543            var deleteCode = await dataShareHelper.delete(rawContactUri, condition1);
2544            sleep(sleep_one);
2545            console.info("logMessage contact_delete_test_4700: deleteCode = " + deleteCode);
2546            expect(deleteCode == 0).assertTrue();
2547        } catch (error) {
2548            console.info("logMessage contact_delete_test_4700: delete error = " + error);
2549            done();
2550        }
2551    }
2552
2553    async function companyRawContactDeleteQuery(dataShareHelper, rawContactId)
2554    {
2555        var resultColumns = [ "id", "display_name", "backup_data" ];
2556        var condition2 = new dataShare.DataSharePredicates();
2557        condition2.equalTo("raw_contact_id", rawContactId.toString());
2558        try {
2559            var resultSet = await dataShareHelper.query(deletedRawContactUri, resultColumns, condition2);
2560            sleep(sleep_one);
2561            if (resultSet.goToFirstRow()) {
2562                console.info("logMessage contact_delete_test_4700: columnNames:" + resultSet.columnNames);
2563                console.info("logMessage contact_delete_test_4700: columnCount:" + resultSet.columnCount);
2564                console.info('logMessage contact_delete_test_4700: id = ' + resultSet.getString(0));
2565                console.info('logMessage contact_delete_test_4700: display_name = ' + resultSet.getString(1));
2566                expect(resultSet.getString(1) == "xiaozhang").assertEqual(true);
2567                console.info('logMessage contact_delete_test_4700: backup_data = ' + resultSet.getString(array_two));
2568            }
2569            resultSet.close();
2570        } catch (error) {
2571            console.info("logMessage contact_delete_test_4700: query error:" + error);
2572        }
2573    }
2574
2575    /**
2576     * @tc.number  contact_delete_test_4800
2577     * @tc.name    Delete and record basic data of a single contact
2578     * @tc.desc    Function test
2579     */
2580    it("contact_delete_test_4800", 0, async function(done) {
2581        console.info("-------logMessage contact_delete_test_4800 is starting!-------");
2582        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
2583        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
2584
2585        var insertRawContactValues = {"display_name" : "xiaopeng"};
2586        try {
2587            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
2588            sleep(sleep_one);
2589            console.info("logMessage contact_delete_test_4800: rawContactId = " + rawContactId);
2590            expect(rawContactId > 0).assertTrue();
2591            await ContactDelete(dataShareHelper, rawContactId);
2592            await DeletedRawContactQuery(dataShareHelper, rawContactId)
2593                await deleteAll(contactDataUri, "contact_delete_test_4800");
2594            done();
2595        } catch (error) {
2596            console.info("logMessage contact_delete_test_4800: raw_contact insert error:" + error);
2597            done();
2598        }
2599    });
2600
2601    async function ContactDelete(dataShareHelper, rawContactId)
2602    {
2603        var condition1 = new dataShare.DataSharePredicates();
2604        condition1.equalTo("name_raw_contact_id", rawContactId.toString());
2605        try {
2606            var deleteCode = await dataShareHelper.delete(contactUri, condition1);
2607            sleep(sleep_one);
2608            console.info("logMessage contact_delete_test_4800: deleteCode = " + deleteCode);
2609            expect(deleteCode == 0).assertTrue();
2610        } catch (error) {
2611            console.info("logMessage contact_delete_test_4800: delete error = " + error);
2612        }
2613    }
2614
2615    async function DeletedRawContactQuery(dataShareHelper, rawContactId)
2616    {
2617        var resultColumns = [ "id", "delete_time", "display_name" ];
2618        var condition2 = new dataShare.DataSharePredicates();
2619        condition2.equalTo("raw_contact_id", rawContactId.toString());
2620        try {
2621            var resultSet = await dataShareHelper.query(deletedRawContactUri, resultColumns, condition2);
2622            sleep(sleep_one)
2623            if (resultSet.goToFirstRow())
2624            {
2625                console.info("logMessage contact_delete_test_4800: columnNames:" + resultSet.columnNames);
2626                console.info("logMessage contact_delete_test_4800: columnCount:" + resultSet.columnCount);
2627                console.info('logMessage contact_delete_test_4800: id = ' + resultSet.getString(0));
2628                console.info('logMessage contact_delete_test_4800: delete_time = ' + resultSet.getString(1));
2629                console.info('logMessage contact_delete_test_4800: display_name = ' + resultSet.getString(array_two));
2630                expect(resultSet.getString(array_two) == "xiaopeng").assertTrue();
2631            }
2632            resultSet.close();
2633        } catch (error) {
2634            console.info("logMessage contact_delete_test_4800: query error:" + error);
2635        }
2636    }
2637
2638    /**
2639     * @tc.number  contact_batchinsert_test_4900
2640     * @tc.name    Insert contacts in batches(raw_contact)
2641     * @tc.desc    Function test
2642     */
2643    it("contact_batchinsert_test_4900", 0, async function(done) {
2644        console.info("--------logMessage contact_batchinsert_test_4900 is starting!-------");
2645        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
2646        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
2647        try {
2648            var batchInsertCode = await dataShareHelper.batchInsert(rawContactUri, common.getContactBatchCompany());
2649            sleep(sleep_one);
2650            console.info("logMessage contact_batchinsert_test_4900: batchInsertCode = " + batchInsertCode);
2651            expect(batchInsertCode == 0).assertTrue();
2652            var resultColumns = [];
2653            let condition = new dataShare.DataSharePredicates();
2654            condition.equalTo("company", "TT4900");
2655            var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
2656            console.info(
2657                'contact_batchinsert_test_4900 : queryBatch start ! resultSet.rowCount = ' + resultSet.rowCount);
2658            expect(resultSet.rowCount == 5).assertEqual(true);
2659            resultSet.close();
2660            await deleteRawContact("contact_batchinsert_test_4900");
2661            done();
2662        } catch (error) {
2663            console.info("logMessage contact_batchinsert_test_4900: batchInsert error = " + error);
2664            done();
2665        }
2666    });
2667
2668    /**
2669     * @tc.number  contact_batchinsert_test_5000
2670     * @tc.name    Insert contact_data in batches of address book
2671     * @tc.desc    Function test
2672     */
2673    it("contact_batchinsert_test_5000", 0, async function(done) {
2674        console.info("--------logMessage contact_batchinsert_test_5000  start!-------");
2675        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
2676        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
2677        var rawContactValues = {"display_name" : "xiaozhi"};
2678        try {
2679            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
2680            sleep(sleep_one);
2681            console.info("logMessage contact_batchinsert_test_5000: rawContactId = " + rawContactId);
2682            expect(rawContactId > 0).assertTrue();
2683            await ContactDataBatchInsert();
2684            done();
2685        } catch (error) {
2686            console.info("logMessage contact_batchinsert_test_5000: raw_contact insert error = " + error);
2687            done();
2688        }
2689        async function ContactDataBatchInsert()
2690        {
2691            try {
2692                var batchInsertCode = await dataShareHelper.batchInsert(contactDataUri, common.getContactBatchCompanyTwo());
2693                sleep(sleep_one);
2694                console.info("logMessage contact_batchinsert_test_5000: batchInsertCode = " + batchInsertCode);
2695                expect(batchInsertCode == 0).assertTrue();
2696                var map = new Map();
2697                map.set("raw_contact_id", raw_contact_id.toString());
2698                await queryBatch(map, "contact_batchinsert_test_5000", 5);
2699                await deleteRawContact("contact_batchinsert_test_5000");
2700                done();
2701            } catch (error) {
2702                console.info("logMessage contact_batchinsert_test_5000: batchInsert error = " + error);
2703                done();
2704            }
2705        }
2706    });
2707
2708    /**
2709     * @tc.number  contact_batchinsert_test_5400
2710     * @tc.name    Batch operation of contact blocklist
2711     * @tc.desc    Function test
2712     */
2713    it("contact_batchinsert_test_5400", 0, async function(done) {
2714        console.info("--------logMessage contact_batchinsert_test_5400 is starting!-------");
2715        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
2716        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
2717        var phoneNumber = randomNum(13);
2718        try {
2719            var batchInsertCode = await dataShareHelper.batchInsert(contactBlocklistUri, common.getPhoneNumberBatch());
2720            sleep(sleep_one);
2721            console.info("logMessage contact_batchinsert_test_5400: batchInsertCode = " + batchInsertCode);
2722            expect(batchInsertCode == 0).assertTrue();
2723            await query(5);
2724            await BlocklistDelete();
2725            done();
2726        } catch (error) {
2727            console.info("logMessage contact_batchinsert_test_5400: batchInsert error = " + error);
2728            done();
2729        }
2730
2731        async function BlocklistDelete()
2732        {
2733            let condition = new dataShare.DataSharePredicates();
2734            condition.equalTo("phone_number", phoneNumber);
2735            try {
2736                var deleteCode = await dataShareHelper.delete(contactBlocklistUri, condition);
2737                console.info("logMessage contact_batchinsert_test_5400: deleteCode = " + deleteCode);
2738                expect(deleteCode == 0).assertTrue();
2739                await query(0);
2740                done();
2741            } catch (error) {
2742                console.info("logMessage contact_batchinsert_test_5400: delete error = " + error);
2743                done();
2744            }
2745        }
2746
2747        async function query(size)
2748        {
2749            var resultColumns = [];
2750            let condition = new dataShare.DataSharePredicates();
2751            condition.equalTo("phone_number", phoneNumber);
2752            try {
2753                var resultSet = await dataShareHelper.query(contactBlocklistUri, resultColumns, condition);
2754                sleep(sleep_one);
2755                console.info(
2756                    'contact_batchinsert_test_5400 : queryBatch start ! resultSet.rowCount = ' + resultSet.rowCount);
2757                expect(resultSet.rowCount == size).assertEqual(true);
2758                resultSet.close();
2759            } catch (error) {
2760                console.info(" contact_batchinsert_test_5400 logMessage resultSet.rowCount: error = " + error);
2761            }
2762        }
2763    });
2764
2765    /**
2766     * @tc.number  contact_update_test_5300
2767     * @tc.name    Bulk favorites and unfavorites of contacts
2768     * @tc.desc    Function test
2769     */
2770    it("contact_update_test_5300", 0, async function(done) {
2771        console.info("--------logMessage contact_update_test_5300 is starting!-------");
2772        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
2773        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
2774
2775        var rawContactValuesOne = {"display_name" : "fengyuan", "favorite" : 1};
2776        var rawContactValuesTwo = {"display_name" : "xiaoli", "favorite" : 1};
2777        var rawContactValuesThree = {"display_name" : "xiaoma", "favorite" : 1};
2778        var listAddBluk = []
2779        listAddBluk[0] = rawContactValuesOne;
2780        listAddBluk[1] = rawContactValuesTwo;
2781        listAddBluk[array_two] = rawContactValuesThree;
2782        try {
2783            var batchInsertCode = await dataShareHelper.batchInsert(rawContactUri, listAddBluk);
2784            sleep(sleep_one);
2785            console.info("logMessage contact_update_test_5300: batchInsertCode = " + batchInsertCode);
2786            expect(batchInsertCode == 0).assertTrue();
2787            await RawContactUpdateUnFavorites(dataShareHelper);
2788            await queryUnFavorites(dataShareHelper);
2789            await deleteRawContact("contact_update_test_5300");
2790            done();
2791        } catch (error) {
2792            console.info("logMessage contact_update_test_5300: batchInsert error = " + error);
2793            done();
2794        }
2795    });
2796
2797    async function RawContactUpdateUnFavorites(dataShareHelper)
2798    {
2799        var updateValues = {"favorite" : 0};
2800        let condition = new dataShare.DataSharePredicates();
2801        condition.equalTo("display_name", "fengyuan");
2802        condition.or();
2803        condition.equalTo("display_name", "xiaoma");
2804        try {
2805            var updateCode = await dataShareHelper.update(rawContactUri, updateValues, condition);
2806            sleep(sleep_one);
2807            console.info("logMessage contact_update_test_5300: updateCode = " + updateCode);
2808            expect(updateCode == 0).assertTrue();
2809        } catch (error) {
2810            console.info("logMessage contact_update_test_5300: update error = " + error);
2811        }
2812    }
2813
2814    async function queryUnFavorites(dataShareHelper)
2815    {
2816        var resultColumns = [];
2817        let condition = new dataShare.DataSharePredicates();
2818        condition.equalTo("display_name", "fengyuan");
2819        condition.or();
2820        condition.equalTo("display_name", "xiaoma");
2821        try {
2822            var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
2823            sleep(sleep_one);
2824            console.info('contact_update_test_5300 : queryBatch start ! resultSet.rowCount = ' + resultSet.rowCount);
2825            expect(resultSet.rowCount == array_two).assertEqual(true);
2826            if (resultSet.rowCount > 0) {
2827                if (resultSet.goToFirstRow()) {
2828                    do {
2829                        var dbresult = resultSet.getString(resultSet.getColumnIndex("favorite"));
2830                        console.info(' contact_update_test_5300 :logMessage contactsQuery dbresult :' + dbresult +
2831                                     ' value : ' + value);
2832                        expect(dbresult == "0").assertEqual(true);
2833                    } while (resultSet.goToNextRow());
2834                }
2835            }
2836            resultSet.close();
2837        } catch (error) {
2838            console.info(" contact_update_test_5300 logMessage resultSet.rowCount: error = " + error);
2839        }
2840    }
2841
2842    /**
2843     * @tc.number  contact_batchinsert_test_5500
2844     * @tc.name    Contacts are added to and removed from groups in batches
2845     * @tc.desc    Function test
2846     */
2847    it("contact_batchinsert_test_5500", 0, async function(done) {
2848        console.info("--------logMessage contact_batchinsert_test_5500 is starting!-------");
2849        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
2850        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
2851        var groupValues = {"group_name" : "ManagerGroup"};
2852        try {
2853            var groupId = await dataShareHelper.insert(groupUri, groupValues);
2854            console.info("logMessage contact_batchinsert_test_5500: groupId = " + groupId);
2855            expect(groupId > 0).assertTrue();
2856        } catch (error) {
2857            console.info("logMessage contact_batchinsert_test_5500: group insert error = " + error);
2858            done();
2859        }
2860
2861        try {
2862            var rawContactValues1 = {"display_name" : "xiaohuang"};
2863            var rawContactIdOne = await dataShareHelper.insert(rawContactUri, rawContactValues1);
2864            console.info("logMessage contact_batchinsert_test_5500: rawContactIdOne = " + rawContactIdOne);
2865            expect(rawContactIdOne > 0).assertTrue();
2866        } catch (error) {
2867            console.info("logMessage contact_batchinsert_test_5500: raw_contact_1 insert error = " + error);
2868            done();
2869        }
2870
2871        try {
2872            var rawContactValues2 = {"display_name" : "xiaolv"};
2873            var rawContactIdTwo = await dataShareHelper.insert(rawContactUri, rawContactValues2);
2874            console.info("logMessage contact_batchinsert_test_5500: rawContactIdTwo = " + rawContactIdTwo);
2875            expect(rawContactIdTwo > 0).assertTrue();
2876        } catch (error) {
2877            console.info("logMessage contact_batchinsert_test_5500: raw_contact_2 insert error = " + error);
2878            done();
2879        }
2880
2881        try {
2882            var rawContactValues3 = {"display_name" : "xiaobai"};
2883            var rawContactId3 = await dataShareHelper.insert(rawContactUri, rawContactValues3);
2884            console.info("logMessage contact_batchinsert_test_5500: rawContactId3 = " + rawContactId3);
2885            expect(rawContactId3 > 0).assertTrue();
2886        } catch (error) {
2887            console.info("logMessage contact_batchinsert_test_5500: raw_contact_3 insert error = " + error);
2888            done();
2889        }
2890        await threeDataInsert(dataShareHelper, rawContactIdOne, rawContactIdTwo, rawContactId3, groupId);
2891        await deleteRawContact("contact_batchinsert_test_5500");
2892        await deleteAll(groupUri, "contact_batchinsert_test_5500");
2893        await deleteAll(contactDataUri, "contact_batchinsert_test_5500");
2894        done();
2895    });
2896
2897    async function threeDataInsert(dataShareHelper, rawContactIdOne, rawContactIdTwo, rawContactId3, groupId)
2898    {
2899        var contactDataValues1 = {
2900            "raw_contact_id" : rawContactIdOne,
2901            "content_type" : "group_membership",
2902            "detail_info" : groupId.toString()
2903        };
2904        var contactDataValues2 = {
2905            "raw_contact_id" : rawContactIdTwo,
2906            "content_type" : "group_membership",
2907            "detail_info" : groupId.toString()
2908        };
2909        var contactDataValues3 = {
2910            "raw_contact_id" : rawContactId3,
2911            "content_type" : "group_membership",
2912            "detail_info" : groupId.toString()
2913        };
2914        var listAddBluk = [];
2915        listAddBluk[0] = contactDataValues1;
2916        listAddBluk[1] = contactDataValues2;
2917        listAddBluk[array_two] = contactDataValues3;
2918        try {
2919            var batchInsertCode = await dataShareHelper.batchInsert(contactDataUri, listAddBluk);
2920            sleep(sleep_one);
2921            console.info("logMessage contact_batchinsert_test_5500: batchInsertCode = " + batchInsertCode);
2922            expect(batchInsertCode == 0).assertTrue();
2923            await ContactDataDelete(dataShareHelper, rawContactIdOne, rawContactId3);
2924        } catch (error) {
2925            console.info("logMessage contact_batchinsert_test_5500: batchInsert error = " + error);
2926        }
2927    }
2928
2929    async function ContactDataDelete(dataShareHelper, rawContactIdOne, rawContactId3)
2930    {
2931        let condition = new dataShare.DataSharePredicates();
2932        condition.equalTo("raw_contact_id", rawContactIdOne.toString());
2933        condition.or();
2934        condition.equalTo("raw_contact_id", rawContactId3.toString());
2935        try {
2936            var deleteCode = await dataShareHelper.delete(contactDataUri, condition);
2937            sleep(sleep_one);
2938            console.info("logMessage contact_batchinsert_test_5500: deleteCode = " + deleteCode);
2939            expect(deleteCode == 0).assertTrue();
2940            await queryTwoData(dataShareHelper, rawContactIdOne, rawContactId3);
2941        } catch (error) {
2942            console.info("logMessage contact_batchinsert_test_5500: delete error = " + error);
2943        }
2944    }
2945
2946    async function queryTwoData(dataShareHelper, rawContactIdOne, rawContactId3)
2947    {
2948        var resultColumns = [];
2949        let condition = new dataShare.DataSharePredicates();
2950        condition.equalTo("raw_contact_id", rawContactIdOne.toString());
2951        condition.or();
2952        condition.equalTo("raw_contact_id", rawContactId3.toString());
2953        try {
2954            var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
2955            sleep(sleep_one);
2956            console.info(
2957                'contact_batchinsert_test_5500 : queryBatch start ! resultSet.rowCount = ' + resultSet.rowCount);
2958            expect(resultSet.rowCount == 0).assertEqual(true);
2959            resultSet.close();
2960        } catch (error) {
2961            console.info(" contact_batchinsert_test_5500 logMessage resultSet.rowCount: error = " + error);
2962        }
2963    }
2964
2965    /**
2966     * @tc.number  contact_pinyin_query_test_200
2967     * @tc.name    Contact name to pinyin (Chinese Simplified)
2968     * @tc.desc    Function test
2969     */
2970    it("contact_pinyin_query_test_200", 0, async function(done) {
2971        console.info("--------logMessage contact_pinyin_query_test_200 is starting!-------");
2972        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
2973        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
2974
2975        var rawContactValues = {"display_name" : "小黄"};
2976        try {
2977            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
2978            console.info('logMessage contact_pinyin_query_test_200 rawContactId = ' + rawContactId);
2979            expect(rawContactId > 0).assertTrue();
2980            await ContactDataInsert();
2981            await deleteRawContact("contact_pinyin_query_test_200");
2982            await deleteAll(contactDataUri, "contact_pinyin_query_test_200");
2983            done();
2984        } catch (error) {
2985            console.info("logMessage contact_pinyin_query_test_200: raw_contact insert error = " + error);
2986            done();
2987        }
2988
2989        async function ContactDataInsert()
2990        {
2991            var contactDataValues = {
2992                "raw_contact_id" : rawContactId,
2993                "content_type" : "name",
2994                "detail_info" : "xiaohuang"
2995            };
2996            try {
2997                var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
2998                console.info('logMessage contact_pinyin_query_test_200 contactDataId = ' + contactDataId);
2999                expect(contactDataId > 0).assertTrue();
3000                await SearchQuery(dataShareHelper, rawContactId);
3001            } catch (error) {
3002                console.info('logMessage contact_pinyin_query_test_200 contact_data insert error = ' + error);
3003                done();
3004            }
3005        }
3006    });
3007
3008    async function SearchQuery(dataShareHelper, rawContactId)
3009    {
3010        var resultColumns = [ "id", "search_name" ];
3011        let condition = new dataShare.DataSharePredicates();
3012        condition.equalTo("raw_contact_id", rawContactId.toString());
3013        try {
3014            var resultSet = await dataShareHelper.query(searchContactUri, resultColumns, condition);
3015            var map = common.getSearchMap();
3016            map.set("raw_contact_id", rawContactId.toString());
3017            if (resultSet.goToFirstRow()) {
3018                do {
3019                    for (var [key, value] of map) {
3020                        let dbresult = resultSet.getString(resultSet.getColumnIndex(key));
3021                        console.info(tag + ':contact_pinyin_query_test_200 key = ' + key + ' dbresult :' + dbresult +
3022                                     ' value : ' + value);
3023                        expect(value == dbresult).assertEqual(true);
3024                    }
3025                } while (resultSet.goToNextRow());
3026            }
3027            resultSet.close();
3028        } catch (error) {
3029            console.info('logMessage contact_pinyin_query_test_200 query error = ' + error);
3030        }
3031    }
3032
3033    /**
3034     * @tc.number  contact_pinyin_query_test_100
3035     * @tc.name    Contact name to pinyin (Chinese Traditional)
3036     * @tc.desc    Function test
3037     */
3038    it("contact_pinyin_query_test_100", 0, async function(done) {
3039        console.info("--------logMessage contact_pinyin_query_test_100 is starting!-------");
3040        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3041        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3042
3043        var rawContactValues = {"display_name" : "鍵盤"};
3044        try {
3045            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3046            sleep(sleep_one);
3047            console.info('logMessage contact_pinyin_query_test_100 rawContactId = ' + rawContactId);
3048            expect(rawContactId > 0).assertTrue();
3049            await ContactDataInsert();
3050            await deleteRawContact("contact_pinyin_query_test_100");
3051            await deleteAll(contactDataUri, "contact_pinyin_query_test_100");
3052            done();
3053        } catch (error) {
3054            console.info('logMessage contact_pinyin_query_test_100 raw_contact insert error = ' + error);
3055            done();
3056        }
3057
3058        async function ContactDataInsert()
3059        {
3060            var contactDataValues = {"raw_contact_id" : rawContactId, "content_type" : "name", "detail_info" : "鍵盤"};
3061            try {
3062                var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
3063                sleep(sleep_one);
3064                console.info('logMessage contact_pinyin_query_test_100 contactDataId = ' + contactDataId);
3065                expect(contactDataId > 0).assertTrue();
3066                await SearchContactQueryChinese(dataShareHelper, rawContactId);
3067            } catch (error) {
3068                console.info('logMessage contact_pinyin_query_test_100 contact_data insert error = ' + error);
3069                done();
3070            }
3071        }
3072    });
3073
3074    async function SearchContactQueryChinese(dataShareHelper, rawContactId)
3075    {
3076        var resultColumns = [ "raw_contact_id", "search_name" ];
3077        let condition = new dataShare.DataSharePredicates();
3078        condition.equalTo("raw_contact_id", rawContactId.toString());
3079        try {
3080            var resultSet = await dataShareHelper.query(searchContactUri, resultColumns, condition);
3081            if (resultSet.goToFirstRow()) {
3082                do {
3083                    console.info('logMessage contact_pinyin_query_test_100: id = ' + resultSet.getString(0));
3084                    expect(resultSet.getString(0) == rawContactId.toString()).assertEqual(true);
3085                    console.info('logMessage contact_pinyin_query_test_100: search_name = ' + resultSet.getString(1));
3086                    expect(resultSet.getString(1) == "鍵盤||jianpan||jp").assertEqual(true);
3087                } while (resultSet.goToNextRow());
3088            }
3089            resultSet.close();
3090        } catch (error) {
3091            console.info('logMessage contact_pinyin_query_test_100 query error = ' + error);
3092        }
3093    }
3094
3095    /**
3096     * @tc.number  contact_pinyin_query_test_300
3097     * @tc.name    Contact name to pinyin (English)
3098     * @tc.desc    Function test
3099     */
3100    it("contact_pinyin_query_test_300", 0, async function(done) {
3101        console.info("--------logMessage contact_pinyin_query_test_300 is starting!-------");
3102        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3103        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3104
3105        var rawContactValues = {"display_name" : "Tom"};
3106        try {
3107            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3108            sleep(sleep_one);
3109            console.info('logMessage contact_pinyin_query_test_300 rawContactId = ' + rawContactId);
3110            expect(rawContactId > 0).assertTrue();
3111            await ContactDataInsert();
3112            await deleteRawContact("contact_pinyin_query_test_300");
3113            done();
3114        } catch (error) {
3115            console.info('logMessage contact_pinyin_query_test_300 raw_contact insert error = ' + error);
3116            done();
3117        }
3118
3119        async function ContactDataInsert()
3120        {
3121            var contactDataValues = {"raw_contact_id" : rawContactId, "content_type" : "name", "detail_info" : "Tom"};
3122            try {
3123                var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
3124                console.info('logMessage contact_pinyin_query_test_300 contactDataId = ' + contactDataId);
3125                expect(contactDataId > 0).assertTrue();
3126                await SearchContactQuery(dataShareHelper, rawContactId);
3127            } catch (error) {
3128                console.info('logMessage contact_pinyin_query_test_300 contact_data insert error = ' + error);
3129                done();
3130            }
3131        }
3132    });
3133
3134    async function SearchContactQuery(dataShareHelper, rawContactId)
3135    {
3136        var resultColumns = [ "raw_contact_id", "search_name" ];
3137        let condition = new dataShare.DataSharePredicates();
3138        condition.equalTo("raw_contact_id", rawContactId.toString());
3139        try {
3140            var resultSet = await dataShareHelper.query(searchContactUri, resultColumns, condition);
3141            if (resultSet.goToFirstRow()) {
3142                do {
3143                    console.info('logMessage contact_pinyin_query_test_300: id = ' + resultSet.getString(0));
3144                    expect(resultSet.getString(0) == rawContactId.toString()).assertTrue();
3145                    console.info('logMessage contact_pinyin_query_test_300: search_name = ' + resultSet.getString(1));
3146                    expect(resultSet.getString(1) == "Tom||Tom||Tom").assertTrue();
3147                } while (resultSet.goToNextRow());
3148            }
3149            resultSet.close();
3150        } catch (error) {
3151            console.info('logMessage contact_pinyin_query_test_300 query error = ' + error);
3152        }
3153    }
3154
3155    /**
3156     * @tc.number  contact_fuzzyquery_test_400
3157     * @tc.name    Contact fuzzy search query interface (name)
3158     * @tc.desc    Function test
3159     */
3160    it("contact_fuzzyquery_test_400", 0, async function(done) {
3161        console.info("--------logMessage contact_fuzzyquery_test_400 is starting!-------");
3162        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3163        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3164
3165        var rawContactValues = {"display_name" : "400xiaoming400"};
3166        try {
3167            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3168            sleep(sleep_one);
3169            console.info('logMessage contact_fuzzyquery_test_400 rawContactId = ' + rawContactId);
3170            expect(rawContactId > 0).assertTrue();
3171            await RawContactNameQuery();
3172            await deleteRawContact("contact_fuzzyquery_test_400");
3173            done();
3174        } catch (error) {
3175            console.info('logMessage contact_fuzzyquery_test_400 raw_contact insert error = ' + error);
3176            done();
3177        }
3178
3179        async function RawContactNameQuery()
3180        {
3181            var resultColumns = [ "id", "display_name" ];
3182            let condition = new dataShare.DataSharePredicates();
3183            condition.like("display_name", "%xiaoming40%");
3184            condition.and();
3185            condition.equalTo("is_deleted", "0");
3186            try {
3187                var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
3188                if (resultSet.goToFirstRow()) {
3189                    do {
3190                        console.info('logMessage contact_fuzzyquery_test_400: id = ' + resultSet.getString(0));
3191                        expect(resultSet.getString(0) == rawContactId.toString()).assertEqual(true);
3192                        console.info(
3193                            'logMessage contact_fuzzyquery_test_400: display_name = ' + resultSet.getString(1));
3194                        expect(resultSet.getString(1) == "400xiaoming400").assertEqual(true);
3195                    } while (resultSet.goToNextRow());
3196                }
3197                resultSet.close();
3198            } catch (error) {
3199                console.info('logMessage contact_fuzzyquery_test_400 query error = ' + error);
3200                done();
3201            }
3202        }
3203    });
3204
3205    /**
3206     * @tc.number  contact_fuzzyquery_test_500
3207     * @tc.name    Contact fuzzy search query interface (name pinyin, pinyin name)
3208     * @tc.desc    Function test
3209     */
3210    it("contact_fuzzyquery_test_500", 0, async function(done) {
3211        console.info("--------logMessage contact_fuzzyquery_test_500 is starting!-------");
3212        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3213        var rawContactValues = {"display_name" : "500xiaoming500", "phonetic_name" : "500xiaoming500||xm"};
3214        try {
3215            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3216            sleep(sleep_one);
3217            console.info('logMessage contact_fuzzyquery_test_500 rawContactId = ' + rawContactId);
3218            expect(rawContactId > 0).assertTrue();
3219            await RawContactPhoneticNameQuery();
3220            await deleteRawContact("contact_fuzzyquery_test_500");
3221            done();
3222        } catch (error) {
3223            console.info('logMessage contact_fuzzyquery_test_500 raw_contact insert error = ' + error);
3224            done();
3225        }
3226
3227        async function RawContactPhoneticNameQuery()
3228        {
3229            var resultColumns = [ "id", "display_name", "phonetic_name" ];
3230            let condition = new dataShare.DataSharePredicates();
3231            condition.like("phonetic_name", "%xiaoming%");
3232            condition.and();
3233            condition.equalTo("is_deleted", "0");
3234            condition.or();
3235            condition.like("phonetic_name", "%xm%");
3236            condition.and();
3237            condition.equalTo("is_deleted", "0");
3238            try {
3239                var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
3240                if (resultSet.goToFirstRow()) {
3241                    do {
3242                        console.info('logMessage contact_fuzzyquery_test_500: id = ' + resultSet.getString(0));
3243                        expect(resultSet.getString(0) == rawContactId.toString()).assertTrue();
3244                        console.info(
3245                            'logMessage contact_fuzzyquery_test_500: display_name = ' + resultSet.getString(1));
3246                        expect(resultSet.getString(1) == "500xiaoming500").assertTrue();
3247                        console.info(
3248                            'logMessage contact_fuzzyquery_test_500: phonetic_name = ' + resultSet.getString(array_two));
3249                        expect(resultSet.getString(array_two) == "500xiaoming500||xm").assertTrue();
3250                    } while (resultSet.goToNextRow());
3251                }
3252                resultSet.close();
3253            } catch (error) {
3254                console.info('logMessage contact_fuzzyquery_test_500 query error = ' + error);
3255                done();
3256            }
3257        }
3258    });
3259
3260    /**
3261     * @tc.number  contact_fuzzyquery_test_600
3262     * @tc.name    Contact fuzzy search query interface (company, position)
3263     * @tc.desc    Function test
3264     */
3265    it("contact_fuzzyquery_test_600", 0, async function(done) {
3266        console.info("--------logMessage contact_fuzzyquery_test_600 is starting!-------");
3267        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3268        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3269
3270        var rawContactValues = {"display_name" : "xiaoming", "company" : "TT600", "position" : "Testers600"};
3271        try {
3272            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3273            sleep(sleep_one);
3274            console.info('logMessage contact_fuzzyquery_test_600 rawContactId = ' + rawContactId);
3275            expect(rawContactId > 0).assertTrue();
3276            await RawContactCompanyQuery(dataShareHelper, rawContactId);
3277            await deleteRawContact("contact_fuzzyquery_test_600");
3278            done();
3279        } catch (error) {
3280            console.info('logMessage contact_fuzzyquery_test_600 raw_contact insert error = ' + error);
3281            done();
3282        }
3283    });
3284
3285    async function RawContactCompanyQuery(dataShareHelper, rawContactId)
3286    {
3287        var resultColumns = [ "id", "display_name", "company", "position" ];
3288        let condition = new dataShare.DataSharePredicates();
3289        condition.like("company", "%TT6%");
3290        condition.and();
3291        condition.equalTo("is_deleted", "0");
3292        condition.or();
3293        condition.like("position", "%Testers6%");
3294        condition.and();
3295        condition.equalTo("is_deleted", "0");
3296        try {
3297            var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
3298            if (resultSet.goToFirstRow()) {
3299                do {
3300                    console.info('logMessage contact_fuzzyquery_test_600: id = ' + resultSet.getString(0));
3301                    expect(resultSet.getString(0) == rawContactId.toString()).assertEqual(true);
3302                    console.info('logMessage contact_fuzzyquery_test_600: display_name = ' + resultSet.getString(1));
3303                    expect(resultSet.getString(1) == "xiaoming").assertEqual(true);
3304                    console.info('logMessage contact_fuzzyquery_test_600: company = ' + resultSet.getString(array_two));
3305                    expect(resultSet.getString(array_two) == "TT600").assertEqual(true);
3306                    console.info('logMessage contact_fuzzyquery_test_600: position = ' + resultSet.getString(array_three));
3307                    expect(resultSet.getString(array_three) == "Testers600").assertEqual(true);
3308                } while (resultSet.goToNextRow());
3309            }
3310            resultSet.close();
3311        } catch (error) {
3312            console.info('logMessage contact_fuzzyquery_test_600 query error = ' + error);
3313        }
3314    }
3315
3316    /**
3317     * @tc.number  contact_fuzzyquery_test_700
3318     * @tc.name    Contact fuzzy search query interface (mobile phone number)
3319     * @tc.desc    Function test
3320     */
3321    it("contact_fuzzyquery_test_700", 0, async function(done) {
3322        console.info("--------logMessage contact_fuzzyquery_test_700 is starting!-------");
3323        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3324        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3325
3326        var rawContactValues = {"display_name" : "xiaoming"};
3327        try {
3328            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3329            sleep(sleep_one);
3330            console.info('logMessage contact_fuzzyquery_test_700 rawContactId = ' + rawContactId);
3331            expect(rawContactId > 0).assertTrue();
3332            await ContactDataPhoneInsert();
3333            await deleteRawContact("contact_fuzzyquery_test_700");
3334            await deleteAll(contactDataUri, "contact_fuzzyquery_test_700");
3335            done();
3336        } catch (error) {
3337            console.info('logMessage contact_fuzzyquery_test_700 raw_contact insert error = ' + error);
3338            done();
3339        }
3340
3341        async function ContactDataPhoneInsert()
3342        {
3343            var contactDataValues = {
3344                "raw_contact_id" : rawContactId,
3345                "content_type" : "phone",
3346                "detail_info" : "14528963"
3347            };
3348            try {
3349                var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
3350                sleep(sleep_one);
3351                console.info('logMessage contact_fuzzyquery_test_700 contactDataId  = ' + contactDataId);
3352                expect(contactDataId > 0).assertTrue();
3353                await fuzzyQueryPhone(dataShareHelper, rawContactId, contactDataId);
3354            } catch (error) {
3355                console.info('logMessage contact_fuzzyquery_test_700 contact_data insert error = ' + contactDataId);
3356                done();
3357            }
3358        }
3359    });
3360
3361    async function fuzzyQueryPhone(dataShareHelper, rawContactId, contactDataId)
3362    {
3363        var resultColumns = [ "id", "raw_contact_id", "detail_info" ];
3364        let condition = new dataShare.DataSharePredicates();
3365        // type_id = 5 data is phone
3366        condition.like("detail_info", "%52896%");
3367        condition.and();
3368        condition.equalTo("type_id", "5");
3369        try {
3370            var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
3371            sleep(sleep_one);
3372            if (resultSet.goToFirstRow()) {
3373                do {
3374                    console.info('logMessage contact_fuzzyquery_test_700: id = ' + resultSet.getString(0));
3375                    expect(resultSet.getString(0) == contactDataId.toString()).assertEqual(true);
3376                    console.info('logMessage contact_fuzzyquery_test_700: raw_contact_id = ' + resultSet.getString(1));
3377                    expect(resultSet.getString(1) == rawContactId.toString()).assertEqual(true);
3378                    console.info('logMessage contact_fuzzyquery_test_700: detail_info = ' + resultSet.getString(array_two));
3379                    expect(resultSet.getString(array_two) == "14528963").assertEqual(true);
3380                } while (resultSet.goToNextRow());
3381            }
3382            resultSet.close();
3383        } catch (error) {
3384            console.info('logMessage contact_fuzzyquery_test_700 query error = ' + error);
3385        }
3386    }
3387
3388    /**
3389     * @tc.number  contact_fuzzyquery_test_800
3390     * @tc.name    Contact fuzzy search query interface (nickname)
3391     * @tc.desc    Function test
3392     */
3393    it("contact_fuzzyquery_test_800", 0, async function(done) {
3394        console.info("--------logMessage contact_fuzzyquery_test_800 is starting!-------");
3395        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3396        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3397
3398        var rawContactValues = {"display_name" : "xiaoming"};
3399        try {
3400            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3401            sleep(sleep_one);
3402            console.info('logMessage contact_fuzzyquery_test_800 rawContactId = ' + rawContactId);
3403            expect(rawContactId > 0).assertTrue();
3404            await ContactNickNameInsert();
3405            await deleteRawContact("contact_fuzzyquery_test_800");
3406            await deleteAll(contactDataUri, "contact_fuzzyquery_test_800");
3407            done();
3408        } catch (error) {
3409            console.info('logMessage contact_fuzzyquery_test_800 raw_contact insert error = ' + error);
3410            done();
3411        }
3412
3413        async function ContactNickNameInsert()
3414        {
3415            var contactDataValues = {
3416                "raw_contact_id" : rawContactId,
3417                "content_type" : "nickname",
3418                "detail_info" : "daming"
3419            };
3420            try {
3421                var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
3422                console.info('logMessage contact_fuzzyquery_test_800 contactDataId = ' + contactDataId);
3423                expect(contactDataId > 0).assertTrue();
3424                await fuzzyQueryPhoneNickName(dataShareHelper, rawContactId, contactDataId);
3425            } catch (error) {
3426                console.info('logMessage contact_fuzzyquery_test_800 contact_data insert error = ' + contactDataId);
3427                done();
3428            }
3429        }
3430    });
3431
3432    async function fuzzyQueryPhoneNickName(dataShareHelper, rawContactId, contactDataId)
3433    {
3434        var resultColumns = [ "id", "raw_contact_id", "detail_info" ];
3435        let condition = new dataShare.DataSharePredicates();
3436        // type_id = 3 data is nickname
3437        condition.like("detail_info", "%daming%");
3438        condition.and();
3439        condition.equalTo("type_id", "3");
3440        try {
3441            var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
3442            sleep(sleep_one);
3443            if (resultSet.goToFirstRow()) {
3444                do {
3445                    console.info('logMessage contact_fuzzyquery_test_800: id = ' + resultSet.getString(0));
3446                    expect(resultSet.getString(0) == contactDataId.toString()).assertTrue();
3447                    console.info('logMessage contact_fuzzyquery_test_800: raw_contact_id = ' + resultSet.getString(1));
3448                    expect(resultSet.getString(1) == rawContactId.toString()).assertTrue();
3449                    console.info('logMessage contact_fuzzyquery_test_800: detail_info = ' + resultSet.getString(array_two));
3450                    expect(resultSet.getString(array_two) == "daming").assertTrue();
3451                } while (resultSet.goToNextRow());
3452            }
3453            resultSet.close();
3454        } catch (error) {
3455            console.info('logMessage contact_fuzzyquery_test_800 query error = ' + error);
3456        }
3457    }
3458    /**
3459     * @tc.number  contact_fuzzyquery_test_900
3460     * @tc.name    Contact fuzzy search query interface (mailbox)
3461     * @tc.desc    Function test
3462     */
3463    it("contact_fuzzyquery_test_900", 0, async function(done) {
3464        console.info("--------logMessage contact_fuzzyquery_test_900 is starting!-------");
3465        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3466        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3467
3468        var rawContactValues = {"display_name" : "xiaoming"};
3469        try {
3470            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3471            sleep(sleep_one);
3472            console.info('logMessage contact_fuzzyquery_test_900 rawContactId = ' + rawContactId);
3473            expect(rawContactId > 0).assertTrue();
3474            await ContactDataEmailInsert();
3475            await deleteRawContact("contact_fuzzyquery_test_900");
3476            await deleteAll(contactDataUri, "contact_fuzzyquery_test_900");
3477            done();
3478        } catch (error) {
3479            console.info('logMessage contact_fuzzyquery_test_900 raw_contact insert error = ' + error);
3480            done();
3481        }
3482
3483        async function ContactDataEmailInsert()
3484        {
3485            var contactDataValues = {
3486                "raw_contact_id" : rawContactId,
3487                "content_type" : "email",
3488                "detail_info" : "1564@163.com"
3489            };
3490            try {
3491                var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
3492                console.info('logMessage contact_fuzzyquery_test_900 ; = ' + contactDataId);
3493                expect(contactDataId > 0).assertTrue();
3494                await fuzzyQueryEmail(dataShareHelper, rawContactId, contactDataId);
3495            } catch (error) {
3496                console.info('logMessage contact_fuzzyquery_test_900 contact_data insert error = ' + error);
3497                done();
3498            }
3499        }
3500    });
3501
3502    async function fuzzyQueryEmail(dataShareHelper, rawContactId, contactDataId)
3503    {
3504        var resultColumns = [ "id", "raw_contact_id", "detail_info" ];
3505        let condition = new dataShare.DataSharePredicates();
3506        // type_id = 1 data is email
3507        condition.like("detail_info", "%1564%");
3508        condition.and();
3509        condition.equalTo("type_id", "1");
3510        try {
3511            var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
3512            sleep(sleep_one);
3513            if (resultSet.goToFirstRow()) {
3514                do {
3515                    console.info('logMessage contact_fuzzyquery_test_900: id = ' + resultSet.getString(0));
3516                    expect(resultSet.getString(0) == contactDataId.toString()).assertTrue();
3517                    console.info('logMessage contact_fuzzyquery_test_900: raw_contact_id = ' + resultSet.getString(1));
3518                    expect(resultSet.getString(1) == rawContactId.toString()).assertTrue();
3519                    console.info('logMessage contact_fuzzyquery_test_900: detail_info = ' + resultSet.getString(array_two));
3520                    expect(resultSet.getString(array_two) == "1564@163.com").assertTrue();
3521                } while (resultSet.goToNextRow());
3522            }
3523            resultSet.close();
3524        } catch (error) {
3525            console.info('logMessage contact_fuzzyquery_test_900 query error = ' + error);
3526        }
3527    }
3528
3529    /**
3530     * @tc.number  contact_fuzzyquery_test_1000
3531     * @tc.name    Contact fuzzy search query interface (residential)
3532     * @tc.desc    Function test
3533     */
3534    it("contact_fuzzyquery_test_1000", 0, async function(done) {
3535        console.info("--------logMessage contact_fuzzyquery_test_1000 is starting!-------");
3536        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3537        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3538
3539        var rawContactValues = {"display_name" : "xiaoming"};
3540        try {
3541            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3542            sleep(sleep_one);
3543            console.info('logMessage contact_fuzzyquery_test_1000 rawContactId = ' + rawContactId);
3544            expect(rawContactId > 0).assertTrue();
3545            await ContactDataPostalInsert();
3546            await deleteRawContact("contact_fuzzyquery_test_1000");
3547            await deleteAll(contactDataUri, "contact_fuzzyquery_test_1000");
3548            done();
3549        } catch (error) {
3550            console.info('logMessage contact_fuzzyquery_test_1000 raw_contact insert error = ' + error);
3551            done();
3552        }
3553
3554        async function ContactDataPostalInsert()
3555        {
3556            var contactDataValues = {
3557                "raw_contact_id" : rawContactId,
3558                "content_type" : "postal_address",
3559                "detail_info" : "nanjing1000"
3560            };
3561            try {
3562                var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
3563                sleep(sleep_one);
3564                console.info('logMessage contact_fuzzyquery_test_1000 contactDataId = ' + contactDataId);
3565                expect(contactDataId > 0).assertTrue();
3566                await fuzzyQueryAddress(dataShareHelper, rawContactId, contactDataId);
3567            } catch (error) {
3568                console.info('logMessage contact_fuzzyquery_test_1000 contact_data insert error = ' + error);
3569                done();
3570            }
3571        }
3572    });
3573
3574    async function fuzzyQueryAddress(dataShareHelper, rawContactId, contactDataId)
3575    {
3576        var resultColumns = [ "id", "raw_contact_id", "detail_info" ];
3577        let condition = new dataShare.DataSharePredicates();
3578        // type_id = 1 data is postal_address
3579        condition.like("detail_info", "%nanjing10%");
3580        condition.and();
3581        condition.equalTo("type_id", "7");
3582        try {
3583            var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
3584            sleep(sleep_one);
3585            if (resultSet.goToFirstRow()) {
3586                do {
3587                    console.info('logMessage contact_fuzzyquery_test_1000: id = ' + resultSet.getString(0));
3588                    expect(resultSet.getString(0) == contactDataId.toString()).assertTrue();
3589                    console.info('logMessage contact_fuzzyquery_test_1000: raw_contact_id = ' + resultSet.getString(1));
3590                    expect(resultSet.getString(1) == rawContactId.toString()).assertTrue();
3591                    console.info('logMessage contact_fuzzyquery_test_1000: detail_info = ' + resultSet.getString(array_two));
3592                    expect(resultSet.getString(array_two) == "nanjing1000").assertTrue();
3593                } while (resultSet.goToNextRow());
3594            }
3595            resultSet.close();
3596        } catch (error) {
3597            console.info('logMessage contact_fuzzyquery_test_1000: query error' + error);
3598        }
3599    }
3600
3601    /**
3602     * @tc.number  contact_fuzzyquery_test_1100
3603     * @tc.name    Contact fuzzy search query interface (remarks)
3604     * @tc.desc    Function test
3605     */
3606    it("contact_fuzzyquery_test_1100", 0, async function(done) {
3607        console.info("--------logMessage contact_fuzzyquery_test_1100 is starting!-------");
3608        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3609        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3610
3611        var rawContactValues = {"display_name" : "xiaoming"};
3612        try {
3613            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3614            sleep(sleep_one);
3615            console.info('logMessage contact_fuzzyquery_test_1100 rawContactId = ' + rawContactId);
3616            expect(rawContactId > 0).assertTrue();
3617            await ContactDataNoteInsert();
3618            await deleteRawContact("contact_fuzzyquery_test_1100");
3619            await deleteAll(contactDataUri, "contact_fuzzyquery_test_1100");
3620            done();
3621        } catch (error) {
3622            console.info('logMessage contact_fuzzyquery_test_1100 raw_contact insert error = ' + error);
3623            done();
3624        }
3625
3626        async function ContactDataNoteInsert()
3627        {
3628            var contactDataValues = {
3629                "raw_contact_id" : rawContactId,
3630                "content_type" : "note",
3631                "detail_info" : "java1100"
3632            };
3633            try {
3634                var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
3635                sleep(sleep_one);
3636                console.info('logMessage contact_fuzzyquery_test_1100 contactDataId = ' + contactDataId);
3637                expect(contactDataId > 0).assertTrue();
3638                await fuzzyQueryNote(dataShareHelper, rawContactId, contactDataId);
3639            } catch (error) {
3640                console.info('logMessage contact_fuzzyquery_test_1100 contact_data insert error = ' + error);
3641                done();
3642            }
3643        }
3644    });
3645
3646    async function fuzzyQueryNote(dataShareHelper, rawContactId, contactDataId)
3647    {
3648        var resultColumns = [ "id", "raw_contact_id", "detail_info" ];
3649        let condition = new dataShare.DataSharePredicates();
3650        // type_id = 10 data is note
3651        condition.like("detail_info", "%java11%");
3652        condition.and();
3653        condition.equalTo("type_id", "10");
3654        try {
3655            var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
3656            if (resultSet.goToFirstRow()) {
3657                do {
3658                    console.info('logMessage contact_fuzzyquery_test_1100: id = ' + resultSet.getString(0));
3659                    expect(resultSet.getString(0) == contactDataId.toString()).assertEqual(true);
3660                    console.info('logMessage contact_fuzzyquery_test_1100: raw_contact_id = ' + resultSet.getString(1));
3661                    expect(resultSet.getString(1) == rawContactId.toString()).assertEqual(true);
3662                    console.info('logMessage contact_fuzzyquery_test_1100: detail_info = ' + resultSet.getString(array_two));
3663                    expect(resultSet.getString(array_two) == "java1100").assertEqual(true);
3664                } while (resultSet.goToNextRow());
3665            }
3666            resultSet.close();
3667        } catch (error) {
3668            console.info('logMessage contact_fuzzyquery_test_1100: query error' + error);
3669        }
3670    }
3671
3672    /**
3673     * @tc.number  contact_fuzzyquery_test_1200
3674     * @tc.name    Contact fuzzy search query interface (AIM)
3675     * @tc.desc    Function test
3676     */
3677    it("contact_fuzzyquery_test_1200", 0, async function(done) {
3678        console.info("--------logMessage contact_fuzzyquery_test_1200 is starting!-------");
3679        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3680        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3681
3682        var rawContactValues = {"display_name" : "xiaoming"};
3683        try {
3684            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3685            console.info('logMessage contact_fuzzyquery_test_1200 rawContactId = ' + rawContactId);
3686            expect(rawContactId > 0).assertTrue();
3687            await ContactDataAimInsert();
3688            await deleteRawContact("contact_fuzzyquery_test_1200");
3689            await deleteAll(contactDataUri, "contact_fuzzyquery_test_1200");
3690            done();
3691        } catch (error) {
3692            console.info('logMessage contact_fuzzyquery_test_1200 raw_contact insert error = ' + error);
3693            done();
3694        }
3695
3696        async function ContactDataAimInsert()
3697        {
3698            var contactDataValues = {
3699                "raw_contact_id" : rawContactId,
3700                "content_type" : "im",
3701                "detail_info" : "aaaa1200"
3702            };
3703            try {
3704                var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
3705                console.info('logMessage contact_fuzzyquery_test_1200 ; = ' + contactDataId);
3706                expect(contactDataId > 0).assertTrue();
3707                await fuzzyQueryIM(dataShareHelper, rawContactId, contactDataId);
3708            } catch (error) {
3709                console.info('logMessage contact_fuzzyquery_test_1200 contact_data insert error = ' + error);
3710                done();
3711            }
3712        }
3713    });
3714
3715    async function fuzzyQueryIM(dataShareHelper, rawContactId, contactDataId)
3716    {
3717        var resultColumns = [ "id", "raw_contact_id", "detail_info" ];
3718        let condition = new dataShare.DataSharePredicates();
3719        // type_id = 10 data is im account number
3720        condition.like("detail_info", "%aa12%");
3721        condition.and();
3722        condition.equalTo("type_id", "2");
3723        try {
3724            var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
3725            if (resultSet.goToFirstRow()) {
3726                do {
3727                    console.info('logMessage contact_fuzzyquery_test_1200: id = ' + resultSet.getString(0));
3728                    expect(resultSet.getString(0) == contactDataId.toString()).assertEqual(true);
3729                    console.info('logMessage contact_fuzzyquery_test_1200: raw_contact_id = ' + resultSet.getString(1));
3730                    expect(resultSet.getString(1) == rawContactId.toString()).assertEqual(true);
3731                    console.info('logMessage contact_fuzzyquery_test_1200: detail_info = ' + resultSet.getString(array_two));
3732                    expect(resultSet.getString(array_two) == "aaaa1200").assertEqual(true);
3733                } while (resultSet.goToNextRow());
3734            }
3735            resultSet.close();
3736        } catch (error) {
3737            console.info('logMessage contact_fuzzyquery_test_1200: query error' + error);
3738        }
3739    }
3740
3741    /**
3742     * @tc.number  abnormal_contact_insert_test_200
3743     * @tc.name    Abnormal use case, an incorrect field is passed in when inserting
3744     * @tc.desc    Function test
3745     */
3746    it("abnormal_contact_insert_test_200", 0, async function(done) {
3747        console.info("------------abnormal_contact_insert_test_200 is starting!-----------");
3748        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3749        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3750
3751        var rawContactValues = {"display_names" : "xiaoshan"};
3752        try {
3753            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3754            console.info("logMessage abnormal_contact_insert_test_200: rawContactId = " + rawContactId);
3755            expect(rawContactId).assertEqual(-1);
3756            done();
3757        } catch (error) {
3758            console.info('logMessage abnormal_contact_insert_test_200: raw_contact insert error' + error);
3759            done();
3760        }
3761    });
3762
3763    /**
3764     * @tc.number  abnormal_contact_insert_test_300
3765     * @tc.name    Abnormal use case, an incorrect table name is passed in when inserting
3766     * @tc.desc    Function test
3767     */
3768    it("abnormal_contact_insert_test_300", 0, async function(done) {
3769        console.info("------------abnormal_contact_insert_test_300 is starting!-----------");
3770        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3771        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3772        var errorUri = "datashare:///com.ohos.calllogability/contacts/raw_contacts";
3773
3774        var rawContactValues = {"display_name" : "xiaoshan"};
3775        try {
3776            var rawContactId = await dataShareHelper.insert(errorUri, rawContactValues);
3777            console.info("logMessage abnormal_contact_insert_test_300: rawContactId = " + rawContactId);
3778            expect(rawContactId == -1).assertTrue();
3779            done();
3780        } catch (error) {
3781            console.info('logMessage abnormal_contact_insert_test_300: raw_contact insert error' + error);
3782            done();
3783        }
3784    });
3785
3786    /**
3787     * @tc.number  abnormal_contact_update_test_1100
3788     * @tc.name    Abnormal use case, an incorrect field is passed in when updating
3789     * @tc.desc    Function test
3790     */
3791    it("abnormal_contact_update_test_1100", 0, async function(done) {
3792        console.info("------------abnormal_contact_update_test_1100 is starting!-----------");
3793        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3794        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3795
3796        var rawContactValues = {"display_name" : "xiaoshan"};
3797        try {
3798            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3799            console.info("logMessage abnormal_contact_update_test_1100: rawContactId = " + rawContactId);
3800            expect(rawContactId > 0).assertTrue();
3801            await AbnormalUpdate();
3802            await deleteRawContact("abnormal_contact_update_test_1100");
3803            done();
3804        } catch (error) {
3805            console.info('logMessage abnormal_contact_update_test_1100: raw_contact insert error' + error);
3806            done();
3807        }
3808
3809        async function AbnormalUpdate()
3810        {
3811            var updateValues = {"display_names" : "xiaosan"};
3812            let condition = new dataShare.DataSharePredicates();
3813            condition.equalTo("ids", rawContactId.toString());
3814            try {
3815                var updataCode = await dataShareHelper.update(rawContactUri, updateValues, condition)
3816                console.info("logMessage abnormal_contact_update_test_1100: updataCode = " + updataCode);
3817                expect(updataCode == -1).assertTrue();
3818                var map = new Map();
3819                map.set("id", rawContactId.toString());
3820                map.set("display_name", "xiaoshan");
3821                await contactsQuery(map, "abnormal_contact_update_test_1100", rawContactUri);
3822            } catch (error) {
3823                console.info('logMessage abnormal_contact_update_test_1100: update error' + error);
3824                done();
3825            }
3826        }
3827    });
3828
3829    /**
3830     * @tc.number  abnormal_contact_update_test_1000
3831     * @tc.name    Abnormal use case, an incorrect table name is passed in when updating
3832     * @tc.desc    Function test
3833     */
3834    it("abnormal_contact_update_test_1000", 0, async function(done) {
3835        console.info("------------abnormal_contact_update_test_1000 is starting!-----------");
3836        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3837        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3838        var errorUri = "datashare:///com.ohos.calllogability/contacts/raw_contacts";
3839
3840        var rawContactValues = {"display_name" : "xiaoshan"};
3841        try {
3842            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3843            console.info("logMessage abnormal_contact_update_test_1000: rawContactId = " + rawContactId);
3844            expect(rawContactId > 0).assertTrue();
3845            await AbnormalUpdate();
3846            await deleteRawContact("abnormal_contact_update_test_1000");
3847            done();
3848        } catch (error) {
3849            console.info('logMessage abnormal_contact_update_test_1000: raw_contact insert error' + error);
3850            done();
3851        }
3852
3853        async function AbnormalUpdate()
3854        {
3855            var updateValues = {"display_name" : "xiaosan"};
3856            let condition = new dataShare.DataSharePredicates();
3857            condition.equalTo("id", rawContactId.toString());
3858            try {
3859                var updataCode = await dataShareHelper.update(errorUri, updateValues, condition);
3860                console.info("logMessage abnormal_contact_update_test_1000: updataCode = " + updataCode);
3861                expect(updataCode == -1).assertTrue();
3862                var map = new Map();
3863                map.set("id", rawContactId.toString());
3864                map.set("display_name", "xiaoshan");
3865                await contactsQuery(map, "abnormal_contact_update_test_1000", rawContactUri);
3866            } catch (error) {
3867                console.info("logMessage abnormal_contact_update_test_1000: updata error = " + error);
3868                done();
3869            }
3870        }
3871    });
3872
3873    /**
3874     * @tc.number  abnormal_contact_delete_test_4500
3875     * @tc.name    Abnormal use case, an incorrect field is passed in when deleting
3876     * @tc.desc    Function test
3877     */
3878    it("abnormal_contact_delete_test_4500", 0, async function(done) {
3879        console.info("------------abnormal_contact_delete_test_4500 is starting!-----------");
3880        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3881        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3882
3883        var rawContactValues = {"display_name" : "xiaozhi"};
3884        try {
3885            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3886            console.info("logMessage abnormal_contact_delete_test_4500: rawContactId = " + rawContactId);
3887            expect(rawContactId > 0).assertTrue();
3888            await AbnormalDelete();
3889            await deleteRawContact("abnormal_contact_delete_test_4500");
3890            done();
3891        } catch (error) {
3892            console.info('logMessage abnormal_contact_delete_test_4500: raw_contact insert error' + error);
3893            done();
3894        }
3895
3896        async function AbnormalDelete()
3897        {
3898            let condition = new dataShare.DataSharePredicates();
3899            condition.equalTo("ids", rawContactId.toString());
3900            try {
3901                var deleteCode = await dataShareHelper.delete(rawContactUri, condition);
3902                console.info("logMessage abnormal_contact_delete_test_4500: deleteCode = " + deleteCode);
3903                expect(deleteCode == -1).assertTrue();
3904                var map = new Map();
3905                map.set("id", rawContactId.toString());
3906                map.set("display_name", "xiaozhi");
3907                await contactsQuery(map, "abnormal_contact_delete_test_4500", rawContactUri);
3908                done();
3909            } catch (error) {
3910                console.info('logMessage abnormal_contact_delete_test_4500: delete error' + error);
3911                done();
3912            }
3913        }
3914    });
3915
3916    /**
3917     * @tc.number  abnormal_contact_delete_test_4600
3918     * @tc.name    Abnormal use case, an incorrect table name is passed in when deleting
3919     * @tc.desc    Function test
3920     */
3921    it("abnormal_contact_delete_test_4600", 0, async function(done) {
3922        console.info("------------abnormal_contact_delete_test_4600 is starting!-----------");
3923        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3924        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3925        var errorUri = "datashare:///com.ohos.calllogability/contacts/raw_contacts";
3926
3927        var rawContactValues = {"display_name" : "xiaoshan"};
3928        try {
3929            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3930            console.info("logMessage abnormal_contact_delete_test_4600: rawContactId = " + rawContactId);
3931            expect(rawContactId > 0).assertTrue();
3932            await AbnormalDelete();
3933            await deleteRawContact("abnormal_contact_delete_test_4600");
3934            done();
3935        } catch (error) {
3936            console.info('logMessage abnormal_contact_delete_test_4600: raw_contact insert error' + error);
3937            done();
3938        }
3939
3940        async function AbnormalDelete()
3941        {
3942            let condition = new dataShare.DataSharePredicates();
3943            condition.equalTo("id", rawContactId.toString());
3944            try {
3945                var deleteCode = await dataShareHelper.delete(errorUri, condition);
3946                console.info("logMessage abnormal_contact_delete_test_4600: deleteCode = " + deleteCode);
3947                expect(deleteCode == -1).assertTrue();
3948                var map = new Map();
3949                map.set("id", rawContactId.toString());
3950                map.set("display_name", "xiaoshan");
3951                await contactsQuery(map, "abnormal_contact_delete_test_4600", rawContactUri);
3952                done();
3953            } catch (error) {
3954                console.info('logMessage abnormal_contact_delete_test_4600: delete error' + error);
3955                done();
3956            }
3957        }
3958    });
3959
3960    /**
3961     * @tc.number  abnormal_contact_query_test_4200
3962     * @tc.name    Abnormal use case, an incorrect field is passed in when querying
3963     * @tc.desc    Function test
3964     */
3965    it("abnormal_contact_query_test_4200", 0, async function(done) {
3966        console.info("------------abnormal_contact_query_test_4200 is starting!-----------");
3967        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
3968        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
3969
3970        var rawContactValues = {"display_name" : "xiaozhicheng"};
3971        try {
3972            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
3973            console.info("logMessage abnormal_contact_query_test_4200: rawContactId = " + rawContactId);
3974            expect(rawContactId > 0).assertTrue();
3975            await AbnormalQuery();
3976            await deleteRawContact("abnormal_contact_query_test_4200");
3977            done();
3978        } catch (error) {
3979            console.info('logMessage abnormal_contact_query_test_4200: raw_contact insert error' + error);
3980            done();
3981        }
3982
3983        async function AbnormalQuery()
3984        {
3985            var resultColumns = [ "id", "display_name" ];
3986            let condition = new dataShare.DataSharePredicates();
3987            condition.equalTo("ids", rawContactId.toString());
3988            try {
3989                var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
3990                expect(resultSet.goToFirstRow()).assertEqual(false);
3991                console.info('logMessage abnormal_contact_query_test_4200: goToFirstRow' + resultSet.goToFirstRow());
3992                resultSet.close();
3993            } catch (error) {
3994                console.info('logMessage abnormal_contact_query_test_4200: query error = ' + error);
3995                done();
3996            }
3997        }
3998    });
3999
4000    /**
4001     * @tc.number  abnormal_contact_batchinsert_test_5100
4002     * @tc.name    Abnormal use cases, when adding data in batches, some of them failed, check the processing logic
4003     * @tc.desc    Function test
4004     */
4005    it("abnormal_contact_batchinsert_test_5100", 0, async function(done) {
4006        console.info("--------logMessage abnormal_contact_batchinsert_test_5100 is starting!------------");
4007        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4008        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4009
4010        var addBulk_value1 = {"display_name" : "zhangsan"};
4011        var addBulk_value2 = {"display_names" : "lisi"};
4012        var addBulk_value3 = {"display_name" : "wangwu"};
4013        var addBulk_value4 = {"display_names" : "laoliu"};
4014        var addBulk_value5 = {"display_name" : "xiaozhang"};
4015        var listAddBluk = [];
4016        listAddBluk[0] = addBulk_value1;
4017        listAddBluk[1] = addBulk_value2;
4018        listAddBluk[array_two] = addBulk_value3;
4019        listAddBluk[array_three] = addBulk_value4;
4020        listAddBluk[array_four] = addBulk_value5;
4021        try {
4022            var batchInsertCode = await dataShareHelper.batchInsert(rawContactUri, listAddBluk);
4023            console.info("logMessage abnormal_contact_batchinsert_test_5100: batchInsertCode = " + batchInsertCode);
4024            expect(batchInsertCode == -1).assertTrue();
4025            done();
4026        } catch (error) {
4027            console.info("logMessage abnormal_contact_batchinsert_test_5100: batch insert error = " + error);
4028            done();
4029        }
4030    });
4031
4032    /**
4033     * @tc.number  abnormal_contact_insert_data_5300
4034     * @tc.name    insert_data error no rawContactId
4035     * @tc.desc    Function test
4036     */
4037    it("abnormal_contact_insert_data_5300", 0, async function(done) {
4038        console.info("--------logMessage abnormal_contact_insert_data_5300 is starting!-------");
4039        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4040        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4041
4042        var rawContactValues = {"display_name" : "xiaotian"};
4043        try {
4044            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
4045            sleep(sleep_one);
4046            console.info('logMessage abnormal_contact_insert_data_5300 rawContactId = ' + rawContactId);
4047            expect(rawContactId > 0).assertTrue();
4048            await ContactDataAimInsert();
4049            await deleteRawContact("abnormal_contact_insert_data_5300");
4050            done();
4051        } catch (error) {
4052            console.info('logMessage abnormal_contact_insert_data_5300 raw_contact insert error = ' + error);
4053            done();
4054        }
4055
4056        async function ContactDataAimInsert()
4057        {
4058            var contactDataValues = {"content_type" : "im", "detail_info" : "aaaa"};
4059            try {
4060                var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
4061                console.info('logMessage abnormal_contact_insert_data_5300 ; = ' + contactDataId);
4062                expect(contactDataId == -1).assertTrue();
4063            } catch (error) {
4064                console.info('logMessage abnormal_contact_insert_data_5300 contact_data insert error = ' + error);
4065                done();
4066            }
4067        }
4068    });
4069
4070    /**
4071     * @tc.number  abnormal_contact_insert_data_5400
4072     * @tc.name    insert_data error no content_type
4073     * @tc.desc    Function test
4074     */
4075    it("abnormal_contact_insert_data_5400", 0, async function(done) {
4076        console.info("--------logMessage abnormal_contact_insert_data_5400 is starting!-------");
4077        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4078        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4079
4080        var rawContactValues = {"display_name" : "xiaotian"};
4081        try {
4082            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
4083            console.info('logMessage abnormal_contact_insert_data_5400 rawContactId = ' + rawContactId);
4084            expect(rawContactId > 0).assertTrue();
4085            await ContactDataAimInsert();
4086            await deleteRawContact("abnormal_contact_insert_data_5400");
4087            done();
4088        } catch (error) {
4089            console.info('logMessage abnormal_contact_insert_data_5400 raw_contact insert error = ' + error);
4090            done();
4091        }
4092
4093        async function ContactDataAimInsert()
4094        {
4095            var contactDataValues = {"raw_contact_id" : rawContactId, "detail_info" : "aaaa"};
4096            try {
4097                var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
4098                console.info('logMessage abnormal_contact_insert_data_5400 ; = ' + contactDataId);
4099                expect(contactDataId == -1).assertTrue();
4100            } catch (error) {
4101                console.info('logMessage abnormal_contact_insert_data_5400 contact_data insert error = ' + error);
4102                done();
4103            }
4104        }
4105    });
4106
4107    /**
4108     * @tc.number  contact_delete_test_5500
4109     * @tc.name    batchDelete
4110     * @tc.desc    Function test
4111     */
4112    it("contact_delete_test_5500", 0, async function(done) {
4113        console.info("--------logMessage contact_delete_test_5500 is starting!------------");
4114        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4115        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4116        try {
4117            var rawContactId = await dataShareHelper.insert(rawContactUri, common.getProfileRawContact());
4118            console.info("logMessage contact_delete_test_5500: rawContactId = " + rawContactId);
4119            expect(rawContactId > 0).assertTrue();
4120            var map = common.getProfileRawContactMap();
4121            map.set("id", rawContactId.toString());
4122            await contactsQuery(map, "contact_delete_test_5500", rawContactUri);
4123            await executeBatch();
4124        } catch (error) {
4125            console.info("logMessage contact_delete_test_5500:  insert error = " + error);
4126            done();
4127        }
4128        async function executeBatch()
4129        {
4130            let condition = new dataShare.DataSharePredicates();
4131            condition.equalTo("id", rawContactId.toString());
4132            dataShareHelper.executeBatch(URI_CONTACTS, [ {
4133                uri : rawContactUri,
4134                type : featureAbility.DataAbilityOperationType.TYPE_DELETE,
4135                predicates : condition,
4136                expectedCount : 0,
4137                PredicatesBackReferences : {},
4138                interrupted : true,
4139            } ],
4140                (error, data) => {
4141                    console.info("logMessage contact_delete_test_5500: executeBatch data = " + JSON.stringify(data));
4142                    console.info("logMessage contact_delete_test_5500: data_3 = " + data);
4143                    console.info("logMessage contact_delete_test_5500:  data_1= " + data[0].count);
4144                    expect(data[0].count == 0).assertTrue();
4145                    done();
4146                });
4147        }
4148    });
4149
4150    /**
4151     * @tc.number  contact_update_test_5600
4152     * @tc.name    batchUpdate
4153     * @tc.desc    Function test
4154     */
4155    it("contact_update_test_5600", 0, async function(done) {
4156        console.info("--------logMessage contact_update_test_5600 is starting!------------");
4157        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4158        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4159        try {
4160            var rawContactId = await dataShareHelper.insert(rawContactUri, common.getProfileRawContact());
4161            console.info("logMessage contact_update_test_5600: rawContactId = " + rawContactId);
4162            expect(rawContactId > 0).assertTrue();
4163            var map = common.getProfileRawContactMap();
4164            map.set("id", rawContactId.toString());
4165            await contactsQuery(map, "contact_update_test_5600", rawContactUri);
4166            await executeBatch();
4167        } catch (error) {
4168            console.info("logMessage contact_update_test_5600:  insert error = " + error);
4169            done();
4170        }
4171
4172        async function executeBatch()
4173        {
4174            var updateValues = {"display_name" : "xiaoxiaoxiao"};
4175            let condition = new dataShare.DataSharePredicates();
4176            condition.equalTo("id", rawContactId.toString());
4177            dataShareHelper.executeBatch(URI_CONTACTS, [ {
4178                uri : rawContactUri,
4179                type : featureAbility.DataAbilityOperationType.TYPE_UPDATE,
4180                valuesBucket : updateValues,
4181                predicates : condition,
4182                expectedCount : 0,
4183                PredicatesBackReferences : {},
4184                interrupted : true,
4185            } ],
4186                (error, data) => {
4187                    console.info("logMessage contact_update_test_5600: executeBatch data = " + JSON.stringify(data));
4188                    console.info("logMessage contact_update_test_5600: data_3 = " + data);
4189                    console.info("logMessage contact_update_test_5600: data_1= " + data[0].count);
4190                    expect(data[0].count == 0).assertTrue();
4191                    done();
4192                });
4193        }
4194    });
4195
4196    /**
4197     * @tc.number  contact_insert_test_5700
4198     * @tc.name    Insert Multiple raw_contact essential information
4199     * @tc.desc    Function test
4200     */
4201    it("contact_insert_test_5700", 0, async function(done) {
4202        console.info("------logMessage contact_insert_test_5700 is starting!-----");
4203        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4204        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4205        try {
4206            var rawContactId = await dataShareHelper.insert(rawContactUri, common.getProfileRawContact());
4207            sleep(sleep_one);
4208            console.info('logMessage contact_insert_test_5700: rawContactId = ' + rawContactId);
4209            expect(rawContactId > 0).assertTrue();
4210            var map = common.getProfileRawContactMap();
4211            map.set("id", rawContactId.toString());
4212            await contactsQuery(map, "contact_insert_test_5700", rawContactUri);
4213            var rawContactIdOne = await dataShareHelper.insert(rawContactUri, common.getProfileRawContact());
4214            sleep(sleep_one);
4215            console.info('logMessage contact_insert_test_5700: rawContactIdOne = ' + rawContactIdOne);
4216            expect(rawContactIdOne > 0).assertTrue();
4217            var map = common.getProfileRawContactMap();
4218            map.set("id", rawContactIdOne.toString());
4219            await contactsQuery(map, "contact_insert_test_5700", rawContactUri);
4220            var rawContactIdTwo = await dataShareHelper.insert(rawContactUri, common.getProfileRawContact());
4221            sleep(sleep_one);
4222            console.info('logMessage contact_insert_test_5700: rawContactIdTwo = ' + rawContactIdTwo);
4223            expect(rawContactIdTwo > 0).assertTrue();
4224            var map = common.getProfileRawContactMap();
4225            map.set("id", rawContactIdTwo.toString());
4226            await contactsQuery(map, "contact_insert_test_5700", rawContactUri);
4227            await deleteRawContact("contact_insert_test_5700");
4228            done();
4229        } catch (error) {
4230            console.info('logMessage contact_insert_test_5700: insert error = ' + error);
4231            done();
4232        }
4233    });
4234
4235    /**
4236     * @tc.number  contact_insert_test_5800
4237     * @tc.name    Add 20000 bytes of basic contact information and verify whether the text insertion is successful
4238     * @tc.desc    Function test
4239     */
4240    it("contact_insert_test_5800", 0, async function(done) {
4241        console.info("------logMessage contact_insert_test_5800 is starting!-----");
4242        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4243        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4244        var name;
4245        for (var i = 0; i < 20000; i++) {
4246            name += "i";
4247        }
4248        var contcatvalues = {"display_name" : name}
4249        try {
4250            var rawContactId = await dataShareHelper.insert(rawContactUri, contcatvalues);
4251            sleep(sleep_one);
4252            console.info('logMessage contact_insert_test_5800: rawContactId = ' + rawContactId);
4253            expect(rawContactId > 0).assertTrue();
4254            var map = new Map();
4255            map.set("id", rawContactId.toString());
4256            map.set("display_name", name);
4257            await contactsQuery(map, "contact_insert_test_5800", rawContactUri);
4258            await deleteRawContact("contact_insert_test_5800");
4259            done();
4260        } catch (error) {
4261            console.info('logMessage contact_insert_test_5800: insert error = ' + error);
4262            done();
4263        }
4264    });
4265
4266    /**
4267     * @tc.number  contact_insert_test_5900
4268     * @tc.name    Add multiple contact details and verify that the insertion was successful
4269     * @tc.desc    Function test
4270     */
4271    it("contact_insert_test_5900", 0, async function(done) {
4272        console.info("------logMessage contact_insert_test_5900 is starting!-----");
4273        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4274        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4275        var contcatvalues = {"display_name" : "xiao5900"}
4276        try {
4277            var rawContactId = await dataShareHelper.insert(rawContactUri, contcatvalues);
4278            console.info('logMessage contact_insert_test_5900: rawContactId = ' + rawContactId);
4279            expect(rawContactId > 0).assertTrue();
4280            var contactDataValues1 = {
4281                "raw_contact_id" : rawContactId,
4282                "content_type" : "phone",
4283                "detail_info" : "19960229"
4284            };
4285            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues1);
4286            console.info('logMessage contact_insert_test_5900: contactDataId = ' + contactDataId);
4287            expect(contactDataId > 0).assertTrue();
4288
4289            var map = new Map();
4290            map.set("id", contactDataId.toString());
4291            map.set("detail_info", "19960229");
4292            await contactsQuery(map, "contact_insert_test_5900", contactDataUri);
4293
4294            var rawContactIdOne = await dataShareHelper.insert(rawContactUri, contcatvalues);
4295            console.info('logMessage contact_insert_test_5900: rawContactId = ' + rawContactIdOne);
4296            expect(rawContactIdOne > 0).assertTrue();
4297            var contactDataValues2 = {
4298                "raw_contact_id" : rawContactIdOne,
4299                "content_type" : "phone",
4300                "detail_info" : "111111032"
4301            };
4302            var contactDataId1 = await dataShareHelper.insert(contactDataUri, contactDataValues2);
4303            console.info('logMessage contact_insert_test_5900: contactDataId = ' + contactDataId1);
4304            expect(contactDataId1 > 0).assertTrue();
4305
4306            var map = new Map();
4307            map.set("id", contactDataId1.toString());
4308            map.set("detail_info", "111111032");
4309            await contactsQuery(map, "contact_insert_test_5900", contactDataUri);
4310
4311            await deleteRawContact("contact_insert_test_5900");
4312            await deleteAll(contactDataUri, "contact_insert_test_5900");
4313            done();
4314        } catch (error) {
4315            console.info('logMessage contact_insert_test_5900: insert error = ' + error);
4316            done();
4317        }
4318    });
4319
4320    /**
4321     * @tc.number  contact_insert_test_6000
4322     * @tc.name    Add the basic information of a single contact and verify whether the insertion is successful (name,
4323     * Pinyin, company, position, favorite)
4324     * @tc.desc    Function test
4325     */
4326    it("contact_insert_test_6000", 0, async function(done) {
4327        console.info("------logMessage contact_insert_test_6000 is starting!-----");
4328        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4329        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4330
4331        var insertRawContactValues = {
4332            "display_name" : "licheng",
4333            "company" : "TT",
4334            "position" : "developer",
4335            "favorite" : 1,
4336            "phonetic_name" : "licheng||lc"
4337        };
4338        try {
4339            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
4340            console.info("logMessage contact_insert_test_6000: rawContactId = " + rawContactId);
4341            expect(rawContactId > 0).assertTrue();
4342
4343            var map = new Map();
4344            map.set("id", rawContactId.toString());
4345            map.set("display_name", "licheng");
4346            map.set("company", "TT");
4347            map.set("position", "developer");
4348            map.set("favorite", "1");
4349            map.set("phonetic_name", "licheng||lc");
4350            await contactsQuery(map, "contact_insert_test_6000", rawContactUri);
4351            await deleteRawContact("contact_insert_test_6000");
4352            await deleteAll(contactDataUri, "contact_insert_test_6000");
4353            done();
4354        } catch (error) {
4355            console.info("logMessage contact_insert_test_6000: raw_contact insert error = " + error);
4356            done();
4357        }
4358    });
4359
4360    /**
4361     * @tc.number  contact_insertData_test_6100
4362     * @tc.name    To contact_data Add a full field data to the data table and verify whether the insertion is
4363     * successful
4364     * @tc.desc    Function test
4365     */
4366    it("contact_insertData_test_6100", 0, async function(done) {
4367        console.info("------logMessage contact_insertData_test_6100 is starting!-----");
4368        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4369        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4370
4371        var insertRawContactValues = {
4372            "display_name" : "xiaocai",
4373        };
4374        try {
4375            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
4376            console.info("logMessage contact_insertData_test_6100: rawContactId = " + rawContactId);
4377            expect(rawContactId > 0).assertTrue();
4378            var contactDataValues = common.getProfileContactData();
4379            contactDataValues["raw_contact_id"] = rawContactId;
4380            console.info('logMessage contact_insertData_test_6100: contactDataValues["raw_contact_id"] = ' +
4381                         contactDataValues.raw_contact_id);
4382            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
4383            console.info('logMessage contact_insertData_test_6100: contactDataId = ' + contactDataId);
4384            expect(contactDataId > 0).assertTrue();
4385            var map = common.getProfileContactDataMap();
4386            map.set("id", contactDataId.toString());
4387            map.set("raw_contact_id", rawContactId.toString());
4388            await contactsQuery(map, "contact_insertData_test_6100", contactDataUri);
4389            await deleteRawContact("contact_insertData_test_6100");
4390            await deleteAll(contactDataUri, "contact_insertData_test_6100");
4391            done();
4392        } catch (error) {
4393            console.info("logMessage contact_insertData_test_6100: raw_contact insert error = " + error);
4394            done();
4395        }
4396    });
4397
4398    /**
4399     * @tc.number  contact_update_test_6200
4400     * @tc.name    Modify the basic information of multiple contacts and verify whether the modification is successful
4401     * @tc.desc    Function test
4402     */
4403    it("contact_update_test_6200", 0, async function(done) {
4404        console.info("--------logMessage contact_update_test_6200 is starting!------------");
4405        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4406        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4407        try {
4408            var insertRawContactValues = {
4409                "display_name" : "xiaocai",
4410            };
4411            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
4412            expect(rawContactId > 0).assertTrue();
4413            console.info("logMessage contact_update_test_6200: rawContactId = " + rawContactId);
4414            var insertRawContactValuesOne = {
4415                "display_name" : "xiaocai1",
4416            };
4417            var rawContactIdOne = await dataShareHelper.insert(rawContactUri, insertRawContactValuesOne);
4418            expect(rawContactIdOne > 0).assertTrue();
4419            console.info("logMessage contact_update_test_6200: rawContactIdOne = " + rawContactIdOne);
4420            var insertRawContactValuesTwo = {
4421                "display_name" : "xiaocai1",
4422            };
4423            var rawContactIdTwo = await dataShareHelper.insert(rawContactUri, insertRawContactValuesTwo);
4424            expect(rawContactIdTwo > 0).assertTrue();
4425            console.info("logMessage contact_update_test_6200: rawContactIdTwo = " + rawContactIdTwo);
4426
4427            var updateValues = {"display_name" : "xiaosan"};
4428            let condition = new dataShare.DataSharePredicates();
4429            condition.equalTo("id", rawContactId.toString());
4430            condition.or();
4431            condition.equalTo("id", rawContactIdOne.toString());
4432            condition.or();
4433            condition.equalTo("id", rawContactIdTwo.toString());
4434            var updataCode = await dataShareHelper.update(rawContactUri, updateValues, condition);
4435            console.info("logMessage contact_update_test_6200: updataCode = " + updataCode);
4436            expect(updataCode == 0).assertTrue();
4437            sleep(sleep_one);
4438            await queryUpdateThree(
4439                "contact_update_test_6200", dataShareHelper, rawContactId, rawContactIdOne, rawContactIdTwo);
4440            await deleteRawContact("contact_update_test_6200");
4441            done();
4442        } catch (error) {
4443            console.info("logMessage contact_update_test_6200:  insert error = " + error);
4444            done();
4445        }
4446    });
4447
4448    async function queryUpdateThree(tag, dataShareHelper, rawContactId, rawContactIdOne, rawContactIdTwo)
4449    {
4450
4451        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4452        console.info(tag + ': contactsQuery start ! dataShareHelper = ' + dataShareHelper);
4453        var resultColumns = [ "display_name" ];
4454        let condition = new dataShare.DataSharePredicates();
4455        condition.equalTo("id", rawContactId.toString());
4456        condition.or();
4457        condition.equalTo("id", rawContactIdOne.toString());
4458        condition.or();
4459        condition.equalTo("id", rawContactIdTwo.toString());
4460        try {
4461            var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
4462            if (resultSet.rowCount > 0) {
4463                if (resultSet.goToFirstRow()) {
4464                    do {
4465                        var name = resultSet.getString(resultSet.getColumnIndex("display_name"));
4466                        expect(name == "xiaosan").assertEqual(true);
4467                    } while (resultSet.goToNextRow());
4468                }
4469            }
4470            resultSet.close();
4471        } catch (error) {
4472            console.info(tag + "logMessage contactsQuery: error = " + error);
4473        }
4474    }
4475
4476    /**
4477     * @tc.number  contact_UpdateRawContcat_test_6300
4478     * @tc.name    Update raw_contact The full field data of the contact table and verify whether the modification is
4479     * successful
4480     * @tc.desc    Function test
4481     */
4482    it("contact_UpdateRawContcat_test_6300", 0, async function(done) {
4483        console.info("------logMessage contact_UpdateRawContcat_test_6300 is starting!-----");
4484        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4485        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4486        try {
4487            var rawContactId = await dataShareHelper.insert(rawContactUri, common.getProfileRawContact());
4488            console.info("logMessage contact_UpdateRawContcat_test_6300: rawContactId = " + rawContactId);
4489            expect(rawContactId > 0).assertTrue();
4490            sleep(sleep_two);
4491            var updateValues = common.getProfileRawContactUpdate();
4492            let condition = new dataShare.DataSharePredicates();
4493            condition.equalTo("id", rawContactId.toString());
4494            var updataCode = await dataShareHelper.update(rawContactUri, updateValues, condition);
4495            console.info('logMessage contact_UpdateRawContcat_test_6300: updataCode = ' + updataCode);
4496            sleep(3000);
4497            var map = common.getProfileRawContactUpdateMap();
4498            map.set("id", rawContactId.toString());
4499            await contactsQuery(map, "contact_UpdateRawContcat_test_6300", rawContactUri);
4500            await deleteRawContact("contact_UpdateRawContcat_test_6300");
4501            await deleteAll(contactDataUri, "contact_UpdateRawContcat_test_6300");
4502            done();
4503        } catch (error) {
4504            console.info("logMessage contact_UpdateRawContcat_test_6300: raw_contact insert error = " + error);
4505            done();
4506        }
4507    });
4508
4509    /**
4510     * @tc.number  contact_insertDataUpdate_test_6400
4511     * @tc.name    Update contact_data table, and verify whether the modification is successful
4512     * @tc.desc    Function test
4513     */
4514    it("contact_insertDataUpdate_test_6400", 0, async function(done) {
4515        console.info("------logMessage contact_insertDataUpdate_test_6400 is starting!-----");
4516        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4517        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4518
4519        var insertRawContactValues = {
4520            "display_name" : "xiaocai",
4521        };
4522        try {
4523            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
4524            console.info("logMessage contact_insertDataUpdate_test_6400: rawContactId = " + rawContactId);
4525            expect(rawContactId > 0).assertTrue();
4526
4527            var contactDataValues = common.getProfileContactData();
4528            contactDataValues["raw_contact_id"] = rawContactId;
4529            console.info('logMessage contact_insertDataUpdate_test_6400: contactDataValues.raw_contact_id = ' +
4530                         contactDataValues.raw_contact_id);
4531            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
4532            console.info('logMessage contact_insertDataUpdate_test_6400: contactDataId = ' + contactDataId);
4533            expect(contactDataId > 0).assertTrue();
4534
4535            var updateValues = common.getProfileContactDataUpdate();
4536            let condition = new dataShare.DataSharePredicates();
4537            condition.equalTo("id", contactDataId.toString());
4538            var updataCode = await dataShareHelper.update(contactDataUri, updateValues, condition);
4539            console.info('logMessage contact_insertDataUpdate_test_6400: updataCode = ' + updataCode);
4540            sleep(sleep_one);
4541            var map = common.getProfileContactDataUpdateMap();
4542            map.set("id", contactDataId.toString());
4543            map.set("raw_contact_id", rawContactId.toString());
4544            await contactsQuery(map, "contact_insertDataUpdate_test_6400", contactDataUri);
4545            await deleteRawContact("contact_insertDataUpdate_test_6400");
4546            await deleteAll(contactDataUri, "contact_insertDataUpdate_test_6400");
4547            done();
4548        } catch (error) {
4549            console.info("logMessage contact_insertDataUpdate_test_6400: raw_contact insert error = " + error);
4550            done();
4551        }
4552    });
4553
4554    /**
4555     * @tc.number  contact_insertDataUpdateAll_test_6500
4556     * @tc.name    Update all contact details and verify that the modification was successful
4557     * @tc.desc    Function test
4558     */
4559    it("contact_insertDataUpdateAll_test_6500", 0, async function(done) {
4560        console.info("------logMessage contact_insertDataUpdateAll_test_6500 is starting!-----");
4561        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4562        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4563
4564        var insertRawContactValues = {
4565            "display_name" : "xiaocai",
4566        };
4567        try {
4568            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
4569            console.info("logMessage contact_insertDataUpdateAll_test_6500: rawContactId = " + rawContactId);
4570            expect(rawContactId > 0).assertTrue();
4571            await insertData(rawContactId, "name", "xiaocai", "");
4572            await insertData(rawContactId, "phone", "6500", "");
4573            await insertData(rawContactId, "organization", "TTTTT", "Deve");
4574            await insertData(rawContactId, "nickname", "xxxxcai", "");
4575            await insertData(rawContactId, "email", "111@fox.com", "");
4576            await insertData(rawContactId, "postal_address", "dddd", "");
4577            await insertData(rawContactId, "note", "caicai", "");
4578            await insertData(rawContactId, "im", "999999999", "");
4579            await insertData(rawContactId, "contact_event", "1125", "");
4580            await insertData(rawContactId, "website", "wwww.xxx.com", "");
4581            await insertData(rawContactId, "relation", "xiaobai", "");
4582            await insertData(rawContactId, "group_membership", 1, "");
4583            await insertData(rawContactId, "contact_misc", "5678", "");
4584            var updateValues = {"detail_info" : "xiaocai"};
4585            let condition = new dataShare.DataSharePredicates();
4586            condition.equalTo("raw_contact_id", rawContactId.toString());
4587            var updataCode = await dataShareHelper.update(contactDataUri, updateValues, condition);
4588            console.info('logMessage contact_insertDataUpdateAll_test_6500: updataCode = ' + updataCode);
4589            sleep(sleep_one);
4590            await queryUpdateAllData("contact_insertDataUpdateAll_test_6500", dataShareHelper, rawContactId);
4591            await deleteRawContact("contact_insertDataUpdateAll_test_6500");
4592            await deleteAll(contactDataUri, "contact_insertDataUpdateAll_test_6500");
4593            done();
4594        } catch (error) {
4595            console.info("logMessage contact_insertDataUpdateAll_test_6500: raw_contact insert error = " + error);
4596            done();
4597        }
4598    });
4599
4600    async function queryUpdateAllData(tag, dataShareHelper, rawContactId)
4601    {
4602
4603        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4604        console.info(tag + ': contactsQuery start ! dataShareHelper = ' + dataShareHelper);
4605        var resultColumns = [ "detail_info" ];
4606        let condition = new dataShare.DataSharePredicates();
4607        condition.equalTo("row_contact_id", rawContactId.toString());
4608        try {
4609            var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
4610            if (resultSet.rowCount > 0) {
4611                if (resultSet.goToFirstRow()) {
4612                    do {
4613                        var detail_info = resultSet.getString(resultSet.getColumnIndex("detail_info"));
4614                        expect(detail_info == "xiaocai").assertEqual(true);
4615                    } while (resultSet.goToNextRow());
4616                }
4617            }
4618            resultSet.close();
4619        } catch (error) {
4620            console.info(tag + "logMessage contactsQuery: error = " + error);
4621        }
4622    }
4623
4624    /**
4625     * @tc.number  contact_insertFavorite_test_6600
4626     * @tc.name    Add multiple contacts to favorites and verify that the favorites field is changed
4627     * @tc.desc    Function test
4628     */
4629    it("contact_insertFavorite_test_6600", 0, async function(done) {
4630        console.info("------logMessage contact_insertFavorite_test_6600 is starting!-----");
4631        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4632        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4633
4634        try {
4635            var insertRawContactValues = {"display_name" : "xiaocai", "favorite" : 1};
4636            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
4637            console.info("logMessage contact_insertFavorite_test_6600: rawContactId = " + rawContactId);
4638
4639            var insertRawContactValuesOne = {"display_name" : "xiaotian", "favorite" : 1};
4640            var rawContactIdOne = await dataShareHelper.insert(rawContactUri, insertRawContactValuesOne);
4641            console.info("logMessage contact_insertFavorite_test_6600: rawContactId = " + rawContactIdOne);
4642
4643            var insertRawContactValuesTwo = {"display_name" : "xiaoli", "favorite" : 1};
4644            var rawContactIdTwo = await dataShareHelper.insert(rawContactUri, insertRawContactValuesTwo);
4645            console.info("logMessage contact_insertFavorite_test_6600: rawContactId = " + rawContactIdTwo);
4646
4647            sleep(sleep_one);
4648            await queryThreeFavorite(
4649                "contact_insertFavorite_test_6600", dataShareHelper, rawContactId, rawContactIdOne, rawContactIdTwo, 1);
4650            await deleteRawContact("contact_insertFavorite_test_6600");
4651            done();
4652        } catch (error) {
4653            console.info("logMessage contact_insertFavorite_test_6600: raw_contact insert error = " + error);
4654            done();
4655        }
4656    });
4657
4658    async function queryThreeFavorite(tag, dataShareHelper, rawContactId, rawContactIdOne, rawContactIdTwo, favoritevalue)
4659    {
4660
4661        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4662        console.info(tag + ': queryThreeFavorite start ! dataShareHelper = ' + dataShareHelper);
4663        var resultColumns = [ "favorite" ];
4664        let condition = new dataShare.DataSharePredicates();
4665        condition.equalTo("id", rawContactId.toString());
4666        condition.or();
4667        condition.equalTo("id", rawContactIdOne.toString());
4668        condition.or();
4669        condition.equalTo("id", rawContactIdTwo.toString());
4670        try {
4671            var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
4672            if (resultSet.rowCount > 0) {
4673                if (resultSet.goToFirstRow()) {
4674                    do {
4675                        var favorite = resultSet.getInt(resultSet.getColumnIndex("favorite"));
4676                        expect(favorite == favoritevalue).assertEqual(true);
4677                    } while (resultSet.goToNextRow());
4678                }
4679            }
4680            resultSet.close();
4681        } catch (error) {
4682            console.info(tag + "logMessage queryThreeFavorite: error = " + error);
4683        }
4684    }
4685
4686    /**
4687     * @tc.number  contact_unFavorite_test_6700
4688     * @tc.name    Remove favorites from multiple contacts and verify that the favorites field has changed
4689     * @tc.desc    Function test
4690     */
4691    it("contact_unFavorite_test_6700", 0, async function(done) {
4692        console.info("------logMessage contact_unFavorite_test_6700 is starting!-----");
4693        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4694        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4695
4696        try {
4697            var insertRawContactValues = {"display_name" : "xiaocai", "favorite" : 1};
4698            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
4699            console.info("logMessage contact_unFavorite_test_6700: rawContactId = " + rawContactId);
4700
4701            var insertRawContactValuesOne = {"display_name" : "xiaotian", "favorite" : 1};
4702            var rawContactIdOne = await dataShareHelper.insert(rawContactUri, insertRawContactValuesOne);
4703            console.info("logMessage contact_unFavorite_test_6700: rawContactId = " + rawContactIdOne);
4704
4705            var insertRawContactValuesTwo = {"display_name" : "xiaoli", "favorite" : 1};
4706            var rawContactIdTwo = await dataShareHelper.insert(rawContactUri, insertRawContactValuesTwo);
4707            console.info("logMessage contact_unFavorite_test_6700: rawContactId = " + rawContactIdTwo);
4708
4709            var updateValues = {"favorite" : 0};
4710            let condition = new dataShare.DataSharePredicates();
4711            condition.equalTo("id", rawContactId.toString());
4712            condition.or();
4713            condition.equalTo("id", rawContactIdOne.toString());
4714            condition.or();
4715            condition.equalTo("id", rawContactIdTwo.toString());
4716            var updataCode = await dataShareHelper.update(rawContactUri, updateValues, condition);
4717            console.info("logMessage contact_unFavorite_test_6700: updataCode = " + updataCode);
4718            sleep(sleep_one);
4719            await queryThreeFavorite(
4720                "contact_unFavorite_test_6700", dataShareHelper, rawContactId, rawContactIdOne, rawContactIdTwo, 0);
4721            await deleteRawContact("contact_unFavorite_test_6700");
4722            done();
4723        } catch (error) {
4724            console.info("logMessage contact_unFavorite_test_6700: raw_contact insert error = " + error);
4725            done();
4726        }
4727    });
4728
4729    /**
4730     * @tc.number  contact_insertContactBlocklist_test_6800
4731     * @tc.name    Add multiple records to the blocklist and verify whether the insertion is successful
4732     * @tc.desc    Function test
4733     */
4734    it("contact_insertContactBlocklist_test_6800", 0, async function(done) {
4735        console.info("--------logMessage contact_insertContactBlocklist_test_6800 is starting!-------");
4736        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4737        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4738        try {
4739            var batchInsertCode = await dataShareHelper.insert(contactBlocklistUri, common.getProfileBlockList());
4740            console.info("logMessage contact_insertContactBlocklist_test_6800: insert = " + batchInsertCode);
4741            var batchInsertCodeOne = await dataShareHelper.insert(contactBlocklistUri, common.getProfileBlockList());
4742            console.info("logMessage contact_insertContactBlocklist_test_6800: insert = " + batchInsertCodeOne);
4743            var batchInsertCodeTwo = await dataShareHelper.insert(contactBlocklistUri, common.getProfileBlockList());
4744            console.info("logMessage contact_insertContactBlocklist_test_6800: insert = " + batchInsertCodeTwo);
4745            sleep(sleep_one);
4746            expect(batchInsertCode > 0).assertTrue();
4747            await query(array_three);
4748            await deleteAll(contactBlocklistUri, "contact_insertContactBlocklist_test_6800");
4749            done();
4750        } catch (error) {
4751            console.info("logMessage contact_insertContactBlocklist_test_6800: insert error = " + error);
4752            done();
4753        }
4754
4755        async function query(size)
4756        {
4757            var resultColumns = [];
4758            let condition = new dataShare.DataSharePredicates();
4759            var phoneNumber = randomNum(8);
4760            condition.equalTo("phone_number", phoneNumber);
4761            try {
4762                var resultSet = await dataShareHelper.query(contactBlocklistUri, resultColumns, condition);
4763                sleep(sleep_one);
4764                console.info('contact_insertContactBlocklist_test_6800 :resultSet.goToFirstRow()  = ' +
4765                             resultSet.goToFirstRow());
4766                console.info(
4767                    'contact_insertContactBlocklist_test_6800 : query result is  = ' + resultSet.rowCount == size);
4768                expect(resultSet.rowCount == size).assertEqual(true);
4769                resultSet.close();
4770            } catch (error) {
4771                console.info(" contact_insertContactBlocklist_test_6800  error = " + error);
4772            }
4773        }
4774    });
4775
4776    /**
4777     * @tc.number  contact_removeContactBlocklist_test_6900
4778     * @tc.name    Delete multiple records from the blocklist and verify whether the deletion is successful
4779     * @tc.desc    Function test
4780     */
4781    it("contact_removeContactBlocklist_test_6900", 0, async function(done) {
4782        console.info("--------logMessage contact_removeContactBlocklist_test_6900 is starting!-------");
4783        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4784        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4785        try {
4786            var batchInsertCode = await dataShareHelper.insert(contactBlocklistUri, common.getProfileBlockList());
4787            console.info("logMessage contact_removeContactBlocklist_test_6900: batchInsertCode = " + batchInsertCode);
4788            var batchInsertCodeOne = await dataShareHelper.insert(contactBlocklistUri, common.getProfileBlockList());
4789            console.info("logMessage contact_removeContactBlocklist_test_6900: insert = " + batchInsertCodeOne);
4790            var batchInsertCodeTwo = await dataShareHelper.insert(contactBlocklistUri, common.getProfileBlockList());
4791            console.info("logMessage contact_removeContactBlocklist_test_6900: insert = " + batchInsertCodeTwo);
4792            sleep(sleep_one);
4793            expect(batchInsertCode > 0).assertTrue();
4794            await deleteAll(contactBlocklistUri, "contact_removeContactBlocklist_test_6900");
4795            await query(0);
4796            done();
4797        } catch (error) {
4798            console.info("logMessage contact_removeContactBlocklist_test_6900: batchInsert error = " + error);
4799            done();
4800        }
4801        async function query(size)
4802        {
4803            var resultColumns = [];
4804            let condition = new dataShare.DataSharePredicates();
4805            var phoneNumber = randomNum(8);
4806            condition.equalTo("phone_number", phoneNumber);
4807            try {
4808                var resultSet = await dataShareHelper.query(contactBlocklistUri, resultColumns, condition);
4809                console.info('contact_removeContactBlocklist_test_6900 : resultSet  = ' + resultSet);
4810                expect(resultSet.rowCount == size).assertEqual(true);
4811                resultSet.close();
4812            } catch (error) {
4813                console.info(" contact_removeContactBlocklist_test_6900  error = " + error);
4814            }
4815        }
4816    });
4817
4818    /**
4819     * @tc.number  contact_insertGroup_test_7000
4820     * @tc.name    Add multiple contacts to favorites and verify that the favorites field is changed
4821     * @tc.desc    Function test
4822     */
4823    it("contact_insertGroup_test_7000", 0, async function(done) {
4824        console.info("------logMessage contact_insertGroup_test_7000 is starting!-----");
4825        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4826        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4827
4828        try {
4829            var insertRawContactValues = {
4830                "display_name" : "xiaocai",
4831            };
4832            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
4833            console.info("logMessage contact_insertGroup_test_7000: rawContactId = " + rawContactId);
4834            await insertData(rawContactId, "group_membership", 1, "");
4835
4836            var insertRawContactValuesOne = {
4837                "display_name" : "xiaotian",
4838            };
4839            var rawContactIdOne = await dataShareHelper.insert(rawContactUri, insertRawContactValuesOne);
4840            console.info("logMessage contact_insertGroup_test_7000: rawContactId = " + rawContactIdOne);
4841            await insertData(rawContactIdOne, "group_membership", 1, "");
4842            var insertRawContactValuesTwo = {
4843                "display_name" : "xiaoli",
4844            };
4845            var rawContactIdTwo = await dataShareHelper.insert(rawContactUri, insertRawContactValuesTwo);
4846            console.info("logMessage contact_insertGroup_test_7000: rawContactId = " + rawContactIdTwo);
4847            await insertData(rawContactIdTwo, "group_membership", 1, "");
4848            sleep(sleep_one);
4849            await queryThreeGroup(
4850                "contact_insertGroup_test_7000", dataShareHelper, rawContactId, rawContactIdOne, rawContactIdTwo, 1);
4851            await deleteRawContact("contact_insertGroup_test_7000");
4852            done();
4853        } catch (error) {
4854            console.info("logMessage contact_insertGroup_test_7000: raw_contact insert error = " + error);
4855            done();
4856        }
4857    });
4858
4859    async function queryThreeGroup(tag, dataShareHelper, rawContactId, rawContactIdOne, rawContactIdTwo, groupId)
4860    {
4861        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4862        console.info(tag + ': queryThreeGroup start ! dataShareHelper = ' + dataShareHelper);
4863        var resultColumns = [ "detail_info" ];
4864        let condition = new dataShare.DataSharePredicates();
4865        condition.equalTo("id", rawContactId.toString());
4866        condition.or();
4867        condition.equalTo("id", rawContactIdOne.toString());
4868        condition.or();
4869        condition.equalTo("id", rawContactIdTwo.toString());
4870        try {
4871            var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
4872            if (resultSet.rowCount > 0) {
4873                if (resultSet.goToFirstRow()) {
4874                    do {
4875                        var group = resultSet.getInt(resultSet.getColumnIndex("detail_info"));
4876                        expect(group == groupId).assertEqual(true);
4877                    } while (resultSet.goToNextRow());
4878                }
4879            }
4880            resultSet.close();
4881        } catch (error) {
4882            console.info(tag + "logMessage queryThreeGroup: error = " + error);
4883        }
4884    }
4885
4886    /**
4887     * @tc.number  contact_insert_test_7100
4888     * @tc.name    Add a full field data to the groups table and verify whether the insertion is successful
4889     * @tc.desc    Function test
4890     */
4891    it("contact_insert_test_7100", 0, async function(done) {
4892        console.info("---------logMessage contact_insert_test_7100 is starting!----------");
4893        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4894        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4895        try {
4896            var groupId = await dataShareHelper.insert(groupUri, common.getProfileGroup());
4897            console.info("logMessage contact_insert_test_7100: groupId = " + groupId);
4898            expect(groupId > 0).assertTrue();
4899            var map = common.getProfileGroupMap();
4900            map.set("id", groupId.toString());
4901            await contactsQuery(map, "contact_insert_test_7100", groupUri);
4902            await deleteAll(groupUri, "contact_insert_test_7100");
4903            done();
4904        } catch (error) {
4905            console.info("logMessage contact_insert_test_7100: group insert error = " + error);
4906            done();
4907        }
4908    });
4909
4910    /**
4911     * @tc.number  contact_delete_test_7200
4912     * @tc.name    Add a full field data to the groups table and verify whether the insertion is successful
4913     * @tc.desc    Function test
4914     */
4915    it("contact_delete_test_7200", 0, async function(done) {
4916        console.info("------logMessage contact_delete_test_7200 is starting!-----");
4917        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4918        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4919
4920        try {
4921            var insertRawContactValues = {
4922                "display_name" : "xiaocai",
4923            };
4924            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
4925            console.info("logMessage contact_delete_test_7200: rawContactId = " + rawContactId);
4926            await insertData(rawContactId, "group_membership", 1, "");
4927
4928            var insertRawContactValuesOne = {
4929                "display_name" : "xiaotian",
4930            };
4931            var rawContactIdOne = await dataShareHelper.insert(rawContactUri, insertRawContactValuesOne);
4932            console.info("logMessage contact_delete_test_7200: rawContactId = " + rawContactIdOne);
4933            await insertData(rawContactIdOne, "group_membership", 1, "");
4934            var insertRawContactValuesTwo = {
4935                "display_name" : "xiaoli",
4936            };
4937            var rawContactIdTwo = await dataShareHelper.insert(rawContactUri, insertRawContactValuesTwo);
4938            console.info("logMessage contact_delete_test_7200: rawContactId = " + rawContactIdTwo);
4939            await insertData(rawContactIdTwo, "group_membership", 1, "");
4940            sleep(sleep_one);
4941            await deleteAll(contactDataUri, "contact_delete_test_7200");
4942            sleep(sleep_one);
4943            await queryZeroGroup("contact_delete_test_7200", dataShareHelper, rawContactId, rawContactIdOne, rawContactIdTwo);
4944            await deleteRawContact("contact_delete_test_7200");
4945            done();
4946        } catch (error) {
4947            console.info("logMessage contact_delete_test_7200: raw_contact insert error = " + error);
4948            done();
4949        }
4950    });
4951
4952    async function queryZeroGroup(tag, dataShareHelper, rawContactId, rawContactIdOne, rawContactIdTwo)
4953    {
4954
4955        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4956        console.info(tag + ': queryZeroGroup start ! dataShareHelper = ' + dataShareHelper);
4957        var resultColumns = [ "detail_info" ];
4958        let condition = new dataShare.DataSharePredicates();
4959        condition.equalTo("raw_contact_id", rawContactId.toString());
4960        condition.or();
4961        condition.equalTo("raw_contact_id", rawContactIdOne.toString());
4962        condition.or();
4963        condition.equalTo("raw_contact_id", rawContactIdTwo.toString());
4964        try {
4965            var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
4966            console.info(tag + ': queryZeroGroup! resultSet.rowCount  = ' + resultSet.rowCount);
4967            expect(resultSet.rowCount == 0).assertEqual(true);
4968            resultSet.close();
4969        } catch (error) {
4970            console.info(tag + "logMessage queryZeroGroup: error = " + error);
4971        }
4972    }
4973
4974    /**
4975     * @tc.number  contact_delete_test_7300
4976     * @tc.name    Delete the full field data of a groups table and verify whether the deletion is successful
4977     * @tc.desc    Function test
4978     */
4979    it("contact_delete_test_7300", 0, async function(done) {
4980        console.info("---------logMessage contact_delete_test_7300 is starting!----------");
4981        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
4982        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
4983        try {
4984            var groupId = await dataShareHelper.insert(groupUri, common.getProfileGroup());
4985            console.info("logMessage contact_delete_test_7300: groupId = " + groupId);
4986            expect(groupId > 0).assertTrue();
4987            var map = common.getProfileGroupMap();
4988            map.set("id", groupId.toString());
4989            await contactsQuery(map, "contact_delete_test_7300", groupUri);
4990            await deleteAll(groupUri, "contact_delete_test_7300");
4991            done();
4992        } catch (error) {
4993            console.info("logMessage contact_delete_test_7300: group insert error = " + error);
4994            done();
4995        }
4996    });
4997
4998    /**
4999     * @tc.number  contact_delete_test_7400
5000     * @tc.name    Add a raw_contact all fields, delete raw_contact
5001     * @tc.desc    Function test
5002     */
5003    it("contact_delete_test_7400", 0, async function(done) {
5004        console.info("------logMessage contact_Delete_test_7400 is starting!-----");
5005        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5006        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5007        try {
5008            var rawContactId = await dataShareHelper.insert(rawContactUri, common.getProfileRawContact());
5009            sleep(sleep_one);
5010            console.info('logMessage contact_Delete_test_7400: rawContactId = ' + rawContactId);
5011            expect(rawContactId > 0).assertTrue();
5012            var map = common.getProfileRawContactMap();
5013            map.set("id", rawContactId.toString());
5014            map.set("version", "2");
5015            map.set("is_deleted", "1");
5016            await deleteAll(rawContactUri, "contact_Delete_test_7400");
5017            sleep(sleep_one);
5018            await contactsQuery(map, "contact_Delete_test_7400", rawContactUri);
5019            var conditionAll = new dataShare.DataSharePredicates();
5020            conditionAll.greaterThan("id", "0");
5021            var code = await dataShareHelper.delete(deletedUri, conditionAll);
5022            console.info('contact_Delete_test_7400 : Completely delete code = ' + code);
5023            expect(code == 0).assertTrue();
5024            done();
5025        } catch (error) {
5026            console.info('logMessage contact_Delete_test_7400: insert error = ' + error);
5027            done();
5028        }
5029    });
5030
5031    /**
5032     * @tc.number  contact_delete_test_7500
5033     * @tc.name    Delete contact_data Single full field data in data table
5034     * @tc.desc    Function test
5035     */
5036    it("contact_delete_test_7500", 0, async function(done) {
5037        console.info("------logMessage contact_delete_test_7500 is starting!-----");
5038        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5039        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5040
5041        var insertRawContactValues = {
5042            "display_name" : "xiaocai",
5043        };
5044        try {
5045            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
5046            console.info("logMessage contact_delete_test_7500: rawContactId = " + rawContactId);
5047            expect(rawContactId > 0).assertTrue();
5048            var contactDataValues = common.getProfileContactData();
5049            contactDataValues["raw_contact_id"] = rawContactId;
5050            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues);
5051            console.info('logMessage contact_delete_test_7500: contactDataId = ' + contactDataId);
5052            expect(contactDataId > 0).assertTrue();
5053            await deleteAll(contactDataUri, "contact_delete_test_7500");
5054            var map = new Map();
5055            map.set("id", contactDataId.toString());
5056            await queryIdForDelete(map, "contact_delete_test_7500", contactDataUri);
5057            await deleteRawContact("contact_delete_test_7500");
5058            done();
5059        } catch (error) {
5060            console.info("logMessage contact_delete_test_7500: raw_contact insert error = " + error);
5061            done();
5062        }
5063    });
5064
5065    /**
5066     * @tc.number  contact_insertDataAll_test_7600
5067     * @tc.name    Add all details of a single contact and verify whether the insertion is successful (name, mobile
5068     * number, company, position, nickname, email, home, remarks, aim)
5069     * @tc.desc    Function test
5070     */
5071    it("contact_insertDataAll_test_7600", 0, async function(done) {
5072        console.info("------logMessage contact_insertDataAll_test_7600 is starting!-----");
5073        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5074        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5075
5076        var insertRawContactValues = {
5077            "display_name" : "xiaocai",
5078        };
5079        try {
5080            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
5081            console.info("logMessage contact_insertDataAll_test_7600: rawContactId = " + rawContactId);
5082            expect(rawContactId > 0).assertTrue();
5083            var contactdata1 = await insertData(rawContactId, "name", "xiaocai", "");
5084            await queryAlldata("contact_insertDataAll_test_7600", dataShareHelper, rawContactId, contactdata1, "xiaocai");
5085            var contactdata2 = await insertData(rawContactId, "phone", "6500", "");
5086            await queryAlldata("contact_insertDataAll_test_7600", dataShareHelper, rawContactId, contactdata2, "6500");
5087            var contactdatd3 = await insertData(rawContactId, "organization", "TTTTT", "Deve");
5088            await queryAlldata("contact_insertDataAll_test_7600", dataShareHelper, rawContactId, contactdatd3, "TTTTT");
5089            var contactdatd4 = await insertData(rawContactId, "nickname", "xxxxcai", "");
5090            await queryAlldata("contact_insertDataAll_test_7600", dataShareHelper, rawContactId, contactdatd4, "xxxxcai");
5091            var contactdatd5 = await insertData(rawContactId, "email", "111@fox.com", "");
5092            await queryAlldata("contact_insertDataAll_test_7600", dataShareHelper, rawContactId, contactdatd5, "111@fox.com");
5093            var contactdatd6 = await insertData(rawContactId, "postal_address", "dddd", "");
5094            await queryAlldata("contact_insertDataAll_test_7600", dataShareHelper, rawContactId, contactdatd6, "dddd");
5095            var contactdatd7 = await insertData(rawContactId, "note", "caicai", "");
5096            await queryAlldata("contact_insertDataAll_test_7600", dataShareHelper, rawContactId, contactdatd7, "caicai");
5097            var contactdatd8 = await insertData(rawContactId, "im", "999999999", "");
5098            await queryAlldata("contact_insertDataAll_test_7600", dataShareHelper, rawContactId, contactdatd8, "999999999");
5099            sleep(sleep_one);
5100            await deleteRawContact("contact_insertDataAll_test_7600");
5101            await deleteAll(contactDataUri, "contact_insertDataAll_test_7600");
5102            done();
5103        } catch (error) {
5104            console.info("logMessage contact_insertDataAll_test_7600: raw_contact insert error = " + error);
5105            done();
5106        }
5107    });
5108
5109    async function queryAlldata(tag, dataShareHelper, rawContactId, contactdata, values)
5110    {
5111        var resultColumns = [ "raw_contact_id", "detail_info" ];
5112        let condition = new dataShare.DataSharePredicates();
5113        condition.equalTo("id", contactdata.toString());
5114        try {
5115            var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
5116            if (resultSet.rowCount > 0) {
5117                if (resultSet.goToFirstRow()) {
5118                    do {
5119                        var id = resultSet.getString(resultSet.getColumnIndex("raw_contact_id"));
5120                        console.info(tag + " result raw_contact_id = " + id);
5121                        expect(id == rawContactId).assertEqual(true);
5122                        var info = resultSet.getString(resultSet.getColumnIndex("detail_info"));
5123                        console.info(tag + " result info = " + info + " value = " + values);
5124                        expect(info == values).assertEqual(true);
5125                    } while (resultSet.goToNextRow());
5126                }
5127            }
5128            resultSet.close();
5129        } catch (error) {
5130            console.info(tag + " :logMessage queryIdForDelete: error = " + error);
5131        }
5132    }
5133
5134    /**
5135     * @tc.number  contact_insertDataAll_test_7700
5136     * @tc.name    Add all details of a single contact and verify whether the insertion is successful (name, mobile
5137     * number, company, position, nickname, email, home, remarks, aim, birthday, website, assistant, group, phone ring)
5138     * @tc.desc    Function test
5139     */
5140    it("contact_insertDataAll_test_7700", 0, async function(done) {
5141        console.info("------logMessage contact_insertDataAll_test_7700 is starting!-----");
5142        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5143        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5144
5145        var insertRawContactValues = {
5146            "display_name" : "xiaocai",
5147        };
5148        try {
5149            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
5150            console.info("logMessage contact_insertDataAll_test_7700: rawContactId = " + rawContactId);
5151            expect(rawContactId > 0).assertTrue();
5152            var contactdata1 = await insertData(rawContactId, "name", "xiaocai", "");
5153            await queryAlldata("contact_insertDataAll_test_7700", dataShareHelper, rawContactId, contactdata1, "xiaocai");
5154            var contactdata2 = await insertData(rawContactId, "phone", "6500", "");
5155            await queryAlldata("contact_insertDataAll_test_7700", dataShareHelper, rawContactId, contactdata2, "6500");
5156            var contactdatd3 = await insertData(rawContactId, "organization", "TTTTT", "Deve");
5157            await queryAlldata("contact_insertDataAll_test_7700", dataShareHelper, rawContactId, contactdatd3, "TTTTT");
5158            var contactdatd4 = await insertData(rawContactId, "nickname", "xxxxcai", "");
5159            await queryAlldata("contact_insertDataAll_test_7700", dataShareHelper, rawContactId, contactdatd4, "xxxxcai");
5160            var contactdatd5 = await insertData(rawContactId, "email", "111@fox.com", "");
5161            await queryAlldata("contact_insertDataAll_test_7700", dataShareHelper, rawContactId, contactdatd5, "111@fox.com");
5162            var contactdatd6 = await insertData(rawContactId, "postal_address", "dddd", "");
5163            await queryAlldata("contact_insertDataAll_test_7700", dataShareHelper, rawContactId, contactdatd6, "dddd");
5164            var contactdatd7 = await insertData(rawContactId, "note", "caicai", "");
5165            await queryAlldata("contact_insertDataAll_test_7700", dataShareHelper, rawContactId, contactdatd7, "caicai");
5166            var contactdatd8 = await insertData(rawContactId, "im", "999999999", "");
5167            await queryAlldata("contact_insertDataAll_test_7700", dataShareHelper, rawContactId, contactdatd8, "999999999");
5168            var contactdatd9 = await insertData(rawContactId, "contact_event", "1125", "");
5169            await queryAlldata("contact_insertDataAll_test_7700", dataShareHelper, rawContactId, contactdatd9, "1125");
5170            var contactdatd10 = await insertData(rawContactId, "website", "wwww.xxx.com", "");
5171            await queryAlldata(
5172                "contact_insertDataAll_test_7700", dataShareHelper, rawContactId, contactdatd10, "wwww.xxx.com");
5173            var contactdatd11 = await insertData(rawContactId, "relation", "xiaobai", "");
5174            await queryAlldata("contact_insertDataAll_test_7700", dataShareHelper, rawContactId, contactdatd11, "xiaobai");
5175            var contactdatd12 = await insertData(rawContactId, "group_membership", 1, "");
5176            await queryAlldata("contact_insertDataAll_test_7700", dataShareHelper, rawContactId, contactdatd12, 1);
5177            var contactdatd13 = await insertData(rawContactId, "contact_misc", "5678", "");
5178            await queryAlldata("contact_insertDataAll_test_7700", dataShareHelper, rawContactId, contactdatd13, "5678");
5179            sleep(sleep_one);
5180            await deleteRawContact("contact_insertDataAll_test_7700");
5181            await deleteAll(contactDataUri, "contact_insertDataAll_test_7700");
5182            done();
5183        } catch (error) {
5184            console.info("logMessage contact_insertDataAll_test_7700: raw_contact insert error = " + error);
5185            done();
5186        }
5187    });
5188
5189    /**
5190     * @tc.number  contact_insertDataUpdateMore_test_7800
5191     * @tc.name    Modify multiple contact details and verify whether the modification is successful
5192     * @tc.desc    Function test
5193     */
5194    it("contact_insertDataUpdateMore_test_7800", 0, async function(done) {
5195        console.info("------logMessage contact_insertDataUpdateMore_test_7800 is starting!-----");
5196        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5197        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5198        try {
5199            var insertRawContactValues = {"display_name" : "xiaocai"};
5200            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
5201            console.info("logMessage contact_insertDataUpdateMore_test_7800: rawContactId = " + rawContactId);
5202            expect(rawContactId > 0).assertTrue();
5203            await insertData(rawContactId, "name", "xiaotian", "");
5204
5205            var insertRawContactValues1 = {"display_name" : "xiaotian"};
5206            var rawContactId1 = await dataShareHelper.insert(rawContactUri, insertRawContactValues1);
5207            console.info("logMessage contact_insertDataUpdateMore_test_7800: rawContactId1 = " + rawContactId1);
5208            expect(rawContactId1 > 0).assertTrue();
5209            await insertData(rawContactId, "name", "xiaotian", "");
5210
5211            var updateValues = {"detail_info" : "xiaocai7800"};
5212            let condition = new dataShare.DataSharePredicates();
5213            condition.equalTo("raw_contact_id", rawContactId.toString());
5214            condition.or();
5215            condition.equalTo("raw_contact_id", rawContactId1.toString())
5216            var updataCode = await dataShareHelper.update(contactDataUri, updateValues, condition);
5217            console.info('logMessage contact_insertDataUpdateMore_test_7800: updataCode = ' + updataCode);
5218            sleep(sleep_one);
5219            await insertDataUpdateMoreQuery(
5220                "contact_insertDataUpdateMore_test_7800", dataShareHelper, rawContactId, rawContactId1);
5221            await deleteRawContact("contact_insertDataUpdateMore_test_7800");
5222            await deleteAll(contactDataUri, "contact_insertDataUpdateMore_test_7800");
5223            done();
5224        } catch (error) {
5225            console.info("logMessage contact_insertDataUpdateMore_test_7800: raw_contact insert error = " + error);
5226            done();
5227        }
5228    });
5229
5230    async function insertDataUpdateMoreQuery(tag, dataShareHelper, rawContactId, rawContactId1)
5231    {
5232        var resultColumns = [ "detail_info" ];
5233        let condition = new dataShare.DataSharePredicates();
5234        condition.equalTo("raw_contact_id", rawContactId.toString());
5235        condition.or();
5236        condition.equalTo("raw_contact_id", rawContactId1.toString())
5237        try {
5238            var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
5239            if (resultSet.rowCount > 0) {
5240                if (resultSet.goToFirstRow()) {
5241                    do {
5242                        var info = resultSet.getString(resultSet.getColumnIndex("detail_info"));
5243                        console.info(tag + " result info = " + info);
5244                        expect(info == "xiaocai7800").assertEqual(true);
5245                    } while (resultSet.goToNextRow());
5246                }
5247            }
5248            resultSet.close();
5249        } catch (error) {
5250            console.info(tag + " :logMessage : error = " + error);
5251        }
5252    }
5253
5254    /**
5255     * @tc.number  contact_deleterestore_test_7900
5256     * @tc.name    Delete contacts and restore
5257     * @tc.desc    Function test
5258     */
5259    it("contact_deleterestore_test_7900", 0, async function(done) {
5260        console.info("------logMessage contact_deleterestore_test_7900 is starting!-----");
5261        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5262        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5263        try {
5264            var insertRawContactValues = {"display_name" : "xaioli7900"};
5265            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
5266            console.info("logMessage contact_deleterestore_test_7900: rawContactId = " + rawContactId);
5267            expect(rawContactId > 0).assertTrue();
5268            sleep(sleep_one);
5269            var condition1 = new dataShare.DataSharePredicates();
5270            condition1.equalTo("id", rawContactId.toString());
5271            var deleteCode = await dataShareHelper.delete(rawContactUri, condition1);
5272            console.info("contact_deleterestore_test_7900 " +
5273                         ': deleteCode = ' + deleteCode);
5274            expect(deleteCode == 0).assertTrue();
5275            sleep(sleep_one);
5276
5277            var condition2 = new dataShare.DataSharePredicates();
5278            condition2.equalTo("id", rawContactId.toString());
5279            var updatevalue = {"is_deleted" : 0};
5280            var updateCode = await dataShareHelper.update(rawContactUri, updatevalue, condition2);
5281            console.info('contact_deleterestore_test_7900 : update = ' + updateCode);
5282            sleep(sleep_one);
5283
5284            var condition3 = new dataShare.DataSharePredicates();
5285            condition3.equalTo("id", rawContactId.toString());
5286            var code = await dataShareHelper.delete(deleted_raw_contact_record, condition3);
5287            console.info('contact_deleterestore_test_7900 : record code = ' + code);
5288            var map = new Map();
5289            map.set("id", rawContactId.toString());
5290            map.set("is_deleted", "0");
5291            await contactsQuery(map, "contact_deleterestore_test_7900", rawContactUri);
5292            await deleteRawContact("contact_deleterestore_test_7900");
5293            done();
5294        } catch (error) {
5295            console.info("logMessage contact_deleterestore_test_7900: raw_contact insert error = " + error);
5296            done();
5297        }
5298    });
5299
5300    /**
5301     * @tc.number  abnormal_contact_updateData_test_8000
5302     * @tc.name    When modifying contact_data table, incorrect field or table name or nonexistent value is passed in
5303     * @tc.desc    Function test
5304     */
5305    it("abnormal_contact_updateData_test_8000", 0, async function(done) {
5306        console.info("------logMessage abnormal_contact_updateData_test_8000 is starting!-----");
5307        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5308        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5309        try {
5310            var insertRawContactValues = {"display_name" : "xaioli8000"};
5311            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
5312            console.info("logMessage abnormal_contact_updateData_test_8000: rawContactId = " + rawContactId);
5313            expect(rawContactId > 0).assertTrue();
5314            sleep(sleep_one);
5315            var contactDataId = await insertData(rawContactId, "name", "xaioli8000", "");
5316            console.info("logMessage abnormal_contact_updateData_test_8000: contactDataId = " + contactDataId);
5317            expect(contactDataId > 0).assertTrue();
5318
5319            let condition = new dataShare.DataSharePredicates();
5320            var updateValues = {"display_namess" : "xaioli80000000"};
5321            condition.equalTo("id", contactDataId.toString());
5322            var code = await dataShareHelper.update(contactDataUri, updateValues, condition);
5323            console.info('abnormal_contact_updateData_test_8000 : update code = ' + code);
5324            expect(code == -1).assertTrue();
5325            var map = new Map();
5326            map.set("id", contactDataId.toString());
5327            map.set("display_name", "xaioli8000");
5328            await contactsQuery(map, "abnormal_contact_updateData_test_8000", contactDataUri);
5329            await deleteRawContact("abnormal_contact_updateData_test_8000");
5330            await deleteAll(contactDataUri, "abnormal_contact_updateData_test_8000");
5331            done();
5332        } catch (error) {
5333            console.info("logMessage abnormal_contact_updateData_test_8000: raw_contact insert error = " + error);
5334            done();
5335        }
5336    });
5337
5338    /**
5339     * @tc.number  abnormal_contact_favorite_test_8100
5340     * @tc.name    When collecting contacts, an incorrect field was passed in
5341     * @tc.desc    Function test
5342     */
5343    it("abnormal_contact_favorite_test_8100", 0, async function(done) {
5344        console.info("------logMessage abnormal_contact_favorite_test_8100 is starting!-----");
5345        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5346        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5347        try {
5348            var insertRawContactValues = {"display_name" : "xaioli8100", "favoriteeee" : 1};
5349            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
5350            console.info("logMessage abnormal_contact_favorite_test_8100: rawContactId = " + rawContactId);
5351            expect(rawContactId == -1).assertTrue();
5352            sleep(sleep_one);
5353            done();
5354        } catch (error) {
5355            console.info("logMessage abnormal_contact_favorite_test_8100: raw_contact insert error = " + error);
5356            done();
5357        }
5358    });
5359
5360    /**
5361     * @tc.number  abnormal_contact_blocklist_test_8200
5362     * @tc.name    When adding to the blocklist, an error field is passed in
5363     * @tc.desc    Function test
5364     */
5365    it("abnormal_contact_blocklist_test_8200", 0, async function(done) {
5366        console.info("------logMessage abnormal_contact_blocklist_test_8200 is starting!-----");
5367        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5368        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5369        var phoneNumber = randomNum(6);
5370        try {
5371            var insertValues = {
5372                "phone_numberss" : phoneNumber,
5373            };
5374            var id = await dataShareHelper.insert(contactBlocklistUri, insertValues);
5375            console.info("logMessage abnormal_contact_blocklist_test_8200: id = " + id);
5376            expect(id == -1).assertTrue();
5377            sleep(sleep_one);
5378            done();
5379        } catch (error) {
5380            console.info("logMessage abnormal_contact_blocklist_test_8200: raw_contact insert error = " + error);
5381            done();
5382        }
5383    });
5384
5385    /**
5386     * @tc.number  abnormal_contact_group_test_8300
5387     * @tc.name    When joining a group, an incorrect field is passed in
5388     * @tc.desc    Function test
5389     */
5390    it("abnormal_contact_group_test_8300", 0, async function(done) {
5391        console.info("------logMessage abnormal_contact_group_test_8300 is starting!-----");
5392        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5393        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5394        try {
5395            var insertRawContactValues = {"display_name" : "xaioli8100"};
5396            var rawContactId = await dataShareHelper.insert(rawContactUri, insertRawContactValues);
5397            console.info("logMessage abnormal_contact_group_test_8300: rawContactId = " + rawContactId);
5398            expect(rawContactId > 0).assertTrue();
5399            var contactDataValues1 = {
5400                "raw_contact_id" : rawContactId,
5401                "content_typess" : "group_membership",
5402                "detail_info" : 1
5403            };
5404            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues1);
5405            console.info("abnormal_contact_group_test_8300 logMessage : contactDataId " + contactDataId);
5406            expect(contactDataId == -1).assertTrue();
5407            done();
5408        } catch (error) {
5409            console.info("logMessage abnormal_contact_group_test_8300: raw_contact insert error = " + error);
5410            done();
5411        }
5412    });
5413
5414    /**
5415     * @tc.number  abnormal_contact_query_test_8400
5416     * @tc.name    When querying the basic information of multiple contacts, an error field is passed in
5417     * @tc.desc    Function test
5418     */
5419    it("abnormal_contact_query_test_8400", 0, async function(done) {
5420        console.info("------------abnormal_contact_query_test_8400 is starting!-----------");
5421        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5422        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5423        try {
5424            var rawContactValues = {"display_name" : "xiaotian8400"};
5425            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
5426            console.info("logMessage abnormal_contact_query_test_8400: rawContactId = " + rawContactId);
5427            expect(rawContactId > 0).assertTrue();
5428            var rawContactValues = {"display_name" : "xiaoli8400"};
5429            var rawContactId1 = await dataShareHelper.insert(rawContactUri, rawContactValues);
5430            console.info("logMessage abnormal_contact_query_test_8400: rawContactId1 = " + rawContactId1);
5431            expect(rawContactId1 > 0).assertTrue();
5432            await AbnormalQuery();
5433            await deleteRawContact("abnormal_contact_query_test_8400");
5434            done();
5435        } catch (error) {
5436            console.info('logMessage abnormal_contact_query_test_8400: raw_contact insert error' + error);
5437            done();
5438        }
5439
5440        async function AbnormalQuery()
5441        {
5442            var resultColumns = [ "id", "display_name" ];
5443            let condition = new dataShare.DataSharePredicates();
5444            condition.equalTo("ids", rawContactId.toString());
5445            condition.or();
5446            condition.equalTo("ids", rawContactId1.toString());
5447            try {
5448                var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
5449                expect(resultSet.goToFirstRow()).assertEqual(false);
5450                console.info('logMessage abnormal_contact_query_test_8400: goToFirstRow' + resultSet.goToFirstRow());
5451                resultSet.close();
5452            } catch (error) {
5453                console.info('logMessage abnormal_contact_query_test_8400: query error = ' + error);
5454                done();
5455            }
5456        }
5457    });
5458
5459    /**
5460     * @tc.number  abnormal_contact_query_test_8500
5461     * @tc.name    When querying the basic information of all contacts, an error field is passed in
5462     * @tc.desc    Function test
5463     */
5464    it("abnormal_contact_query_test_8500", 0, async function(done) {
5465        console.info("------------abnormal_contact_query_test_8500 is starting!-----------");
5466        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5467        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5468        try {
5469            var rawContactValues = {"display_name" : "xiaotian8500"};
5470            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
5471            console.info("logMessage abnormal_contact_query_test_8500: rawContactId = " + rawContactId);
5472            expect(rawContactId > 0).assertTrue();
5473            var rawContactValues = {"display_name" : "xiaoli8500"};
5474            var rawContactId1 = await dataShareHelper.insert(rawContactUri, rawContactValues);
5475            console.info("logMessage abnormal_contact_query_test_8500: rawContactId1 = " + rawContactId1);
5476            expect(rawContactId1 > 0).assertTrue();
5477            await AbnormalQuery();
5478            await deleteRawContact("abnormal_contact_query_test_8500");
5479            done();
5480        } catch (error) {
5481            console.info('logMessage abnormal_contact_query_test_8500: raw_contact insert error' + error);
5482            done();
5483        }
5484
5485        async function AbnormalQuery()
5486        {
5487            var resultColumns = [ "id", "display_name" ];
5488            let condition = new dataShare.DataSharePredicates();
5489            condition.greaterThan("ids", "0");
5490            try {
5491                var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
5492                expect(resultSet.goToFirstRow()).assertEqual(false);
5493                console.info('logMessage abnormal_contact_query_test_8500: goToFirstRow' + resultSet.goToFirstRow());
5494                resultSet.close();
5495            } catch (error) {
5496                console.info('logMessage abnormal_contact_query_test_8500: query error = ' + error);
5497                done();
5498            }
5499        }
5500    });
5501
5502    /**
5503     * @tc.number  abnormal_contact_query_test_8600
5504     * @tc.name    When querying all the information of a single contact, an error field is passed in
5505     * @tc.desc    Function test
5506     */
5507    it("abnormal_contact_query_test_8600", 0, async function(done) {
5508        console.info("------------abnormal_contact_query_test_8600 is starting!-----------");
5509        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5510        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5511        try {
5512            var rawContactValues = {"display_name" : "xiaotian8600"};
5513            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
5514            console.info("logMessage abnormal_contact_query_test_8600: rawContactId = " + rawContactId);
5515            expect(rawContactId > 0).assertTrue();
5516            await AbnormalQuery();
5517            await deleteRawContact("abnormal_contact_query_test_8600");
5518            done();
5519        } catch (error) {
5520            console.info('logMessage abnormal_contact_query_test_8600: raw_contact insert error' + error);
5521            done();
5522        }
5523
5524        async function AbnormalQuery()
5525        {
5526            var resultColumns = [ "id", "display_names" ];
5527            let condition = new dataShare.DataSharePredicates();
5528            condition.equalTo("id", rawContactId.toString());
5529            try {
5530                var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
5531                expect(resultSet.goToFirstRow()).assertEqual(false);
5532                console.info('logMessage abnormal_contact_query_test_8600: goToFirstRow' + resultSet.goToFirstRow());
5533                resultSet.close();
5534            } catch (error) {
5535                console.info('logMessage abnormal_contact_query_test_8600: query error = ' + error);
5536                done();
5537            }
5538        }
5539    });
5540
5541    /**
5542     * @tc.number  abnormal_contact_query_test_8700
5543     * @tc.name    An incorrect field was passed in when querying group members
5544     * @tc.desc    Function test
5545     */
5546    it("abnormal_contact_query_test_8700", 0, async function(done) {
5547        console.info("------------abnormal_contact_query_test_8700 is starting!-----------");
5548        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5549        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5550        try {
5551            var rawContactValues = {"display_name" : "xiaotian8700"};
5552            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
5553            console.info("logMessage abnormal_contact_query_test_8700: rawContactId = " + rawContactId);
5554            expect(rawContactId > 0).assertTrue();
5555            var dataId = await insertData(rawContactId, "group_membership", 1, "");
5556            console.info("logMessage abnormal_contact_query_test_8700: dataId = " + dataId);
5557            expect(dataId > 0).assertTrue();
5558            await AbnormalQuery();
5559            await deleteRawContact("abnormal_contact_query_test_8700");
5560            done();
5561        } catch (error) {
5562            console.info('logMessage abnormal_contact_query_test_8700: raw_contact insert error' + error);
5563            done();
5564        }
5565
5566        async function AbnormalQuery()
5567        {
5568            var resultColumns = [ "raw_contact_id" ];
5569            let condition = new dataShare.DataSharePredicates();
5570            condition.equalTo("content_typess", "group_membership");
5571            try {
5572                var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
5573                expect(resultSet.goToFirstRow()).assertEqual(false);
5574                console.info('logMessage abnormal_contact_query_test_8700: goToFirstRow' + resultSet.goToFirstRow());
5575                resultSet.close();
5576            } catch (error) {
5577                console.info('logMessage abnormal_contact_query_test_8700: query error = ' + error);
5578                done();
5579            }
5580        }
5581    });
5582
5583    /**
5584     * @tc.number  abnormal_contact_query_test_8800
5585     * @tc.name    An incorrect field was passed in when querying favorite contacts
5586     * @tc.desc    Function test
5587     */
5588    it("abnormal_contact_query_test_8800", 0, async function(done) {
5589        console.info("------------abnormal_contact_query_test_8800 is starting!-----------");
5590        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5591        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5592        try {
5593            var rawContactValues = {"display_name" : "xiaotian8700", "favorite" : 1};
5594            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
5595            console.info("logMessage abnormal_contact_query_test_8800: rawContactId = " + rawContactId);
5596            expect(rawContactId > 0).assertTrue();
5597            await AbnormalQuery();
5598            await deleteRawContact("abnormal_contact_query_test_8800");
5599            done();
5600        } catch (error) {
5601            console.info('logMessage abnormal_contact_query_test_8800: raw_contact insert error' + error);
5602            done();
5603        }
5604
5605        async function AbnormalQuery()
5606        {
5607            var resultColumns = [];
5608            let condition = new dataShare.DataSharePredicates();
5609            condition.equalTo("ids", rawContactId.toString());
5610            try {
5611                var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
5612                expect(resultSet.goToFirstRow()).assertEqual(false);
5613                console.info('logMessage abnormal_contact_query_test_8800: goToFirstRow' + resultSet.goToFirstRow());
5614                resultSet.close();
5615            } catch (error) {
5616                console.info('logMessage abnormal_contact_query_test_8800: query error = ' + error);
5617                done();
5618            }
5619        }
5620    });
5621
5622    /**
5623     * @tc.number  abnormal_contact_query_test_8900
5624     * @tc.name    An incorrect field was passed in when querying recent contacts
5625     * @tc.desc    Function test
5626     */
5627    it("abnormal_contact_query_test_8900", 0, async function(done) {
5628        console.info("------------abnormal_contact_query_test_8900 is starting!-----------");
5629        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5630        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5631        try {
5632            var rawContactValues = {"display_name" : "xiaoyuzhou", "lastest_contacted_time" : 60};
5633            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
5634            console.info("logMessage abnormal_contact_query_test_8900: rawContactId = " + rawContactId);
5635            expect(rawContactId > 0).assertTrue();
5636            await AbnormalQuery();
5637            await deleteRawContact("abnormal_contact_query_test_8900");
5638            done();
5639        } catch (error) {
5640            console.info('logMessage abnormal_contact_query_test_8900: raw_contact insert error' + error);
5641            done();
5642        }
5643
5644        async function AbnormalQuery()
5645        {
5646            var resultColumns = [];
5647            let condition = new dataShare.DataSharePredicates();
5648            condition.greaterThan("lastest_contacted_timess", "50");
5649            try {
5650                var resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition);
5651                expect(resultSet.goToFirstRow()).assertEqual(false);
5652                console.info('logMessage abnormal_contact_query_test_8900: goToFirstRow' + resultSet.goToFirstRow());
5653                resultSet.close();
5654            } catch (error) {
5655                console.info('logMessage abnormal_contact_query_test_8900: query error = ' + error);
5656                done();
5657            }
5658        }
5659    });
5660
5661    /**
5662     * @tc.number  abnormal_contact_query_test_9000
5663     * @tc.name    An error field was passed in when querying the recently deleted contact
5664     * @tc.desc    Function test
5665     */
5666    it("abnormal_contact_query_test_9000", 0, async function(done) {
5667        console.info("------------abnormal_contact_query_test_9000 is starting!-----------");
5668        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5669        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5670        try {
5671            var rawContactValues = {"display_name" : "xiaotian"};
5672            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
5673            console.info("logMessage abnormal_contact_query_test_9000: rawContactId = " + rawContactId);
5674            expect(rawContactId > 0).assertTrue();
5675            let condition = new dataShare.DataSharePredicates();
5676            condition.equalTo("id", rawContactId.toString());
5677            var deleteCode = await dataShareHelper.delete(rawContactUri, condition);
5678            console.info('abnormal_contact_query_test_9000 : deleteRawContact deleteCode = ' + deleteCode);
5679            expect(deleteCode == 0).assertTrue();
5680            await AbnormalQuery();
5681            var conditionAll = new dataShare.DataSharePredicates();
5682            conditionAll.greaterThan("id", "0");
5683            var code = await dataShareHelper.delete(deletedUri, conditionAll);
5684            console.info('abnormal_contact_query_test_9000 : Completely delete code = ' + code);
5685            expect(code == 0).assertTrue();
5686            done();
5687        } catch (error) {
5688            console.info('logMessage abnormal_contact_query_test_9000: raw_contact insert error' + error);
5689            done();
5690        }
5691
5692        async function AbnormalQuery()
5693        {
5694            var resultColumns = [];
5695            let condition = new dataShare.DataSharePredicates();
5696            condition.orderByDesc("delete_timess");
5697            try {
5698                var resultSet = await dataShareHelper.query(deletedRawContactUri, resultColumns, condition);
5699                expect(resultSet.goToFirstRow()).assertEqual(false);
5700                console.info('logMessage abnormal_contact_query_test_9000: goToFirstRow' + resultSet.goToFirstRow());
5701                resultSet.close();
5702            } catch (error) {
5703                console.info('logMessage abnormal_contact_query_test_9000: query error = ' + error);
5704                done();
5705            }
5706        }
5707    });
5708
5709    /**
5710     * @tc.number  abnormal_contact_query_test_9100
5711     * @tc.name    When querying all mobile phone numbers, an error field is passed in
5712     * @tc.desc    Function test
5713     */
5714    it("abnormal_contact_query_test_9100", 0, async function(done) {
5715        console.info("------------abnormal_contact_query_test_9100 is starting!-----------");
5716        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5717        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5718        try {
5719            var rawContactValues = {"display_name" : "xiaotian9100"};
5720            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
5721            console.info("logMessage abnormal_contact_query_test_9100: rawContactId = " + rawContactId);
5722            expect(rawContactId > 0).assertTrue();
5723            var dataId = await insertData(rawContactId, "phone", "11159100", "");
5724            console.info("logMessage abnormal_contact_query_test_9100: dataId = " + dataId);
5725            var dataId1 = await insertData(rawContactId, "phone", "111591009100", "");
5726            console.info("logMessage abnormal_contact_query_test_9100: dataId1 = " + dataId1);
5727            await AbnormalQuery();
5728            await deleteRawContact("abnormal_contact_query_test_9100");
5729            await deleteAll(contactDataUri, "abnormal_contact_query_test_9100");
5730            done();
5731        } catch (error) {
5732            console.info('logMessage abnormal_contact_query_test_9100: raw_contact insert error' + error);
5733            done();
5734        }
5735
5736        async function AbnormalQuery()
5737        {
5738            var resultColumns = [ "detail_info" ];
5739            let condition = new dataShare.DataSharePredicates();
5740            condition.equalTo("content_typess", "phone");
5741            try {
5742                var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
5743                expect(resultSet.goToFirstRow()).assertEqual(false);
5744                console.info('logMessage abnormal_contact_query_test_9100: goToFirstRow' + resultSet.goToFirstRow());
5745                resultSet.close();
5746            } catch (error) {
5747                console.info('logMessage abnormal_contact_query_test_9100: query error = ' + error);
5748                done();
5749            }
5750        }
5751    });
5752
5753    /**
5754     * @tc.number  abnormal_contact_query_test_9200
5755     * @tc.name    When querying all mailboxes, an error field was passed in
5756     * @tc.desc    Function test
5757     */
5758    it("abnormal_contact_query_test_9200", 0, async function(done) {
5759        console.info("------------abnormal_contact_query_test_9200 is starting!-----------");
5760        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5761        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5762        try {
5763            var rawContactValues = {"display_name" : "xiaotian9100"};
5764            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
5765            console.info("logMessage abnormal_contact_query_test_9200: rawContactId = " + rawContactId);
5766            expect(rawContactId > 0).assertTrue();
5767            var dataId = await insertData(rawContactId, "email", "fox@1.com", "");
5768            console.info("logMessage abnormal_contact_query_test_9200: dataId = " + dataId);
5769            var dataId1 = await insertData(rawContactId, "phone", "fox@2.com", "");
5770            console.info("logMessage abnormal_contact_query_test_9200: dataId1 = " + dataId1);
5771            await AbnormalQuery();
5772            await deleteRawContact("abnormal_contact_query_test_9200");
5773            await deleteAll(contactDataUri, "abnormal_contact_query_test_9200");
5774            done();
5775        } catch (error) {
5776            console.info('logMessage abnormal_contact_query_test_9200: raw_contact insert error' + error);
5777            done();
5778        }
5779
5780        async function AbnormalQuery()
5781        {
5782            var resultColumns = [ "detail_info" ];
5783            let condition = new dataShare.DataSharePredicates();
5784            condition.equalTo("content_typess", "email");
5785            try {
5786                var resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition);
5787                expect(resultSet.goToFirstRow()).assertEqual(false);
5788                console.info('logMessage abnormal_contact_query_test_9200: goToFirstRow' + resultSet.goToFirstRow());
5789                resultSet.close();
5790            } catch (error) {
5791                console.info('logMessage abnormal_contact_query_test_9200: query error = ' + error);
5792                done();
5793            }
5794        }
5795    });
5796
5797    /**
5798     * @tc.number  abnormal_contact_delete_test_10000
5799     * @tc.name    When querying all mailboxes, an error field was passed in
5800     * @tc.desc    Function test
5801     */
5802    it("abnormal_contact_delete_test_10000", 0, async function(done) {
5803        console.info("------------abnormal_contact_delete_test_10000 is starting!-----------");
5804        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5805        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5806        try {
5807            var rawContactValues = {"display_name" : "xiaotian9300"};
5808            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
5809            console.info("logMessage abnormal_contact_delete_test_10000: rawContactId = " + rawContactId);
5810            expect(rawContactId > 0).assertTrue();
5811            var dataId = await insertData(rawContactId, "email", "fox@1.com", "");
5812            console.info("logMessage abnormal_contact_delete_test_10000: dataId = " + dataId);
5813            var dataId1 = await insertData(rawContactId, "phone", "fox@2.com", "");
5814            console.info("logMessage abnormal_contact_delete_test_10000: dataId1 = " + dataId1);
5815
5816            var errorUri = "datashare:///com.ohos.contactsdataability/contacts/contact_datasss";
5817            let condition = new dataShare.DataSharePredicates();
5818            condition.equalTo("id", dataId.toString());
5819            var deleteCode = await dataShareHelper.delete(errorUri, condition);
5820            console.info(' abnormal_contact_delete_test_10000 : deleteAll deleteCode = ' + deleteCode);
5821            expect(deleteCode == -1).assertTrue();
5822            var map = new Map();
5823            map.set("id", dataId.toString());
5824            map.set("detail_info", "fox@1.com");
5825            await contactsQuery(map, "abnormal_contact_delete_test_10000", contactDataUri);
5826            await deleteRawContact("abnormal_contact_delete_test_10000");
5827            await deleteAll(contactDataUri, "abnormal_contact_delete_test_10000");
5828            done();
5829        } catch (error) {
5830            console.info('logMessage abnormal_contact_delete_test_10000: raw_contact insert error' + error);
5831            done();
5832        }
5833    });
5834
5835    /**
5836     * @tc.number  abnormal_contact_delete_test_9300
5837     * @tc.name    When deleting, an incorrect URI was passed in
5838     * @tc.desc    Function test
5839     */
5840    it("abnormal_contact_delete_test_9300", 0, async function(done) {
5841        console.info("------------abnormal_contact_delete_test_9300 is starting!-----------");
5842        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5843        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5844        try {
5845            var rawContactValues = {"display_name" : "xiaotian9300"};
5846            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
5847            console.info("logMessage abnormal_contact_delete_test_9300: rawContactId = " + rawContactId);
5848            expect(rawContactId > 0).assertTrue();
5849            var dataId = await insertData(rawContactId, "email", "fox@1.com", "");
5850            console.info("logMessage abnormal_contact_delete_test_9300: dataId = " + dataId);
5851            var dataId1 = await insertData(rawContactId, "phone", "fox@2.com", "");
5852            console.info("logMessage abnormal_contact_delete_test_9300: dataId1 = " + dataId1);
5853
5854            var errorUri = "datashare:///com.ohos.contactsdataability/contacts/raw_contactsss";
5855            let condition = new dataShare.DataSharePredicates();
5856            condition.equalTo("id", rawContactId.toString());
5857            var deleteCode = await dataShareHelper.delete(errorUri, condition);
5858            console.info(' abnormal_contact_delete_test_9300 : deleteAll deleteCode = ' + deleteCode);
5859            expect(deleteCode == -1).assertTrue();
5860            var map = new Map();
5861            map.set("id", rawContactId.toString());
5862            map.set("display_name", "xiaotian9300");
5863            await contactsQuery(map, "abnormal_contact_delete_test_9300", rawContactUri);
5864            await deleteRawContact("abnormal_contact_delete_test_9300");
5865            await deleteAll(contactDataUri, "abnormal_contact_delete_test_9300");
5866            done();
5867        } catch (error) {
5868            console.info('logMessage abnormal_contact_delete_test_9300: raw_contact insert error' + error);
5869            done();
5870        }
5871    });
5872
5873    /**
5874     * @tc.number  abnormal_contact_delete_test_9400
5875     * @tc.name    When deleting contacts in batch, an error field is passed in
5876     * @tc.desc    Function test
5877     */
5878    it("abnormal_contact_delete_test_9400", 0, async function(done) {
5879        console.info("------------abnormal_contact_delete_test_9400 is starting!-----------");
5880        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5881        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5882        try {
5883            var rawContactValues = {"display_name" : "xiaotian9400"};
5884            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
5885            console.info("logMessage abnormal_contact_delete_test_9400: rawContactId = " + rawContactId);
5886            expect(rawContactId > 0).assertTrue();
5887            var rawContactValues = {"display_name" : "xiaoli9400"};
5888            var rawContactId1 = await dataShareHelper.insert(rawContactUri, rawContactValues);
5889            console.info("logMessage abnormal_contact_delete_test_9400: rawContactId1 = " + rawContactId1);
5890            expect(rawContactId1 > 0).assertTrue();
5891
5892            let condition = new dataShare.DataSharePredicates();
5893            condition.equalTo("ids", rawContactId.toString());
5894            condition.or();
5895            condition.equalTo("ids", rawContactId1.toString())
5896            var deleteCode = await dataShareHelper.delete(rawContactUri, condition);
5897            console.info('abnormal_contact_delete_test_9400 :  deleteCode = ' + deleteCode);
5898            expect(deleteCode == -1).assertTrue();
5899            await deleteRawContact("abnormal_contact_delete_test_9400");
5900            done();
5901        } catch (error) {
5902            console.info('logMessage abnormal_contact_delete_test_9400: raw_contact insert error' + error);
5903            done();
5904        }
5905    });
5906
5907    /**
5908     * @tc.number  abnormal_contact_favorite_test_9500
5909     * @tc.name    When collecting contacts in batch, the error field is transferred
5910     * @tc.desc    Function test
5911     */
5912    it("abnormal_contact_favorite_test_9500", 0, async function(done) {
5913        console.info("------------abnormal_contact_favorite_test_9500 is starting!-----------");
5914        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5915        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5916        try {
5917            var rawContactValues = {"display_name" : "xiaotian9500", "favorite" : 0};
5918            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
5919            console.info("logMessage abnormal_contact_favorite_test_9500: rawContactId = " + rawContactId);
5920            expect(rawContactId > 0).assertTrue();
5921            var rawContactValues = {"display_name" : "xiaoli9500", "favorite" : 0};
5922            var rawContactId1 = await dataShareHelper.insert(rawContactUri, rawContactValues);
5923            console.info("logMessage abnormal_contact_favorite_test_9500: rawContactId1 = " + rawContactId1);
5924            expect(rawContactId1 > 0).assertTrue();
5925
5926            let condition = new dataShare.DataSharePredicates();
5927            var updateValues = {"favorites" : 1};
5928            condition.equalTo("id", rawContactId.toString());
5929            condition.or();
5930            condition.equalTo("id", rawContactId1.toString())
5931            var code = await dataShareHelper.update(rawContactUri, updateValues, condition);
5932            console.info(' abnormal_contact_favorite_test_9500 : update code = ' + code);
5933            expect(code == -1).assertTrue();
5934            await deleteRawContact("abnormal_contact_favorite_test_9500");
5935            done();
5936        } catch (error) {
5937            console.info('logMessage abnormal_contact_favorite_test_9500: raw_contact insert error' + error);
5938            done();
5939        }
5940    });
5941
5942    /**
5943     * @tc.number  abnormal_contact_insertblocklist_test_9600
5944     * @tc.name    When collecting contacts in batch, the error field is transferred
5945     * @tc.desc    Function test
5946     */
5947    it("abnormal_contact_insertblocklist_test_9600", 0, async function(done) {
5948        console.info("------------abnormal_contact_insertblocklist_test_9600 is starting!-----------");
5949        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5950        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5951        try {
5952            var rawContactValues = {
5953                "display_name" : "xiaotian9600",
5954            };
5955            var phoneNumber = randomNum(12);
5956            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
5957            console.info("logMessage abnormal_contact_insertblocklist_test_9600: rawContactId = " + rawContactId);
5958            expect(rawContactId > 0).assertTrue();
5959            var dataId = await insertData(rawContactId, "phone", phoneNumber, "");
5960            console.info("logMessage abnormal_contact_insertblocklist_test_9600: dataId = " + dataId);
5961            var rawContactValues = {
5962                "display_name" : "xiaoli9600",
5963            };
5964            var rawContactId1 = await dataShareHelper.insert(rawContactUri, rawContactValues);
5965            console.info("logMessage abnormal_contact_insertblocklist_test_9600: rawContactId1 = " + rawContactId1);
5966            expect(rawContactId1 > 0).assertTrue();
5967            var dataId1 = await insertData(rawContactId1, "phone", phoneNumber, "");
5968            console.info("logMessage abnormal_contact_insertblocklist_test_9600: dataId1 = " + dataId1);
5969
5970            var blocklist = {"phone_numbers" : phoneNumber};
5971            var code = await dataShareHelper.insert(contactBlocklistUri, blocklist);
5972            expect(code == -1).assertTrue();
5973            await deleteRawContact("abnormal_contact_insertblocklist_test_9600");
5974            await deleteAll(contactDataUri, "abnormal_contact_insertblocklist_test_9600");
5975            done();
5976        } catch (error) {
5977            console.info('logMessage abnormal_contact_insertblocklist_test_9600: raw_contact insert error' + error);
5978            done();
5979        }
5980    });
5981
5982    /**
5983     * @tc.number  abnormal_contact_insertGroup_test_9700
5984     * @tc.name    When a contact joins a group in batch, an error field is passed
5985     * @tc.desc    Function test
5986     */
5987    it("abnormal_contact_insertGroup_test_9700", 0, async function(done) {
5988        console.info("------------abnormal_contact_insertGroup_test_9700 is starting!-----------");
5989        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
5990        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
5991        try {
5992            var rawContactValues = {"display_name" : "xiaotian9700"};
5993            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
5994            console.info("logMessage abnormal_contact_insertGroup_test_9700: rawContactId = " + rawContactId);
5995            expect(rawContactId > 0).assertTrue();
5996            var contactDataValues1 = {
5997                "raw_contact_id" : rawContactId,
5998                "content_typess" : "group_membership",
5999                "detail_info" : 1
6000            };
6001            var contactDataId = await dataShareHelper.insert(contactDataUri, contactDataValues1);
6002            console.info("abnormal_contact_insertGroup_test_9700 logMessage : contactDataId " + contactDataId);
6003            expect(contactDataId == -1).assertTrue();
6004            var rawContactValues = {"display_name" : "xiaoli9700"};
6005            var rawContactId1 = await dataShareHelper.insert(rawContactUri, rawContactValues);
6006            console.info("logMessage abnormal_contact_insertGroup_test_9700: rawContactId1 = " + rawContactId1);
6007            expect(rawContactId1 > 0).assertTrue();
6008            var contactDataValues2 = {
6009                "raw_contact_id" : rawContactId1,
6010                "content_typess" : "group_membership",
6011                "detail_info" : 1
6012            };
6013            var contactDataId1 = await dataShareHelper.insert(contactDataUri, contactDataValues2);
6014            console.info("abnormal_contact_insertGroup_test_9700 logMessage : contactDataId1 " + contactDataId1);
6015            expect(contactDataId1 == -1).assertTrue();
6016            await deleteRawContact("abnormal_contact_insertGroup_test_9700");
6017            done();
6018        } catch (error) {
6019            console.info('logMessage abnormal_contact_insertGroup_test_9700: raw_contact insert error' + error);
6020            done();
6021        }
6022    });
6023
6024    /**
6025     * @tc.number  abnormal_contact_pinyinquery_test_9800
6026     * @tc.name    Insert a name with special characters to view the converted Pinyin
6027     * @tc.desc    Function test
6028     */
6029    it("abnormal_contact_pinyinquery_test_9800", 0, async function(done) {
6030        console.info("--------logMessage abnormal_contact_pinyinquery_test_9800 is starting!-------");
6031        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
6032        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
6033
6034        var rawContactValues = {"display_name" : "李bp玉成욱"};
6035        try {
6036            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
6037            sleep(sleep_one);
6038            console.info('logMessage abnormal_contact_pinyinquery_test_9800 rawContactId = ' + rawContactId);
6039            expect(rawContactId > 0).assertTrue();
6040            var dataId = await insertData(rawContactId, "name", "李bp玉成욱", "");
6041            console.info('logMessage abnormal_contact_pinyinquery_test_9800 dataId = ' + dataId);
6042            expect(dataId > 0).assertTrue();
6043            await query();
6044            await deleteRawContact("abnormal_contact_pinyinquery_test_9800");
6045            await deleteAll(contactDataUri, "abnormal_contact_pinyinquery_test_9800")
6046            done();
6047        } catch (error) {
6048            console.info('logMessage abnormal_contact_pinyinquery_test_9800 raw_contact insert error = ' + error);
6049            done();
6050        }
6051
6052        async function query()
6053        {
6054            var resultColumns = [ "search_name" ];
6055            let condition = new dataShare.DataSharePredicates();
6056            condition.equalTo("raw_contact_id", rawContactId.toString());
6057            try {
6058                var resultSet = await dataShareHelper.query(searchContactUri, resultColumns, condition);
6059                if (resultSet.rowCount > 0) {
6060                    if (resultSet.goToFirstRow()) {
6061                        do {
6062                            var name = resultSet.getString(resultSet.getColumnIndex("search_name"));
6063                            console.info(
6064                                ' abnormal_contact_pinyinquery_test_9800 :logMessage contactsQuery name = ' + name);
6065                            expect(name == "李bp玉成욱||libpyucheng욱||lbpyc욱").assertEqual(true);
6066                        } while (resultSet.goToNextRow());
6067                    }
6068                }
6069                resultSet.close();
6070            } catch (error) {
6071                console.info('logMessage abnormal_contact_pinyinquery_test_9800 query error = ' + error);
6072                done();
6073            }
6074        }
6075    });
6076
6077    /**
6078     * @tc.number  abnormal_contact_query_test_9900
6079     * @tc.name    An incorrect field name was passed in during retrieval
6080     * @tc.desc    Function test
6081     */
6082    it("abnormal_contact_query_test_9900", 0, async function(done) {
6083        console.info("--------logMessage abnormal_contact_query_test_9900 is starting!-------");
6084        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
6085        console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper);
6086
6087        var rawContactValues = {"display_name" : "键盘"};
6088        try {
6089            var rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues);
6090            sleep(sleep_one);
6091            console.info('logMessage abnormal_contact_query_test_9900 rawContactId = ' + rawContactId);
6092            expect(rawContactId > 0).assertTrue();
6093            var dataId = await insertData(rawContactId, "name", "键盘", "");
6094            console.info('logMessage abnormal_contact_query_test_9900 dataId = ' + dataId);
6095            expect(dataId > 0).assertTrue();
6096            await query();
6097            await deleteRawContact("abnormal_contact_query_test_9900");
6098            await deleteAll(contactDataUri, "abnormal_contact_query_test_9900")
6099            done();
6100        } catch (error) {
6101            console.info('logMessage abnormal_contact_query_test_9900 raw_contact insert error = ' + error);
6102            done();
6103        }
6104
6105        async function query()
6106        {
6107            var resultColumns = [];
6108            let condition = new dataShare.DataSharePredicates();
6109            condition.like("search_namesss", "%jp%");
6110            try {
6111                var resultSet = await dataShareHelper.query(searchContactUri, resultColumns, condition);
6112                console.info(
6113                    ' abnormal_contact_query_test_9900 :resultSet.goToFirstRow() = ' + resultSet.goToFirstRow());
6114                expect(resultSet.goToFirstRow() == false).assertTrue();
6115                resultSet.close();
6116            } catch (error) {
6117                console.info('logMessage abnormal_contact_pinyinquery_test_9800 query error = ' + error);
6118                done();
6119            }
6120        }
6121    });
6122
6123    afterAll(async function() {
6124        var tag = "Contacts_test_start_deleted";
6125        let condition = new dataShare.DataSharePredicates();
6126        condition.greaterThan("id", "0");
6127        let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS);
6128        console.info(tag + ': start ! dataShareHelper = ' + dataShareHelper);
6129        var deleteBlockList = await dataShareHelper.delete(contactBlocklistUri, condition);
6130        console.info(tag + " : logMessage : deleteBlockList = " + deleteBlockList);
6131        var deletedGroup = await dataShareHelper.delete(groupUri, condition);
6132        console.info(tag + " : logMessage : deletedGroup = " + deletedGroup);
6133        var dataDeletedCode = await dataShareHelper.delete(contactDataUri, condition);
6134        sleep(sleep_two);
6135        console.info(tag + " : logMessage : dataDeletedCode = " + dataDeletedCode);
6136        var rawContactDeleted = await dataShareHelper.delete(rawContactUri, condition);
6137        sleep(sleep_two);
6138        console.info(tag + " : logMessage : rawContactDeleted = " + rawContactDeleted);
6139        var deleted = await dataShareHelper.delete(deletedUri, condition);
6140        sleep(sleep_two);
6141        console.info(tag + " : logMessage : deleted = " + deleted);
6142    });
6143});
6144
6145function randomNum (num) {
6146    let number = toString(Math.floor(Math.random() * (9 * Math.pow(10, num))) + (1 * Math.pow(10, num)));
6147    return number ;
6148}
6149