Fix service file to match installed elogind binary location

[elogind.git] / src / test / test-unaligned.c

diff --git a/src/test/test-unaligned.c b/src/test/test-unaligned.c
index 52693cd325e1b712c71ebd4d7cdb1c7a2d0b4206..4f643989432a91a0d10976649667b0c07f776359 100644 (file)
--- a/src/test/test-unaligned.c
+++ b/src/test/test-unaligned.c
@@ -17,6 +17,7 @@
   along with systemd; If not, see <http://www.gnu.org/licenses/>.
 ***/
 
+#include "sparse-endian.h"
 #include "unaligned.h"
 #include "util.h"
 
@@ -25,68 +26,164 @@ static uint8_t data[] = {
         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 };
 
-int main(int argc, const char *argv[]) {
+static void test_be(void) {
+        uint8_t scratch[16];
+
+        assert_se(unaligned_read_be16(&data[0]) == 0x0001);
+        assert_se(unaligned_read_be16(&data[1]) == 0x0102);
+
+        assert_se(unaligned_read_be32(&data[0]) == 0x00010203);
+        assert_se(unaligned_read_be32(&data[1]) == 0x01020304);
+        assert_se(unaligned_read_be32(&data[2]) == 0x02030405);
+        assert_se(unaligned_read_be32(&data[3]) == 0x03040506);
+
+        assert_se(unaligned_read_be64(&data[0]) == 0x0001020304050607);
+        assert_se(unaligned_read_be64(&data[1]) == 0x0102030405060708);
+        assert_se(unaligned_read_be64(&data[2]) == 0x0203040506070809);
+        assert_se(unaligned_read_be64(&data[3]) == 0x030405060708090a);
+        assert_se(unaligned_read_be64(&data[4]) == 0x0405060708090a0b);
+        assert_se(unaligned_read_be64(&data[5]) == 0x05060708090a0b0c);
+        assert_se(unaligned_read_be64(&data[6]) == 0x060708090a0b0c0d);
+        assert_se(unaligned_read_be64(&data[7]) == 0x0708090a0b0c0d0e);
+
+        zero(scratch);
+        unaligned_write_be16(&scratch[0], 0x0001);
+        assert_se(memcmp(&scratch[0], &data[0], sizeof(uint16_t)) == 0);
+        zero(scratch);
+        unaligned_write_be16(&scratch[1], 0x0102);
+        assert_se(memcmp(&scratch[1], &data[1], sizeof(uint16_t)) == 0);
+
+        zero(scratch);
+        unaligned_write_be32(&scratch[0], 0x00010203);
+        assert_se(memcmp(&scratch[0], &data[0], sizeof(uint32_t)) == 0);
+        zero(scratch);
+        unaligned_write_be32(&scratch[1], 0x01020304);
+        assert_se(memcmp(&scratch[1], &data[1], sizeof(uint32_t)) == 0);
+        zero(scratch);
+        unaligned_write_be32(&scratch[2], 0x02030405);
+        assert_se(memcmp(&scratch[2], &data[2], sizeof(uint32_t)) == 0);
+        zero(scratch);
+        unaligned_write_be32(&scratch[3], 0x03040506);
+        assert_se(memcmp(&scratch[3], &data[3], sizeof(uint32_t)) == 0);
+
+        zero(scratch);
+        unaligned_write_be64(&scratch[0], 0x0001020304050607);
+        assert_se(memcmp(&scratch[0], &data[0], sizeof(uint64_t)) == 0);
+        zero(scratch);
+        unaligned_write_be64(&scratch[1], 0x0102030405060708);
+        assert_se(memcmp(&scratch[1], &data[1], sizeof(uint64_t)) == 0);
+        zero(scratch);
+        unaligned_write_be64(&scratch[2], 0x0203040506070809);
+        assert_se(memcmp(&scratch[2], &data[2], sizeof(uint64_t)) == 0);
+        zero(scratch);
+        unaligned_write_be64(&scratch[3], 0x030405060708090a);
+        assert_se(memcmp(&scratch[3], &data[3], sizeof(uint64_t)) == 0);
+        zero(scratch);
+        unaligned_write_be64(&scratch[4], 0x0405060708090a0b);
+        assert_se(memcmp(&scratch[4], &data[4], sizeof(uint64_t)) == 0);
+        zero(scratch);
+        unaligned_write_be64(&scratch[5], 0x05060708090a0b0c);
+        assert_se(memcmp(&scratch[5], &data[5], sizeof(uint64_t)) == 0);
+        zero(scratch);
+        unaligned_write_be64(&scratch[6], 0x060708090a0b0c0d);
+        assert_se(memcmp(&scratch[6], &data[6], sizeof(uint64_t)) == 0);
+        zero(scratch);
+        unaligned_write_be64(&scratch[7], 0x0708090a0b0c0d0e);
+        assert_se(memcmp(&scratch[7], &data[7], sizeof(uint64_t)) == 0);
+}
+
+static void test_le(void) {
         uint8_t scratch[16];
 
-        assert_se(unaligned_read_be16((be16_t*)&data[0]) == 0x0001);
-        assert_se(unaligned_read_be16((be16_t*)&data[1]) == 0x0102);
+        assert_se(unaligned_read_le16(&data[0]) == 0x0100);
+        assert_se(unaligned_read_le16(&data[1]) == 0x0201);
 
-        assert_se(unaligned_read_be32((be32_t*)&data[0]) == 0x00010203);
-        assert_se(unaligned_read_be32((be32_t*)&data[1]) == 0x01020304);
-        assert_se(unaligned_read_be32((be32_t*)&data[2]) == 0x02030405);
-        assert_se(unaligned_read_be32((be32_t*)&data[3]) == 0x03040506);
+        assert_se(unaligned_read_le32(&data[0]) == 0x03020100);
+        assert_se(unaligned_read_le32(&data[1]) == 0x04030201);
+        assert_se(unaligned_read_le32(&data[2]) == 0x05040302);
+        assert_se(unaligned_read_le32(&data[3]) == 0x06050403);
 
-        assert_se(unaligned_read_be64((be64_t*)&data[0]) == 0x0001020304050607);
-        assert_se(unaligned_read_be64((be64_t*)&data[1]) == 0x0102030405060708);
-        assert_se(unaligned_read_be64((be64_t*)&data[2]) == 0x0203040506070809);
-        assert_se(unaligned_read_be64((be64_t*)&data[3]) == 0x030405060708090a);
-        assert_se(unaligned_read_be64((be64_t*)&data[4]) == 0x0405060708090a0b);
-        assert_se(unaligned_read_be64((be64_t*)&data[5]) == 0x05060708090a0b0c);
-        assert_se(unaligned_read_be64((be64_t*)&data[6]) == 0x060708090a0b0c0d);
-        assert_se(unaligned_read_be64((be64_t*)&data[7]) == 0x0708090a0b0c0d0e);
+        assert_se(unaligned_read_le64(&data[0]) == 0x0706050403020100);
+        assert_se(unaligned_read_le64(&data[1]) == 0x0807060504030201);
+        assert_se(unaligned_read_le64(&data[2]) == 0x0908070605040302);
+        assert_se(unaligned_read_le64(&data[3]) == 0x0a09080706050403);
+        assert_se(unaligned_read_le64(&data[4]) == 0x0b0a090807060504);
+        assert_se(unaligned_read_le64(&data[5]) == 0x0c0b0a0908070605);
+        assert_se(unaligned_read_le64(&data[6]) == 0x0d0c0b0a09080706);
+        assert_se(unaligned_read_le64(&data[7]) == 0x0e0d0c0b0a090807);
 
         zero(scratch);
-        unaligned_write_be16((uint16_t*)&scratch[0], 0x0001);
+        unaligned_write_le16(&scratch[0], 0x0100);
         assert_se(memcmp(&scratch[0], &data[0], sizeof(uint16_t)) == 0);
         zero(scratch);
-        unaligned_write_be16((uint16_t*)&scratch[1], 0x0102);
+        unaligned_write_le16(&scratch[1], 0x0201);
         assert_se(memcmp(&scratch[1], &data[1], sizeof(uint16_t)) == 0);
 
         zero(scratch);
-        unaligned_write_be32((be32_t*)&scratch[0], 0x00010203);
+        unaligned_write_le32(&scratch[0], 0x03020100);
+
         assert_se(memcmp(&scratch[0], &data[0], sizeof(uint32_t)) == 0);
         zero(scratch);
-        unaligned_write_be32((be32_t*)&scratch[1], 0x01020304);
+        unaligned_write_le32(&scratch[1], 0x04030201);
         assert_se(memcmp(&scratch[1], &data[1], sizeof(uint32_t)) == 0);
         zero(scratch);
-        unaligned_write_be32((be32_t*)&scratch[2], 0x02030405);
+        unaligned_write_le32(&scratch[2], 0x05040302);
         assert_se(memcmp(&scratch[2], &data[2], sizeof(uint32_t)) == 0);
         zero(scratch);
-        unaligned_write_be32((be32_t*)&scratch[3], 0x03040506);
+        unaligned_write_le32(&scratch[3], 0x06050403);
         assert_se(memcmp(&scratch[3], &data[3], sizeof(uint32_t)) == 0);
 
         zero(scratch);
-        unaligned_write_be64((be64_t*)&scratch[0], 0x0001020304050607);
+        unaligned_write_le64(&scratch[0], 0x0706050403020100);
         assert_se(memcmp(&scratch[0], &data[0], sizeof(uint64_t)) == 0);
         zero(scratch);
-        unaligned_write_be64((be64_t*)&scratch[1], 0x0102030405060708);
+        unaligned_write_le64(&scratch[1], 0x0807060504030201);
         assert_se(memcmp(&scratch[1], &data[1], sizeof(uint64_t)) == 0);
         zero(scratch);
-        unaligned_write_be64((be64_t*)&scratch[2], 0x0203040506070809);
+        unaligned_write_le64(&scratch[2], 0x0908070605040302);
         assert_se(memcmp(&scratch[2], &data[2], sizeof(uint64_t)) == 0);
         zero(scratch);
-        unaligned_write_be64((be64_t*)&scratch[3], 0x030405060708090a);
+        unaligned_write_le64(&scratch[3], 0x0a09080706050403);
         assert_se(memcmp(&scratch[3], &data[3], sizeof(uint64_t)) == 0);
         zero(scratch);
-        unaligned_write_be64((be64_t*)&scratch[4], 0x0405060708090a0b);
+        unaligned_write_le64(&scratch[4], 0x0B0A090807060504);
         assert_se(memcmp(&scratch[4], &data[4], sizeof(uint64_t)) == 0);
         zero(scratch);
-        unaligned_write_be64((be64_t*)&scratch[5], 0x05060708090a0b0c);
+        unaligned_write_le64(&scratch[5], 0x0c0b0a0908070605);
         assert_se(memcmp(&scratch[5], &data[5], sizeof(uint64_t)) == 0);
         zero(scratch);
-        unaligned_write_be64((be64_t*)&scratch[6], 0x060708090a0b0c0d);
+        unaligned_write_le64(&scratch[6], 0x0d0c0b0a09080706);
         assert_se(memcmp(&scratch[6], &data[6], sizeof(uint64_t)) == 0);
         zero(scratch);
-        unaligned_write_be64((be64_t*)&scratch[7], 0x0708090a0b0c0d0e);
+        unaligned_write_le64(&scratch[7], 0x0e0d0c0b0a090807);
         assert_se(memcmp(&scratch[7], &data[7], sizeof(uint64_t)) == 0);
 }
+
+static void test_ne(void) {
+        uint16_t x = 4711;
+        uint32_t y = 123456;
+        uint64_t z = 9876543210;
+
+        /* Note that we don't bother actually testing alignment issues in this function, after all the _ne() functions
+         * are just aliases for the _le() or _be() implementations, which we test extensively above. Hence, in this
+         * function, just ensure that they map to the right version on the local architecture. */
+
+        assert_se(unaligned_read_ne16(&x) == 4711);
+        assert_se(unaligned_read_ne32(&y) == 123456);
+        assert_se(unaligned_read_ne64(&z) == 9876543210);
+
+        unaligned_write_ne16(&x, 1);
+        unaligned_write_ne32(&y, 2);
+        unaligned_write_ne64(&z, 3);
+
+        assert_se(x == 1);
+        assert_se(y == 2);
+        assert_se(z == 3);
+}
+
+int main(int argc, const char *argv[]) {
+        test_be();
+        test_le();
+        test_ne();
+        return 0;
+}