Merge branch 'containers'

5 files changed, 429 insertions, 36 deletions

diff --git a/test/Jamfile.jam b/test/Jamfile.jam
index 1ce73b7..3b4e891 100644
--- a/test/Jamfile.jam
+++ b/test/Jamfile.jam
@@ -58,6 +58,8 @@ run perf-assetFactory.cpp : -- : test-assetFactory : <library>benchmark <library
 run perf-persistence.cpp : -- : test-persistence : <library>benchmark <library>test ;
 run test-worker.cpp ;
 run test-instancing.cpp : : : <library>test ;
+run test-glContainer.cpp : : : <library>test ;
+run test-pack.cpp : : : <library>test ;
 compile test-static-enumDetails.cpp ;
 compile test-static-stream_support.cpp ;
 explicit perf-assetFactory ;
diff --git a/test/test-glContainer.cpp b/test/test-glContainer.cpp
new file mode 100644
index 0000000..33ec992
--- /dev/null
+++ b/test/test-glContainer.cpp
@@ -0,0 +1,355 @@
+#define BOOST_TEST_MODULE glContainer
+
+#include "testHelpers.h"
+#include "testMainWindow.h"
+#include "ui/applicationBase.h"
+#include <boost/test/data/test_case.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include "glContainer.h"
+
+BOOST_TEST_DONT_PRINT_LOG_VALUE(glContainer<int>::iterator);
+BOOST_TEST_DONT_PRINT_LOG_VALUE(glContainer<int>::const_iterator);
+BOOST_TEST_DONT_PRINT_LOG_VALUE(glContainer<int>::reserve_iterator);
+BOOST_TEST_DONT_PRINT_LOG_VALUE(glContainer<int>::const_reserve_iterator);
+
+BOOST_GLOBAL_FIXTURE(ApplicationBase);
+BOOST_GLOBAL_FIXTURE(TestMainWindow);
+
+BOOST_FIXTURE_TEST_SUITE(i, glContainer<int>)
+
+BOOST_AUTO_TEST_CASE(createDestroy, *boost::unit_test::timeout(1))
+{
+	BOOST_CHECK(!data_);
+	BOOST_CHECK_NO_THROW(map());
+	BOOST_REQUIRE(!data_);
+	BOOST_CHECK_NO_THROW(emplace_back(0));
+	BOOST_CHECK_NO_THROW(map());
+	BOOST_REQUIRE(data_);
+	BOOST_CHECK_NO_THROW(unmap());
+	BOOST_CHECK(!data_);
+}
+
+BOOST_AUTO_TEST_CASE(push_back_test, *boost::unit_test::timeout(1))
+{
+	BOOST_CHECK_EQUAL(capacity_, 1);
+	BOOST_CHECK_EQUAL(size_, 0);
+	BOOST_CHECK_NO_THROW(push_back(1));
+	BOOST_CHECK_NO_THROW(push_back(2));
+	BOOST_CHECK_NO_THROW(push_back(3));
+	BOOST_CHECK_NO_THROW(push_back(4));
+	BOOST_CHECK_EQUAL(capacity_, 4);
+	BOOST_CHECK_EQUAL(size_, 4);
+	{
+		std::array expected1 {1, 2, 3, 4};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected1.begin(), expected1.end());
+		BOOST_CHECK_EQUAL_COLLECTIONS(rbegin(), rend(), expected1.rbegin(), expected1.rend());
+	}
+}
+
+BOOST_AUTO_TEST_CASE(emplace_back_test, *boost::unit_test::timeout(1))
+{
+	BOOST_CHECK_EQUAL(capacity_, 1);
+	BOOST_CHECK_EQUAL(size_, 0);
+
+	BOOST_CHECK_NO_THROW(emplace_back(1));
+	BOOST_CHECK_NO_THROW(emplace_back(2));
+	BOOST_CHECK_EQUAL(capacity_, 2);
+	BOOST_CHECK_EQUAL(size_, 2);
+
+	BOOST_CHECK_NO_THROW(reserve(5));
+	BOOST_CHECK_EQUAL(capacity_, 5);
+	BOOST_CHECK_EQUAL(size_, 2);
+
+	BOOST_CHECK_NO_THROW(emplace_back(3));
+	BOOST_CHECK_NO_THROW(emplace_back(4));
+	BOOST_CHECK_EQUAL(capacity_, 5);
+	BOOST_CHECK_EQUAL(size_, 4);
+
+	{
+		std::array expected1 {1, 2, 3, 4};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected1.begin(), expected1.end());
+		BOOST_CHECK_EQUAL_COLLECTIONS(rbegin(), rend(), expected1.rbegin(), expected1.rend());
+	}
+
+	BOOST_CHECK_NO_THROW(emplace_back(5));
+	BOOST_CHECK_EQUAL(capacity_, 5);
+	BOOST_CHECK_EQUAL(size_, 5);
+	BOOST_CHECK_NO_THROW(emplace_back(6));
+	BOOST_CHECK_NO_THROW(emplace_back(7));
+	BOOST_CHECK_EQUAL(capacity_, 10);
+	BOOST_CHECK_EQUAL(size_, 7);
+
+	{
+		std::array expected2 {1, 2, 3, 4, 5, 6, 7};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected2.begin(), expected2.end());
+		BOOST_CHECK_EQUAL_COLLECTIONS(rbegin(), rend(), expected2.rbegin(), expected2.rend());
+	}
+
+	BOOST_CHECK_EQUAL(7, end() - begin());
+	BOOST_CHECK_EQUAL(7, rend() - rbegin());
+}
+
+BOOST_AUTO_TEST_CASE(resize_test)
+{
+	BOOST_CHECK_NO_THROW(push_back(1));
+	BOOST_CHECK_NO_THROW(emplace_back(2));
+	BOOST_CHECK_NO_THROW(resize(4));
+	BOOST_CHECK_EQUAL(capacity_, 4);
+	BOOST_CHECK_EQUAL(size_, 4);
+	{
+		std::array expected1 {1, 2, 0, 0};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected1.begin(), expected1.end());
+	}
+
+	BOOST_CHECK_NO_THROW(resize(1));
+	BOOST_CHECK_EQUAL(capacity_, 1);
+	BOOST_CHECK_EQUAL(size_, 1);
+	{
+		std::array expected2 {1};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected2.begin(), expected2.end());
+	}
+
+	BOOST_CHECK_NO_THROW(resize(1));
+	BOOST_CHECK_EQUAL(capacity_, 1);
+	BOOST_CHECK_EQUAL(size_, 1);
+
+	BOOST_CHECK_NO_THROW(resize(0));
+	BOOST_CHECK_EQUAL(capacity_, 1);
+	BOOST_CHECK_EQUAL(size_, 0);
+	BOOST_CHECK_EQUAL(begin(), end());
+	BOOST_CHECK_EQUAL(rbegin(), rend());
+}
+
+BOOST_AUTO_TEST_CASE(shrink_to_fit_test)
+{
+	BOOST_CHECK_NO_THROW(reserve(4));
+	BOOST_CHECK_NO_THROW(emplace_back(1));
+	BOOST_CHECK_NO_THROW(emplace_back(2));
+	BOOST_CHECK_EQUAL(capacity_, 4);
+	BOOST_CHECK_EQUAL(size_, 2);
+	{
+		std::array expected1 {1, 2};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected1.begin(), expected1.end());
+	}
+	BOOST_CHECK_NO_THROW(shrink_to_fit());
+	BOOST_CHECK_EQUAL(capacity_, 2);
+	BOOST_CHECK_EQUAL(size_, 2);
+	{
+		std::array expected1 {1, 2};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected1.begin(), expected1.end());
+	}
+
+	BOOST_CHECK_NO_THROW(shrink_to_fit());
+	BOOST_CHECK_EQUAL(capacity(), 2);
+	BOOST_CHECK_EQUAL(size(), 2);
+
+	BOOST_CHECK_NO_THROW(clear());
+	BOOST_CHECK_EQUAL(capacity(), 2);
+	BOOST_CHECK_EQUAL(size(), 0);
+}
+
+BOOST_AUTO_TEST_CASE(getters)
+{
+	BOOST_CHECK(empty());
+	BOOST_CHECK_NO_THROW(emplace_back(1));
+	BOOST_CHECK(!empty());
+	BOOST_CHECK_NO_THROW(emplace_back(2));
+	BOOST_CHECK_EQUAL(1, front());
+	BOOST_CHECK_EQUAL(2, back());
+	BOOST_CHECK_EQUAL(1, at(0));
+	BOOST_CHECK_EQUAL(2, at(1));
+	BOOST_CHECK_EQUAL(1, (*this)[0]);
+	BOOST_CHECK_EQUAL(2, (*this)[1]);
+	BOOST_CHECK_EQUAL(data_, data());
+	BOOST_CHECK_THROW(std::ignore = at(2), std::out_of_range);
+
+	const auto & constCont {*this};
+	BOOST_CHECK_EQUAL(1, constCont.front());
+	BOOST_CHECK_EQUAL(2, constCont.back());
+	{
+		std::array expected1 {1, 2};
+		BOOST_CHECK_EQUAL_COLLECTIONS(constCont.begin(), constCont.end(), expected1.begin(), expected1.end());
+		BOOST_CHECK_EQUAL_COLLECTIONS(constCont.rbegin(), constCont.rend(), expected1.rbegin(), expected1.rend());
+		BOOST_CHECK_EQUAL_COLLECTIONS(constCont.cbegin(), constCont.cend(), expected1.cbegin(), expected1.cend());
+		BOOST_CHECK_EQUAL_COLLECTIONS(constCont.crbegin(), constCont.crend(), expected1.crbegin(), expected1.crend());
+	}
+	BOOST_CHECK_EQUAL(1, constCont.at(0));
+	BOOST_CHECK_EQUAL(2, constCont.at(1));
+	BOOST_CHECK_EQUAL(1, constCont[0]);
+	BOOST_CHECK_EQUAL(2, constCont[1]);
+	BOOST_CHECK_EQUAL(data_, constCont.data());
+	BOOST_CHECK_THROW(std::ignore = constCont.at(2), std::out_of_range);
+}
+
+BOOST_AUTO_TEST_CASE(random_access)
+{
+	BOOST_CHECK_NO_THROW(emplace_back(1));
+	BOOST_CHECK_NO_THROW(emplace_back(2));
+	BOOST_CHECK_NO_THROW(emplace_back(3));
+
+	auto i = begin();
+	BOOST_CHECK_EQUAL(1, *i);
+	BOOST_CHECK_EQUAL(2, *++i);
+	BOOST_CHECK_EQUAL(2, *i++);
+	BOOST_CHECK_EQUAL(3, *i);
+	BOOST_CHECK_EQUAL(3, *i--);
+	BOOST_CHECK_EQUAL(2, *i);
+	BOOST_CHECK_EQUAL(1, *--i);
+	BOOST_CHECK_EQUAL(1, *i);
+}
+
+BOOST_AUTO_TEST_CASE(insert_remove_test)
+{
+	BOOST_CHECK_NO_THROW(emplace_back(1));
+	BOOST_CHECK_NO_THROW(emplace_back(2));
+	BOOST_CHECK_NO_THROW(emplace_back(3));
+	BOOST_CHECK_NO_THROW(emplace_back(4));
+	BOOST_CHECK_NO_THROW(pop_back());
+	BOOST_CHECK_EQUAL(size_, 3);
+	BOOST_CHECK_EQUAL(capacity_, 4);
+
+	BOOST_CHECK_NO_THROW(emplace(begin(), 5));
+	BOOST_CHECK_EQUAL(size_, 4);
+	BOOST_CHECK_EQUAL(capacity_, 4);
+	{
+		std::array expected1 {5, 1, 2, 3};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected1.begin(), expected1.end());
+	}
+
+	{
+		std::array expected1 {2, 3};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin() + 2, end(), expected1.begin(), expected1.end());
+	}
+	BOOST_CHECK_NO_THROW(insert(begin() + 2, 6));
+	BOOST_CHECK_EQUAL(size_, 5);
+	BOOST_CHECK_EQUAL(capacity_, 8);
+	{
+		std::array expected1 {5, 1, 6, 2, 3};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected1.begin(), expected1.end());
+	}
+	erase(begin() + 1);
+	BOOST_CHECK_EQUAL(size_, 4);
+	BOOST_CHECK_EQUAL(capacity_, 8);
+	{
+		std::array expected1 {5, 6, 2, 3};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected1.begin(), expected1.end());
+	}
+	erase(begin() + 1, end() - 1);
+	BOOST_CHECK_EQUAL(size_, 2);
+	BOOST_CHECK_EQUAL(capacity_, 8);
+	{
+		std::array expected1 {5, 3};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected1.begin(), expected1.end());
+	}
+}
+
+BOOST_AUTO_TEST_CASE(stl)
+{
+	BOOST_CHECK_NO_THROW(resize(10));
+	BOOST_CHECK_NO_THROW(std::generate(begin(), end(), [x = 0]() mutable {
+		return x++;
+	}));
+	BOOST_CHECK_NO_THROW(std::sort(rbegin(), rend()));
+	{
+		std::array expected1 {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected1.begin(), expected1.end());
+	}
+	const auto newend = std::remove_if(begin(), end(), [](const auto & x) {
+		return x % 2 == 0;
+	});
+	{
+		std::array expected1 {9, 7, 5, 3, 1};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), newend, expected1.begin(), expected1.end());
+	}
+}
+
+BOOST_AUTO_TEST_CASE(iter_compare)
+{
+	BOOST_CHECK_EQUAL(begin(), end());
+	BOOST_CHECK_EQUAL(rbegin(), rend());
+	emplace_back();
+	BOOST_CHECK_LT(begin(), end());
+	BOOST_CHECK_LT(rbegin(), rend());
+	BOOST_CHECK_LT(cbegin(), cend());
+	BOOST_CHECK_LT(crbegin(), crend());
+}
+
+BOOST_AUTO_TEST_SUITE_END();
+
+struct C {
+	int x;
+	float y;
+};
+static_assert(std::is_trivially_destructible_v<C>);
+
+BOOST_FIXTURE_TEST_SUITE(c, glContainer<C>)
+
+BOOST_AUTO_TEST_CASE(basic)
+{
+	BOOST_CHECK_NO_THROW(emplace_back(1, 2.f));
+	BOOST_CHECK_EQUAL(1, begin()->x);
+	BOOST_CHECK_EQUAL(2.f, begin()->y);
+	BOOST_CHECK_NO_THROW(begin()->x = 3);
+	BOOST_CHECK_EQUAL(3, begin()->x);
+
+	BOOST_CHECK_NO_THROW(push_back(C {4, 5.f}));
+	BOOST_CHECK_EQUAL(3, begin()->x);
+	BOOST_CHECK_EQUAL(2.f, begin()->y);
+	BOOST_CHECK_EQUAL(4, rbegin()->x);
+	BOOST_CHECK_EQUAL(5.f, rbegin()->y);
+}
+
+BOOST_AUTO_TEST_SUITE_END();
+
+struct CC {
+	~CC()
+	{
+		++x;
+	}
+	int x;
+	float y;
+};
+static_assert(!std::is_trivially_destructible_v<CC>);
+
+BOOST_FIXTURE_TEST_SUITE(cc, glContainer<CC>)
+
+BOOST_AUTO_TEST_CASE(basic)
+{
+	BOOST_CHECK_NO_THROW(emplace_back(1, 2.f));
+	BOOST_CHECK_EQUAL(1, begin()->x);
+	BOOST_CHECK_EQUAL(2.f, begin()->y);
+	BOOST_CHECK_NO_THROW(begin()->x = 3);
+	BOOST_CHECK_EQUAL(3, begin()->x);
+
+	BOOST_CHECK_NO_THROW(push_back(CC {4, 5.f}));
+	BOOST_CHECK_EQUAL(3, begin()->x);
+	BOOST_CHECK_EQUAL(2.f, begin()->y);
+	BOOST_CHECK_EQUAL(4, rbegin()->x);
+	BOOST_CHECK_EQUAL(5.f, rbegin()->y);
+	BOOST_CHECK_NO_THROW(pop_back());
+	BOOST_CHECK_EQUAL(size(), 1);
+	BOOST_CHECK_EQUAL(capacity(), 2);
+	BOOST_CHECK_NO_THROW(resize(3));
+	BOOST_CHECK_EQUAL(size(), 3);
+	BOOST_CHECK_EQUAL(capacity(), 3);
+	BOOST_CHECK_NO_THROW(resize(1));
+	BOOST_CHECK_EQUAL(size(), 1);
+	BOOST_CHECK_EQUAL(capacity(), 1);
+}
+
+BOOST_AUTO_TEST_CASE(insert_remove_test)
+{
+	BOOST_CHECK_NO_THROW(emplace_back(1, 2.f));
+	BOOST_CHECK_NO_THROW(emplace_back(3, 4.f));
+	BOOST_CHECK_NO_THROW(emplace(begin(), 5, 6.f));
+	BOOST_CHECK_NO_THROW(emplace(begin() + 1, 7, 8.f));
+	BOOST_CHECK_NO_THROW(emplace(begin() + 2, 9, 10.f));
+	BOOST_CHECK_EQUAL(capacity(), 8);
+	BOOST_CHECK_EQUAL(size(), 5);
+	BOOST_CHECK_NO_THROW(shrink_to_fit());
+	BOOST_CHECK_EQUAL(capacity(), 5);
+	BOOST_CHECK_EQUAL(size(), 5);
+}
+
+BOOST_AUTO_TEST_SUITE_END();
diff --git a/test/test-instancing.cpp b/test/test-instancing.cpp
index 8745484..7d8ea55 100644
--- a/test/test-instancing.cpp
+++ b/test/test-instancing.cpp
@@ -17,14 +17,8 @@ BOOST_FIXTURE_TEST_SUITE(i, InstanceVertices<int>)
 
 BOOST_AUTO_TEST_CASE(createDestroy)
 {
-	BOOST_CHECK(!data);
-	map();
-	BOOST_REQUIRE(data);
-	BOOST_CHECK_EQUAL(0, next);
 	BOOST_CHECK(unused.empty());
 	BOOST_CHECK(index.empty());
-	unmap();
-	BOOST_CHECK(!data);
 }
 
 BOOST_AUTO_TEST_CASE(acquireRelease)
@@ -32,12 +26,12 @@ BOOST_AUTO_TEST_CASE(acquireRelease)
 	{
 		auto proxy = acquire();
 		*proxy = 20;
-		BOOST_CHECK_EQUAL(1, next);
+		BOOST_CHECK_EQUAL(1, size());
 		BOOST_REQUIRE_EQUAL(1, index.size());
 		BOOST_CHECK_EQUAL(0, index.front());
 		BOOST_CHECK(unused.empty());
 	}
-	BOOST_CHECK_EQUAL(0, next);
+	BOOST_CHECK_EQUAL(0, size());
 	BOOST_CHECK(unused.empty());
 	BOOST_CHECK(index.empty());
 }
@@ -47,13 +41,13 @@ BOOST_AUTO_TEST_CASE(acquireReleaseMove)
 	{
 		auto proxy1 = acquire();
 		*proxy1 = 20;
-		BOOST_CHECK_EQUAL(1, next);
+		BOOST_CHECK_EQUAL(1, size());
 		auto proxy2 = std::move(proxy1);
 		proxy2 = 40;
-		BOOST_CHECK_EQUAL(1, next);
-		BOOST_CHECK_EQUAL(data[0], 40);
+		BOOST_CHECK_EQUAL(1, size());
+		BOOST_CHECK_EQUAL(at(0), 40);
 	}
-	BOOST_CHECK_EQUAL(0, next);
+	BOOST_CHECK_EQUAL(0, size());
 	BOOST_CHECK(unused.empty());
 	BOOST_CHECK(index.empty());
 }
@@ -62,13 +56,13 @@ BOOST_AUTO_TEST_CASE(autoMapUnmap)
 {
 	{
 		auto proxy = acquire();
-		BOOST_CHECK(data);
+		BOOST_CHECK(data_);
 		std::ignore = bufferName();
-		BOOST_CHECK(data);
-		BOOST_CHECK_EQUAL(1, count());
-		BOOST_CHECK(!data);
+		BOOST_CHECK(data_);
+		BOOST_CHECK_EQUAL(1, size());
+		BOOST_CHECK(!data_);
 	}
-	BOOST_CHECK_EQUAL(0, count());
+	BOOST_CHECK_EQUAL(0, size());
 }
 
 BOOST_AUTO_TEST_CASE(initialize)
@@ -89,7 +83,7 @@ BOOST_AUTO_TEST_CASE(resize)
 		proxies.push_back(acquire(n));
 		expected.emplace_back(n);
 	}
-	BOOST_CHECK_EQUAL_COLLECTIONS(expected.begin(), expected.end(), data, data + COUNT);
+	BOOST_CHECK_EQUAL_COLLECTIONS(expected.begin(), expected.end(), data(), data() + COUNT);
 	BOOST_CHECK_EQUAL_COLLECTIONS(expected.begin(), expected.end(), proxies.begin(), proxies.end());
 }
 
@@ -100,11 +94,11 @@ BOOST_AUTO_TEST_CASE(shuffle)
 	BOOST_CHECK_EQUAL(1, proxies.emplace_back(acquire(1)));
 	BOOST_CHECK_EQUAL(2, proxies.emplace_back(acquire(2)));
 	BOOST_CHECK_EQUAL(3, proxies.emplace_back(acquire(3)));
-	BOOST_CHECK_EQUAL(4, next);
-	BOOST_CHECK_EQUAL(data + 0, proxies[0].get());
-	BOOST_CHECK_EQUAL(data + 1, proxies[1].get());
-	BOOST_CHECK_EQUAL(data + 2, proxies[2].get());
-	BOOST_CHECK_EQUAL(data + 3, proxies[3].get());
+	BOOST_CHECK_EQUAL(4, size());
+	BOOST_CHECK_EQUAL(at(0), *proxies[0].get());
+	BOOST_CHECK_EQUAL(at(1), *proxies[1].get());
+	BOOST_CHECK_EQUAL(at(2), *proxies[2].get());
+	BOOST_CHECK_EQUAL(at(3), *proxies[3].get());
 	BOOST_CHECK(unused.empty());
 	BOOST_REQUIRE_EQUAL(4, index.size());
 	BOOST_CHECK_EQUAL(0, index[0]);
@@ -113,28 +107,29 @@ BOOST_AUTO_TEST_CASE(shuffle)
 	BOOST_CHECK_EQUAL(3, index[3]);
 	// Remove 1, 3 moves to [1]
 	proxies.erase(proxies.begin() + 1);
+	BOOST_REQUIRE_EQUAL(3, proxies.size());
 	BOOST_REQUIRE_EQUAL(4, index.size());
 	BOOST_REQUIRE_EQUAL(1, unused.size());
 	BOOST_CHECK_EQUAL(1, unused[0]);
-	BOOST_CHECK_EQUAL(data + 0, proxies[0].get());
-	BOOST_CHECK_EQUAL(data + 2, proxies[1].get());
-	BOOST_CHECK_EQUAL(data + 1, proxies[2].get());
-	// Remove 1, 2 moves to [1]
+	BOOST_CHECK_EQUAL(at(0), *proxies[0].get());
+	BOOST_CHECK_EQUAL(at(2), *proxies[1].get());
+	BOOST_CHECK_EQUAL(at(1), *proxies[2].get());
+	//  Remove 1, 2 moves to [1]
 	proxies.erase(proxies.begin() + 1);
 	BOOST_REQUIRE_EQUAL(4, index.size());
 	BOOST_REQUIRE_EQUAL(2, unused.size());
 	BOOST_CHECK_EQUAL(1, unused[0]);
 	BOOST_CHECK_EQUAL(2, unused[1]);
-	BOOST_CHECK_EQUAL(data + 0, proxies[0].get());
-	BOOST_CHECK_EQUAL(data + 1, proxies[1].get());
+	BOOST_CHECK_EQUAL(at(0), *proxies[0].get());
+	BOOST_CHECK_EQUAL(at(1), *proxies[1].get());
 	// Add new, takes 2 at [2]
 	BOOST_CHECK_EQUAL(4, proxies.emplace_back(acquire(4)));
 	BOOST_REQUIRE_EQUAL(4, index.size());
 	BOOST_REQUIRE_EQUAL(1, unused.size());
 	BOOST_CHECK_EQUAL(1, unused[0]);
-	BOOST_CHECK_EQUAL(data + 0, proxies[0].get());
-	BOOST_CHECK_EQUAL(data + 1, proxies[1].get());
-	BOOST_CHECK_EQUAL(data + 2, proxies[2].get());
+	BOOST_CHECK_EQUAL(at(0), *proxies[0].get());
+	BOOST_CHECK_EQUAL(at(1), *proxies[1].get());
+	BOOST_CHECK_EQUAL(at(2), *proxies[2].get());
 }
 
 BOOST_DATA_TEST_CASE(shuffle_random, boost::unit_test::data::xrange(0, 10), x)
@@ -158,7 +153,7 @@ BOOST_DATA_TEST_CASE(shuffle_random, boost::unit_test::data::xrange(0, 10), x)
 				break;
 		}
 
-		BOOST_REQUIRE_EQUAL(next, proxies.size());
+		BOOST_REQUIRE_EQUAL(size(), proxies.size());
 		for (const auto & [n, p] : proxies) {
 			BOOST_REQUIRE_EQUAL(n, p);
 		}
@@ -169,10 +164,10 @@ BOOST_DATA_TEST_CASE(shuffle_random, boost::unit_test::data::xrange(0, 10), x)
 			}
 		}
 		BOOST_TEST_CONTEXT(index) {
-			BOOST_REQUIRE_EQUAL(iused.size(), next);
+			BOOST_REQUIRE_EQUAL(iused.size(), size());
 			if (!iused.empty()) {
 				BOOST_REQUIRE_EQUAL(*iused.begin(), 0);
-				BOOST_REQUIRE_EQUAL(*iused.rbegin(), next - 1);
+				BOOST_REQUIRE_EQUAL(*iused.rbegin(), size() - 1);
 			}
 		}
 	}
diff --git a/test/test-pack.cpp b/test/test-pack.cpp
new file mode 100644
index 0000000..1f9f061
--- /dev/null
+++ b/test/test-pack.cpp
@@ -0,0 +1,41 @@
+#define BOOST_TEST_MODULE pack
+
+#include <boost/test/data/test_case.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include "pack.h"
+#include <vector>
+
+using IntegerVectorPack = pack<int, std::vector>;
+
+BOOST_FIXTURE_TEST_SUITE(pint, IntegerVectorPack)
+
+BOOST_AUTO_TEST_CASE(basics)
+{
+	BOOST_CHECK_EQUAL(size(), 0);
+	BOOST_CHECK_NO_THROW(emplace(1));
+	BOOST_CHECK_NO_THROW(emplace(2));
+	BOOST_CHECK_NO_THROW(emplace(3));
+	BOOST_CHECK_NO_THROW(emplace(4));
+	BOOST_CHECK_EQUAL(size(), 4);
+	{
+		std::array expected1 {1, 2, 3, 4};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected1.begin(), expected1.end());
+	}
+
+	BOOST_CHECK_NO_THROW(erase(begin() + 1));
+	BOOST_CHECK_EQUAL(size(), 3);
+	{
+		std::array expected1 {1, 4, 3};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected1.begin(), expected1.end());
+	}
+
+	BOOST_CHECK_NO_THROW(erase(--end()));
+	BOOST_CHECK_EQUAL(size(), 2);
+	{
+		std::array expected1 {1, 4};
+		BOOST_CHECK_EQUAL_COLLECTIONS(begin(), end(), expected1.begin(), expected1.end());
+	}
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/test-render.cpp b/test/test-render.cpp
index 4bfcad2..0d384a3 100644
--- a/test/test-render.cpp
+++ b/test/test-render.cpp
@@ -21,9 +21,9 @@
 #include <ui/window.h>
 
 class TestScene : public SceneProvider {
-	std::shared_ptr<RailVehicle> train1, train2;
 	const RailVehicleClassPtr brush47rvc = std::dynamic_pointer_cast<RailVehicleClass>(
 			AssetFactory::loadXML(RESDIR "/brush47.xml")->assets.at("brush-47"));
+	std::shared_ptr<RailVehicle> train1, train2;
 
 	Terrain terrain {[]() {
 		auto gd = std::make_shared<GeoData>(GeoData::Limits {{0, 0}, {100, 100}});