Respect endianness correctly in CheckEnums test suite

The endianness can change the test expectation for the enum check.
This change is correcting these expectations and adds separate tests
for big endian targets with the correct expectations.

Author: 1c3t3a

tests/ui/mir/enum/convert_non_enum_break_big_endian.rs

@@ -0,0 +1,22 @@
+//@ run-pass
+//@ compile-flags: -C debug-assertions
+// This test depends on the endianess and has a different behavior on
+// little endian.
+//@ ignore-endian-little
+
+#[allow(dead_code)]
+#[repr(u32)]
+enum Foo {
+    A,
+    B,
+}
+
+#[allow(dead_code)]
+struct Bar {
+    a: u16,
+    b: u16,
+}
+
+fn main() {
+    let _val: Foo = unsafe { std::mem::transmute::<_, Foo>(Bar { a: 0, b: 1 }) };
+}

tests/ui/mir/enum/convert_non_enum_break.rs renamed to tests/ui/mir/enum/convert_non_enum_break_little_endian.rs

@@ -1,5 +1,8 @@
 //@ run-fail
 //@ compile-flags: -C debug-assertions
+// This test depends on the endianess and has a different behavior on
+// big endian.
+//@ ignore-endian-big
 //@ error-pattern: trying to construct an enum from an invalid value 0x10000
 
 #[allow(dead_code)]

tests/ui/mir/enum/convert_non_enum_ok_big_endian.rs

@@ -0,0 +1,23 @@
+//@ run-fail
+//@ compile-flags: -C debug-assertions
+// This test depends on the endianess and has a different behavior on
+// little endian.
+//@ ignore-endian-little
+//@ error-pattern: trying to construct an enum from an invalid value
+
+#[allow(dead_code)]
+#[repr(u32)]
+enum Foo {
+    A,
+    B,
+}
+
+#[allow(dead_code)]
+struct Bar {
+    a: u16,
+    b: u16,
+}
+
+fn main() {
+    let _val: Foo = unsafe { std::mem::transmute::<_, Foo>(Bar { a: 1, b: 0 }) };
+}

tests/ui/mir/enum/convert_non_enum_ok.rs renamed to tests/ui/mir/enum/convert_non_enum_ok_little_endian.rs

@@ -1,5 +1,8 @@
 //@ run-pass
 //@ compile-flags: -C debug-assertions
+// This test depends on the endianess and has a different behavior on
+// big endian.
+//@ ignore-endian-big
 
 #[allow(dead_code)]
 #[repr(u32)]

tests/ui/mir/enum/niche_option_tuple_break_big_endian.rs

@@ -0,0 +1,22 @@
+//@ run-pass
+//@ compile-flags: -C debug-assertions
+// This test depends on the endianess and has a different behavior on
+// big endian.
+//@ ignore-endian-little
+
+#[allow(dead_code)]
+enum Foo {
+    A,
+    B,
+}
+
+#[allow(dead_code)]
+struct Bar {
+    a: usize,
+    b: usize,
+}
+
+fn main() {
+    let _val: Option<(usize, Foo)> =
+        unsafe { std::mem::transmute::<_, Option<(usize, Foo)>>(Bar { a: 3, b: 3 }) };
+}

tests/ui/mir/enum/niche_option_tuple_break.rs renamed to tests/ui/mir/enum/niche_option_tuple_break_little_endian.rs

@@ -1,5 +1,8 @@
 //@ run-fail
 //@ compile-flags: -C debug-assertions
+// This test depends on the endianess and has a different behavior on
+// big endian.
+//@ ignore-endian-big
 //@ error-pattern: trying to construct an enum from an invalid value 0x3
 
 #[allow(dead_code)]

tests/ui/mir/enum/with_niche_int_break_big_endian.rs

@@ -0,0 +1,23 @@
+//@ run-pass
+//@ compile-flags: -C debug-assertions
+// This test depends on the endianess and has a different behavior on
+// little endian.
+//@ ignore-endian-little
+
+#[allow(dead_code)]
+#[repr(u16)]
+enum Mix {
+    A,
+    B(u16),
+}
+
+#[allow(dead_code)]
+enum Nested {
+    C(Mix),
+    D,
+    E,
+}
+
+fn main() {
+    let _val: Nested = unsafe { std::mem::transmute::<u32, Nested>(4) };
+}

tests/ui/mir/enum/with_niche_int_break.rs renamed to tests/ui/mir/enum/with_niche_int_break_little_endian.rs

@@ -1,6 +1,9 @@
 //@ run-fail
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: trying to construct an enum from an invalid value 0x4
+// This test depends on the endianess and has a different behavior on
+// big endian.
+//@ ignore-endian-big
 
 #[allow(dead_code)]
 #[repr(u16)]