//===- 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