mirror of
https://github.com/wpilibsuite/allwpilib
synced 2026-06-22 01:11:42 +00:00
[wpiutil] Upgrade to LLVM 17.0.1 (#5482)
This commit is contained in:
Tyler Veness
@@ -12,10 +12,12 @@
|
||||
|
||||
#include "wpi/DenseMap.h"
|
||||
#include "wpi/DenseMapInfo.h"
|
||||
#include "wpi/DenseMapInfoVariant.h"
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <string_view>
|
||||
#include <utility>
|
||||
#include <variant>
|
||||
|
||||
@@ -126,6 +128,7 @@ TYPED_TEST(DenseMapTest, EmptyIntMapTest) {
|
||||
|
||||
// Lookup tests
|
||||
EXPECT_FALSE(this->Map.count(this->getKey()));
|
||||
EXPECT_FALSE(this->Map.contains(this->getKey()));
|
||||
EXPECT_TRUE(this->Map.find(this->getKey()) == this->Map.end());
|
||||
EXPECT_EQ(typename TypeParam::mapped_type(),
|
||||
this->Map.lookup(this->getKey()));
|
||||
@@ -157,11 +160,21 @@ TYPED_TEST(DenseMapTest, SingleEntryMapTest) {
|
||||
|
||||
// Lookup tests
|
||||
EXPECT_TRUE(this->Map.count(this->getKey()));
|
||||
EXPECT_TRUE(this->Map.contains(this->getKey()));
|
||||
EXPECT_TRUE(this->Map.find(this->getKey()) == this->Map.begin());
|
||||
EXPECT_EQ(this->getValue(), this->Map.lookup(this->getKey()));
|
||||
EXPECT_EQ(this->getValue(), this->Map[this->getKey()]);
|
||||
}
|
||||
|
||||
TYPED_TEST(DenseMapTest, AtTest) {
|
||||
this->Map[this->getKey(0)] = this->getValue(0);
|
||||
this->Map[this->getKey(1)] = this->getValue(1);
|
||||
this->Map[this->getKey(2)] = this->getValue(2);
|
||||
EXPECT_EQ(this->getValue(0), this->Map.at(this->getKey(0)));
|
||||
EXPECT_EQ(this->getValue(1), this->Map.at(this->getKey(1)));
|
||||
EXPECT_EQ(this->getValue(2), this->Map.at(this->getKey(2)));
|
||||
}
|
||||
|
||||
// Test clear() method
|
||||
TYPED_TEST(DenseMapTest, ClearTest) {
|
||||
this->Map[this->getKey()] = this->getValue();
|
||||
@@ -658,6 +671,10 @@ struct A {
|
||||
struct B : public A {
|
||||
using A::A;
|
||||
};
|
||||
|
||||
struct AlwaysEqType {
|
||||
bool operator==(const AlwaysEqType &RHS) const { return true; }
|
||||
};
|
||||
} // namespace
|
||||
|
||||
namespace wpi {
|
||||
@@ -670,6 +687,16 @@ struct DenseMapInfo<T, std::enable_if_t<std::is_base_of_v<A, T>>> {
|
||||
return LHS.value == RHS.value;
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct DenseMapInfo<AlwaysEqType> {
|
||||
using T = AlwaysEqType;
|
||||
static inline T getEmptyKey() { return {}; }
|
||||
static inline T getTombstoneKey() { return {}; }
|
||||
static unsigned getHashValue(const T &Val) { return 0; }
|
||||
static bool isEqual(const T &LHS, const T &RHS) {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
} // namespace wpi
|
||||
|
||||
namespace {
|
||||
@@ -693,16 +720,21 @@ TEST(DenseMapCustomTest, SFINAEMapInfo) {
|
||||
}
|
||||
|
||||
TEST(DenseMapCustomTest, VariantSupport) {
|
||||
using variant = std::variant<int, int>;
|
||||
using variant = std::variant<int, int, AlwaysEqType>;
|
||||
DenseMap<variant, int> Map;
|
||||
variant Keys[] = {
|
||||
variant(std::in_place_index<0>, 1),
|
||||
variant(std::in_place_index<1>, 1),
|
||||
variant(std::in_place_index<2>),
|
||||
};
|
||||
Map.try_emplace(Keys[0], 0);
|
||||
Map.try_emplace(Keys[1], 1);
|
||||
EXPECT_THAT(Map, testing::SizeIs(2));
|
||||
EXPECT_NE(DenseMapInfo<variant>::getHashValue(Keys[0]),
|
||||
DenseMapInfo<variant>::getHashValue(Keys[1]));
|
||||
// Check that isEqual dispatches to isEqual of underlying type, and not to
|
||||
// operator==.
|
||||
EXPECT_FALSE(DenseMapInfo<variant>::isEqual(Keys[2], Keys[2]));
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
@@ -94,8 +94,10 @@ TEST(MapVectorTest, erase) {
|
||||
MV.insert(std::make_pair(5, 6));
|
||||
ASSERT_EQ(MV.size(), 3u);
|
||||
|
||||
ASSERT_TRUE(MV.contains(1));
|
||||
MV.erase(MV.find(1));
|
||||
ASSERT_EQ(MV.size(), 2u);
|
||||
ASSERT_FALSE(MV.contains(1));
|
||||
ASSERT_EQ(MV.find(1), MV.end());
|
||||
ASSERT_EQ(MV[3], 4);
|
||||
ASSERT_EQ(MV[5], 6);
|
||||
|
||||
@@ -13,58 +13,6 @@ using namespace wpi;
|
||||
|
||||
namespace {
|
||||
|
||||
TEST(MathExtras, countTrailingZeros) {
|
||||
uint8_t Z8 = 0;
|
||||
uint16_t Z16 = 0;
|
||||
uint32_t Z32 = 0;
|
||||
uint64_t Z64 = 0;
|
||||
EXPECT_EQ(8u, countTrailingZeros(Z8));
|
||||
EXPECT_EQ(16u, countTrailingZeros(Z16));
|
||||
EXPECT_EQ(32u, countTrailingZeros(Z32));
|
||||
EXPECT_EQ(64u, countTrailingZeros(Z64));
|
||||
|
||||
uint8_t NZ8 = 42;
|
||||
uint16_t NZ16 = 42;
|
||||
uint32_t NZ32 = 42;
|
||||
uint64_t NZ64 = 42;
|
||||
EXPECT_EQ(1u, countTrailingZeros(NZ8));
|
||||
EXPECT_EQ(1u, countTrailingZeros(NZ16));
|
||||
EXPECT_EQ(1u, countTrailingZeros(NZ32));
|
||||
EXPECT_EQ(1u, countTrailingZeros(NZ64));
|
||||
}
|
||||
|
||||
TEST(MathExtras, countLeadingZeros) {
|
||||
uint8_t Z8 = 0;
|
||||
uint16_t Z16 = 0;
|
||||
uint32_t Z32 = 0;
|
||||
uint64_t Z64 = 0;
|
||||
EXPECT_EQ(8u, countLeadingZeros(Z8));
|
||||
EXPECT_EQ(16u, countLeadingZeros(Z16));
|
||||
EXPECT_EQ(32u, countLeadingZeros(Z32));
|
||||
EXPECT_EQ(64u, countLeadingZeros(Z64));
|
||||
|
||||
uint8_t NZ8 = 42;
|
||||
uint16_t NZ16 = 42;
|
||||
uint32_t NZ32 = 42;
|
||||
uint64_t NZ64 = 42;
|
||||
EXPECT_EQ(2u, countLeadingZeros(NZ8));
|
||||
EXPECT_EQ(10u, countLeadingZeros(NZ16));
|
||||
EXPECT_EQ(26u, countLeadingZeros(NZ32));
|
||||
EXPECT_EQ(58u, countLeadingZeros(NZ64));
|
||||
|
||||
EXPECT_EQ(8u, countLeadingZeros(0x00F000FFu));
|
||||
EXPECT_EQ(8u, countLeadingZeros(0x00F12345u));
|
||||
for (unsigned i = 0; i <= 30; ++i) {
|
||||
EXPECT_EQ(31 - i, countLeadingZeros(1u << i));
|
||||
}
|
||||
|
||||
EXPECT_EQ(8u, countLeadingZeros(0x00F1234500F12345ULL));
|
||||
EXPECT_EQ(1u, countLeadingZeros(1ULL << 62));
|
||||
for (unsigned i = 0; i <= 62; ++i) {
|
||||
EXPECT_EQ(63 - i, countLeadingZeros(1ULL << i));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(MathExtras, onesMask) {
|
||||
EXPECT_EQ(0U, maskLeadingOnes<uint8_t>(0));
|
||||
EXPECT_EQ(0U, maskTrailingOnes<uint8_t>(0));
|
||||
@@ -90,46 +38,6 @@ TEST(MathExtras, onesMask) {
|
||||
EXPECT_EQ(0xFFFFFFFFFFFF0000ULL, maskLeadingOnes<uint64_t>(48U));
|
||||
}
|
||||
|
||||
TEST(MathExtras, findFirstSet) {
|
||||
uint8_t Z8 = 0;
|
||||
uint16_t Z16 = 0;
|
||||
uint32_t Z32 = 0;
|
||||
uint64_t Z64 = 0;
|
||||
EXPECT_EQ(0xFFULL, findFirstSet(Z8));
|
||||
EXPECT_EQ(0xFFFFULL, findFirstSet(Z16));
|
||||
EXPECT_EQ(0xFFFFFFFFULL, findFirstSet(Z32));
|
||||
EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, findFirstSet(Z64));
|
||||
|
||||
uint8_t NZ8 = 42;
|
||||
uint16_t NZ16 = 42;
|
||||
uint32_t NZ32 = 42;
|
||||
uint64_t NZ64 = 42;
|
||||
EXPECT_EQ(1u, findFirstSet(NZ8));
|
||||
EXPECT_EQ(1u, findFirstSet(NZ16));
|
||||
EXPECT_EQ(1u, findFirstSet(NZ32));
|
||||
EXPECT_EQ(1u, findFirstSet(NZ64));
|
||||
}
|
||||
|
||||
TEST(MathExtras, findLastSet) {
|
||||
uint8_t Z8 = 0;
|
||||
uint16_t Z16 = 0;
|
||||
uint32_t Z32 = 0;
|
||||
uint64_t Z64 = 0;
|
||||
EXPECT_EQ(0xFFULL, findLastSet(Z8));
|
||||
EXPECT_EQ(0xFFFFULL, findLastSet(Z16));
|
||||
EXPECT_EQ(0xFFFFFFFFULL, findLastSet(Z32));
|
||||
EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, findLastSet(Z64));
|
||||
|
||||
uint8_t NZ8 = 42;
|
||||
uint16_t NZ16 = 42;
|
||||
uint32_t NZ32 = 42;
|
||||
uint64_t NZ64 = 42;
|
||||
EXPECT_EQ(5u, findLastSet(NZ8));
|
||||
EXPECT_EQ(5u, findLastSet(NZ16));
|
||||
EXPECT_EQ(5u, findLastSet(NZ32));
|
||||
EXPECT_EQ(5u, findLastSet(NZ64));
|
||||
}
|
||||
|
||||
TEST(MathExtras, isIntN) {
|
||||
EXPECT_TRUE(isIntN(16, 32767));
|
||||
EXPECT_FALSE(isIntN(16, 32768));
|
||||
@@ -235,12 +143,6 @@ TEST(MathExtras, PowerOf2Ceil) {
|
||||
EXPECT_EQ(8U, PowerOf2Ceil(7U));
|
||||
}
|
||||
|
||||
TEST(MathExtras, PowerOf2Floor) {
|
||||
EXPECT_EQ(0U, PowerOf2Floor(0U));
|
||||
EXPECT_EQ(8U, PowerOf2Floor(8U));
|
||||
EXPECT_EQ(4U, PowerOf2Floor(7U));
|
||||
}
|
||||
|
||||
TEST(MathExtras, CTLog2) {
|
||||
EXPECT_EQ(CTLog2<1ULL << 0>(), 0U);
|
||||
EXPECT_EQ(CTLog2<1ULL << 1>(), 1U);
|
||||
@@ -260,31 +162,6 @@ TEST(MathExtras, CTLog2) {
|
||||
EXPECT_EQ(CTLog2<1ULL << 15>(), 15U);
|
||||
}
|
||||
|
||||
TEST(MathExtras, countLeadingOnes) {
|
||||
for (int i = 30; i >= 0; --i) {
|
||||
// Start with all ones and unset some bit.
|
||||
EXPECT_EQ(31u - i, countLeadingOnes(0xFFFFFFFF ^ (1 << i)));
|
||||
}
|
||||
for (int i = 62; i >= 0; --i) {
|
||||
// Start with all ones and unset some bit.
|
||||
EXPECT_EQ(63u - i, countLeadingOnes(0xFFFFFFFFFFFFFFFFULL ^ (1LL << i)));
|
||||
}
|
||||
for (int i = 30; i >= 0; --i) {
|
||||
// Start with all ones and unset some bit.
|
||||
EXPECT_EQ(31u - i, countLeadingOnes(0xFFFFFFFF ^ (1 << i)));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(MathExtras, FloatBits) {
|
||||
static const float kValue = 5632.34f;
|
||||
EXPECT_FLOAT_EQ(kValue, BitsToFloat(FloatToBits(kValue)));
|
||||
}
|
||||
|
||||
TEST(MathExtras, DoubleBits) {
|
||||
static const double kValue = 87987234.983498;
|
||||
EXPECT_DOUBLE_EQ(kValue, BitsToDouble(DoubleToBits(kValue)));
|
||||
}
|
||||
|
||||
TEST(MathExtras, MinAlign) {
|
||||
EXPECT_EQ(1u, MinAlign(2, 3));
|
||||
EXPECT_EQ(2u, MinAlign(2, 4));
|
||||
|
||||
@@ -109,4 +109,22 @@ TEST(PointerIntPairTest, ManyUnusedBits) {
|
||||
"trivially copyable");
|
||||
}
|
||||
|
||||
TEST(PointerIntPairTest, TypePunning) {
|
||||
int I = 0;
|
||||
int *IntPtr = &I;
|
||||
|
||||
int **IntPtrBegin = &IntPtr;
|
||||
int **IntPtrEnd = IntPtrBegin + 1;
|
||||
|
||||
PointerIntPair<int *, 1> Pair;
|
||||
int **PairAddr = Pair.getAddrOfPointer();
|
||||
|
||||
while (IntPtrBegin != IntPtrEnd) {
|
||||
*PairAddr = *IntPtrBegin;
|
||||
++PairAddr;
|
||||
++IntPtrBegin;
|
||||
}
|
||||
EXPECT_EQ(Pair.getPointer(), IntPtr);
|
||||
}
|
||||
|
||||
} // end anonymous namespace
|
||||
|
||||
@@ -89,29 +89,29 @@ TEST_F(PointerUnionTest, Null) {
|
||||
}
|
||||
|
||||
TEST_F(PointerUnionTest, Is) {
|
||||
EXPECT_FALSE(a.is<int *>());
|
||||
EXPECT_TRUE(a.is<float *>());
|
||||
EXPECT_TRUE(b.is<int *>());
|
||||
EXPECT_FALSE(b.is<float *>());
|
||||
EXPECT_TRUE(n.is<int *>());
|
||||
EXPECT_FALSE(n.is<float *>());
|
||||
EXPECT_TRUE(i3.is<int *>());
|
||||
EXPECT_TRUE(f3.is<float *>());
|
||||
EXPECT_TRUE(l3.is<long long *>());
|
||||
EXPECT_TRUE(i4.is<int *>());
|
||||
EXPECT_TRUE(f4.is<float *>());
|
||||
EXPECT_TRUE(l4.is<long long *>());
|
||||
EXPECT_TRUE(d4.is<double *>());
|
||||
EXPECT_TRUE(i4null.is<int *>());
|
||||
EXPECT_TRUE(f4null.is<float *>());
|
||||
EXPECT_TRUE(l4null.is<long long *>());
|
||||
EXPECT_TRUE(d4null.is<double *>());
|
||||
EXPECT_FALSE(isa<int *>(a));
|
||||
EXPECT_TRUE(isa<float *>(a));
|
||||
EXPECT_TRUE(isa<int *>(b));
|
||||
EXPECT_FALSE(isa<float *>(b));
|
||||
EXPECT_TRUE(isa<int *>(n));
|
||||
EXPECT_FALSE(isa<float *>(n));
|
||||
EXPECT_TRUE(isa<int *>(i3));
|
||||
EXPECT_TRUE(isa<float *>(f3));
|
||||
EXPECT_TRUE(isa<long long *>(l3));
|
||||
EXPECT_TRUE(isa<int *>(i4));
|
||||
EXPECT_TRUE(isa<float *>(f4));
|
||||
EXPECT_TRUE(isa<long long *>(l4));
|
||||
EXPECT_TRUE(isa<double *>(d4));
|
||||
EXPECT_TRUE(isa<int *>(i4null));
|
||||
EXPECT_TRUE(isa<float *>(f4null));
|
||||
EXPECT_TRUE(isa<long long *>(l4null));
|
||||
EXPECT_TRUE(isa<double *>(d4null));
|
||||
}
|
||||
|
||||
TEST_F(PointerUnionTest, Get) {
|
||||
EXPECT_EQ(a.get<float *>(), &f);
|
||||
EXPECT_EQ(b.get<int *>(), &i);
|
||||
EXPECT_EQ(n.get<int *>(), (int *)nullptr);
|
||||
EXPECT_EQ(cast<float *>(a), &f);
|
||||
EXPECT_EQ(cast<int *>(b), &i);
|
||||
EXPECT_EQ(cast<int *>(n), (int *)nullptr);
|
||||
}
|
||||
|
||||
template<int I> struct alignas(8) Aligned {};
|
||||
@@ -125,27 +125,27 @@ TEST_F(PointerUnionTest, ManyElements) {
|
||||
Aligned<7> a7;
|
||||
|
||||
PU8 a = &a0;
|
||||
EXPECT_TRUE(a.is<Aligned<0>*>());
|
||||
EXPECT_FALSE(a.is<Aligned<1>*>());
|
||||
EXPECT_FALSE(a.is<Aligned<2>*>());
|
||||
EXPECT_FALSE(a.is<Aligned<3>*>());
|
||||
EXPECT_FALSE(a.is<Aligned<4>*>());
|
||||
EXPECT_FALSE(a.is<Aligned<5>*>());
|
||||
EXPECT_FALSE(a.is<Aligned<6>*>());
|
||||
EXPECT_FALSE(a.is<Aligned<7>*>());
|
||||
EXPECT_EQ(a.dyn_cast<Aligned<0>*>(), &a0);
|
||||
EXPECT_TRUE(isa<Aligned<0> *>(a));
|
||||
EXPECT_FALSE(isa<Aligned<1> *>(a));
|
||||
EXPECT_FALSE(isa<Aligned<2> *>(a));
|
||||
EXPECT_FALSE(isa<Aligned<3> *>(a));
|
||||
EXPECT_FALSE(isa<Aligned<4> *>(a));
|
||||
EXPECT_FALSE(isa<Aligned<5> *>(a));
|
||||
EXPECT_FALSE(isa<Aligned<6> *>(a));
|
||||
EXPECT_FALSE(isa<Aligned<7> *>(a));
|
||||
EXPECT_EQ(dyn_cast_if_present<Aligned<0> *>(a), &a0);
|
||||
EXPECT_EQ(*a.getAddrOfPtr1(), &a0);
|
||||
|
||||
a = &a7;
|
||||
EXPECT_FALSE(a.is<Aligned<0>*>());
|
||||
EXPECT_FALSE(a.is<Aligned<1>*>());
|
||||
EXPECT_FALSE(a.is<Aligned<2>*>());
|
||||
EXPECT_FALSE(a.is<Aligned<3>*>());
|
||||
EXPECT_FALSE(a.is<Aligned<4>*>());
|
||||
EXPECT_FALSE(a.is<Aligned<5>*>());
|
||||
EXPECT_FALSE(a.is<Aligned<6>*>());
|
||||
EXPECT_TRUE(a.is<Aligned<7>*>());
|
||||
EXPECT_EQ(a.dyn_cast<Aligned<7>*>(), &a7);
|
||||
EXPECT_FALSE(isa<Aligned<0> *>(a));
|
||||
EXPECT_FALSE(isa<Aligned<1> *>(a));
|
||||
EXPECT_FALSE(isa<Aligned<2> *>(a));
|
||||
EXPECT_FALSE(isa<Aligned<3> *>(a));
|
||||
EXPECT_FALSE(isa<Aligned<4> *>(a));
|
||||
EXPECT_FALSE(isa<Aligned<5> *>(a));
|
||||
EXPECT_FALSE(isa<Aligned<6> *>(a));
|
||||
EXPECT_TRUE(isa<Aligned<7> *>(a));
|
||||
EXPECT_EQ(dyn_cast_if_present<Aligned<7> *>(a), &a7);
|
||||
|
||||
EXPECT_TRUE(a == PU8(&a7));
|
||||
EXPECT_TRUE(a != PU8(&a0));
|
||||
|
||||
@@ -176,6 +176,11 @@ LLVM_ATTRIBUTE_USED void CompileTest() {
|
||||
V.resize(42);
|
||||
}
|
||||
|
||||
TEST(SmallVectorTest, ConstructNonCopyableTest) {
|
||||
SmallVector<NonCopyable, 0> V(42);
|
||||
EXPECT_EQ(V.size(), (size_t)42);
|
||||
}
|
||||
|
||||
// Assert that v contains the specified values, in order.
|
||||
template <typename VectorT>
|
||||
void assertValuesInOrder(VectorT &v, size_t size, ...) {
|
||||
|
||||
@@ -39,6 +39,7 @@ protected:
|
||||
EXPECT_TRUE(testMap.begin() == testMap.end());
|
||||
|
||||
// Lookup tests
|
||||
EXPECT_FALSE(testMap.contains(testKey));
|
||||
EXPECT_EQ(0u, testMap.count(testKey));
|
||||
EXPECT_EQ(0u, testMap.count(std::string_view(testKeyFirst, testKeyLength)));
|
||||
EXPECT_EQ(0u, testMap.count(testKeyStr));
|
||||
@@ -62,6 +63,7 @@ protected:
|
||||
EXPECT_TRUE(it == testMap.end());
|
||||
|
||||
// Lookup tests
|
||||
EXPECT_TRUE(testMap.contains(testKey));
|
||||
EXPECT_EQ(1u, testMap.count(testKey));
|
||||
EXPECT_EQ(1u, testMap.count(std::string_view(testKeyFirst, testKeyLength)));
|
||||
EXPECT_EQ(1u, testMap.count(testKeyStr));
|
||||
@@ -203,6 +205,18 @@ TEST_F(StringMapTest, CopyCtorTest) {
|
||||
EXPECT_EQ(5, Map2.lookup("funf"));
|
||||
}
|
||||
|
||||
TEST_F(StringMapTest, AtTest) {
|
||||
wpi::StringMap<int> Map;
|
||||
|
||||
// keys both found and not found on non-empty map
|
||||
Map["a"] = 1;
|
||||
Map["b"] = 2;
|
||||
Map["c"] = 3;
|
||||
EXPECT_EQ(1, Map.at("a"));
|
||||
EXPECT_EQ(2, Map.at("b"));
|
||||
EXPECT_EQ(3, Map.at("c"));
|
||||
}
|
||||
|
||||
// A more complex iteration test.
|
||||
TEST_F(StringMapTest, IterationTest) {
|
||||
bool visited[100];
|
||||
|
||||
@@ -16,16 +16,6 @@ using namespace wpi;
|
||||
|
||||
namespace {
|
||||
|
||||
TEST(ByteSwap, Swap_32) {
|
||||
EXPECT_EQ(0x44332211u, ByteSwap_32(0x11223344));
|
||||
EXPECT_EQ(0xDDCCBBAAu, ByteSwap_32(0xAABBCCDD));
|
||||
}
|
||||
|
||||
TEST(ByteSwap, Swap_64) {
|
||||
EXPECT_EQ(0x8877665544332211ULL, ByteSwap_64(0x1122334455667788LL));
|
||||
EXPECT_EQ(0x1100FFEEDDCCBBAAULL, ByteSwap_64(0xAABBCCDDEEFF0011LL));
|
||||
}
|
||||
|
||||
// In these first two tests all of the original_uintx values are truncated
|
||||
// except for 64. We could avoid this, but there's really no point.
|
||||
|
||||
|
||||
63
wpiutil/src/test/native/cpp/llvm/xxhashTest.cpp
Normal file
63
wpiutil/src/test/native/cpp/llvm/xxhashTest.cpp
Normal file
@@ -0,0 +1,63 @@
|
||||
//===- llvm/unittest/Support/xxhashTest.cpp -------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "wpi/xxhash.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
using namespace wpi;
|
||||
|
||||
TEST(xxhashTest, Basic) {
|
||||
EXPECT_EQ(0xef46db3751d8e999U, xxHash64(std::string_view()));
|
||||
EXPECT_EQ(0x33bf00a859c4ba3fU, xxHash64("foo"));
|
||||
EXPECT_EQ(0x48a37c90ad27a659U, xxHash64("bar"));
|
||||
EXPECT_EQ(0x69196c1b3af0bff9U,
|
||||
xxHash64("0123456789abcdefghijklmnopqrstuvwxyz"));
|
||||
}
|
||||
|
||||
TEST(xxhashTest, xxh3) {
|
||||
constexpr size_t size = 2243;
|
||||
uint8_t a[size];
|
||||
uint64_t x = 1;
|
||||
for (size_t i = 0; i < size; ++i) {
|
||||
x ^= x << 13;
|
||||
x ^= x >> 7;
|
||||
x ^= x << 17;
|
||||
a[i] = uint8_t(x);
|
||||
}
|
||||
|
||||
#define F(len, expected) \
|
||||
EXPECT_EQ(uint64_t(expected), xxh3_64bits(std::span(a, size_t(len))))
|
||||
F(0, 0x2d06800538d394c2);
|
||||
F(1, 0xd0d496e05c553485);
|
||||
F(2, 0x84d625edb7055eac);
|
||||
F(3, 0x6ea2d59aca5c3778);
|
||||
F(4, 0xbf65290914e80242);
|
||||
F(5, 0xc01fd099ad4fc8e4);
|
||||
F(6, 0x9e3ea8187399caa5);
|
||||
F(7, 0x9da8b60540644f5a);
|
||||
F(8, 0xabc1413da6cd0209);
|
||||
F(9, 0x8bc89400bfed51f6);
|
||||
F(16, 0x7e46916754d7c9b8);
|
||||
F(17, 0xed4be912ba5f836d);
|
||||
F(32, 0xf59b59b58c304fd1);
|
||||
F(33, 0x9013fb74ca603e0c);
|
||||
F(64, 0xfa5271fcce0db1c3);
|
||||
F(65, 0x79c42431727f1012);
|
||||
F(96, 0x591ee0ddf9c9ccd1);
|
||||
F(97, 0x8ffc6a3111fe19da);
|
||||
F(128, 0x06a146ee9a2da378);
|
||||
F(129, 0xbc7138129bf065da);
|
||||
F(403, 0xcefeb3ffa532ad8c);
|
||||
F(512, 0xcdfa6b6268e3650f);
|
||||
F(513, 0x4bb5d42742f9765f);
|
||||
F(2048, 0x330ce110cbb79eae);
|
||||
F(2049, 0x3ba6afa0249fef9a);
|
||||
F(2240, 0xd61d4d2a94e926a8);
|
||||
F(2243, 0x0979f786a24edde7);
|
||||
#undef F
|
||||
}
|
||||
Reference in New Issue
Block a user