#include <bits/stdc++.h>
#include "fastallocator.h"

using namespace std;
template<size_t number>
struct C1 {
  static inline vector<int> v = {0, 0, 0, 0, 0};
  C1() {
    v[0]++;
  }
  C1(int) {
    v[1]++;
  }
  C1(const C1&) {
    v[2]++;
  }
  C1& operator=(const C1&) {
    v[3]++;
    return *this;
  }
  ~C1() {
    v[4]++;
  }
  static void print() {
    for (int i: v) {
      cout << i << " ";
    }
    cout << endl;
  }
};

void test1() {

  {
    const int N = 10000;

    List<C1<0>> l(N);
    list<C1<1>> t(N);

    assert(C1<0>::v == C1<1>::v);

    List<C1<0>> ll(N, C1<0>(10));
    list<C1<1>> tt(N, C1<1>(10));

    assert(C1<0>::v == C1<1>::v);

    for (size_t i = 0; i < N; ++i) {
      l.push_back(C1<0>());
      t.push_back(C1<1>());
      l.push_front(C1<0>());
      t.push_front(C1<1>());
    }

    assert(C1<0>::v == C1<1>::v);

    for (size_t i = 0; i < N; ++i) {
      l.insert(l.begin(), C1<0>());
      t.insert(t.begin(), C1<1>());
      l.insert(next(l.begin()), C1<0>(10));
      t.insert(next(t.begin()), C1<1>(10));
      l.insert(prev(l.end()), C1<0>());
      t.insert(prev(t.end()), C1<1>());
    }

    assert(C1<0>::v == C1<1>::v);

    for (size_t i = 0; i < N / 4; ++i) {
      l.pop_back();
      t.pop_back();
    }

    assert(C1<0>::v == C1<1>::v);

    for (size_t i = 0; i < N / 8; ++i) {
      l.erase(l.begin());
      t.erase(t.begin());
    }

    assert(C1<0>::v == C1<1>::v);

    for (size_t i = 0; i < N / 8; ++i) {
      l.erase(prev(l.end()));
      t.erase(prev(t.end()));
    }

    assert(C1<0>::v == C1<1>::v);

    for (size_t i = 0; i < N / 8; ++i) {
      auto a = C1<0>();
      l.push_back(a);
      auto b = C1<1>();
      t.push_back(b);
    }

    assert(C1<0>::v == C1<1>::v);

    for (size_t i = 0; i < N / 8; ++i) {
      (*next(l.begin())) = C1<0>();
      (*next(t.begin())) = C1<1>();
    }

    assert(C1<0>::v == C1<1>::v);

    C1<0>::print();
    C1<1>::print();
    List<C1<0>> lll = l;
    list<C1<1>> ttt = t;

    for (int i = 0; i < 10; ++i) {
      l.push_back(10);
      t.push_back(10);
    }

    assert(C1<0>::v == C1<1>::v);

    C1<0>::print();
    C1<1>::print();
    lll = l;
    ttt = t;
    C1<0>::print();
    C1<1>::print();

    assert(C1<0>::v == C1<1>::v);
  }

  assert(C1<0>::v == C1<1>::v);

  std::cout << "TEST 1 PASSED" << endl;
}

int main() {
  test1();

  std::list<char, FastAllocator<char>> x;
  x.push_back(10);
}