Python ModulesChooser Examples

Example #1

File: python_unittests.py Project: Hackmanit/botan

    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")

Example #2

    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")

Example #3

 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"]))

Example #4

 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"]))

Example #5

 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"]))

Example #6

 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"]))

Example #7

File: python_unittests.py Project: Hackmanit/botan

 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"]))

Example #8

 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)

Example #9

File: python_unittests.py Project: Hackmanit/botan

 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)

Example #10

File: python_unittests.py Project: Hackmanit/botan

 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"]))

Example #11

File: python_unittests.py Project: Hackmanit/botan

 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"]))

Example #12

File: python_unittests.py Project: Hackmanit/botan

 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"]))

Example #13

 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"]))

Example #14

File: python_unittests.py Project: Hackmanit/botan

 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"]))