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
16 #include "napi/native_api.h"
17 #include "hilog/log.h"
18 #include <string>
19 #include <unistd.h>
20 #include "database/pasteboard/oh_pasteboard.h"
21 #include "database/pasteboard/oh_pasteboard_err_code.h"
22 #include "database/udmf/udmf.h"
23 #include "database/udmf/udmf_meta.h"
24 #include "database/udmf/uds.h"
25 #include "database/udmf/utd.h"
26 #include <iostream>
27 #include <map>
28 #include <ctime>
29 #include "common.h"
30 #include <cctype>
31 #include <condition_variable>
32 #include <cstdint>
33 #include <fcntl.h>
34 #include <functional>
35 #include <iostream>
36 #include <list>
37 #include <map>
38 #include <memory>
39 #include <mutex>
40 #include <string>
41 #include <sys/mman.h>
42 #include <thread>
43 #include <vector>
44 #include <string>
45 #include <random>
46 #include <chrono>
47 const char *TAG = "testLog";
48
49
50 int g_changeNum = 0;
51 static Pasteboard_GetDataParams *g_params = nullptr;
52
53
Pasteboard_ProgressListener(Pasteboard_ProgressInfo * progressInfo)54 void Pasteboard_ProgressListener(Pasteboard_ProgressInfo *progressInfo)
55 {
56 int percentage = OH_Pasteboard_ProgressInfo_GetProgress(progressInfo);
57 printf("percentage = %d\n", percentage);
58 if (g_params != nullptr) {
59 OH_Pasteboard_ProgressCancel(g_params);
60 }
61 }
62
oh_Pasteboard_ProgressListener(Pasteboard_ProgressInfo * progressInfo)63 void oh_Pasteboard_ProgressListener(Pasteboard_ProgressInfo *progressInfo)
64 {
65 int percentage = OH_Pasteboard_ProgressInfo_GetProgress(progressInfo);
66 printf("percentage = %d\n", percentage);
67 }
68
OH_Pasteboard_GetDataWithProgress001(napi_env env,napi_callback_info info)69 static napi_value OH_Pasteboard_GetDataWithProgress001(napi_env env, napi_callback_info info)
70 {
71 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
72 OH_UdmfRecord* record = OH_UdmfRecord_Create();
73 OH_UdmfData* unifiedData = OH_UdmfData_Create();
74 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
75 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
76 OH_UdsFileUri_SetFileUri(fileUri, uri1);
77 OH_UdmfRecord_AddFileUri(record, fileUri);
78 OH_UdmfData_AddRecord(unifiedData, record);
79 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
80 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
81
82 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps/";
83
84 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
85
86 OH_Pasteboard_GetDataParams_SetDestUri(params, uri, strlen(uri));
87 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_SKIP);
88 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, PASTEBOARD_DEFAULT);
89 int status = -1;
90
91 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
92 NAPI_ASSERT(env, status == ERR_OK, "OH_Pasteboard_GetDataWithProgress is fail.");
93 NAPI_ASSERT(env, getData != nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
94
95 unsigned int getrecordCount = 0;
96 OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(getData, &getrecordCount);
97 NAPI_ASSERT(env, getrecordCount == 1, "OH_UdmfData_GetRecords is fail.");
98 OH_UdsFileUri* getfileUri = OH_UdsFileUri_Create();
99 OH_UdmfRecord_GetFileUri(getRecords[0], getfileUri);
100 const char* getContent = OH_UdsFileUri_GetFileUri(getfileUri);
101 std::string str = uri;
102 std::string str1 = str + "dstFile.txt";
103 NAPI_ASSERT(env, strcmp(getContent, str1.c_str()) == 0, "OH_UdsPlainText_GetContent is fail.");
104 OH_Pasteboard_ClearData(pasteboard);
105
106 int recode = 0;
107 napi_value result;
108 napi_create_int32(env, recode, &result);
109 OH_Pasteboard_GetDataParams_Destroy(params);
110 OH_Pasteboard_Destroy(pasteboard);
111 OH_UdmfRecord_Destroy(record);
112 OH_UdmfData_Destroy(unifiedData);
113 OH_UdsFileUri_Destroy(fileUri);
114 OH_UdsFileUri_Destroy(getfileUri);
115 return result;
116 }
117
OH_Pasteboard_GetDataWithProgress002(napi_env env,napi_callback_info info)118 static napi_value OH_Pasteboard_GetDataWithProgress002(napi_env env, napi_callback_info info)
119 {
120 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
121 OH_UdmfRecord* record = OH_UdmfRecord_Create();
122 OH_UdmfData* unifiedData = OH_UdmfData_Create();
123 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
124 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
125 OH_UdsFileUri_SetFileUri(fileUri, uri1);
126 OH_UdmfRecord_AddFileUri(record, fileUri);
127 OH_UdmfData_AddRecord(unifiedData, record);
128 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
129 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
130
131 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps/daily/";
132
133 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
134
135 OH_Pasteboard_GetDataParams_SetDestUri(params, uri, strlen(uri));
136 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_SKIP);
137 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, PASTEBOARD_DEFAULT);
138 int status = -1;
139
140 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
141 NAPI_ASSERT(env, status == ERR_OK, "OH_Pasteboard_GetDataWithProgress is fail.");
142 NAPI_ASSERT(env, getData != nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
143
144 unsigned int getrecordCount = 0;
145 OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(getData, &getrecordCount);
146 NAPI_ASSERT(env, getrecordCount == 1, "OH_UdmfData_GetRecords is fail.");
147 OH_UdsFileUri* getfileUri = OH_UdsFileUri_Create();
148 OH_UdmfRecord_GetFileUri(getRecords[0], getfileUri);
149 const char* getContent = OH_UdsFileUri_GetFileUri(getfileUri);
150 std::string str = uri;
151 std::string str1 = str + "dstFile.txt";
152 NAPI_ASSERT(env, strcmp(getContent, str1.c_str()) == 0, "OH_UdsPlainText_GetContent is fail.");
153 OH_Pasteboard_ClearData(pasteboard);
154
155 int recode = 0;
156 napi_value result;
157 napi_create_int32(env, recode, &result);
158 OH_Pasteboard_Destroy(pasteboard);
159 OH_UdmfRecord_Destroy(record);
160 OH_UdmfData_Destroy(unifiedData);
161 OH_UdsFileUri_Destroy(fileUri);
162 OH_UdsFileUri_Destroy(getfileUri);
163 OH_Pasteboard_GetDataParams_Destroy(params);
164 return result;
165 }
166
OH_Pasteboard_GetDataWithProgress003(napi_env env,napi_callback_info info)167 static napi_value OH_Pasteboard_GetDataWithProgress003(napi_env env, napi_callback_info info)
168 {
169 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
170 OH_UdmfRecord* record = OH_UdmfRecord_Create();
171 OH_UdmfData* unifiedData = OH_UdmfData_Create();
172 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
173 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
174 OH_UdsFileUri_SetFileUri(fileUri, uri);
175 OH_UdmfRecord_AddFileUri(record, fileUri);
176 OH_UdmfData_AddRecord(unifiedData, record);
177 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
178 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
179
180 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps11/";
181 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
182
183 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, strlen(uri1));
184 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_SKIP);
185 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, PASTEBOARD_DEFAULT);
186 int status = -1;
187
188 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
189 NAPI_ASSERT(env, status == ERR_PASTEBOARD_COPY_FILE_ERROR, "OH_Pasteboard_GetDataWithProgress is fail.");
190 OH_Pasteboard_ClearData(pasteboard);
191
192 int recode = 0;
193 napi_value result;
194 napi_create_int32(env, recode, &result);
195 OH_Pasteboard_Destroy(pasteboard);
196 OH_Pasteboard_GetDataParams_Destroy(params);
197 return result;
198 }
199
OH_Pasteboard_GetDataWithProgress004(napi_env env,napi_callback_info info)200 static napi_value OH_Pasteboard_GetDataWithProgress004(napi_env env, napi_callback_info info)
201 {
202 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
203 OH_UdmfRecord* record = OH_UdmfRecord_Create();
204 OH_UdmfData* unifiedData = OH_UdmfData_Create();
205 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
206 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
207 OH_UdsFileUri_SetFileUri(fileUri, uri);
208 OH_UdmfRecord_AddFileUri(record, fileUri);
209 OH_UdmfData_AddRecord(unifiedData, record);
210 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
211 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
212
213 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/文件/";
214 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
215
216 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, strlen(uri1));
217 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_SKIP);
218 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, PASTEBOARD_DEFAULT);
219 int status = -1;
220
221 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
222 NAPI_ASSERT(env, status == ERR_PASTEBOARD_COPY_FILE_ERROR, "OH_Pasteboard_GetDataWithProgress is fail.");
223 NAPI_ASSERT(env, getData == nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
224
225 int recode = 0;
226 napi_value result;
227 napi_create_int32(env, recode, &result);
228 OH_Pasteboard_Destroy(pasteboard);
229 OH_Pasteboard_GetDataParams_Destroy(params);
230 return result;
231 }
232
OH_Pasteboard_GetDataWithProgress005(napi_env env,napi_callback_info info)233 static napi_value OH_Pasteboard_GetDataWithProgress005(napi_env env, napi_callback_info info)
234 {
235 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
236 OH_UdmfRecord* record = OH_UdmfRecord_Create();
237 OH_UdmfData* unifiedData = OH_UdmfData_Create();
238 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
239 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
240 OH_UdsFileUri_SetFileUri(fileUri, uri);
241 OH_UdmfRecord_AddFileUri(record, fileUri);
242 OH_UdmfData_AddRecord(unifiedData, record);
243 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
244 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
245
246 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps1122/";
247 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
248
249 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, strlen(uri1));
250 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_SKIP);
251 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, PASTEBOARD_DEFAULT);
252 int status = -1;
253
254 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
255 NAPI_ASSERT(env, status == ERR_OK, "OH_Pasteboard_GetDataWithProgress is fail.");
256 NAPI_ASSERT(env, getData != nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
257
258 unsigned int getrecordCount = 0;
259 OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(getData, &getrecordCount);
260 NAPI_ASSERT(env, getrecordCount == 1, "OH_UdmfData_GetRecords is fail.");
261 OH_UdsFileUri* getfileUri = OH_UdsFileUri_Create();
262 OH_UdmfRecord_GetFileUri(getRecords[0], getfileUri);
263 const char* getContent = OH_UdsFileUri_GetFileUri(getfileUri);
264 std::string str = uri1;
265 std::string str1 = str + "dstFile.txt";
266 NAPI_ASSERT(env, strcmp(getContent, str1.c_str()) == 0, "OH_UdsPlainText_GetContent is fail.");
267 OH_Pasteboard_ClearData(pasteboard);
268
269 int recode = 0;
270 napi_value result;
271 napi_create_int32(env, recode, &result);
272 OH_Pasteboard_Destroy(pasteboard);
273 OH_UdmfRecord_Destroy(record);
274 OH_UdmfData_Destroy(unifiedData);
275 OH_UdsFileUri_Destroy(fileUri);
276 OH_UdsFileUri_Destroy(getfileUri);
277 OH_Pasteboard_GetDataParams_Destroy(params);
278 return result;
279 }
280
OH_Pasteboard_GetDataWithProgress006(napi_env env,napi_callback_info info)281 static napi_value OH_Pasteboard_GetDataWithProgress006(napi_env env, napi_callback_info info)
282 {
283 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
284 OH_UdmfRecord* record = OH_UdmfRecord_Create();
285 OH_UdmfData* unifiedData = OH_UdmfData_Create();
286 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
287 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
288 OH_UdsFileUri_SetFileUri(fileUri, uri);
289 OH_UdmfRecord_AddFileUri(record, fileUri);
290 OH_UdmfData_AddRecord(unifiedData, record);
291 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
292 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
293
294 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps_day/";
295 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
296
297 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, strlen(uri1));
298 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_SKIP);
299 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, PASTEBOARD_DEFAULT);
300 int status = -1;
301
302 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
303 NAPI_ASSERT(env, status == ERR_OK, "OH_Pasteboard_GetDataWithProgress is fail.");
304 NAPI_ASSERT(env, getData != nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
305
306 unsigned int getrecordCount = 0;
307 OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(getData, &getrecordCount);
308 NAPI_ASSERT(env, getrecordCount == 1, "OH_UdmfData_GetRecords is fail.");
309 OH_UdsFileUri* getfileUri = OH_UdsFileUri_Create();
310 OH_UdmfRecord_GetFileUri(getRecords[0], getfileUri);
311 const char* getContent = OH_UdsFileUri_GetFileUri(getfileUri);
312 std::string str = uri1;
313 std::string str1 = str + "dstFile.txt";
314 NAPI_ASSERT(env, strcmp(getContent, str1.c_str()) == 0, "OH_UdsPlainText_GetContent is fail.");
315 OH_Pasteboard_ClearData(pasteboard);
316
317 int recode = 0;
318 napi_value result;
319 napi_create_int32(env, recode, &result);
320 OH_Pasteboard_Destroy(pasteboard);
321 OH_UdmfRecord_Destroy(record);
322 OH_UdmfData_Destroy(unifiedData);
323 OH_UdsFileUri_Destroy(fileUri);
324 OH_UdsFileUri_Destroy(getfileUri);
325 OH_Pasteboard_GetDataParams_Destroy(params);
326 return result;
327 }
328
OH_Pasteboard_GetDataWithProgress007(napi_env env,napi_callback_info info)329 static napi_value OH_Pasteboard_GetDataWithProgress007(napi_env env, napi_callback_info info)
330 {
331 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
332 OH_UdmfRecord* record = OH_UdmfRecord_Create();
333 OH_UdmfData* unifiedData = OH_UdmfData_Create();
334 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
335 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
336 OH_UdsFileUri_SetFileUri(fileUri, uri);
337 OH_UdmfRecord_AddFileUri(record, fileUri);
338 OH_UdmfData_AddRecord(unifiedData, record);
339 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
340 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
341
342 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps.day/";
343 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
344
345 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, strlen(uri1));
346 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_SKIP);
347 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, PASTEBOARD_DEFAULT);
348 int status = -1;
349
350 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
351 NAPI_ASSERT(env, status == ERR_OK, "OH_Pasteboard_GetDataWithProgress is fail.");
352 NAPI_ASSERT(env, getData != nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
353
354 unsigned int getrecordCount = 0;
355 OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(getData, &getrecordCount);
356 NAPI_ASSERT(env, getrecordCount == 1, "OH_UdmfData_GetRecords is fail.");
357 OH_UdsFileUri* getfileUri = OH_UdsFileUri_Create();
358 OH_UdmfRecord_GetFileUri(getRecords[0], getfileUri);
359 const char* getContent = OH_UdsFileUri_GetFileUri(getfileUri);
360 std::string str = uri1;
361 std::string str1 = str + "dstFile.txt";
362 NAPI_ASSERT(env, strcmp(getContent, str1.c_str()) == 0, "OH_UdsPlainText_GetContent is fail.");
363 OH_Pasteboard_ClearData(pasteboard);
364
365 int recode = 0;
366 napi_value result;
367 napi_create_int32(env, recode, &result);
368 OH_Pasteboard_Destroy(pasteboard);
369 OH_UdmfRecord_Destroy(record);
370 OH_UdmfData_Destroy(unifiedData);
371 OH_UdsFileUri_Destroy(fileUri);
372 OH_UdsFileUri_Destroy(getfileUri);
373 OH_Pasteboard_GetDataParams_Destroy(params);
374 return result;
375 }
376
OH_Pasteboard_GetDataWithProgress008(napi_env env,napi_callback_info info)377 static napi_value OH_Pasteboard_GetDataWithProgress008(napi_env env, napi_callback_info info)
378 {
379 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
380 OH_UdmfRecord* record = OH_UdmfRecord_Create();
381 OH_UdmfData* unifiedData = OH_UdmfData_Create();
382 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
383 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
384 OH_UdsFileUri_SetFileUri(fileUri, uri);
385 OH_UdmfRecord_AddFileUri(record, fileUri);
386 OH_UdmfData_AddRecord(unifiedData, record);
387 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
388 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
389
390 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps*day/";
391 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
392
393 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, strlen(uri1));
394 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_SKIP);
395 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, PASTEBOARD_DEFAULT);
396 int status = -1;
397
398 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
399 NAPI_ASSERT(env, status == ERR_OK, "OH_Pasteboard_GetDataWithProgress is fail.");
400 NAPI_ASSERT(env, getData != nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
401
402 unsigned int getrecordCount = 0;
403 OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(getData, &getrecordCount);
404 NAPI_ASSERT(env, getrecordCount == 1, "OH_UdmfData_GetRecords is fail.");
405 OH_UdsFileUri* getfileUri = OH_UdsFileUri_Create();
406 OH_UdmfRecord_GetFileUri(getRecords[0], getfileUri);
407 const char* getContent = OH_UdsFileUri_GetFileUri(getfileUri);
408 std::string str = uri1;
409 std::string str1 = str + "dstFile.txt";
410 NAPI_ASSERT(env, strcmp(getContent, str1.c_str()) == 0, "OH_UdsPlainText_GetContent is fail.");
411 OH_Pasteboard_ClearData(pasteboard);
412
413 int recode = 0;
414 napi_value result;
415 napi_create_int32(env, recode, &result);
416 OH_Pasteboard_Destroy(pasteboard);
417 OH_UdmfRecord_Destroy(record);
418 OH_UdmfData_Destroy(unifiedData);
419 OH_UdsFileUri_Destroy(fileUri);
420 OH_UdsFileUri_Destroy(getfileUri);
421 OH_Pasteboard_GetDataParams_Destroy(params);
422 return result;
423 }
424
OH_Pasteboard_GetDataWithProgress009(napi_env env,napi_callback_info info)425 static napi_value OH_Pasteboard_GetDataWithProgress009(napi_env env, napi_callback_info info)
426 {
427 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
428 OH_UdmfRecord* record = OH_UdmfRecord_Create();
429 OH_UdmfData* unifiedData = OH_UdmfData_Create();
430 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
431 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
432 OH_UdsFileUri_SetFileUri(fileUri, uri);
433 OH_UdmfRecord_AddFileUri(record, fileUri);
434 OH_UdmfData_AddRecord(unifiedData, record);
435 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
436 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
437
438 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps/";
439 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
440 Pasteboard_ProgressIndicator num = (Pasteboard_ProgressIndicator) 3;
441 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, strlen(uri1));
442 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_SKIP);
443 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, num);
444 int status = -1;
445
446 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
447 NAPI_ASSERT(env, status == ERR_OK, "OH_Pasteboard_GetDataWithProgress is fail.");
448 NAPI_ASSERT(env, getData != nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
449
450 unsigned int getrecordCount = 0;
451 OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(getData, &getrecordCount);
452 NAPI_ASSERT(env, getrecordCount == 1, "OH_UdmfData_GetRecords is fail.");
453 OH_UdsFileUri* getfileUri = OH_UdsFileUri_Create();
454 OH_UdmfRecord_GetFileUri(getRecords[0], getfileUri);
455 const char* getContent = OH_UdsFileUri_GetFileUri(getfileUri);
456 std::string str = uri1;
457 std::string str1 = str + "dstFile.txt";
458 NAPI_ASSERT(env, strcmp(getContent, str1.c_str()) == 0, "OH_UdsPlainText_GetContent is fail.");
459 OH_Pasteboard_ClearData(pasteboard);
460 OH_Pasteboard_ClearData(pasteboard);
461
462 int recode = 0;
463 napi_value result;
464 napi_create_int32(env, recode, &result);
465 OH_Pasteboard_Destroy(pasteboard);
466 OH_UdmfRecord_Destroy(record);
467 OH_UdmfData_Destroy(unifiedData);
468 OH_UdsFileUri_Destroy(fileUri);
469 OH_UdsFileUri_Destroy(getfileUri);
470 OH_Pasteboard_GetDataParams_Destroy(params);
471 return result;
472 }
473
OH_Pasteboard_GetDataWithProgress010(napi_env env,napi_callback_info info)474 static napi_value OH_Pasteboard_GetDataWithProgress010(napi_env env, napi_callback_info info)
475 {
476 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/le.txt";
477 OH_UdmfRecord* record = OH_UdmfRecord_Create();
478 OH_UdmfData* unifiedData = OH_UdmfData_Create();
479 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
480 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
481 OH_UdsFileUri_SetFileUri(fileUri, uri);
482 OH_UdmfRecord_AddFileUri(record, fileUri);
483 OH_UdmfData_AddRecord(unifiedData, record);
484 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
485 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
486
487 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/"
488 "files/haps22222222222222222222222222222222222222222222222222222222222222222222222222222222"
489 "222222222222222222222222222222222222222222222222222222222222222222222222222222222222222/";
490 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
491 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, strlen(uri1));
492 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_SKIP);
493 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, PASTEBOARD_DEFAULT);
494 int status = -1;
495
496 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
497 NAPI_ASSERT(env, status == ERR_OK, "OH_Pasteboard_GetDataWithProgress is fail.");
498 NAPI_ASSERT(env, getData != nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
499
500 unsigned int getrecordCount = 0;
501 OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(getData, &getrecordCount);
502 NAPI_ASSERT(env, getrecordCount == 1, "OH_UdmfData_GetRecords is fail.");
503 OH_UdsFileUri* getfileUri = OH_UdsFileUri_Create();
504 OH_UdmfRecord_GetFileUri(getRecords[0], getfileUri);
505 const char* getContent = OH_UdsFileUri_GetFileUri(getfileUri);
506 std::string str = uri1;
507 std::string str1 = str + "le.txt";
508 NAPI_ASSERT(env, strcmp(getContent, str1.c_str()) == 0, "OH_UdsPlainText_GetContent is fail.");
509 OH_Pasteboard_ClearData(pasteboard);
510
511 int recode = 0;
512 napi_value result;
513 napi_create_int32(env, recode, &result);
514 OH_Pasteboard_Destroy(pasteboard);
515 OH_UdmfRecord_Destroy(record);
516 OH_UdmfData_Destroy(unifiedData);
517 OH_UdsFileUri_Destroy(fileUri);
518 OH_UdsFileUri_Destroy(getfileUri);
519 return result;
520 }
521
OH_Pasteboard_GetDataWithProgress011(napi_env env,napi_callback_info info)522 static napi_value OH_Pasteboard_GetDataWithProgress011(napi_env env, napi_callback_info info)
523 {
524 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
525 OH_UdmfRecord* record = OH_UdmfRecord_Create();
526 OH_UdmfData* unifiedData = OH_UdmfData_Create();
527 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
528 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
529 OH_UdsFileUri_SetFileUri(fileUri, uri);
530 OH_UdmfRecord_AddFileUri(record, fileUri);
531 OH_UdmfData_AddRecord(unifiedData, record);
532 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
533 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
534
535 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/"
536 "files/haps2222222222222222222222222222222222222222222222222222222222222222222222222222222"
537 "222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222/";
538 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
539 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, strlen(uri1));
540 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_SKIP);
541 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, PASTEBOARD_DEFAULT);
542 int status = -1;
543
544 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
545 NAPI_ASSERT(env, status == ERR_INVALID_PARAMETER, "OH_Pasteboard_GetDataWithProgress is fail.");
546 NAPI_ASSERT(env, getData == nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
547
548 int recode = 0;
549 napi_value result;
550 napi_create_int32(env, recode, &result);
551 OH_Pasteboard_Destroy(pasteboard);
552 return result;
553 }
554
OH_Pasteboard_GetDataWithProgress012(napi_env env,napi_callback_info info)555 static napi_value OH_Pasteboard_GetDataWithProgress012(napi_env env, napi_callback_info info)
556 {
557 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
558 OH_UdmfRecord* record = OH_UdmfRecord_Create();
559 OH_UdmfData* unifiedData = OH_UdmfData_Create();
560 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
561 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
562 OH_UdsFileUri_SetFileUri(fileUri, uri);
563 OH_UdmfRecord_AddFileUri(record, fileUri);
564 OH_UdmfData_AddRecord(unifiedData, record);
565 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
566 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
567
568 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps/";
569 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
570 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, strlen(uri1));
571 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_SKIP);
572 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, PASTEBOARD_DEFAULT);
573 int status = -1;
574
575 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
576 NAPI_ASSERT(env, status == ERR_OK, "OH_Pasteboard_GetDataWithProgress is fail.");
577 NAPI_ASSERT(env, getData != nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
578
579 unsigned int getrecordCount = 0;
580 OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(getData, &getrecordCount);
581 NAPI_ASSERT(env, getrecordCount == 1, "OH_UdmfData_GetRecords is fail.");
582 OH_UdsFileUri* getfileUri = OH_UdsFileUri_Create();
583 OH_UdmfRecord_GetFileUri(getRecords[0], getfileUri);
584 const char* getContent = OH_UdsFileUri_GetFileUri(getfileUri);
585 std::string str = uri1;
586 std::string str1 = str + "dstFile.txt";
587 NAPI_ASSERT(env, strcmp(getContent, str1.c_str()) == 0, "OH_UdsPlainText_GetContent is fail.");
588 OH_Pasteboard_ClearData(pasteboard);
589
590 int recode = 0;
591 napi_value result;
592 napi_create_int32(env, recode, &result);
593 OH_Pasteboard_Destroy(pasteboard);
594 OH_UdmfRecord_Destroy(record);
595 OH_UdmfData_Destroy(unifiedData);
596 OH_UdsFileUri_Destroy(fileUri);
597 OH_UdsFileUri_Destroy(getfileUri);
598 OH_Pasteboard_GetDataParams_Destroy(params);
599 return result;
600 }
601
OH_Pasteboard_GetDataWithProgress013(napi_env env,napi_callback_info info)602 static napi_value OH_Pasteboard_GetDataWithProgress013(napi_env env, napi_callback_info info)
603 {
604 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
605 OH_UdmfRecord* record = OH_UdmfRecord_Create();
606 OH_UdmfData* unifiedData = OH_UdmfData_Create();
607 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
608 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
609 OH_UdsFileUri_SetFileUri(fileUri, uri);
610 OH_UdmfRecord_AddFileUri(record, fileUri);
611 OH_UdmfData_AddRecord(unifiedData, record);
612 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
613 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
614
615 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps/";
616 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
617 int num = strlen(uri1) + 1;
618 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, num);
619 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_SKIP);
620 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, PASTEBOARD_DEFAULT);
621 int status = -1;
622
623 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
624 NAPI_ASSERT(env, status == ERR_INVALID_PARAMETER, "OH_Pasteboard_GetDataWithProgress is fail.");
625
626 OH_Pasteboard_ClearData(pasteboard);
627
628 int recode = 0;
629 napi_value result;
630 napi_create_int32(env, recode, &result);
631 OH_Pasteboard_Destroy(pasteboard);
632 OH_UdmfRecord_Destroy(record);
633 OH_UdmfData_Destroy(unifiedData);
634 OH_UdsFileUri_Destroy(fileUri);
635 OH_Pasteboard_GetDataParams_Destroy(params);
636 return result;
637 }
638
OH_Pasteboard_GetDataWithProgress014(napi_env env,napi_callback_info info)639 static napi_value OH_Pasteboard_GetDataWithProgress014(napi_env env, napi_callback_info info)
640 {
641 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
642 OH_UdmfRecord* record = OH_UdmfRecord_Create();
643 OH_UdmfData* unifiedData = OH_UdmfData_Create();
644 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
645 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
646 OH_UdsFileUri_SetFileUri(fileUri, uri);
647 OH_UdmfRecord_AddFileUri(record, fileUri);
648 OH_UdmfData_AddRecord(unifiedData, record);
649 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
650 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
651
652 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps/";
653 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
654 int num = strlen(uri1);
655 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, num);
656 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_OVERWRITE);
657 int status = -1;
658
659 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
660 NAPI_ASSERT(env, status == ERR_OK, "OH_Pasteboard_GetDataWithProgress is fail.");
661 NAPI_ASSERT(env, getData != nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
662
663 unsigned int getrecordCount = 0;
664 OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(getData, &getrecordCount);
665 NAPI_ASSERT(env, getrecordCount == 1, "OH_UdmfData_GetRecords is fail.");
666 OH_UdsFileUri* getfileUri = OH_UdsFileUri_Create();
667 OH_UdmfRecord_GetFileUri(getRecords[0], getfileUri);
668 const char* getContent = OH_UdsFileUri_GetFileUri(getfileUri);
669 std::string str = uri1;
670 std::string str1 = str + "dstFile.txt";
671 NAPI_ASSERT(env, strcmp(getContent, str1.c_str()) == 0, "OH_UdsPlainText_GetContent is fail.");
672 OH_Pasteboard_ClearData(pasteboard);
673
674 int recode = status;
675 napi_value result;
676 napi_create_int32(env, recode, &result);
677 OH_Pasteboard_Destroy(pasteboard);
678 OH_UdmfRecord_Destroy(record);
679 OH_UdmfData_Destroy(unifiedData);
680 OH_UdsFileUri_Destroy(fileUri);
681 OH_UdsFileUri_Destroy(getfileUri);
682 OH_Pasteboard_GetDataParams_Destroy(params);
683 return result;
684 }
685
OH_Pasteboard_GetDataWithProgress015(napi_env env,napi_callback_info info)686 static napi_value OH_Pasteboard_GetDataWithProgress015(napi_env env, napi_callback_info info)
687 {
688 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
689 OH_UdmfRecord* record = OH_UdmfRecord_Create();
690 OH_UdmfData* unifiedData = OH_UdmfData_Create();
691 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
692 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
693 OH_UdsFileUri_SetFileUri(fileUri, uri);
694 OH_UdmfRecord_AddFileUri(record, fileUri);
695 OH_UdmfData_AddRecord(unifiedData, record);
696 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
697 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
698
699 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps/";
700 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
701 int num = strlen(uri1);
702 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, num);
703 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_OVERWRITE);
704 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, PASTEBOARD_DEFAULT);
705 int status = -1;
706
707 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
708 NAPI_ASSERT(env, status == ERR_OK, "OH_Pasteboard_GetDataWithProgress is fail.");
709 NAPI_ASSERT(env, getData != nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
710
711 unsigned int getrecordCount = 0;
712 OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(getData, &getrecordCount);
713 NAPI_ASSERT(env, getrecordCount == 1, "OH_UdmfData_GetRecords is fail.");
714 OH_UdsFileUri* getfileUri = OH_UdsFileUri_Create();
715 OH_UdmfRecord_GetFileUri(getRecords[0], getfileUri);
716 const char* getContent = OH_UdsFileUri_GetFileUri(getfileUri);
717 std::string str = uri1;
718 std::string str1 = str + "dstFile.txt";
719 NAPI_ASSERT(env, strcmp(getContent, str1.c_str()) == 0, "OH_UdsPlainText_GetContent is fail.");
720 OH_Pasteboard_ClearData(pasteboard);
721
722 int recode = status;
723 napi_value result;
724 napi_create_int32(env, recode, &result);
725 OH_Pasteboard_Destroy(pasteboard);
726 OH_UdmfRecord_Destroy(record);
727 OH_UdmfData_Destroy(unifiedData);
728 OH_UdsFileUri_Destroy(fileUri);
729 OH_UdsFileUri_Destroy(getfileUri);
730 OH_Pasteboard_GetDataParams_Destroy(params);
731 return result;
732 }
733
OH_Pasteboard_GetDataWithProgress016(napi_env env,napi_callback_info info)734 static napi_value OH_Pasteboard_GetDataWithProgress016(napi_env env, napi_callback_info info)
735 {
736 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
737 OH_UdmfRecord* record = OH_UdmfRecord_Create();
738 OH_UdmfData* unifiedData = OH_UdmfData_Create();
739 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
740 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
741 OH_UdsFileUri_SetFileUri(fileUri, uri);
742 OH_UdmfRecord_AddFileUri(record, fileUri);
743 OH_UdmfData_AddRecord(unifiedData, record);
744 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
745 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
746
747 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps/";
748 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
749 Pasteboard_FileConflictOptions num1 = (Pasteboard_FileConflictOptions) 3;
750 int num = strlen(uri1);
751 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, num);
752 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, num1);
753 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, PASTEBOARD_DEFAULT);
754 int status = -1;
755
756 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
757 NAPI_ASSERT(env, status == ERR_OK, "OH_Pasteboard_GetDataWithProgress is fail.");
758 NAPI_ASSERT(env, getData != nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
759
760 unsigned int getrecordCount = 0;
761 OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(getData, &getrecordCount);
762 NAPI_ASSERT(env, getrecordCount == 1, "OH_UdmfData_GetRecords is fail.");
763 OH_UdsFileUri* getfileUri = OH_UdsFileUri_Create();
764 OH_UdmfRecord_GetFileUri(getRecords[0], getfileUri);
765 const char* getContent = OH_UdsFileUri_GetFileUri(getfileUri);
766 std::string str = uri1;
767 std::string str1 = str + "dstFile.txt";
768 NAPI_ASSERT(env, strcmp(getContent, str1.c_str()) == 0, "OH_UdsPlainText_GetContent is fail.");
769 OH_Pasteboard_ClearData(pasteboard);
770 OH_Pasteboard_ClearData(pasteboard);
771
772 int recode = 0;
773 napi_value result;
774 napi_create_int32(env, recode, &result);
775 OH_Pasteboard_Destroy(pasteboard);
776 OH_UdmfRecord_Destroy(record);
777 OH_UdmfData_Destroy(unifiedData);
778 OH_UdsFileUri_Destroy(fileUri);
779 OH_UdsFileUri_Destroy(getfileUri);
780 OH_Pasteboard_GetDataParams_Destroy(params);
781 return result;
782 }
783
OH_Pasteboard_GetDataWithProgress017(napi_env env,napi_callback_info info)784 static napi_value OH_Pasteboard_GetDataWithProgress017(napi_env env, napi_callback_info info)
785 {
786 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
787 OH_UdmfRecord* record = OH_UdmfRecord_Create();
788 OH_UdmfData* unifiedData = OH_UdmfData_Create();
789 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
790 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
791 OH_UdsFileUri_SetFileUri(fileUri, uri);
792 OH_UdmfRecord_AddFileUri(record, fileUri);
793 OH_UdmfData_AddRecord(unifiedData, record);
794 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
795 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
796
797 const char *uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps/";
798 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
799 int num = strlen(uri1);
800 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, num);
801 int status = -1;
802
803 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, g_params, &status);
804 NAPI_ASSERT(env, status == ERR_INVALID_PARAMETER, "OH_Pasteboard_GetDataWithProgress is fail.");
805 OH_Pasteboard_ClearData(pasteboard);
806
807 int recode = 0;
808 napi_value result;
809 napi_create_int32(env, recode, &result);
810 OH_Pasteboard_Destroy(pasteboard);
811 OH_UdmfRecord_Destroy(record);
812 OH_UdmfData_Destroy(unifiedData);
813 OH_UdsFileUri_Destroy(fileUri);
814 OH_Pasteboard_GetDataParams_Destroy(params);
815 return result;
816 }
817
OH_Pasteboard_GetDataWithProgress018(napi_env env,napi_callback_info info)818 static napi_value OH_Pasteboard_GetDataWithProgress018(napi_env env, napi_callback_info info)
819 {
820 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
821 OH_UdmfRecord* record = OH_UdmfRecord_Create();
822 OH_UdmfData* unifiedData = OH_UdmfData_Create();
823 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
824 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
825 OH_UdsFileUri_SetFileUri(fileUri, uri);
826 OH_UdmfRecord_AddFileUri(record, fileUri);
827 OH_UdmfData_AddRecord(unifiedData, record);
828 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
829 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
830
831 const char* uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps/";
832 Pasteboard_GetDataParams* params = OH_Pasteboard_GetDataParams_Create();
833 int num = strlen(uri1);
834 OH_Pasteboard_GetDataParams_SetDestUri(params, uri1, num);
835 OH_Pasteboard_GetDataParams_SetFileConflictOptions(params, PASTEBOARD_SKIP);
836 OH_Pasteboard_GetDataParams_SetProgressIndicator(params, PASTEBOARD_NONE);
837 int status = -1;
838
839 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, params, &status);
840 NAPI_ASSERT(env, status == ERR_OK, "OH_Pasteboard_GetDataWithProgress is fail.");
841 NAPI_ASSERT(env, getData != nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
842
843 unsigned int getrecordCount = 0;
844 OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(getData, &getrecordCount);
845 NAPI_ASSERT(env, getrecordCount == 1, "OH_UdmfData_GetRecords is fail.");
846 OH_UdsFileUri* getfileUri = OH_UdsFileUri_Create();
847 OH_UdmfRecord_GetFileUri(getRecords[0], getfileUri);
848 const char* getContent = OH_UdsFileUri_GetFileUri(getfileUri);
849 std::string str = uri1;
850 std::string str1 = str + "dstFile.txt";
851 NAPI_ASSERT(env, strcmp(getContent, str1.c_str()) == 0, "OH_UdsFileUri_GetFileUri is fail.");
852 OH_Pasteboard_ClearData(pasteboard);
853
854 int recode = 0;
855 napi_value result;
856 napi_create_int32(env, recode, &result);
857 OH_Pasteboard_Destroy(pasteboard);
858 OH_UdmfRecord_Destroy(record);
859 OH_UdmfData_Destroy(unifiedData);
860 OH_UdsFileUri_Destroy(fileUri);
861 OH_UdsFileUri_Destroy(getfileUri);
862 OH_Pasteboard_GetDataParams_Destroy(params);
863 return result;
864 }
865
OH_Pasteboard_GetDataWithProgress019(napi_env env,napi_callback_info info)866 static napi_value OH_Pasteboard_GetDataWithProgress019(napi_env env, napi_callback_info info)
867 {
868 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
869 OH_UdmfRecord* record = OH_UdmfRecord_Create();
870 OH_UdmfData* unifiedData = OH_UdmfData_Create();
871 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
872 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
873 OH_UdsFileUri_SetFileUri(fileUri, uri);
874 OH_UdmfRecord_AddFileUri(record, fileUri);
875 OH_UdmfData_AddRecord(unifiedData, record);
876 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
877 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
878
879 const char* uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps/";
880 g_params = OH_Pasteboard_GetDataParams_Create();
881 int num = strlen(uri1);
882 OH_Pasteboard_GetDataParams_SetDestUri(g_params, uri1, num);
883 OH_Pasteboard_GetDataParams_SetFileConflictOptions(g_params, PASTEBOARD_SKIP);
884 OH_Pasteboard_GetDataParams_SetProgressIndicator(g_params, PASTEBOARD_NONE);
885 OH_Pasteboard_GetDataParams_SetProgressListener(g_params, Pasteboard_ProgressListener);
886 int status = -1;
887
888 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, g_params, &status);
889 NAPI_ASSERT(env, status == ERR_OK, "OH_Pasteboard_GetDataWithProgress is fail.");
890 NAPI_ASSERT(env, getData != nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
891
892 OH_Pasteboard_ClearData(pasteboard);
893
894 int recode = 0;
895 napi_value result;
896 napi_create_int32(env, recode, &result);
897 OH_Pasteboard_Destroy(pasteboard);
898 OH_UdmfRecord_Destroy(record);
899 OH_UdmfData_Destroy(unifiedData);
900 OH_UdsFileUri_Destroy(fileUri);
901 OH_Pasteboard_GetDataParams_Destroy(g_params);
902 return result;
903 }
904
OH_Pasteboard_GetDataWithProgress020(napi_env env,napi_callback_info info)905 static napi_value OH_Pasteboard_GetDataWithProgress020(napi_env env, napi_callback_info info)
906 {
907 const char *uri = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/dstFile.txt";
908 OH_UdmfRecord* record = OH_UdmfRecord_Create();
909 OH_UdmfData* unifiedData = OH_UdmfData_Create();
910 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
911 OH_UdsFileUri* fileUri = OH_UdsFileUri_Create();
912 OH_UdsFileUri_SetFileUri(fileUri, uri);
913 OH_UdmfRecord_AddFileUri(record, fileUri);
914 OH_UdmfData_AddRecord(unifiedData, record);
915 int ret = OH_Pasteboard_SetData(pasteboard, unifiedData);
916 NAPI_ASSERT(env, ret == ERR_OK, "OH_Pasteboard_SetData is fail.");
917
918 const char* uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps/";
919 g_params = OH_Pasteboard_GetDataParams_Create();
920 int num = strlen(uri1);
921 OH_Pasteboard_GetDataParams_SetDestUri(g_params, uri1, num);
922 OH_Pasteboard_GetDataParams_SetFileConflictOptions(g_params, PASTEBOARD_SKIP);
923 OH_Pasteboard_GetDataParams_SetProgressIndicator(g_params, PASTEBOARD_NONE);
924 OH_Pasteboard_GetDataParams_SetProgressListener(g_params, oh_Pasteboard_ProgressListener);
925 int status = -1;
926
927 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, g_params, &status);
928 NAPI_ASSERT(env, status == ERR_OK, "OH_Pasteboard_GetDataWithProgress is fail.");
929 NAPI_ASSERT(env, getData != nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
930
931 unsigned int getrecordCount = 0;
932 OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(getData, &getrecordCount);
933 NAPI_ASSERT(env, getrecordCount == 1, "OH_UdmfData_GetRecords is fail.");
934 OH_UdsFileUri* getfileUri = OH_UdsFileUri_Create();
935 OH_UdmfRecord_GetFileUri(getRecords[0], getfileUri);
936 const char* getContent = OH_UdsFileUri_GetFileUri(getfileUri);
937 std::string str = uri1;
938 std::string str1 = str + "dstFile.txt";
939 NAPI_ASSERT(env, strcmp(getContent, str1.c_str()) == 0, "OH_UdsFileUri_GetFileUri is fail.");
940 OH_Pasteboard_ClearData(pasteboard);
941
942 int recode = status;
943 napi_value result;
944 napi_create_int32(env, recode, &result);
945 OH_Pasteboard_Destroy(pasteboard);
946 OH_UdmfRecord_Destroy(record);
947 OH_UdmfData_Destroy(unifiedData);
948 OH_UdsFileUri_Destroy(fileUri);
949 OH_UdsFileUri_Destroy(getfileUri);
950 OH_Pasteboard_GetDataParams_Destroy(g_params);
951 return result;
952 }
953
OH_Pasteboard_GetDataWithProgress021(napi_env env,napi_callback_info info)954 static napi_value OH_Pasteboard_GetDataWithProgress021(napi_env env, napi_callback_info info)
955 {
956 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
957 const char* uri1 = "file://com.acts.Pastboard.ndkWithPermissionstest/data/storage/el2/base/files/haps/";
958 g_params = OH_Pasteboard_GetDataParams_Create();
959 int num = strlen(uri1);
960 OH_Pasteboard_GetDataParams_SetDestUri(g_params, uri1, num);
961 OH_Pasteboard_GetDataParams_SetFileConflictOptions(g_params, PASTEBOARD_SKIP);
962 OH_Pasteboard_GetDataParams_SetProgressIndicator(g_params, PASTEBOARD_NONE);
963 OH_Pasteboard_GetDataParams_SetProgressListener(g_params, oh_Pasteboard_ProgressListener);
964 int status = -1;
965
966 OH_UdmfData* getData = OH_Pasteboard_GetDataWithProgress(pasteboard, g_params, &status);
967 NAPI_ASSERT(env, status == ERR_PASTEBOARD_GET_DATA_FAILED, "OH_Pasteboard_GetDataWithProgress is fail.");
968 NAPI_ASSERT(env, getData == nullptr, "OH_Pasteboard_GetDataWithProgress is fail.");
969
970 int recode = 0;
971 napi_value result;
972 napi_create_int32(env, recode, &result);
973 OH_Pasteboard_Destroy(pasteboard);
974 OH_Pasteboard_GetDataParams_Destroy(g_params);
975 return result;
976 }
977
OH_Pasteboard_GetChangeCount0100(napi_env env,napi_callback_info info)978 static napi_value OH_Pasteboard_GetChangeCount0100(napi_env env, napi_callback_info info)
979 {
980 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
981 uint32_t changeCount = OH_Pasteboard_GetChangeCount(pasteboard);
982 OH_Pasteboard_ClearData(pasteboard);
983 uint32_t newCount = OH_Pasteboard_GetChangeCount(pasteboard);
984 NAPI_ASSERT(env, newCount == changeCount, "OH_Pasteboard_GetChangeCount is fail.");
985 OH_Pasteboard_Destroy(pasteboard);
986 int errcode = 0;
987 napi_value result;
988 napi_create_double(env, errcode, &result);
989 return result;
990 }
991
OH_Pasteboard_GetChangeCount0200(napi_env env,napi_callback_info info)992 static napi_value OH_Pasteboard_GetChangeCount0200(napi_env env, napi_callback_info info)
993 {
994 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
995 uint32_t changeCount = OH_Pasteboard_GetChangeCount(pasteboard);
996 OH_UdmfData* setData = OH_UdmfData_Create();
997 OH_UdmfRecord* record = OH_UdmfRecord_Create();
998 OH_UdsPlainText* plainText = OH_UdsPlainText_Create();
999 char content[] = "hello world";
1000 OH_UdsPlainText_SetContent(plainText, content);
1001 OH_UdmfRecord_AddPlainText(record, plainText);
1002 OH_UdmfData_AddRecord(setData, record);
1003 OH_Pasteboard_SetData(pasteboard, setData);
1004 uint32_t newCount = OH_Pasteboard_GetChangeCount(pasteboard);
1005 NAPI_ASSERT(env, newCount == changeCount + 1, "OH_Pasteboard_GetChangeCount is fail.");
1006 OH_Pasteboard_Destroy(pasteboard);
1007 int errcode = 0;
1008 napi_value result;
1009 napi_create_double(env, errcode, &result);
1010 return result;
1011 }
1012
OH_Pasteboard_GetChangeCount0300(napi_env env,napi_callback_info info)1013 static napi_value OH_Pasteboard_GetChangeCount0300(napi_env env, napi_callback_info info)
1014 {
1015 OH_Pasteboard* pasteboard = OH_Pasteboard_Create();
1016 uint32_t changeCount = OH_Pasteboard_GetChangeCount(pasteboard);
1017 OH_UdmfData* setData = OH_UdmfData_Create();
1018 OH_UdmfRecord* record = OH_UdmfRecord_Create();
1019 OH_UdsPlainText* plainText = OH_UdsPlainText_Create();
1020 char content[] = "hello world";
1021 OH_UdsPlainText_SetContent(plainText, content);
1022 OH_UdmfRecord_AddPlainText(record, plainText);
1023 OH_UdmfData_AddRecord(setData, record);
1024 OH_Pasteboard_SetData(pasteboard, setData);
1025 OH_UdmfRecord* record2 = OH_UdmfRecord_Create();
1026 OH_UdsHtml* htmlText = OH_UdsHtml_Create();
1027 char html[] = "<div class='disabled'>hello</div>";
1028 OH_UdsHtml_SetContent(htmlText, html);
1029 OH_UdmfRecord_AddHtml(record2, htmlText);
1030 OH_UdmfData_AddRecord(setData, record2);
1031 OH_Pasteboard_SetData(pasteboard, setData);
1032 uint32_t newCount = OH_Pasteboard_GetChangeCount(pasteboard);
1033 NAPI_ASSERT(env, newCount == changeCount + 2, "OH_Pasteboard_GetChangeCount is fail.");
1034 OH_Pasteboard_Destroy(pasteboard);
1035 int errcode = 0;
1036 napi_value result;
1037 napi_create_double(env, errcode, &result);
1038 return result;
1039 }
1040
1041 EXTERN_C_START
Init(napi_env env,napi_value exports)1042 static napi_value Init(napi_env env, napi_value exports)
1043 {
1044 napi_property_descriptor desc[] = {
1045 {"OH_Pasteboard_GetDataWithProgress001", nullptr, OH_Pasteboard_GetDataWithProgress001,
1046 nullptr, nullptr, nullptr, napi_default, nullptr},
1047 {"OH_Pasteboard_GetDataWithProgress002", nullptr, OH_Pasteboard_GetDataWithProgress002,
1048 nullptr, nullptr, nullptr, napi_default, nullptr},
1049 {"OH_Pasteboard_GetDataWithProgress003", nullptr, OH_Pasteboard_GetDataWithProgress003,
1050 nullptr, nullptr, nullptr, napi_default, nullptr},
1051 {"OH_Pasteboard_GetDataWithProgress004", nullptr, OH_Pasteboard_GetDataWithProgress004,
1052 nullptr, nullptr, nullptr, napi_default, nullptr},
1053 {"OH_Pasteboard_GetDataWithProgress005", nullptr, OH_Pasteboard_GetDataWithProgress005,
1054 nullptr, nullptr, nullptr, napi_default, nullptr},
1055 {"OH_Pasteboard_GetDataWithProgress006", nullptr, OH_Pasteboard_GetDataWithProgress006,
1056 nullptr, nullptr, nullptr, napi_default, nullptr},
1057 {"OH_Pasteboard_GetDataWithProgress007", nullptr, OH_Pasteboard_GetDataWithProgress007,
1058 nullptr, nullptr, nullptr, napi_default, nullptr},
1059 {"OH_Pasteboard_GetDataWithProgress008", nullptr, OH_Pasteboard_GetDataWithProgress008,
1060 nullptr, nullptr, nullptr, napi_default, nullptr},
1061 {"OH_Pasteboard_GetDataWithProgress009", nullptr, OH_Pasteboard_GetDataWithProgress009,
1062 nullptr, nullptr, nullptr, napi_default, nullptr},
1063 {"OH_Pasteboard_GetDataWithProgress010", nullptr, OH_Pasteboard_GetDataWithProgress010,
1064 nullptr, nullptr, nullptr, napi_default, nullptr},
1065 {"OH_Pasteboard_GetDataWithProgress011", nullptr, OH_Pasteboard_GetDataWithProgress011,
1066 nullptr, nullptr, nullptr, napi_default, nullptr},
1067 {"OH_Pasteboard_GetDataWithProgress012", nullptr, OH_Pasteboard_GetDataWithProgress012,
1068 nullptr, nullptr, nullptr, napi_default, nullptr},
1069 {"OH_Pasteboard_GetDataWithProgress013", nullptr, OH_Pasteboard_GetDataWithProgress013,
1070 nullptr, nullptr, nullptr, napi_default, nullptr},
1071 {"OH_Pasteboard_GetDataWithProgress014", nullptr, OH_Pasteboard_GetDataWithProgress014,
1072 nullptr, nullptr, nullptr, napi_default, nullptr},
1073 {"OH_Pasteboard_GetDataWithProgress015", nullptr, OH_Pasteboard_GetDataWithProgress015,
1074 nullptr, nullptr, nullptr, napi_default, nullptr},
1075 {"OH_Pasteboard_GetDataWithProgress016", nullptr, OH_Pasteboard_GetDataWithProgress016,
1076 nullptr, nullptr, nullptr, napi_default, nullptr},
1077 {"OH_Pasteboard_GetDataWithProgress017", nullptr, OH_Pasteboard_GetDataWithProgress017,
1078 nullptr, nullptr, nullptr, napi_default, nullptr},
1079 {"OH_Pasteboard_GetDataWithProgress018", nullptr, OH_Pasteboard_GetDataWithProgress018,
1080 nullptr, nullptr, nullptr, napi_default, nullptr},
1081 {"OH_Pasteboard_GetDataWithProgress019", nullptr, OH_Pasteboard_GetDataWithProgress019,
1082 nullptr, nullptr, nullptr, napi_default, nullptr},
1083 {"OH_Pasteboard_GetDataWithProgress020", nullptr, OH_Pasteboard_GetDataWithProgress020,
1084 nullptr, nullptr, nullptr, napi_default, nullptr},
1085 {"OH_Pasteboard_GetDataWithProgress021", nullptr, OH_Pasteboard_GetDataWithProgress021,
1086 nullptr, nullptr, nullptr, napi_default, nullptr},
1087 {"OH_Pasteboard_GetChangeCount0100", nullptr, OH_Pasteboard_GetChangeCount0100,
1088 nullptr, nullptr, nullptr, napi_default, nullptr},
1089 {"OH_Pasteboard_GetChangeCount0200", nullptr, OH_Pasteboard_GetChangeCount0200,
1090 nullptr, nullptr, nullptr, napi_default, nullptr},
1091 {"OH_Pasteboard_GetChangeCount0300", nullptr, OH_Pasteboard_GetChangeCount0300,
1092 nullptr, nullptr, nullptr, napi_default, nullptr},
1093 };
1094 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1095 return exports;
1096 }
1097 EXTERN_C_END
1098
1099 static napi_module demoModule = {
1100 .nm_version = 1,
1101 .nm_flags = 0,
1102 .nm_filename = nullptr,
1103 .nm_register_func = Init,
1104 .nm_modname = "entry",
1105 .nm_priv = ((void*)0),
1106 .reserved = { 0 },
1107 };
1108
RegisterEntryModule(void)1109 extern "C" __attribute__((constructor)) void RegisterEntryModule(void)
1110 {
1111 napi_module_register(&demoModule);
1112 }
1113