Adding unit tests

tests/test_bigarray.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python
+
+"""
+Copyright (c) 2006-2026 sqlmap developers (https://sqlmap.org)
+See the file 'LICENSE' for copying permission
+
+BigArray disk-spill semantics (lib/core/bigarray.py).
+
+BigArray is the structure that lets sqlmap dump tables far larger than RAM: once
+the in-memory chunk exceeds chunk_size it is pickled to a temp file and a new
+chunk starts. The tricky, easy-to-break part is that indexing / iteration /
+pop / pickling must stay correct ACROSS the in-memory<->on-disk boundary.
+
+These force a spill with a tiny chunk_size and assert the data survives intact.
+"""
+
+import os
+import pickle
+import sys
+import unittest
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _testutils import bootstrap
+bootstrap()
+
+from lib.core.bigarray import BigArray
+
+N = 5000
+
+
+def _make_spilled():
+    # tiny chunk_size guarantees many on-disk chunks for N items
+    ba = BigArray(chunk_size=1024)
+    for i in range(N):
+        ba.append("item-%d" % i)
+    return ba
+
+
+class TestSpill(unittest.TestCase):
+    def test_actually_spilled_to_disk(self):
+        ba = _make_spilled()
+        self.assertGreater(len(ba.chunks), 1, msg="expected multiple chunks (a disk spill)")
+        # stronger than "more than one chunk": at least one chunk must be a real on-disk file
+        # (spilled chunks are stored as filenames). Otherwise this could pass while everything
+        # stayed in RAM.
+        disk_chunks = [c for c in ba.chunks if isinstance(c, str)]
+        self.assertTrue(disk_chunks, msg="no chunk was spilled to disk")
+        self.assertTrue(os.path.exists(disk_chunks[0]), msg="spilled chunk file missing on disk")
+
+    def test_len(self):
+        self.assertEqual(len(_make_spilled()), N)
+
+    def test_random_access_across_boundary(self):
+        ba = _make_spilled()
+        for i in (0, 1, 499, 500, 2500, N - 1):
+            self.assertEqual(ba[i], "item-%d" % i, msg="ba[%d]" % i)
+
+    def test_negative_index(self):
+        ba = _make_spilled()
+        self.assertEqual(ba[-1], "item-%d" % (N - 1))
+
+    def test_iteration_order_preserved(self):
+        ba = _make_spilled()
+        for idx, value in enumerate(ba):
+            if value != "item-%d" % idx:
+                self.fail("iteration order broke at %d: %r" % (idx, value))
+        self.assertEqual(idx, N - 1)
+
+    def test_pop_from_end(self):
+        ba = _make_spilled()
+        self.assertEqual(ba.pop(), "item-%d" % (N - 1))
+        self.assertEqual(len(ba), N - 1)
+
+    def test_pickle_roundtrip_across_spill(self):
+        ba = _make_spilled()
+        restored = pickle.loads(pickle.dumps(ba))
+        self.assertIsInstance(restored, BigArray)
+        self.assertEqual(len(restored), N)
+        self.assertEqual(restored[0], "item-0")
+        self.assertEqual(restored[N - 1], "item-%d" % (N - 1))
+
+
+class TestInMemorySmall(unittest.TestCase):
+    def test_no_spill_for_small(self):
+        ba = BigArray([1, 2, 3])
+        self.assertEqual(len(ba), 3)
+        self.assertEqual(list(ba), [1, 2, 3])
+        # the actual point of this test (the name promised it): a tiny array stays in ONE
+        # in-memory chunk and never touches disk
+        self.assertEqual(len(ba.chunks), 1, msg="small array unexpectedly spilled: %r" % (ba.chunks,))
+        self.assertFalse(any(isinstance(c, str) for c in ba.chunks), msg="small array wrote a disk chunk")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)