Add vector and option.

1 files changed, 138 insertions, 0 deletions

diff --git a/test/test_vector.cpp b/test/test_vector.cpp
new file mode 100644
index 0000000..b4fd83c
--- /dev/null
+++ b/test/test_vector.cpp
@@ -0,0 +1,138 @@
+/*
+ * libfud
+ * Copyright 2024 Dominick Allen
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "fud_vector.hpp"
+
+#include "gtest/gtest.h"
+
+namespace fud {
+
+TEST(VectorTest, TrivialVector)
+{
+    Vector<int> intVector{};
+    ASSERT_EQ(intVector.size(), 0);
+    ASSERT_EQ(intVector.capacity(), 0);
+    ASSERT_TRUE(intVector.ref(0).isError());
+
+    ASSERT_EQ(intVector.resize(10), FudStatus::Success);
+    ASSERT_EQ(intVector.size(), 10);
+    ASSERT_EQ(intVector.capacity(), 10);
+
+    ASSERT_TRUE(intVector.ref(0).isOkay());
+    ASSERT_EQ(intVector.ref(0).getOkay(), 0);
+    intVector.get(0).takeOkay().get() = 10;
+    ASSERT_EQ(intVector.ref(0).getOkay(), 10);
+}
+
+struct NonTrivial {
+    static thread_local int counter;
+    NonTrivial()
+    {
+        counter++;
+    }
+    explicit NonTrivial(int val) : value{val}
+    {
+        counter++;
+    }
+    NonTrivial(const NonTrivial&) = delete;
+    NonTrivial(NonTrivial&& rhs) : value{rhs.value}, destroyed{rhs.destroyed}
+    {
+        rhs.destroyed = true;
+    }
+    ~NonTrivial()
+    {
+        if (!destroyed) {
+            counter--;
+            destroyed = true;
+        }
+    }
+    NonTrivial& operator=(const NonTrivial& rhs) = delete;
+    NonTrivial& operator=(NonTrivial&& rhs) {
+        value = rhs.value;
+        destroyed = rhs.destroyed;
+        rhs.destroyed = true;
+        return *this;
+    }
+    int value{0};
+    bool destroyed{false};
+};
+
+int thread_local NonTrivial::counter = 0;
+
+TEST(VectorTest, NonTrivialVector)
+{
+    auto& counter = NonTrivial::counter;
+    counter = 0;
+    Vector<NonTrivial> nonTrivialVector{};
+    ASSERT_EQ(nonTrivialVector.size(), 0);
+    ASSERT_EQ(nonTrivialVector.capacity(), 0);
+    ASSERT_TRUE(nonTrivialVector.ref(0).isError());
+    ASSERT_EQ(counter, 0);
+
+    ASSERT_EQ(nonTrivialVector.resize(10), FudStatus::Success);
+    ASSERT_EQ(nonTrivialVector.size(), 10);
+    ASSERT_EQ(nonTrivialVector.capacity(), 10);
+    ASSERT_EQ(counter, 10);
+
+    ASSERT_TRUE(nonTrivialVector.ref(0).isOkay());
+    ASSERT_EQ(nonTrivialVector.ref(0).getOkay().get().value, 0);
+    nonTrivialVector.get(0).takeOkay().get().value = 10;
+    ASSERT_EQ(nonTrivialVector.ref(0).getOkay().get().value, 10);
+
+    ASSERT_EQ(nonTrivialVector.pushBack(NonTrivial{42}), FudStatus::Success);
+    ASSERT_EQ(nonTrivialVector.size(), 11);
+    ASSERT_GE(nonTrivialVector.capacity(), 11);
+    ASSERT_EQ(counter, 11);
+    auto capacity = nonTrivialVector.capacity();
+    ASSERT_EQ(nonTrivialVector.reserve(SIZE_MAX / sizeof(NonTrivial)), FudStatus::AllocFailure);
+    ASSERT_EQ(nonTrivialVector.capacity(), capacity);
+
+    {
+        auto popResult{nonTrivialVector.popBack()};
+        ASSERT_TRUE(popResult.isOkay());
+        auto value{popResult.takeOkay()};
+        ASSERT_EQ(value.value, 42);
+        ASSERT_EQ(counter, 11);
+    }
+    ASSERT_EQ(counter, 10);
+    ASSERT_EQ(nonTrivialVector.eraseBack(), FudStatus::Success);
+    ASSERT_EQ(counter, 9);
+
+    int val = 1;
+    for (auto& element: nonTrivialVector) {
+        element.value = val;
+        val++;
+    }
+    ASSERT_EQ(nonTrivialVector.insert(3, NonTrivial{13}), FudStatus::Success);
+    for (size_t idx = 0; idx < 3; ++idx) {
+        ASSERT_EQ(nonTrivialVector[idx].value, idx + 1);
+    }
+    ASSERT_EQ(counter, 10);
+    ASSERT_EQ(nonTrivialVector[3].value, 13);
+    for (size_t idx = 4; idx < nonTrivialVector.size(); ++idx) {
+        ASSERT_EQ(nonTrivialVector[idx].value, idx);
+    }
+    ASSERT_EQ(counter, nonTrivialVector.size());
+
+    ASSERT_EQ(nonTrivialVector.erase(3), FudStatus::Success);
+    for (size_t idx = 0; idx < nonTrivialVector.size(); ++idx) {
+        EXPECT_EQ(nonTrivialVector[idx].value, idx + 1);
+    }
+    ASSERT_EQ(counter, nonTrivialVector.size());
+}
+
+} // namespace fud