| // Copyright 2019 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "public/emboss_bit_util.h" |
| |
| #include <gtest/gtest.h> |
| |
| namespace emboss { |
| namespace support { |
| namespace test { |
| |
| TEST(ByteSwap, ByteSwap) { |
| EXPECT_EQ(0x01U, ByteSwap(::std::uint8_t{0x01})); |
| EXPECT_EQ(0x0102U, ByteSwap(::std::uint16_t{0x0201})); |
| EXPECT_EQ(0x01020304U, ByteSwap(::std::uint32_t{0x04030201})); |
| EXPECT_EQ(0x0102030405060708UL, |
| ByteSwap(::std::uint64_t{0x0807060504030201UL})); |
| } |
| |
| TEST(MaskToNBits, MaskToNBits) { |
| EXPECT_EQ(0xffU, MaskToNBits(0xffffffffU, 8)); |
| EXPECT_EQ(0x00U, MaskToNBits(0xffffff00U, 8)); |
| EXPECT_EQ(0x01U, MaskToNBits(0xffffffffU, 1)); |
| EXPECT_EQ(0x00U, MaskToNBits(0xfffffffeU, 1)); |
| EXPECT_EQ(0xffffffffU, MaskToNBits(0xffffffffU, 32)); |
| EXPECT_EQ(0xffffffffffffffffU, MaskToNBits(0xffffffffffffffffU, 64)); |
| EXPECT_EQ(0xfU, MaskToNBits(::std::uint8_t{0xff}, 4)); |
| } |
| |
| TEST(IsPowerOfTwo, IsPowerOfTwo) { |
| EXPECT_TRUE(IsPowerOfTwo(1U)); |
| EXPECT_TRUE(IsPowerOfTwo(2U)); |
| EXPECT_TRUE(IsPowerOfTwo(1UL << 63)); |
| EXPECT_TRUE(IsPowerOfTwo(::std::uint8_t{128})); |
| EXPECT_TRUE(IsPowerOfTwo(1)); |
| EXPECT_TRUE(IsPowerOfTwo(2)); |
| EXPECT_TRUE(IsPowerOfTwo(1L << 62)); |
| EXPECT_TRUE(IsPowerOfTwo(::std::int8_t{64})); |
| |
| EXPECT_FALSE(IsPowerOfTwo(0U)); |
| EXPECT_FALSE(IsPowerOfTwo(3U)); |
| EXPECT_FALSE(IsPowerOfTwo((1UL << 63) - 1)); |
| EXPECT_FALSE(IsPowerOfTwo((1UL << 62) + 1)); |
| EXPECT_FALSE(IsPowerOfTwo((3UL << 62))); |
| EXPECT_FALSE( |
| IsPowerOfTwo(::std::numeric_limits</**/ ::std::uint64_t>::max())); |
| EXPECT_FALSE(IsPowerOfTwo(::std::uint8_t{129})); |
| EXPECT_FALSE(IsPowerOfTwo(::std::uint8_t{255})); |
| EXPECT_FALSE(IsPowerOfTwo(-1)); |
| EXPECT_FALSE(IsPowerOfTwo(-2)); |
| EXPECT_FALSE(IsPowerOfTwo(-3)); |
| EXPECT_FALSE(IsPowerOfTwo(::std::numeric_limits</**/ ::std::int64_t>::min())); |
| EXPECT_FALSE(IsPowerOfTwo(::std::numeric_limits</**/ ::std::int64_t>::max())); |
| EXPECT_FALSE(IsPowerOfTwo(0)); |
| EXPECT_FALSE(IsPowerOfTwo(3)); |
| EXPECT_FALSE(IsPowerOfTwo((1L << 62) - 1)); |
| EXPECT_FALSE(IsPowerOfTwo((1L << 61) + 1)); |
| EXPECT_FALSE(IsPowerOfTwo((3L << 61))); |
| EXPECT_FALSE(IsPowerOfTwo(::std::int8_t{-1})); |
| EXPECT_FALSE(IsPowerOfTwo(::std::int8_t{-128})); |
| EXPECT_FALSE(IsPowerOfTwo(::std::int8_t{65})); |
| EXPECT_FALSE(IsPowerOfTwo(::std::int8_t{127})); |
| } |
| |
| #if defined(EMBOSS_LITTLE_ENDIAN_TO_NATIVE) |
| TEST(EndianConversion, LittleEndianToNative) { |
| ::std::uint16_t data16 = 0; |
| reinterpret_cast<char *>(&data16)[0] = 0x01; |
| reinterpret_cast<char *>(&data16)[1] = 0x02; |
| EXPECT_EQ(0x0201, EMBOSS_LITTLE_ENDIAN_TO_NATIVE(data16)); |
| |
| ::std::uint32_t data32 = 0; |
| reinterpret_cast<char *>(&data32)[0] = 0x01; |
| reinterpret_cast<char *>(&data32)[1] = 0x02; |
| reinterpret_cast<char *>(&data32)[2] = 0x03; |
| reinterpret_cast<char *>(&data32)[3] = 0x04; |
| EXPECT_EQ(0x04030201U, EMBOSS_LITTLE_ENDIAN_TO_NATIVE(data32)); |
| |
| ::std::uint64_t data64 = 0; |
| reinterpret_cast<char *>(&data64)[0] = 0x01; |
| reinterpret_cast<char *>(&data64)[1] = 0x02; |
| reinterpret_cast<char *>(&data64)[2] = 0x03; |
| reinterpret_cast<char *>(&data64)[3] = 0x04; |
| reinterpret_cast<char *>(&data64)[4] = 0x05; |
| reinterpret_cast<char *>(&data64)[5] = 0x06; |
| reinterpret_cast<char *>(&data64)[6] = 0x07; |
| reinterpret_cast<char *>(&data64)[7] = 0x08; |
| EXPECT_EQ(0x0807060504030201UL, EMBOSS_LITTLE_ENDIAN_TO_NATIVE(data64)); |
| } |
| #endif // defined(EMBOSS_LITTLE_ENDIAN_TO_NATIVE) |
| |
| #if defined(EMBOSS_BIG_ENDIAN_TO_NATIVE) |
| TEST(EndianConversion, BigEndianToNative) { |
| ::std::uint16_t data16 = 0; |
| reinterpret_cast<char *>(&data16)[0] = 0x01; |
| reinterpret_cast<char *>(&data16)[1] = 0x02; |
| EXPECT_EQ(0x0102, EMBOSS_BIG_ENDIAN_TO_NATIVE(data16)); |
| |
| ::std::uint32_t data32 = 0; |
| reinterpret_cast<char *>(&data32)[0] = 0x01; |
| reinterpret_cast<char *>(&data32)[1] = 0x02; |
| reinterpret_cast<char *>(&data32)[2] = 0x03; |
| reinterpret_cast<char *>(&data32)[3] = 0x04; |
| EXPECT_EQ(0x01020304U, EMBOSS_BIG_ENDIAN_TO_NATIVE(data32)); |
| |
| ::std::uint64_t data64 = 0; |
| reinterpret_cast<char *>(&data64)[0] = 0x01; |
| reinterpret_cast<char *>(&data64)[1] = 0x02; |
| reinterpret_cast<char *>(&data64)[2] = 0x03; |
| reinterpret_cast<char *>(&data64)[3] = 0x04; |
| reinterpret_cast<char *>(&data64)[4] = 0x05; |
| reinterpret_cast<char *>(&data64)[5] = 0x06; |
| reinterpret_cast<char *>(&data64)[6] = 0x07; |
| reinterpret_cast<char *>(&data64)[7] = 0x08; |
| EXPECT_EQ(0x0102030405060708UL, EMBOSS_BIG_ENDIAN_TO_NATIVE(data64)); |
| } |
| #endif // defined(EMBOSS_BIG_ENDIAN_TO_NATIVE) |
| |
| #if defined(EMBOSS_NATIVE_TO_LITTLE_ENDIAN) |
| TEST(EndianConversion, NativeToLittleEndian) { |
| ::std::uint16_t data16 = |
| EMBOSS_NATIVE_TO_LITTLE_ENDIAN(static_cast</**/ ::std::uint16_t>(0x0201)); |
| EXPECT_EQ(0x01, reinterpret_cast<char *>(&data16)[0]); |
| EXPECT_EQ(0x02, reinterpret_cast<char *>(&data16)[1]); |
| |
| ::std::uint32_t data32 = EMBOSS_NATIVE_TO_LITTLE_ENDIAN( |
| static_cast</**/ ::std::uint32_t>(0x04030201)); |
| EXPECT_EQ(0x01, reinterpret_cast<char *>(&data32)[0]); |
| EXPECT_EQ(0x02, reinterpret_cast<char *>(&data32)[1]); |
| EXPECT_EQ(0x03, reinterpret_cast<char *>(&data32)[2]); |
| EXPECT_EQ(0x04, reinterpret_cast<char *>(&data32)[3]); |
| |
| ::std::uint64_t data64 = EMBOSS_NATIVE_TO_LITTLE_ENDIAN( |
| static_cast</**/ ::std::uint64_t>(0x0807060504030201)); |
| EXPECT_EQ(0x01, reinterpret_cast<char *>(&data64)[0]); |
| EXPECT_EQ(0x02, reinterpret_cast<char *>(&data64)[1]); |
| EXPECT_EQ(0x03, reinterpret_cast<char *>(&data64)[2]); |
| EXPECT_EQ(0x04, reinterpret_cast<char *>(&data64)[3]); |
| EXPECT_EQ(0x05, reinterpret_cast<char *>(&data64)[4]); |
| EXPECT_EQ(0x06, reinterpret_cast<char *>(&data64)[5]); |
| EXPECT_EQ(0x07, reinterpret_cast<char *>(&data64)[6]); |
| EXPECT_EQ(0x08, reinterpret_cast<char *>(&data64)[7]); |
| } |
| #endif // defined(EMBOSS_NATIVE_TO_LITTLE_ENDIAN) |
| |
| #if defined(EMBOSS_NATIVE_TO_BIG_ENDIAN) |
| TEST(EndianConversion, NativeToBigEndian) { |
| ::std::uint16_t data16 = |
| EMBOSS_NATIVE_TO_BIG_ENDIAN(static_cast</**/ ::std::uint16_t>(0x0102)); |
| EXPECT_EQ(0x01, reinterpret_cast<char *>(&data16)[0]); |
| EXPECT_EQ(0x02, reinterpret_cast<char *>(&data16)[1]); |
| |
| ::std::uint32_t data32 = EMBOSS_NATIVE_TO_BIG_ENDIAN( |
| static_cast</**/ ::std::uint32_t>(0x01020304)); |
| EXPECT_EQ(0x01, reinterpret_cast<char *>(&data32)[0]); |
| EXPECT_EQ(0x02, reinterpret_cast<char *>(&data32)[1]); |
| EXPECT_EQ(0x03, reinterpret_cast<char *>(&data32)[2]); |
| EXPECT_EQ(0x04, reinterpret_cast<char *>(&data32)[3]); |
| |
| ::std::uint64_t data64 = EMBOSS_NATIVE_TO_BIG_ENDIAN( |
| static_cast</**/ ::std::uint64_t>(0x0102030405060708)); |
| EXPECT_EQ(0x01, reinterpret_cast<char *>(&data64)[0]); |
| EXPECT_EQ(0x02, reinterpret_cast<char *>(&data64)[1]); |
| EXPECT_EQ(0x03, reinterpret_cast<char *>(&data64)[2]); |
| EXPECT_EQ(0x04, reinterpret_cast<char *>(&data64)[3]); |
| EXPECT_EQ(0x05, reinterpret_cast<char *>(&data64)[4]); |
| EXPECT_EQ(0x06, reinterpret_cast<char *>(&data64)[5]); |
| EXPECT_EQ(0x07, reinterpret_cast<char *>(&data64)[6]); |
| EXPECT_EQ(0x08, reinterpret_cast<char *>(&data64)[7]); |
| } |
| #endif // defined(EMBOSS_NATIVE_TO_BIG_ENDIAN) |
| |
| } // namespace test |
| } // namespace support |
| } // namespace emboss |