You've already forked linux-packaging-mono
Imported Upstream version 5.18.0.247
Former-commit-id: 2d6af2e4ed0eda5cbdc2946446ef7718456ad190
This commit is contained in:
Xamarin Public Jenkins (auto-signing)
parent
279aa8f685
commit
ce8e504569
201
external/llvm/unittests/ADT/DenseSetTest.cpp
vendored
201
external/llvm/unittests/ADT/DenseSetTest.cpp
vendored
@ -1,201 +0,0 @@
|
||||
//===- llvm/unittest/ADT/DenseSetTest.cpp - DenseSet unit tests --*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/ADT/DenseSet.h"
|
||||
#include "gtest/gtest.h"
|
||||
#include <type_traits>
|
||||
|
||||
using namespace llvm;
|
||||
|
||||
namespace {
|
||||
|
||||
// Test hashing with a set of only two entries.
|
||||
TEST(DenseSetTest, DoubleEntrySetTest) {
|
||||
llvm::DenseSet<unsigned> set(2);
|
||||
set.insert(0);
|
||||
set.insert(1);
|
||||
// Original failure was an infinite loop in this call:
|
||||
EXPECT_EQ(0u, set.count(2));
|
||||
}
|
||||
|
||||
struct TestDenseSetInfo {
|
||||
static inline unsigned getEmptyKey() { return ~0; }
|
||||
static inline unsigned getTombstoneKey() { return ~0U - 1; }
|
||||
static unsigned getHashValue(const unsigned& Val) { return Val * 37U; }
|
||||
static unsigned getHashValue(const char* Val) {
|
||||
return (unsigned)(Val[0] - 'a') * 37U;
|
||||
}
|
||||
static bool isEqual(const unsigned& LHS, const unsigned& RHS) {
|
||||
return LHS == RHS;
|
||||
}
|
||||
static bool isEqual(const char* LHS, const unsigned& RHS) {
|
||||
return (unsigned)(LHS[0] - 'a') == RHS;
|
||||
}
|
||||
};
|
||||
|
||||
// Test fixture
|
||||
template <typename T> class DenseSetTest : public testing::Test {
|
||||
protected:
|
||||
T Set = GetTestSet();
|
||||
|
||||
private:
|
||||
static T GetTestSet() {
|
||||
typename std::remove_const<T>::type Set;
|
||||
Set.insert(0);
|
||||
Set.insert(1);
|
||||
Set.insert(2);
|
||||
return Set;
|
||||
}
|
||||
};
|
||||
|
||||
// Register these types for testing.
|
||||
typedef ::testing::Types<DenseSet<unsigned, TestDenseSetInfo>,
|
||||
const DenseSet<unsigned, TestDenseSetInfo>,
|
||||
SmallDenseSet<unsigned, 1, TestDenseSetInfo>,
|
||||
SmallDenseSet<unsigned, 4, TestDenseSetInfo>,
|
||||
const SmallDenseSet<unsigned, 4, TestDenseSetInfo>,
|
||||
SmallDenseSet<unsigned, 64, TestDenseSetInfo>>
|
||||
DenseSetTestTypes;
|
||||
TYPED_TEST_CASE(DenseSetTest, DenseSetTestTypes);
|
||||
|
||||
TYPED_TEST(DenseSetTest, InitializerList) {
|
||||
TypeParam set({1, 2, 1, 4});
|
||||
EXPECT_EQ(3u, set.size());
|
||||
EXPECT_EQ(1u, set.count(1));
|
||||
EXPECT_EQ(1u, set.count(2));
|
||||
EXPECT_EQ(1u, set.count(4));
|
||||
EXPECT_EQ(0u, set.count(3));
|
||||
}
|
||||
|
||||
TYPED_TEST(DenseSetTest, ConstIteratorComparison) {
|
||||
TypeParam set({1});
|
||||
const TypeParam &cset = set;
|
||||
EXPECT_EQ(set.begin(), cset.begin());
|
||||
EXPECT_EQ(set.end(), cset.end());
|
||||
EXPECT_NE(set.end(), cset.begin());
|
||||
EXPECT_NE(set.begin(), cset.end());
|
||||
}
|
||||
|
||||
TYPED_TEST(DenseSetTest, DefaultConstruction) {
|
||||
typename TypeParam::iterator I, J;
|
||||
typename TypeParam::const_iterator CI, CJ;
|
||||
EXPECT_EQ(I, J);
|
||||
EXPECT_EQ(CI, CJ);
|
||||
}
|
||||
|
||||
TYPED_TEST(DenseSetTest, EmptyInitializerList) {
|
||||
TypeParam set({});
|
||||
EXPECT_EQ(0u, set.size());
|
||||
EXPECT_EQ(0u, set.count(0));
|
||||
}
|
||||
|
||||
TYPED_TEST(DenseSetTest, FindAsTest) {
|
||||
auto &set = this->Set;
|
||||
// Size tests
|
||||
EXPECT_EQ(3u, set.size());
|
||||
|
||||
// Normal lookup tests
|
||||
EXPECT_EQ(1u, set.count(1));
|
||||
EXPECT_EQ(0u, *set.find(0));
|
||||
EXPECT_EQ(1u, *set.find(1));
|
||||
EXPECT_EQ(2u, *set.find(2));
|
||||
EXPECT_TRUE(set.find(3) == set.end());
|
||||
|
||||
// find_as() tests
|
||||
EXPECT_EQ(0u, *set.find_as("a"));
|
||||
EXPECT_EQ(1u, *set.find_as("b"));
|
||||
EXPECT_EQ(2u, *set.find_as("c"));
|
||||
EXPECT_TRUE(set.find_as("d") == set.end());
|
||||
}
|
||||
|
||||
// Simple class that counts how many moves and copy happens when growing a map
|
||||
struct CountCopyAndMove {
|
||||
static int Move;
|
||||
static int Copy;
|
||||
int Value;
|
||||
CountCopyAndMove(int Value) : Value(Value) {}
|
||||
|
||||
CountCopyAndMove(const CountCopyAndMove &RHS) {
|
||||
Value = RHS.Value;
|
||||
Copy++;
|
||||
}
|
||||
CountCopyAndMove &operator=(const CountCopyAndMove &RHS) {
|
||||
Value = RHS.Value;
|
||||
Copy++;
|
||||
return *this;
|
||||
}
|
||||
CountCopyAndMove(CountCopyAndMove &&RHS) {
|
||||
Value = RHS.Value;
|
||||
Move++;
|
||||
}
|
||||
CountCopyAndMove &operator=(const CountCopyAndMove &&RHS) {
|
||||
Value = RHS.Value;
|
||||
Move++;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
int CountCopyAndMove::Copy = 0;
|
||||
int CountCopyAndMove::Move = 0;
|
||||
} // anonymous namespace
|
||||
|
||||
namespace llvm {
|
||||
// Specialization required to insert a CountCopyAndMove into a DenseSet.
|
||||
template <> struct DenseMapInfo<CountCopyAndMove> {
|
||||
static inline CountCopyAndMove getEmptyKey() { return CountCopyAndMove(-1); };
|
||||
static inline CountCopyAndMove getTombstoneKey() {
|
||||
return CountCopyAndMove(-2);
|
||||
};
|
||||
static unsigned getHashValue(const CountCopyAndMove &Val) {
|
||||
return Val.Value;
|
||||
}
|
||||
static bool isEqual(const CountCopyAndMove &LHS,
|
||||
const CountCopyAndMove &RHS) {
|
||||
return LHS.Value == RHS.Value;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
namespace {
|
||||
// Make sure reserve actually gives us enough buckets to insert N items
|
||||
// without increasing allocation size.
|
||||
TEST(DenseSetCustomTest, ReserveTest) {
|
||||
// Test a few different size, 48 is *not* a random choice: we need a value
|
||||
// that is 2/3 of a power of two to stress the grow() condition, and the power
|
||||
// of two has to be at least 64 because of minimum size allocation in the
|
||||
// DenseMa. 66 is a value just above the 64 default init.
|
||||
for (auto Size : {1, 2, 48, 66}) {
|
||||
DenseSet<CountCopyAndMove> Set;
|
||||
Set.reserve(Size);
|
||||
unsigned MemorySize = Set.getMemorySize();
|
||||
CountCopyAndMove::Copy = 0;
|
||||
CountCopyAndMove::Move = 0;
|
||||
for (int i = 0; i < Size; ++i)
|
||||
Set.insert(CountCopyAndMove(i));
|
||||
// Check that we didn't grow
|
||||
EXPECT_EQ(MemorySize, Set.getMemorySize());
|
||||
// Check that move was called the expected number of times
|
||||
EXPECT_EQ(Size, CountCopyAndMove::Move);
|
||||
// Check that no copy occured
|
||||
EXPECT_EQ(0, CountCopyAndMove::Copy);
|
||||
}
|
||||
}
|
||||
TEST(DenseSetCustomTest, ConstTest) {
|
||||
// Test that const pointers work okay for count and find, even when the
|
||||
// underlying map is a non-const pointer.
|
||||
DenseSet<int *> Map;
|
||||
int A;
|
||||
int *B = &A;
|
||||
const int *C = &A;
|
||||
Map.insert(B);
|
||||
EXPECT_EQ(Map.count(B), 1u);
|
||||
EXPECT_EQ(Map.count(C), 1u);
|
||||
EXPECT_NE(Map.find(B), Map.end());
|
||||
EXPECT_NE(Map.find(C), Map.end());
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user