1 //===- unittests/Support/EndianTest.cpp - Endian.h tests ------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "llvm/Support/Endian.h" 11 #include "llvm/Support/DataTypes.h" 12 #include "gtest/gtest.h" 13 #include <cstdlib> 14 #include <ctime> 15 using namespace llvm; 16 using namespace support; 17 18 #undef max 19 20 namespace { 21 22 TEST(Endian, Read) { 23 // These are 5 bytes so we can be sure at least one of the reads is unaligned. 24 unsigned char bigval[] = {0x00, 0x01, 0x02, 0x03, 0x04}; 25 unsigned char littleval[] = {0x00, 0x04, 0x03, 0x02, 0x01}; 26 int32_t BigAsHost = 0x00010203; 27 EXPECT_EQ(BigAsHost, (endian::read<int32_t, big, unaligned>(bigval))); 28 int32_t LittleAsHost = 0x02030400; 29 EXPECT_EQ(LittleAsHost,(endian::read<int32_t, little, unaligned>(littleval))); 30 31 EXPECT_EQ((endian::read<int32_t, big, unaligned>(bigval + 1)), 32 (endian::read<int32_t, little, unaligned>(littleval + 1))); 33 } 34 35 TEST(Endian, ReadBitAligned) { 36 // Simple test to make sure we properly pull out the 0x0 word. 37 unsigned char littleval[] = {0x3f, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff}; 38 unsigned char bigval[] = {0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0}; 39 EXPECT_EQ( 40 (endian::readAtBitAlignment<int, little, unaligned>(&littleval[0], 6)), 41 0x0); 42 EXPECT_EQ((endian::readAtBitAlignment<int, big, unaligned>(&bigval[0], 6)), 43 0x0); 44 // Test to make sure that signed right shift of 0xf0000000 is masked 45 // properly. 46 unsigned char littleval2[] = {0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00}; 47 unsigned char bigval2[] = {0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 48 EXPECT_EQ( 49 (endian::readAtBitAlignment<int, little, unaligned>(&littleval2[0], 4)), 50 0x0f000000); 51 EXPECT_EQ((endian::readAtBitAlignment<int, big, unaligned>(&bigval2[0], 4)), 52 0x0f000000); 53 } 54 55 TEST(Endian, WriteBitAligned) { 56 // This test ensures that signed right shift of 0xffffaa is masked 57 // properly. 58 unsigned char bigval[8] = {0x00}; 59 endian::writeAtBitAlignment<int32_t, big, unaligned>(bigval, (int)0xffffaaaa, 60 4); 61 EXPECT_EQ(bigval[0], 0xff); 62 EXPECT_EQ(bigval[1], 0xfa); 63 EXPECT_EQ(bigval[2], 0xaa); 64 EXPECT_EQ(bigval[3], 0xa0); 65 EXPECT_EQ(bigval[4], 0x00); 66 EXPECT_EQ(bigval[5], 0x00); 67 EXPECT_EQ(bigval[6], 0x00); 68 EXPECT_EQ(bigval[7], 0x0f); 69 70 unsigned char littleval[8] = {0x00}; 71 endian::writeAtBitAlignment<int32_t, little, unaligned>(littleval, 72 (int)0xffffaaaa, 4); 73 EXPECT_EQ(littleval[0], 0xa0); 74 EXPECT_EQ(littleval[1], 0xaa); 75 EXPECT_EQ(littleval[2], 0xfa); 76 EXPECT_EQ(littleval[3], 0xff); 77 EXPECT_EQ(littleval[4], 0x0f); 78 EXPECT_EQ(littleval[5], 0x00); 79 EXPECT_EQ(littleval[6], 0x00); 80 EXPECT_EQ(littleval[7], 0x00); 81 } 82 83 TEST(Endian, Write) { 84 unsigned char data[5]; 85 endian::write<int32_t, big, unaligned>(data, -1362446643); 86 EXPECT_EQ(data[0], 0xAE); 87 EXPECT_EQ(data[1], 0xCA); 88 EXPECT_EQ(data[2], 0xB6); 89 EXPECT_EQ(data[3], 0xCD); 90 endian::write<int32_t, big, unaligned>(data + 1, -1362446643); 91 EXPECT_EQ(data[1], 0xAE); 92 EXPECT_EQ(data[2], 0xCA); 93 EXPECT_EQ(data[3], 0xB6); 94 EXPECT_EQ(data[4], 0xCD); 95 96 endian::write<int32_t, little, unaligned>(data, -1362446643); 97 EXPECT_EQ(data[0], 0xCD); 98 EXPECT_EQ(data[1], 0xB6); 99 EXPECT_EQ(data[2], 0xCA); 100 EXPECT_EQ(data[3], 0xAE); 101 endian::write<int32_t, little, unaligned>(data + 1, -1362446643); 102 EXPECT_EQ(data[1], 0xCD); 103 EXPECT_EQ(data[2], 0xB6); 104 EXPECT_EQ(data[3], 0xCA); 105 EXPECT_EQ(data[4], 0xAE); 106 } 107 108 TEST(Endian, PackedEndianSpecificIntegral) { 109 // These are 5 bytes so we can be sure at least one of the reads is unaligned. 110 unsigned char big[] = {0x00, 0x01, 0x02, 0x03, 0x04}; 111 unsigned char little[] = {0x00, 0x04, 0x03, 0x02, 0x01}; 112 big32_t *big_val = 113 reinterpret_cast<big32_t *>(big + 1); 114 little32_t *little_val = 115 reinterpret_cast<little32_t *>(little + 1); 116 117 EXPECT_EQ(*big_val, *little_val); 118 } 119 120 } // end anon namespace 121