1 /*
2 * Copyright (c) 2024 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 #undef private
16 #undef protected
17 #define private public
18 #define protected public
19 #include <thread>
20 #include "gtest/gtest.h"
21 #include "test_log.h"
22 #include "api_cache_manager.h"
23 #include "message_parcel.h"
24 #include "iservice_registry.h"
25 #include "if_system_ability_manager.h"
26
27 using namespace testing::ext;
28 namespace OHOS {
29 namespace {
30 std::u16string g_descriptor1 = u"testdescriptor1";
31 std::u16string g_descriptor2 = u"testdescriptor2";
32 std::u16string g_descriptor3 = u"testdescriptor3";
33
34 const std::u16string CACHE_KEY_STR_1 = u"ohos.cacheAPIKey.1";
35 const std::u16string CACHE_KEY_STR_2 = u"ohos.cacheAPIKey.2";
36 const std::u16string CACHE_VALUE_STR_1 = u"ohos.cacheAPIValue.1";
37 const std::u16string CACHE_VALUE_STR_2 = u"ohos.cacheAPIValue.2";
38 const std::string CACHE_KEY_STR_3 = "ohoscacheAPIKey3";
39 const std::string CACHE_VALUE_STR_3 = "ohoscacheAPIValue3";
40 constexpr int32_t CACHE_KEY_INT_1 = 9999;
41 constexpr int32_t CACHE_VALUE_INT_1 = 6666;
42
43 constexpr uint32_t CACHE_API_CODE_100 = 100;
44 constexpr uint32_t CACHE_API_CODE_1 = 1;
45
46 constexpr int64_t EXPIRE_TIME_1S = 1000;
47 constexpr int64_t EXPIRE_TIME_100S = 100000;
48 constexpr int64_t EXPIRE_TIME_3S = 3000;
49
50 }
51
52 class CacheManagerTest : public testing::Test {
53 public:
54 static void SetUpTestCase();
55 static void TearDownTestCase();
56 void SetUp();
57 void TearDown();
58 };
59
SetUpTestCase()60 void CacheManagerTest::SetUpTestCase()
61 {
62 DTEST_LOG << "SetUpTestCase" << std::endl;
63 }
64
TearDownTestCase()65 void CacheManagerTest::TearDownTestCase()
66 {
67 DTEST_LOG << "TearDownTestCase" << std::endl;
68 }
69
SetUp()70 void CacheManagerTest::SetUp()
71 {
72 DTEST_LOG << "SetUp" << std::endl;
73 }
74
TearDown()75 void CacheManagerTest::TearDown()
76 {
77 DTEST_LOG << "TearDown" << std::endl;
78 }
79 /**
80 * @tc.name: AddAndDeleteCacheAPI001
81 * @tc.desc: test AddCacheApi and DelCacheApi
82 * @tc.type: FUNC
83 * @tc.require:
84 */
85 HWTEST_F(CacheManagerTest, AddAndDeleteCacheAPI001, TestSize.Level2)
86 {
87 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor1, CACHE_API_CODE_100, EXPIRE_TIME_100S);
88 EXPECT_EQ(ApiCacheManager::GetInstance().caches_.size(), 1);
89
90 // repeated addition
91 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor1, CACHE_API_CODE_100, EXPIRE_TIME_100S);
92 EXPECT_EQ(ApiCacheManager::GetInstance().caches_.size(), 1);
93
94 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor2, CACHE_API_CODE_100, EXPIRE_TIME_100S);
95 EXPECT_EQ(ApiCacheManager::GetInstance().caches_.size(), 2);
96
97 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor1, CACHE_API_CODE_1);
98 EXPECT_EQ(ApiCacheManager::GetInstance().caches_.size(), 2);
99
100 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor1, CACHE_API_CODE_100);
101 EXPECT_EQ(ApiCacheManager::GetInstance().caches_.size(), 1);
102
103 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor2, CACHE_API_CODE_100);
104 EXPECT_EQ(ApiCacheManager::GetInstance().caches_.size(), 0);
105 }
106
107 /**
108 * @tc.name: PreSendRequest001
109 * @tc.desc: test AddCacheApi and DelCacheApi
110 * @tc.type: FUNC
111 * @tc.require:
112 */
113 HWTEST_F(CacheManagerTest, PreSendRequest001, TestSize.Level2)
114 {
115 bool ret;
116
117 MessageParcel data1;
118 MessageParcel reply1;
119 // (des1, apicode100) api has not enabled the proxy cache
120 ret = ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_100, data1, reply1);
121 EXPECT_EQ(ret, false);
122
123 MessageParcel data2;
124 MessageParcel reply2;
125 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor1, CACHE_API_CODE_100, EXPIRE_TIME_3S);
126 ret = data2.WriteString16(CACHE_KEY_STR_1);
127 EXPECT_EQ(ret, true);
128 // cache miss
129 ret = ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_100, data2, reply2);
130 EXPECT_EQ(ret, false);
131
132 MessageParcel data3;
133 MessageParcel reply3;
134 data3.WriteString16(CACHE_KEY_STR_1);
135 reply3.WriteString16(CACHE_VALUE_STR_1);
136 // add cache
137 ret = ApiCacheManager::GetInstance().PostSendRequest(g_descriptor1, CACHE_API_CODE_100, data3, reply3);
138 EXPECT_EQ(ret, true);
139
140 MessageParcel data4;
141 MessageParcel reply4;
142 std::u16string cacheReplyStr1;
143 data4.WriteString16(CACHE_KEY_STR_1);
144 // cache hit
145 ret = ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_100, data4, reply4);
146 EXPECT_EQ(ret, true);
147
148 reply4.ReadString16(cacheReplyStr1);
149 EXPECT_EQ(cacheReplyStr1.compare(CACHE_VALUE_STR_1), 0);
150
151 MessageParcel data5;
152 MessageParcel reply5;
153 std::u16string cacheReplyStr2;
154 data5.WriteString16(CACHE_KEY_STR_2);
155 ret = ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_100, data5, reply5);
156 EXPECT_EQ(ret, false);
157
158 ret = reply5.ReadString16(cacheReplyStr2);
159 EXPECT_EQ(ret, false);
160
161 // cache expiration
162 sleep(4);
163 MessageParcel data6;
164 MessageParcel reply6;
165 ret = ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_100, data6, reply6);
166 EXPECT_EQ(ret, false);
167 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor1, CACHE_API_CODE_100);
168 }
169
LRUTest001AddCache1()170 void LRUTest001AddCache1()
171 {
172 bool testTrueBool = true;
173 bool testFalseBool = true;
174 bool ret;
175 {
176 MessageParcel data;
177 MessageParcel reply;
178 EXPECT_EQ(data.WriteBool(testTrueBool), true);
179
180 EXPECT_EQ(reply.WriteBool(testFalseBool), true);
181 ret = ApiCacheManager::GetInstance().PostSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
182 EXPECT_EQ(ret, true);
183 }
184 {
185 MessageParcel data;
186 MessageParcel reply;
187 EXPECT_EQ(data.WriteBool(testTrueBool), true);
188
189 ret = ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
190 EXPECT_EQ(ret, true);
191 EXPECT_EQ(reply.ReadBool(ret), true);
192 EXPECT_EQ(ret, testFalseBool);
193 }
194
195 return;
196 }
197
LRUTest001AddCache2()198 void LRUTest001AddCache2()
199 {
200 int32_t keyInt32T = -999;
201 int16_t keyInt16T = -666;
202 double keyDouble = -3.1445926358979323846;
203 float keyFloat = 0.012345;
204 std::u16string keyU16string = u"keyU16161616Ustring";
205 double valDouble = -9.3284928942;
206 float valFloat = 7.32489;
207 std::string valString = "valstringvalvalvalvalvalvalvalval";
208 bool ret;
209 {
210 MessageParcel data;
211 MessageParcel reply;
212 EXPECT_EQ(data.WriteInt32(keyInt32T), true);
213 EXPECT_EQ(data.WriteInt16(keyInt16T), true);
214 EXPECT_EQ(data.WriteDouble(keyDouble), true);
215 EXPECT_EQ(data.WriteFloat(keyFloat), true);
216 EXPECT_EQ(data.WriteString16(keyU16string), true);
217
218 EXPECT_EQ(reply.WriteDouble(valDouble), true);
219 EXPECT_EQ(reply.WriteFloat(valFloat), true);
220 EXPECT_EQ(reply.WriteString(valString), true);
221 ret = ApiCacheManager::GetInstance().PostSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
222 EXPECT_EQ(ret, true);
223 }
224 {
225 MessageParcel data;
226 MessageParcel reply;
227 EXPECT_EQ(data.WriteInt32(keyInt32T), true);
228 EXPECT_EQ(data.WriteInt16(keyInt16T), true);
229 EXPECT_EQ(data.WriteDouble(keyDouble), true);
230 EXPECT_EQ(data.WriteFloat(keyFloat), true);
231 EXPECT_EQ(data.WriteString16(keyU16string), true);
232
233 ret = ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
234 EXPECT_EQ(ret, true);
235 double retdouble;
236 float retfloat;
237 std::string retstring;
238 EXPECT_EQ(reply.ReadDouble(retdouble), true);
239 EXPECT_EQ(reply.ReadFloat(retfloat), true);
240 EXPECT_EQ(reply.ReadString(retstring), true);
241 EXPECT_EQ(retdouble, valDouble);
242 EXPECT_EQ(retfloat, valFloat);
243 EXPECT_EQ(retstring, valString);
244 }
245 return;
246 }
247
LRUTest001AddCache3()248 void LRUTest001AddCache3()
249 {
250 double keyDouble = -3.1445926358979323846;
251 float keyFloat = 0.012345;
252 std::u16string keyU16string = u"keyU16161616Ustring";
253 std::vector<std::string> keyStringVector = {"hello", "world", "!"};
254 std::vector<std::u16string> key16StringVector = {u"key", u"vector", u"!!!"};
255
256 double valDouble = -9.3284928942;
257 float valFloat = 7.32489;
258 std::string valString = "valstringvalvalvalvalvalvalvalval";
259 std::vector<std::u16string> val16StringVector = {u"val", u"hhh", u"!!!"};
260
261 MessageParcel data;
262 MessageParcel reply;
263 EXPECT_EQ(data.WriteStringVector(keyStringVector), true);
264 EXPECT_EQ(data.WriteString16Vector(key16StringVector), true);
265 EXPECT_EQ(data.WriteDouble(keyDouble), true);
266 EXPECT_EQ(data.WriteFloat(keyFloat), true);
267 EXPECT_EQ(data.WriteString16(keyU16string), true);
268
269 EXPECT_EQ(reply.WriteDouble(valDouble), true);
270 EXPECT_EQ(reply.WriteFloat(valFloat), true);
271 EXPECT_EQ(reply.WriteString(valString), true);
272 EXPECT_EQ(reply.WriteString16Vector(val16StringVector), true);
273 auto ret = ApiCacheManager::GetInstance().PostSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
274 EXPECT_EQ(ret, true);
275 }
276
LRUTest001AddCache4()277 void LRUTest001AddCache4()
278 {
279 std::u16string keyU16string = u"keyU16161616Ustring";
280 std::vector<std::string> keyStringVector = {"hello", "world", "!"};
281 double valDouble = -9.3284928942;
282 float valFloat = 7.32489;
283 bool ret;
284
285 {
286 MessageParcel data;
287 MessageParcel reply;
288 EXPECT_EQ(data.WriteStringVector(keyStringVector), true);
289 EXPECT_EQ(data.WriteString16(keyU16string), true);
290
291 EXPECT_EQ(reply.WriteDouble(valDouble), true);
292 EXPECT_EQ(reply.WriteFloat(valFloat), true);
293 ret = ApiCacheManager::GetInstance().PostSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
294 EXPECT_EQ(ret, true);
295 }
296
297 {
298 MessageParcel data;
299 MessageParcel reply;
300 EXPECT_EQ(data.WriteStringVector(keyStringVector), true);
301 EXPECT_EQ(data.WriteString16(keyU16string), true);
302
303 ret = ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
304 EXPECT_EQ(ret, true);
305 double retdouble;
306 float retfloat;
307 EXPECT_EQ(reply.ReadDouble(retdouble), true);
308 EXPECT_EQ(reply.ReadFloat(retfloat), true);
309 EXPECT_EQ(retdouble, valDouble);
310 EXPECT_EQ(retfloat, valFloat);
311 }
312 return;
313 }
314
LRUTest001AddCache5()315 void LRUTest001AddCache5()
316 {
317 bool ret;
318 const std::u16string testKeyToken = u"ohos.keytesttoken.KEYTESTTOKEN";
319 const std::u16string testValToken = u"ohos.valtesttoken.VALTESTTOKEN";
320 MessageParcel data;
321 MessageParcel reply;
322 EXPECT_EQ(data.WriteInterfaceToken(testKeyToken), true);
323
324 EXPECT_EQ(reply.WriteInterfaceToken(testValToken), true);
325 ret = ApiCacheManager::GetInstance().PostSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
326 EXPECT_EQ(ret, true);
327 return;
328 }
329
LRUTest001AddCache6()330 void LRUTest001AddCache6()
331 {
332 uintptr_t keyPtr = 6666;
333 uintptr_t valPtr = 300;
334 bool ret;
335 {
336 MessageParcel data;
337 MessageParcel reply;
338 EXPECT_EQ(data.WritePointer(keyPtr), true);
339
340 EXPECT_EQ(reply.WritePointer(valPtr), true);
341 ret = ApiCacheManager::GetInstance().PostSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
342 EXPECT_EQ(ret, true);
343 }
344 {
345 MessageParcel data;
346 MessageParcel reply;
347 EXPECT_EQ(data.WritePointer(keyPtr), true);
348
349 ret = ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
350 EXPECT_EQ(ret, true);
351 EXPECT_EQ(reply.ReadPointer(), valPtr);
352 }
353 return;
354 }
355
LRUTest001AddCache7()356 void LRUTest001AddCache7()
357 {
358 std::string valString = "valstringvalvalvalvalvalvalvalval";
359 uint16_t keyUint16T = 777;
360 MessageParcel data;
361 MessageParcel reply;
362 EXPECT_EQ(data.WriteUint16Unaligned(keyUint16T), true);
363
364 EXPECT_EQ(reply.WriteString(valString), true);
365 auto ret = ApiCacheManager::GetInstance().PostSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
366 EXPECT_EQ(ret, true);
367 return;
368 }
369
LRUTest001ParcelCache8(MessageParcel & data)370 void LRUTest001ParcelCache8(MessageParcel& data)
371 {
372 int32_t keyInt32T = -999;
373 uint32_t keyUint32T = 888;
374 int16_t keyInt16T = -666;
375 uint16_t keyUint16T = 777;
376 double keyDouble = -3.1445926358979323846;
377 float keyFloat = 0.012345;
378 std::string keyString = "keystringabcdefghijklmn";
379 std::u16string keyU16string = u"keyU16161616Ustring";
380 std::vector<std::string> keyStringVector = {"hello", "world", "!"};
381 std::vector<std::u16string> key16StringVector = {u"key", u"vector", u"!!!"};
382 const std::u16string testKeyToken = u"ohos.keytesttoken.KEYTESTTOKEN";
383 uintptr_t keyPtr = 6666;
384 bool testTrueBool = true;
385
386 EXPECT_EQ(data.WriteInterfaceToken(testKeyToken), true);
387 EXPECT_EQ(data.WriteInt32(keyInt32T), true);
388 EXPECT_EQ(data.WriteUint32(keyUint32T), true);
389 EXPECT_EQ(data.WriteInt16(keyInt16T), true);
390 EXPECT_EQ(data.WriteUint16(keyUint16T), true);
391 EXPECT_EQ(data.WriteDouble(keyDouble), true);
392 EXPECT_EQ(data.WriteFloat(keyFloat), true);
393 EXPECT_EQ(data.WriteString(keyString), true);
394 EXPECT_EQ(data.WriteString16(keyU16string), true);
395 EXPECT_EQ(data.WriteStringVector(keyStringVector), true);
396 EXPECT_EQ(data.WriteString16Vector(key16StringVector), true);
397 EXPECT_EQ(data.WriteBool(testTrueBool), true);
398 EXPECT_EQ(data.WritePointer(keyPtr), true);
399 return;
400 }
401
LRUTest001AddCache8()402 void LRUTest001AddCache8()
403 {
404 double valDouble = -9.3284928942;
405 float valFloat = 7.32489;
406 std::string valString = "valstringvalvalvalvalvalvalvalval";
407 std::vector<std::string> valStringVector = {"val", "abc", "!"};
408 std::vector<std::u16string> val16StringVector = {u"val", u"hhh", u"!!!"};
409 const std::u16string testValToken = u"ohos.valtesttoken.VALTESTTOKEN";
410 uintptr_t valPtr = 300;
411 MessageParcel data;
412 MessageParcel reply;
413
414 LRUTest001ParcelCache8(data);
415
416 EXPECT_EQ(reply.WriteDouble(valDouble), true);
417 EXPECT_EQ(reply.WriteFloat(valFloat), true);
418 EXPECT_EQ(reply.WriteString(valString), true);
419 EXPECT_EQ(reply.WriteStringVector(valStringVector), true);
420 EXPECT_EQ(reply.WriteString16Vector(val16StringVector), true);
421 EXPECT_EQ(reply.WriteInterfaceToken(testValToken), true);
422 EXPECT_EQ(reply.WritePointer(valPtr), true);
423 auto ret = ApiCacheManager::GetInstance().PostSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
424 EXPECT_EQ(ret, true);
425 return;
426 }
427
LRUTest001CheckCache8()428 void LRUTest001CheckCache8()
429 {
430 double valDouble = -9.3284928942;
431 float valFloat = 7.32489;
432 std::string valString = "valstringvalvalvalvalvalvalvalval";
433 std::vector<std::string> valStringVector = {"val", "abc", "!"};
434 std::vector<std::u16string> val16StringVector = {u"val", u"hhh", u"!!!"};
435 const std::u16string testValToken = u"ohos.valtesttoken.VALTESTTOKEN";
436 uintptr_t valPtr = 300;
437
438 MessageParcel data;
439 MessageParcel reply;
440 LRUTest001ParcelCache8(data);
441
442 auto ret = ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
443 EXPECT_EQ(ret, true);
444 double retdouble;
445 float retfloat;
446 std::string retString;
447 std::vector<std::string> retStringVector;
448 std::vector<std::u16string> retU16StringVector;
449 std::u16string retdescriptor;
450 EXPECT_EQ(reply.ReadDouble(retdouble), true);
451 EXPECT_EQ(retdouble, valDouble);
452 EXPECT_EQ(reply.ReadFloat(retfloat), true);
453 EXPECT_EQ(retfloat, valFloat);
454 EXPECT_EQ(reply.ReadString(retString), true);
455 EXPECT_EQ(retString, valString);
456 EXPECT_EQ(reply.ReadStringVector(&retStringVector), true);
457 EXPECT_EQ(retStringVector, valStringVector);
458 EXPECT_EQ(reply.ReadString16Vector(&retU16StringVector), true);
459 EXPECT_EQ(retU16StringVector, val16StringVector);
460 EXPECT_EQ(reply.ReadInterfaceToken(), testValToken);
461 EXPECT_EQ(reply.ReadPointer(), valPtr);
462 }
463
LRUTest001CheckCacheNums(int32_t expectNums)464 void LRUTest001CheckCacheNums(int32_t expectNums)
465 {
466 std::pair<std::u16string, uint32_t> myPair = std::make_pair(g_descriptor1, CACHE_API_CODE_100);
467 auto apiCache = ApiCacheManager::GetInstance().caches_.find(myPair);
468 EXPECT_NE(apiCache, ApiCacheManager::GetInstance().caches_.end());
469 if (apiCache != ApiCacheManager::GetInstance().caches_.end()) {
470 EXPECT_EQ(apiCache->second->data_.size(), expectNums);
471 EXPECT_EQ(apiCache->second->timestamp_.size(), expectNums);
472 EXPECT_EQ(apiCache->second->keys_.size(), expectNums);
473 }
474 return;
475 }
476
LRUTest001AddCache9()477 void LRUTest001AddCache9()
478 {
479 int32_t keyInt32T = -999;
480 std::string valString = "valstringvalvalvalvalvalvalvalval";
481 MessageParcel data;
482 MessageParcel reply;
483 EXPECT_EQ(data.WriteInt32(keyInt32T), true);
484
485 EXPECT_EQ(reply.WriteString(valString), true);
486 auto ret = ApiCacheManager::GetInstance().PostSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
487 EXPECT_EQ(ret, true);
488 return;
489 }
490 /**
491 * @tc.name: LRUTest001
492 * @tc.desc: test LRU elimination
493 * @tc.type: FUNC
494 * @tc.require:
495 */
496 HWTEST_F(CacheManagerTest, LRUTest001, TestSize.Level2)
497 {
498 bool ret;
499 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor1, CACHE_API_CODE_100, EXPIRE_TIME_1S);
500 float keyFloat = 0.012345;
501 std::u16string keyU16string = u"keyU16161616Ustring";
502 bool testTrueBool = true;
503 double valDouble = -9.3284928942;
504
505 // add cache 1
506 LRUTest001AddCache1();
507 // add cache 2
508 LRUTest001AddCache2();
509 // add cache 3
510 LRUTest001AddCache3();
511 // add cache 4
512 LRUTest001AddCache4();
513 // add cache 5
514 LRUTest001AddCache5();
515 // add cache 6
516 LRUTest001AddCache6();
517 // add cache 7
518 LRUTest001AddCache7();
519 // add cache 8
520 LRUTest001AddCache8();
521 LRUTest001CheckCache8();
522 // check the number of caches
523 LRUTest001CheckCacheNums(8);
524 // add cache 9, cache map full, will eliminate earliest recently used cache
525 LRUTest001AddCache9();
526 // check the earliest recently used cache is eliminated
527 {
528 MessageParcel data;
529 MessageParcel reply;
530 EXPECT_EQ(data.WriteBool(testTrueBool), true);
531 ret = ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
532 EXPECT_EQ(ret, false);
533 }
534
535 // wait for all caches expired
536 usleep(1200000);
537 // add cache, because the cache map is full, it will eliminate all expired cache in cache map
538 {
539 MessageParcel data;
540 MessageParcel reply;
541 EXPECT_EQ(data.WriteFloat(keyFloat), true);
542
543 EXPECT_EQ(reply.WriteDouble(valDouble), true);
544 ret = ApiCacheManager::GetInstance().PostSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
545 }
546 LRUTest001CheckCacheNums(1);
547 {
548 MessageParcel data;
549 MessageParcel reply;
550 double retDouble;
551 EXPECT_EQ(data.WriteFloat(keyFloat), true);
552
553 ret = ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_100, data, reply);
554 EXPECT_EQ(ret, true);
555 EXPECT_EQ(reply.ReadDouble(retDouble), true);
556 EXPECT_EQ(retDouble, valDouble);
557 }
558 ApiCacheManager::GetInstance().ClearCache();
559 }
560
ClearCache001TestParcelData(MessageParcel & data,const std::u16string & data1,int32_t data2)561 void ClearCache001TestParcelData(MessageParcel& data, const std::u16string& data1, int32_t data2)
562 {
563 data.WriteString16(data1);
564 data.WriteInt32(data2);
565 return;
566 }
567
ClearCache001TestParcelData(MessageParcel & data,const std::string & data1,int32_t data2)568 void ClearCache001TestParcelData(MessageParcel& data, const std::string& data1, int32_t data2)
569 {
570 data.WriteString(data1);
571 data.WriteInt32(data2);
572 return;
573 }
574
ClearCache001TestParcelData(MessageParcel & data,int32_t data1,const std::u16string & data2)575 void ClearCache001TestParcelData(MessageParcel& data, int32_t data1, const std::u16string& data2)
576 {
577 data.WriteInt32(data1);
578 data.WriteString16(data2);
579 return;
580 }
581
ClearCache001TestParcelData(MessageParcel & data,int32_t data1,const std::string & data2)582 void ClearCache001TestParcelData(MessageParcel& data, int32_t data1, const std::string& data2)
583 {
584 data.WriteInt32(data1);
585 data.WriteString(data2);
586 return;
587 }
588
ClearCache001TestParcelData(MessageParcel & data,int32_t data1)589 void ClearCache001TestParcelData(MessageParcel& data, int32_t data1)
590 {
591 data.WriteInt32(data1);
592 return;
593 }
594
ClearCache001TestCheckParcelData(MessageParcel & data,const std::string & data1,int32_t data2)595 bool ClearCache001TestCheckParcelData(MessageParcel& data, const std::string& data1, int32_t data2)
596 {
597 bool ret;
598 std::string cacheReplyStr;
599 int32_t cacheReplyInt;
600
601 ret = data.ReadString(cacheReplyStr);
602 if (ret != true) {
603 EXPECT_EQ(ret, true);
604 return false;
605 }
606 if (cacheReplyStr != data1) {
607 EXPECT_EQ(cacheReplyStr, data1);
608 return false;
609 }
610 ret = data.ReadInt32(cacheReplyInt);
611 if (ret != true) {
612 EXPECT_EQ(ret, true);
613 return false;
614 }
615 if (cacheReplyInt != data2) {
616 EXPECT_EQ(cacheReplyStr, data1);
617 return false;
618 }
619 return true;
620 }
621
ClearCache001TestCheckParcelData(MessageParcel & data,const std::u16string & data1,int32_t data2)622 bool ClearCache001TestCheckParcelData(MessageParcel& data, const std::u16string& data1, int32_t data2)
623 {
624 bool ret;
625 std::u16string cacheReplyStr;
626 int32_t cacheReplyInt;
627
628 ret = data.ReadString16(cacheReplyStr);
629 if (ret != true) {
630 EXPECT_EQ(ret, true);
631 return false;
632 }
633 if (cacheReplyStr != data1) {
634 EXPECT_EQ(cacheReplyStr, data1);
635 return false;
636 }
637 ret = data.ReadInt32(cacheReplyInt);
638 if (ret != true) {
639 EXPECT_EQ(ret, true);
640 return false;
641 }
642 if (cacheReplyInt != data2) {
643 EXPECT_EQ(cacheReplyStr, data1);
644 return false;
645 }
646 return true;
647 }
648
ClearCache001TestCheckParcelData(MessageParcel & data,int32_t data1,const std::string & data2)649 bool ClearCache001TestCheckParcelData(MessageParcel& data, int32_t data1, const std::string& data2)
650 {
651 bool ret;
652 std::string cacheReplyStr;
653 int32_t cacheReplyInt;
654
655 ret = data.ReadInt32(cacheReplyInt);
656 if (ret != true) {
657 EXPECT_EQ(ret, true);
658 return false;
659 }
660 if (cacheReplyInt != data1) {
661 EXPECT_EQ(cacheReplyInt, data1);
662 return false;
663 }
664 ret = data.ReadString(cacheReplyStr);
665 if (ret != true) {
666 EXPECT_EQ(ret, true);
667 return false;
668 }
669 if (cacheReplyStr != data2) {
670 EXPECT_EQ(cacheReplyStr, data2);
671 return false;
672 }
673 return true;
674 }
675
ClearCache001TestCheckParcelData(MessageParcel & data,int32_t data1,const std::u16string & data2)676 bool ClearCache001TestCheckParcelData(MessageParcel& data, int32_t data1, const std::u16string& data2)
677 {
678 bool ret;
679 std::u16string cacheReplyStr;
680 int32_t cacheReplyInt;
681
682 ret = data.ReadInt32(cacheReplyInt);
683 if (ret != true) {
684 EXPECT_EQ(ret, true);
685 return false;
686 }
687 if (cacheReplyInt != data1) {
688 EXPECT_EQ(cacheReplyInt, data1);
689 return false;
690 }
691 ret = data.ReadString16(cacheReplyStr);
692 if (ret != true) {
693 EXPECT_EQ(ret, true);
694 return false;
695 }
696 if (cacheReplyStr != data2) {
697 EXPECT_EQ(cacheReplyStr, data2);
698 return false;
699 }
700 return true;
701 }
702
ClearCache001TestPrevSet(const std::u16string & descriptor,uint32_t apiCode,const std::u16string & key,const std::u16string & val)703 bool ClearCache001TestPrevSet(const std::u16string& descriptor, uint32_t apiCode,
704 const std::u16string& key, const std::u16string& val)
705 {
706 bool ret;
707 MessageParcel data;
708 MessageParcel reply;
709 data.WriteString16(key);
710 reply.WriteString16(val);
711 ret = ApiCacheManager::GetInstance().PostSendRequest(descriptor, apiCode, data, reply);
712 return ret;
713 }
714
ClearCache001TestPrevSet(const std::u16string & descriptor,uint32_t apiCode,const std::string & key,const std::string & val)715 bool ClearCache001TestPrevSet(const std::u16string& descriptor, uint32_t apiCode,
716 const std::string& key, const std::string& val)
717 {
718 bool ret;
719 MessageParcel data;
720 MessageParcel reply;
721 data.WriteString(key);
722 reply.WriteString(val);
723 ret = ApiCacheManager::GetInstance().PostSendRequest(descriptor, apiCode, data, reply);
724 return ret;
725 }
726
ClearCache001TestPrevSet(const std::u16string & descriptor,uint32_t apiCode,MessageParcel & data,MessageParcel & reply)727 bool ClearCache001TestPrevSet(const std::u16string& descriptor, uint32_t apiCode,
728 MessageParcel& data, MessageParcel& reply)
729 {
730 bool ret = ApiCacheManager::GetInstance().PostSendRequest(descriptor, apiCode, data, reply);
731 return ret;
732 }
733
ClearCache001TestCheck(const std::u16string & descriptor,uint32_t apiCode,const std::u16string & key,const std::u16string & val,bool expectRet)734 bool ClearCache001TestCheck(const std::u16string& descriptor, uint32_t apiCode,
735 const std::u16string& key, const std::u16string& val, bool expectRet)
736 {
737 bool ret;
738 MessageParcel data;
739 MessageParcel reply;
740 data.WriteString16(key);
741 ret = ApiCacheManager::GetInstance().PreSendRequest(descriptor, apiCode, data, reply);
742 if (ret != expectRet) {
743 EXPECT_EQ(ret, expectRet);
744 return false;
745 }
746 if (expectRet == false) {
747 return true;
748 }
749
750 std::u16string cacheReplyStr;
751 ret = reply.ReadString16(cacheReplyStr);
752 if (ret != true) {
753 EXPECT_EQ(ret, true);
754 return false;
755 }
756 if (cacheReplyStr.compare(val) != 0) {
757 EXPECT_EQ(cacheReplyStr.compare(val), 0);
758 return false;
759 }
760 return true;
761 }
762
ClearCache001TestStep1AddCache()763 void ClearCache001TestStep1AddCache()
764 {
765 // add SA:descriptor1 API_CODE:100, cache: [keystr1, valstr1], [keystr2, valstr2]
766 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor1, CACHE_API_CODE_100, EXPIRE_TIME_3S);
767 EXPECT_EQ(ClearCache001TestPrevSet(g_descriptor1, CACHE_API_CODE_100, CACHE_KEY_STR_1, CACHE_VALUE_STR_1), true);
768 EXPECT_EQ(ClearCache001TestPrevSet(g_descriptor1, CACHE_API_CODE_100, CACHE_KEY_STR_2, CACHE_VALUE_STR_2), true);
769
770 // add SA:descriptor1 API_CODE:1, cache: [keystr2, valstr2], [keystr3, valstr3]
771 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor1, CACHE_API_CODE_1, EXPIRE_TIME_3S);
772 EXPECT_EQ(ClearCache001TestPrevSet(g_descriptor1, CACHE_API_CODE_1, CACHE_KEY_STR_2, CACHE_VALUE_STR_2), true);
773 EXPECT_EQ(ClearCache001TestPrevSet(g_descriptor1, CACHE_API_CODE_1, CACHE_KEY_STR_3, CACHE_VALUE_STR_3), true);
774
775 // add SA:descriptor2 API_CODE:1, cache: [keystr3, valstr3_valint1], [keystr2, valstr2]
776 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor2, CACHE_API_CODE_1, EXPIRE_TIME_3S);
777 {
778 MessageParcel data;
779 MessageParcel reply;
780 ClearCache001TestParcelData(data, CACHE_KEY_STR_3, CACHE_KEY_INT_1);
781 ClearCache001TestParcelData(reply, CACHE_VALUE_STR_3, CACHE_VALUE_INT_1);
782 EXPECT_EQ(ClearCache001TestPrevSet(g_descriptor2, CACHE_API_CODE_1, data, reply), true);
783 }
784
785 EXPECT_EQ(ClearCache001TestPrevSet(g_descriptor2, CACHE_API_CODE_1, CACHE_KEY_STR_2, CACHE_VALUE_STR_2), true);
786
787 // add SA:descriptor2 API_CODE:100, cache: [keyint1, valint1_valstr3], [keystr2, valstr2]
788 {
789 MessageParcel data;
790 MessageParcel reply;
791 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor2, CACHE_API_CODE_100, EXPIRE_TIME_3S);
792 ClearCache001TestParcelData(data, CACHE_KEY_INT_1);
793 ClearCache001TestParcelData(reply, CACHE_VALUE_INT_1, CACHE_VALUE_STR_3);
794 EXPECT_EQ(ClearCache001TestPrevSet(g_descriptor2, CACHE_API_CODE_100, data, reply), true);
795 EXPECT_EQ(ClearCache001TestPrevSet(g_descriptor2, CACHE_API_CODE_100, CACHE_KEY_STR_2, CACHE_VALUE_STR_2),
796 true);
797 }
798
799 // check number
800 {
801 EXPECT_EQ(ApiCacheManager::GetInstance().caches_.size(), 4); // 4:expect_numbers
802 for (auto i : ApiCacheManager::GetInstance().caches_) {
803 EXPECT_EQ(i.second->data_.size(), 2); // 2:expect_numbers
804 }
805 }
806
807 bool ret = ClearCache001TestCheck(g_descriptor1, CACHE_API_CODE_100, CACHE_KEY_STR_1, CACHE_VALUE_STR_1, true);
808 EXPECT_EQ(ret, true);
809 }
810
ClearCache001TestCheckNumber(int32_t cacheSize,int32_t apiNums)811 bool ClearCache001TestCheckNumber(int32_t cacheSize, int32_t apiNums)
812 {
813 if (ApiCacheManager::GetInstance().caches_.size() != cacheSize) {
814 EXPECT_EQ(ApiCacheManager::GetInstance().caches_.size(), cacheSize);
815 return false;
816 }
817 for (auto i : ApiCacheManager::GetInstance().caches_) {
818 if (i.second->data_.size() != apiNums) {
819 EXPECT_EQ(i.second->data_.size(), apiNums);
820 return false;
821 }
822 }
823 return true;
824 }
825 /**
826 * @tc.name: ClearCache001
827 * @tc.desc: test clear api
828 * @tc.type: FUNC
829 * @tc.require:
830 */
831 HWTEST_F(CacheManagerTest, ClearCache001, TestSize.Level2)
832 {
833 ClearCache001TestStep1AddCache();
834
835 ApiCacheManager::GetInstance().ClearCache(g_descriptor1, CACHE_API_CODE_100);
836 EXPECT_EQ(ApiCacheManager::GetInstance().caches_.size(), 4);
837
838 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor1, CACHE_API_CODE_100);
839 EXPECT_EQ(ClearCache001TestCheckNumber(3, 2), true);
840
841 bool ret = ClearCache001TestCheck(g_descriptor1, CACHE_API_CODE_100, CACHE_KEY_STR_1, CACHE_VALUE_STR_1, false);
842 EXPECT_EQ(ret, true);
843 ret = ClearCache001TestCheck(g_descriptor1, CACHE_API_CODE_100, CACHE_KEY_STR_2, CACHE_VALUE_STR_2, false);
844 EXPECT_EQ(ret, true);
845 ret = ClearCache001TestCheck(g_descriptor1, CACHE_API_CODE_1, CACHE_KEY_STR_2, CACHE_VALUE_STR_2, true);
846 EXPECT_EQ(ret, true);
847
848 MessageParcel data1, data2, reply1, reply2;
849 ClearCache001TestParcelData(data1, CACHE_KEY_STR_3, CACHE_KEY_INT_1);
850 EXPECT_EQ(ApiCacheManager::GetInstance().PreSendRequest(g_descriptor2, CACHE_API_CODE_1, data1, reply1), true);
851 EXPECT_EQ(ClearCache001TestCheckParcelData(reply1, CACHE_VALUE_STR_3, CACHE_VALUE_INT_1), true);
852
853 ClearCache001TestParcelData(data2, CACHE_KEY_INT_1);
854 EXPECT_EQ(ApiCacheManager::GetInstance().PreSendRequest(g_descriptor2, CACHE_API_CODE_100, data2, reply2), true);
855 EXPECT_EQ(ClearCache001TestCheckParcelData(reply2, CACHE_VALUE_INT_1, CACHE_VALUE_STR_3), true);
856
857 ApiCacheManager::GetInstance().ClearCache(g_descriptor2);
858 EXPECT_EQ(ApiCacheManager::GetInstance().caches_.size(), 3);
859
860 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor2, CACHE_API_CODE_100);
861 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor2, CACHE_API_CODE_1);
862
863 EXPECT_EQ(ClearCache001TestCheckNumber(1, 2), true);
864
865 MessageParcel data3, data4, reply3, reply4;
866 ClearCache001TestParcelData(data3, CACHE_KEY_STR_3, CACHE_KEY_INT_1);
867 EXPECT_EQ(ApiCacheManager::GetInstance().PreSendRequest(g_descriptor2, CACHE_API_CODE_1, data3, reply4), false);
868
869 EXPECT_EQ(data4.WriteInt32(CACHE_KEY_INT_1), true);
870 EXPECT_EQ(ApiCacheManager::GetInstance().PreSendRequest(g_descriptor2, CACHE_API_CODE_100, data4, reply4), false);
871
872 // add SA:descriptor2 API_CODE:1, cache: [keystr3, valstr3_valint1], [keystr2, valstr2]
873 MessageParcel data5, data6, reply5, reply6;
874 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor2, CACHE_API_CODE_1, EXPIRE_TIME_3S);
875 ClearCache001TestParcelData(data5, CACHE_KEY_STR_3, CACHE_KEY_INT_1);
876 ClearCache001TestParcelData(reply5, CACHE_VALUE_STR_3, CACHE_VALUE_INT_1);
877 EXPECT_EQ(ApiCacheManager::GetInstance().PostSendRequest(g_descriptor2, CACHE_API_CODE_1, data5, reply5), true);
878
879 EXPECT_EQ(ClearCache001TestPrevSet(g_descriptor2, CACHE_API_CODE_1, CACHE_KEY_STR_2, CACHE_VALUE_STR_2), true);
880
881 // add SA:descriptor2 API_CODE:100, cache: [keyint1, valint1_valstr3], [keystr2, valstr2]
882 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor2, CACHE_API_CODE_100, EXPIRE_TIME_3S);
883 ClearCache001TestParcelData(data6, CACHE_KEY_INT_1);
884 ClearCache001TestParcelData(reply6, CACHE_VALUE_INT_1, CACHE_VALUE_STR_3);
885 EXPECT_EQ(ApiCacheManager::GetInstance().PostSendRequest(g_descriptor2, CACHE_API_CODE_100, data6, reply6), true);
886
887 EXPECT_EQ(ClearCache001TestPrevSet(g_descriptor2, CACHE_API_CODE_100, CACHE_KEY_STR_2, CACHE_VALUE_STR_2), true);
888
889 ApiCacheManager::GetInstance().ClearCache();
890
891 EXPECT_EQ(ClearCache001TestCheckNumber(3, 0), true);
892
893 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor1, CACHE_API_CODE_1);
894 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor2, CACHE_API_CODE_100);
895 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor2, CACHE_API_CODE_1);
896 EXPECT_EQ(ApiCacheManager::GetInstance().caches_.size(), 0);
897 }
898
Task001(bool & stop)899 void Task001(bool& stop)
900 {
901 MessageParcel data1;
902 MessageParcel data2;
903 MessageParcel reply1;
904 MessageParcel reply2;
905 ClearCache001TestParcelData(data1, CACHE_KEY_STR_1, CACHE_KEY_INT_1);
906 ClearCache001TestParcelData(reply1, CACHE_VALUE_STR_1, CACHE_VALUE_INT_1);
907
908 ClearCache001TestParcelData(data2, CACHE_KEY_INT_1, CACHE_KEY_STR_1);
909 ClearCache001TestParcelData(reply2, CACHE_VALUE_INT_1, CACHE_VALUE_STR_1);
910 while (!stop) {
911 ApiCacheManager::GetInstance().PostSendRequest(g_descriptor1, CACHE_API_CODE_1, data1, reply1);
912 ApiCacheManager::GetInstance().PostSendRequest(g_descriptor1, CACHE_API_CODE_100, data2, reply2);
913 }
914 }
915
Task002(bool & stop)916 void Task002(bool& stop)
917 {
918 MessageParcel data1;
919 MessageParcel data2;
920 MessageParcel reply1;
921 MessageParcel reply2;
922 ClearCache001TestParcelData(data1, CACHE_KEY_STR_2, CACHE_KEY_INT_1);
923 ClearCache001TestParcelData(reply1, CACHE_VALUE_STR_2, CACHE_VALUE_INT_1);
924
925 ClearCache001TestParcelData(data2, CACHE_KEY_INT_1, CACHE_KEY_STR_2);
926 ClearCache001TestParcelData(reply2, CACHE_VALUE_INT_1, CACHE_VALUE_STR_2);
927 while (!stop) {
928 ApiCacheManager::GetInstance().PostSendRequest(g_descriptor2, CACHE_API_CODE_1, data1, reply1);
929 ApiCacheManager::GetInstance().PostSendRequest(g_descriptor2, CACHE_API_CODE_100, data2, reply2);
930 }
931 }
932
Task003(bool & stop)933 void Task003(bool& stop)
934 {
935 MessageParcel data1;
936 MessageParcel data2;
937 MessageParcel data3;
938 MessageParcel data4;
939 MessageParcel reply1;
940 MessageParcel reply2;
941 MessageParcel reply3;
942 MessageParcel reply4;
943 ClearCache001TestParcelData(data1, CACHE_KEY_STR_1, CACHE_KEY_INT_1);
944 ClearCache001TestParcelData(data2, CACHE_KEY_INT_1, CACHE_KEY_STR_1);
945 ClearCache001TestParcelData(data3, CACHE_KEY_STR_2, CACHE_KEY_INT_1);
946 ClearCache001TestParcelData(data4, CACHE_KEY_INT_1, CACHE_KEY_STR_2);
947
948 while (!stop) {
949 ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_1, data1, reply1);
950 ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_100, data2, reply2);
951 ApiCacheManager::GetInstance().PreSendRequest(g_descriptor2, CACHE_API_CODE_1, data3, reply3);
952 ApiCacheManager::GetInstance().PreSendRequest(g_descriptor2, CACHE_API_CODE_100, data4, reply4);
953 }
954 }
955
Task004(bool & stop)956 void Task004(bool& stop)
957 {
958 while (!stop) {
959 ApiCacheManager::GetInstance().ClearCache();
960 ApiCacheManager::GetInstance().ClearCache(g_descriptor2, CACHE_API_CODE_100);
961 ApiCacheManager::GetInstance().ClearCache(g_descriptor1, CACHE_API_CODE_1);
962 ApiCacheManager::GetInstance().ClearCache(g_descriptor1, CACHE_API_CODE_100);
963 ApiCacheManager::GetInstance().ClearCache(g_descriptor3, CACHE_API_CODE_1);
964 ApiCacheManager::GetInstance().ClearCache(g_descriptor3);
965 ApiCacheManager::GetInstance().ClearCache(g_descriptor1);
966 }
967 }
968
Task005(bool & stop)969 void Task005(bool& stop)
970 {
971 while (!stop) {
972 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor1, CACHE_API_CODE_1, 0);
973 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor1, CACHE_API_CODE_100, 0);
974 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor2, CACHE_API_CODE_1, 0);
975 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor2, CACHE_API_CODE_100, 0);
976 }
977 }
978
Task006(bool & stop)979 void Task006(bool& stop)
980 {
981 while (!stop) {
982 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor1, CACHE_API_CODE_1);
983 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor1, CACHE_API_CODE_100);
984 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor2, CACHE_API_CODE_1);
985 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor2, CACHE_API_CODE_100);
986 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor3, CACHE_API_CODE_1);
987 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor3, CACHE_API_CODE_100);
988 }
989 }
990
991 /**
992 * @tc.name: Conc001
993 * @tc.desc: test ApiCacheManager concurrency
994 * @tc.type: FUNC
995 * @tc.require:
996 */
997 HWTEST_F(CacheManagerTest, Conc001, TestSize.Level2)
998 {
999 bool stop = false;
1000 bool stopAdd = false;
1001
1002 std::thread addapiT(Task005, std::ref(stop));
1003 std::thread delapiT(Task006, std::ref(stop));
1004 sleep(1);
1005 stop = true;
1006 addapiT.join();
1007 delapiT.join();
1008
1009 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor1, CACHE_API_CODE_1, 0);
1010 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor1, CACHE_API_CODE_100, 0);
1011 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor2, CACHE_API_CODE_1, 0);
1012 ApiCacheManager::GetInstance().AddCacheApi(g_descriptor2, CACHE_API_CODE_100, 0);
1013 stop = false;
1014 std::thread t1(Task001, std::ref(stopAdd));
1015 std::thread t2(Task002, std::ref(stopAdd));
1016 std::thread t3(Task003, std::ref(stop));
1017 std::thread t4(Task004, std::ref(stop));
1018
1019 sleep(5);
1020 stop = true;
1021 usleep(50000);
1022 stopAdd = true;
1023
1024 t1.join();
1025 t2.join();
1026 t3.join();
1027 t4.join();
1028
1029 MessageParcel data1, data2, data3, data4;
1030 MessageParcel reply1, reply2, reply3, reply4;
1031 ClearCache001TestParcelData(data1, CACHE_KEY_STR_1, CACHE_KEY_INT_1);
1032 ClearCache001TestParcelData(data2, CACHE_KEY_INT_1, CACHE_KEY_STR_1);
1033 ClearCache001TestParcelData(data3, CACHE_KEY_STR_2, CACHE_KEY_INT_1);
1034 ClearCache001TestParcelData(data4, CACHE_KEY_INT_1, CACHE_KEY_STR_2);
1035
1036 EXPECT_EQ(ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_1, data1, reply1), true);
1037 EXPECT_EQ(ClearCache001TestCheckParcelData(reply1, CACHE_VALUE_STR_1, CACHE_VALUE_INT_1), true);
1038
1039 EXPECT_EQ(ApiCacheManager::GetInstance().PreSendRequest(g_descriptor1, CACHE_API_CODE_100, data2, reply2), true);
1040 EXPECT_EQ(ClearCache001TestCheckParcelData(reply2, CACHE_VALUE_INT_1, CACHE_VALUE_STR_1), true);
1041
1042 EXPECT_EQ(ApiCacheManager::GetInstance().PreSendRequest(g_descriptor2, CACHE_API_CODE_1, data3, reply3), true);
1043 EXPECT_EQ(ClearCache001TestCheckParcelData(reply3, CACHE_VALUE_STR_2, CACHE_VALUE_INT_1), true);
1044
1045 EXPECT_EQ(ApiCacheManager::GetInstance().PreSendRequest(g_descriptor2, CACHE_API_CODE_100, data4, reply4), true);
1046 EXPECT_EQ(ClearCache001TestCheckParcelData(reply4, CACHE_VALUE_INT_1, CACHE_VALUE_STR_2), true);
1047
1048 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor1, CACHE_API_CODE_1);
1049 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor1, CACHE_API_CODE_100);
1050 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor2, CACHE_API_CODE_1);
1051 ApiCacheManager::GetInstance().DelCacheApi(g_descriptor2, CACHE_API_CODE_100);
1052 return;
1053 }
1054 }