Update of unit tests

tests/test_threads.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python
+
+"""
+Copyright (c) 2006-2026 sqlmap developers (https://sqlmap.org)
+See the file 'LICENSE' for copying permission
+
+Threading helpers in lib/core/threads.py: the thread-local data model,
+current-thread accessors, the exception-isolating wrapper, and runThreads()
+(the worker-pool driver used throughout extraction). Exercised with trivial,
+fast, network-free workers.
+"""
+
+import os
+import sys
+import threading
+import unittest
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _testutils import bootstrap
+bootstrap()
+
+from lib.core import threads as T
+from lib.core.data import conf, kb
+from thirdparty.six.moves import queue as _queue
+
+
+class TestThreadData(unittest.TestCase):
+    def test_reset_initializes_fields(self):
+        td = T.getCurrentThreadData()
+        td.retriesCount = 5
+        td.reset()
+        self.assertEqual(td.retriesCount, 0)
+        self.assertEqual(td.valueStack, [])
+        self.assertFalse(td.disableStdOut)
+
+    def test_get_current_thread_data_is_threadlocal(self):
+        # ThreadData subclasses threading.local: the wrapper object is shared, but its
+        # ATTRIBUTE STATE is per-thread. Verify both: same object, independent state.
+        main = T.getCurrentThreadData()
+        self.assertIs(main, T.getCurrentThreadData())      # stable within a thread
+
+        main.retriesCount = 111
+
+        other = {}
+
+        def worker():
+            td = T.getCurrentThreadData()
+            other["same_obj"] = (td is main)
+            # a fresh thread gets reset()-initialised state, NOT the main thread's 111
+            other["retries_seen"] = td.retriesCount
+            td.retriesCount = 222
+
+        t = threading.Thread(target=worker)
+        t.start()
+        t.join()
+
+        # the wrapper object identity is shared (threading.local semantics) ...
+        self.assertTrue(other["same_obj"])
+        # ... but the worker never saw the main thread's mutation (thread-local state) ...
+        self.assertEqual(other["retries_seen"], 0)
+        # ... and the worker's own mutation did not leak back into the main thread
+        self.assertEqual(main.retriesCount, 111)
+
+    def test_get_current_thread_name(self):
+        self.assertEqual(T.getCurrentThreadName(), threading.current_thread().name)
+
+
+class TestExceptionHandledFunction(unittest.TestCase):
+    def test_success_runs_function(self):
+        calls = []
+        T.exceptionHandledFunction(lambda: calls.append(1))
+        self.assertEqual(calls, [1])
+
+    def _capture_errors(self, silent):
+        """Run a raising worker, returning the list of logged error messages."""
+        errors = []
+
+        class _Rec(object):
+            def error(self, msg, *a):
+                errors.append(msg % a if a else msg)
+
+            def __getattr__(self, name):
+                return lambda *a, **k: None
+
+        saved_logger = T.logger
+        saved_continue = kb.get("threadContinue")
+        saved_multi = kb.get("multipleCtrlC")
+        T.logger = _Rec()
+        kb.threadContinue = True
+        kb.multipleCtrlC = False
+        try:
+            # must never propagate, regardless of the silent flag
+            T.exceptionHandledFunction(lambda: 1 / 0, silent=silent)
+        finally:
+            T.logger = saved_logger
+            kb.threadContinue = saved_continue
+            kb.multipleCtrlC = saved_multi
+        return errors
+
+    def test_non_silent_logs_error(self):
+        # silent=False (with threadContinue) routes the swallowed exception to logger.error
+        errors = self._capture_errors(silent=False)
+        self.assertTrue(errors, msg="non-silent mode logged no error")
+        self.assertTrue(any("ZeroDivisionError" in e for e in errors),
+                        msg="error message did not name the exception: %r" % errors)
+
+    def test_silent_logs_nothing(self):
+        # silent=True gates the logging: the exception is swallowed without any error log
+        errors = self._capture_errors(silent=True)
+        self.assertEqual(errors, [], msg="silent mode unexpectedly logged: %r" % errors)
+
+    def test_keyboardinterrupt_propagates(self):
+        def boom():
+            raise KeyboardInterrupt
+        self.assertRaises(KeyboardInterrupt, T.exceptionHandledFunction, boom)
+
+
+class TestSetDaemon(unittest.TestCase):
+    def test_sets_daemon_flag(self):
+        t = threading.Thread(target=lambda: None)
+        T.setDaemon(t)
+        self.assertTrue(t.daemon)
+
+
+class TestRunThreads(unittest.TestCase):
+    def setUp(self):
+        self._saved = {k: conf.get(k) for k in ("threads", "hashDB")}
+        conf.hashDB = None
+
+    def tearDown(self):
+        for k, v in self._saved.items():
+            conf[k] = v
+
+    def test_workers_drain_shared_queue(self):
+        q = _queue.Queue()
+        total = 50
+        for i in range(total):
+            q.put(i)
+        seen = []
+        lock = threading.Lock()
+
+        def worker():
+            while True:
+                try:
+                    item = q.get_nowait()
+                except _queue.Empty:
+                    break
+                with lock:
+                    seen.append(item)
+
+        conf.threads = 4
+        T.runThreads(4, worker, startThreadMsg=False)
+        self.assertEqual(sorted(seen), list(range(total)))
+
+    def test_single_thread_runs_worker(self):
+        calls = []
+        conf.threads = 1
+        T.runThreads(1, lambda: calls.append(1), startThreadMsg=False)
+        self.assertEqual(calls, [1])
+
+    def test_cleanup_function_invoked(self):
+        flags = []
+        conf.threads = 2
+        T.runThreads(2, lambda: None,
+                     cleanupFunction=lambda: flags.append(1),
+                     startThreadMsg=False)
+        self.assertTrue(flags)
+
+
+if __name__ == "__main__":
+    unittest.main()