Run all benchmarks and return results.

Run all tests and report results.

Run all performance tests and return results.

Test different capacities with various initial loads

Run a test specifically designed to stress complex tree structures

Test edge cases and boundary conditions

Run a smaller fuzz test for development/testing

Run intensive stress test with our optimal configuration

Run fuzz tests with different capacities

Save results to JSON file.

Standard setup for concurrent access simulation

Split leaf and insert key-value, returning (new_leaf, separator_key)

Split this branch node, returning the new right node and promoted key.

Test to establish baseline performance metrics.

Test basic C extension functionality.

Compare C extension performance against Python implementations.

Test detection of concurrent modifications during iteration.

Test that we handle concurrent modification errors gracefully.

Test that deletion after many splits doesn't segfault.

Test that every step of deletion maintains B+ tree invariants

Test that invariant checker should catch single-child branch nodes

Test that items() iterator is also invalidated.

Test that iteration after splits doesn't segfault.

Test iteration behavior when tree structure changes significantly.

Test that new iterators work after tree modification.

Test that iterator is invalidated when items are deleted.

Test that iterator is invalidated when items are inserted.

Test that iterator is invalidated when existing items are updated.

Test that list(tree.keys()) works after heavy modification.

Test lookup performance on full tree.

Stress test memory management with many insertions and deletions.

Test that deletion prefers redistribution over merging when possible

Test that modification counter handles large numbers of modifications.

Test that all iterators are invalidated when tree is modified.

Test that iterators don't get falsely invalidated.

Test creating multiple trees doesn't cause segfaults.

Test that must NOT segfault under any circumstances. This test replicates the conditions that cause segfaults.

Test that stress iterations don't segfault.

Run all segfault prevention tests.

Compare optimized vs original B+ tree performance.

Run performance comparison tests.

Test random insertion performance.

Test that random insertion doesn't cause segfaults.

Test range query performance.

Test if root accumulates children without splitting

Test sequential insertion performance.

Test that sequential insertion of 5000 items doesn't segfault.

Test integer-only single array optimization.

Test that single-child parent case doesn't crash

Try to find the exact deletion that breaks invariants

SMALLEST POSSIBLE TEST: Single node split must maintain sorted order. This test MUST fail until the bug is fixed.

Test with a smaller tree to find minimal reproduction

Test a specific sequence that should trigger the bug

Test the specific case that was creating single-child parents

Stress test the C extension with large dataset.

Second minimal test: Two splits must maintain sorted order.

Delete key from tree */

Insert key-value pair into tree */

Recursive insert helper */

Get a reference to the values in this leaf node.

Verify tree has expected number of items

Verify tree ordering for integer trees

Return True if tree is not empty

Check if key exists (for 'in' operator)

Delete a key (dict-like API)

Lookup with optimized nodes.

Get value for a key (dict-like API)