third_party/highway/hwy/base_test.cc

   1 // Copyright 2019 Google LLC
   2 // SPDX-License-Identifier: Apache-2.0
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //      http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15
  16 #include <stddef.h>
  17 #include <stdint.h>
  18
  19 #include <limits>
  20
  21 #include "hwy/base.h"
  22
  23 #undef HWY_TARGET_INCLUDE
  24 #define HWY_TARGET_INCLUDE "base_test.cc"
  25 #include "hwy/foreach_target.h"  // IWYU pragma: keep
  26 #include "hwy/highway.h"
  27 #include "hwy/tests/test_util-inl.h"
  28
  29 HWY_BEFORE_NAMESPACE();
  30 namespace hwy {
  31 namespace HWY_NAMESPACE {
  32
  33 HWY_NOINLINE void TestAllLimits() {
  34   HWY_ASSERT_EQ(uint8_t{0}, LimitsMin<uint8_t>());
  35   HWY_ASSERT_EQ(uint16_t{0}, LimitsMin<uint16_t>());
  36   HWY_ASSERT_EQ(uint32_t{0}, LimitsMin<uint32_t>());
  37   HWY_ASSERT_EQ(uint64_t{0}, LimitsMin<uint64_t>());
  38
  39   HWY_ASSERT_EQ(int8_t{-128}, LimitsMin<int8_t>());
  40   HWY_ASSERT_EQ(int16_t{-32768}, LimitsMin<int16_t>());
  41   HWY_ASSERT_EQ(static_cast<int32_t>(0x80000000u), LimitsMin<int32_t>());
  42   HWY_ASSERT_EQ(static_cast<int64_t>(0x8000000000000000ull),
  43                 LimitsMin<int64_t>());
  44
  45   HWY_ASSERT_EQ(uint8_t{0xFF}, LimitsMax<uint8_t>());
  46   HWY_ASSERT_EQ(uint16_t{0xFFFF}, LimitsMax<uint16_t>());
  47   HWY_ASSERT_EQ(uint32_t{0xFFFFFFFFu}, LimitsMax<uint32_t>());
  48   HWY_ASSERT_EQ(uint64_t{0xFFFFFFFFFFFFFFFFull}, LimitsMax<uint64_t>());
  49
  50   HWY_ASSERT_EQ(int8_t{0x7F}, LimitsMax<int8_t>());
  51   HWY_ASSERT_EQ(int16_t{0x7FFF}, LimitsMax<int16_t>());
  52   HWY_ASSERT_EQ(int32_t{0x7FFFFFFFu}, LimitsMax<int32_t>());
  53   HWY_ASSERT_EQ(int64_t{0x7FFFFFFFFFFFFFFFull}, LimitsMax<int64_t>());
  54 }
  55
  56 struct TestLowestHighest {
  57   template <class T>
  58   HWY_NOINLINE void operator()(T /*unused*/) const {
  59     HWY_ASSERT_EQ(std::numeric_limits<T>::lowest(), LowestValue<T>());
  60     HWY_ASSERT_EQ(std::numeric_limits<T>::max(), HighestValue<T>());
  61   }
  62 };
  63
  64 HWY_NOINLINE void TestAllLowestHighest() { ForAllTypes(TestLowestHighest()); }
  65 struct TestIsUnsigned {
  66   template <class T>
  67   HWY_NOINLINE void operator()(T /*unused*/) const {
  68     static_assert(!IsFloat<T>(), "Expected !IsFloat");
  69     static_assert(!IsSigned<T>(), "Expected !IsSigned");
  70   }
  71 };
  72
  73 struct TestIsSigned {
  74   template <class T>
  75   HWY_NOINLINE void operator()(T /*unused*/) const {
  76     static_assert(!IsFloat<T>(), "Expected !IsFloat");
  77     static_assert(IsSigned<T>(), "Expected IsSigned");
  78   }
  79 };
  80
  81 struct TestIsFloat {
  82   template <class T>
  83   HWY_NOINLINE void operator()(T /*unused*/) const {
  84     static_assert(IsFloat<T>(), "Expected IsFloat");
  85     static_assert(IsSigned<T>(), "Floats are also considered signed");
  86   }
  87 };
  88
  89 HWY_NOINLINE void TestAllType() {
  90   ForUnsignedTypes(TestIsUnsigned());
  91   ForSignedTypes(TestIsSigned());
  92   ForFloatTypes(TestIsFloat());
  93
  94   static_assert(sizeof(MakeUnsigned<hwy::uint128_t>) == 16, "");
  95   static_assert(sizeof(MakeWide<uint64_t>) == 16, "Expected uint128_t");
  96   static_assert(sizeof(MakeNarrow<hwy::uint128_t>) == 8, "Expected uint64_t");
  97 }
  98
  99 struct TestIsSame {
 100   template <class T>
 101   HWY_NOINLINE void operator()(T /*unused*/) const {
 102     static_assert(IsSame<T, T>(), "T == T");
 103     static_assert(!IsSame<MakeSigned<T>, MakeUnsigned<T>>(), "S != U");
 104     static_assert(!IsSame<MakeUnsigned<T>, MakeSigned<T>>(), "U != S");
 105   }
 106 };
 107
 108 HWY_NOINLINE void TestAllIsSame() { ForAllTypes(TestIsSame()); }
 109
 110 HWY_NOINLINE void TestAllBitScan() {
 111   HWY_ASSERT_EQ(size_t{0}, Num0BitsAboveMS1Bit_Nonzero32(0x80000000u));
 112   HWY_ASSERT_EQ(size_t{0}, Num0BitsAboveMS1Bit_Nonzero32(0xFFFFFFFFu));
 113   HWY_ASSERT_EQ(size_t{1}, Num0BitsAboveMS1Bit_Nonzero32(0x40000000u));
 114   HWY_ASSERT_EQ(size_t{1}, Num0BitsAboveMS1Bit_Nonzero32(0x40108210u));
 115   HWY_ASSERT_EQ(size_t{30}, Num0BitsAboveMS1Bit_Nonzero32(2u));
 116   HWY_ASSERT_EQ(size_t{30}, Num0BitsAboveMS1Bit_Nonzero32(3u));
 117   HWY_ASSERT_EQ(size_t{31}, Num0BitsAboveMS1Bit_Nonzero32(1u));
 118
 119   HWY_ASSERT_EQ(size_t{0},
 120                 Num0BitsAboveMS1Bit_Nonzero64(0x8000000000000000ull));
 121   HWY_ASSERT_EQ(size_t{0},
 122                 Num0BitsAboveMS1Bit_Nonzero64(0xFFFFFFFFFFFFFFFFull));
 123   HWY_ASSERT_EQ(size_t{1},
 124                 Num0BitsAboveMS1Bit_Nonzero64(0x4000000000000000ull));
 125   HWY_ASSERT_EQ(size_t{1},
 126                 Num0BitsAboveMS1Bit_Nonzero64(0x4010821004200011ull));
 127   HWY_ASSERT_EQ(size_t{62}, Num0BitsAboveMS1Bit_Nonzero64(2ull));
 128   HWY_ASSERT_EQ(size_t{62}, Num0BitsAboveMS1Bit_Nonzero64(3ull));
 129   HWY_ASSERT_EQ(size_t{63}, Num0BitsAboveMS1Bit_Nonzero64(1ull));
 130
 131   HWY_ASSERT_EQ(size_t{0}, Num0BitsBelowLS1Bit_Nonzero32(1u));
 132   HWY_ASSERT_EQ(size_t{1}, Num0BitsBelowLS1Bit_Nonzero32(2u));
 133   HWY_ASSERT_EQ(size_t{30}, Num0BitsBelowLS1Bit_Nonzero32(0xC0000000u));
 134   HWY_ASSERT_EQ(size_t{31}, Num0BitsBelowLS1Bit_Nonzero32(0x80000000u));
 135
 136   HWY_ASSERT_EQ(size_t{0}, Num0BitsBelowLS1Bit_Nonzero64(1ull));
 137   HWY_ASSERT_EQ(size_t{1}, Num0BitsBelowLS1Bit_Nonzero64(2ull));
 138   HWY_ASSERT_EQ(size_t{62},
 139                 Num0BitsBelowLS1Bit_Nonzero64(0xC000000000000000ull));
 140   HWY_ASSERT_EQ(size_t{63},
 141                 Num0BitsBelowLS1Bit_Nonzero64(0x8000000000000000ull));
 142 }
 143
 144 HWY_NOINLINE void TestAllPopCount() {
 145   HWY_ASSERT_EQ(size_t{0}, PopCount(0u));
 146   HWY_ASSERT_EQ(size_t{1}, PopCount(1u));
 147   HWY_ASSERT_EQ(size_t{1}, PopCount(2u));
 148   HWY_ASSERT_EQ(size_t{2}, PopCount(3u));
 149   HWY_ASSERT_EQ(size_t{1}, PopCount(0x80000000u));
 150   HWY_ASSERT_EQ(size_t{31}, PopCount(0x7FFFFFFFu));
 151   HWY_ASSERT_EQ(size_t{32}, PopCount(0xFFFFFFFFu));
 152
 153   HWY_ASSERT_EQ(size_t{1}, PopCount(0x80000000ull));
 154   HWY_ASSERT_EQ(size_t{31}, PopCount(0x7FFFFFFFull));
 155   HWY_ASSERT_EQ(size_t{32}, PopCount(0xFFFFFFFFull));
 156   HWY_ASSERT_EQ(size_t{33}, PopCount(0x10FFFFFFFFull));
 157   HWY_ASSERT_EQ(size_t{63}, PopCount(0xFFFEFFFFFFFFFFFFull));
 158   HWY_ASSERT_EQ(size_t{64}, PopCount(0xFFFFFFFFFFFFFFFFull));
 159 }
 160
 161 // NOLINTNEXTLINE(google-readability-namespace-comments)
 162 }  // namespace HWY_NAMESPACE
 163 }  // namespace hwy
 164 HWY_AFTER_NAMESPACE();
 165
 166 #if HWY_ONCE
 167
 168 namespace hwy {
 169 HWY_BEFORE_TEST(BaseTest);
 170 HWY_EXPORT_AND_TEST_P(BaseTest, TestAllLimits);
 171 HWY_EXPORT_AND_TEST_P(BaseTest, TestAllLowestHighest);
 172 HWY_EXPORT_AND_TEST_P(BaseTest, TestAllType);
 173 HWY_EXPORT_AND_TEST_P(BaseTest, TestAllIsSame);
 174 HWY_EXPORT_AND_TEST_P(BaseTest, TestAllBitScan);
 175 HWY_EXPORT_AND_TEST_P(BaseTest, TestAllPopCount);
 176 }  // namespace hwy
 177
 178 #endif