import unittest
import importlib
import user_code

class TestTask(unittest.TestCase):
    def setUp(self):
        importlib.reload(user_code)
        self.BTree = user_code.BTree

    def test_insert_and_search_all_values(self):
        btree = self.BTree(2)
        values = [10, 20, 5, 6, 12, 30, 7, 17]
        for v in values:
            btree.insert(v)

        missing = [v for v in values if not btree.search(v)]

        self._assert(
            len(missing) == 0,
            "All inserted values are correctly found in the B-tree.",
            f"The following inserted values were NOT found: {missing}"
        )

    def test_search_existing(self):
        btree = self.BTree(2)
        for v in [10, 20, 5, 6]:
            btree.insert(v)

        self._assert(
            btree.search(10),
            "Search successfully found existing value 10.",
            "Search FAILED to find value 10 which was inserted."
        )

        self._assert(
            btree.search(20),
            "Search successfully found existing value 20.",
            "Search FAILED to find value 20 which was inserted."
        )

    def test_search_nonexistent(self):
        btree = self.BTree(2)
        for v in [1, 2, 3]:
            btree.insert(v)

        self._assert(
            not btree.search(100),
            "Search correctly returned False for non-existing value 100.",
            "Search INCORRECTLY returned True for value 100 which was never inserted."
        )

        self._assert(
            not btree.search(-5),
            "Search correctly returned False for non-existing value -5.",
            "Search INCORRECTLY returned True for value -5 which was never inserted."
        )

    def test_splits_do_not_break_tree(self):
        btree = self.BTree(2)
        values = list(range(1, 20))
        for v in values:
            btree.insert(v)

        # Validate all values are present
        missing = [v for v in values if not btree.search(v)]
        self._assert(
            len(missing) == 0,
            "All values remain accessible after multiple node splits.",
            f"Values missing after splits: {missing}"
        )

        # Root capacity constraint
        self._assert(
            len(btree.root.keys) <= 3,
            "Root node size is valid after splits (≤ 3 keys for t=2).",
            f"Root node contains too many keys: {btree.root.keys}"
        )

    # Helper wrapper for positive + negative message
    def _assert(self, condition, success_msg, failure_msg):
        if condition:
            self._testMethodName = success_msg
            self.assertTrue(True, success_msg)
        else:
            self._testMethodName = failure_msg
            self.fail(failure_msg)

if __name__ == "__main__":
    unittest.main()


test_main.py

A comprehensive course exploring the foundational algorithms and data structures that underpin modern data engineering and large-scale data systems. Learn how sorting, hashing, indexing, and probabilistic structures power real-world data infrastructure, with conceptual explanations and practical Python demonstrations.

Explore the essential algorithms for processing and organizing data efficiently, including sorting, hashing, and key-value lookup structures, with practical Python demonstrations.

Examine the tree-based and heap-based data structures that power fast search, indexing, and data organization in modern storage engines.

Delve into memory-efficient, approximate data structures and algorithms for high-throughput, streaming, and big-data scenarios.

Challenge: Build a Simple B-Tree

解答