blob: be34a71373ce2c31022fc08317180d2a8deb8310 [file] [log] [blame]
//===- unittests/ADT/BumpPtrListTest.cpp - BumpPtrList unit tests ---------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/ADT/AllocatorList.h"
#include "llvm/ADT/STLExtras.h"
#include "gtest/gtest.h"
using namespace llvm;
namespace {
struct CountsDestructors {
static unsigned NumCalls;
~CountsDestructors() { ++NumCalls; }
};
unsigned CountsDestructors::NumCalls = 0;
struct MoveOnly {
int V;
explicit MoveOnly(int V) : V(V) {}
MoveOnly() = delete;
MoveOnly(MoveOnly &&X) { V = X.V; }
MoveOnly(const MoveOnly &X) = delete;
MoveOnly &operator=(MoveOnly &&X) = delete;
MoveOnly &operator=(const MoveOnly &X) = delete;
};
struct EmplaceOnly {
int V1, V2;
explicit EmplaceOnly(int V1, int V2) : V1(V1), V2(V2) {}
EmplaceOnly() = delete;
EmplaceOnly(EmplaceOnly &&X) = delete;
EmplaceOnly(const EmplaceOnly &X) = delete;
EmplaceOnly &operator=(EmplaceOnly &&X) = delete;
EmplaceOnly &operator=(const EmplaceOnly &X) = delete;
};
TEST(BumpPtrListTest, DefaultConstructor) {
BumpPtrList<int> L;
EXPECT_TRUE(L.empty());
}
TEST(BumpPtrListTest, pushPopBack) {
// Build a list with push_back.
BumpPtrList<int> L;
int Ns[] = {1, 3, 9, 5, 7};
for (const int N : Ns)
L.push_back(N);
// Use iterators to check contents.
auto I = L.begin();
for (int N : Ns)
EXPECT_EQ(N, *I++);
EXPECT_EQ(I, L.end());
// Unbuild the list with pop_back.
for (int N : llvm::reverse(Ns)) {
EXPECT_EQ(N, L.back());
L.pop_back();
}
EXPECT_TRUE(L.empty());
}
TEST(BumpPtrListTest, pushPopFront) {
// Build a list with push_front.
BumpPtrList<int> L;
int Ns[] = {1, 3, 9, 5, 7};
for (const int N : Ns)
L.push_front(N);
// Use reverse iterators to check contents.
auto I = L.rbegin();
for (int N : Ns)
EXPECT_EQ(N, *I++);
EXPECT_EQ(I, L.rend());
// Unbuild the list with pop_front.
for (int N : llvm::reverse(Ns)) {
EXPECT_EQ(N, L.front());
L.pop_front();
}
EXPECT_TRUE(L.empty());
}
TEST(BumpPtrListTest, pushBackMoveOnly) {
BumpPtrList<MoveOnly> L;
int Ns[] = {1, 3, 9, 5, 7};
for (const int N : Ns) {
L.push_back(MoveOnly(N));
EXPECT_EQ(N, L.back().V);
}
// Instantiate with MoveOnly.
while (!L.empty())
L.pop_back();
}
TEST(BumpPtrListTest, pushFrontMoveOnly) {
BumpPtrList<MoveOnly> L;
int Ns[] = {1, 3, 9, 5, 7};
for (const int N : Ns) {
L.push_front(MoveOnly(N));
EXPECT_EQ(N, L.front().V);
}
// Instantiate with MoveOnly.
while (!L.empty())
L.pop_front();
}
TEST(BumpPtrListTest, emplaceBack) {
BumpPtrList<EmplaceOnly> L;
int N1s[] = {1, 3, 9, 5, 7};
int N2s[] = {7, 3, 1, 8, 2};
for (int I = 0; I != 5; ++I) {
L.emplace_back(N1s[I], N2s[I]);
EXPECT_EQ(N1s[I], L.back().V1);
EXPECT_EQ(N2s[I], L.back().V2);
}
// Instantiate with EmplaceOnly.
while (!L.empty())
L.pop_back();
}
TEST(BumpPtrListTest, emplaceFront) {
BumpPtrList<EmplaceOnly> L;
int N1s[] = {1, 3, 9, 5, 7};
int N2s[] = {7, 3, 1, 8, 2};
for (int I = 0; I != 5; ++I) {
L.emplace_front(N1s[I], N2s[I]);
EXPECT_EQ(N1s[I], L.front().V1);
EXPECT_EQ(N2s[I], L.front().V2);
}
// Instantiate with EmplaceOnly.
while (!L.empty())
L.pop_front();
}
TEST(BumpPtrListTest, swap) {
// Build two lists with different lifetimes and swap them.
int N1s[] = {1, 3, 5, 7, 9};
int N2s[] = {2, 4, 6, 8, 10};
BumpPtrList<int> L1;
L1.insert(L1.end(), std::begin(N1s), std::end(N1s));
{
BumpPtrList<int> L2;
L2.insert(L2.end(), std::begin(N2s), std::end(N2s));
// Swap the lists.
L1.swap(L2);
// Check L2's contents before it goes out of scope.
auto I = L2.begin();
for (int N : N1s)
EXPECT_EQ(N, *I++);
EXPECT_EQ(I, L2.end());
}
// Check L1's contents now that L2 is out of scope (with its allocation
// blocks).
auto I = L1.begin();
for (int N : N2s)
EXPECT_EQ(N, *I++);
EXPECT_EQ(I, L1.end());
}
TEST(BumpPtrListTest, clear) {
CountsDestructors::NumCalls = 0;
CountsDestructors N;
BumpPtrList<CountsDestructors> L;
L.push_back(N);
L.push_back(N);
L.push_back(N);
EXPECT_EQ(3u, L.size());
EXPECT_EQ(0u, CountsDestructors::NumCalls);
L.pop_back();
EXPECT_EQ(1u, CountsDestructors::NumCalls);
L.clear();
EXPECT_EQ(3u, CountsDestructors::NumCalls);
}
TEST(BumpPtrListTest, move) {
BumpPtrList<int> L1, L2;
L1.push_back(1);
L2.push_back(2);
L1 = std::move(L2);
EXPECT_EQ(1u, L1.size());
EXPECT_EQ(2, L1.front());
EXPECT_EQ(0u, L2.size());
}
TEST(BumpPtrListTest, moveCallsDestructors) {
CountsDestructors::NumCalls = 0;
BumpPtrList<CountsDestructors> L1, L2;
L1.emplace_back();
EXPECT_EQ(0u, CountsDestructors::NumCalls);
L1 = std::move(L2);
EXPECT_EQ(1u, CountsDestructors::NumCalls);
}
TEST(BumpPtrListTest, copy) {
BumpPtrList<int> L1, L2;
L1.push_back(1);
L2.push_back(2);
L1 = L2;
EXPECT_EQ(1u, L1.size());
EXPECT_EQ(2, L1.front());
EXPECT_EQ(1u, L2.size());
EXPECT_EQ(2, L2.front());
}
TEST(BumpPtrListTest, copyCallsDestructors) {
CountsDestructors::NumCalls = 0;
BumpPtrList<CountsDestructors> L1, L2;
L1.emplace_back();
EXPECT_EQ(0u, CountsDestructors::NumCalls);
L1 = L2;
EXPECT_EQ(1u, CountsDestructors::NumCalls);
}
TEST(BumpPtrListTest, resetAlloc) {
// Resetting an empty list should work.
BumpPtrList<int> L;
// Resetting an empty list that has allocated should also work.
L.resetAlloc();
L.push_back(5);
L.erase(L.begin());
L.resetAlloc();
// Resetting a non-empty list should crash.
L.push_back(5);
#if defined(GTEST_HAS_DEATH_TEST) && !defined(NDEBUG)
EXPECT_DEATH(L.resetAlloc(), "Cannot reset allocator if not empty");
#endif
}
} // end namespace