Fix little-endian-specific endian.h tests

The test code assumed a little-endian host, changed this to be endianness-agnostic.

tests/endian.c

@@ -4,6 +4,18 @@
 
 #include "test_helpers.h"
 
+void to_be(uintmax_t in, uint8_t *out, size_t size) {
+    for (size_t i = 0; i < size; i++) {
+        out[i] = (in >> 8*(size - 1 - i)) & 0xff;
+    }
+}
+
+void to_le(uintmax_t in, uint8_t *out, size_t size) {
+    for (size_t i = 0; i < size; i++) {
+        out[i] = (in >> 8*i) & 0xff;
+    }
+}
+
 int main() {
     uint16_t zero_u16 = 0;
     assert(be16toh(zero_u16) == zero_u16);
@@ -11,12 +23,14 @@ int main() {
     assert(htole16(zero_u16) == zero_u16);
     assert(le16toh(zero_u16) == zero_u16);
 
-    uint16_t value_be_u16 = 0x0123;
-    uint16_t value_le_u16 = 0x2301;
-    assert(be16toh(value_be_u16) == value_le_u16);
-    assert(htobe16(value_le_u16) == value_be_u16);
-    assert(htole16(value_le_u16) == value_le_u16);
-    assert(le16toh(value_le_u16) == value_le_u16);
+    uint16_t u16_ne = 0x0123;
+    uint16_t u16_be, u16_le;
+    to_be(u16_ne, (uint8_t *)&u16_be, sizeof(uint16_t));
+    to_le(u16_ne, (uint8_t *)&u16_le, sizeof(uint16_t));
+    assert(be16toh(u16_be) == u16_ne);
+    assert(htobe16(u16_ne) == u16_be);
+    assert(htole16(u16_ne) == u16_le);
+    assert(le16toh(u16_le) == u16_ne);
 
     uint32_t zero_u32 = 0;
     assert(be32toh(zero_u32) == zero_u32);
@@ -24,12 +38,14 @@ int main() {
     assert(htole32(zero_u32) == zero_u32);
     assert(le32toh(zero_u32) == zero_u32);
 
-    uint32_t value_be_u32 = 0x01234567;
-    uint32_t value_le_u32 = 0x67452301;
-    assert(be32toh(value_be_u32) == value_le_u32);
-    assert(htobe32(value_le_u32) == value_be_u32);
-    assert(htole32(value_le_u32) == value_le_u32);
-    assert(le32toh(value_le_u32) == value_le_u32);
+    uint32_t u32_ne = 0x01234567;
+    uint32_t u32_be, u32_le;
+    to_be(u32_ne, (uint8_t *)&u32_be, sizeof(uint32_t));
+    to_le(u32_ne, (uint8_t *)&u32_le, sizeof(uint32_t));
+    assert(be32toh(u32_be) == u32_ne);
+    assert(htobe32(u32_ne) == u32_be);
+    assert(htole32(u32_ne) == u32_le);
+    assert(le32toh(u32_le) == u32_ne);
 
     uint64_t zero_u64 = 0;
     assert(be64toh(zero_u64) == zero_u64);
@@ -37,10 +53,12 @@ int main() {
     assert(htole64(zero_u64) == zero_u64);
     assert(le64toh(zero_u64) == zero_u64);
 
-    uint64_t value_be_u64 = 0x0123456789ABCDEF;
-    uint64_t value_le_u64 = 0xEFCDAB8967452301;
-    assert(be64toh(value_be_u64) == value_le_u64);
-    assert(htobe64(value_le_u64) == value_be_u64);
-    assert(htole64(value_le_u64) == value_le_u64);
-    assert(le64toh(value_le_u64) == value_le_u64);
+    uint64_t u64_ne = 0x0123456789ABCDEF;
+    uint64_t u64_be, u64_le;
+    to_be(u64_ne, (uint8_t *)&u64_be, sizeof(uint64_t));
+    to_le(u64_ne, (uint8_t *)&u64_le, sizeof(uint64_t));
+    assert(be64toh(u64_be) == u64_ne);
+    assert(htobe64(u64_ne) == u64_be);
+    assert(htole64(u64_ne) == u64_le);
+    assert(le64toh(u64_le) == u64_ne);
 }