1 /*
2 * Copyright (c) 2023 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
16 #include "dlp_callback_test.h"
17 #include <string>
18 #include "gtest/gtest.h"
19 #define private public
20 #include "dlp_sandbox_change_callback_manager.h"
21 #include "open_dlp_file_callback_manager.h"
22 #undef private
23 #include "dlp_permission_log.h"
24 #include "dlp_permission.h"
25 #include "iremote_broker.h"
26
27 using namespace testing::ext;
28 using namespace OHOS;
29 using namespace OHOS::Security::DlpPermission;
30
31 namespace {
32 static const uint32_t MAX_CALLBACK_SIZE = 1024;
33 static const int32_t DEFAULT_USERID = 100;
34 static const int32_t TIME_STAMP = 100;
35 static const std::string DLP_MANAGER_APP = "com.ohos.dlpmanager";
36 static const std::string URI = "test";
37 static const uint32_t MAX_CALLBACKS = 100;
38 } // namespace
39
SetUpTestCase()40 void DlpCallbackTest::SetUpTestCase() {}
41
TearDownTestCase()42 void DlpCallbackTest::TearDownTestCase() {}
43
SetUp()44 void DlpCallbackTest::SetUp() {}
45
TearDown()46 void DlpCallbackTest::TearDown() {}
47
48 class DlpTestRemoteObj : public IRemoteBroker {
49 public:
50 DECLARE_INTERFACE_DESCRIPTOR(u"ohos.dlp.test");
51
52 DlpTestRemoteObj() = default;
53 virtual ~DlpTestRemoteObj() noexcept = default;
54 };
55
56 /**
57 * @tc.name: DlpSandboxChangeCallback001
58 * @tc.desc: DlpSandboxChangeCallbackProxy test
59 * @tc.type: FUNC
60 * @tc.require:
61 */
62 HWTEST_F(DlpCallbackTest, DlpSandboxChangeCallback001, TestSize.Level1)
63 {
64 sptr<DlpTestRemoteObj> callback = new (std::nothrow)IRemoteStub<DlpTestRemoteObj>();
65 EXPECT_TRUE(callback != nullptr);
66
67 auto proxy = std::make_shared<DlpSandboxChangeCallbackProxy>(callback->AsObject());
68 DlpSandboxCallbackInfo input;
69 proxy->DlpSandboxStateChangeCallback(input);
70 EXPECT_EQ(true, (callback != nullptr));
71 }
72
73 class DlpSandboxChangeCallbackTest : public DlpSandboxChangeCallbackStub {
74 public:
75 DlpSandboxChangeCallbackTest() = default;
76 ~DlpSandboxChangeCallbackTest() override;
77
78 void DlpSandboxStateChangeCallback(DlpSandboxCallbackInfo &result) override;
79 };
80
81 /**
82 * @tc.name: DlpSandboxChangeCallback002
83 * @tc.desc: DlpSandboxChangeCallbackManager test
84 * @tc.type: FUNC
85 * @tc.require:
86 */
87 HWTEST_F(DlpCallbackTest, DlpSandboxChangeCallback002, TestSize.Level1)
88 {
89 int32_t res = DlpSandboxChangeCallbackManager::GetInstance().AddCallback(0, nullptr);
90 EXPECT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
91
92 sptr<DlpSandboxChangeCallbackTest> callback = new (std::nothrow) DlpSandboxChangeCallbackTest();
93 EXPECT_TRUE(callback != nullptr);
94
95 for (uint32_t index = 0; index <= MAX_CALLBACK_SIZE; ++index) {
96 DlpSandboxChangeCallbackRecord recordInstance;
97 recordInstance.callbackObject_ = callback->AsObject();
98 recordInstance.pid = index;
99 DlpSandboxChangeCallbackManager::GetInstance().callbackInfoMap_.
100 insert(std::pair<int32_t, DlpSandboxChangeCallbackRecord>(index, recordInstance));
101 }
102 res = DlpSandboxChangeCallbackManager::GetInstance().AddCallback(0, callback->AsObject());
103 EXPECT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
104 res = DlpSandboxChangeCallbackManager::GetInstance().RemoveCallback(nullptr);
105 EXPECT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
106 DlpSandboxInfo dlpSandboxInfo;
107 dlpSandboxInfo.pid = MAX_CALLBACK_SIZE + 1;
108 DlpSandboxChangeCallbackManager::GetInstance().ExecuteCallbackAsync(dlpSandboxInfo);
109 dlpSandboxInfo.pid = 1;
110 DlpSandboxChangeCallbackManager::GetInstance().ExecuteCallbackAsync(dlpSandboxInfo);
111 bool result = false;
112 res = DlpSandboxChangeCallbackManager::GetInstance().RemoveCallback(0, result);
113 EXPECT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
114 for (auto it = DlpSandboxChangeCallbackManager::GetInstance().callbackInfoMap_.begin();
115 it != DlpSandboxChangeCallbackManager::GetInstance().callbackInfoMap_.end(); ++it) {
116 it->second.callbackObject_ = nullptr;
117 DlpSandboxChangeCallbackManager::GetInstance().callbackInfoMap_.erase(it);
118 }
119 DlpSandboxChangeCallbackManager::GetInstance().callbackInfoMap_.clear();
120 }
121
122 class TestOpenDlpFileCallback : public OpenDlpFileCallbackStub {
123 public:
TestOpenDlpFileCallback()124 TestOpenDlpFileCallback() {}
~TestOpenDlpFileCallback()125 ~TestOpenDlpFileCallback() {}
126
OnOpenDlpFile(OpenDlpFileCallbackInfo & result)127 void OnOpenDlpFile(OpenDlpFileCallbackInfo& result) override
128 {
129 called_ = true;
130 }
131 bool called_ = false;
132 };
133
134 /**
135 * @tc.name: OpenDlpFileCallbackProxy001
136 * @tc.desc: OpenDlpFileCallbackProxy test
137 * @tc.type: FUNC
138 * @tc.require:
139 */
140 HWTEST_F(DlpCallbackTest, OpenDlpFileCallbackProxy001, TestSize.Level1)
141 {
142 sptr<DlpTestRemoteObj> callback = new (std::nothrow)IRemoteStub<DlpTestRemoteObj>();
143 ASSERT_NE(nullptr, callback);
144
145 auto proxy = std::make_shared<OpenDlpFileCallbackProxy>(callback->AsObject());
146 OpenDlpFileCallbackInfo input;
147 proxy->OnOpenDlpFile(input);
148 ASSERT_NE(nullptr, callback);
149 }
150
151 /**
152 * @tc.name: OpenDlpFileCallback001
153 * @tc.desc: AddCallback if callback is null
154 * @tc.type: FUNC
155 * @tc.require:
156 */
157 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback001, TestSize.Level1)
158 {
159 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
160 int32_t res =
161 OpenDlpFileCallbackManager::GetInstance().AddCallback(getpid(), DEFAULT_USERID, DLP_MANAGER_APP, nullptr);
162 EXPECT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
163 }
164
165 /**
166 * @tc.name: OpenDlpFileCallback002
167 * @tc.desc: AddCallback in normal case
168 * @tc.type: FUNC
169 * @tc.require:
170 */
171 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback002, TestSize.Level1)
172 {
173 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
174 sptr<TestOpenDlpFileCallback> callback = new (std::nothrow) TestOpenDlpFileCallback();
175 ASSERT_NE(nullptr, callback);
176 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
177 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback->AsObject());
178 EXPECT_EQ(DLP_OK, res);
179 // repeat add
180 res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
181 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback->AsObject());
182 EXPECT_EQ(DLP_OK, res);
183 res = OpenDlpFileCallbackManager::GetInstance().RemoveCallback(getpid(), callback->AsObject());
184 EXPECT_EQ(DLP_OK, res);
185 }
186
187 /**
188 * @tc.name: OpenDlpFileCallback003
189 * @tc.desc: AddCallback if openDlpFileCallbackMap_ reach max size
190 * @tc.type: FUNC
191 * @tc.require:
192 */
193 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback003, TestSize.Level1)
194 {
195 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
196 uint32_t pid;
197 for (pid = 10; pid < MAX_CALLBACKS + 10; ++pid) {
198 sptr<TestOpenDlpFileCallback> callback = new (std::nothrow) TestOpenDlpFileCallback();
199 ASSERT_NE(nullptr, callback);
200 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
201 pid, DEFAULT_USERID, DLP_MANAGER_APP, callback->AsObject());
202 EXPECT_EQ(DLP_OK, res);
203 }
204 sptr<TestOpenDlpFileCallback> callback = new (std::nothrow) TestOpenDlpFileCallback();
205 ASSERT_NE(nullptr, callback);
206 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
207 pid, DEFAULT_USERID, DLP_MANAGER_APP, callback->AsObject());
208 EXPECT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
209 }
210
211 /**
212 * @tc.name: OpenDlpFileCallback004
213 * @tc.desc: AddCallback if openDlpFileCallbackMap_.second reach max size
214 * @tc.type: FUNC
215 * @tc.require:
216 */
217 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback004, TestSize.Level1)
218 {
219 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
220 for (uint32_t index = 0; index < MAX_CALLBACKS; ++index) {
221 sptr<TestOpenDlpFileCallback> callback = new (std::nothrow) TestOpenDlpFileCallback();
222 ASSERT_NE(nullptr, callback);
223 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
224 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback->AsObject());
225 EXPECT_EQ(DLP_OK, res);
226 }
227
228 sptr<TestOpenDlpFileCallback> callback = new (std::nothrow) TestOpenDlpFileCallback();
229 ASSERT_NE(nullptr, callback);
230 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
231 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback->AsObject());
232 EXPECT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
233 }
234
235 /**
236 * @tc.name: OpenDlpFileCallback005
237 * @tc.desc: RemoveCallback from pid if callback is null
238 * @tc.type: FUNC
239 * @tc.require:
240 */
241 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback005, TestSize.Level1)
242 {
243 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
244 int32_t res = OpenDlpFileCallbackManager::GetInstance().RemoveCallback(getpid(), nullptr);
245 EXPECT_EQ(res, DLP_CALLBACK_PARAM_INVALID);
246 }
247
248 /**
249 * @tc.name: OpenDlpFileCallback006
250 * @tc.desc: RemoveCallback from pid if pid is 0
251 * @tc.type: FUNC
252 * @tc.require:
253 */
254 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback006, TestSize.Level1)
255 {
256 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
257 sptr<TestOpenDlpFileCallback> callback = new (std::nothrow) TestOpenDlpFileCallback();
258 ASSERT_NE(nullptr, callback);
259 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
260 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback->AsObject());
261 EXPECT_EQ(DLP_OK, res);
262 res = OpenDlpFileCallbackManager::GetInstance().RemoveCallback(0, callback->AsObject());
263 EXPECT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
264 }
265
266 /**
267 * @tc.name: OpenDlpFileCallback007
268 * @tc.desc: RemoveCallback from pid in noraml case
269 * @tc.type: FUNC
270 * @tc.require:
271 */
272 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback007, TestSize.Level1)
273 {
274 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
275 sptr<TestOpenDlpFileCallback> callback = new (std::nothrow) TestOpenDlpFileCallback();
276 ASSERT_NE(nullptr, callback);
277 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
278 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback->AsObject());
279 EXPECT_EQ(DLP_OK, res);
280 res = OpenDlpFileCallbackManager::GetInstance().RemoveCallback(getpid(), callback->AsObject());
281 EXPECT_EQ(DLP_OK, res);
282 }
283
284 /**
285 * @tc.name: OpenDlpFileCallback008
286 * @tc.desc: RemoveCallback from pid if pid not found
287 * @tc.type: FUNC
288 * @tc.require:
289 */
290 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback008, TestSize.Level1)
291 {
292 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
293 sptr<TestOpenDlpFileCallback> callback = new (std::nothrow) TestOpenDlpFileCallback();
294 ASSERT_NE(nullptr, callback);
295 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
296 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback->AsObject());
297 EXPECT_EQ(DLP_OK, res);
298 res = OpenDlpFileCallbackManager::GetInstance().RemoveCallback(getpid() + 1, callback->AsObject());
299 EXPECT_EQ(DLP_CALLBACK_PARAM_INVALID, res);
300 }
301
302 /**
303 * @tc.name: OpenDlpFileCallback009
304 * @tc.desc: RemoveCallback from pid if callback not found at first time
305 * @tc.type: FUNC
306 * @tc.require:
307 */
308 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback009, TestSize.Level1)
309 {
310 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
311 sptr<TestOpenDlpFileCallback> callback1 = new (std::nothrow) TestOpenDlpFileCallback();
312 ASSERT_NE(nullptr, callback1);
313 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
314 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback1->AsObject());
315 EXPECT_EQ(DLP_OK, res);
316 sptr<TestOpenDlpFileCallback> callback2 = new (std::nothrow) TestOpenDlpFileCallback();
317 ASSERT_NE(nullptr, callback2);
318 res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
319 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback2->AsObject());
320 EXPECT_EQ(DLP_OK, res);
321 res = OpenDlpFileCallbackManager::GetInstance().RemoveCallback(getpid(), callback2->AsObject());
322 EXPECT_EQ(DLP_OK, res);
323 }
324
325 /**
326 * @tc.name: OpenDlpFileCallback010
327 * @tc.desc: RemoveCallback from pid if callback not found
328 * @tc.type: FUNC
329 * @tc.require:
330 */
331 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback010, TestSize.Level1)
332 {
333 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
334 sptr<TestOpenDlpFileCallback> callback1 = new (std::nothrow) TestOpenDlpFileCallback();
335 ASSERT_NE(nullptr, callback1);
336 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
337 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback1->AsObject());
338 EXPECT_EQ(DLP_OK, res);
339 sptr<TestOpenDlpFileCallback> callback2 = new (std::nothrow) TestOpenDlpFileCallback();
340 ASSERT_NE(nullptr, callback2);
341 res = OpenDlpFileCallbackManager::GetInstance().RemoveCallback(getpid(), callback2->AsObject());
342 EXPECT_EQ(DLP_OK, res);
343 }
344
345 /**
346 * @tc.name: OpenDlpFileCallback011
347 * @tc.desc: RemoveCallback from death if callback is null
348 * @tc.type: FUNC
349 * @tc.require:
350 */
351 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback011, TestSize.Level1)
352 {
353 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
354 int32_t res = OpenDlpFileCallbackManager::GetInstance().RemoveCallback(nullptr);
355 EXPECT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
356 }
357
358 /**
359 * @tc.name: OpenDlpFileCallback012
360 * @tc.desc: RemoveCallback from death in normal case
361 * @tc.type: FUNC
362 * @tc.require:
363 */
364 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback012, TestSize.Level1)
365 {
366 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
367 sptr<TestOpenDlpFileCallback> callback = new (std::nothrow) TestOpenDlpFileCallback();
368 ASSERT_NE(nullptr, callback);
369 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
370 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback->AsObject());
371 EXPECT_EQ(DLP_OK, res);
372 res = OpenDlpFileCallbackManager::GetInstance().RemoveCallback(callback->AsObject());
373 EXPECT_EQ(DLP_OK, res);
374 }
375
376
377 /**
378 * @tc.name: OpenDlpFileCallback013
379 * @tc.desc: RemoveCallback from death if callback not found at first time
380 * @tc.type: FUNC
381 * @tc.require:
382 */
383 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback013, TestSize.Level1)
384 {
385 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
386 sptr<TestOpenDlpFileCallback> callback1 = new (std::nothrow) TestOpenDlpFileCallback();
387 ASSERT_NE(nullptr, callback1);
388 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
389 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback1->AsObject());
390 EXPECT_EQ(DLP_OK, res);
391 sptr<TestOpenDlpFileCallback> callback2 = new (std::nothrow) TestOpenDlpFileCallback();
392 ASSERT_NE(nullptr, callback2);
393 res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
394 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback2->AsObject());
395 EXPECT_EQ(DLP_OK, res);
396 res = OpenDlpFileCallbackManager::GetInstance().RemoveCallback(callback2->AsObject());
397 EXPECT_EQ(DLP_OK, res);
398 }
399
400 /**
401 * @tc.name: OpenDlpFileCallback014
402 * @tc.desc: RemoveCallback from death if callback not found
403 * @tc.type: FUNC
404 * @tc.require:
405 */
406 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback014, TestSize.Level1)
407 {
408 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
409 sptr<TestOpenDlpFileCallback> callback1 = new (std::nothrow) TestOpenDlpFileCallback();
410 ASSERT_NE(nullptr, callback1);
411 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
412 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback1->AsObject());
413 EXPECT_EQ(DLP_OK, res);
414 sptr<TestOpenDlpFileCallback> callback2 = new (std::nothrow) TestOpenDlpFileCallback();
415 ASSERT_NE(nullptr, callback2);
416 res = OpenDlpFileCallbackManager::GetInstance().RemoveCallback(callback2->AsObject());
417 EXPECT_EQ(DLP_OK, res);
418 }
419
420 /**
421 * @tc.name: OpenDlpFileCallback015
422 * @tc.desc: ExecuteCallbackAsync in normal case
423 * @tc.type: FUNC
424 * @tc.require:
425 */
426 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback015, TestSize.Level1)
427 {
428 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
429 sptr<TestOpenDlpFileCallback> callback = new (std::nothrow) TestOpenDlpFileCallback();
430 ASSERT_NE(nullptr, callback);
431 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
432 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback->AsObject());
433 EXPECT_EQ(DLP_OK, res);
434
435 DlpSandboxInfo dlpSandboxInfo;
436 dlpSandboxInfo.uri = URI;
437 dlpSandboxInfo.userId = DEFAULT_USERID;
438 dlpSandboxInfo.bundleName = DLP_MANAGER_APP;
439 dlpSandboxInfo.timeStamp = TIME_STAMP;
440 OpenDlpFileCallbackManager::GetInstance().ExecuteCallbackAsync(dlpSandboxInfo);
441 usleep(50000); // sleep 50ms
442 EXPECT_EQ(true, callback->called_);
443
444 res = OpenDlpFileCallbackManager::GetInstance().RemoveCallback(callback->AsObject());
445 EXPECT_EQ(DLP_OK, res);
446 }
447
448 /**
449 * @tc.name: OpenDlpFileCallback016
450 * @tc.desc: ExecuteCallbackAsync if not found
451 * @tc.type: FUNC
452 * @tc.require:
453 */
454 HWTEST_F(DlpCallbackTest, OpenDlpFileCallback016, TestSize.Level1)
455 {
456 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
457 sptr<TestOpenDlpFileCallback> callback = new (std::nothrow) TestOpenDlpFileCallback();
458 ASSERT_NE(nullptr, callback);
459 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
460 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback->AsObject());
461 EXPECT_EQ(DLP_OK, res);
462
463 DlpSandboxInfo dlpSandboxInfo;
464 dlpSandboxInfo.uri = URI;
465 dlpSandboxInfo.userId = DEFAULT_USERID + 1;
466 dlpSandboxInfo.bundleName = DLP_MANAGER_APP;
467 dlpSandboxInfo.timeStamp = TIME_STAMP;
468 OpenDlpFileCallbackManager::GetInstance().ExecuteCallbackAsync(dlpSandboxInfo);
469 usleep(50000); // sleep 50ms
470 EXPECT_EQ(false, callback->called_);
471
472 res = OpenDlpFileCallbackManager::GetInstance().RemoveCallback(callback->AsObject());
473 EXPECT_EQ(DLP_OK, res);
474 }
475