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 #![feature(file_create_new)]
17 use utils_rust::file_ex;
18 use std::fs::File;
19 use std::io::prelude::*;
20 use std::fs::remove_file;
21 use std::os::unix::io::{AsRawFd, RawFd};
22 use std::ffi::c_char;
23 use std::sync::Mutex;
24
25 pub const CONTENT_STR: &str = "TTtt@#$%^&*()_+~`";
26 pub const FILE_PATH: &str = "./tmp.txt";
27 pub const NULL_STR: &str = "";
28 pub const MAX_FILE_LENGTH: usize = 32 * 1024 * 1024;
29
30 // Use mutex to make sure only one testcase can be running at the same time.
31 // Testcases in this file which involved file operation should use TEST_MUTEX to prevent fd reuse in other threads.
32 static TEST_MUTEX: std::sync::Mutex<()> = Mutex::new(());
33
34 // This code is converted from 43 functions of the utils_file_test.cpp.
35
create_test_file(path: &String, content: &String) -> bool36 pub fn create_test_file(path: &String, content: &String) -> bool {
37 if let Ok(mut file) = File::create(path) {
38 if let Err(err) = file.write_all(content.as_bytes()) {
39 println!("Error writing to file: {}", err);
40 return false;
41 }
42 true
43 } else {
44 println!("Failed to create file: {}", path);
45 false
46 }
47 }
48
remove_test_file(path: &String) -> Result<(), std::io::Error>49 pub fn remove_test_file(path: &String) -> Result<(), std::io::Error> {
50 remove_file(path)
51 }
52
53 #[test]
test_load_string_from_file_001()54 fn test_load_string_from_file_001() {
55 let _guard = TEST_MUTEX.lock().unwrap();
56 let mut str = String::new();
57 let filename = String::from("/proc/meminfo");
58 assert!(file_ex::ffi::RustLoadStringFromFile(&filename, &mut str));
59
60 let mut str2 = String::new();
61 let file = File::open(&filename).expect("Failed to open file");
62 let fd: RawFd = file.as_raw_fd();
63 assert!(file_ex::ffi::RustLoadStringFromFd(fd, &mut str2));
64 assert_eq!(str.len(), str2.len());
65
66 let mut buff: Vec<c_char> = Vec::new();
67 let ret = file_ex::ffi::RustLoadBufferFromFile(&filename, &mut buff);
68 assert!(ret);
69 assert_eq!(str2.len(), buff.len());
70 }
71
72 #[test]
test_load_string_from_file_002()73 fn test_load_string_from_file_002() {
74 let _guard = TEST_MUTEX.lock().unwrap();
75 let mut str = String::new();
76 let filename = NULL_STR.to_string();
77 assert!(!file_ex::ffi::RustLoadStringFromFile(&filename, &mut str));
78 assert!(str.is_empty());
79 }
80
81 #[test]
test_load_string_from_file_003()82 fn test_load_string_from_file_003() {
83 let _guard = TEST_MUTEX.lock().unwrap();
84 let mut str = String::new();
85 let filename = FILE_PATH.to_string() + ".003";
86 let content = NULL_STR.to_string();
87 create_test_file(&filename, &content);
88 assert!(file_ex::ffi::RustLoadStringFromFile(&filename, &mut str));
89 let _err = remove_test_file(&filename);
90 assert_eq!(str, content);
91 }
92
93 #[test]
test_load_string_from_file_004()94 fn test_load_string_from_file_004() {
95 let _guard = TEST_MUTEX.lock().unwrap();
96 let mut str = String::new();
97 let filename = FILE_PATH.to_string() + ".004";
98 let content = CONTENT_STR.to_string();
99 create_test_file(&filename, &content);
100 assert!(file_ex::ffi::RustLoadStringFromFile(&filename, &mut str));
101 let _err = remove_test_file(&filename);
102 assert_eq!(str, content);
103 }
104
105 #[test]
test_load_string_from_file_005()106 fn test_load_string_from_file_005() {
107 let _guard = TEST_MUTEX.lock().unwrap();
108 let mut str = String::new();
109 let filename = FILE_PATH.to_string() + ".005";
110 let content: String = "t".repeat(MAX_FILE_LENGTH);
111 create_test_file(&filename, &content);
112 assert!(file_ex::ffi::RustLoadStringFromFile(&filename, &mut str));
113 let _err = remove_test_file(&filename);
114 assert_eq!(str, content);
115 }
116
117 #[test]
test_load_string_from_file_006()118 fn test_load_string_from_file_006() {
119 let _guard = TEST_MUTEX.lock().unwrap();
120 let mut str = String::new();
121 let filename = FILE_PATH.to_string() + ".006";
122 let content: String = "t".repeat(MAX_FILE_LENGTH + 1);
123 create_test_file(&filename, &content);
124 assert!(!file_ex::ffi::RustLoadStringFromFile(&filename, &mut str));
125 let _err = remove_test_file(&filename);
126 assert!(str.is_empty());
127 }
128
129 #[test]
test_load_string_from_fd_001()130 fn test_load_string_from_fd_001() {
131 let _guard = TEST_MUTEX.lock().unwrap();
132 let mut result = String::new();
133 assert!(!file_ex::ffi::RustLoadStringFromFd(-1, &mut result));
134 assert_eq!(result, "");
135 }
136
137 #[test]
test_load_string_from_fd_002()138 fn test_load_string_from_fd_002() {
139 let _guard = TEST_MUTEX.lock().unwrap();
140 let mut result = String::new();
141 let filename =FILE_PATH.to_string() + ".008";
142 let content = NULL_STR.to_string();
143 create_test_file(&filename, &content);
144 let file = File::open(&filename).expect("Failed to open file");
145 let fd: RawFd = file.as_raw_fd();
146 assert!(file_ex::ffi::RustLoadStringFromFd(fd, &mut result));
147 let _err = remove_test_file(&filename);
148 assert_eq!(result, content);
149 }
150
151 #[test]
test_load_string_from_fd_003()152 fn test_load_string_from_fd_003() {
153 let _guard = TEST_MUTEX.lock().unwrap();
154 let mut result = String::new();
155 let filename = FILE_PATH.to_string() + ".009";
156 let content = CONTENT_STR.to_string();
157 create_test_file(&filename, &content);
158 let file = File::open(&filename).expect("Failed to open file");
159 let fd: RawFd = file.as_raw_fd();
160 assert!(file_ex::ffi::RustLoadStringFromFd(fd, &mut result));
161 let _err = remove_test_file(&filename);
162 assert_eq!(result, content);
163 }
164
165 #[test]
test_load_string_from_fd_004()166 fn test_load_string_from_fd_004() {
167 let _guard = TEST_MUTEX.lock().unwrap();
168 let mut result = String::new();
169 let filename = FILE_PATH.to_string() + ".010";
170 let content: String = "t".repeat(MAX_FILE_LENGTH);
171 create_test_file(&filename, &content);
172 let file = File::open(&filename).expect("Failed to open file");
173 let fd: RawFd = file.as_raw_fd();
174 assert!(file_ex::ffi::RustLoadStringFromFd(fd, &mut result));
175 let _err = remove_test_file(&filename);
176 assert_eq!(result, content);
177 }
178
179 #[test]
test_load_string_from_fd_005()180 fn test_load_string_from_fd_005() {
181 let _guard = TEST_MUTEX.lock().unwrap();
182 let mut result = String::new();
183 let filename = FILE_PATH.to_string() + ".011";
184 let content: String = "t".repeat(MAX_FILE_LENGTH + 1);
185 create_test_file(&filename, &content);
186 let file = File::open(&filename).expect("Failed to open file");
187 let fd: RawFd = file.as_raw_fd();
188 assert!(!file_ex::ffi::RustLoadStringFromFd(fd, &mut result));
189 let _err = remove_test_file(&filename);
190 assert_ne!(result, content);
191 }
192
193 #[test]
test_load_string_from_fd_006()194 fn test_load_string_from_fd_006() {
195 let _guard = TEST_MUTEX.lock().unwrap();
196 let mut result = String::new();
197 let filename = FILE_PATH.to_string() + ".012";
198 let content = CONTENT_STR.to_string();
199 create_test_file(&filename, &content);
200 let fd: i32;
201 {
202 let file = File::open(&filename).expect("Failed to open file");
203 fd = file.as_raw_fd();
204 }
205 assert!(!file_ex::ffi::RustLoadStringFromFd(fd, &mut result));
206 let _err = remove_test_file(&filename);
207 assert_eq!(result, "");
208 }
209
210 #[test]
test_save_string_to_file_001()211 fn test_save_string_to_file_001() {
212 let _guard = TEST_MUTEX.lock().unwrap();
213 let path = FILE_PATH.to_string() + ".013";
214 let content = CONTENT_STR.to_string();
215 let new_content = NULL_STR.to_string();
216 create_test_file(&path, &content);
217 let ret = file_ex::ffi::RustSaveStringToFile(&path, &new_content, true);
218 assert!(ret);
219
220 let mut load_result = String::new();
221 assert!(file_ex::ffi::RustLoadStringFromFile(&path, &mut load_result));
222 let _err = remove_test_file(&path);
223 assert_eq!(load_result, content);
224 }
225
226 #[test]
test_save_string_to_file_002()227 fn test_save_string_to_file_002() {
228 let _guard = TEST_MUTEX.lock().unwrap();
229 let path = FILE_PATH.to_string() + ".014";
230 let content = "Before truncated!".to_string();
231 create_test_file(&path, &content);
232
233 let new_content = CONTENT_STR.to_string();
234 assert!(file_ex::ffi::RustSaveStringToFile(&path, &new_content, true));
235
236 let mut load_result = String::new();
237 assert!(file_ex::ffi::RustLoadStringFromFile(&path, &mut load_result));
238 let _err = remove_test_file(&path);
239 assert_eq!(load_result, new_content);
240 }
241
242 #[test]
test_save_string_to_file_003()243 fn test_save_string_to_file_003() {
244 let _guard = TEST_MUTEX.lock().unwrap();
245 let path = FILE_PATH.to_string() + ".015";
246 let content = "Before truncated!".to_string();
247 create_test_file(&path, &content);
248
249 let new_content = NULL_STR.to_string();
250 assert!(file_ex::ffi::RustSaveStringToFile(&path, &new_content, true));
251
252 let mut load_result = String::new();
253 let ret = file_ex::ffi::RustLoadStringFromFile(&path, &mut load_result);
254 let _err = remove_test_file(&path);
255 assert!(ret);
256 assert_eq!(load_result, content);
257 }
258
259 #[test]
test_save_string_to_file_004()260 fn test_save_string_to_file_004() {
261 let _guard = TEST_MUTEX.lock().unwrap();
262 let path = FILE_PATH.to_string()+ ".016";
263 let new_content = NULL_STR.to_string();
264 let content = "Before truncated!".to_string();
265 create_test_file(&path, &content);
266 assert!(file_ex::ffi::RustSaveStringToFile(&path, &new_content, false));
267
268 let mut load_result = String::new();
269 let ret = file_ex::ffi::RustLoadStringFromFile(&path, &mut load_result);
270 let _err = remove_test_file(&path);
271 assert!(ret);
272 assert_eq!(load_result, content);
273 }
274
275 #[test]
test_save_string_to_file_005()276 fn test_save_string_to_file_005() {
277 let _guard = TEST_MUTEX.lock().unwrap();
278 let path = FILE_PATH.to_string()+ ".017";
279 let content = "Before truncated!".to_string();
280 create_test_file(&path, &content);
281
282 let new_content = CONTENT_STR.to_string();
283 assert!(file_ex::ffi::RustSaveStringToFile(&path, &new_content, false));
284
285 let mut load_result = String::new();
286 let ret = file_ex::ffi::RustLoadStringFromFile(&path, &mut load_result);
287 let _err = remove_test_file(&path);
288 assert!(ret);
289 assert_eq!(load_result, content + &new_content);
290 }
291
292 #[test]
test_save_string_to_fd_001()293 fn test_save_string_to_fd_001() {
294 let _guard = TEST_MUTEX.lock().unwrap();
295 let mut content = String::new();
296 let mut ret = file_ex::ffi::RustSaveStringToFd(0, &content);
297 assert!(!ret);
298 ret = file_ex::ffi::RustSaveStringToFd(-1, &content);
299 assert!(!ret);
300
301 content = CONTENT_STR.to_string();
302 ret = file_ex::ffi::RustSaveStringToFd(0, &content);
303 assert!(!ret);
304 ret = file_ex::ffi::RustSaveStringToFd(-1, &content);
305 assert!(!ret);
306 }
307
308 #[test]
test_save_string_to_fd_002()309 fn test_save_string_to_fd_002() {
310 let _guard = TEST_MUTEX.lock().unwrap();
311 let content = String::new();
312 let filename = FILE_PATH.to_string() + ".019";
313 let mut file = File::create_new(&filename).expect("Failed to create file");
314 let mut fd: RawFd = file.as_raw_fd();
315 let mut ret = file_ex::ffi::RustSaveStringToFd(fd, &content);
316 assert!(ret);
317
318 let mut load_result = String::new();
319 file = File::open(&filename).expect("Failed to open file");
320 fd = file.as_raw_fd();
321 ret = file_ex::ffi::RustLoadStringFromFd(fd, &mut load_result);
322 let _err = remove_test_file(&filename);
323 assert!(ret);
324 assert_eq!(load_result, "");
325 }
326
327 #[test]
test_save_string_to_fd_003()328 fn test_save_string_to_fd_003() {
329 let _guard = TEST_MUTEX.lock().unwrap();
330 let content = CONTENT_STR.to_string();
331 let filename = FILE_PATH.to_string() + ".020";
332 let mut file = File::create_new(&filename).expect("Failed to create file");
333 let mut fd: RawFd = file.as_raw_fd();
334 let mut ret = file_ex::ffi::RustSaveStringToFd(fd, &content);
335 assert!(ret);
336
337 let mut load_result = String::new();
338 file = File::open(&filename).expect("Failed to open file");
339 fd = file.as_raw_fd();
340 ret = file_ex::ffi::RustLoadStringFromFd(fd, &mut load_result);
341 let _err = remove_test_file(&filename);
342 assert!(ret);
343 assert_eq!(load_result, content);
344 }
345
346 #[test]
test_save_string_to_fd_004()347 fn test_save_string_to_fd_004() {
348 let _guard = TEST_MUTEX.lock().unwrap();
349 let content = CONTENT_STR.to_string();
350 let filename = FILE_PATH.to_string() + ".021";
351 File::create(&filename).expect("Failed to create file");
352 let mut file = File::open(&filename).expect("Failed to open file");
353 let mut fd: RawFd = file.as_raw_fd();
354 let mut ret = file_ex::ffi::RustSaveStringToFd(fd, &content);
355 assert!(!ret);
356
357 let mut load_result = String::new();
358 file = File::open(&filename).expect("Failed to open file");
359 fd = file.as_raw_fd();
360 ret = file_ex::ffi::RustLoadStringFromFd(fd, &mut load_result);
361 let _err = remove_test_file(&filename);
362 assert!(ret);
363 assert_eq!(load_result, "");
364 }
365
366 #[test]
test_load_buffer_from_file_001()367 fn test_load_buffer_from_file_001() {
368 let _guard = TEST_MUTEX.lock().unwrap();
369 let mut buff: Vec<c_char> = Vec::new();
370 let filename = FILE_PATH.to_string() + ".022";
371 let ret = file_ex::ffi::RustLoadBufferFromFile(&filename, &mut buff);
372 assert!(!ret);
373 assert_eq!(0, buff.len());
374 }
375
376 #[test]
test_load_buffer_from_file_002()377 fn test_load_buffer_from_file_002() {
378 let _guard = TEST_MUTEX.lock().unwrap();
379 let mut buff: Vec<c_char> = Vec::new();
380 let filename = FILE_PATH.to_string() + ".023";
381 let content = "".to_string();
382 create_test_file(&filename, &content);
383 let ret = file_ex::ffi::RustLoadBufferFromFile(&filename, &mut buff);
384 let _err = remove_test_file(&filename);
385 assert!(ret);
386 assert_eq!(0, buff.len());
387 }
388
389 #[test]
test_load_buffer_from_file_003()390 fn test_load_buffer_from_file_003() {
391 let _guard = TEST_MUTEX.lock().unwrap();
392 let mut buff: Vec<c_char> = Vec::new();
393 let filename = FILE_PATH.to_string() + ".024";
394 let content = "TXB".to_string();
395 create_test_file(&filename, &content);
396 let ret = file_ex::ffi::RustLoadBufferFromFile(&filename, &mut buff);
397 let _err = remove_test_file(&filename);
398 assert!(ret);
399 assert_eq!(3, buff.len());
400 assert_eq!('T' as c_char, buff[0]);
401 assert_eq!('X' as c_char, buff[1]);
402 assert_eq!('B' as c_char, buff[2]);
403 }
404
405 #[test]
test_load_buffer_from_file_004()406 fn test_load_buffer_from_file_004() {
407 let _guard = TEST_MUTEX.lock().unwrap();
408 let mut buff: Vec<c_char> = Vec::new();
409 let filename = FILE_PATH.to_string() + ".025";
410 let content = "t".repeat(MAX_FILE_LENGTH + 1);
411 create_test_file(&filename, &content);
412 let ret = file_ex::ffi::RustLoadBufferFromFile(&filename, &mut buff);
413 let _err = remove_test_file(&filename);
414 assert!(!ret);
415 assert_eq!(0, buff.len());
416 }
417
418 #[test]
test_save_buffer_to_file_001()419 fn test_save_buffer_to_file_001() {
420 let _guard = TEST_MUTEX.lock().unwrap();
421 let filename = FILE_PATH.to_string() + ".026";
422 let content = "ttxx".to_string();
423 create_test_file(&filename, &content);
424 let buff: Vec<c_char> = Vec::new();
425 let ret = file_ex::ffi::RustSaveBufferToFile(&filename, &buff, false);
426 assert!(ret);
427
428 let mut load_result = String::new();
429 let ret = file_ex::ffi::RustLoadStringFromFile(&filename, &mut load_result);
430 let _err = remove_test_file(&filename);
431 assert!(ret);
432 assert_eq!(load_result, content);
433 }
434
435 #[test]
test_save_buffer_to_file_002()436 fn test_save_buffer_to_file_002() {
437 let _guard = TEST_MUTEX.lock().unwrap();
438 let filename = FILE_PATH.to_string() + ".027";
439 let content = "ttxx".to_string();
440 create_test_file(&filename, &content);
441
442 let new_content: Vec<c_char> = vec!['x' as c_char, 'x' as c_char, 't' as c_char, 't' as c_char];
443 let ret = file_ex::ffi::RustSaveBufferToFile(&filename, &new_content, true);
444 assert!(ret);
445
446 let mut load_result = String::new();
447 let ret = file_ex::ffi::RustLoadStringFromFile(&filename, &mut load_result);
448 let _err = remove_test_file(&filename);
449 assert!(ret);
450 assert_eq!(load_result, String::from_utf8_lossy(&new_content));
451 }
452
453 #[test]
test_save_buffer_to_file_003()454 fn test_save_buffer_to_file_003() {
455 let _guard = TEST_MUTEX.lock().unwrap();
456 let filename = FILE_PATH.to_string() + ".028";
457 let content = "ttxx".to_string();
458 create_test_file(&filename, &content);
459
460 let new_content: Vec<c_char> = vec!['x' as c_char, 'x' as c_char, 't' as c_char, 't' as c_char];
461 let mut ret = file_ex::ffi::RustSaveBufferToFile(&filename, &new_content, false);
462 assert!(ret);
463
464 let mut load_result = String::new();
465 ret = file_ex::ffi::RustLoadStringFromFile(&filename, &mut load_result);
466 let _err = remove_test_file(&filename);
467 assert!(ret);
468 assert_eq!(&load_result, &(content + &String::from_utf8_lossy(&new_content)));
469 }
470
471 #[test]
test_string_exists_in_file_001()472 fn test_string_exists_in_file_001() {
473 let _guard = TEST_MUTEX.lock().unwrap();
474 let str_value = "abc".to_string();
475 let filename = String::new();
476 assert!(!file_ex::ffi::RustStringExistsInFile(&filename, &str_value, true));
477 assert!(!str_value.is_empty());
478 }
479
480 #[test]
test_string_exists_in_file_002()481 fn test_string_exists_in_file_002() {
482 let _guard = TEST_MUTEX.lock().unwrap();
483 let str_value = NULL_STR.to_string();
484 let filename = FILE_PATH.to_string() + ".030";
485 let content = "hello world!".to_string();
486 create_test_file(&filename, &content);
487 assert!(!file_ex::ffi::RustStringExistsInFile(&filename, &str_value, true));
488 let _err = remove_test_file(&filename);
489 }
490
491 #[test]
test_string_exists_in_file_003()492 fn test_string_exists_in_file_003() {
493 let _guard = TEST_MUTEX.lock().unwrap();
494 let str_value = "world".to_string();
495 let filename = FILE_PATH.to_string() + ".031";
496 let content = "hello world!".to_string();
497 create_test_file(&filename, &content);
498 assert!(file_ex::ffi::RustStringExistsInFile(&filename, &str_value, true));
499 let _err = remove_test_file(&filename);
500 }
501
502 #[test]
test_string_exists_in_file_004()503 fn test_string_exists_in_file_004() {
504 let _guard = TEST_MUTEX.lock().unwrap();
505 let str_value1 = "t".repeat(MAX_FILE_LENGTH + 1);
506 let str_value2 = "t".repeat(MAX_FILE_LENGTH);
507 let filename = FILE_PATH.to_string() + ".032";
508 let content = "t".repeat(MAX_FILE_LENGTH);
509 create_test_file(&filename, &content);
510 assert!(!file_ex::ffi::RustStringExistsInFile(&filename, &str_value1, true));
511 assert!(file_ex::ffi::RustStringExistsInFile(&filename, &str_value2, true));
512 let _err = remove_test_file(&filename);
513 }
514
515 #[test]
test_string_exists_in_file_005()516 fn test_string_exists_in_file_005() {
517 let _guard = TEST_MUTEX.lock().unwrap();
518 let str_value = "woRld".to_string();
519 let filename = FILE_PATH.to_string() + ".033";
520 let content = "hello world!".to_string();
521 create_test_file(&filename, &content);
522 assert!(file_ex::ffi::RustStringExistsInFile(&filename, &str_value, false));
523 assert!(!file_ex::ffi::RustStringExistsInFile(&filename, &str_value, true));
524 let _err = remove_test_file(&filename);
525 }
526
527 #[test]
test_string_exists_in_file_006()528 fn test_string_exists_in_file_006() {
529 let _guard = TEST_MUTEX.lock().unwrap();
530 let str_value1 = "woRld".to_string();
531 let str_value2 = "123".to_string();
532 let str_value3 = "llo ".to_string();
533 let str_value4 = "123 w".to_string();
534 let str_value5 = "hi".to_string();
535 let filename = FILE_PATH.to_string() + ".034";
536 let content = "Test, hello 123 World!".to_string();
537 create_test_file(&filename, &content);
538 assert!(file_ex::ffi::RustStringExistsInFile(&filename, &str_value1, false));
539 assert!(!file_ex::ffi::RustStringExistsInFile(&filename, &str_value1, true));
540
541 assert!(file_ex::ffi::RustStringExistsInFile(&filename, &str_value2, false));
542 assert!(file_ex::ffi::RustStringExistsInFile(&filename, &str_value2, true));
543
544 assert!(file_ex::ffi::RustStringExistsInFile(&filename, &str_value3, false));
545 assert!(file_ex::ffi::RustStringExistsInFile(&filename, &str_value3, true));
546
547 assert!(file_ex::ffi::RustStringExistsInFile(&filename, &str_value4, false));
548 assert!(!file_ex::ffi::RustStringExistsInFile(&filename, &str_value4, true));
549
550 assert!(!file_ex::ffi::RustStringExistsInFile(&filename, &str_value5, false));
551 assert!(!file_ex::ffi::RustStringExistsInFile(&filename, &str_value5, true));
552 let _err = remove_test_file(&filename);
553 }
554
555 #[test]
test_string_exists_in_file_007()556 fn test_string_exists_in_file_007() {
557 let _guard = TEST_MUTEX.lock().unwrap();
558 let str_value1 = "is".to_string();
559 let str_value2 = "\n\ris".to_string();
560 let filename = FILE_PATH.to_string() + ".035";
561 let content = "Test, special string\n\ris ok".to_string();
562 create_test_file(&filename, &content);
563 assert!(file_ex::ffi::RustStringExistsInFile(&filename, &str_value1, false));
564 assert!(file_ex::ffi::RustStringExistsInFile(&filename, &str_value1, true));
565
566 assert!(file_ex::ffi::RustStringExistsInFile(&filename, &str_value2, false));
567 assert!(file_ex::ffi::RustStringExistsInFile(&filename, &str_value2, true));
568 let _err = remove_test_file(&filename);
569 }
570
571 #[test]
test_file_exist_001()572 fn test_file_exist_001()
573 {
574 let _guard = TEST_MUTEX.lock().unwrap();
575 let filepath = "/proc/meminfo".to_string();
576 let filepath1 = "/proc/meminfo1".to_string();
577
578 assert!(file_ex::ffi::RustFileExists(&filepath));
579 assert!(!(file_ex::ffi::RustFileExists(&filepath1)));
580 }
581
582 #[test]
test_count_str_in_file_001()583 fn test_count_str_in_file_001()
584 {
585 let _guard = TEST_MUTEX.lock().unwrap();
586 let str = "abc".to_string();
587 let filename = "".to_string();
588 assert_eq!(file_ex::ffi::RustCountStrInFile(&filename, &str, true), -1);
589 assert!(!str.is_empty());
590 }
591
592 #[test]
test_count_str_in_file_002()593 fn test_count_str_in_file_002()
594 {
595 let _guard = TEST_MUTEX.lock().unwrap();
596 let str = NULL_STR.to_string();
597 let filename = FILE_PATH.to_string() + ".038";
598 let content = "hello world!".to_string();
599 create_test_file(&filename, &content);
600 assert_eq!(file_ex::ffi::RustCountStrInFile(&filename, &str, true), -1);
601 let _err = remove_test_file(&filename);
602 }
603
604 #[test]
test_count_str_in_file_003()605 fn test_count_str_in_file_003()
606 {
607 let _guard = TEST_MUTEX.lock().unwrap();
608 let str1 = "t".repeat(MAX_FILE_LENGTH + 1);
609 let str2 = "t".repeat(MAX_FILE_LENGTH);
610 let filename = FILE_PATH.to_string() + ".039";
611 let content = "t".repeat(MAX_FILE_LENGTH);
612 create_test_file(&filename, &content);
613 assert_eq!(file_ex::ffi::RustCountStrInFile(&filename, &str1, true), 0);
614 assert_eq!(file_ex::ffi::RustCountStrInFile(&filename, &str2, true), 1);
615 let _err = remove_test_file(&filename);
616 }
617
618 #[test]
test_count_str_in_file_004()619 fn test_count_str_in_file_004()
620 {
621 let _guard = TEST_MUTEX.lock().unwrap();
622 let str1 = "very".to_string();
623 let str2 = "VERY".to_string();
624 let str3 = "abc".to_string();
625 let filename = FILE_PATH.to_string() + ".040";
626 let content = "This is very very long string for test.\n Very Good,\r VERY HAPPY.".to_string();
627 create_test_file(&filename, &content);
628 assert_eq!(file_ex::ffi::RustCountStrInFile(&filename, &str1, true), 2);
629 assert_eq!(file_ex::ffi::RustCountStrInFile(&filename, &str1, false), 4);
630
631 assert_eq!(file_ex::ffi::RustCountStrInFile(&filename, &str2, true), 1);
632 assert_eq!(file_ex::ffi::RustCountStrInFile(&filename, &str2, false), 4);
633
634 assert_eq!(file_ex::ffi::RustCountStrInFile(&filename, &str3, true), 0);
635 let _err = remove_test_file(&filename);
636 }
637
638 #[test]
test_count_str_in_file_005()639 fn test_count_str_in_file_005()
640 {
641 let _guard = TEST_MUTEX.lock().unwrap();
642 let str1 = "aba".to_string();
643 let filename = FILE_PATH.to_string() + ".041";
644 let content = "This is abababaBABa.".to_string();
645 create_test_file(&filename, &content);
646 assert_eq!(file_ex::ffi::RustCountStrInFile(&filename, &str1, true), 2);
647 assert_eq!(file_ex::ffi::RustCountStrInFile(&filename, &str1, false), 3);
648 let _err = remove_test_file(&filename);
649 }