Wrap read and write in helper function

Author: tiif

tests/pass-dep/libc/libc-eventfd.rs

@@ -10,21 +10,29 @@ fn main() {
     test_race();
 }
 
+fn read_bytes<const N: usize>(fd: i32, buf: &mut [u8; N]) -> i32 {
+    let res: i32 =
+        unsafe { libc::read(fd, buf.as_mut_ptr().cast(), N as libc::size_t).try_into().unwrap() };
+    return res;
+}
+
+fn write_bytes<const N: usize>(fd: i32, data: [u8; N]) -> i32 {
+    let res: i32 =
+        unsafe { libc::write(fd, data.as_ptr() as *const libc::c_void, N).try_into().unwrap() };
+    return res;
+}
+
 fn test_read_write() {
     let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
     let fd = unsafe { libc::eventfd(0, flags) };
     let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
     // Write 1 to the counter.
-    let res: i64 = unsafe {
-        libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
-    };
+    let res = write_bytes(fd, sized_8_data);
     assert_eq!(res, 8);
 
     // Read 1 from the counter.
     let mut buf: [u8; 8] = [0; 8];
-    let res: i32 = unsafe {
-        libc::read(fd, buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = read_bytes(fd, &mut buf);
     // Read returns number of bytes has been read, which is always 8.
     assert_eq!(res, 8);
     // Check the value of counter read.
@@ -34,51 +42,40 @@ fn test_read_write() {
     // After read, the counter is currently 0, read counter 0 should fail with return
     // value -1.
     let mut buf: [u8; 8] = [0; 8];
-    let res: i32 = unsafe {
-        libc::read(fd, buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = read_bytes(fd, &mut buf);
     assert_eq!(res, -1);
 
     // Write with supplied buffer that > 8 bytes should be allowed.
     let sized_9_data: [u8; 9];
     if cfg!(target_endian = "big") {
-        // Adjust the data based on the endianess of host system.
+        // Adjust the data based on the endianness of host system.
         sized_9_data = [0, 0, 0, 0, 0, 0, 0, 1, 0];
     } else {
         sized_9_data = [1, 0, 0, 0, 0, 0, 0, 0, 0];
     }
-    let res: i64 = unsafe {
-        libc::write(fd, sized_9_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
-    };
+    let res = write_bytes(fd, sized_9_data);
     assert_eq!(res, 8);
 
     // Read with supplied buffer that < 8 bytes should fail with return
     // value -1.
     let mut buf: [u8; 7] = [1; 7];
-    let res: i32 = unsafe {
-        libc::read(fd, buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = read_bytes(fd, &mut buf);
     assert_eq!(res, -1);
 
     // Write with supplied buffer that < 8 bytes should fail with return
     // value -1.
-    let res: i64 = unsafe {
-        libc::write(fd, sized_8_data[0..7].as_ptr() as *const libc::c_void, 7).try_into().unwrap()
-    };
+    let size_7_data: [u8; 7] = [1; 7];
+    let res = write_bytes(fd, size_7_data);
     assert_eq!(res, -1);
 
     // Read with supplied buffer > 8 bytes should be allowed.
     let mut buf: [u8; 9] = [1; 9];
-    let res: i32 = unsafe {
-        libc::read(fd, buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = read_bytes(fd, &mut buf);
     assert_eq!(res, 8);
 
     // Write u64::MAX should fail.
     let u64_max_bytes: [u8; 8] = [255; 8];
-    let res: i64 = unsafe {
-        libc::write(fd, u64_max_bytes.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
-    };
+    let res = write_bytes(fd, u64_max_bytes);
     assert_eq!(res, -1);
 }
 
@@ -88,9 +85,7 @@ fn test_race() {
     let fd = unsafe { libc::eventfd(0, flags) };
     let thread1 = thread::spawn(move || {
         let mut buf: [u8; 8] = [0; 8];
-        let res: i32 = unsafe {
-            libc::read(fd, buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
-        };
+        let res = read_bytes(fd, &mut buf);
         // read returns number of bytes has been read, which is always 8.
         assert_eq!(res, 8);
         let counter = u64::from_ne_bytes(buf);
@@ -99,8 +94,7 @@ fn test_race() {
     });
     unsafe { VAL = 1 };
     let data: [u8; 8] = 1_u64.to_ne_bytes();
-    let res: i64 =
-        unsafe { libc::write(fd, data.as_ptr() as *const libc::c_void, 8).try_into().unwrap() };
+    let res = write_bytes(fd, data);
     // write returns number of bytes written, which is always 8.
     assert_eq!(res, 8);
     thread::yield_now();