fix(array): fix various bugs with array clearing

storm/array/TSBaseArray.hpp

@@ -8,17 +8,20 @@
 template <class T>
 class TSBaseArray {
     public:
-    uint32_t m_alloc = 0;
+    // Member variables
-    uint32_t m_count = 0;
+    uint32_t m_alloc;
-    T* m_data = nullptr;
+    uint32_t m_count;
+    T* m_data;
 
+    // Virtual member functions
     virtual const char* MemFileName() const;
     virtual int32_t MemLineNo() const;
 
+    // Member functions
     T& operator[](uint32_t index);
     void CheckArrayBounds(uint32_t index) const;
+    void Constructor();
     uint32_t Count() const;
-    void Clear();
     T* Ptr();
     const T* Ptr() const;
     T* Top();
@@ -48,14 +51,15 @@ void TSBaseArray<T>::CheckArrayBounds(uint32_t index) const {
 }
 
 template <class T>
-uint32_t TSBaseArray<T>::Count() const {
+void TSBaseArray<T>::Constructor() {
-    return this->m_count;
+    this->m_alloc = 0;
+    this->m_count = 0;
+    this->m_data = nullptr;
 }
 
 template <class T>
-void TSBaseArray<T>::Clear() {
+uint32_t TSBaseArray<T>::Count() const {
-    delete[] this->m_data;
+    return this->m_count;
-    TSBaseArray<T>();
 }
 
 template <class T>

storm/array/TSFixedArray.hpp

@@ -8,14 +8,21 @@
 template <class T>
 class TSFixedArray : public TSBaseArray<T> {
     public:
+    TSFixedArray();
     ~TSFixedArray();
     TSFixedArray<T>& operator=(const TSFixedArray<T>& source);
+    void Clear();
     void ReallocAndClearData(uint32_t count);
     void ReallocData(uint32_t count);
     void Set(uint32_t count, const T* data);
     void SetCount(uint32_t count);
 };
 
+template <class T>
+TSFixedArray<T>::TSFixedArray() {
+    this->Constructor();
+}
+
 template <class T>
 TSFixedArray<T>::~TSFixedArray() {
     for (uint32_t i = 0; i < this->Count(); i++) {
@@ -37,6 +44,12 @@ TSFixedArray<T>& TSFixedArray<T>::operator=(const TSFixedArray<T>& source) {
   return *this;
 }
 
+template <class T>
+void TSFixedArray<T>::Clear() {
+  this->~TSFixedArray<T>();
+  this->Constructor();
+}
+
 template <class T>
 void TSFixedArray<T>::ReallocAndClearData(uint32_t count) {
     this->m_alloc = count;

test/Array.cpp

@@ -9,7 +9,7 @@ struct TestArrayObject {
 TEST_CASE("TSBaseArray", "[array]") {
     SECTION("constructs correctly") {
         TSBaseArray<uint32_t> array;
-        REQUIRE(array.Count() == 0);
+        SUCCEED();
     }
 }
 
@@ -31,6 +31,52 @@ TEST_CASE("TSFixedArray", "[array]") {
     SECTION("constructs correctly") {
         TSFixedArray<uint32_t> array;
         REQUIRE(array.Count() == 0);
+        REQUIRE(array.Ptr() == nullptr);
+    }
+}
+
+TEST_CASE("TSFixedArray::Clear", "[array]") {
+    SECTION("clears already empty array") {
+        TSFixedArray<uint32_t> array;
+        array.Clear();
+
+        CHECK(array.Count() == 0);
+        CHECK(array.Ptr() == nullptr);
+    }
+
+    SECTION("clears non-empty array") {
+        TSFixedArray<uint32_t> array;
+        array.SetCount(10);
+
+        CHECK(array.Count() == 10);
+        CHECK(array.Ptr() != nullptr);
+
+        array.Clear();
+
+        CHECK(array.Count() == 0);
+        CHECK(array.Ptr() == nullptr);
+    }
+
+    SECTION("permits setting entry after clearing and resizing") {
+        TSFixedArray<uint32_t> array;
+        array.SetCount(1);
+        array[0] = 1234;
+
+        CHECK(array.Count() == 1);
+        CHECK(array.Ptr() != nullptr);
+        CHECK(array[0] == 1234);
+
+        array.Clear();
+
+        CHECK(array.Count() == 0);
+        CHECK(array.Ptr() == nullptr);
+
+        array.SetCount(1);
+        array[0] = 4567;
+
+        CHECK(array.Count() == 1);
+        CHECK(array.Ptr() != nullptr);
+        CHECK(array[0] == 4567);
     }
 }