ci: Add Miri tests including big endian

https://github.com/rust-lang/miri#cross-interpretation-running-for-different-targets

Author: sharksforarms

.github/workflows/main.yml

@@ -33,6 +33,30 @@ jobs:
           command: test
           args: --all
 
+  test_miri:
+    name: Miri Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          override: true
+      - run: rustup component add miri
+      - run: cargo miri test
+
+  test_miri_big_endian:
+    name: Miri Test Big Endian
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          override: true
+      - run: rustup target add mips64-unknown-linux-gnuabi64 && rustup component add miri
+      - run: cargo miri test --target mips64-unknown-linux-gnuabi64
+
   examples:
     name: Examples
     runs-on: ubuntu-latest

src/impls/boxed.rs

@@ -69,12 +69,13 @@ where
 mod tests {
     use super::*;
     use crate::ctx::*;
+    use crate::native_endian;
     use rstest::rstest;
 
     #[rstest(input, expected, expected_rest,
         case(
             &[0xEF, 0xBE],
-            Box::new(0xBEEF),
+            Box::new(native_endian!(0xBEEF)),
             bits![Msb0, u8;]
         ),
     )]

src/impls/cow.rs

@@ -34,12 +34,13 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::native_endian;
     use rstest::rstest;
 
     #[rstest(input, expected, expected_rest,
         case(
             &[0xEF, 0xBE],
-            Cow::Owned(0xBEEF),
+            Cow::Owned(native_endian!(0xBEEF)),
             bits![Msb0, u8;]
         ),
     )]

src/impls/primitive.rs

@@ -223,6 +223,7 @@ ImplDekuTraits!(f64);
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::native_endian;
     use rstest::rstest;
 
     static ENDIAN: Endian = Endian::new();
@@ -244,13 +245,23 @@ mod tests {
     }
 
     TestPrimitive!(test_u8, u8, vec![0xAAu8], 0xAAu8);
-    TestPrimitive!(test_u16, u16, vec![0xABu8, 0xCD], 0xCDAB);
-    TestPrimitive!(test_u32, u32, vec![0xABu8, 0xCD, 0xEF, 0xBE], 0xBEEFCDAB);
+    TestPrimitive!(
+        test_u16,
+        u16,
+        vec![0xABu8, 0xCD],
+        native_endian!(0xCDAB_u16)
+    );
+    TestPrimitive!(
+        test_u32,
+        u32,
+        vec![0xABu8, 0xCD, 0xEF, 0xBE],
+        native_endian!(0xBEEFCDAB_u32)
+    );
     TestPrimitive!(
         test_u64,
         u64,
         vec![0xABu8, 0xCD, 0xEF, 0xBE, 0xAB, 0xCD, 0xFE, 0xC0],
-        0xC0FECDABBEEFCDAB
+        native_endian!(0xC0FECDABBEEFCDAB_u64)
     );
     TestPrimitive!(
         test_u128,
@@ -259,26 +270,31 @@ mod tests {
             0xABu8, 0xCD, 0xEF, 0xBE, 0xAB, 0xCD, 0xFE, 0xC0, 0xAB, 0xCD, 0xEF, 0xBE, 0xAB, 0xCD,
             0xFE, 0xC0
         ],
-        0xC0FECDABBEEFCDABC0FECDABBEEFCDAB
+        native_endian!(0xC0FECDABBEEFCDABC0FECDABBEEFCDAB_u128)
     );
     TestPrimitive!(
         test_usize,
         usize,
         vec![0xABu8, 0xCD, 0xEF, 0xBE, 0xAB, 0xCD, 0xFE, 0xC0],
         if core::mem::size_of::<usize>() == 8 {
-            0xC0FECDABBEEFCDAB
+            native_endian!(0xC0FECDABBEEFCDAB_usize)
         } else {
-            0xBEEFCDAB
+            native_endian!(0xBEEFCDAB_usize)
         }
     );
     TestPrimitive!(test_i8, i8, vec![0xFBu8], -5);
-    TestPrimitive!(test_i16, i16, vec![0xFDu8, 0xFE], -259);
-    TestPrimitive!(test_i32, i32, vec![0x02u8, 0x3F, 0x01, 0xEF], -0x10FEC0FE);
+    TestPrimitive!(test_i16, i16, vec![0xFDu8, 0xFE], native_endian!(-259_i16));
+    TestPrimitive!(
+        test_i32,
+        i32,
+        vec![0x02u8, 0x3F, 0x01, 0xEF],
+        native_endian!(-0x10FEC0FE_i32)
+    );
     TestPrimitive!(
         test_i64,
         i64,
         vec![0x02u8, 0x3F, 0x01, 0xEF, 0x01, 0x3F, 0x01, 0xEF],
-        -0x10FEC0FE10FEC0FE
+        native_endian!(-0x10FEC0FE10FEC0FE_i64)
     );
     TestPrimitive!(
         test_i128,
@@ -287,24 +303,29 @@ mod tests {
             0x02u8, 0x3F, 0x01, 0xEF, 0x01, 0x3F, 0x01, 0xEF, 0x01, 0x3F, 0x01, 0xEF, 0x01, 0x3F,
             0x01, 0xEF
         ],
-        -0x10FEC0FE10FEC0FE10FEC0FE10FEC0FE
+        native_endian!(-0x10FEC0FE10FEC0FE10FEC0FE10FEC0FE_i128)
     );
     TestPrimitive!(
         test_isize,
         isize,
         vec![0x02u8, 0x3F, 0x01, 0xEF, 0x01, 0x3F, 0x01, 0xEF],
         if core::mem::size_of::<isize>() == 8 {
-            -0x10FEC0FE10FEC0FE
+            native_endian!(-0x10FEC0FE10FEC0FE_isize)
         } else {
-            -0x10FEC0FE
+            native_endian!(-0x10FEC0FE_isize)
         }
     );
-    TestPrimitive!(test_f32, f32, vec![0xA6u8, 0x9B, 0xC4, 0xBB], -0.006);
+    TestPrimitive!(
+        test_f32,
+        f32,
+        vec![0xA6u8, 0x9B, 0xC4, 0xBB],
+        native_endian!(-0.006_f32)
+    );
     TestPrimitive!(
         test_f64,
         f64,
         vec![0xFAu8, 0x7E, 0x6A, 0xBC, 0x74, 0x93, 0x78, 0xBF],
-        -0.006
+        native_endian!(-0.006_f64)
     );
 
     #[rstest(input, endian, bit_size, expected, expected_rest,

src/impls/tuple.rs

@@ -83,15 +83,16 @@ ImplDekuTupleTraits! { A, B, C, D, E, F, G, H, I, J, K, }
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::native_endian;
     use core::fmt::Debug;
 
     use rstest::rstest;
 
     #[rstest(input, expected, expected_rest,
-        case::length_1([0xef, 0xbe, 0xad, 0xde].as_ref(), (0xdeadbeefu32,), bits![Msb0, u8;]),
-        case::length_2([1, 0x24, 0x98, 0x82, 0].as_ref(), (true, 0x829824u32), bits![Msb0, u8;]),
+        case::length_1([0xef, 0xbe, 0xad, 0xde].as_ref(), (native_endian!(0xdeadbeef_u32),), bits![Msb0, u8;]),
+        case::length_2([1, 0x24, 0x98, 0x82, 0].as_ref(), (true, native_endian!(0x829824_u32)), bits![Msb0, u8;]),
         case::length_11([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10].as_ref(), (0u8, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8, 10u8), bits![Msb0, u8;]),
-        case::extra_rest([1, 0x24, 0x98, 0x82, 0, 0].as_ref(), (true, 0x829824u32), bits![Msb0, u8; 0, 0, 0, 0, 0, 0, 0, 0]),
+        case::extra_rest([1, 0x24, 0x98, 0x82, 0, 0].as_ref(), (true, native_endian!(0x829824_u32)), bits![Msb0, u8; 0, 0, 0, 0, 0, 0, 0, 0]),
     )]
     fn test_tuple_read<'a, T>(input: &'a [u8], expected: T, expected_rest: &BitSlice<Msb0, u8>)
     where
@@ -104,8 +105,8 @@ mod tests {
     }
 
     #[rstest(input, expected,
-        case::length_1((0xdeadbeefu32,), vec![0xef, 0xbe, 0xad, 0xde]),
-        case::length_2((true, 0x829824u32), vec![1, 0x24, 0x98, 0x82, 0]),
+        case::length_1((native_endian!(0xdeadbeef_u32),), vec![0xef, 0xbe, 0xad, 0xde]),
+        case::length_2((true, native_endian!(0x829824_u32)), vec![1, 0x24, 0x98, 0x82, 0]),
         case::length_11((0u8, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8, 10u8), vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
     )]
     fn test_tuple_write<T>(input: T, expected: Vec<u8>)

src/lib.rs

@@ -363,3 +363,31 @@ where
         Ok(())
     }
 }
+
+#[cfg(test)]
+pub mod test_utils {
+    /// Converts value to native endian
+    ///
+    /// Input is assumed to be little endian and the result is swapped if
+    /// target is big endian.
+    #[macro_export]
+    macro_rules! native_endian {
+        ($num:expr) => {{
+            #[cfg(target_endian = "little")]
+            let res = $num;
+
+            #[cfg(target_endian = "big")]
+            let res = {
+                use bitvec::macros::internal::funty::IsNumber;
+
+                let mut val = $num;
+                let bytes = val.to_le_bytes();
+                val = <_>::from_be_bytes(bytes);
+
+                val
+            };
+
+            res
+        }};
+    }
+}

tests/test_compile/mod.rs

@@ -1,5 +1,6 @@
 #[test]
 #[cfg(not(tarpaulin))]
+#[cfg_attr(miri, ignore)]
 fn test_compile() {
     let t = trybuild::TestCases::new();
     t.compile_fail("tests/test_compile/cases/*.rs");