1 /* Copyright (c) 2023 Huawei Device Co., Ltd.
2  * Licensed under the Apache License, Version 2.0 (the "License");
3  * you may not use this file except in compliance with the License.
4  * You may obtain a copy of the License at
5  *
6  *     http://www.apache.org/licenses/LICENSE-2.0
7  *
8  * Unless required by applicable law or agreed to in writing, software
9  * distributed under the License is distributed on an "AS IS" BASIS,
10  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11  * See the License for the specific language governing permissions and
12  * limitations under the License.
13  */
14 
15 use std::ptr;
16 use std::ffi::{c_char, CStr, CString};
17 use utils_rust::ashmem;
18 
19 const MEMORY_SIZE: i32 = 1024;
20 const MEMORY_NAME: &str = "Test SharedMemory";
21 const MEMORY_CONTENT: &str = "HelloWorld2023";
22 
23 #[test]
test_ashmem_ffi_write_read_001()24 fn test_ashmem_ffi_write_read_001()
25 {
26     let c_name = CString::new(MEMORY_NAME).expect("CString::new Failed!");
27     let ashmem = unsafe { ashmem::ffi::CreateAshmemStd(c_name.as_ptr(), MEMORY_SIZE) };
28     assert!(!ashmem.is_null());
29     assert_eq!(ashmem.GetAshmemSize(), MEMORY_SIZE);
30 
31     assert!(ashmem.MapAshmem(ashmem::PROT_READ | ashmem::PROT_WRITE));
32 
33     ashmem.UnmapAshmem();
34     ashmem.CloseAshmem();
35 }
36 
37 #[test]
test_ashmem_ffi_write_read_002()38 fn test_ashmem_ffi_write_read_002()
39 {
40     let c_name = CString::new(MEMORY_NAME).expect("CString::new Failed!");
41     let ashmem = unsafe { ashmem::ffi::CreateAshmemStd(c_name.as_ptr(), MEMORY_SIZE) };
42     assert!(!ashmem.is_null());
43 
44     assert!(ashmem.MapReadAndWriteAshmem());
45 
46     let c_content = CString::new(MEMORY_CONTENT).expect("CString::new Failed!");
47     let c_content_ptr: *const ashmem::ffi::c_void = unsafe { ashmem::ffi::AsVoidPtr(c_content.as_ptr()) };
48 
49     unsafe {
50         assert!(ashmem.WriteToAshmem(c_content_ptr, MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
51         assert!(ashmem.WriteToAshmem(c_content_ptr, MEMORY_CONTENT.len().try_into().expect("Invalid content size."),
52                 MEMORY_CONTENT.len().try_into().expect("Invalid content size.")));
53     }
54     let readout_ptr: *const c_char;
55     unsafe {
56         readout_ptr = ashmem::ffi::AsCharPtr(ashmem.ReadFromAshmem(MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
57     }
58     assert!(!readout_ptr.is_null());
59 
60     // readout_ptr requires a valid nul terminator at the end of the string.
61     let readout_c_str: &CStr = unsafe { CStr::from_ptr(readout_ptr) };
62     let readout_str: &str = readout_c_str.to_str().expect("Bad encoding.");
63 
64     let mut expect = String::from(MEMORY_CONTENT);
65     expect.push_str(MEMORY_CONTENT);
66     assert_eq!(readout_str, expect.as_str());
67 
68     ashmem.UnmapAshmem();
69     ashmem.CloseAshmem();
70 }
71 
72 #[test]
test_ashmem_ffi_write_read_003()73 fn test_ashmem_ffi_write_read_003()
74 {
75     let c_name = CString::new(MEMORY_NAME).expect("CString::new Failed!");
76     let ashmem = unsafe { ashmem::ffi::CreateAshmemStd(c_name.as_ptr(), MEMORY_SIZE) };
77     assert!(!ashmem.is_null());
78 
79     assert!(ashmem.MapReadAndWriteAshmem());
80 
81     let c_content = CString::new(MEMORY_CONTENT).expect("CString::new Failed!");
82     let c_content_ptr: *const ashmem::ffi::c_void = unsafe { ashmem::ffi::AsVoidPtr(c_content.as_ptr()) };
83 
84     unsafe {
85         assert!(ashmem.WriteToAshmem(c_content_ptr, MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
86     }
87 
88     ashmem.UnmapAshmem();
89     assert!(ashmem.MapReadOnlyAshmem());
90 
91     unsafe {
92         assert!(!ashmem.WriteToAshmem(c_content_ptr, MEMORY_CONTENT.len().try_into().expect("Invalid content size."),
93                 MEMORY_NAME.len().try_into().expect("Invalid content size.")));
94     }
95 
96     let readout_ptr: *const c_char;
97     unsafe {
98         readout_ptr = ashmem::ffi::AsCharPtr(ashmem.ReadFromAshmem(MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
99     }
100     assert!(!readout_ptr.is_null());
101 
102     // readout_ptr requires a valid nul terminator at the end of the string.
103     let readout_c_str: &CStr = unsafe { CStr::from_ptr(readout_ptr) };
104     let readout_str: &str = readout_c_str.to_str().expect("Bad encoding.");
105 
106     assert_eq!(readout_str, MEMORY_CONTENT);
107 
108     ashmem.UnmapAshmem();
109     ashmem.CloseAshmem();
110 }
111 
112 #[test]
test_ashmem_ffi_write_read_004()113 fn test_ashmem_ffi_write_read_004()
114 {
115     let c_name = CString::new(MEMORY_NAME).expect("CString::new Failed!");
116     let ashmem = unsafe { ashmem::ffi::CreateAshmemStd(c_name.as_ptr(), MEMORY_SIZE) };
117     assert!(!ashmem.is_null());
118 
119     assert!(ashmem.MapReadAndWriteAshmem());
120     let c_content = CString::new(MEMORY_CONTENT).expect("CString::new Failed!");
121     let c_content_ptr: *const ashmem::ffi::c_void = unsafe { ashmem::ffi::AsVoidPtr(c_content.as_ptr()) };
122     unsafe {
123         assert!(ashmem.WriteToAshmem(c_content_ptr, MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
124     }
125 
126     ashmem.UnmapAshmem();
127     assert!(ashmem.SetProtection(ashmem::PROT_READ));
128     assert!(!ashmem.MapReadAndWriteAshmem());
129     assert!(ashmem.MapReadOnlyAshmem());
130 
131     let readout_ptr: *const c_char;
132     unsafe {
133         readout_ptr = ashmem::ffi::AsCharPtr(ashmem.ReadFromAshmem(MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
134     }
135     assert!(!readout_ptr.is_null());
136 
137     // readout_ptr requires a valid nul terminator at the end of the string.
138     let readout_c_str: &CStr = unsafe { CStr::from_ptr(readout_ptr) };
139     let readout_str: &str = readout_c_str.to_str().expect("Bad encoding.");
140     assert_eq!(readout_str, MEMORY_CONTENT);
141 
142     ashmem.UnmapAshmem();
143     ashmem.CloseAshmem();
144 }
145 
146 #[test]
test_ashmem_ffi_write_read_005()147 fn test_ashmem_ffi_write_read_005()
148 {
149     let c_name = CString::new(MEMORY_NAME).expect("CString::new Failed!");
150     let ashmem = unsafe { ashmem::ffi::CreateAshmemStd(c_name.as_ptr(), MEMORY_SIZE) };
151     assert!(!ashmem.is_null());
152 
153     assert!(ashmem.MapReadAndWriteAshmem());
154     assert!(ashmem.SetProtection(ashmem::PROT_READ));
155     let c_content = CString::new(MEMORY_CONTENT).expect("CString::new Failed!");
156     let c_content_ptr: *const ashmem::ffi::c_void = unsafe { ashmem::ffi::AsVoidPtr(c_content.as_ptr()) };
157     unsafe {
158         assert!(!ashmem.WriteToAshmem(c_content_ptr, MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
159     }
160 
161     assert!(ashmem.MapReadOnlyAshmem());
162 
163     let readout_ptr: *const c_char;
164     unsafe {
165         readout_ptr = ashmem::ffi::AsCharPtr(ashmem.ReadFromAshmem(MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
166     }
167     assert!(!readout_ptr.is_null());
168 
169     // readout_ptr requires a valid nul terminator at the end of the string.
170     let readout_c_str: &CStr = unsafe { CStr::from_ptr(readout_ptr) };
171     let readout_str: &str = readout_c_str.to_str().expect("Bad encoding.");
172     assert_eq!(readout_str, "");
173 
174     ashmem.UnmapAshmem();
175     ashmem.CloseAshmem();
176 }
177 
178 #[test]
test_ashmem_ffi_invalid_001()179 fn test_ashmem_ffi_invalid_001()
180 {
181     let c_name = CString::new(MEMORY_NAME).expect("CString::new Failed!");
182     let ashmem = unsafe { ashmem::ffi::CreateAshmemStd(c_name.as_ptr(), -1) };
183     assert!(ashmem.is_null());
184 
185     let ashmem = unsafe { ashmem::ffi::CreateAshmemStd(c_name.as_ptr(), MEMORY_SIZE) };
186     assert!(!ashmem.is_null());
187 
188     assert!(!ashmem.SetProtection(-1));
189 
190     ashmem.CloseAshmem();
191 }
192 
193 #[test]
test_ashmem_ffi_invalid_002()194 fn test_ashmem_ffi_invalid_002()
195 {
196     let c_name = CString::new(MEMORY_NAME).expect("CString::new Failed!");
197     let ashmem = unsafe { ashmem::ffi::CreateAshmemStd(c_name.as_ptr(), MEMORY_SIZE) };
198     assert!(!ashmem.is_null());
199 
200     ashmem.CloseAshmem();
201     assert!(!ashmem.MapReadAndWriteAshmem());
202 }
203 
204 #[test]
test_ashmem_ffi_invalid_003()205 fn test_ashmem_ffi_invalid_003()
206 {
207     let c_name = CString::new(MEMORY_NAME).expect("CString::new Failed!");
208     let ashmem = unsafe { ashmem::ffi::CreateAshmemStd(c_name.as_ptr(), MEMORY_SIZE) };
209     assert!(!ashmem.is_null());
210 
211     assert!(ashmem.MapReadAndWriteAshmem());
212 
213     ashmem.CloseAshmem();
214     let c_content = CString::new(MEMORY_CONTENT).expect("CString::new Failed!");
215     let c_content_ptr: *const ashmem::ffi::c_void = unsafe { ashmem::ffi::AsVoidPtr(c_content.as_ptr()) };
216     unsafe {
217         assert!(!ashmem.WriteToAshmem(c_content_ptr, MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
218     }
219 
220     let readout_ptr: *const c_char;
221     unsafe {
222         readout_ptr = ashmem::ffi::AsCharPtr(ashmem.ReadFromAshmem(MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
223     }
224     assert!(readout_ptr.is_null());
225 }
226 
227 #[test]
test_ashmem_ffi_invalid_004()228 fn test_ashmem_ffi_invalid_004()
229 {
230     let c_name = CString::new(MEMORY_NAME).expect("CString::new Failed!");
231     let ashmem = unsafe { ashmem::ffi::CreateAshmemStd(c_name.as_ptr(), MEMORY_SIZE) };
232     assert!(!ashmem.is_null());
233 
234     assert!(ashmem.MapReadAndWriteAshmem());
235 
236     ashmem.UnmapAshmem();
237     let c_content = CString::new(MEMORY_CONTENT).expect("CString::new Failed!");
238     let c_content_ptr: *const ashmem::ffi::c_void = unsafe { ashmem::ffi::AsVoidPtr(c_content.as_ptr()) };
239     unsafe {
240         assert!(!ashmem.WriteToAshmem(c_content_ptr, MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
241     }
242 
243     let readout_ptr: *const c_char;
244     unsafe {
245         readout_ptr = ashmem::ffi::AsCharPtr(ashmem.ReadFromAshmem(MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
246     }
247     assert!(readout_ptr.is_null());
248 
249     ashmem.CloseAshmem();
250 }
251 
252 #[test]
test_ashmem_ffi_invalid_005()253 fn test_ashmem_ffi_invalid_005()
254 {
255     let c_name = CString::new(MEMORY_NAME).expect("CString::new Failed!");
256     let ashmem = unsafe { ashmem::ffi::CreateAshmemStd(c_name.as_ptr(), MEMORY_SIZE) };
257     assert!(!ashmem.is_null());
258 
259     assert!(ashmem.SetProtection(ashmem::PROT_WRITE));
260     assert!(!ashmem.SetProtection(ashmem::PROT_READ));
261     assert!(!ashmem.SetProtection(ashmem::PROT_READ | ashmem::PROT_WRITE));
262     assert!(ashmem.SetProtection(ashmem::PROT_NONE));
263     assert!(!ashmem.SetProtection(ashmem::PROT_READ));
264     assert!(!ashmem.SetProtection(ashmem::PROT_WRITE));
265 
266     ashmem.CloseAshmem();
267 }
268 
269 
270 #[test]
test_ashmem_ffi_invalid_006()271 fn test_ashmem_ffi_invalid_006()
272 {
273     let c_name = CString::new(MEMORY_NAME).expect("CString::new Failed!");
274     let ashmem = unsafe { ashmem::ffi::CreateAshmemStd(c_name.as_ptr(), MEMORY_SIZE) };
275     assert!(!ashmem.is_null());
276 
277     assert!(ashmem.MapReadAndWriteAshmem());
278     let c_content = CString::new(MEMORY_CONTENT).expect("CString::new Failed!");
279     let c_content_ptr: *const ashmem::ffi::c_void = unsafe { ashmem::ffi::AsVoidPtr(c_content.as_ptr()) };
280     unsafe {
281         assert!(!ashmem.WriteToAshmem(ptr::null(), MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
282         assert!(!ashmem.WriteToAshmem(c_content_ptr, MEMORY_CONTENT.len().try_into().expect("Invalid content size."), MEMORY_SIZE));
283         assert!(!ashmem.WriteToAshmem(c_content_ptr, MEMORY_CONTENT.len().try_into().expect("Invalid content size."), MEMORY_SIZE + 1));
284         assert!(!ashmem.WriteToAshmem(c_content_ptr, MEMORY_CONTENT.len().try_into().expect("Invalid content size."), -1));
285         assert!(!ashmem.WriteToAshmem(c_content_ptr, MEMORY_SIZE + 1, 0));
286         assert!(!ashmem.WriteToAshmem(c_content_ptr, -1, 0));
287     }
288 
289     ashmem.UnmapAshmem();
290     ashmem.CloseAshmem();
291 }
292 
293 #[test]
test_ashmem_write_read_001()294 fn test_ashmem_write_read_001()
295 {
296     let ashmem = unsafe { ashmem::create_ashmem_instance(MEMORY_NAME, MEMORY_SIZE) };
297     assert!(ashmem.is_some());
298 
299     let ashmem = ashmem.unwrap();
300     assert_eq!(ashmem.get_ashmem_size(), MEMORY_SIZE);
301     assert_eq!(ashmem.get_protection(), ashmem::PROT_READ | ashmem::PROT_WRITE | ashmem::PROT_EXEC); // default protection mask.
302     assert_ne!(ashmem.get_ashmem_fd(), -1);
303 
304     assert!(ashmem.map_ashmem(ashmem::PROT_READ | ashmem::PROT_WRITE));
305 
306     ashmem.unmap_ashmem();
307     ashmem.close_ashmem();
308 }
309 
310 #[test]
test_ashmem_write_read_002()311 fn test_ashmem_write_read_002()
312 {
313     let ashmem = unsafe { ashmem::create_ashmem_instance(MEMORY_NAME, MEMORY_SIZE) };
314     assert!(ashmem.is_some());
315 
316     let ashmem = ashmem.unwrap();
317     assert!(ashmem.map_read_write_ashmem());
318 
319     let c_content = CString::new(MEMORY_CONTENT).expect("CString::new Failed!");
320     unsafe {
321         assert!(ashmem.write_to_ashmem(c_content.as_ptr(), MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
322         assert!(ashmem.write_to_ashmem(c_content.as_ptr(), MEMORY_CONTENT.len().try_into().expect("Invalid content size."),
323                 MEMORY_CONTENT.len().try_into().expect("Invalid content size.")));
324     }
325     let readout_ptr: *const c_char;
326     unsafe {
327         readout_ptr = ashmem.read_from_ashmem(MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0);
328         assert!(!readout_ptr.is_null());
329     }
330 
331     // readout_ptr requires a valid nul terminator at the end of the string.
332     let readout_c_str: &CStr = unsafe { CStr::from_ptr(readout_ptr) };
333     let readout_str: &str = readout_c_str.to_str().expect("Bad encoding.");
334 
335     let mut expect = String::from(MEMORY_CONTENT);
336     expect.push_str(MEMORY_CONTENT);
337     assert_eq!(readout_str, expect.as_str());
338 
339     ashmem.unmap_ashmem();
340     ashmem.close_ashmem();
341 }
342 
343 #[test]
test_ashmem_write_read_003()344 fn test_ashmem_write_read_003()
345 {
346     let ashmem = unsafe { ashmem::create_ashmem_instance(MEMORY_NAME, MEMORY_SIZE) };
347     assert!(ashmem.is_some());
348 
349     let ashmem = ashmem.unwrap();
350     assert!(ashmem.map_read_write_ashmem());
351 
352     let c_content = CString::new(MEMORY_CONTENT).expect("CString::new Failed!");
353     unsafe {
354         assert!(ashmem.write_to_ashmem(c_content.as_ptr(), MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
355     }
356 
357     ashmem.unmap_ashmem();
358     assert!(ashmem.map_read_only_ashmem());
359 
360     unsafe {
361         assert!(!ashmem.write_to_ashmem(c_content.as_ptr(), MEMORY_CONTENT.len().try_into().expect("Invalid content size."),
362                 MEMORY_CONTENT.len().try_into().expect("Invalid content size.")));
363     }
364 
365     let readout_ptr: *const c_char;
366     unsafe {
367         readout_ptr = ashmem.read_from_ashmem(MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0);
368         assert!(!readout_ptr.is_null());
369     }
370 
371     // readout_ptr requires a valid nul terminator at the end of the string.
372     let readout_c_str: &CStr = unsafe { CStr::from_ptr(readout_ptr) };
373     let readout_str: &str = readout_c_str.to_str().expect("Bad encoding.");
374 
375     assert_eq!(readout_str, MEMORY_CONTENT);
376 
377     ashmem.unmap_ashmem();
378     ashmem.close_ashmem();
379 }
380 
381 #[test]
test_ashmem_write_read_004()382 fn test_ashmem_write_read_004()
383 {
384     let ashmem = unsafe { ashmem::create_ashmem_instance(MEMORY_NAME, MEMORY_SIZE) };
385     assert!(ashmem.is_some());
386 
387     let ashmem = ashmem.unwrap();
388     assert!(ashmem.map_read_write_ashmem());
389 
390     let c_content = CString::new(MEMORY_CONTENT).expect("CString::new Failed!");
391     unsafe {
392         assert!(ashmem.write_to_ashmem(c_content.as_ptr(), MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
393     }
394 
395     ashmem.unmap_ashmem();
396     assert!(ashmem.set_protection(ashmem::PROT_READ));
397     assert!(!ashmem.map_read_write_ashmem());
398     assert!(ashmem.map_read_only_ashmem());
399 
400     let readout_ptr: *const c_char;
401     unsafe {
402         readout_ptr = ashmem.read_from_ashmem(MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0);
403         assert!(!readout_ptr.is_null());
404     }
405 
406     // readout_ptr requires a valid nul terminator at the end of the string.
407     let readout_c_str: &CStr = unsafe { CStr::from_ptr(readout_ptr) };
408     let readout_str: &str = readout_c_str.to_str().expect("Bad encoding.");
409     assert_eq!(readout_str, MEMORY_CONTENT);
410 
411     ashmem.unmap_ashmem();
412     ashmem.close_ashmem();
413 }
414 
415 #[test]
test_ashmem_write_read_005()416 fn test_ashmem_write_read_005()
417 {
418     let ashmem = unsafe { ashmem::create_ashmem_instance(MEMORY_NAME, MEMORY_SIZE) };
419     assert!(ashmem.is_some());
420 
421     let ashmem = ashmem.unwrap();
422     assert!(ashmem.map_read_write_ashmem());
423     assert!(ashmem.set_protection(ashmem::PROT_READ));
424     let c_content = CString::new(MEMORY_CONTENT).expect("CString::new Failed!");
425     unsafe {
426         assert!(!ashmem.write_to_ashmem(c_content.as_ptr(), MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
427     }
428 
429     assert!(ashmem.map_read_only_ashmem());
430 
431     let readout_ptr: *const c_char;
432     unsafe {
433         readout_ptr = ashmem.read_from_ashmem(MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0);
434         assert!(!readout_ptr.is_null());
435     }
436 
437     // readout_ptr requires a valid nul terminator at the end of the string.
438     let readout_c_str: &CStr = unsafe { CStr::from_ptr(readout_ptr) };
439     let readout_str: &str = readout_c_str.to_str().expect("Bad encoding.");
440     assert_eq!(readout_str, "");
441 
442     ashmem.unmap_ashmem();
443     ashmem.close_ashmem();
444 }
445 
446 #[test]
test_ashmem_invalid_001()447 fn test_ashmem_invalid_001()
448 {
449     let ashmem = unsafe { ashmem::create_ashmem_instance(MEMORY_NAME, -1i32) };
450     assert!(ashmem.is_none());
451 
452     let ashmem = unsafe { ashmem::create_ashmem_instance(MEMORY_NAME, MEMORY_SIZE) };
453     assert!(ashmem.is_some());
454 
455     let ashmem = ashmem.unwrap();
456 
457     assert!(!ashmem.set_protection(-1));
458 
459     ashmem.close_ashmem();
460 }
461 
462 #[test]
test_ashmem_invalid_002()463 fn test_ashmem_invalid_002()
464 {
465     let ashmem = unsafe { ashmem::create_ashmem_instance(MEMORY_NAME, MEMORY_SIZE) };
466     assert!(ashmem.is_some());
467 
468     let ashmem = ashmem.unwrap();
469     ashmem.close_ashmem();
470 
471     assert!(!ashmem.map_read_write_ashmem());
472 }
473 
474 
475 #[test]
test_ashmem_invalid_003()476 fn test_ashmem_invalid_003()
477 {
478     let ashmem = unsafe { ashmem::create_ashmem_instance(MEMORY_NAME, MEMORY_SIZE) };
479     assert!(ashmem.is_some());
480 
481     let ashmem = ashmem.unwrap();
482 
483     assert!(ashmem.map_read_write_ashmem());
484 
485     ashmem.close_ashmem();
486     let c_content = CString::new(MEMORY_CONTENT).expect("CString::new Failed!");
487     unsafe {
488         assert!(!ashmem.write_to_ashmem(c_content.as_ptr(), MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
489     }
490 
491     let readout_ptr: *const c_char;
492     unsafe {
493         readout_ptr = ashmem.read_from_ashmem(MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0);
494         assert!(readout_ptr.is_null());
495     }
496 }
497 
498 #[test]
test_ashmem_invalid_004()499 fn test_ashmem_invalid_004()
500 {
501     let ashmem = unsafe { ashmem::create_ashmem_instance(MEMORY_NAME, MEMORY_SIZE) };
502     assert!(ashmem.is_some());
503 
504     let ashmem = ashmem.unwrap();
505 
506     assert!(ashmem.map_read_write_ashmem());
507 
508     ashmem.unmap_ashmem();
509     let c_content = CString::new(MEMORY_CONTENT).expect("CString::new Failed!");
510     unsafe {
511         assert!(!ashmem.write_to_ashmem(c_content.as_ptr(), MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
512     }
513 
514     let readout_ptr: *const c_char;
515     unsafe {
516         readout_ptr = ashmem.read_from_ashmem(MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0);
517         assert!(readout_ptr.is_null());
518     }
519 
520     ashmem.close_ashmem();
521 }
522 
523 #[test]
test_ashmem_invalid_005()524 fn test_ashmem_invalid_005()
525 {
526     let ashmem = unsafe { ashmem::create_ashmem_instance(MEMORY_NAME, MEMORY_SIZE) };
527     assert!(ashmem.is_some());
528 
529     let ashmem = ashmem.unwrap();
530 
531     assert!(ashmem.set_protection(ashmem::PROT_WRITE));
532     assert!(!ashmem.set_protection(ashmem::PROT_READ));
533     assert!(!ashmem.set_protection(ashmem::PROT_READ | ashmem::PROT_WRITE));
534     assert!(ashmem.set_protection(ashmem::PROT_NONE));
535     assert!(!ashmem.set_protection(ashmem::PROT_READ));
536     assert!(!ashmem.set_protection(ashmem::PROT_WRITE));
537 
538     ashmem.close_ashmem();
539 }
540 
541 #[test]
test_ashmem_invalid_006()542 fn test_ashmem_invalid_006()
543 {
544     let ashmem = unsafe { ashmem::create_ashmem_instance(MEMORY_NAME, MEMORY_SIZE) };
545     assert!(ashmem.is_some());
546 
547     let ashmem = ashmem.unwrap();
548 
549     assert!(ashmem.map_read_write_ashmem());
550     let c_content = CString::new(MEMORY_CONTENT).expect("CString::new Failed!");
551     unsafe {
552         assert!(!ashmem.write_to_ashmem(ptr::null(), MEMORY_CONTENT.len().try_into().expect("Invalid content size."), 0));
553         assert!(!ashmem.write_to_ashmem(c_content.as_ptr(), MEMORY_CONTENT.len().try_into().expect("Invalid content size."), MEMORY_SIZE));
554         assert!(!ashmem.write_to_ashmem(c_content.as_ptr(), MEMORY_CONTENT.len().try_into().expect("Invalid content size."), MEMORY_SIZE + 1));
555         assert!(!ashmem.write_to_ashmem(c_content.as_ptr(), MEMORY_CONTENT.len().try_into().expect("Invalid content size."), -1));
556         assert!(!ashmem.write_to_ashmem(c_content.as_ptr(), MEMORY_SIZE + 1, 0));
557         assert!(!ashmem.write_to_ashmem(c_content.as_ptr(), -1, 0));
558     }
559 
560     ashmem.unmap_ashmem();
561     ashmem.close_ashmem();
562 }