From e178ef587dec9fe91b2d2d6e6ca804d15d8dfe0a Mon Sep 17 00:00:00 2001
From: Ilya Vankov <vankov-ilya@yandex-team.ru>
Date: Tue, 9 Jul 2024 03:05:29 +0400
Subject: [PATCH 1/2] refactored deque tests using GTEST

---
 tasks/tests/deque_test.cpp | 1770 +++++++++++++++++++++++-------------
 1 file changed, 1134 insertions(+), 636 deletions(-)

diff --git a/tasks/tests/deque_test.cpp b/tasks/tests/deque_test.cpp
index 04860e2..58f15bf 100644
--- a/tasks/tests/deque_test.cpp
+++ b/tasks/tests/deque_test.cpp
@@ -1,729 +1,1227 @@
-#include <type_traits>
-#include <unordered_set>
+#include "gtest/gtest.h"
 #include <algorithm>
+#include <cstddef>
+#include <gtest/gtest.h>
+#include <iterator>
 #include <numeric>
 #include <random>
-#include <iostream>
-#include <cassert>
-#include <deque>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
-//#include "deque.h"
+// #include <deque>
+// template <typename T> using Deque = std::deque<T>;
 
-template <typename T>
-using Deque = std::deque<T>;
+#include "deque.h"
 
-namespace TestsByMesyarik {
+namespace {
 
-void test1() {
-    Deque<int> d(10, 3);
+// Counts every call of defaul/copy-ctor and dtor
+class Accountant {
+public:
+  Accountant() { ++default_ctor_calls; }
+  Accountant(const Accountant &) { ++copy_default_ctor_calls; }
+  ~Accountant() { ++dtor_calls; }
+
+  static void ResetDefaultCtorCounter() { default_ctor_calls = 0; }
+  static void ResetCopyCtorCounter() { copy_default_ctor_calls = 0; }
+  static void ResetDtorCounter() { dtor_calls = 0; }
+  static void ResetAll() {
+    ResetDefaultCtorCounter();
+    ResetCopyCtorCounter();
+    ResetDtorCounter();
+  }
+
+  static size_t default_ctor_calls;
+  static size_t copy_default_ctor_calls;
+  static size_t dtor_calls;
+};
 
-    d[3] = 5;
+size_t Accountant::default_ctor_calls = 0;
+size_t Accountant::copy_default_ctor_calls = 0;
+size_t Accountant::dtor_calls = 0;
 
-    d[7] = 8;
+// Every default-constructed object has unique number
+// When copied number remains the same
+class UniqueDefaultConstructed {
+public:
+  static size_t counter;
+  size_t number_;
 
-    d[9] = 10;
+  UniqueDefaultConstructed() : number_(counter++) {}
+  static void Reset() { counter = 0; }
+};
 
-    std::string s = "33353338310";
-    std::string ss;
-    Deque<int> dd;
+size_t UniqueDefaultConstructed::counter = 0;
 
-    {
-        Deque<int> d2 = d;
+class Unique {
+public:
+  static size_t counter;
+  size_t number_;
 
-        dd = d2;
-    }
+  Unique() : number_(counter++) {}
+  Unique(const Unique &other) : number_(counter++) {}
+  static void Reset() { counter = 0; }
+};
 
-    d[1] = 2;
+size_t Unique::counter = 0;
 
-    d.at(2) = 1;
+class ConstructorsTests : public ::testing::Test {
+protected:
+  const size_t kSmallSize = 10;
+  const size_t kBigSize = 1000000;
 
-    try {
-        d.at(10) = 0;
-        assert(false);
-    } catch (std::out_of_range&) {}
+  void SetUp() override {
+    Accountant::ResetAll();
+    UniqueDefaultConstructed::Reset();
+    Unique::Reset();
+  }
 
-    const Deque<int>& ddd = dd;
-    for (size_t i = 0; i < ddd.size(); ++i) {
-        ss += std::to_string(ddd[i]);
-    }
+  void TearDown() override {
+    Accountant::ResetAll();
+    Unique::Reset();
+    UniqueDefaultConstructed::Reset();
+  }
+};
+
+TEST_F(ConstructorsTests, HasConstructors) {
+  ASSERT_TRUE((std::is_default_constructible_v<Deque<Unique>>));
+  ASSERT_TRUE((std::is_copy_constructible_v<Deque<Unique>>));
+  ASSERT_TRUE((std::is_constructible_v<Deque<Unique>, int>));
+  ASSERT_TRUE((std::is_constructible_v<Deque<Unique>, int, const Unique &>));
+  ASSERT_TRUE((std::is_copy_assignable_v<Deque<Unique>>));
+}
 
-    assert(s == ss);
+TEST_F(ConstructorsTests, DefaultConstructorWithAccountant) {
+
+  {
+    Deque<Accountant> d;
+    ASSERT_EQ(0, Accountant::default_ctor_calls);
+    ASSERT_EQ(0, Accountant::dtor_calls);
+    ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
+    ASSERT_EQ(0, d.size());
+  }
+
+  ASSERT_EQ(0, Accountant::default_ctor_calls);
+  ASSERT_EQ(0, Accountant::dtor_calls);
+  ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
 }
 
-void test2() {
-    Deque<int> d(1);
+TEST_F(ConstructorsTests, SizeConstructorWithAccountant) {
+  {
+    Deque<Accountant> d(kSmallSize);
+    ASSERT_EQ(kSmallSize, Accountant::default_ctor_calls);
+    ASSERT_EQ(0, Accountant::dtor_calls);
+    ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
+    ASSERT_EQ(kSmallSize, d.size());
+  }
+
+  ASSERT_EQ(kSmallSize, Accountant::default_ctor_calls);
+  ASSERT_EQ(kSmallSize, Accountant::dtor_calls);
+  ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
+
+  {
+    Accountant::ResetAll();
+    Deque<Accountant> d(kSmallSize, Accountant());
+    ASSERT_EQ(1, Accountant::default_ctor_calls);
+    ASSERT_EQ(1, Accountant::dtor_calls);
+    ASSERT_EQ(kSmallSize, Accountant::copy_default_ctor_calls);
+    ASSERT_EQ(kSmallSize, d.size());
+  }
+
+  ASSERT_EQ(1, Accountant::default_ctor_calls);
+  ASSERT_EQ(kSmallSize + 1, Accountant::dtor_calls);
+  ASSERT_EQ(kSmallSize, Accountant::copy_default_ctor_calls);
+
+  {
+    Accountant::ResetAll();
+    Deque<Accountant> d(kBigSize);
+    ASSERT_EQ(kBigSize, Accountant::default_ctor_calls);
+    ASSERT_EQ(0, Accountant::dtor_calls);
+    ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
+    ASSERT_EQ(kBigSize, d.size());
+  }
+
+  ASSERT_EQ(kBigSize, Accountant::default_ctor_calls);
+  ASSERT_EQ(kBigSize, Accountant::dtor_calls);
+  ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
+
+  {
+    Accountant::ResetAll();
+    Deque<Accountant> d(kBigSize, Accountant());
+    ASSERT_EQ(1, Accountant::default_ctor_calls);
+    ASSERT_EQ(1, Accountant::dtor_calls);
+    ASSERT_EQ(kBigSize, Accountant::copy_default_ctor_calls);
+    ASSERT_EQ(kBigSize, d.size());
+  }
+
+  ASSERT_EQ(1, Accountant::default_ctor_calls);
+  ASSERT_EQ(kBigSize + 1, Accountant::dtor_calls);
+  ASSERT_EQ(kBigSize, Accountant::copy_default_ctor_calls);
+}
 
-    d[0] = 0;
-    
-    for (int i = 0; i < 8; ++i) {
-        d.push_back(i);
-        d.push_front(i);
+TEST_F(ConstructorsTests, CopyConstructorWithAccountant) {
+  {
+    Deque<Accountant> d;
+    ASSERT_EQ(0, Accountant::default_ctor_calls);
+    ASSERT_EQ(0, Accountant::dtor_calls);
+    ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
+
+    Deque<Accountant> d2(d);
+    ASSERT_EQ(0, Accountant::default_ctor_calls);
+    ASSERT_EQ(0, Accountant::dtor_calls);
+    ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
+    ASSERT_EQ(0, d2.size());
+  }
+
+  ASSERT_EQ(0, Accountant::default_ctor_calls);
+  ASSERT_EQ(0, Accountant::dtor_calls);
+  ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
+
+  {
+    Accountant::ResetAll();
+    Deque<Accountant> d(kSmallSize);
+    ASSERT_EQ(kSmallSize, Accountant::default_ctor_calls);
+    ASSERT_EQ(0, Accountant::dtor_calls);
+    ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
+
+    Deque<Accountant> d2(d);
+    ASSERT_EQ(kSmallSize, Accountant::default_ctor_calls);
+    ASSERT_EQ(0, Accountant::dtor_calls);
+    ASSERT_EQ(kSmallSize, Accountant::copy_default_ctor_calls);
+    ASSERT_EQ(kSmallSize, d2.size());
+  }
+
+  ASSERT_EQ(kSmallSize, Accountant::default_ctor_calls);
+  ASSERT_EQ(2 * kSmallSize, Accountant::dtor_calls);
+  ASSERT_EQ(kSmallSize, Accountant::copy_default_ctor_calls);
+
+  {
+    Accountant::ResetAll();
+    Deque<Accountant> d(kBigSize);
+    ASSERT_EQ(kBigSize, Accountant::default_ctor_calls);
+    ASSERT_EQ(0, Accountant::dtor_calls);
+    ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
+
+    Deque<Accountant> d2(d);
+    ASSERT_EQ(kBigSize, Accountant::default_ctor_calls);
+    ASSERT_EQ(0, Accountant::dtor_calls);
+    ASSERT_EQ(kBigSize, Accountant::copy_default_ctor_calls);
+    ASSERT_EQ(kBigSize, d2.size());
+  }
+
+  ASSERT_EQ(kBigSize, Accountant::default_ctor_calls);
+  ASSERT_EQ(2 * kBigSize, Accountant::dtor_calls);
+  ASSERT_EQ(kBigSize, Accountant::copy_default_ctor_calls);
+}
+
+TEST_F(ConstructorsTests, SizeConstructor) {
+  {
+    UniqueDefaultConstructed::Reset();
+    Deque<UniqueDefaultConstructed> d(kSmallSize);
+
+    ASSERT_EQ(kSmallSize, UniqueDefaultConstructed::counter);
+    for (size_t i = 0; i < kSmallSize; ++i) {
+      ASSERT_EQ(i, d[i].number_);
     }
+  }
+
+  {
+    UniqueDefaultConstructed::Reset();
+    Deque<UniqueDefaultConstructed> d(kBigSize);
 
-    for (int i = 0; i < 12; ++i) {
-        d.pop_front();
+    ASSERT_EQ(kBigSize, UniqueDefaultConstructed::counter);
+    for (size_t i = 0; i < kBigSize; ++i) {
+      ASSERT_EQ(i, d[i].number_);
     }
-    
-    d.pop_back();
-    assert(d.size() == 4);
+  }
+
+  {
+    UniqueDefaultConstructed::Reset();
+    Deque<UniqueDefaultConstructed> d(kSmallSize, UniqueDefaultConstructed());
+
+    ASSERT_EQ(1, UniqueDefaultConstructed::counter);
+    for (size_t i = 0; i < kSmallSize; ++i) {
+      ASSERT_EQ(0, d[i].number_);
+    }
+  }
+
+  {
+    UniqueDefaultConstructed::Reset();
+    Deque<UniqueDefaultConstructed> d(kBigSize, UniqueDefaultConstructed());
+
+    ASSERT_EQ(1, UniqueDefaultConstructed::counter);
+    for (size_t i = 0; i < kBigSize; ++i) {
+      ASSERT_EQ(0, d[i].number_);
+    }
+  }
+}
 
-    std::string ss;
+TEST_F(ConstructorsTests, CopyConstructor) {
+  {
+    Unique::Reset();
+    Deque<Unique> d(kSmallSize);
+    Deque<Unique> d2(d);
 
-    for (size_t i = 0; i < d.size(); ++i) {
-        ss += std::to_string(d[i]);
+    for (size_t i = 0; i < kSmallSize; ++i) {
+      ASSERT_EQ(i, d[i].number_);
+      ASSERT_EQ(i + kSmallSize, d2[i].number_);
     }
-    
-    assert(ss == "3456");
+  }
+
+  {
+    Unique::Reset();
+    Deque<Unique> d(kBigSize);
+    Deque<Unique> d2(d);
+
+    for (size_t i = 0; i < kBigSize; ++i) {
+      ASSERT_EQ(i, d[i].number_);
+      ASSERT_EQ(i + kBigSize, d2[i].number_);
+    }
+  }
 }
 
-void test3() {
-    Deque<int> d;
+TEST_F(ConstructorsTests, InitializerListConstructor) {
+  {
+    Deque<int> d({1, 2, 3});
+    ASSERT_EQ(3, d.size());
+    ASSERT_EQ(1, d[0]);
+    ASSERT_EQ(2, d[1]);
+    ASSERT_EQ(3, d[2]);
+  }
+}
 
-    for (int i = 0; i < 1000; ++i) {
-        for (int j = 0; j < 1000; ++j) {
-            
-            if (j % 3 == 2) {
-                d.pop_back();
-            } else {
-                d.push_front(i*j);
-            }
+TEST_F(ConstructorsTests, CopyAssigment) {
+  {
+    Unique::Reset();
+    Deque<Unique> d(kSmallSize);
+    Deque<Unique> d2;
+    d2 = d;
 
-        }
+    for (size_t i = 0; i < kSmallSize; ++i) {
+      ASSERT_EQ(i, d[i].number_);
+      ASSERT_EQ(i + kSmallSize, d2[i].number_);
     }
+  }
 
-    assert(d.size() == 334'000);
+  {
+    Unique::Reset();
+    Deque<Unique> d(kBigSize);
+    Deque<Unique> d2;
+    d2 = d;
 
-    Deque<int>::iterator left = d.begin() + 100'000;
-    Deque<int>::iterator right = d.end() - 233'990;
-    while (d.begin() != left) d.pop_front();
-    while (d.end() != right) d.pop_back();
+    for (size_t i = 0; i < kBigSize; ++i) {
+      ASSERT_EQ(i, d[i].number_);
+      ASSERT_EQ(i + kBigSize, d2[i].number_);
+    }
+  }
+}
+
+TEST_F(ConstructorsTests, CopyAssigmentWithAccountant) {
+  {
+    Deque<Accountant> d;
+    ASSERT_EQ(0, Accountant::default_ctor_calls);
+    ASSERT_EQ(0, Accountant::dtor_calls);
+    ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
+
+    Deque<Accountant> d2;
+    d2 = d;
+    ASSERT_EQ(0, Accountant::default_ctor_calls);
+    ASSERT_EQ(0, Accountant::dtor_calls);
+    ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
+    ASSERT_EQ(0, d2.size());
+  }
+
+  ASSERT_EQ(0, Accountant::default_ctor_calls);
+  ASSERT_EQ(0, Accountant::dtor_calls);
+  ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
+
+  {
+    Accountant::ResetAll();
+    Deque<Accountant> d(kSmallSize);
+    ASSERT_EQ(kSmallSize, Accountant::default_ctor_calls);
+    ASSERT_EQ(0, Accountant::dtor_calls);
+    ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
+
+    Deque<Accountant> d2;
+    d2 = d;
+    ASSERT_EQ(kSmallSize, Accountant::default_ctor_calls);
+    ASSERT_EQ(0, Accountant::dtor_calls);
+    ASSERT_EQ(kSmallSize, Accountant::copy_default_ctor_calls);
+    ASSERT_EQ(kSmallSize, d2.size());
+  }
+
+  ASSERT_EQ(kSmallSize, Accountant::default_ctor_calls);
+  ASSERT_EQ(2 * kSmallSize, Accountant::dtor_calls);
+  ASSERT_EQ(kSmallSize, Accountant::copy_default_ctor_calls);
+
+  {
+    Accountant::ResetAll();
+    Deque<Accountant> d(kBigSize);
+    ASSERT_EQ(kBigSize, Accountant::default_ctor_calls);
+    ASSERT_EQ(0, Accountant::dtor_calls);
+    ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
+
+    Deque<Accountant> d2;
+    d2 = d;
+    ASSERT_EQ(kBigSize, Accountant::default_ctor_calls);
+    ASSERT_EQ(0, Accountant::dtor_calls);
+    ASSERT_EQ(kBigSize, Accountant::copy_default_ctor_calls);
+    ASSERT_EQ(kBigSize, d2.size());
+  }
+
+  ASSERT_EQ(kBigSize, Accountant::default_ctor_calls);
+  ASSERT_EQ(2 * kBigSize, Accountant::dtor_calls);
+  ASSERT_EQ(kBigSize, Accountant::copy_default_ctor_calls);
+}
 
-    assert(d.size() == 10);
+class IndexationTests : public ::testing::Test {
+protected:
+  const size_t kSmallSize = 10;
+  const size_t kBigSize = 10000000;
+  Deque<UniqueDefaultConstructed> smallDeque_;
+  Deque<UniqueDefaultConstructed> bigDeque_;
+
+  IndexationTests() {}
+  ~IndexationTests() {}
+
+  void SetUp() override {
+    Accountant::ResetAll();
+    Unique::Reset();
+    UniqueDefaultConstructed::Reset();
+    smallDeque_ = Deque<UniqueDefaultConstructed>(kSmallSize);
+    bigDeque_ = Deque<UniqueDefaultConstructed>(kBigSize);
+  }
+  void TearDown() override {
+    Accountant::ResetAll();
+    Unique::Reset();
+    UniqueDefaultConstructed::Reset();
+  }
+};
 
-    assert(right - left == 10);
+TEST_F(IndexationTests, IndexationReturnType) {
+  ASSERT_TRUE(
+      (std::is_same_v<Unique &,
+                      decltype(std::declval<Deque<Unique>>().operator[](0))>));
+  ASSERT_TRUE((std::is_same_v<
+               const Unique &,
+               decltype(std::declval<Deque<const Unique>>().operator[](0))>));
+  ASSERT_TRUE((
+      std::is_same_v<Unique &,
+                     decltype(std::declval<Deque<Unique> &>().operator[](0))>));
+  ASSERT_TRUE((std::is_same_v<
+               const Unique &,
+               decltype(std::declval<const Deque<Unique> &>().operator[](0))>));
+
+  ASSERT_TRUE(
+      (std::is_same_v<Unique &,
+                      decltype(std::declval<Deque<Unique>>().front())>));
+  ASSERT_TRUE(
+      (std::is_same_v<const Unique &,
+                      decltype(std::declval<Deque<const Unique>>().front())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Unique &,
+                      decltype(std::declval<Deque<Unique> &>().front())>));
+  ASSERT_TRUE((
+      std::is_same_v<const Unique &,
+                     decltype(std::declval<const Deque<Unique> &>().front())>));
+
+  ASSERT_TRUE((std::is_same_v<Unique &,
+                              decltype(std::declval<Deque<Unique>>().back())>));
+  ASSERT_TRUE(
+      (std::is_same_v<const Unique &,
+                      decltype(std::declval<Deque<const Unique>>().back())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Unique &,
+                      decltype(std::declval<Deque<Unique> &>().back())>));
+  ASSERT_TRUE(
+      (std::is_same_v<const Unique &,
+                      decltype(std::declval<const Deque<Unique> &>().back())>));
+
+  ASSERT_TRUE((
+      std::is_same_v<Unique &, decltype(std::declval<Deque<Unique>>().at(0))>));
+  ASSERT_TRUE(
+      (std::is_same_v<const Unique &,
+                      decltype(std::declval<Deque<const Unique>>().at(0))>));
+  ASSERT_TRUE(
+      (std::is_same_v<Unique &,
+                      decltype(std::declval<Deque<Unique> &>().at(0))>));
+  ASSERT_TRUE(
+      (std::is_same_v<const Unique &,
+                      decltype(std::declval<const Deque<Unique> &>().at(0))>));
+
+  ASSERT_THROW(smallDeque_.at(kSmallSize + 100), std::out_of_range);
+  ASSERT_THROW(bigDeque_.at(kBigSize + 100), std::out_of_range);
+  ASSERT_THROW(smallDeque_.at(-100), std::out_of_range);
+  ASSERT_THROW(bigDeque_.at(-100), std::out_of_range);
+}
 
-    std::string s;
-    for (auto it = left; it != right; ++it) {
-        ++*it;
+TEST_F(IndexationTests, IndexationSetAndGet) {
+  for (size_t i = 0; i < kSmallSize; ++i) {
+    ASSERT_EQ(i, smallDeque_[i].number_);
+  }
+
+  smallDeque_[2] = UniqueDefaultConstructed();
+  smallDeque_[5] = UniqueDefaultConstructed();
+  ASSERT_EQ(kSmallSize + kBigSize, smallDeque_[2].number_);
+  ASSERT_EQ(kSmallSize + kBigSize + 1, smallDeque_[5].number_);
+  for (size_t i = 0; i < kSmallSize; ++i) {
+    if (i != 2 && i != 5) {
+      ASSERT_EQ(i, smallDeque_[i].number_);
     }
-    for (auto it = right - 1; it >= left; --it) {
-        s += std::to_string(*it);
+  }
+
+  for (size_t i = 0; i < kBigSize; ++i) {
+    ASSERT_EQ(i + kSmallSize, bigDeque_[i].number_);
+  }
+
+  const int indices[] = {1, 127, 5556, 123123};
+  for (size_t i = 0; i < sizeof(indices) / sizeof(int); ++i) {
+    bigDeque_[indices[i]] = UniqueDefaultConstructed();
+  }
+
+  for (size_t i = 0; i < sizeof(indices) / sizeof(int); ++i) {
+    ASSERT_EQ(kSmallSize + kBigSize + 2 + i, bigDeque_[indices[i]].number_);
+  }
+  for (size_t i = 0; i < kBigSize; ++i) {
+    if (std::find(indices, indices + sizeof(indices) / sizeof(int), i) ==
+        indices + sizeof(indices) / sizeof(int)) {
+      ASSERT_EQ(kSmallSize + i, bigDeque_[i].number_);
     }
-    
-    assert(s == "51001518515355154401561015695158651595016120162051");
+  }
 }
 
-struct S {
-    int x = 0;
-    double y = 0.0;
+class PushPopTests : public ::testing::Test {
+protected:
+  const size_t kSmallSize = 10;
+  const size_t kBigSize = 10000000;
+  Deque<UniqueDefaultConstructed> smallDeque_;
+  Deque<UniqueDefaultConstructed> bigDeque_;
+
+  PushPopTests() {}
+  virtual ~PushPopTests() {}
+  virtual void SetUp() {
+    Accountant::ResetAll();
+    Unique::Reset();
+    UniqueDefaultConstructed::Reset();
+    smallDeque_ = Deque<UniqueDefaultConstructed>(kSmallSize);
+    bigDeque_ = Deque<UniqueDefaultConstructed>(kBigSize);
+  }
+  virtual void TearDown() {
+    Accountant::ResetAll();
+    Unique::Reset();
+    UniqueDefaultConstructed::Reset();
+  }
 };
 
-void test4() {
-    
-    Deque<S> d(5, {1, 2.0});
-    const Deque<S>& cd = d;
+TEST_F(PushPopTests, PushBackPopBack) {
+  ASSERT_EQ(kSmallSize, smallDeque_.size());
+  smallDeque_.push_back(UniqueDefaultConstructed());
+  ASSERT_EQ(kSmallSize + 1, smallDeque_.size());
+  UniqueDefaultConstructed last_element = smallDeque_.back();
+  smallDeque_.pop_back();
+  ASSERT_EQ(kSmallSize, smallDeque_.size());
+  ASSERT_EQ(kSmallSize + kBigSize, last_element.number_);
+
+  for (size_t i = 0; i < smallDeque_.size(); ++i) {
+    ASSERT_EQ(i, smallDeque_[i].number_);
+  }
 
-    static_assert(!std::is_assignable_v<decltype(*cd.begin()), S>);
-    static_assert(std::is_assignable_v<decltype(*d.begin()), S>);
-    static_assert(!std::is_assignable_v<decltype(*d.cbegin()), S>);
+  //---------------------------------------------------
 
-    static_assert(!std::is_assignable_v<decltype(*cd.end()), S>);
-    static_assert(std::is_assignable_v<decltype(*d.end()), S>);
-    static_assert(!std::is_assignable_v<decltype(*d.cend()), S>);
+  bigDeque_.push_back(UniqueDefaultConstructed());
+  ASSERT_EQ(kBigSize + 1, bigDeque_.size());
 
-    assert(cd.size() == 5);
+  UniqueDefaultConstructed last_big_element = bigDeque_.back();
+  bigDeque_.pop_back();
+  ASSERT_EQ(kBigSize, bigDeque_.size());
+  ASSERT_EQ(kSmallSize + kBigSize + 1, last_big_element.number_);
 
-    auto it = d.begin() + 2;
-    auto cit = cd.end() - 3;
+  for (size_t i = 0; i < bigDeque_.size(); ++i) {
+    ASSERT_EQ(i + kSmallSize, bigDeque_[i].number_);
+  }
+}
 
-    it->x = 5;
-    assert(cit->x == 5);
+TEST_F(PushPopTests, PushFrontPopFront) {
+  smallDeque_.push_front(UniqueDefaultConstructed());
 
-    d.erase(d.begin() + 1);
-    d.erase(d.begin() + 3);
-    assert(d.size() == 3);
+  ASSERT_EQ(kSmallSize + 1, smallDeque_.size());
 
-    auto dd = cd;
+  UniqueDefaultConstructed first_element = smallDeque_.front();
+  smallDeque_.pop_front();
 
-    dd.pop_back();
-    dd.insert(dd.begin(), {3, 4.0});
-    dd.insert(dd.begin() + 2, {4, 5.0});
+  ASSERT_EQ(kSmallSize, smallDeque_.size());
+  ASSERT_EQ(kSmallSize + kBigSize, first_element.number_);
 
-    std::string s;
-    for (const auto& x: dd) {
-        s += std::to_string(x.x);
-    }
-    assert(s == "3145");
+  for (size_t i = 0; i < smallDeque_.size(); ++i) {
+    ASSERT_EQ(i, smallDeque_[i].number_);
+  }
+
+  //------------------------------------------------------------------------------
+
+  bigDeque_.push_front(UniqueDefaultConstructed());
+  ASSERT_EQ(kBigSize + 1, bigDeque_.size());
+  UniqueDefaultConstructed first_big_element = bigDeque_.front();
+  bigDeque_.pop_front();
+  ASSERT_EQ(kBigSize, bigDeque_.size());
+  ASSERT_EQ(kSmallSize + kBigSize + 1, first_big_element.number_);
 
-    std::string ss;
-    for (const auto& x: d) {
-        ss += std::to_string(x.x);
+  for (size_t i = 0; i < bigDeque_.size(); ++i) {
+    ASSERT_EQ(i + kSmallSize, bigDeque_[i].number_);
+  }
+}
+
+TEST_F(PushPopTests, ManyPushAndPops) {
+  for (size_t i = 0; i < 100000; ++i) {
+    bigDeque_.push_back(UniqueDefaultConstructed());
+    bigDeque_.push_front(UniqueDefaultConstructed());
+    bigDeque_.pop_back();
+    bigDeque_.pop_front();
+  }
+
+  ASSERT_EQ(kBigSize, bigDeque_.size());
+
+  Deque<int> d;
+  for (int i = 0; i < 1000; ++i) {
+    for (int j = 0; j < 1000; ++j) {
+
+      if (j % 3 == 2) {
+        d.pop_back();
+      } else {
+        d.push_front(i * j);
+      }
     }
-    assert(ss == "151");
+  }
+
+  ASSERT_EQ(334'000, d.size());
+
+  for (size_t i = 0; i < 100000; ++i) {
+    d.pop_front();
+  }
+
+  for (size_t i = 0; i < 233'990; ++i) {
+    d.pop_back();
+  }
+
+  ASSERT_EQ(10, d.size());
+  const int result[] = {62050, 61200, 59500, 58650, 56950,
+                        56100, 54400, 53550, 51850, 51000};
+  for (size_t i = 0; i < 10; ++i) {
+    ASSERT_EQ(result[i], d[i]);
+  }
+}
+
+class IteratorsTests : public ::testing::Test {
+protected:
+  const size_t kSmallSize = 10;
+  const size_t kBigSize = 10000000;
+  Deque<UniqueDefaultConstructed> smallDeque_;
+
+  IteratorsTests() {}
+  virtual ~IteratorsTests() {}
+  virtual void SetUp() {
+    Accountant::ResetAll();
+    Unique::Reset();
+    UniqueDefaultConstructed::Reset();
+    smallDeque_ = Deque<UniqueDefaultConstructed>(kSmallSize);
+  }
+  virtual void TearDown() {
+    Accountant::ResetAll();
+    Unique::Reset();
+    UniqueDefaultConstructed::Reset();
+  }
+};
+
+TEST_F(IteratorsTests, IteratorTypes) {
+  ASSERT_TRUE((std::is_same_v<std::reverse_iterator<Deque<Unique>::iterator>,
+                              Deque<Unique>::reverse_iterator>));
+  ASSERT_TRUE(
+      (std::is_same_v<std::reverse_iterator<Deque<Unique>::const_iterator>,
+                      Deque<Unique>::const_reverse_iterator>));
+
+  ASSERT_TRUE((
+      std::is_same_v<Unique &, decltype(std::declval<Deque<Unique>::iterator>().
+                                        operator*())>));
+  ASSERT_TRUE(
+      (std::is_same_v<const Unique &,
+                      decltype(std::declval<Deque<Unique>::const_iterator>().
+                               operator*())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Unique &,
+                      decltype(std::declval<Deque<Unique>::reverse_iterator>().
+                               operator*())>));
+  ASSERT_TRUE((std::is_same_v<
+               const Unique &,
+               decltype(std::declval<Deque<Unique>::const_reverse_iterator>().
+                        operator*())>));
+
+  ASSERT_TRUE(
+      (std::is_same_v<
+          Unique *,
+          decltype(std::declval<Deque<Unique>::iterator>().operator->())>));
+  ASSERT_TRUE((std::is_same_v<
+               const Unique *,
+               decltype(std::declval<Deque<Unique>::const_iterator>().
+                        operator->())>));
+  ASSERT_TRUE(
+      (std::is_same_v<
+          Unique *,
+          decltype(std::declval<Deque<Unique>::reverse_iterator>().
+                   operator->())>));
+  ASSERT_TRUE((std::is_same_v<
+               const Unique *,
+               decltype(std::declval<Deque<Unique>::const_reverse_iterator>()
+                            .
+                            operator->())>));
+
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::iterator,
+                      decltype(std::declval<Deque<Unique>>().begin())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_iterator,
+                      decltype(std::declval<const Deque<Unique>>().begin())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::iterator,
+                      decltype(std::declval<Deque<Unique> &>().begin())>));
+  ASSERT_TRUE((
+      std::is_same_v<Deque<Unique>::const_iterator,
+                     decltype(std::declval<const Deque<Unique> &>().begin())>));
+
+  ASSERT_TRUE((std::is_same_v<Deque<Unique>::iterator,
+                              decltype(std::declval<Deque<Unique>>().end())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_iterator,
+                      decltype(std::declval<const Deque<Unique>>().end())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::iterator,
+                      decltype(std::declval<Deque<Unique> &>().end())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_iterator,
+                      decltype(std::declval<const Deque<Unique> &>().end())>));
+
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_iterator,
+                      decltype(std::declval<Deque<Unique>>().cbegin())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_iterator,
+                      decltype(std::declval<const Deque<Unique>>().cbegin())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_iterator,
+                      decltype(std::declval<Deque<Unique> &>().cbegin())>));
+  ASSERT_TRUE((std::is_same_v<
+               Deque<Unique>::const_iterator,
+               decltype(std::declval<const Deque<Unique> &>().cbegin())>));
+
+  ASSERT_TRUE((std::is_same_v<Deque<Unique>::const_iterator,
+                              decltype(std::declval<Deque<Unique>>().cend())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_iterator,
+                      decltype(std::declval<const Deque<Unique>>().cend())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_iterator,
+                      decltype(std::declval<Deque<Unique> &>().cend())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_iterator,
+                      decltype(std::declval<const Deque<Unique> &>().cend())>));
+
+  // reverse
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::reverse_iterator,
+                      decltype(std::declval<Deque<Unique>>().rbegin())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
+                      decltype(std::declval<const Deque<Unique>>().rbegin())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::reverse_iterator,
+                      decltype(std::declval<Deque<Unique> &>().rbegin())>));
+  ASSERT_TRUE((std::is_same_v<
+               Deque<Unique>::const_reverse_iterator,
+               decltype(std::declval<const Deque<Unique> &>().rbegin())>));
+
+  ASSERT_TRUE((std::is_same_v<Deque<Unique>::reverse_iterator,
+                              decltype(std::declval<Deque<Unique>>().rend())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
+                      decltype(std::declval<const Deque<Unique>>().rend())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::reverse_iterator,
+                      decltype(std::declval<Deque<Unique> &>().rend())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
+                      decltype(std::declval<const Deque<Unique> &>().rend())>));
+
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
+                      decltype(std::declval<Deque<Unique>>().crbegin())>));
+  ASSERT_TRUE((
+      std::is_same_v<Deque<Unique>::const_reverse_iterator,
+                     decltype(std::declval<const Deque<Unique>>().crbegin())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
+                      decltype(std::declval<Deque<Unique> &>().crbegin())>));
+  ASSERT_TRUE((std::is_same_v<
+               Deque<Unique>::const_reverse_iterator,
+               decltype(std::declval<const Deque<Unique> &>().crbegin())>));
+
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
+                      decltype(std::declval<Deque<Unique>>().crend())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
+                      decltype(std::declval<const Deque<Unique>>().crend())>));
+  ASSERT_TRUE(
+      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
+                      decltype(std::declval<Deque<Unique> &>().crend())>));
+  ASSERT_TRUE((
+      std::is_same_v<Deque<Unique>::const_reverse_iterator,
+                     decltype(std::declval<const Deque<Unique> &>().crend())>));
+
+  ASSERT_TRUE((std::is_convertible_v<Deque<Unique>::iterator,
+                                     Deque<Unique>::const_iterator>));
+  ASSERT_TRUE((!std::is_convertible_v<Deque<Unique>::const_iterator,
+                                      Deque<Unique>::iterator>));
 }
 
-void test5() {
-    Deque<int> d;
+template <typename Iter, typename T> void testIteratorArithmeticTypes() {
+  using traits = std::iterator_traits<Iter>;
+
+  ASSERT_TRUE((std::is_same_v<decltype(std::declval<Iter>()++), Iter>));
+  ASSERT_TRUE((std::is_same_v<decltype(++std::declval<Iter>()), Iter &>));
+  ASSERT_TRUE((std::is_same_v<decltype(std::declval<Iter>() + 5), Iter>));
+  ASSERT_TRUE((std::is_same_v<decltype(std::declval<Iter>() += 5), Iter &>));
+
+  ASSERT_TRUE(
+      (std::is_same_v<decltype(std::declval<Iter>() - std::declval<Iter>()),
+                      typename traits::difference_type>));
+  ASSERT_TRUE((std::is_same_v<decltype(*std::declval<Iter>()), T &>));
+
+  ASSERT_TRUE(
+      (std::is_same_v<decltype(std::declval<Iter>() < std::declval<Iter>()),
+                      bool>));
+  ASSERT_TRUE(
+      (std::is_same_v<decltype(std::declval<Iter>() <= std::declval<Iter>()),
+                      bool>));
+  ASSERT_TRUE(
+      (std::is_same_v<decltype(std::declval<Iter>() > std::declval<Iter>()),
+                      bool>));
+  ASSERT_TRUE(
+      (std::is_same_v<decltype(std::declval<Iter>() >= std::declval<Iter>()),
+                      bool>));
+  ASSERT_TRUE(
+      (std::is_same_v<decltype(std::declval<Iter>() == std::declval<Iter>()),
+                      bool>));
+  ASSERT_TRUE(
+      (std::is_same_v<decltype(std::declval<Iter>() != std::declval<Iter>()),
+                      bool>));
+}
 
-    d.push_back(1);
-    d.push_front(2);
+TEST_F(IteratorsTests, IteratorArithmeticsTypes) {
+  testIteratorArithmeticTypes<Deque<Unique>::iterator, Unique>();
+  testIteratorArithmeticTypes<Deque<Unique>::const_iterator, const Unique>();
+  testIteratorArithmeticTypes<Deque<Unique>::reverse_iterator, Unique>();
+  testIteratorArithmeticTypes<Deque<Unique>::const_reverse_iterator,
+                              const Unique>();
+}
 
-    auto left_ptr = &*d.begin();
-    auto right_ptr = &*(d.end()-1);
+TEST_F(IteratorsTests, IteratorArithmetics) {
 
-    d.push_back(3);
-    d.push_front(4);
-    auto left = *d.begin();
-    auto right = *(d.end()-1);
+  ASSERT_EQ(smallDeque_.begin() + smallDeque_.size(), smallDeque_.end());
+  ASSERT_EQ(smallDeque_.end() - smallDeque_.begin(), smallDeque_.size());
+  ASSERT_EQ(smallDeque_.end() - smallDeque_.size(), smallDeque_.begin());
 
-    for (int i = 0; i < 10'000; ++i) {
-        d.push_back(i);
+  {
+    auto iter = smallDeque_.begin();
+    for (size_t i = 0; i < smallDeque_.size(); ++i) {
+      ASSERT_EQ(iter, smallDeque_.begin() + i);
+      ++iter;
+    }
+    ASSERT_EQ(iter, smallDeque_.end());
+  }
+
+  {
+    auto iter = smallDeque_.begin();
+    for (size_t i = 0; i < smallDeque_.size(); ++i) {
+      ASSERT_EQ(iter->number_, smallDeque_[i].number_);
+      ++iter;
     }
-    for (int i = 0; i < 20'000; ++i) {
-        d.push_front(i);
+  }
+
+  {
+    auto iter = smallDeque_.end() - 1;
+    for (size_t i = 0; i < smallDeque_.size(); ++i) {
+      ASSERT_EQ(iter->number_, smallDeque_[smallDeque_.size() - 1 - i].number_);
+      if (i < smallDeque_.size() - 1) {
+        --iter;
+      }
     }
-    
-    std::string s;
-    s += std::to_string(left);
-    s += std::to_string(right);
+  }
 
-    s += std::to_string(*left_ptr);
-    s += std::to_string(*right_ptr);
-    //for (auto it = left; it <= right; ++it) {
-    //    s += std::to_string(*it);
-    //}
-    assert(s == "4321");
+  {
+    auto iter_incr = smallDeque_.begin();
+    auto iter_plus = smallDeque_.begin();
+    for (; iter_incr != smallDeque_.end(); ++iter_incr, iter_plus += 1) {
+      ASSERT_EQ(iter_incr, iter_plus);
+    }
+  }
+
+  {
+    for (size_t step = 1; step < smallDeque_.size(); ++step) {
+      auto iter = smallDeque_.begin();
+      for (size_t i = 0; i < smallDeque_.size(); i += step) {
+        ASSERT_EQ(i, (iter + i)->number_);
+      }
+    }
+  }
 }
 
-struct VerySpecialType {
-    int x = 0;
+TEST_F(IteratorsTests, IteratorComparison) {
+  {
+    for (size_t i = 0; i < smallDeque_.size(); ++i) {
+      ASSERT_GT(smallDeque_.end(), smallDeque_.begin() + i);
+      ASSERT_GT(smallDeque_.cend(), smallDeque_.cbegin() + i);
+      ASSERT_GT(smallDeque_.rend(), smallDeque_.rbegin() + i);
+      ASSERT_GT(smallDeque_.crend(), smallDeque_.crbegin() + i);
+    }
 
-    explicit VerySpecialType(int x): x(x) {}
-};
+    ASSERT_EQ(smallDeque_.end(), smallDeque_.begin() + smallDeque_.size());
+    ASSERT_EQ(smallDeque_.cend(), smallDeque_.cbegin() + smallDeque_.size());
+    ASSERT_EQ(smallDeque_.rend(), smallDeque_.rbegin() + smallDeque_.size());
+    ASSERT_EQ(smallDeque_.crend(), smallDeque_.crbegin() + smallDeque_.size());
+  }
+
+  {
+    Deque<Unique> empty;
+    ASSERT_EQ(empty.end() - empty.begin(), 0);
+    ASSERT_EQ(empty.begin() + 0, empty.end());
+    ASSERT_EQ(empty.end() - 0, empty.begin());
+
+    ASSERT_EQ(empty.rend() - empty.rbegin(), 0);
+    ASSERT_EQ(empty.rbegin() + 0, empty.rend());
+    ASSERT_EQ(empty.rend() - 0, empty.rbegin());
+
+    ASSERT_EQ(empty.cend() - empty.cbegin(), 0);
+    ASSERT_EQ(empty.cbegin() + 0, empty.cend());
+    ASSERT_EQ(empty.cend() - 0, empty.cbegin());
+
+    ASSERT_EQ(empty.crend() - empty.crbegin(), 0);
+    ASSERT_EQ(empty.crbegin() + 0, empty.crend());
+    ASSERT_EQ(empty.crend() - 0, empty.crbegin());
+  }
+}
 
-struct NotDefaultConstructible {
-    NotDefaultConstructible() = delete;
-    NotDefaultConstructible(const NotDefaultConstructible&) = default;
-    NotDefaultConstructible& operator=(const NotDefaultConstructible&) = default;
+TEST_F(IteratorsTests, IteratorsAlgorithms) {
+  Deque<int> d(1000);
+  std::iota(d.begin(), d.end(), 13);
+  std::mt19937 g(31415);
+  std::shuffle(d.begin(), d.end(), g);
+  std::sort(d.rbegin(), d.rbegin() + 500);
+  std::reverse(d.begin(), d.end());
+  auto sorted_border = std::is_sorted_until(d.begin(), d.end());
+  ASSERT_EQ(sorted_border - d.begin(), 500);
+}
 
-    NotDefaultConstructible(VerySpecialType v): x(v.x) {}
+TEST_F(IteratorsTests, IteratorsInvalidationAfterPop) {
+  {
+    auto iter = smallDeque_.begin();
+    for (size_t i = 0; i < smallDeque_.size(); ++i) {
+      ASSERT_EQ(iter->number_, smallDeque_[i].number_);
+      ++iter;
+    }
+  }
 
-public:
-    int x = 0;
-};
+  {
+    std::vector<Deque<UniqueDefaultConstructed>::iterator> iterators;
+    for (size_t i = 0; i <= smallDeque_.size(); ++i) {
+      iterators.push_back(smallDeque_.begin() + i);
+    }
 
-void test6() {
-    Deque<NotDefaultConstructible> d;
-    
-    NotDefaultConstructible ndc = VerySpecialType(-1);
+    size_t start = 0, end = smallDeque_.size();
+    while (start < end) {
+      smallDeque_.pop_front();
+      ++start;
+      for (size_t i = start; i < end; ++i) {
+        ASSERT_EQ(iterators[i]->number_, i);
+        ASSERT_EQ(iterators[i], smallDeque_.begin() + i - start);
+        ASSERT_EQ(&*iterators[i], &smallDeque_[i - start]);
+      }
+      ASSERT_EQ(iterators[end], smallDeque_.end());
+    }
+  }
 
-    for (int i = 0; i < 1500; ++i) {
-        ++ndc.x;
-        d.push_back(ndc);
+  {
+    std::vector<Deque<UniqueDefaultConstructed>::iterator> iterators;
+    for (size_t i = 0; i <= smallDeque_.size(); ++i) {
+      iterators.push_back(smallDeque_.begin() + i);
     }
 
-    assert(d.size() == 1500);
+    size_t start = 0, end = smallDeque_.size();
+    while (start < end) {
+      smallDeque_.pop_back();
+      --end;
+      for (size_t i = start; i < end; ++i) {
+        ASSERT_EQ(iterators[i]->number_, i);
+        ASSERT_EQ(iterators[i], smallDeque_.begin() + i - start);
+        ASSERT_EQ(&*iterators[i], &smallDeque_[i - start]);
+      }
+      ASSERT_EQ(iterators[end], smallDeque_.end());
+    }
+  }
 
-    for (int i = 0; i < 1300; ++i) {
-        d.pop_front();
+  {
+    std::vector<Deque<UniqueDefaultConstructed>::iterator> iterators;
+    for (size_t i = 0; i <= smallDeque_.size(); ++i) {
+      iterators.push_back(smallDeque_.begin() + i);
     }
 
-    assert(d.size() == 200);
+    size_t start = 0, end = smallDeque_.size();
+    for (size_t round = 0; start < end; ++round) {
+      if (round % 2 == 0) {
+        smallDeque_.pop_back();
+        --end;
+      } else {
+        smallDeque_.pop_front();
+        ++start;
+      }
+
+      for (size_t i = start; i < end; ++i) {
+        ASSERT_EQ(iterators[i]->number_, i);
+        ASSERT_EQ(iterators[i], smallDeque_.begin() + i - start);
+        ASSERT_EQ(&*iterators[i], &smallDeque_[i - start]);
+      }
+      ASSERT_EQ(iterators[end], smallDeque_.end());
+    }
+  }
+}
 
-    assert(d[99].x == 1399);
+TEST_F(IteratorsTests, PointerAndReferenceInvalidationAfterPush) {
+  {
+    std::vector<UniqueDefaultConstructed *> pointers;
+    for (size_t i = 0; i < smallDeque_.size(); ++i) {
+      pointers.push_back(&smallDeque_[i]);
+    }
 
-    d[100] = VerySpecialType(0);
-    assert(d[100].x == 0);
+    size_t start = 0, end = smallDeque_.size();
+    for (size_t round = 0; round < 100; ++round) {
+      if (round % 2 == 0) {
+        smallDeque_.push_back(UniqueDefaultConstructed());
+      } else {
+        smallDeque_.push_front(UniqueDefaultConstructed());
+        ++start;
+        ++end;
+      }
+
+      for (size_t i = start; i < end; ++i) {
+        ASSERT_EQ(pointers[i - start]->number_, i - start);
+        ASSERT_EQ(pointers[i - start], &smallDeque_[i]);
+        ASSERT_EQ(pointers[i - start], &*(smallDeque_.begin() + i));
+      }
+    }
+  }
 }
 
+class InsertEraseTests : public ::testing::Test {
+protected:
+  const size_t kSmallSize = 10;
+  const size_t kBigSize = 10000000;
+  Deque<UniqueDefaultConstructed> smallDeque_;
+  Deque<UniqueDefaultConstructed> bigDeque_;
+
+  InsertEraseTests() {}
+  virtual ~InsertEraseTests() {}
+  virtual void SetUp() {
+    Accountant::ResetAll();
+    Unique::Reset();
+    UniqueDefaultConstructed::Reset();
+    smallDeque_ = Deque<UniqueDefaultConstructed>(kSmallSize);
+    bigDeque_ = Deque<UniqueDefaultConstructed>(kBigSize);
+  }
+  virtual void TearDown() {
+    Accountant::ResetAll();
+    Unique::Reset();
+    UniqueDefaultConstructed::Reset();
+  }
+};
 
-struct Explosive {
-    int x = 0;
-    Explosive(int x): x(x) {}
-    Explosive(const Explosive&) {
-        if (x) throw std::runtime_error("Boom!");
+TEST_F(InsertEraseTests, InsertErase) {
+  {
+    smallDeque_.insert(smallDeque_.begin() + kSmallSize / 2,
+                       UniqueDefaultConstructed());
+    ASSERT_EQ(kSmallSize + 1, smallDeque_.size());
+    for (size_t i = 0; i < kSmallSize / 2; ++i) {
+      ASSERT_EQ(i, smallDeque_[i].number_);
     }
-};
+    ASSERT_EQ(kSmallSize + kBigSize, smallDeque_[kSmallSize / 2].number_);
+    for (size_t i = kSmallSize / 2; i < kSmallSize; ++i) {
+      ASSERT_EQ(i, smallDeque_[i + 1].number_);
+    }
+  }
+
+  {
+    bigDeque_.insert(bigDeque_.begin() + kBigSize / 2,
+                     UniqueDefaultConstructed());
+    ASSERT_EQ(kBigSize + 1, bigDeque_.size());
+    for (size_t i = 0; i < kBigSize / 2; ++i) {
+      ASSERT_EQ(i + kSmallSize, bigDeque_[i].number_);
+    }
+    ASSERT_EQ(kSmallSize + kBigSize + 1, bigDeque_[kBigSize / 2].number_);
+    for (size_t i = kBigSize / 2; i < kBigSize; ++i) {
+      ASSERT_EQ(i + kSmallSize, bigDeque_[i + 1].number_);
+    }
+  }
+
+  {
+    smallDeque_.erase(smallDeque_.begin() + kSmallSize / 2 - 1);
+    ASSERT_EQ(kSmallSize, smallDeque_.size());
+    for (size_t i = 0; i < kSmallSize / 2 - 1; ++i) {
+      ASSERT_EQ(i, smallDeque_[i].number_);
+    }
+    ASSERT_EQ(kSmallSize + kBigSize, smallDeque_[kSmallSize / 2 - 1].number_);
+    for (size_t i = kSmallSize / 2; i < kSmallSize; ++i) {
+      ASSERT_EQ(i, smallDeque_[i].number_);
+    }
+  }
 
-void test7() {
+  {
+    bigDeque_.erase(bigDeque_.begin() + kBigSize / 2 - 1);
+    ASSERT_EQ(kBigSize, bigDeque_.size());
+    for (size_t i = 0; i < kBigSize / 2 - 1; ++i) {
+      ASSERT_EQ(i + kSmallSize, bigDeque_[i].number_);
+    }
+    ASSERT_EQ(kSmallSize + kBigSize + 1, bigDeque_[kBigSize / 2 - 1].number_);
+    for (size_t i = kBigSize / 2; i < kBigSize; ++i) {
+      ASSERT_EQ(i + kSmallSize, bigDeque_[i].number_);
+    }
+  }
+}
+
+class ExceptionTests : public ::testing::Test {
+protected:
+  const size_t kSmallSize = 10;
+  const size_t kBigSize = 10000000;
 
-    Deque<Explosive> d;
-    d.push_back(Explosive(0));
+  struct CountedException : public std::exception {};
 
-    for (int i = 0; i < 30'000; ++i) {
-        auto it = d.begin();
-        auto x = it->x;
-        size_t sz = d.size();
-        try {
-            if (i % 2)
-                d.push_back(Explosive(1));
-            else
-                d.push_front(Explosive(1));
-        } catch (...) {
-            assert(it == d.begin());
-            assert(d.begin()->x == x);
-            assert(d.size() == sz);
-        }
+  template <int when_throw> struct Counted {
+    inline static int counter = 0;
 
-        d.push_back(Explosive(0));
+    Counted() {
+      ++counter;
+      if (counter == when_throw) {
+        --counter;
+        throw CountedException();
+      }
     }
 
-}
+    Counted(const Counted &) : Counted() {}
+
+    ~Counted() { --counter; }
+  };
+
+  struct Explosive {
+    struct Safeguard {};
+
+    inline static bool exploded = false;
+
+    Explosive() : should_explode(true) { throw 1; }
+
+    Explosive(Safeguard) : should_explode(false) {}
+
+    Explosive(const Explosive &) : should_explode(true) { throw 2; }
 
-} // tests by mesyarik
+    Explosive &operator=(const Explosive &) { return *this; }
 
-namespace TestsByUnrealf1 {
-    struct Fragile {
-        Fragile(int durability, int data): durability(durability), data(data) {}
-        ~Fragile() = default;
-        
-        // for std::swap
-        Fragile(Fragile&& other): Fragile() {
-            *this = other;
-        }
+    ~Explosive() { exploded |= should_explode; }
 
-        Fragile(const Fragile& other): Fragile() {
-            *this = other;
-        }
+  private:
+    const bool should_explode;
+  };
 
-        Fragile& operator=(const Fragile& other) {
-            durability = other.durability - 1;
-            data = other.data;
-            if (durability <= 0) {
-                throw 2;
-            }
-            return *this;
-        }
-
-        int durability;
-        int data;
-    private:
-        Fragile() {
-
-        }
-    };
-
-    struct Explosive {
-        struct Safeguard {};
-
-        inline static bool exploded = false;
-
-        Explosive(): should_explode(true) {
-            throw 1;
-        }
-
-        Explosive(Safeguard): should_explode(false) {
-
-        }
-
-        Explosive(const Explosive&): should_explode(true) {
-            throw 2;
-        }
-
-        //TODO: is this ok..?
-        Explosive& operator=(const Explosive&) {return *this;}
-
-        ~Explosive() {
-            exploded |= should_explode;
-        }
-
-    private:
-        const bool should_explode;
-    };
-
-    struct DefaultConstructible {
-        DefaultConstructible() {
-            data = default_data;
-        }
-
-        int data = default_data;
-        inline static const int default_data = 117;
-    };
-
-    struct NotDefaultConstructible {
-        NotDefaultConstructible() = delete;
-        NotDefaultConstructible(int input): data(input) {}
-        int data;
-
-        auto operator<=>(const NotDefaultConstructible&) const = default;
-    };
-
-    struct CountedException : public std::exception {
-
-    };
-
-    template<int when_throw>
-    struct Counted {
-        inline static int counter = 0;
-
-        Counted() {
-            ++counter;
-            if (counter == when_throw) {
-                --counter;
-                throw CountedException();
-            }
-        }
-
-        Counted(const Counted&): Counted() { }
-
-        ~Counted() {
-            --counter;
-        }
-    };
-
-    template<typename iter, typename T>
-    struct CheckIter{
-        using traits = std::iterator_traits<iter>;
-
-        static_assert(std::is_same_v<std::remove_cv_t<typename traits::value_type>, std::remove_cv_t<T>>);
-        static_assert(std::is_same_v<typename traits::pointer, T*>);
-        static_assert(std::is_same_v<typename traits::reference, T&>);
-        static_assert(std::is_same_v<typename traits::iterator_category, std::random_access_iterator_tag>);
-
-        static_assert(std::is_same_v<decltype(std::declval<iter>()++), iter>);
-        static_assert(std::is_same_v<decltype(++std::declval<iter>()), iter&>);
-        static_assert(std::is_same_v<decltype(std::declval<iter>() + 5), iter>);
-        static_assert(std::is_same_v<decltype(std::declval<iter>() += 5), iter&>);
-
-        static_assert(std::is_same_v<decltype(std::declval<iter>() - std::declval<iter>()), typename traits::difference_type>);
-        static_assert(std::is_same_v<decltype(*std::declval<iter>()), T&>);
-        
-        static_assert(std::is_same_v<decltype(std::declval<iter>() < std::declval<iter>()), bool>);
-        static_assert(std::is_same_v<decltype(std::declval<iter>() <= std::declval<iter>()), bool>);
-        static_assert(std::is_same_v<decltype(std::declval<iter>() > std::declval<iter>()), bool>);
-        static_assert(std::is_same_v<decltype(std::declval<iter>() >= std::declval<iter>()), bool>);
-        static_assert(std::is_same_v<decltype(std::declval<iter>() == std::declval<iter>()), bool>);
-        static_assert(std::is_same_v<decltype(std::declval<iter>() != std::declval<iter>()), bool>);
-    };
-
-    void testDefault() {
-        Deque<int> defaulted;
-        assert((defaulted.size() == 0));
-        Deque<NotDefaultConstructible> without_default;
-        assert((without_default.size() == 0));
-    }
-
-    void testCopy() {
-        Deque<NotDefaultConstructible> without_default;
-        Deque<NotDefaultConstructible> copy = without_default;
-        assert((copy.size() == 0));
-    }
-
-    void testWithSize() {
-        int size = 17;
-        int value = 14;
-        Deque<int> simple(size);
-        assert((simple.size() == size_t(size)) && std::all_of(simple.begin(), simple.end(), [](int item){ return item == 0; }));
-        Deque<NotDefaultConstructible> less_simple(size, value);
-        assert((less_simple.size() == size_t(size)) && std::all_of(less_simple.begin(), less_simple.end(), [&](const auto& item){ 
-                    return item.data == value; 
-        }));
-        Deque<DefaultConstructible> default_constructor(size);
-        assert(std::all_of(default_constructor.begin(), default_constructor.end(), [](const auto& item) { 
-                    return item.data == DefaultConstructible::default_data;
-        }));
-    }
-
-    void testAssignment(){ 
-        Deque<int> first(10, 10);
-        Deque<int> second(9, 9);
-        first = second;
-        assert((first.size() == second.size()) && (first.size() == 9) && std::equal(first.begin(), first.end(), second.begin()));
-    }
-
-    void testStaticAsserts() {
-        using T1 = int;
-        using T2 = NotDefaultConstructible;
-
-        static_assert(std::is_default_constructible_v<Deque<T1>>, "should have default constructor");
-        static_assert(std::is_default_constructible_v<Deque<T2>>, "should have default constructor");
-        static_assert(std::is_copy_constructible_v<Deque<T1> >, "should have copy constructor");
-        static_assert(std::is_copy_constructible_v<Deque<T2> >, "should have copy constructor");
-        //static_assert(std::is_constructible_v<Deque<T1>, int>, "should have constructor from int");
-        //static_assert(std::is_constructible_v<Deque<T2>, int>, "should have constructor from int");
-        static_assert(std::is_constructible_v<Deque<T1>, int, const T1&>, "should have constructor from int and const T&");
-        static_assert(std::is_constructible_v<Deque<T2>, int, const T2&>, "should have constructor from int and const T&");
-
-        static_assert(std::is_copy_assignable_v<Deque<T1>>, "should have assignment operator");
-        static_assert(std::is_copy_assignable_v<Deque<T2>>, "should have assignment operator");
-    }
-        
-    void testOperatorSubscript() {
-        Deque<size_t> defaulted(1300, 43);
-        assert((defaulted[0] == defaulted[1280]) && (defaulted[0] == 43));
-        assert((defaulted.at(0) == defaulted[1280]) && (defaulted.at(0) == 43));
-        int caught = 0;
-
-        try {
-            defaulted.at(size_t(-1));
-        } catch (std::out_of_range& e) {
-            ++caught;
-        }
-
-        try {
-            defaulted.at(1300);
-        } catch (std::out_of_range& e) {
-            ++caught;
-        }
-
-        assert(caught == 2);
-    }
-
-    void testStaticAssertsAccess() {
-        Deque<size_t> defaulted;
-        const Deque<size_t> constant;
-        static_assert(std::is_same_v<decltype(defaulted[0]), size_t&>);
-        static_assert(std::is_same_v<decltype(defaulted.at(0)), size_t&>);
-        static_assert(std::is_same_v<decltype(constant[0]), const size_t&>);
-        static_assert(std::is_same_v<decltype(constant.at(0)), const size_t&>);
-
-        //static_assert(noexcept(defaulted[0]), "operator[] should not throw");
-        static_assert(!noexcept(defaulted.at(0)), "at() can throw");
-
-    }
-
-
-    void testStaticAssertsIterators() {
-        CheckIter<Deque<int>::iterator, int> iter;
-        std::ignore = iter;
-        CheckIter<decltype(std::declval<Deque<int>>().rbegin()), int> reverse_iter;
-        std::ignore = reverse_iter;
-        CheckIter<decltype(std::declval<Deque<int>>().cbegin()), const int> const_iter;
-        std::ignore = const_iter;
-
-        static_assert(std::is_convertible_v<
-                decltype(std::declval<Deque<int>>().begin()), 
-                decltype(std::declval<Deque<int>>().cbegin()) 
-                >, "should be able to construct const iterator from non const iterator");
-        static_assert(!std::is_convertible_v<
-                decltype(std::declval<Deque<int>>().cbegin()), 
-                decltype(std::declval<Deque<int>>().begin()) 
-                >, "should NOT be able to construct iterator from const iterator");
-    }
-
-    void testIteratorsArithmetic() {
-        Deque<int> empty;
-        assert((empty.end() - empty.begin()) == 0);
-        assert((empty.begin() + 0 == empty.end()) && (empty.end() - 0 == empty.begin()));
-
-        Deque<int> one(1);
-        auto iter2 = one.end();
-        assert(((--iter2) == one.begin()));
-
-        assert((empty.rend() - empty.rbegin()) == 0);
-        assert((empty.rbegin() + 0 == empty.rend()) && (empty.rend() - 0 == empty.rbegin()));
-        auto r_iter = empty.rbegin();
-        assert((r_iter++ == empty.rbegin()));
-
-        assert((empty.cend() - empty.cbegin()) == 0);
-        assert((empty.cbegin() + 0 == empty.cend()) && (empty.cend() - 0 == empty.cbegin()));
-        auto c_iter = empty.cbegin();
-        assert((c_iter++ == empty.cbegin()));
-
-        Deque<int> d(1000, 3);
-        assert(size_t((d.end() - d.begin())) == d.size());
-        assert((d.begin() + d.size() == d.end()) && (d.end() - d.size() == d.begin()));
-    }
-
-    void testIteratorsComparison() {
-        Deque<int> d(1000, 3);
-
-        assert(d.end() > d.begin());
-        assert(d.cend() > d.cbegin());
-        assert(d.rend() > d.rbegin());
-    }
-
-    void testIteratorsAlgorithms() {
-        Deque<int> d(1000, 3);
-
-        std::iota(d.begin(), d.end(), 13);
-        std::mt19937 g(31415);
-        std::shuffle(d.begin(), d.end(), g);
-        std::sort(d.rbegin(), d.rbegin() + 500);
-        std::reverse(d.begin(), d.end());
-        auto sorted_border = std::is_sorted_until(d.begin(), d.end());
-        //std::copy(d.begin(), d.end(), std::ostream_iterator<int>(std::cout, " "));
-        //std::cout << std::endl;
-        assert(sorted_border - d.begin() == 500);
-    }
-
-    void testPushAndPop() {
-        Deque<NotDefaultConstructible> d(10000, { 1 });
-        auto start_size = d.size();
-        
-        auto middle = &(*(d.begin() + start_size / 2)); // 5000
-        auto& middle_element = *middle;
-        auto begin = &(*d.begin());
-        auto end = &(*d.rbegin());
-
-        auto middle2 = &(*((d.begin() + start_size / 2) + 2000)); // 7000
-        
-        // remove 400 elements 
-        for (size_t i = 0; i < 400; ++i) {
-            d.pop_back();
-        }
-        
-        // begin and middle pointers are still valid
-        assert(begin->data == 1);
-        assert(middle->data == 1);
-        assert(middle_element.data == 1);
-        assert(middle2->data == 1);
-
-        end = &*d.rbegin();
-        
-        // 800 elemets removed in total
-        for (size_t i = 0; i < 400; ++i) {
-            d.pop_front();
-        }
-
-        // and and middle iterators are still valid
-        assert(end->data == 1);
-        assert(middle->data == 1);
-        assert(middle_element.data == 1);
-        assert(middle2->data == 1);
-        
-        // removed 9980 items in total
-        for (size_t i = 0; i < 4590; ++i) {
-            d.pop_front();
-            d.pop_back();
-        }
-
-        assert(d.size() == 20);
-        assert(middle_element.data == 1);
-        assert(middle->data == 1 && middle->data == 1);
-        assert(std::all_of(d.begin(), d.end(), [](const auto& item) { return item.data == 1; } ));
-
-        begin = &*d.begin();
-        end = &*d.rbegin();
-
-        for (size_t i = 0; i < 5500; ++i) {
-            d.push_back({2});
-            d.push_front({2});
-        }
-
-        assert((*begin).data == 1);
-        assert((*end).data == 1);
-        assert(d.begin()->data == 2);
-        assert(d.size() == 5500 * 2 + 20);
-        assert(std::count(d.begin(), d.end(), NotDefaultConstructible{1}) == 20);
-        assert(std::count(d.begin(), d.end(), NotDefaultConstructible{2}) == 11000);
-    }
-
-    void testInsertAndErase() {
-        Deque<NotDefaultConstructible> d(10000, { 1 });
-        auto start_size = d.size();
-        
-        d.insert(d.begin() + start_size / 2, NotDefaultConstructible{2});
-        assert(d.size() == start_size + 1);
-        d.erase(d.begin() + start_size / 2 - 1);
-        assert(d.size() == start_size);
-
-        assert(size_t(std::count(d.begin(), d.end(), NotDefaultConstructible{1})) == start_size - 1);
-        assert(std::count(d.begin(), d.end(), NotDefaultConstructible{2}) == 1);
-
-        Deque<NotDefaultConstructible> copy;
-        for (const auto& item : d) {
-            copy.insert(copy.end(), item);
-        }
-        // std::copy(d.cbegin(), d.cend(), std::inserter(copy, copy.begin()));
-        
-        assert(d.size() == copy.size());
-        assert(std::equal(d.begin(), d.end(), copy.begin()));
-    }
-
-    void testExceptions() {
-        try {
-            Deque<Counted<17>> d(100);
-        } catch (CountedException& e) {
-            assert(Counted<17>::counter == 0);
-        } catch (...) {
-            // should have caught same exception as thrown by Counted
-            assert(false);
-        }
-
-        try {
-            Deque<Explosive> d(100);
-        } catch (...) {
-            
-        }
-
-        try {
-            Deque<Explosive> d;
-        } catch (...) {
-            // no objects should have been created
-            assert(false);
-        }
-        assert(Explosive::exploded == false);
-
-        try {
-            Deque<Explosive> d;
-            auto safe = Explosive(Explosive::Safeguard{});
-            d.push_back(safe);
-        } catch (...) {
-
-        }
-
-        // Destructor should not be called for an object
-        // with no finihshed constructor
-        // the only destructor called - safe explosive with the safeguard
-        assert(Explosive::exploded == false);
-    }
-
-    void testStrongGuarantee() {
-        const size_t size = 20'000;
-        const size_t initial_data = 100;
-        Deque<Fragile> d(size, Fragile(size, initial_data));
-
-        auto is_intact = [&] {
-            return d.size() == size && std::all_of(d.begin(), d.end(), [initial_data](const auto& item) {return item.data == initial_data;} );
-        };
-        try {
-            d.insert(d.begin() + size / 2, Fragile(0, initial_data + 1));
-        } catch (...) {
-            // have to throw
-            assert(is_intact());
-        }
-        try {
-            // for those who like additional copies...
-            d.insert(d.begin() + size / 2, Fragile(3, initial_data + 2));
-        } catch (...) {
-            // might throw depending on the implementation
-            // if it DID throw, then deque should be untouched
-            assert(is_intact());
-        }
-    }
-} // namespace TestsByUnrealf1
-
-int main() {
-    
-    //static_assert(!std::is_same_v<std::deque<VerySpecialType>,
-    //        Deque<VerySpecialType>>, "You cannot use std::deque, cheater!");
-    //static_assert(!std::is_base_of_v<std::deque<VerySpecialType>,
-    //        Deque<VerySpecialType>>, "You cannot use std::deque, cheater!");
-     
-    TestsByMesyarik::test1();
-    TestsByMesyarik::test2();
-    TestsByMesyarik::test3();
-    TestsByMesyarik::test4();
-    TestsByMesyarik::test5();
-    TestsByMesyarik::test6();
-    TestsByMesyarik::test7();
-
-    TestsByUnrealf1::testDefault();
-    TestsByUnrealf1::testCopy();
-    TestsByUnrealf1::testWithSize();
-    TestsByUnrealf1::testAssignment();
-    TestsByUnrealf1::testStaticAsserts();
-    TestsByUnrealf1::testOperatorSubscript();
-    TestsByUnrealf1::testStaticAssertsAccess();
-    TestsByUnrealf1::testStaticAssertsIterators();
-    TestsByUnrealf1::testIteratorsArithmetic();
-    TestsByUnrealf1::testIteratorsComparison();
-    TestsByUnrealf1::testIteratorsAlgorithms();
-    TestsByUnrealf1::testPushAndPop();
-    TestsByUnrealf1::testInsertAndErase();
-    TestsByUnrealf1::testExceptions();
-    TestsByUnrealf1::testStrongGuarantee();
-
-    std::cout << 0;
+  struct Fragile {
+    Fragile(int durability, int data) : durability(durability), data(data) {}
+    ~Fragile() = default;
+
+    // for std::swap
+    Fragile(Fragile &&other) : Fragile() { *this = other; }
+
+    Fragile(const Fragile &other) : Fragile() { *this = other; }
+
+    Fragile &operator=(const Fragile &other) {
+      durability = other.durability - 1;
+      data = other.data;
+      if (durability <= 0) {
+        throw 2;
+      }
+      return *this;
+    }
+
+    int durability;
+    int data;
+
+  private:
+    Fragile() {}
+  };
+
+  ExceptionTests() {}
+  virtual ~ExceptionTests() {}
+  virtual void SetUp() {}
+  virtual void TearDown() {}
+};
+
+TEST_F(ExceptionTests, ThrowsExceptions) {
+  ASSERT_THROW([]() { Deque<Counted<17>> d(100); }(), CountedException);
+  try {
+    Deque<Counted<17>> d(100);
+  } catch (CountedException &) {
+    ASSERT_EQ(Counted<17>::counter, 0);
+  }
+
+  ASSERT_THROW([]() { Deque<Explosive> d(100); }(), int);
+  ASSERT_NO_THROW([]() { Deque<Explosive> d; }());
+  ASSERT_FALSE(Explosive::exploded);
+
+  ASSERT_THROW(
+      []() {
+        Deque<Explosive> d;
+        auto safe = Explosive(Explosive::Safeguard{});
+        d.push_back(safe);
+      }(),
+      int);
+  ASSERT_FALSE(Explosive::exploded);
+}
+
+TEST_F(ExceptionTests, StrongGuarantee) {
+  const size_t size = 20'000;
+  const size_t initial_data = 100;
+  Deque<Fragile> d(size, Fragile(size, initial_data));
+
+  auto is_intact = [&] {
+    return d.size() == size &&
+           std::all_of(d.begin(), d.end(), [initial_data](const auto &item) {
+             return item.data == initial_data;
+           });
+  };
+
+  EXPECT_THROW(
+      [&d]() {
+        d.insert(d.begin() + size / 2, Fragile(0, initial_data + 1));
+      }(),
+      int);
+  EXPECT_TRUE(is_intact());
+
+  try {
+    // for those who like additional copies...
+    d.insert(d.begin() + size / 2, Fragile(3, initial_data + 2));
+  } catch (...) {
+    // might throw depending on the implementation
+    // if it DID throw, then deque should be untouched
+    EXPECT_TRUE(is_intact());
+  }
 }
+
+} // namespace
+
+int main(int argc, char *argv[]) {
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
\ No newline at end of file

From 345d75a0413bf7a7810c94dcf6e5a40521791a71 Mon Sep 17 00:00:00 2001
From: Ilya Vankov <vankov-ilya@yandex-team.ru>
Date: Sun, 14 Jul 2024 22:02:51 +0300
Subject: [PATCH 2/2] Added concepts for deque members

---
 tasks/tests/deque_test.cpp | 709 ++++++++++++++++---------------------
 1 file changed, 304 insertions(+), 405 deletions(-)

diff --git a/tasks/tests/deque_test.cpp b/tasks/tests/deque_test.cpp
index 58f15bf..0f06456 100644
--- a/tasks/tests/deque_test.cpp
+++ b/tasks/tests/deque_test.cpp
@@ -1,5 +1,6 @@
 #include "gtest/gtest.h"
 #include <algorithm>
+#include <concepts>
 #include <cstddef>
 #include <gtest/gtest.h>
 #include <iterator>
@@ -10,13 +11,121 @@
 #include <utility>
 #include <vector>
 
-// #include <deque>
-// template <typename T> using Deque = std::deque<T>;
-
+#ifdef USE_STL_DEQUE
+#include <deque>
+template <typename T> using Deque = std::deque<T>;
+#endif
+#ifndef USE_STL_DEQUE
 #include "deque.h"
+#endif
 
 namespace {
 
+template <typename Container, typename Value>
+concept HasConcstructorsAndAssigns =
+    requires(Container d, size_t size, const Value &value,
+             const Container &cd) {
+      Container();
+      Container(size);
+      Container(size, value);
+      Container(d);
+    } &&
+    std::is_assignable_v<Container, Container> &&
+    std::is_assignable_v<Container, const Container> &&
+    !std::is_assignable_v<const Container, Container>;
+
+template <typename Container, typename Value>
+concept HasSettersAndGetters = requires(Container d, const Container cd) {
+  { d.front() } -> std::same_as<Value &>;
+  { d.back() } -> std::same_as<Value &>;
+  { d[0] } -> std::same_as<Value &>;
+  { d.at(0) } -> std::same_as<Value &>;
+
+  { cd.front() } -> std::same_as<const Value &>;
+  { cd.back() } -> std::same_as<const Value &>;
+  { cd[0] } -> std::same_as<const Value &>;
+  { cd.at(0) } -> std::same_as<const Value &>;
+};
+
+template <typename Container, typename Value>
+concept HasPushPop = requires(Container d, const Value &value) {
+  { d.push_front(value) } -> std::same_as<void>;
+  { d.push_back(value) } -> std::same_as<void>;
+  { d.pop_front() } -> std::same_as<void>;
+  { d.pop_back() } -> std::same_as<void>;
+};
+
+template <typename Container, typename Value>
+concept HasInsertEraseClear = requires(Container d, const Value &value) {
+  { d.insert(d.begin(), value) } -> std::same_as<typename Container::iterator>;
+  { d.erase(d.begin()) } -> std::same_as<typename Container::iterator>;
+  { d.clear() } -> std::same_as<void>;
+};
+
+template <typename Container, typename Value>
+concept HasBeginEnd = requires(Container d, const Container cd) {
+  { d.begin() } -> std::same_as<typename Container::iterator>;
+  { d.end() } -> std::same_as<typename Container::iterator>;
+  { cd.begin() } -> std::same_as<typename Container::const_iterator>;
+  { cd.end() } -> std::same_as<typename Container::const_iterator>;
+
+  { d.cbegin() } -> std::same_as<typename Container::const_iterator>;
+  { d.cend() } -> std::same_as<typename Container::const_iterator>;
+  { cd.cbegin() } -> std::same_as<typename Container::const_iterator>;
+  { cd.cend() } -> std::same_as<typename Container::const_iterator>;
+
+  { d.rbegin() } -> std::same_as<typename Container::reverse_iterator>;
+  { d.rend() } -> std::same_as<typename Container::reverse_iterator>;
+  { cd.rbegin() } -> std::same_as<typename Container::const_reverse_iterator>;
+  { cd.rend() } -> std::same_as<typename Container::const_reverse_iterator>;
+
+  { d.crbegin() } -> std::same_as<typename Container::const_reverse_iterator>;
+  { d.crend() } -> std::same_as<typename Container::const_reverse_iterator>;
+  { cd.crbegin() } -> std::same_as<typename Container::const_reverse_iterator>;
+  { cd.crend() } -> std::same_as<typename Container::const_reverse_iterator>;
+};
+
+template <typename Container, typename Value>
+concept HasMembers = requires(Container d, size_t size) {
+  { d.resize(size) } -> std::same_as<void>;
+  { d.shrink_to_fit() } -> std::same_as<void>;
+  { d.swap(d) } -> std::same_as<void>;
+};
+
+template <typename Container, typename Value>
+concept HasTypes =
+    std::same_as<typename Container::value_type, Value> &&
+    std::same_as<typename Container::size_type, size_t> &&
+    std::same_as<typename Container::difference_type, std::ptrdiff_t> &&
+    std::same_as<typename Container::reference, Value &> &&
+    std::same_as<typename Container::const_reference, const Value &> &&
+    std::same_as<typename Container::pointer, Value *> &&
+    std::same_as<typename Container::const_pointer, const Value *>;
+
+template <typename Container, typename Value>
+concept HasIterators =
+    std::same_as<typename Container::reverse_iterator,
+                 std::reverse_iterator<typename Container::iterator>> &&
+    std::same_as<typename Container::const_reverse_iterator,
+                 std::reverse_iterator<typename Container::const_iterator>> &&
+    std::random_access_iterator<typename Container::iterator> &&
+    std::is_convertible_v<typename Container::iterator,
+                          typename Container::const_iterator> &&
+    !std::is_convertible_v<typename Container::const_iterator,
+                           typename Container::iterator>;
+
+template <typename Container, typename Value>
+concept implies_deque =
+    HasConcstructorsAndAssigns<Container, Value> &&
+    HasSettersAndGetters<Container, Value> && HasPushPop<Container, Value> &&
+    HasInsertEraseClear<Container, Value> && HasBeginEnd<Container, Value> &&
+    HasMembers<Container, Value> &&
+    std::random_access_iterator<typename Container::iterator>;
+
+template <typename T>
+  requires(implies_deque<std::deque<T>, T>)
+using deque = Deque<T>;
+
 // Counts every call of defaul/copy-ctor and dtor
 class Accountant {
 public:
@@ -65,6 +174,13 @@ class Unique {
   static void Reset() { counter = 0; }
 };
 
+class NorDefaultNorCopyConstructible {
+public:
+  NorDefaultNorCopyConstructible() = delete;
+  NorDefaultNorCopyConstructible(const NorDefaultNorCopyConstructible &) =
+      delete;
+};
+
 size_t Unique::counter = 0;
 
 class ConstructorsTests : public ::testing::Test {
@@ -84,19 +200,10 @@ class ConstructorsTests : public ::testing::Test {
     UniqueDefaultConstructed::Reset();
   }
 };
-
-TEST_F(ConstructorsTests, HasConstructors) {
-  ASSERT_TRUE((std::is_default_constructible_v<Deque<Unique>>));
-  ASSERT_TRUE((std::is_copy_constructible_v<Deque<Unique>>));
-  ASSERT_TRUE((std::is_constructible_v<Deque<Unique>, int>));
-  ASSERT_TRUE((std::is_constructible_v<Deque<Unique>, int, const Unique &>));
-  ASSERT_TRUE((std::is_copy_assignable_v<Deque<Unique>>));
-}
-
 TEST_F(ConstructorsTests, DefaultConstructorWithAccountant) {
 
   {
-    Deque<Accountant> d;
+    deque<Accountant> d;
     ASSERT_EQ(0, Accountant::default_ctor_calls);
     ASSERT_EQ(0, Accountant::dtor_calls);
     ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
@@ -110,7 +217,7 @@ TEST_F(ConstructorsTests, DefaultConstructorWithAccountant) {
 
 TEST_F(ConstructorsTests, SizeConstructorWithAccountant) {
   {
-    Deque<Accountant> d(kSmallSize);
+    deque<Accountant> d(kSmallSize);
     ASSERT_EQ(kSmallSize, Accountant::default_ctor_calls);
     ASSERT_EQ(0, Accountant::dtor_calls);
     ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
@@ -123,7 +230,7 @@ TEST_F(ConstructorsTests, SizeConstructorWithAccountant) {
 
   {
     Accountant::ResetAll();
-    Deque<Accountant> d(kSmallSize, Accountant());
+    deque<Accountant> d(kSmallSize, Accountant());
     ASSERT_EQ(1, Accountant::default_ctor_calls);
     ASSERT_EQ(1, Accountant::dtor_calls);
     ASSERT_EQ(kSmallSize, Accountant::copy_default_ctor_calls);
@@ -136,7 +243,7 @@ TEST_F(ConstructorsTests, SizeConstructorWithAccountant) {
 
   {
     Accountant::ResetAll();
-    Deque<Accountant> d(kBigSize);
+    deque<Accountant> d(kBigSize);
     ASSERT_EQ(kBigSize, Accountant::default_ctor_calls);
     ASSERT_EQ(0, Accountant::dtor_calls);
     ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
@@ -149,7 +256,7 @@ TEST_F(ConstructorsTests, SizeConstructorWithAccountant) {
 
   {
     Accountant::ResetAll();
-    Deque<Accountant> d(kBigSize, Accountant());
+    deque<Accountant> d(kBigSize, Accountant());
     ASSERT_EQ(1, Accountant::default_ctor_calls);
     ASSERT_EQ(1, Accountant::dtor_calls);
     ASSERT_EQ(kBigSize, Accountant::copy_default_ctor_calls);
@@ -163,12 +270,12 @@ TEST_F(ConstructorsTests, SizeConstructorWithAccountant) {
 
 TEST_F(ConstructorsTests, CopyConstructorWithAccountant) {
   {
-    Deque<Accountant> d;
+    deque<Accountant> d;
     ASSERT_EQ(0, Accountant::default_ctor_calls);
     ASSERT_EQ(0, Accountant::dtor_calls);
     ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
 
-    Deque<Accountant> d2(d);
+    deque<Accountant> d2(d);
     ASSERT_EQ(0, Accountant::default_ctor_calls);
     ASSERT_EQ(0, Accountant::dtor_calls);
     ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
@@ -181,12 +288,12 @@ TEST_F(ConstructorsTests, CopyConstructorWithAccountant) {
 
   {
     Accountant::ResetAll();
-    Deque<Accountant> d(kSmallSize);
+    deque<Accountant> d(kSmallSize);
     ASSERT_EQ(kSmallSize, Accountant::default_ctor_calls);
     ASSERT_EQ(0, Accountant::dtor_calls);
     ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
 
-    Deque<Accountant> d2(d);
+    deque<Accountant> d2(d);
     ASSERT_EQ(kSmallSize, Accountant::default_ctor_calls);
     ASSERT_EQ(0, Accountant::dtor_calls);
     ASSERT_EQ(kSmallSize, Accountant::copy_default_ctor_calls);
@@ -199,12 +306,12 @@ TEST_F(ConstructorsTests, CopyConstructorWithAccountant) {
 
   {
     Accountant::ResetAll();
-    Deque<Accountant> d(kBigSize);
+    deque<Accountant> d(kBigSize);
     ASSERT_EQ(kBigSize, Accountant::default_ctor_calls);
     ASSERT_EQ(0, Accountant::dtor_calls);
     ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
 
-    Deque<Accountant> d2(d);
+    deque<Accountant> d2(d);
     ASSERT_EQ(kBigSize, Accountant::default_ctor_calls);
     ASSERT_EQ(0, Accountant::dtor_calls);
     ASSERT_EQ(kBigSize, Accountant::copy_default_ctor_calls);
@@ -219,7 +326,7 @@ TEST_F(ConstructorsTests, CopyConstructorWithAccountant) {
 TEST_F(ConstructorsTests, SizeConstructor) {
   {
     UniqueDefaultConstructed::Reset();
-    Deque<UniqueDefaultConstructed> d(kSmallSize);
+    deque<UniqueDefaultConstructed> d(kSmallSize);
 
     ASSERT_EQ(kSmallSize, UniqueDefaultConstructed::counter);
     for (size_t i = 0; i < kSmallSize; ++i) {
@@ -229,7 +336,7 @@ TEST_F(ConstructorsTests, SizeConstructor) {
 
   {
     UniqueDefaultConstructed::Reset();
-    Deque<UniqueDefaultConstructed> d(kBigSize);
+    deque<UniqueDefaultConstructed> d(kBigSize);
 
     ASSERT_EQ(kBigSize, UniqueDefaultConstructed::counter);
     for (size_t i = 0; i < kBigSize; ++i) {
@@ -239,7 +346,7 @@ TEST_F(ConstructorsTests, SizeConstructor) {
 
   {
     UniqueDefaultConstructed::Reset();
-    Deque<UniqueDefaultConstructed> d(kSmallSize, UniqueDefaultConstructed());
+    deque<UniqueDefaultConstructed> d(kSmallSize, UniqueDefaultConstructed());
 
     ASSERT_EQ(1, UniqueDefaultConstructed::counter);
     for (size_t i = 0; i < kSmallSize; ++i) {
@@ -249,7 +356,7 @@ TEST_F(ConstructorsTests, SizeConstructor) {
 
   {
     UniqueDefaultConstructed::Reset();
-    Deque<UniqueDefaultConstructed> d(kBigSize, UniqueDefaultConstructed());
+    deque<UniqueDefaultConstructed> d(kBigSize, UniqueDefaultConstructed());
 
     ASSERT_EQ(1, UniqueDefaultConstructed::counter);
     for (size_t i = 0; i < kBigSize; ++i) {
@@ -261,8 +368,8 @@ TEST_F(ConstructorsTests, SizeConstructor) {
 TEST_F(ConstructorsTests, CopyConstructor) {
   {
     Unique::Reset();
-    Deque<Unique> d(kSmallSize);
-    Deque<Unique> d2(d);
+    deque<Unique> d(kSmallSize);
+    deque<Unique> d2(d);
 
     for (size_t i = 0; i < kSmallSize; ++i) {
       ASSERT_EQ(i, d[i].number_);
@@ -272,8 +379,8 @@ TEST_F(ConstructorsTests, CopyConstructor) {
 
   {
     Unique::Reset();
-    Deque<Unique> d(kBigSize);
-    Deque<Unique> d2(d);
+    deque<Unique> d(kBigSize);
+    deque<Unique> d2(d);
 
     for (size_t i = 0; i < kBigSize; ++i) {
       ASSERT_EQ(i, d[i].number_);
@@ -284,7 +391,7 @@ TEST_F(ConstructorsTests, CopyConstructor) {
 
 TEST_F(ConstructorsTests, InitializerListConstructor) {
   {
-    Deque<int> d({1, 2, 3});
+    deque<int> d({1, 2, 3});
     ASSERT_EQ(3, d.size());
     ASSERT_EQ(1, d[0]);
     ASSERT_EQ(2, d[1]);
@@ -295,8 +402,8 @@ TEST_F(ConstructorsTests, InitializerListConstructor) {
 TEST_F(ConstructorsTests, CopyAssigment) {
   {
     Unique::Reset();
-    Deque<Unique> d(kSmallSize);
-    Deque<Unique> d2;
+    deque<Unique> d(kSmallSize);
+    deque<Unique> d2;
     d2 = d;
 
     for (size_t i = 0; i < kSmallSize; ++i) {
@@ -307,8 +414,8 @@ TEST_F(ConstructorsTests, CopyAssigment) {
 
   {
     Unique::Reset();
-    Deque<Unique> d(kBigSize);
-    Deque<Unique> d2;
+    deque<Unique> d(kBigSize);
+    deque<Unique> d2;
     d2 = d;
 
     for (size_t i = 0; i < kBigSize; ++i) {
@@ -320,12 +427,12 @@ TEST_F(ConstructorsTests, CopyAssigment) {
 
 TEST_F(ConstructorsTests, CopyAssigmentWithAccountant) {
   {
-    Deque<Accountant> d;
+    deque<Accountant> d;
     ASSERT_EQ(0, Accountant::default_ctor_calls);
     ASSERT_EQ(0, Accountant::dtor_calls);
     ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
 
-    Deque<Accountant> d2;
+    deque<Accountant> d2;
     d2 = d;
     ASSERT_EQ(0, Accountant::default_ctor_calls);
     ASSERT_EQ(0, Accountant::dtor_calls);
@@ -339,12 +446,12 @@ TEST_F(ConstructorsTests, CopyAssigmentWithAccountant) {
 
   {
     Accountant::ResetAll();
-    Deque<Accountant> d(kSmallSize);
+    deque<Accountant> d(kSmallSize);
     ASSERT_EQ(kSmallSize, Accountant::default_ctor_calls);
     ASSERT_EQ(0, Accountant::dtor_calls);
     ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
 
-    Deque<Accountant> d2;
+    deque<Accountant> d2;
     d2 = d;
     ASSERT_EQ(kSmallSize, Accountant::default_ctor_calls);
     ASSERT_EQ(0, Accountant::dtor_calls);
@@ -358,12 +465,12 @@ TEST_F(ConstructorsTests, CopyAssigmentWithAccountant) {
 
   {
     Accountant::ResetAll();
-    Deque<Accountant> d(kBigSize);
+    deque<Accountant> d(kBigSize);
     ASSERT_EQ(kBigSize, Accountant::default_ctor_calls);
     ASSERT_EQ(0, Accountant::dtor_calls);
     ASSERT_EQ(0, Accountant::copy_default_ctor_calls);
 
-    Deque<Accountant> d2;
+    deque<Accountant> d2;
     d2 = d;
     ASSERT_EQ(kBigSize, Accountant::default_ctor_calls);
     ASSERT_EQ(0, Accountant::dtor_calls);
@@ -380,8 +487,8 @@ class IndexationTests : public ::testing::Test {
 protected:
   const size_t kSmallSize = 10;
   const size_t kBigSize = 10000000;
-  Deque<UniqueDefaultConstructed> smallDeque_;
-  Deque<UniqueDefaultConstructed> bigDeque_;
+  deque<UniqueDefaultConstructed> smalldeque_;
+  deque<UniqueDefaultConstructed> bigdeque_;
 
   IndexationTests() {}
   ~IndexationTests() {}
@@ -390,8 +497,8 @@ class IndexationTests : public ::testing::Test {
     Accountant::ResetAll();
     Unique::Reset();
     UniqueDefaultConstructed::Reset();
-    smallDeque_ = Deque<UniqueDefaultConstructed>(kSmallSize);
-    bigDeque_ = Deque<UniqueDefaultConstructed>(kBigSize);
+    smalldeque_ = deque<UniqueDefaultConstructed>(kSmallSize);
+    bigdeque_ = deque<UniqueDefaultConstructed>(kBigSize);
   }
   void TearDown() override {
     Accountant::ResetAll();
@@ -400,94 +507,37 @@ class IndexationTests : public ::testing::Test {
   }
 };
 
-TEST_F(IndexationTests, IndexationReturnType) {
-  ASSERT_TRUE(
-      (std::is_same_v<Unique &,
-                      decltype(std::declval<Deque<Unique>>().operator[](0))>));
-  ASSERT_TRUE((std::is_same_v<
-               const Unique &,
-               decltype(std::declval<Deque<const Unique>>().operator[](0))>));
-  ASSERT_TRUE((
-      std::is_same_v<Unique &,
-                     decltype(std::declval<Deque<Unique> &>().operator[](0))>));
-  ASSERT_TRUE((std::is_same_v<
-               const Unique &,
-               decltype(std::declval<const Deque<Unique> &>().operator[](0))>));
-
-  ASSERT_TRUE(
-      (std::is_same_v<Unique &,
-                      decltype(std::declval<Deque<Unique>>().front())>));
-  ASSERT_TRUE(
-      (std::is_same_v<const Unique &,
-                      decltype(std::declval<Deque<const Unique>>().front())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Unique &,
-                      decltype(std::declval<Deque<Unique> &>().front())>));
-  ASSERT_TRUE((
-      std::is_same_v<const Unique &,
-                     decltype(std::declval<const Deque<Unique> &>().front())>));
-
-  ASSERT_TRUE((std::is_same_v<Unique &,
-                              decltype(std::declval<Deque<Unique>>().back())>));
-  ASSERT_TRUE(
-      (std::is_same_v<const Unique &,
-                      decltype(std::declval<Deque<const Unique>>().back())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Unique &,
-                      decltype(std::declval<Deque<Unique> &>().back())>));
-  ASSERT_TRUE(
-      (std::is_same_v<const Unique &,
-                      decltype(std::declval<const Deque<Unique> &>().back())>));
-
-  ASSERT_TRUE((
-      std::is_same_v<Unique &, decltype(std::declval<Deque<Unique>>().at(0))>));
-  ASSERT_TRUE(
-      (std::is_same_v<const Unique &,
-                      decltype(std::declval<Deque<const Unique>>().at(0))>));
-  ASSERT_TRUE(
-      (std::is_same_v<Unique &,
-                      decltype(std::declval<Deque<Unique> &>().at(0))>));
-  ASSERT_TRUE(
-      (std::is_same_v<const Unique &,
-                      decltype(std::declval<const Deque<Unique> &>().at(0))>));
-
-  ASSERT_THROW(smallDeque_.at(kSmallSize + 100), std::out_of_range);
-  ASSERT_THROW(bigDeque_.at(kBigSize + 100), std::out_of_range);
-  ASSERT_THROW(smallDeque_.at(-100), std::out_of_range);
-  ASSERT_THROW(bigDeque_.at(-100), std::out_of_range);
-}
-
 TEST_F(IndexationTests, IndexationSetAndGet) {
   for (size_t i = 0; i < kSmallSize; ++i) {
-    ASSERT_EQ(i, smallDeque_[i].number_);
+    ASSERT_EQ(i, smalldeque_[i].number_);
   }
 
-  smallDeque_[2] = UniqueDefaultConstructed();
-  smallDeque_[5] = UniqueDefaultConstructed();
-  ASSERT_EQ(kSmallSize + kBigSize, smallDeque_[2].number_);
-  ASSERT_EQ(kSmallSize + kBigSize + 1, smallDeque_[5].number_);
+  smalldeque_[2] = UniqueDefaultConstructed();
+  smalldeque_[5] = UniqueDefaultConstructed();
+  ASSERT_EQ(kSmallSize + kBigSize, smalldeque_[2].number_);
+  ASSERT_EQ(kSmallSize + kBigSize + 1, smalldeque_[5].number_);
   for (size_t i = 0; i < kSmallSize; ++i) {
     if (i != 2 && i != 5) {
-      ASSERT_EQ(i, smallDeque_[i].number_);
+      ASSERT_EQ(i, smalldeque_[i].number_);
     }
   }
 
   for (size_t i = 0; i < kBigSize; ++i) {
-    ASSERT_EQ(i + kSmallSize, bigDeque_[i].number_);
+    ASSERT_EQ(i + kSmallSize, bigdeque_[i].number_);
   }
 
   const int indices[] = {1, 127, 5556, 123123};
   for (size_t i = 0; i < sizeof(indices) / sizeof(int); ++i) {
-    bigDeque_[indices[i]] = UniqueDefaultConstructed();
+    bigdeque_[indices[i]] = UniqueDefaultConstructed();
   }
 
   for (size_t i = 0; i < sizeof(indices) / sizeof(int); ++i) {
-    ASSERT_EQ(kSmallSize + kBigSize + 2 + i, bigDeque_[indices[i]].number_);
+    ASSERT_EQ(kSmallSize + kBigSize + 2 + i, bigdeque_[indices[i]].number_);
   }
   for (size_t i = 0; i < kBigSize; ++i) {
     if (std::find(indices, indices + sizeof(indices) / sizeof(int), i) ==
         indices + sizeof(indices) / sizeof(int)) {
-      ASSERT_EQ(kSmallSize + i, bigDeque_[i].number_);
+      ASSERT_EQ(kSmallSize + i, bigdeque_[i].number_);
     }
   }
 }
@@ -496,8 +546,8 @@ class PushPopTests : public ::testing::Test {
 protected:
   const size_t kSmallSize = 10;
   const size_t kBigSize = 10000000;
-  Deque<UniqueDefaultConstructed> smallDeque_;
-  Deque<UniqueDefaultConstructed> bigDeque_;
+  deque<UniqueDefaultConstructed> smalldeque_;
+  deque<UniqueDefaultConstructed> bigdeque_;
 
   PushPopTests() {}
   virtual ~PushPopTests() {}
@@ -505,8 +555,8 @@ class PushPopTests : public ::testing::Test {
     Accountant::ResetAll();
     Unique::Reset();
     UniqueDefaultConstructed::Reset();
-    smallDeque_ = Deque<UniqueDefaultConstructed>(kSmallSize);
-    bigDeque_ = Deque<UniqueDefaultConstructed>(kBigSize);
+    smalldeque_ = deque<UniqueDefaultConstructed>(kSmallSize);
+    bigdeque_ = deque<UniqueDefaultConstructed>(kBigSize);
   }
   virtual void TearDown() {
     Accountant::ResetAll();
@@ -516,73 +566,73 @@ class PushPopTests : public ::testing::Test {
 };
 
 TEST_F(PushPopTests, PushBackPopBack) {
-  ASSERT_EQ(kSmallSize, smallDeque_.size());
-  smallDeque_.push_back(UniqueDefaultConstructed());
-  ASSERT_EQ(kSmallSize + 1, smallDeque_.size());
-  UniqueDefaultConstructed last_element = smallDeque_.back();
-  smallDeque_.pop_back();
-  ASSERT_EQ(kSmallSize, smallDeque_.size());
+  ASSERT_EQ(kSmallSize, smalldeque_.size());
+  smalldeque_.push_back(UniqueDefaultConstructed());
+  ASSERT_EQ(kSmallSize + 1, smalldeque_.size());
+  UniqueDefaultConstructed last_element = smalldeque_.back();
+  smalldeque_.pop_back();
+  ASSERT_EQ(kSmallSize, smalldeque_.size());
   ASSERT_EQ(kSmallSize + kBigSize, last_element.number_);
 
-  for (size_t i = 0; i < smallDeque_.size(); ++i) {
-    ASSERT_EQ(i, smallDeque_[i].number_);
+  for (size_t i = 0; i < smalldeque_.size(); ++i) {
+    ASSERT_EQ(i, smalldeque_[i].number_);
   }
 
   //---------------------------------------------------
 
-  bigDeque_.push_back(UniqueDefaultConstructed());
-  ASSERT_EQ(kBigSize + 1, bigDeque_.size());
+  bigdeque_.push_back(UniqueDefaultConstructed());
+  ASSERT_EQ(kBigSize + 1, bigdeque_.size());
 
-  UniqueDefaultConstructed last_big_element = bigDeque_.back();
-  bigDeque_.pop_back();
-  ASSERT_EQ(kBigSize, bigDeque_.size());
+  UniqueDefaultConstructed last_big_element = bigdeque_.back();
+  bigdeque_.pop_back();
+  ASSERT_EQ(kBigSize, bigdeque_.size());
   ASSERT_EQ(kSmallSize + kBigSize + 1, last_big_element.number_);
 
-  for (size_t i = 0; i < bigDeque_.size(); ++i) {
-    ASSERT_EQ(i + kSmallSize, bigDeque_[i].number_);
+  for (size_t i = 0; i < bigdeque_.size(); ++i) {
+    ASSERT_EQ(i + kSmallSize, bigdeque_[i].number_);
   }
 }
 
 TEST_F(PushPopTests, PushFrontPopFront) {
-  smallDeque_.push_front(UniqueDefaultConstructed());
+  smalldeque_.push_front(UniqueDefaultConstructed());
 
-  ASSERT_EQ(kSmallSize + 1, smallDeque_.size());
+  ASSERT_EQ(kSmallSize + 1, smalldeque_.size());
 
-  UniqueDefaultConstructed first_element = smallDeque_.front();
-  smallDeque_.pop_front();
+  UniqueDefaultConstructed first_element = smalldeque_.front();
+  smalldeque_.pop_front();
 
-  ASSERT_EQ(kSmallSize, smallDeque_.size());
+  ASSERT_EQ(kSmallSize, smalldeque_.size());
   ASSERT_EQ(kSmallSize + kBigSize, first_element.number_);
 
-  for (size_t i = 0; i < smallDeque_.size(); ++i) {
-    ASSERT_EQ(i, smallDeque_[i].number_);
+  for (size_t i = 0; i < smalldeque_.size(); ++i) {
+    ASSERT_EQ(i, smalldeque_[i].number_);
   }
 
   //------------------------------------------------------------------------------
 
-  bigDeque_.push_front(UniqueDefaultConstructed());
-  ASSERT_EQ(kBigSize + 1, bigDeque_.size());
-  UniqueDefaultConstructed first_big_element = bigDeque_.front();
-  bigDeque_.pop_front();
-  ASSERT_EQ(kBigSize, bigDeque_.size());
+  bigdeque_.push_front(UniqueDefaultConstructed());
+  ASSERT_EQ(kBigSize + 1, bigdeque_.size());
+  UniqueDefaultConstructed first_big_element = bigdeque_.front();
+  bigdeque_.pop_front();
+  ASSERT_EQ(kBigSize, bigdeque_.size());
   ASSERT_EQ(kSmallSize + kBigSize + 1, first_big_element.number_);
 
-  for (size_t i = 0; i < bigDeque_.size(); ++i) {
-    ASSERT_EQ(i + kSmallSize, bigDeque_[i].number_);
+  for (size_t i = 0; i < bigdeque_.size(); ++i) {
+    ASSERT_EQ(i + kSmallSize, bigdeque_[i].number_);
   }
 }
 
 TEST_F(PushPopTests, ManyPushAndPops) {
   for (size_t i = 0; i < 100000; ++i) {
-    bigDeque_.push_back(UniqueDefaultConstructed());
-    bigDeque_.push_front(UniqueDefaultConstructed());
-    bigDeque_.pop_back();
-    bigDeque_.pop_front();
+    bigdeque_.push_back(UniqueDefaultConstructed());
+    bigdeque_.push_front(UniqueDefaultConstructed());
+    bigdeque_.pop_back();
+    bigdeque_.pop_front();
   }
 
-  ASSERT_EQ(kBigSize, bigDeque_.size());
+  ASSERT_EQ(kBigSize, bigdeque_.size());
 
-  Deque<int> d;
+  deque<int> d;
   for (int i = 0; i < 1000; ++i) {
     for (int j = 0; j < 1000; ++j) {
 
@@ -616,7 +666,7 @@ class IteratorsTests : public ::testing::Test {
 protected:
   const size_t kSmallSize = 10;
   const size_t kBigSize = 10000000;
-  Deque<UniqueDefaultConstructed> smallDeque_;
+  deque<UniqueDefaultConstructed> smalldeque_;
 
   IteratorsTests() {}
   virtual ~IteratorsTests() {}
@@ -624,7 +674,7 @@ class IteratorsTests : public ::testing::Test {
     Accountant::ResetAll();
     Unique::Reset();
     UniqueDefaultConstructed::Reset();
-    smallDeque_ = Deque<UniqueDefaultConstructed>(kSmallSize);
+    smalldeque_ = deque<UniqueDefaultConstructed>(kSmallSize);
   }
   virtual void TearDown() {
     Accountant::ResetAll();
@@ -632,157 +682,6 @@ class IteratorsTests : public ::testing::Test {
     UniqueDefaultConstructed::Reset();
   }
 };
-
-TEST_F(IteratorsTests, IteratorTypes) {
-  ASSERT_TRUE((std::is_same_v<std::reverse_iterator<Deque<Unique>::iterator>,
-                              Deque<Unique>::reverse_iterator>));
-  ASSERT_TRUE(
-      (std::is_same_v<std::reverse_iterator<Deque<Unique>::const_iterator>,
-                      Deque<Unique>::const_reverse_iterator>));
-
-  ASSERT_TRUE((
-      std::is_same_v<Unique &, decltype(std::declval<Deque<Unique>::iterator>().
-                                        operator*())>));
-  ASSERT_TRUE(
-      (std::is_same_v<const Unique &,
-                      decltype(std::declval<Deque<Unique>::const_iterator>().
-                               operator*())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Unique &,
-                      decltype(std::declval<Deque<Unique>::reverse_iterator>().
-                               operator*())>));
-  ASSERT_TRUE((std::is_same_v<
-               const Unique &,
-               decltype(std::declval<Deque<Unique>::const_reverse_iterator>().
-                        operator*())>));
-
-  ASSERT_TRUE(
-      (std::is_same_v<
-          Unique *,
-          decltype(std::declval<Deque<Unique>::iterator>().operator->())>));
-  ASSERT_TRUE((std::is_same_v<
-               const Unique *,
-               decltype(std::declval<Deque<Unique>::const_iterator>().
-                        operator->())>));
-  ASSERT_TRUE(
-      (std::is_same_v<
-          Unique *,
-          decltype(std::declval<Deque<Unique>::reverse_iterator>().
-                   operator->())>));
-  ASSERT_TRUE((std::is_same_v<
-               const Unique *,
-               decltype(std::declval<Deque<Unique>::const_reverse_iterator>()
-                            .
-                            operator->())>));
-
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::iterator,
-                      decltype(std::declval<Deque<Unique>>().begin())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_iterator,
-                      decltype(std::declval<const Deque<Unique>>().begin())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::iterator,
-                      decltype(std::declval<Deque<Unique> &>().begin())>));
-  ASSERT_TRUE((
-      std::is_same_v<Deque<Unique>::const_iterator,
-                     decltype(std::declval<const Deque<Unique> &>().begin())>));
-
-  ASSERT_TRUE((std::is_same_v<Deque<Unique>::iterator,
-                              decltype(std::declval<Deque<Unique>>().end())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_iterator,
-                      decltype(std::declval<const Deque<Unique>>().end())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::iterator,
-                      decltype(std::declval<Deque<Unique> &>().end())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_iterator,
-                      decltype(std::declval<const Deque<Unique> &>().end())>));
-
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_iterator,
-                      decltype(std::declval<Deque<Unique>>().cbegin())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_iterator,
-                      decltype(std::declval<const Deque<Unique>>().cbegin())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_iterator,
-                      decltype(std::declval<Deque<Unique> &>().cbegin())>));
-  ASSERT_TRUE((std::is_same_v<
-               Deque<Unique>::const_iterator,
-               decltype(std::declval<const Deque<Unique> &>().cbegin())>));
-
-  ASSERT_TRUE((std::is_same_v<Deque<Unique>::const_iterator,
-                              decltype(std::declval<Deque<Unique>>().cend())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_iterator,
-                      decltype(std::declval<const Deque<Unique>>().cend())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_iterator,
-                      decltype(std::declval<Deque<Unique> &>().cend())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_iterator,
-                      decltype(std::declval<const Deque<Unique> &>().cend())>));
-
-  // reverse
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::reverse_iterator,
-                      decltype(std::declval<Deque<Unique>>().rbegin())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
-                      decltype(std::declval<const Deque<Unique>>().rbegin())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::reverse_iterator,
-                      decltype(std::declval<Deque<Unique> &>().rbegin())>));
-  ASSERT_TRUE((std::is_same_v<
-               Deque<Unique>::const_reverse_iterator,
-               decltype(std::declval<const Deque<Unique> &>().rbegin())>));
-
-  ASSERT_TRUE((std::is_same_v<Deque<Unique>::reverse_iterator,
-                              decltype(std::declval<Deque<Unique>>().rend())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
-                      decltype(std::declval<const Deque<Unique>>().rend())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::reverse_iterator,
-                      decltype(std::declval<Deque<Unique> &>().rend())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
-                      decltype(std::declval<const Deque<Unique> &>().rend())>));
-
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
-                      decltype(std::declval<Deque<Unique>>().crbegin())>));
-  ASSERT_TRUE((
-      std::is_same_v<Deque<Unique>::const_reverse_iterator,
-                     decltype(std::declval<const Deque<Unique>>().crbegin())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
-                      decltype(std::declval<Deque<Unique> &>().crbegin())>));
-  ASSERT_TRUE((std::is_same_v<
-               Deque<Unique>::const_reverse_iterator,
-               decltype(std::declval<const Deque<Unique> &>().crbegin())>));
-
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
-                      decltype(std::declval<Deque<Unique>>().crend())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
-                      decltype(std::declval<const Deque<Unique>>().crend())>));
-  ASSERT_TRUE(
-      (std::is_same_v<Deque<Unique>::const_reverse_iterator,
-                      decltype(std::declval<Deque<Unique> &>().crend())>));
-  ASSERT_TRUE((
-      std::is_same_v<Deque<Unique>::const_reverse_iterator,
-                     decltype(std::declval<const Deque<Unique> &>().crend())>));
-
-  ASSERT_TRUE((std::is_convertible_v<Deque<Unique>::iterator,
-                                     Deque<Unique>::const_iterator>));
-  ASSERT_TRUE((!std::is_convertible_v<Deque<Unique>::const_iterator,
-                                      Deque<Unique>::iterator>));
-}
-
 template <typename Iter, typename T> void testIteratorArithmeticTypes() {
   using traits = std::iterator_traits<Iter>;
 
@@ -817,58 +716,58 @@ template <typename Iter, typename T> void testIteratorArithmeticTypes() {
 }
 
 TEST_F(IteratorsTests, IteratorArithmeticsTypes) {
-  testIteratorArithmeticTypes<Deque<Unique>::iterator, Unique>();
-  testIteratorArithmeticTypes<Deque<Unique>::const_iterator, const Unique>();
-  testIteratorArithmeticTypes<Deque<Unique>::reverse_iterator, Unique>();
-  testIteratorArithmeticTypes<Deque<Unique>::const_reverse_iterator,
+  testIteratorArithmeticTypes<deque<Unique>::iterator, Unique>();
+  testIteratorArithmeticTypes<deque<Unique>::const_iterator, const Unique>();
+  testIteratorArithmeticTypes<deque<Unique>::reverse_iterator, Unique>();
+  testIteratorArithmeticTypes<deque<Unique>::const_reverse_iterator,
                               const Unique>();
 }
 
 TEST_F(IteratorsTests, IteratorArithmetics) {
 
-  ASSERT_EQ(smallDeque_.begin() + smallDeque_.size(), smallDeque_.end());
-  ASSERT_EQ(smallDeque_.end() - smallDeque_.begin(), smallDeque_.size());
-  ASSERT_EQ(smallDeque_.end() - smallDeque_.size(), smallDeque_.begin());
+  ASSERT_EQ(smalldeque_.begin() + smalldeque_.size(), smalldeque_.end());
+  ASSERT_EQ(smalldeque_.end() - smalldeque_.begin(), smalldeque_.size());
+  ASSERT_EQ(smalldeque_.end() - smalldeque_.size(), smalldeque_.begin());
 
   {
-    auto iter = smallDeque_.begin();
-    for (size_t i = 0; i < smallDeque_.size(); ++i) {
-      ASSERT_EQ(iter, smallDeque_.begin() + i);
+    auto iter = smalldeque_.begin();
+    for (size_t i = 0; i < smalldeque_.size(); ++i) {
+      ASSERT_EQ(iter, smalldeque_.begin() + i);
       ++iter;
     }
-    ASSERT_EQ(iter, smallDeque_.end());
+    ASSERT_EQ(iter, smalldeque_.end());
   }
 
   {
-    auto iter = smallDeque_.begin();
-    for (size_t i = 0; i < smallDeque_.size(); ++i) {
-      ASSERT_EQ(iter->number_, smallDeque_[i].number_);
+    auto iter = smalldeque_.begin();
+    for (size_t i = 0; i < smalldeque_.size(); ++i) {
+      ASSERT_EQ(iter->number_, smalldeque_[i].number_);
       ++iter;
     }
   }
 
   {
-    auto iter = smallDeque_.end() - 1;
-    for (size_t i = 0; i < smallDeque_.size(); ++i) {
-      ASSERT_EQ(iter->number_, smallDeque_[smallDeque_.size() - 1 - i].number_);
-      if (i < smallDeque_.size() - 1) {
+    auto iter = smalldeque_.end() - 1;
+    for (size_t i = 0; i < smalldeque_.size(); ++i) {
+      ASSERT_EQ(iter->number_, smalldeque_[smalldeque_.size() - 1 - i].number_);
+      if (i < smalldeque_.size() - 1) {
         --iter;
       }
     }
   }
 
   {
-    auto iter_incr = smallDeque_.begin();
-    auto iter_plus = smallDeque_.begin();
-    for (; iter_incr != smallDeque_.end(); ++iter_incr, iter_plus += 1) {
+    auto iter_incr = smalldeque_.begin();
+    auto iter_plus = smalldeque_.begin();
+    for (; iter_incr != smalldeque_.end(); ++iter_incr, iter_plus += 1) {
       ASSERT_EQ(iter_incr, iter_plus);
     }
   }
 
   {
-    for (size_t step = 1; step < smallDeque_.size(); ++step) {
-      auto iter = smallDeque_.begin();
-      for (size_t i = 0; i < smallDeque_.size(); i += step) {
+    for (size_t step = 1; step < smalldeque_.size(); ++step) {
+      auto iter = smalldeque_.begin();
+      for (size_t i = 0; i < smalldeque_.size(); i += step) {
         ASSERT_EQ(i, (iter + i)->number_);
       }
     }
@@ -877,21 +776,21 @@ TEST_F(IteratorsTests, IteratorArithmetics) {
 
 TEST_F(IteratorsTests, IteratorComparison) {
   {
-    for (size_t i = 0; i < smallDeque_.size(); ++i) {
-      ASSERT_GT(smallDeque_.end(), smallDeque_.begin() + i);
-      ASSERT_GT(smallDeque_.cend(), smallDeque_.cbegin() + i);
-      ASSERT_GT(smallDeque_.rend(), smallDeque_.rbegin() + i);
-      ASSERT_GT(smallDeque_.crend(), smallDeque_.crbegin() + i);
+    for (size_t i = 0; i < smalldeque_.size(); ++i) {
+      ASSERT_GT(smalldeque_.end(), smalldeque_.begin() + i);
+      ASSERT_GT(smalldeque_.cend(), smalldeque_.cbegin() + i);
+      ASSERT_GT(smalldeque_.rend(), smalldeque_.rbegin() + i);
+      ASSERT_GT(smalldeque_.crend(), smalldeque_.crbegin() + i);
     }
 
-    ASSERT_EQ(smallDeque_.end(), smallDeque_.begin() + smallDeque_.size());
-    ASSERT_EQ(smallDeque_.cend(), smallDeque_.cbegin() + smallDeque_.size());
-    ASSERT_EQ(smallDeque_.rend(), smallDeque_.rbegin() + smallDeque_.size());
-    ASSERT_EQ(smallDeque_.crend(), smallDeque_.crbegin() + smallDeque_.size());
+    ASSERT_EQ(smalldeque_.end(), smalldeque_.begin() + smalldeque_.size());
+    ASSERT_EQ(smalldeque_.cend(), smalldeque_.cbegin() + smalldeque_.size());
+    ASSERT_EQ(smalldeque_.rend(), smalldeque_.rbegin() + smalldeque_.size());
+    ASSERT_EQ(smalldeque_.crend(), smalldeque_.crbegin() + smalldeque_.size());
   }
 
   {
-    Deque<Unique> empty;
+    deque<Unique> empty;
     ASSERT_EQ(empty.end() - empty.begin(), 0);
     ASSERT_EQ(empty.begin() + 0, empty.end());
     ASSERT_EQ(empty.end() - 0, empty.begin());
@@ -911,7 +810,7 @@ TEST_F(IteratorsTests, IteratorComparison) {
 }
 
 TEST_F(IteratorsTests, IteratorsAlgorithms) {
-  Deque<int> d(1000);
+  deque<int> d(1000);
   std::iota(d.begin(), d.end(), 13);
   std::mt19937 g(31415);
   std::shuffle(d.begin(), d.end(), g);
@@ -923,73 +822,73 @@ TEST_F(IteratorsTests, IteratorsAlgorithms) {
 
 TEST_F(IteratorsTests, IteratorsInvalidationAfterPop) {
   {
-    auto iter = smallDeque_.begin();
-    for (size_t i = 0; i < smallDeque_.size(); ++i) {
-      ASSERT_EQ(iter->number_, smallDeque_[i].number_);
+    auto iter = smalldeque_.begin();
+    for (size_t i = 0; i < smalldeque_.size(); ++i) {
+      ASSERT_EQ(iter->number_, smalldeque_[i].number_);
       ++iter;
     }
   }
 
   {
-    std::vector<Deque<UniqueDefaultConstructed>::iterator> iterators;
-    for (size_t i = 0; i <= smallDeque_.size(); ++i) {
-      iterators.push_back(smallDeque_.begin() + i);
+    std::vector<deque<UniqueDefaultConstructed>::iterator> iterators;
+    for (size_t i = 0; i <= smalldeque_.size(); ++i) {
+      iterators.push_back(smalldeque_.begin() + i);
     }
 
-    size_t start = 0, end = smallDeque_.size();
+    size_t start = 0, end = smalldeque_.size();
     while (start < end) {
-      smallDeque_.pop_front();
+      smalldeque_.pop_front();
       ++start;
       for (size_t i = start; i < end; ++i) {
         ASSERT_EQ(iterators[i]->number_, i);
-        ASSERT_EQ(iterators[i], smallDeque_.begin() + i - start);
-        ASSERT_EQ(&*iterators[i], &smallDeque_[i - start]);
+        ASSERT_EQ(iterators[i], smalldeque_.begin() + i - start);
+        ASSERT_EQ(&*iterators[i], &smalldeque_[i - start]);
       }
-      ASSERT_EQ(iterators[end], smallDeque_.end());
+      ASSERT_EQ(iterators[end], smalldeque_.end());
     }
   }
 
   {
-    std::vector<Deque<UniqueDefaultConstructed>::iterator> iterators;
-    for (size_t i = 0; i <= smallDeque_.size(); ++i) {
-      iterators.push_back(smallDeque_.begin() + i);
+    std::vector<deque<UniqueDefaultConstructed>::iterator> iterators;
+    for (size_t i = 0; i <= smalldeque_.size(); ++i) {
+      iterators.push_back(smalldeque_.begin() + i);
     }
 
-    size_t start = 0, end = smallDeque_.size();
+    size_t start = 0, end = smalldeque_.size();
     while (start < end) {
-      smallDeque_.pop_back();
+      smalldeque_.pop_back();
       --end;
       for (size_t i = start; i < end; ++i) {
         ASSERT_EQ(iterators[i]->number_, i);
-        ASSERT_EQ(iterators[i], smallDeque_.begin() + i - start);
-        ASSERT_EQ(&*iterators[i], &smallDeque_[i - start]);
+        ASSERT_EQ(iterators[i], smalldeque_.begin() + i - start);
+        ASSERT_EQ(&*iterators[i], &smalldeque_[i - start]);
       }
-      ASSERT_EQ(iterators[end], smallDeque_.end());
+      ASSERT_EQ(iterators[end], smalldeque_.end());
     }
   }
 
   {
-    std::vector<Deque<UniqueDefaultConstructed>::iterator> iterators;
-    for (size_t i = 0; i <= smallDeque_.size(); ++i) {
-      iterators.push_back(smallDeque_.begin() + i);
+    std::vector<deque<UniqueDefaultConstructed>::iterator> iterators;
+    for (size_t i = 0; i <= smalldeque_.size(); ++i) {
+      iterators.push_back(smalldeque_.begin() + i);
     }
 
-    size_t start = 0, end = smallDeque_.size();
+    size_t start = 0, end = smalldeque_.size();
     for (size_t round = 0; start < end; ++round) {
       if (round % 2 == 0) {
-        smallDeque_.pop_back();
+        smalldeque_.pop_back();
         --end;
       } else {
-        smallDeque_.pop_front();
+        smalldeque_.pop_front();
         ++start;
       }
 
       for (size_t i = start; i < end; ++i) {
         ASSERT_EQ(iterators[i]->number_, i);
-        ASSERT_EQ(iterators[i], smallDeque_.begin() + i - start);
-        ASSERT_EQ(&*iterators[i], &smallDeque_[i - start]);
+        ASSERT_EQ(iterators[i], smalldeque_.begin() + i - start);
+        ASSERT_EQ(&*iterators[i], &smalldeque_[i - start]);
       }
-      ASSERT_EQ(iterators[end], smallDeque_.end());
+      ASSERT_EQ(iterators[end], smalldeque_.end());
     }
   }
 }
@@ -997,24 +896,24 @@ TEST_F(IteratorsTests, IteratorsInvalidationAfterPop) {
 TEST_F(IteratorsTests, PointerAndReferenceInvalidationAfterPush) {
   {
     std::vector<UniqueDefaultConstructed *> pointers;
-    for (size_t i = 0; i < smallDeque_.size(); ++i) {
-      pointers.push_back(&smallDeque_[i]);
+    for (size_t i = 0; i < smalldeque_.size(); ++i) {
+      pointers.push_back(&smalldeque_[i]);
     }
 
-    size_t start = 0, end = smallDeque_.size();
+    size_t start = 0, end = smalldeque_.size();
     for (size_t round = 0; round < 100; ++round) {
       if (round % 2 == 0) {
-        smallDeque_.push_back(UniqueDefaultConstructed());
+        smalldeque_.push_back(UniqueDefaultConstructed());
       } else {
-        smallDeque_.push_front(UniqueDefaultConstructed());
+        smalldeque_.push_front(UniqueDefaultConstructed());
         ++start;
         ++end;
       }
 
       for (size_t i = start; i < end; ++i) {
         ASSERT_EQ(pointers[i - start]->number_, i - start);
-        ASSERT_EQ(pointers[i - start], &smallDeque_[i]);
-        ASSERT_EQ(pointers[i - start], &*(smallDeque_.begin() + i));
+        ASSERT_EQ(pointers[i - start], &smalldeque_[i]);
+        ASSERT_EQ(pointers[i - start], &*(smalldeque_.begin() + i));
       }
     }
   }
@@ -1024,8 +923,8 @@ class InsertEraseTests : public ::testing::Test {
 protected:
   const size_t kSmallSize = 10;
   const size_t kBigSize = 10000000;
-  Deque<UniqueDefaultConstructed> smallDeque_;
-  Deque<UniqueDefaultConstructed> bigDeque_;
+  deque<UniqueDefaultConstructed> smalldeque_;
+  deque<UniqueDefaultConstructed> bigdeque_;
 
   InsertEraseTests() {}
   virtual ~InsertEraseTests() {}
@@ -1033,8 +932,8 @@ class InsertEraseTests : public ::testing::Test {
     Accountant::ResetAll();
     Unique::Reset();
     UniqueDefaultConstructed::Reset();
-    smallDeque_ = Deque<UniqueDefaultConstructed>(kSmallSize);
-    bigDeque_ = Deque<UniqueDefaultConstructed>(kBigSize);
+    smalldeque_ = deque<UniqueDefaultConstructed>(kSmallSize);
+    bigdeque_ = deque<UniqueDefaultConstructed>(kBigSize);
   }
   virtual void TearDown() {
     Accountant::ResetAll();
@@ -1045,52 +944,52 @@ class InsertEraseTests : public ::testing::Test {
 
 TEST_F(InsertEraseTests, InsertErase) {
   {
-    smallDeque_.insert(smallDeque_.begin() + kSmallSize / 2,
+    smalldeque_.insert(smalldeque_.begin() + kSmallSize / 2,
                        UniqueDefaultConstructed());
-    ASSERT_EQ(kSmallSize + 1, smallDeque_.size());
+    ASSERT_EQ(kSmallSize + 1, smalldeque_.size());
     for (size_t i = 0; i < kSmallSize / 2; ++i) {
-      ASSERT_EQ(i, smallDeque_[i].number_);
+      ASSERT_EQ(i, smalldeque_[i].number_);
     }
-    ASSERT_EQ(kSmallSize + kBigSize, smallDeque_[kSmallSize / 2].number_);
+    ASSERT_EQ(kSmallSize + kBigSize, smalldeque_[kSmallSize / 2].number_);
     for (size_t i = kSmallSize / 2; i < kSmallSize; ++i) {
-      ASSERT_EQ(i, smallDeque_[i + 1].number_);
+      ASSERT_EQ(i, smalldeque_[i + 1].number_);
     }
   }
 
   {
-    bigDeque_.insert(bigDeque_.begin() + kBigSize / 2,
+    bigdeque_.insert(bigdeque_.begin() + kBigSize / 2,
                      UniqueDefaultConstructed());
-    ASSERT_EQ(kBigSize + 1, bigDeque_.size());
+    ASSERT_EQ(kBigSize + 1, bigdeque_.size());
     for (size_t i = 0; i < kBigSize / 2; ++i) {
-      ASSERT_EQ(i + kSmallSize, bigDeque_[i].number_);
+      ASSERT_EQ(i + kSmallSize, bigdeque_[i].number_);
     }
-    ASSERT_EQ(kSmallSize + kBigSize + 1, bigDeque_[kBigSize / 2].number_);
+    ASSERT_EQ(kSmallSize + kBigSize + 1, bigdeque_[kBigSize / 2].number_);
     for (size_t i = kBigSize / 2; i < kBigSize; ++i) {
-      ASSERT_EQ(i + kSmallSize, bigDeque_[i + 1].number_);
+      ASSERT_EQ(i + kSmallSize, bigdeque_[i + 1].number_);
     }
   }
 
   {
-    smallDeque_.erase(smallDeque_.begin() + kSmallSize / 2 - 1);
-    ASSERT_EQ(kSmallSize, smallDeque_.size());
+    smalldeque_.erase(smalldeque_.begin() + kSmallSize / 2 - 1);
+    ASSERT_EQ(kSmallSize, smalldeque_.size());
     for (size_t i = 0; i < kSmallSize / 2 - 1; ++i) {
-      ASSERT_EQ(i, smallDeque_[i].number_);
+      ASSERT_EQ(i, smalldeque_[i].number_);
     }
-    ASSERT_EQ(kSmallSize + kBigSize, smallDeque_[kSmallSize / 2 - 1].number_);
+    ASSERT_EQ(kSmallSize + kBigSize, smalldeque_[kSmallSize / 2 - 1].number_);
     for (size_t i = kSmallSize / 2; i < kSmallSize; ++i) {
-      ASSERT_EQ(i, smallDeque_[i].number_);
+      ASSERT_EQ(i, smalldeque_[i].number_);
     }
   }
 
   {
-    bigDeque_.erase(bigDeque_.begin() + kBigSize / 2 - 1);
-    ASSERT_EQ(kBigSize, bigDeque_.size());
+    bigdeque_.erase(bigdeque_.begin() + kBigSize / 2 - 1);
+    ASSERT_EQ(kBigSize, bigdeque_.size());
     for (size_t i = 0; i < kBigSize / 2 - 1; ++i) {
-      ASSERT_EQ(i + kSmallSize, bigDeque_[i].number_);
+      ASSERT_EQ(i + kSmallSize, bigdeque_[i].number_);
     }
-    ASSERT_EQ(kSmallSize + kBigSize + 1, bigDeque_[kBigSize / 2 - 1].number_);
+    ASSERT_EQ(kSmallSize + kBigSize + 1, bigdeque_[kBigSize / 2 - 1].number_);
     for (size_t i = kBigSize / 2; i < kBigSize; ++i) {
-      ASSERT_EQ(i + kSmallSize, bigDeque_[i].number_);
+      ASSERT_EQ(i + kSmallSize, bigdeque_[i].number_);
     }
   }
 }
@@ -1169,20 +1068,20 @@ class ExceptionTests : public ::testing::Test {
 };
 
 TEST_F(ExceptionTests, ThrowsExceptions) {
-  ASSERT_THROW([]() { Deque<Counted<17>> d(100); }(), CountedException);
+  ASSERT_THROW([]() { deque<Counted<17>> d(100); }(), CountedException);
   try {
-    Deque<Counted<17>> d(100);
+    deque<Counted<17>> d(100);
   } catch (CountedException &) {
     ASSERT_EQ(Counted<17>::counter, 0);
   }
 
-  ASSERT_THROW([]() { Deque<Explosive> d(100); }(), int);
-  ASSERT_NO_THROW([]() { Deque<Explosive> d; }());
+  ASSERT_THROW([]() { deque<Explosive> d(100); }(), int);
+  ASSERT_NO_THROW([]() { deque<Explosive> d; }());
   ASSERT_FALSE(Explosive::exploded);
 
   ASSERT_THROW(
       []() {
-        Deque<Explosive> d;
+        deque<Explosive> d;
         auto safe = Explosive(Explosive::Safeguard{});
         d.push_back(safe);
       }(),
@@ -1193,7 +1092,7 @@ TEST_F(ExceptionTests, ThrowsExceptions) {
 TEST_F(ExceptionTests, StrongGuarantee) {
   const size_t size = 20'000;
   const size_t initial_data = 100;
-  Deque<Fragile> d(size, Fragile(size, initial_data));
+  deque<Fragile> d(size, Fragile(size, initial_data));
 
   auto is_intact = [&] {
     return d.size() == size &&