unittests/Support/MathExtrasTest.cpp

   1 //===- unittests/Support/MathExtrasTest.cpp - math utils 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 "gtest/gtest.h"
  11 #include "llvm/Support/MathExtras.h"
  12
  13 using namespace llvm;
  14
  15 namespace {
  16
  17 TEST(MathExtras, countTrailingZeros) {
  18   uint8_t Z8 = 0;
  19   uint16_t Z16 = 0;
  20   uint32_t Z32 = 0;
  21   uint64_t Z64 = 0;
  22   EXPECT_EQ(8u, countTrailingZeros(Z8));
  23   EXPECT_EQ(16u, countTrailingZeros(Z16));
  24   EXPECT_EQ(32u, countTrailingZeros(Z32));
  25   EXPECT_EQ(64u, countTrailingZeros(Z64));
  26
  27   uint8_t NZ8 = 42;
  28   uint16_t NZ16 = 42;
  29   uint32_t NZ32 = 42;
  30   uint64_t NZ64 = 42;
  31   EXPECT_EQ(1u, countTrailingZeros(NZ8));
  32   EXPECT_EQ(1u, countTrailingZeros(NZ16));
  33   EXPECT_EQ(1u, countTrailingZeros(NZ32));
  34   EXPECT_EQ(1u, countTrailingZeros(NZ64));
  35 }
  36
  37 TEST(MathExtras, countLeadingZeros) {
  38   uint8_t Z8 = 0;
  39   uint16_t Z16 = 0;
  40   uint32_t Z32 = 0;
  41   uint64_t Z64 = 0;
  42   EXPECT_EQ(8u, countLeadingZeros(Z8));
  43   EXPECT_EQ(16u, countLeadingZeros(Z16));
  44   EXPECT_EQ(32u, countLeadingZeros(Z32));
  45   EXPECT_EQ(64u, countLeadingZeros(Z64));
  46
  47   uint8_t NZ8 = 42;
  48   uint16_t NZ16 = 42;
  49   uint32_t NZ32 = 42;
  50   uint64_t NZ64 = 42;
  51   EXPECT_EQ(2u, countLeadingZeros(NZ8));
  52   EXPECT_EQ(10u, countLeadingZeros(NZ16));
  53   EXPECT_EQ(26u, countLeadingZeros(NZ32));
  54   EXPECT_EQ(58u, countLeadingZeros(NZ64));
  55 }
  56
  57 TEST(MathExtras, findFirstSet) {
  58   uint8_t Z8 = 0;
  59   uint16_t Z16 = 0;
  60   uint32_t Z32 = 0;
  61   uint64_t Z64 = 0;
  62   EXPECT_EQ(0xFFULL, findFirstSet(Z8));
  63   EXPECT_EQ(0xFFFFULL, findFirstSet(Z16));
  64   EXPECT_EQ(0xFFFFFFFFULL, findFirstSet(Z32));
  65   EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, findFirstSet(Z64));
  66
  67   uint8_t NZ8 = 42;
  68   uint16_t NZ16 = 42;
  69   uint32_t NZ32 = 42;
  70   uint64_t NZ64 = 42;
  71   EXPECT_EQ(1u, findFirstSet(NZ8));
  72   EXPECT_EQ(1u, findFirstSet(NZ16));
  73   EXPECT_EQ(1u, findFirstSet(NZ32));
  74   EXPECT_EQ(1u, findFirstSet(NZ64));
  75 }
  76
  77 TEST(MathExtras, findLastSet) {
  78   uint8_t Z8 = 0;
  79   uint16_t Z16 = 0;
  80   uint32_t Z32 = 0;
  81   uint64_t Z64 = 0;
  82   EXPECT_EQ(0xFFULL, findLastSet(Z8));
  83   EXPECT_EQ(0xFFFFULL, findLastSet(Z16));
  84   EXPECT_EQ(0xFFFFFFFFULL, findLastSet(Z32));
  85   EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, findLastSet(Z64));
  86
  87   uint8_t NZ8 = 42;
  88   uint16_t NZ16 = 42;
  89   uint32_t NZ32 = 42;
  90   uint64_t NZ64 = 42;
  91   EXPECT_EQ(5u, findLastSet(NZ8));
  92   EXPECT_EQ(5u, findLastSet(NZ16));
  93   EXPECT_EQ(5u, findLastSet(NZ32));
  94   EXPECT_EQ(5u, findLastSet(NZ64));
  95 }
  96
  97 TEST(MathExtras, reverseBits) {
  98   uint8_t NZ8 = 42;
  99   uint16_t NZ16 = 42;
 100   uint32_t NZ32 = 42;
 101   uint64_t NZ64 = 42;
 102   EXPECT_EQ(0x54ULL, reverseBits(NZ8));
 103   EXPECT_EQ(0x5400ULL, reverseBits(NZ16));
 104   EXPECT_EQ(0x54000000ULL, reverseBits(NZ32));
 105   EXPECT_EQ(0x5400000000000000ULL, reverseBits(NZ64));
 106 }
 107
 108 TEST(MathExtras, isPowerOf2_32) {
 109   EXPECT_TRUE(isPowerOf2_32(1 << 6));
 110   EXPECT_TRUE(isPowerOf2_32(1 << 12));
 111   EXPECT_FALSE(isPowerOf2_32((1 << 19) + 3));
 112   EXPECT_FALSE(isPowerOf2_32(0xABCDEF0));
 113 }
 114
 115 TEST(MathExtras, isPowerOf2_64) {
 116   EXPECT_TRUE(isPowerOf2_64(1LL << 46));
 117   EXPECT_TRUE(isPowerOf2_64(1LL << 12));
 118   EXPECT_FALSE(isPowerOf2_64((1LL << 53) + 3));
 119   EXPECT_FALSE(isPowerOf2_64(0xABCDEF0ABCDEF0LL));
 120 }
 121
 122 TEST(MathExtras, ByteSwap_32) {
 123   EXPECT_EQ(0x44332211u, ByteSwap_32(0x11223344));
 124   EXPECT_EQ(0xDDCCBBAAu, ByteSwap_32(0xAABBCCDD));
 125 }
 126
 127 TEST(MathExtras, ByteSwap_64) {
 128   EXPECT_EQ(0x8877665544332211ULL, ByteSwap_64(0x1122334455667788LL));
 129   EXPECT_EQ(0x1100FFEEDDCCBBAAULL, ByteSwap_64(0xAABBCCDDEEFF0011LL));
 130 }
 131
 132 TEST(MathExtras, CountLeadingZeros_32) {
 133   EXPECT_EQ(8u, CountLeadingZeros_32(0x00F000FF));
 134   EXPECT_EQ(8u, CountLeadingZeros_32(0x00F12345));
 135   for (unsigned i = 0; i <= 30; ++i) {
 136     EXPECT_EQ(31 - i, CountLeadingZeros_32(1 << i));
 137   }
 138 }
 139
 140 TEST(MathExtras, CountLeadingZeros_64) {
 141   EXPECT_EQ(8u, CountLeadingZeros_64(0x00F1234500F12345LL));
 142   EXPECT_EQ(1u, CountLeadingZeros_64(1LL << 62));
 143   for (unsigned i = 0; i <= 62; ++i) {
 144     EXPECT_EQ(63 - i, CountLeadingZeros_64(1LL << i));
 145   }
 146 }
 147
 148 TEST(MathExtras, CountLeadingOnes_32) {
 149   for (int i = 30; i >= 0; --i) {
 150     // Start with all ones and unset some bit.
 151     EXPECT_EQ(31u - i, CountLeadingOnes_32(0xFFFFFFFF ^ (1 << i)));
 152   }
 153 }
 154
 155 TEST(MathExtras, CountLeadingOnes_64) {
 156   for (int i = 62; i >= 0; --i) {
 157     // Start with all ones and unset some bit.
 158     EXPECT_EQ(63u - i, CountLeadingOnes_64(0xFFFFFFFFFFFFFFFFLL ^ (1LL << i)));
 159   }
 160   for (int i = 30; i >= 0; --i) {
 161     // Start with all ones and unset some bit.
 162     EXPECT_EQ(31u - i, CountLeadingOnes_32(0xFFFFFFFF ^ (1 << i)));
 163   }
 164 }
 165
 166 TEST(MathExtras, FloatBits) {
 167   static const float kValue = 5632.34f;
 168   EXPECT_FLOAT_EQ(kValue, BitsToFloat(FloatToBits(kValue)));
 169 }
 170
 171 TEST(MathExtras, DoubleBits) {
 172   static const double kValue = 87987234.983498;
 173   EXPECT_FLOAT_EQ(kValue, BitsToDouble(DoubleToBits(kValue)));
 174 }
 175
 176 TEST(MathExtras, MinAlign) {
 177   EXPECT_EQ(1u, MinAlign(2, 3));
 178   EXPECT_EQ(2u, MinAlign(2, 4));
 179   EXPECT_EQ(1u, MinAlign(17, 64));
 180   EXPECT_EQ(256u, MinAlign(256, 512));
 181 }
 182
 183 TEST(MathExtras, NextPowerOf2) {
 184   EXPECT_EQ(4u, NextPowerOf2(3));
 185   EXPECT_EQ(16u, NextPowerOf2(15));
 186   EXPECT_EQ(256u, NextPowerOf2(128));
 187 }
 188
 189 TEST(MathExtras, RoundUpToAlignment) {
 190   EXPECT_EQ(8u, RoundUpToAlignment(5, 8));
 191   EXPECT_EQ(24u, RoundUpToAlignment(17, 8));
 192   EXPECT_EQ(0u, RoundUpToAlignment(~0LL, 8));
 193 }
 194
 195 }