summaryrefslogtreecommitdiffstats
path: root/comm/third_party/botan/src/scripts/python_unittests.py
diff options
context:
space:
mode:
Diffstat (limited to 'comm/third_party/botan/src/scripts/python_unittests.py')
-rwxr-xr-xcomm/third_party/botan/src/scripts/python_unittests.py224
1 files changed, 224 insertions, 0 deletions
diff --git a/comm/third_party/botan/src/scripts/python_unittests.py b/comm/third_party/botan/src/scripts/python_unittests.py
new file mode 100755
index 0000000000..a6a22f3f0b
--- /dev/null
+++ b/comm/third_party/botan/src/scripts/python_unittests.py
@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+
+"""
+Unittests for Botan Python scripts.
+
+Requires Python 3.
+
+(C) 2017 Simon Warta (Kullo GmbH)
+
+Botan is released under the Simplified BSD License (see license.txt)
+"""
+
+import sys
+import unittest
+
+sys.path.append("../..") # Botan repo root
+from configure import AmalgamationHelper # pylint: disable=wrong-import-position
+from configure import ModulesChooser # pylint: disable=wrong-import-position
+
+class AmalgamationHelperTests(unittest.TestCase):
+ def test_matcher_std_includes(self):
+ self.assertEqual(AmalgamationHelper.is_unconditional_std_include("#include <string>"), "string")
+ self.assertEqual(AmalgamationHelper.is_unconditional_std_include("#include <string> // comment"), "string")
+
+ self.assertEqual(AmalgamationHelper.is_unconditional_std_include("#include <myfile.h>"), None)
+ self.assertEqual(AmalgamationHelper.is_unconditional_std_include("#include <unistd.h>"), None)
+ self.assertEqual(AmalgamationHelper.is_unconditional_std_include(" #include <string>"), None)
+
+ def test_matcher_botan_include(self):
+ self.assertEqual(AmalgamationHelper.is_botan_include("#include <botan/oids.h>"),
+ "oids.h")
+ self.assertEqual(AmalgamationHelper.is_botan_include("#include <botan/internal/socket.h>"),
+ "internal/socket.h")
+ self.assertEqual(AmalgamationHelper.is_botan_include("#include <botan/oids.h> // comment"),
+ "oids.h")
+ self.assertEqual(AmalgamationHelper.is_botan_include("#include <botan/internal/socket.h> // comment"),
+ "internal/socket.h")
+ self.assertEqual(AmalgamationHelper.is_botan_include(" #include <botan/oids.h>"),
+ "oids.h")
+ self.assertEqual(AmalgamationHelper.is_botan_include(" #include <botan/internal/socket.h>"),
+ "internal/socket.h")
+
+ self.assertEqual(AmalgamationHelper.is_botan_include("#include <string>"), None)
+ self.assertEqual(AmalgamationHelper.is_botan_include("#include <myfile.h>"), None)
+ self.assertEqual(AmalgamationHelper.is_botan_include("#include <unistd.h>"), None)
+
+ def test_matcher_any_includes(self):
+ self.assertEqual(AmalgamationHelper.is_any_include("#include <string>"), "string")
+ self.assertEqual(AmalgamationHelper.is_any_include("#include <myfile.h>"), "myfile.h")
+ self.assertEqual(AmalgamationHelper.is_any_include("#include <unistd.h>"), "unistd.h")
+ self.assertEqual(AmalgamationHelper.is_any_include("#include <botan/oids.h>"),
+ "botan/oids.h")
+ self.assertEqual(AmalgamationHelper.is_any_include(" #include <string>"), "string")
+ self.assertEqual(AmalgamationHelper.is_any_include(" #include <myfile.h>"), "myfile.h")
+ self.assertEqual(AmalgamationHelper.is_any_include(" #include <unistd.h>"), "unistd.h")
+ self.assertEqual(AmalgamationHelper.is_any_include(" #include <botan/oids.h>"),
+ "botan/oids.h")
+ self.assertEqual(AmalgamationHelper.is_any_include("#include <string> // comment"), "string")
+ self.assertEqual(AmalgamationHelper.is_any_include("#include <myfile.h> // comment"), "myfile.h")
+ self.assertEqual(AmalgamationHelper.is_any_include("#include <unistd.h> // comment"), "unistd.h")
+ self.assertEqual(AmalgamationHelper.is_any_include("#include <botan/oids.h> // comment"),
+ "botan/oids.h")
+
+class ModulesChooserResolveDependencies(unittest.TestCase):
+ def test_base(self):
+ available_modules = set(["A", "B"])
+ table = {
+ "A": [],
+ }
+ ok, modules = ModulesChooser.resolve_dependencies(available_modules, table, "A")
+ self.assertTrue(ok)
+ self.assertEqual(modules, set(["A"]))
+
+ def test_no_dependencies_defined(self):
+ available_modules = set(["A", "B"])
+ table = {
+ "A": [],
+ }
+ with self.assertRaises(KeyError):
+ ModulesChooser.resolve_dependencies(available_modules, table, "B")
+
+ available_modules = set(["A", "B"])
+ table = {
+ "A": ["B"],
+ }
+ with self.assertRaises(KeyError):
+ ModulesChooser.resolve_dependencies(available_modules, table, "A")
+
+ def test_add_dependency(self):
+ available_modules = set(["A", "B"])
+ table = {
+ "A": ["B"],
+ "B": []
+ }
+ ok, modules = ModulesChooser.resolve_dependencies(available_modules, table, "A")
+ self.assertTrue(ok)
+ self.assertEqual(modules, set(["A", "B"]))
+
+ def test_add_dependencies_two_levels(self):
+ available_modules = set(["A", "B", "C"])
+ table = {
+ "A": ["B"],
+ "B": ["C"],
+ "C": []
+ }
+ ok, modules = ModulesChooser.resolve_dependencies(available_modules, table, "A")
+ self.assertTrue(ok)
+ self.assertEqual(modules, set(["A", "B", "C"]))
+
+ def test_circular(self):
+ available_modules = set(["A", "B", "C"])
+ table = {
+ "A": ["B"],
+ "B": ["C"],
+ "C": ["A"]
+ }
+ ok, modules = ModulesChooser.resolve_dependencies(available_modules, table, "A")
+ self.assertTrue(ok)
+ self.assertEqual(modules, set(["A", "B", "C"]))
+
+ def test_not_available(self):
+ available_modules = set(["A", "C"])
+ table = {
+ "A": ["B"],
+ "B": ["C"],
+ "C": ["A"]
+ }
+ ok, _ = ModulesChooser.resolve_dependencies(available_modules, table, "B")
+ self.assertFalse(ok)
+
+ def test_dependency_not_available(self):
+ available_modules = set(["A", "C"])
+ table = {
+ "A": ["B"],
+ "B": ["C"],
+ "C": ["A"]
+ }
+ ok, _ = ModulesChooser.resolve_dependencies(available_modules, table, "A")
+ self.assertFalse(ok)
+
+ def test_dependency2_not_available(self):
+ available_modules = set(["A", "B"])
+ table = {
+ "A": ["B"],
+ "B": ["C"],
+ "C": ["A"]
+ }
+ ok, _ = ModulesChooser.resolve_dependencies(available_modules, table, "A")
+ self.assertFalse(ok)
+
+ def test_dependency_choices(self):
+ available_modules = set(["A", "B", "C"])
+ table = {
+ "A": ["B|C"],
+ "B": [],
+ "C": []
+ }
+ ok, modules = ModulesChooser.resolve_dependencies(available_modules, table, "A")
+ self.assertTrue(ok)
+ self.assertTrue(modules == set(["A", "B"]) or modules == set(["A", "C"]))
+
+ def test_dependency_prefer_existing(self):
+ available_modules = set(["A", "B", "C"])
+ table = {
+ "A": ["C", "B|C"],
+ "B": [],
+ "C": []
+ }
+ ok, modules = ModulesChooser.resolve_dependencies(available_modules, table, "A")
+ self.assertTrue(ok)
+ self.assertEqual(modules, set(["A", "C"]))
+
+ def test_dependency_prefer_existing2(self):
+ available_modules = set(["A", "B", "C"])
+ table = {
+ "A": ["B", "B|C"],
+ "B": [],
+ "C": []
+ }
+ ok, modules = ModulesChooser.resolve_dependencies(available_modules, table, "A")
+ self.assertTrue(ok)
+ self.assertEqual(modules, set(["A", "B"]))
+
+ def test_dependency_choices_impossible(self):
+ available_modules = set(["A", "C"])
+ table = {
+ "A": ["B|C"],
+ "B": [],
+ "C": []
+ }
+ ok, modules = ModulesChooser.resolve_dependencies(available_modules, table, "A")
+ self.assertTrue(ok)
+ self.assertEqual(modules, set(["A", "C"]))
+
+ def test_dependency_choices_impossible2(self):
+ available_modules = set(["A", "B"])
+ table = {
+ "A": ["B|C"],
+ "B": [],
+ "C": []
+ }
+ ok, modules = ModulesChooser.resolve_dependencies(available_modules, table, "A")
+ self.assertTrue(ok)
+ self.assertEqual(modules, set(["A", "B"]))
+
+ def test_deep(self):
+ available_modules = set(["A", "B", "C", "E", "G"])
+ table = {
+ "A": ["B|C"],
+ "B": ["D"],
+ "C": ["E"],
+ "D": [],
+ "E": ["F|G"],
+ "F": ["A", "B"],
+ "G": ["A", "G"]
+ }
+ ok, modules = ModulesChooser.resolve_dependencies(available_modules, table, "G")
+ self.assertTrue(ok)
+ self.assertEqual(modules, set(["G", "A", "C", "E"]))
+
+
+if __name__ == '__main__':
+ unittest.TestCase.longMessage = True
+ unittest.main()
generated by cgit v1.2.3 (git 2.39.1) at 2024-08-02 12:43:40 +0000