common: SlotVector without generations

tests/SlotVectorTests.cpp

@@ -0,0 +1,103 @@
+#include "common/slotVector.h"
+
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <utility>
+#include <vector>
+
+namespace {
+
+void Check(bool value, const char *message) {
+  if (!value) {
+    std::fprintf(stderr, "SlotVectorTests: failed: %s\n", message);
+    std::abort();
+  }
+}
+
+// Non-movable like the cached Image/Buffer; counts live objects.
+struct Probe {
+  Probe(int *live, uint32_t value) : live(live), value(value) { ++*live; }
+  ~Probe() { --*live; }
+  KYTY_CLASS_NO_COPY(Probe);
+
+  int *live;
+  uint32_t value;
+};
+
+static_assert(sizeof(Common::SlotId) == sizeof(uint32_t));
+
+void TestInsertEraseReuse() {
+  int live = 0;
+  Common::SlotVector<Probe> slots;
+  Check(!slots.is_allocated(Common::SlotId {}) && slots.try_get(Common::SlotId {}) == nullptr &&
+            !slots.is_allocated(Common::SlotId {0}),
+        "an empty vector reported an allocated slot");
+
+  const auto a = slots.insert(&live, 0u);
+  const auto b = slots.insert(&live, 1u);
+  const auto c = slots.insert(&live, 2u);
+  Check(a.index == 0 && b.index == 1 && c.index == 2 && live == 3,
+        "fresh slots were not handed out in order");
+  Check(slots.is_allocated(b) && slots.try_get(b) == &slots[b] && slots[b].value == 1,
+        "an inserted slot did not expose its object");
+  Check(!slots.is_allocated(Common::SlotId {3}), "an unused slot reported an object");
+
+  slots.erase(b);
+  slots.erase(a);
+  Check(live == 1 && !slots.is_allocated(a) && !slots.is_allocated(b) &&
+            slots.try_get(b) == nullptr && slots.is_allocated(c),
+        "erase did not destroy and free exactly its slot");
+
+  // Freed indices are reused most recently freed first, with the same plain id.
+  const auto reused_a = slots.insert(&live, 0u);
+  const auto reused_b = slots.insert(&live, 1u);
+  const auto d = slots.insert(&live, 3u);
+  Check(reused_a == a && reused_b == b && d.index == 3 && live == 4,
+        "freed slots were not reused in LIFO order");
+  Check(slots[reused_a].value == 0 && slots[reused_b].value == 1,
+        "a reused slot did not expose its new object");
+}
+
+void TestForEachAndStability() {
+  int live = 0;
+  {
+    Common::SlotVector<Probe> slots;
+    const auto first = slots.insert(&live, 0u);
+    Probe *const first_address = &slots[first];
+
+    // Cross several chunks; earlier objects must keep their address.
+    std::vector<Common::SlotId> ids {first};
+    for (uint32_t i = 1; i < 1000; ++i) {
+      ids.push_back(slots.insert(&live, i));
+    }
+    Check(&slots[first] == first_address && live == 1000,
+          "growing the vector moved a stored object");
+
+    std::vector<uint32_t> expected;
+    for (uint32_t i = 0; i < 1000; ++i) {
+      if (i % 3 == 0) {
+        slots.erase(ids[i]);
+      } else {
+        expected.push_back(i);
+      }
+    }
+    std::vector<uint32_t> visited;
+    std::as_const(slots).ForEach([&](Common::SlotId id, const Probe &probe) {
+      Check(probe.value == id.index, "ForEach passed an id that does not match its object");
+      visited.push_back(id.index);
+    });
+    Check(visited == expected && live == static_cast<int>(expected.size()),
+          "ForEach did not visit exactly the live slots in index order");
+  }
+  Check(live == 0, "destroying the vector did not destroy every live object exactly once");
+}
+
+} // namespace
+
+int main() {
+  TestInsertEraseReuse();
+  TestForEachAndStability();
+  std::puts("SlotVectorTests: all cases passed");
+  return 0;
+}