enable more tests

src/basic.rs

@@ -297,43 +297,80 @@ mod tests {
         assert_eq!(parse_ascii(b"123456", 6).unwrap().1, b"123456");
     }
 
-/*
+    #[test]
     fn test_pack_bitarray() {
-        packed = pack_bitarray(321)
-        assert_eq!(len(packed), 2);
-        assert_eq!(packed, struct.pack('>H', 321));
+        use crate::basic::pack_bitarray;
+        let mut buf = [10; 3];
+        let mut bools = [false; 16];
+        bools[1] = true;
+        bools[2] = true;
+        bools[11] = true;
+
+        pack_bitarray(&mut buf, &bools);
+        assert_eq!(buf[0], 0b0110_0000);
+        assert_eq!(buf[1], 0b0001_0000);
+        assert_eq!(buf[2], 10);
     }
 
+    #[test]
     fn test_pack_int2() {
-        packed = pack_int2((3, 2, 1))
-        assert(len(packed) == 3*2)
-        assert(packed == struct.pack('>3h', 3, 2, 1))
-        assert(pack_int2([-3, 2, -1]) == struct.pack('>3h', -3, 2, -1))
+        use crate::basic::pack_int2;
+        let mut buf = [10; 3 * 2];
+        pack_int2(&mut buf, -3);
+        pack_int2(&mut buf[2..], 2);
+        pack_int2(&mut buf[4..], -1);
+        assert_eq!(buf[0..2], [0xFF, 0xFD]);
+        assert_eq!(buf[2..4], [0x00, 0x02]);
+        assert_eq!(buf[4..6], [0xFF, 0xFF]);
     }
 
+    #[test]
     fn test_pack_int4() {
-        packed = pack_int4((3, 2, 1))
-        assert(len(packed) == 3*4)
-        assert(packed == struct.pack('>3l', 3, 2, 1))
-        assert(pack_int4([-3, 2, -1]) == struct.pack('>3l', -3, 2, -1))
+        use crate::basic::pack_int4;
+        let mut buf = [10; 3 * 4];
+        pack_int4(&mut buf, -3);
+        pack_int4(&mut buf[4..], 2);
+        pack_int4(&mut buf[8..], -1);
+        assert_eq!(buf[0..4], [0xFF, 0xFF, 0xFF, 0xFD]);
+        assert_eq!(buf[4..8], [0x00, 0x00, 0x00, 0x02]);
+        assert_eq!(buf[8..12], [0xFF, 0xFF, 0xFF, 0xFF]);
     }
 
+    #[test]
     fn test_encode_real8() {
-        assert(encode_real8(numpy.array([0.0])) == 0)
-        arr = numpy.array((1.0, -2.0, 1e-9, 1e-3, 1e-12))
-        assert_array_equal(decode_real8(encode_real8(arr)), arr)
+        use crate::basic::{encode_real8, decode_real8};
+        const REALS: [f64; 5] = [1.0, -2.0, 1e-9, 1e-3, 1e-12];
+        for vv in REALS {
+            print!("{vv}\n");
+            assert!((decode_real8(encode_real8(vv)) - vv).abs() < f64::EPSILON);
+        }
     }
 
+    #[test]
     fn test_pack_real8() {
-        reals = (0, 1, -1, 0.5, 1e-9, 1e-3, 1e-12)
-        packed = pack_real8(reals)
-        assert(len(packed) == len(reals) * 8)
-        assert_array_equal(parse_real8(packed), reals)
+        use crate::basic::{pack_real8, parse_real8};
+        const COUNT: usize = 7;
+        const REALS: [f64; COUNT] = [0.0, 1.0, -1.0, 0.5, 1e-9, 1e-3, 1e-12];
+        let mut buf = [10; 8 * COUNT];
+        for (ii, &vv) in REALS.iter().enumerate() {
+            pack_real8(&mut buf[ii * 8..], vv);
+        }
+        for (ii, &vv) in REALS.iter().enumerate() {
+            print!("{vv}\n");
+            let parsed_val = parse_real8(&buf[ii * 8..]).unwrap().1;
+            assert!((parsed_val - vv).abs() < f64::EPSILON);
+        }
     }
 
+    #[test]
     fn test_pack_ascii() {
-        assert(pack_ascii(b'4321') == b'4321')
-        assert(pack_ascii(b'321') == b'321\0')
+        use crate::basic::pack_ascii;
+        let mut buf = [10; 12];
+        pack_ascii(&mut buf[0..], "4321".as_bytes());
+        pack_ascii(&mut buf[6..], "321".as_bytes());
+        assert_eq!(&buf[0..4], "4321".as_bytes());
+        assert_eq!(&buf[4..6], [10, 10]);
+        assert_eq!(&buf[6..9], "321".as_bytes());
+        assert_eq!(&buf[9..], [0, 10, 10]);
     }
-*/
 }