unittests/ADT/BumpPtrListTest.cpp

   1 //===- unittests/ADT/BumpPtrListTest.cpp - BumpPtrList unit 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 "llvm/ADT/AllocatorList.h"
  11 #include "llvm/ADT/STLExtras.h"
  12 #include "gtest/gtest.h"
  13
  14 using namespace llvm;
  15
  16 namespace {
  17
  18 struct CountsDestructors {
  19   static unsigned NumCalls;
  20   ~CountsDestructors() { ++NumCalls; }
  21 };
  22 unsigned CountsDestructors::NumCalls = 0;
  23
  24 struct MoveOnly {
  25   int V;
  26   explicit MoveOnly(int V) : V(V) {}
  27   MoveOnly() = delete;
  28   MoveOnly(MoveOnly &&X) { V = X.V; }
  29   MoveOnly(const MoveOnly &X) = delete;
  30   MoveOnly &operator=(MoveOnly &&X) = delete;
  31   MoveOnly &operator=(const MoveOnly &X) = delete;
  32 };
  33
  34 struct EmplaceOnly {
  35   int V1, V2;
  36   explicit EmplaceOnly(int V1, int V2) : V1(V1), V2(V2) {}
  37   EmplaceOnly() = delete;
  38   EmplaceOnly(EmplaceOnly &&X) = delete;
  39   EmplaceOnly(const EmplaceOnly &X) = delete;
  40   EmplaceOnly &operator=(EmplaceOnly &&X) = delete;
  41   EmplaceOnly &operator=(const EmplaceOnly &X) = delete;
  42 };
  43
  44 TEST(BumpPtrListTest, DefaultConstructor) {
  45   BumpPtrList<int> L;
  46   EXPECT_TRUE(L.empty());
  47 }
  48
  49 TEST(BumpPtrListTest, pushPopBack) {
  50   // Build a list with push_back.
  51   BumpPtrList<int> L;
  52   int Ns[] = {1, 3, 9, 5, 7};
  53   for (const int N : Ns)
  54     L.push_back(N);
  55
  56   // Use iterators to check contents.
  57   auto I = L.begin();
  58   for (int N : Ns)
  59     EXPECT_EQ(N, *I++);
  60   EXPECT_EQ(I, L.end());
  61
  62   // Unbuild the list with pop_back.
  63   for (int N : llvm::reverse(Ns)) {
  64     EXPECT_EQ(N, L.back());
  65     L.pop_back();
  66   }
  67   EXPECT_TRUE(L.empty());
  68 }
  69
  70 TEST(BumpPtrListTest, pushPopFront) {
  71   // Build a list with push_front.
  72   BumpPtrList<int> L;
  73   int Ns[] = {1, 3, 9, 5, 7};
  74   for (const int N : Ns)
  75     L.push_front(N);
  76
  77   // Use reverse iterators to check contents.
  78   auto I = L.rbegin();
  79   for (int N : Ns)
  80     EXPECT_EQ(N, *I++);
  81   EXPECT_EQ(I, L.rend());
  82
  83   // Unbuild the list with pop_front.
  84   for (int N : llvm::reverse(Ns)) {
  85     EXPECT_EQ(N, L.front());
  86     L.pop_front();
  87   }
  88   EXPECT_TRUE(L.empty());
  89 }
  90
  91 TEST(BumpPtrListTest, pushBackMoveOnly) {
  92   BumpPtrList<MoveOnly> L;
  93   int Ns[] = {1, 3, 9, 5, 7};
  94   for (const int N : Ns) {
  95     L.push_back(MoveOnly(N));
  96     EXPECT_EQ(N, L.back().V);
  97   }
  98   // Instantiate with MoveOnly.
  99   while (!L.empty())
 100     L.pop_back();
 101 }
 102
 103 TEST(BumpPtrListTest, pushFrontMoveOnly) {
 104   BumpPtrList<MoveOnly> L;
 105   int Ns[] = {1, 3, 9, 5, 7};
 106   for (const int N : Ns) {
 107     L.push_front(MoveOnly(N));
 108     EXPECT_EQ(N, L.front().V);
 109   }
 110   // Instantiate with MoveOnly.
 111   while (!L.empty())
 112     L.pop_front();
 113 }
 114
 115 TEST(BumpPtrListTest, emplaceBack) {
 116   BumpPtrList<EmplaceOnly> L;
 117   int N1s[] = {1, 3, 9, 5, 7};
 118   int N2s[] = {7, 3, 1, 8, 2};
 119   for (int I = 0; I != 5; ++I) {
 120     L.emplace_back(N1s[I], N2s[I]);
 121     EXPECT_EQ(N1s[I], L.back().V1);
 122     EXPECT_EQ(N2s[I], L.back().V2);
 123   }
 124   // Instantiate with EmplaceOnly.
 125   while (!L.empty())
 126     L.pop_back();
 127 }
 128
 129 TEST(BumpPtrListTest, emplaceFront) {
 130   BumpPtrList<EmplaceOnly> L;
 131   int N1s[] = {1, 3, 9, 5, 7};
 132   int N2s[] = {7, 3, 1, 8, 2};
 133   for (int I = 0; I != 5; ++I) {
 134     L.emplace_front(N1s[I], N2s[I]);
 135     EXPECT_EQ(N1s[I], L.front().V1);
 136     EXPECT_EQ(N2s[I], L.front().V2);
 137   }
 138   // Instantiate with EmplaceOnly.
 139   while (!L.empty())
 140     L.pop_front();
 141 }
 142
 143 TEST(BumpPtrListTest, swap) {
 144   // Build two lists with different lifetimes and swap them.
 145   int N1s[] = {1, 3, 5, 7, 9};
 146   int N2s[] = {2, 4, 6, 8, 10};
 147
 148   BumpPtrList<int> L1;
 149   L1.insert(L1.end(), std::begin(N1s), std::end(N1s));
 150   {
 151     BumpPtrList<int> L2;
 152     L2.insert(L2.end(), std::begin(N2s), std::end(N2s));
 153
 154     // Swap the lists.
 155     L1.swap(L2);
 156
 157     // Check L2's contents before it goes out of scope.
 158     auto I = L2.begin();
 159     for (int N : N1s)
 160       EXPECT_EQ(N, *I++);
 161     EXPECT_EQ(I, L2.end());
 162   }
 163
 164   // Check L1's contents now that L2 is out of scope (with its allocation
 165   // blocks).
 166   auto I = L1.begin();
 167   for (int N : N2s)
 168     EXPECT_EQ(N, *I++);
 169   EXPECT_EQ(I, L1.end());
 170 }
 171
 172 TEST(BumpPtrListTest, clear) {
 173   CountsDestructors::NumCalls = 0;
 174   CountsDestructors N;
 175   BumpPtrList<CountsDestructors> L;
 176   L.push_back(N);
 177   L.push_back(N);
 178   L.push_back(N);
 179   EXPECT_EQ(3u, L.size());
 180   EXPECT_EQ(0u, CountsDestructors::NumCalls);
 181   L.pop_back();
 182   EXPECT_EQ(1u, CountsDestructors::NumCalls);
 183   L.clear();
 184   EXPECT_EQ(3u, CountsDestructors::NumCalls);
 185 }
 186
 187 TEST(BumpPtrListTest, move) {
 188   BumpPtrList<int> L1, L2;
 189   L1.push_back(1);
 190   L2.push_back(2);
 191   L1 = std::move(L2);
 192   EXPECT_EQ(1u, L1.size());
 193   EXPECT_EQ(2, L1.front());
 194   EXPECT_EQ(0u, L2.size());
 195 }
 196
 197 TEST(BumpPtrListTest, moveCallsDestructors) {
 198   CountsDestructors::NumCalls = 0;
 199   BumpPtrList<CountsDestructors> L1, L2;
 200   L1.emplace_back();
 201   EXPECT_EQ(0u, CountsDestructors::NumCalls);
 202   L1 = std::move(L2);
 203   EXPECT_EQ(1u, CountsDestructors::NumCalls);
 204 }
 205
 206 TEST(BumpPtrListTest, copy) {
 207   BumpPtrList<int> L1, L2;
 208   L1.push_back(1);
 209   L2.push_back(2);
 210   L1 = L2;
 211   EXPECT_EQ(1u, L1.size());
 212   EXPECT_EQ(2, L1.front());
 213   EXPECT_EQ(1u, L2.size());
 214   EXPECT_EQ(2, L2.front());
 215 }
 216
 217 TEST(BumpPtrListTest, copyCallsDestructors) {
 218   CountsDestructors::NumCalls = 0;
 219   BumpPtrList<CountsDestructors> L1, L2;
 220   L1.emplace_back();
 221   EXPECT_EQ(0u, CountsDestructors::NumCalls);
 222   L1 = L2;
 223   EXPECT_EQ(1u, CountsDestructors::NumCalls);
 224 }
 225
 226 TEST(BumpPtrListTest, resetAlloc) {
 227   // Resetting an empty list should work.
 228   BumpPtrList<int> L;
 229
 230   // Resetting an empty list that has allocated should also work.
 231   L.resetAlloc();
 232   L.push_back(5);
 233   L.erase(L.begin());
 234   L.resetAlloc();
 235
 236   // Resetting a non-empty list should crash.
 237   L.push_back(5);
 238 #if defined(GTEST_HAS_DEATH_TEST) && !defined(NDEBUG)
 239   EXPECT_DEATH(L.resetAlloc(), "Cannot reset allocator if not empty");
 240 #endif
 241 }
 242
 243 } // end namespace