From b778751254480fd51e303f8d33804fe3c7c2fb91 Mon Sep 17 00:00:00 2001
From: karl <karl.bittner@hexaquo.at>
Date: Mon, 15 Mar 2021 16:25:02 +0100
Subject: [PATCH] More tests and corresponding fixes

especially related to destructor calls
---
 Vector.h |  9 ++++---
 test.cpp | 81 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 87 insertions(+), 3 deletions(-)

diff --git a/Vector.h b/Vector.h
index 5cd8690..35bb3f9 100644
--- a/Vector.h
+++ b/Vector.h
@@ -43,7 +43,10 @@ class Vector {
 
     // Destructor
     ~Vector() {
-        delete[] data;
+        for (unsigned int i = 0; i < element_count; i++) {
+            data[i].~T();
+        }
+        ::operator delete(data, capacity * sizeof(T));
     }
 
     // Bracket Operator for accessing elements
@@ -164,7 +167,7 @@ class Vector {
             }
         } else if (difference < 0) {
             // Call the destructor on all excess items
-            for (int i = -1; i > difference; i--) {
+            for (int i = -1; i >= difference; i--) {
                 data[element_count + i].~T();
             }
 
@@ -206,7 +209,7 @@ class Vector {
     void reallocate(unsigned int new_size) {
         T *new_data = (T *)::operator new(new_size * sizeof(T));
         std::copy(data, data + element_count, new_data);
-        delete[] data;
+        ::operator delete(data, capacity * sizeof(T));
 
         data = new_data;
     }
diff --git a/test.cpp b/test.cpp
index 69f0f7c..c996635 100644
--- a/test.cpp
+++ b/test.cpp
@@ -296,4 +296,85 @@ SCENARIO("Erase by swap", "[vector]") {
             }
         }
     }
+}
+
+unsigned int count = 0;
+
+class ReferenceCounter {
+  public:
+    ReferenceCounter() {
+        count++;
+    }
+
+    ReferenceCounter(const ReferenceCounter &) {
+        count++;
+    }
+
+    ReferenceCounter(ReferenceCounter &&) {
+        count++;
+    }
+
+    ReferenceCounter &operator=(const ReferenceCounter &) {
+        return *this;
+    }
+
+    ReferenceCounter &operator=(ReferenceCounter &&) {
+        return *this;
+    }
+
+    ~ReferenceCounter() {
+        count--;
+    }
+};
+
+SCENARIO("Constructors and Destructors are called as expected", "[vector]") {
+    GIVEN("A vector with a custom reference-counting class") {
+
+        Vector<ReferenceCounter> v(3);
+        v.push_back(ReferenceCounter());
+        v.push_back(ReferenceCounter());
+        v.push_back(ReferenceCounter());
+
+        REQUIRE(count == 3);
+
+        WHEN("Erasing the first element") {
+            v.erase(0);
+
+            THEN("The reference count should have decreased") {
+                REQUIRE(count == 2);
+            }
+        }
+
+        WHEN("Erasing by swap") {
+            v.erase_by_swap(0);
+
+            THEN("The reference count should have decreased") {
+                REQUIRE(count == 2);
+            }
+        }
+
+        WHEN("Resizing to 1") {
+            v.resize(1);
+
+            THEN("The reference count should be 1") {
+                REQUIRE(count == 1);
+            }
+        }
+
+        WHEN("Resizing to 10") {
+            v.resize(10);
+
+            THEN("The reference count should be 10") {
+                REQUIRE(count == 10);
+            }
+        }
+
+        WHEN("Move-constructing another vector") {
+            Vector<ReferenceCounter> v2 = std::move(v);
+
+            THEN("The reference count should have remained the same") {
+                REQUIRE(count == 3);
+            }
+        }
+    }
 }
\ No newline at end of file