Realisation v1

tests/adaptive_sequence_tests.cpp

@@ -0,0 +1,632 @@
+#include "universal_container/adaptive_sequence.hpp"
+#include "universal_container/ring_block.hpp"
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdlib>
+#include <iostream>
+#include <optional>
+#include <random>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace {
+
+int failures = 0;
+
+void expect(bool condition, const char* expression, int line) {
+    if (!condition) {
+        std::cerr << "FAIL line " << line << ": " << expression << '\n';
+        ++failures;
+    }
+}
+
+#define EXPECT(expression) expect(static_cast<bool>(expression), #expression, __LINE__)
+
+struct DeferredTransitionPolicy {
+    uc::TieredConfig target{8, 4, 2};
+    bool ready = false;
+    std::size_t decisions = 0;
+    std::size_t transitions = 0;
+    uc::StorageMode last_from = uc::StorageMode::vector;
+    uc::StorageMode last_to = uc::StorageMode::vector;
+
+    void observe(const uc::OperationSample& sample) noexcept {
+        if (sample.kind == uc::OperationKind::insert) {
+            ready = true;
+        }
+    }
+
+    [[nodiscard]] bool decision_ready() const noexcept { return ready; }
+
+    [[nodiscard]] std::optional<uc::AdaptationDecision>
+    recommended_decision(uc::StorageMode current,
+                         std::size_t,
+                         uc::TieredConfig) noexcept {
+        if (!ready) {
+            return std::nullopt;
+        }
+        ready = false;
+        ++decisions;
+        if (current == uc::StorageMode::vector) {
+            return uc::AdaptationDecision{uc::StorageMode::tiered, target, 1.0};
+        }
+        return std::nullopt;
+    }
+
+    void on_transition(uc::StorageMode from,
+                       uc::StorageMode to,
+                       uc::TieredConfig active) noexcept {
+        ++transitions;
+        last_from = from;
+        last_to = to;
+        target = active;
+        ready = false;
+    }
+
+    void reset() noexcept {
+        ready = false;
+        decisions = 0;
+        transitions = 0;
+    }
+};
+
+template <class Sequence, class Reference>
+void expect_equal(const Sequence& sequence, const Reference& reference) {
+    EXPECT(sequence.size() == reference.size());
+    for (std::size_t i = 0; i < reference.size() && i < sequence.size(); ++i) {
+        EXPECT(sequence[i] == reference[i]);
+    }
+}
+
+void ring_block_offsets() {
+    uc::detail::RingBlock<int> block(8);
+    block.push_back(2);
+    block.push_back(3);
+    block.insert(0, 1);
+    block.insert(0, 0);
+    block.insert(2, 9);
+    EXPECT(block.offset() != 0);
+    const std::vector<int> expected{0, 1, 9, 2, 3};
+    for (std::size_t i = 0; i < expected.size(); ++i) {
+        EXPECT(block[i] == expected[i]);
+    }
+    EXPECT(block.erase(2) == 9);
+    EXPECT(block.erase(0) == 0);
+    EXPECT(block.size() == 3);
+    EXPECT(block[0] == 1 && block[1] == 2 && block[2] == 3);
+}
+
+void randomized_differential() {
+    uc::TieredConfig config{16, 4, 4};
+    uc::AdaptiveSequence<std::uint32_t> actual(config);
+    actual.force_tiered_mode();
+    std::vector<std::uint32_t> expected;
+    std::mt19937_64 random(0xC0FFEEULL);
+
+    for (std::size_t step = 0; step < 30'000; ++step) {
+        const auto operation = static_cast<unsigned>(random() % 5);
+        if (expected.empty() || operation == 0) {
+            const auto value = static_cast<std::uint32_t>(random());
+            const auto index = expected.empty() ? 0 : static_cast<std::size_t>(random() % (expected.size() + 1));
+            expected.insert(expected.begin() + static_cast<std::ptrdiff_t>(index), value);
+            actual.insert(index, value);
+        } else if (operation == 1) {
+            const auto index = static_cast<std::size_t>(random() % expected.size());
+            expected.erase(expected.begin() + static_cast<std::ptrdiff_t>(index));
+            actual.erase(index);
+        } else if (operation == 2) {
+            const auto value = static_cast<std::uint32_t>(random());
+            expected.push_back(value);
+            actual.push_back(value);
+        } else if (operation == 3) {
+            const auto index = static_cast<std::size_t>(random() % expected.size());
+            const auto value = static_cast<std::uint32_t>(random());
+            expected[index] = value;
+            actual.set(index, value);
+        } else {
+            const auto index = static_cast<std::size_t>(random() % expected.size());
+            EXPECT(actual[index] == expected[index]);
+        }
+
+        if (step % 251 == 0) {
+            expect_equal(actual, expected);
+            actual.force_vector_mode();
+            expect_equal(actual, expected);
+            actual.force_tiered_mode();
+        }
+    }
+    expect_equal(actual, expected);
+}
+
+void indexed_duplicates_and_ids() {
+    uc::AdaptiveSequence<std::uint32_t, true> values({8, 4, 3});
+    values.push_back(5);
+    values.push_back(8);
+    values.push_back(5);
+    values.push_back(3);
+    values.push_back(5);
+
+    const auto middle_id = values.id_at(2);
+    EXPECT(values.contains(5));
+    EXPECT(values.find_all(5) == std::vector<std::size_t>({0, 2, 4}));
+
+    values.force_tiered_mode();
+    values.insert(1, 5);
+    EXPECT(values.find_all(5) == std::vector<std::size_t>({0, 1, 3, 5}));
+    EXPECT(values.id_alive(middle_id));
+    values.force_tiered_mode({16, 4, 3});
+    EXPECT(values.find_all(5) == std::vector<std::size_t>({0, 1, 3, 5}));
+    EXPECT(values.id_alive(middle_id));
+
+    values[3] = 42;
+    EXPECT(values.find_all(5) == std::vector<std::size_t>({0, 1, 5}));
+    EXPECT(values.contains(42));
+    values.erase_by_id(middle_id);
+    EXPECT(!values.id_alive(middle_id));
+    EXPECT(!values.contains(42));
+
+    EXPECT(values.erase_all(5) == 3);
+    EXPECT(!values.contains(5));
+    EXPECT(values.size() == 2);
+}
+
+void indexed_proxy_detects_structural_invalidation() {
+    uc::AdaptiveSequence<std::uint32_t, true> values({8, 4, 2});
+    values.push_back(10);
+    values.push_back(20);
+    auto stale = values[1];
+
+    values.insert(0, 5);
+    bool invalidation_detected = false;
+    try {
+        stale = 99;
+    } catch (const std::logic_error&) {
+        invalidation_detected = true;
+    }
+
+    EXPECT(invalidation_detected);
+    const auto& read_only = values;
+    EXPECT(read_only[0] == 5);
+    EXPECT(read_only[1] == 10);
+    EXPECT(read_only[2] == 20);
+}
+
+void iterator_and_contiguous_contract() {
+    uc::AdaptiveSequence<int> values({8, 4, 3});
+    for (int i = 0; i < 100; ++i) {
+        values.push_back(i);
+    }
+    values.force_tiered_mode();
+    EXPECT(values.data() == nullptr);
+
+    std::int64_t sum = 0;
+    values.for_each([&](int value) { sum += value; });
+    EXPECT(sum == 4'950);
+
+    const auto contiguous = values.make_contiguous();
+    EXPECT(values.mode() == uc::StorageMode::vector);
+    EXPECT(contiguous.size() == 100);
+    EXPECT(contiguous[37] == 37);
+
+    auto iterator = values.begin();
+    EXPECT(*iterator == 0);
+    values.push_back(100);
+    bool invalidation_detected = false;
+    try {
+        (void)*iterator;
+    } catch (const std::logic_error&) {
+        invalidation_detected = true;
+    }
+    EXPECT(invalidation_detected);
+}
+
+struct NonTrivial {
+    std::string text;
+    std::uint64_t marker = 0;
+
+    NonTrivial(std::string value, std::uint64_t number)
+        : text(std::move(value)), marker(number) {}
+    NonTrivial(const NonTrivial&) = default;
+    NonTrivial(NonTrivial&&) noexcept = default;
+    NonTrivial& operator=(const NonTrivial&) = default;
+    NonTrivial& operator=(NonTrivial&&) noexcept = default;
+    ~NonTrivial() { marker ^= 0; }
+
+    friend bool operator==(const NonTrivial&, const NonTrivial&) = default;
+};
+
+void non_trivial_values() {
+    uc::AdaptiveSequence<NonTrivial> values({4, 4, 2});
+    values.push_back(NonTrivial{"alpha", 1});
+    values.push_back(NonTrivial{"gamma", 3});
+    values.force_tiered_mode();
+    values.insert(1, NonTrivial{"beta", 2});
+    EXPECT(values[0].text == "alpha");
+    EXPECT(values[1].text == "beta");
+    EXPECT(values[2].text == "gamma");
+    values.erase(0);
+    EXPECT(values[0].marker == 2);
+}
+
+void tiered_shape_rebuild_preserves_order() {
+    uc::AdaptiveSequence<std::uint32_t> values({8, 4, 2});
+    std::vector<std::uint32_t> expected;
+    for (std::uint32_t i = 0; i < 257; ++i) {
+        values.push_back(i * 3 + 1);
+        expected.push_back(i * 3 + 1);
+    }
+
+    values.force_tiered_mode();
+    values.force_tiered_mode({64, 8, 3});
+    EXPECT(values.mode() == uc::StorageMode::tiered);
+    EXPECT(values.tiered_config() == (uc::TieredConfig{64, 8, 3}));
+    expect_equal(values, expected);
+
+    values.insert(129, 0xfeedu);
+    expected.insert(expected.begin() + 129, 0xfeedu);
+    values.force_tiered_mode({16, 4, 4});
+    EXPECT(values.tiered_config() == (uc::TieredConfig{16, 4, 4}));
+    expect_equal(values, expected);
+
+    values.force_tiered_mode({16, 4, 1});
+    values.force_tiered_mode({16, 4, 4});
+    expect_equal(values, expected);
+    EXPECT(values.policy().telemetry().tiered_rebuilds == 4);
+    EXPECT(values.policy().telemetry().tiered_leaf_rebuilds == 2);
+    EXPECT(values.policy().telemetry().tiered_directory_rebuilds == 2);
+}
+
+void adaptation_is_deferred_until_a_safe_boundary() {
+    using sequence_type = uc::AdaptiveSequence<
+        std::uint32_t, false, DeferredTransitionPolicy>;
+
+    sequence_type explicit_maintenance({8, 4, 2}, DeferredTransitionPolicy{});
+    for (std::uint32_t value = 0; value < 4; ++value) {
+        explicit_maintenance.push_back(value);
+    }
+    explicit_maintenance.insert(2, 99);
+    EXPECT(explicit_maintenance.mode() == uc::StorageMode::vector);
+    EXPECT(explicit_maintenance.policy().decision_ready());
+    EXPECT(explicit_maintenance.policy().transitions == 0);
+    EXPECT(explicit_maintenance.adapt_now());
+    EXPECT(explicit_maintenance.mode() == uc::StorageMode::tiered);
+    EXPECT(explicit_maintenance.policy().decisions == 1);
+    EXPECT(explicit_maintenance.policy().transitions == 1);
+    EXPECT(explicit_maintenance.policy().last_from == uc::StorageMode::vector);
+    EXPECT(explicit_maintenance.policy().last_to == uc::StorageMode::tiered);
+    EXPECT(!explicit_maintenance.adapt_now());
+    EXPECT(!explicit_maintenance.adapt_now());
+    EXPECT(explicit_maintenance.policy().decisions == 1);
+    EXPECT(explicit_maintenance.policy().transitions == 1);
+    expect_equal(explicit_maintenance,
+                 std::vector<std::uint32_t>({0, 1, 99, 2, 3}));
+
+    sequence_type next_mutation({8, 4, 2}, DeferredTransitionPolicy{});
+    for (std::uint32_t value = 0; value < 4; ++value) {
+        next_mutation.push_back(value);
+    }
+    next_mutation.insert(1, 77);
+    EXPECT(next_mutation.mode() == uc::StorageMode::vector);
+    EXPECT(next_mutation.policy().transitions == 0);
+
+    // The pending recommendation is applied before this append; it is not
+    // applied after the preceding, already committed insertion.
+    next_mutation.push_back(4);
+    EXPECT(next_mutation.mode() == uc::StorageMode::tiered);
+    EXPECT(next_mutation.policy().decisions == 1);
+    EXPECT(next_mutation.policy().transitions == 1);
+    expect_equal(next_mutation,
+                 std::vector<std::uint32_t>({0, 77, 1, 2, 3, 4}));
+}
+
+std::optional<uc::AdaptationDecision> shape_decision(
+    std::size_t n,
+    uc::TieredConfig current,
+    bool localized) {
+    uc::AdaptationConfig config;
+    config.evaluation_interval = 64;
+    config.minimum_observations = 64;
+    config.minimum_edit_observations = 64;
+    config.minimum_residency_operations = 0;
+    config.minimum_shape_residency_operations = 0;
+    config.minimum_shape_edit_fraction = 0.0;
+    config.required_confirmation_windows = 1;
+    config.minimum_tiered_size = 1;
+    config.forecast_operations = 1'000'000;
+    config.tiered_rebuild_safety = 0.0;
+    config.minimum_shape_improvement = 0.0;
+    config.vector_move_unit = 1.0;
+    uc::CostModelPolicy policy(config, current);
+    policy.on_transition(uc::StorageMode::vector,
+                         uc::StorageMode::tiered,
+                         current);
+
+    for (std::size_t i = 0; i < 64; ++i) {
+        const auto position = localized
+            ? n / 2 + i % 17
+            : (i * 104'729 + 17) % n;
+        policy.observe({uc::OperationKind::insert, n, position, 1,
+                        sizeof(std::uint32_t)});
+    }
+    return policy.recommended_decision(uc::StorageMode::tiered, n, current);
+}
+
+void forecast_horizon_is_bounded_by_observed_evidence() {
+    uc::AdaptationConfig config;
+    config.evaluation_interval = 64;
+    config.minimum_observations = 64;
+    config.minimum_residency_operations = 0;
+    config.required_confirmation_windows = 1;
+    config.forecast_operations = 10'000;
+    config.minimum_forecast_operations = 1;
+    config.forecast_growth_factor = 8.0;
+
+    const uc::TieredConfig tiered{64, 64, 4};
+    uc::CostModelPolicy policy(config, tiered);
+    for (std::size_t i = 0; i < 64; ++i) {
+        policy.observe({uc::OperationKind::insert, 10'000, i, 1,
+                        sizeof(std::uint32_t)});
+    }
+    (void)policy.recommended_decision(uc::StorageMode::vector, 10'000, tiered);
+    EXPECT(policy.telemetry().last_forecast_operations == 512);
+}
+
+void confirmation_requires_consecutive_supporting_windows() {
+    uc::AdaptationConfig config;
+    config.evaluation_interval = 16;
+    config.edit_evaluation_interval = 8;
+    config.minimum_observations = 16;
+    config.minimum_edit_observations = 8;
+    config.minimum_residency_operations = 0;
+    config.minimum_tiered_size = 1;
+    config.required_confirmation_windows = 2;
+    config.forecast_operations = 1'000'000;
+    config.minimum_forecast_operations = 1;
+    config.vector_to_tiered_safety = 0.0;
+    config.vector_move_unit = 1.0;
+    config.tiered_move_unit = 0.01;
+    config.tiered_directory_unit = 0.0;
+    config.tiered_read_base = 2.0;
+    config.ewma_alpha = 1.0;
+    config.tiered_entry_edit_fraction = 0.50;
+
+    const uc::TieredConfig tiered{64, 64, 4};
+    uc::CostModelPolicy policy(config, tiered);
+    constexpr std::size_t n = 10'000;
+    auto edit_window = [&] {
+        for (std::size_t i = 0; i < 8; ++i) {
+            policy.observe({uc::OperationKind::insert, n, n / 2 + i,
+                            1, sizeof(std::uint32_t)});
+        }
+    };
+
+    edit_window();
+    for (std::size_t i = 0; i < 16; ++i) {
+        policy.observe({uc::OperationKind::random_read, n, i,
+                        1, sizeof(std::uint32_t)});
+    }
+    edit_window();
+
+    // Three windows accumulated, but the middle one contradicted the tiered
+    // proposal, so the final edit window starts a new streak of one.
+    EXPECT(!policy.recommended_decision(
+        uc::StorageMode::vector, n, tiered).has_value());
+
+    edit_window();
+    const auto confirmed = policy.recommended_decision(
+        uc::StorageMode::vector, n, tiered);
+    EXPECT(confirmed.has_value());
+    if (confirmed) {
+        EXPECT(confirmed->target == uc::StorageMode::tiered);
+    }
+}
+
+void stationary_phases_do_not_thrash() {
+    constexpr std::size_t operations = 30'000;
+
+    {
+        // This is the v12 failure shape: a stationary uniform edit phase at
+        // N=10k used to alternate vector/tiered dozens of times.
+        uc::AdaptationConfig config;
+        const uc::TieredConfig initial{512, 64, 4};
+        uc::CostModelPolicy policy(config, initial);
+        uc::StorageMode mode = uc::StorageMode::vector;
+        auto active = initial;
+        std::mt19937_64 random(0x7c4a'9e13'51d2'08b7ULL);
+
+        for (std::size_t observed = 0; observed < operations; observed += 4) {
+            const auto position = static_cast<std::size_t>(random() % 10'000);
+            policy.observe({uc::OperationKind::insert, 10'000, position,
+                            4, sizeof(std::uint64_t)});
+            if (!policy.decision_ready()) {
+                continue;
+            }
+            const auto decision = policy.recommended_decision(mode, 10'000, active);
+            if (!decision) {
+                continue;
+            }
+            const auto previous = mode;
+            mode = decision->target;
+            if (mode == uc::StorageMode::tiered) {
+                active = decision->tiered_config;
+            }
+            policy.on_transition(previous, mode, active);
+        }
+
+        const auto& telemetry = policy.telemetry();
+        EXPECT(telemetry.vector_to_tiered + telemetry.tiered_to_vector <= 1);
+    }
+
+    {
+        // Starting tiered isolates shape selection.  A stationary uniform
+        // phase may select a better leaf once, but must not bounce thereafter.
+        uc::AdaptationConfig config;
+        const uc::TieredConfig initial{512, 64, 4};
+        uc::CostModelPolicy policy(config, initial);
+        uc::StorageMode mode = uc::StorageMode::tiered;
+        auto active = initial;
+        policy.on_transition(uc::StorageMode::vector, mode, active);
+        std::mt19937_64 random(0xd1b5'4a32'09fc'77e1ULL);
+
+        for (std::size_t observed = 0; observed < operations; observed += 4) {
+            const auto position = static_cast<std::size_t>(random() % 100'000);
+            policy.observe({uc::OperationKind::insert, 100'000, position,
+                            4, sizeof(std::uint64_t)});
+            if (!policy.decision_ready()) {
+                continue;
+            }
+            const auto decision = policy.recommended_decision(mode, 100'000, active);
+            if (!decision) {
+                continue;
+            }
+            const auto previous = mode;
+            mode = decision->target;
+            if (mode == uc::StorageMode::tiered) {
+                active = decision->tiered_config;
+            }
+            policy.on_transition(previous, mode, active);
+        }
+
+        const auto& telemetry = policy.telemetry();
+        EXPECT(telemetry.tiered_to_vector == 0);
+        EXPECT(telemetry.tiered_leaf_rebuilds <= 1);
+    }
+}
+
+void policy_changes_shape_with_scale_and_locality() {
+    const auto small_uniform = shape_decision(10'000, {512, 64, 4}, false);
+    EXPECT(small_uniform.has_value());
+    EXPECT(small_uniform->target == uc::StorageMode::tiered);
+    EXPECT(small_uniform->tiered_config.leaf_capacity <= 128);
+
+    const auto large_uniform = shape_decision(1'000'000, {64, 64, 4}, false);
+    EXPECT(large_uniform.has_value());
+    EXPECT(large_uniform->target == uc::StorageMode::tiered);
+    EXPECT(large_uniform->tiered_config.leaf_capacity >= 512);
+
+    const auto large_local = shape_decision(1'000'000, {1024, 64, 4}, true);
+    EXPECT(large_local.has_value());
+    EXPECT(large_local->target == uc::StorageMode::tiered);
+    EXPECT(large_local->tiered_config.leaf_capacity
+           < large_uniform->tiered_config.leaf_capacity);
+
+    uc::AdaptationConfig depth_config;
+    depth_config.evaluation_interval = 64;
+    depth_config.minimum_observations = 64;
+    depth_config.minimum_residency_operations = 0;
+    depth_config.minimum_shape_residency_operations = 0;
+    depth_config.minimum_shape_edit_fraction = 0.0;
+    depth_config.required_confirmation_windows = 1;
+    depth_config.forecast_operations = 1'000'000;
+    depth_config.tiered_rebuild_safety = 0.0;
+    depth_config.minimum_shape_improvement = 0.0;
+    depth_config.vector_read = 100.0;
+    depth_config.tiered_leaf_candidates.fill(64);
+    uc::CostModelPolicy depth_policy(depth_config, {64, 64, 2});
+    depth_policy.on_transition(uc::StorageMode::vector,
+                               uc::StorageMode::tiered,
+                               {64, 64, 2});
+    for (std::size_t i = 0; i < 64; ++i) {
+        depth_policy.observe({uc::OperationKind::random_read, 1'000'000, i,
+                              1, sizeof(std::uint32_t)});
+    }
+    const auto depth = depth_policy.recommended_decision(
+        uc::StorageMode::tiered, 1'000'000, {64, 64, 2});
+    EXPECT(depth.has_value());
+    EXPECT(depth->target == uc::StorageMode::tiered);
+    EXPECT(depth->tiered_config.leaf_capacity == 64);
+    EXPECT(depth->tiered_config.directory_levels == 3);
+}
+
+void container_applies_same_mode_shape_decision() {
+    uc::AdaptationConfig config;
+    config.evaluation_interval = 64;
+    config.minimum_observations = 64;
+    config.minimum_residency_operations = 0;
+    config.minimum_shape_residency_operations = 0;
+    config.minimum_shape_edit_fraction = 0.0;
+    config.required_confirmation_windows = 1;
+    config.minimum_tiered_size = 1;
+    config.forecast_operations = 1'000'000;
+    config.tiered_rebuild_safety = 0.0;
+    config.minimum_shape_improvement = 0.0;
+    config.vector_move_unit = 1.0;
+    const uc::TieredConfig initial_shape{1024, 64, 4};
+    uc::AdaptiveSequence<std::uint32_t> values(
+        initial_shape, uc::CostModelPolicy(config, initial_shape));
+    for (std::uint32_t i = 0; i < 10'000; ++i) {
+        values.push_back(i);
+    }
+    values.force_tiered_mode(initial_shape);
+    values.enable_auto_mode();
+
+    for (std::size_t i = 0;
+         i < 256 && values.policy().telemetry().tiered_rebuilds == 0; ++i) {
+        const auto position = (i * 104'729 + 17) % values.size();
+        values.insert(position, 0xabcdefu);
+        values.erase(position);
+    }
+
+    EXPECT(values.mode() == uc::StorageMode::tiered);
+    EXPECT(values.policy().telemetry().tiered_rebuilds == 1);
+    EXPECT(values.tiered_config().leaf_capacity <= 128);
+    for (std::size_t i = 0; i < values.size(); ++i) {
+        EXPECT(values[i] == i);
+    }
+}
+
+void policy_switches_for_sustained_middle_edits() {
+    uc::TieredConfig tiered{32, 16, 3};
+    uc::AdaptationConfig adaptation;
+    adaptation.evaluation_interval = 64;
+    adaptation.minimum_observations = 64;
+    adaptation.minimum_residency_operations = 0;
+    adaptation.minimum_tiered_size = 128;
+    adaptation.forecast_operations = 16'384;
+    adaptation.vector_to_tiered_safety = 1.0;
+    // Make the decision boundary deliberately small; this test checks policy
+    // plumbing, while machine-calibrated constants are validated by benchmarks.
+    adaptation.vector_move_unit = 0.20;
+    adaptation.tiered_move_unit = 0.20;
+    adaptation.tiered_read_base = 2.0;
+    uc::AdaptiveSequence<std::uint32_t> values(
+        tiered, uc::CostModelPolicy(adaptation, tiered));
+
+    for (std::uint32_t i = 0; i < 512; ++i) {
+        values.push_back(i);
+    }
+    values.enable_auto_mode();
+    for (std::size_t i = 0; i < 256 && values.mode() != uc::StorageMode::tiered; ++i) {
+        values.insert(values.size() / 2, 7);
+        values.erase(values.size() / 2);
+    }
+    EXPECT(values.mode() == uc::StorageMode::tiered);
+}
+
+} // namespace
+
+int main() {
+    ring_block_offsets();
+    randomized_differential();
+    indexed_duplicates_and_ids();
+    indexed_proxy_detects_structural_invalidation();
+    iterator_and_contiguous_contract();
+    non_trivial_values();
+    tiered_shape_rebuild_preserves_order();
+    adaptation_is_deferred_until_a_safe_boundary();
+    forecast_horizon_is_bounded_by_observed_evidence();
+    confirmation_requires_consecutive_supporting_windows();
+    stationary_phases_do_not_thrash();
+    policy_changes_shape_with_scale_and_locality();
+    container_applies_same_mode_shape_decision();
+    policy_switches_for_sustained_middle_edits();
+
+    if (failures != 0) {
+        std::cerr << failures << " test assertion(s) failed\n";
+        return EXIT_FAILURE;
+    }
+    std::cout << "All AdaptiveSequence tests passed\n";
+    return EXIT_SUCCESS;
+}