Add test for history buffer.

Author: rpavlik

CMakeLists.txt

@@ -65,6 +65,7 @@ if(VPR20_FOUND OR VPR22_FOUND)
 endif()
 find_package(GMTL)
 find_package(OpenSceneGraph)
+find_package(Catch2)
 find_package(Eigen3)
 
 set(Boost_USE_STATIC_LIBS ON)

tests/CMakeLists.txt

@@ -257,4 +257,11 @@ if(NOT MSVC)
 	endif()
 endif()
 
+if(Catch2_FOUND)
+	add_executable(test_HistoryBuffer HistoryBuffer.cpp)
+	target_link_libraries(test_HistoryBuffer PRIVATE Catch2::Catch2)
+	add_test(NAME HistoryBuffer COMMAND test_HistoryBuffer HistoryBuffer)
+	add_test(NAME HistoryBuffer_IteratorBase COMMAND test_HistoryBuffer IteratorBase)
+endif()
+
 add_subdirectory(cleanbuild)

tests/HistoryBuffer.cpp

@@ -0,0 +1,209 @@
+// Copyright 2021, Collabora, Ltd.
+// SPDX-License-Identifier: BSL-1.0
+/*!
+ * @file
+ * @brief HistoryBuffer collection tests.
+ * @author Ryan Pavlik <ryan.pavlik@collabora.com>
+ */
+
+#include <iostream>
+#include <util/HistoryBuffer.h>
+
+using util::HistoryBuffer;
+
+template <typename Container>
+static inline std::ostream &
+operator<<(std::ostream &os,
+           const util::RandomAccessIteratorBase<Container> &iter_base) {
+    os << "Iterator@[" << iter_base.index() << "]";
+    return os;
+}
+
+#define CATCH_CONFIG_MAIN
+
+#include "catch/catch.hpp"
+
+TEST_CASE("HistoryBuffer") {
+    HistoryBuffer<int, 4> buffer;
+    SECTION("behavior when empty") {
+        CHECK(buffer.empty());
+        CHECK(0 == buffer.size());
+        CHECK_FALSE(buffer.begin().valid());
+        CHECK_FALSE(buffer.end().valid());
+        CHECK(buffer.begin() == buffer.end());
+    }
+    SECTION("behavior with one") {
+        buffer.push_back(0);
+        CHECK_FALSE(buffer.empty());
+        CHECK(buffer.size() == 1);
+
+        // check iterators
+        CHECK(buffer.begin().valid());
+        CHECK_FALSE(buffer.end().valid());
+        CHECK_FALSE(buffer.begin() == buffer.end());
+        {
+            auto it = buffer.end();
+            // should be permanently cleared
+            ++it;
+            CHECK_FALSE(it.valid());
+            --it;
+            CHECK_FALSE(it.valid());
+        }
+        CHECK(buffer.begin() == buffer.cbegin());
+        CHECK(buffer.end() == buffer.cend());
+
+        // can we decrement our past-the-end iterator to get the begin iterator?
+        CHECK(buffer.begin() == --(buffer.end()));
+
+        // make sure post-decrement works right
+        CHECK_FALSE(buffer.begin() == (buffer.end())--);
+
+        // make sure post-increment works right
+        CHECK(buffer.begin() == buffer.begin()++);
+
+        // make sure pre-increment works right
+        CHECK_FALSE(buffer.begin() == ++(buffer.begin()));
+
+        // check contents
+        CHECK_NOTHROW(buffer.get_at_index(0));
+        CHECK_FALSE(buffer.get_at_index(0) == nullptr);
+        CHECK(*buffer.get_at_index(0) == 0);
+
+        CHECK_FALSE(buffer.get_at_age(0) == nullptr);
+        CHECK(*buffer.get_at_age(0) == 0);
+        CHECK_FALSE(buffer.get_at_clamped_age(0) == nullptr);
+        CHECK(*buffer.get_at_clamped_age(0) == 0);
+
+        CHECK(buffer.get_at_age(1) == nullptr);
+
+        CHECK_FALSE(buffer.get_at_clamped_age(1) == nullptr);
+        CHECK(*buffer.get_at_clamped_age(1) == 0);
+
+        CHECK_FALSE(buffer.get_at_clamped_age(2) == nullptr);
+        CHECK(*buffer.get_at_clamped_age(2) == 0);
+
+        CHECK_NOTHROW(buffer.front());
+        CHECK(buffer.front() == 0);
+
+        CHECK_NOTHROW(buffer.back());
+        CHECK(buffer.back() == 0);
+
+        CHECK(*buffer.begin() == buffer.front());
+    }
+
+    SECTION("behavior with two") {
+        buffer.push_back(0);
+        buffer.push_back(1);
+        CHECK_FALSE(buffer.empty());
+        CHECK(buffer.size() == 2);
+        SECTION("check iterators") {
+            // check iterators
+            CHECK(buffer.begin().valid());
+            CHECK_FALSE(buffer.end().valid());
+            CHECK_FALSE(buffer.begin() == buffer.end());
+            {
+                auto it = buffer.end();
+                // should be permanently cleared
+                ++it;
+                CHECK_FALSE(it.valid());
+                --it;
+                CHECK_FALSE(it.valid());
+            }
+            CHECK(buffer.begin() == buffer.cbegin());
+            CHECK(buffer.end() == buffer.cend());
+
+            // can we decrement our past-the-end iterator to get the begin
+            // iterator?
+            CHECK(buffer.begin() == --(--(buffer.end())));
+
+            // make sure post-decrement works right
+            CHECK_FALSE(buffer.begin() == (buffer.end())--);
+
+            // make sure post-increment works right
+            CHECK(buffer.begin() == buffer.begin()++);
+
+            // make sure pre-increment works right
+            CHECK_FALSE(buffer.begin() == ++(buffer.begin()));
+        }
+        SECTION("check contents") {
+            // check contents
+            CHECK_NOTHROW(buffer.get_at_index(0));
+            CHECK_FALSE(buffer.get_at_index(0) == nullptr);
+            CHECK(*buffer.get_at_index(0) == 0);
+            CHECK_FALSE(buffer.get_at_index(1) == nullptr);
+            CHECK(*buffer.get_at_index(1) == 1);
+            CHECK(buffer.get_at_index(2) == nullptr);
+
+            CHECK_NOTHROW(buffer.get_at_age(0));
+            CHECK_FALSE(buffer.get_at_age(0) == nullptr);
+            CHECK(*buffer.get_at_age(0) == 1);
+            CHECK_FALSE(buffer.get_at_clamped_age(0) == nullptr);
+            CHECK(*buffer.get_at_clamped_age(0) == 1);
+
+            CHECK_FALSE(buffer.get_at_age(1) == nullptr);
+            CHECK(*buffer.get_at_age(1) == 0);
+            CHECK_FALSE(buffer.get_at_clamped_age(1) == nullptr);
+            CHECK(*buffer.get_at_clamped_age(1) == 0);
+
+            CHECK(buffer.get_at_age(2) == nullptr);
+
+            CHECK_FALSE(buffer.get_at_clamped_age(2) == nullptr);
+            CHECK(*buffer.get_at_clamped_age(2) == 0);
+
+            CHECK_FALSE(buffer.get_at_clamped_age(3) == nullptr);
+            CHECK(*buffer.get_at_clamped_age(3) == 0);
+
+            CHECK_NOTHROW(buffer.front());
+            CHECK(buffer.front() == 0);
+
+            CHECK_NOTHROW(buffer.back());
+            CHECK(buffer.back() == 1);
+
+            CHECK(*buffer.begin() == buffer.front());
+            CHECK(buffer.back() == *(--buffer.end()));
+        }
+    }
+
+    SECTION("algorithm behavior with 3") {
+        buffer.push_back(0);
+        buffer.push_back(2);
+        buffer.push_back(4);
+        CHECK_FALSE(buffer.empty());
+        CHECK(buffer.size() == 3);
+        CHECK(buffer.begin() == std::find(buffer.begin(), buffer.end(), 0));
+        CHECK(++(buffer.begin()) == std::find(buffer.begin(), buffer.end(), 2));
+        CHECK(buffer.end() == std::find(buffer.begin(), buffer.end(), 5));
+
+        CHECK(++(buffer.begin()) ==
+              std::lower_bound(buffer.begin(), buffer.end(), 1));
+    }
+}
+
+TEST_CASE("IteratorBase") {
+
+    HistoryBuffer<int, 4> buffer;
+    buffer.push_back(0);
+    buffer.push_back(2);
+    buffer.push_back(4);
+    using namespace util;
+    using const_iterator = typename HistoryBuffer<int, 4>::const_iterator;
+    const_iterator default_constructed{};
+    const_iterator begin_constructed = buffer.begin();
+    const_iterator end_constructed = buffer.end();
+
+    SECTION("Check default constructed") {
+        CHECK_FALSE(default_constructed.valid());
+        CHECK(default_constructed.is_cleared());
+    }
+    SECTION("Check begin constructed") {
+        CHECK(begin_constructed.valid());
+        CHECK_FALSE(begin_constructed.is_cleared());
+        CHECK((--begin_constructed).is_cleared());
+    }
+    SECTION("Check end constructed") {
+        CHECK_FALSE(end_constructed.valid());
+        CHECK_FALSE(end_constructed.is_cleared());
+        // if we go past the end, we can go backwards into validity.
+        CHECK_FALSE((++end_constructed).is_cleared());
+    }
+}