Update unit tests

tests/algorithm/ittest_algorithm.py

@@ -61,7 +61,7 @@ def test_should_NSGAII_work_when_solving_problem_ZDT1_with_standard_settings(sel
         hv = HyperVolume(reference_point=[1, 1])
         value = hv.compute([front[i].objectives for i in range(len(front))])
 
-        self.assertTrue(value >= 0.65)
+        self.assertGreater(value, 0.65)
 
     def test_should_SMPSO_work_when_solving_problem_ZDT1_with_standard_settings(self):
         problem = ZDT1()

tests/core/test_observable.py

@@ -4,31 +4,34 @@
 from jmetal.util.observable import DefaultObservable
 
 
-class DummyObserver(Observer):
+class FakeObserver(Observer):
+    """
+    Fake class used only for testing purposes.
+    """
     def update(self, *args, **kwargs):
         pass
 
 
 class ObservableTestCases(unittest.TestCase):
     def setUp(self):
         self.observable = DefaultObservable()
-        self.observer = DummyObserver()
+        self.observer = FakeObserver()
 
     def test_should_register_add_one_observer(self):
         self.observable.register(self.observer)
 
         self.assertEqual(1, len(self.observable.observers))
 
     def test_should_register_add_two_observers(self):
-        observer_two = DummyObserver()
+        observer_two = FakeObserver()
 
         self.observable.register(self.observer)
         self.observable.register(observer_two)
 
         self.assertEqual(2, len(self.observable.observers))
 
     def test_should_deregister_remove_the_observer_if_it_is_registered(self):
-        observer_two = DummyObserver()
+        observer_two = FakeObserver()
 
         self.observable.register(self.observer)
         self.observable.register(observer_two)
@@ -37,14 +40,14 @@ def test_should_deregister_remove_the_observer_if_it_is_registered(self):
         self.assertEqual(1, len(self.observable.observers))
 
     def test_should_deregister_not_remove_the_observer_if_it_is_not_registered(self):
-        observer_two = DummyObserver()
+        observer_two = FakeObserver()
 
         self.observable.register(self.observer)
         self.observable.deregister(observer_two)
 
         self.assertEqual(1, len(self.observable.observers))
-        self.assertTrue(self.observer in self.observable.observers)
-        self.assertFalse(observer_two in self.observable.observers)
+        self.assertIn(self.observer, self.observable.observers)
+        self.assertNotIn(observer_two, self.observable.observers)
 
     def test_should_deregister_all_remove_all_the_observers(self):
         self.observable.register(self.observer)

tests/core/test_operator.py

@@ -4,44 +4,40 @@
 from jmetal.core.solution import Solution
 
 
-class DummyMutation(Mutation):
-    def __init__(self, probability: float):
-        super(DummyMutation, self).__init__(probability=probability)
+class FakeMutation(Mutation):
+    """
+    Fake class used only for testing purposes.
+    """
 
-    def execute(self, source: Solution) -> None:
-        pass
+    def __init__(self, probability: float):
+        super(FakeMutation, self).__init__(probability=probability)
 
-    def get_name(self) -> str:
-        pass
 
+class FakeCrossover(Crossover):
+    """
+    Fake class used only for testing purposes.
+    """
 
-class DummyCrossover(Crossover):
     def __init__(self, probability: float):
-        super(DummyCrossover, self).__init__(probability=probability)
-
-    def execute(self, source: Solution) -> None:
-        pass
-
-    def get_name(self) -> str:
-        pass
+        super(FakeCrossover, self).__init__(probability=probability)
 
 
 class OperatorTestCase(unittest.TestCase):
     def test_should_mutation_constructor_raises_an_exception_is_probability_is_negative(self) -> None:
         with self.assertRaises(Exception):
-            DummyMutation(-1)
+            FakeMutation(-1)
 
     def test_should_mutation_constructor_raises_an_exception_is_probability_is_higher_than_one(self) -> None:
         with self.assertRaises(Exception):
-            DummyMutation(1.1)
+            FakeMutation(1.1)
 
     def test_should_crossover_constructor_raises_an_exception_is_probability_is_negative(self) -> None:
         with self.assertRaises(Exception):
-            DummyCrossover(-1)
+            FakeCrossover(-1)
 
     def test_should_crossover_constructor_raises_an_exception_is_probability_is_higher_than_one(self) -> None:
         with self.assertRaises(Exception):
-            DummyMutation(1.1)
+            FakeCrossover(1.1)
 
 
 if __name__ == "__main__":

tests/core/test_problem.py

@@ -4,9 +4,13 @@
 from jmetal.core.solution import FloatSolution, IntegerSolution
 
 
-class DummyIntegerProblem(IntegerProblem):
+class FakeIntegerProblem(IntegerProblem):
+    """
+    Fake class used only for testing purposes.
+    """
+
     def __init__(self):
-        super(DummyIntegerProblem, self).__init__()
+        super(FakeIntegerProblem, self).__init__()
 
     def number_of_objectives(self) -> int:
         return 2
@@ -21,9 +25,13 @@ def name(self) -> str:
         return "Dummy integer problem"
 
 
-class DummyFloatProblem(FloatProblem):
+class FakeFloatProblem(FloatProblem):
+    """
+    Fake class used only for testing purposes.
+    """
+
     def __init__(self):
-        super(DummyFloatProblem, self).__init__()
+        super(FakeFloatProblem, self).__init__()
 
     def number_of_objectives(self) -> int:
         return 2
@@ -43,7 +51,7 @@ def test_should_default_constructor_create_a_valid_problem(self):
         lower_bound = [-1.0]
         upper_bound = [1.0]
 
-        problem = DummyFloatProblem()
+        problem = FakeFloatProblem()
         problem.lower_bound = lower_bound
         problem.upper_bound = upper_bound
 
@@ -54,20 +62,20 @@ def test_should_default_constructor_create_a_valid_problem(self):
         self.assertEqual([1], problem.upper_bound)
 
     def test_should_create_solution_create_a_valid_solution(self):
-        problem = DummyFloatProblem()
+        problem = FakeFloatProblem()
 
         problem.lower_bound = [-1.0, -2.0]
         problem.upper_bound = [1.0, 2.0]
 
         solution = problem.create_solution()
-        self.assertNotEqual(None, solution)
+        self.assertIsNotNone(solution)
         self.assertTrue(-1.0 <= solution.variables[0] <= 1.0)
         self.assertTrue(-2.0 <= solution.variables[1] <= 2.0)
 
 
 class IntegerProblemTestCases(unittest.TestCase):
     def test_should_default_constructor_create_a_valid_problem(self):
-        problem = DummyIntegerProblem()
+        problem = FakeIntegerProblem()
 
         problem.lower_bound = [-1]
         problem.upper_bound = [1]
@@ -79,15 +87,15 @@ def test_should_default_constructor_create_a_valid_problem(self):
         self.assertEqual([1], problem.upper_bound)
 
     def test_should_create_solution_create_a_valid_solution(self):
-        problem = DummyIntegerProblem()
+        problem = FakeIntegerProblem()
 
         problem.lower_bound = [-1, -2]
         problem.upper_bound = [1, 2]
 
         print(problem.number_of_variables())
 
         solution = problem.create_solution()
-        self.assertNotEqual(None, solution)
+        self.assertIsNotNone(solution)
         self.assertTrue(-1 <= solution.variables[0] <= 1)
         self.assertTrue(-2 <= solution.variables[1] <= 2)