init

tests/memcmp.rs

@@ -0,0 +1,16 @@
+
+
+#[test]
+pub fn test_memcmp() {
+
+    let buffer1: [u8;8] = [0, 1, 2, 3, 4, 5, 6, 7];
+    let buffer2: [u8;8] = [0, 1, 2, 3, 4, 5, 6, 7];
+    let buffer3: [u8;8] = [0, 1, 2, 3, 4, 5, 6, 6];
+    let buffer4: [u8;8] = [0, 1, 2, 3, 4, 5, 6, 8];
+
+    assert_eq!( 0, unsafe {xrt::memcmp(buffer1.as_ptr(), buffer2.as_ptr(), 8)});
+    assert_eq!( 1, unsafe {xrt::memcmp(buffer1.as_ptr(), buffer3.as_ptr(), 8)}); // <0 - 7 has a greater value than 7
+    assert_eq!(-1, unsafe {xrt::memcmp(buffer1.as_ptr(), buffer4.as_ptr(), 8)}); // >0 - 7 has a lower value than 8
+
+}
+

tests/memcpy.rs

@@ -0,0 +1,33 @@
+
+
+
+
+
+
+
+
+
+
+#[test]
+pub fn test_memcpy() {
+    let mut buffer1: Vec<u8> = Vec::with_capacity(0x1000);
+    let mut buffer2: Vec<u8> = Vec::with_capacity(0x1000);
+
+
+    // fill buffer1 with _random_ bytes
+    let mut seed = 0x696969u64;
+    for _ in 0..0x200 {
+        buffer1.extend(seed.to_le_bytes());
+        seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1)
+    }
+
+    // set buffer2's length to its capacity
+    unsafe { buffer2.set_len(0x1000); }
+
+    // copy buffer1 to buffer2
+    unsafe { xrt::memcpy(buffer2.as_mut_ptr(), buffer1.as_ptr(), 0x1000) };
+
+    assert_eq!(buffer1, buffer2);
+
+}
+

tests/memmove.rs

@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+#[test]
+pub fn test_memmove() {
+    let mut buffer: [u8;8] = [0, 1, 2, 3, 4, 5, 6, 7];
+    let expected:   [u8;8] = [4, 5, 6, 7, 4, 5, 6, 7];
+    unsafe { xrt::memmove(buffer.as_mut_ptr(), buffer[4..].as_ptr(), 4); }
+    assert_eq!(buffer, expected);
+
+    let mut buffer: [u8;8] = [0, 1, 2, 3, 4, 5, 6, 7];
+    let expected:   [u8;8] = [0, 0, 1, 2, 3, 4, 5, 6];
+    unsafe { xrt::memmove(buffer[1..].as_mut_ptr(), buffer.as_ptr(), 7); }
+    assert_eq!(buffer, expected);
+}
+

tests/memset.rs

@@ -0,0 +1,23 @@
+
+
+#[test]
+pub fn test_memset() {
+
+    let mut buffer1 = [1;10];
+    let mut buffer2 = [1;12];
+    let mut buffer3 = [1;2];
+    let mut buffer4 = [1;8];
+
+    unsafe { xrt::memset(buffer1.as_mut_ptr(), 1, buffer1.len()) };
+    unsafe { xrt::memset(buffer3.as_mut_ptr(), 3, buffer3.len()) };
+    unsafe { xrt::memset(buffer4.as_mut_ptr(), 4, buffer4.len()) };
+    unsafe { xrt::memset(buffer3.as_mut_ptr(), 3, buffer3.len()) };
+    unsafe { xrt::memset(buffer2.as_mut_ptr(), 2, buffer2.len()) };
+
+    assert_eq!(None, buffer1.iter().filter(|&&a|a!=1).next());
+    assert_eq!(None, buffer2.iter().filter(|&&a|a!=2).next());
+    assert_eq!(None, buffer3.iter().filter(|&&a|a!=3).next());
+    assert_eq!(None, buffer4.iter().filter(|&&a|a!=4).next());
+
+}
+

tests/strlen.rs

@@ -0,0 +1,11 @@
+
+
+#[test]
+pub fn test_strlen() {
+    let mut buffer: Vec<u8> = "a".repeat(1000).into();
+    buffer.push(0);
+    assert_eq!(unsafe { xrt::strlen(buffer.as_ptr()) }, 1000);
+    assert_eq!(unsafe { xrt::strlen((&buffer[1..]).as_ptr()) }, 999);
+    assert_eq!(unsafe { xrt::strlen((&buffer[8..]).as_ptr()) }, 992);
+}
+