def setUp(self):
        self.maxDiff = None
        self.td1 = TrainDescription(
            train_name='test_train',
            train_version='1.0',
            properties={
                1: url_by_name('FOO'),
                2: token_by_name('BAR'),
                3: enum_by_name('BAZ', choices=['VALUE1', 'VALUE2'])
            },
            formulas=[ConjunctiveNormalForm(Clause(1))],
            model_summary='model summary',
            algorithm_requirement=FormulaAlgorithmRequirement(1))

        self.td2 = TrainDescription(
            train_name='test_train',
            train_version='1.0',
            properties={
                1: url_by_name('FOO'),
                2: token_by_name('BAR'),
                3: enum_by_name('BAZ', choices=['VALUE1', 'VALUE2'])
            },
            formulas=[ConjunctiveNormalForm(Clause(1))],
            model_summary='model summary',
            algorithm_requirement=None)

        self.td3 = TrainDescription(
            train_name='test_train',
            train_version='1.0',
            properties={
                1: url_by_name('FOO'),
                2: token_by_name('BAR'),
                3: enum_by_name('BAZ', choices=['VALUE1', 'VALUE2'])
            },
            formulas=[
                ConjunctiveNormalForm(
                    Clause(1), Clause(-2, 1, 3), Clause(3, 1, -2, -3)
                ),
                ConjunctiveNormalForm(
                    Clause(3, 1), Clause(2, 1, 3, -3)
                ),
                ConjunctiveNormalForm(
                    Clause(-1)
                )
            ],
            model_summary='model summary',
            algorithm_requirement=FormulaAlgorithmRequirement(3))
 def test_invalid_train_description_5(self):
     self.assertValueError(lambda: TrainDescription(
         train_name='foo',
         train_version='1.0',
         properties={
             1: url_by_name('FOO'),
             2: token_by_name('BAR'),
             3: enum_by_name('BAZ', choices=['VALUE1', 'VALUE2'])
         },
         formulas=[
             ConjunctiveNormalForm(
                 Clause(1, -3), Clause(4),
             )
         ],
         model_summary='model summary',
         algorithm_requirement=None))
 def cnf(self):
     return ConjunctiveNormalForm(*self.clauses)
 def test_eq_4(self):
     self.assertIsEqual(ConjunctiveNormalForm(Clause(-1, -2), Clause(-1, -2)), self.cnf4)
 def setUp(self):
     self.cnf1 = ConjunctiveNormalForm(Clause(3, 4), Clause(1, 2))
     self.cnf2 = ConjunctiveNormalForm(Clause(1))
     self.cnf3 = ConjunctiveNormalForm(Clause(1), Clause(1, 2))
     self.cnf4 = ConjunctiveNormalForm(Clause(-1, -2), Clause(-1, -2))
 def test_eq_3(self):
     self.assertIsEqual(ConjunctiveNormalForm(Clause(1), Clause(1, 2)), self.cnf3)
class CnfTests(BaseTest):

    def setUp(self):
        self.cnf1 = ConjunctiveNormalForm(Clause(3, 4), Clause(1, 2))
        self.cnf2 = ConjunctiveNormalForm(Clause(1))
        self.cnf3 = ConjunctiveNormalForm(Clause(1), Clause(1, 2))
        self.cnf4 = ConjunctiveNormalForm(Clause(-1, -2), Clause(-1, -2))

    ################################################################################
    # Empty CNF not allowed
    ################################################################################
    def test_empty_CNF_not_allowed(self):
        self.assertTypeError(lambda: ConjunctiveNormalForm())

    ################################################################################
    # Type Error
    ################################################################################
    def test_type_error_1(self):
        self.assertTypeError(lambda: ConjunctiveNormalForm(1))

    def test_type_error_2(self):
        self.assertTypeError(lambda: ConjunctiveNormalForm(False))

    def test_type_error_3(self):
        self.assertTypeError(lambda: ConjunctiveNormalForm({}))

    def test_type_error_4(self):
        self.assertTypeError(lambda: ConjunctiveNormalForm([]))

    def test_type_error_5(self):
        self.assertTypeError(lambda: ConjunctiveNormalForm('ad'))

    def test_type_error_6(self):
        self.assertTypeError(lambda: ConjunctiveNormalForm(None))

    ################################################################################
    # equals and hash
    ################################################################################
    def test_eq_1(self):
        self.assertIsEqual(ConjunctiveNormalForm(Clause(3, 4), Clause(1, 2)), self.cnf1)

    def test_eq_2(self):
        self.assertIsEqual(ConjunctiveNormalForm(Clause(1)), self.cnf2)

    def test_eq_3(self):
        self.assertIsEqual(ConjunctiveNormalForm(Clause(1), Clause(1, 2)), self.cnf3)

    def test_eq_4(self):
        self.assertIsEqual(ConjunctiveNormalForm(Clause(-1, -2), Clause(-1, -2)), self.cnf4)

    ################################################################################
    # Copy
    ################################################################################
    def test_copy_1(self):
        self.assertCopiesAreEqualOf(self.cnf1)

    def test_copy_2(self):
        self.assertCopiesAreEqualOf(self.cnf2)

    def test_copy_3(self):
        self.assertCopiesAreEqualOf(self.cnf3)

    def test_copy_4(self):
        self.assertCopiesAreEqualOf(self.cnf4)

    ################################################################################
    # as_dict
    ################################################################################
    def test_simple_dict_1(self):
        self.checkExpect(
            expect={
                'value': [[1, 2], [3, 4]],
                '@type': ['ConjunctiveNormalForm', 'Formula'],
                '@typeName': 'ConjunctiveNormalForm',
                "@typeSystem": {
                    'name': 'pythonclass',
                    'version': '1.0'
                },
            },
            actual=self.cnf1.as_simple_mapping())

    def test_dict_2(self):
        self.checkExpect(
            expect={
                'value': [[1]],
                '@type': ['ConjunctiveNormalForm', 'Formula'],
                '@typeName': 'ConjunctiveNormalForm',
                "@typeSystem": {
                    'name': 'pythonclass',
                    'version': '1.0'
                }
            },
            actual=self.cnf2.as_simple_mapping())

    def test_dict_3(self):
        self.checkExpect(
            expect={
                'value': [[1], [1, 2]],
                '@type': ['ConjunctiveNormalForm', 'Formula'],
                '@typeName': 'ConjunctiveNormalForm',
                "@typeSystem": {
                    'name': 'pythonclass',
                    'version': '1.0'
                },
            },
            actual=self.cnf3.as_simple_mapping())

    def test_dict_4(self):
        self.checkExpect(
            expect={
                'value': [[-2, -1]],
                '@type': ['ConjunctiveNormalForm', 'Formula'],
                '@typeName': 'ConjunctiveNormalForm',
                "@typeSystem": {
                    'name': 'pythonclass',
                    'version': '1.0'
                },
            },
            actual=self.cnf4.as_simple_mapping())

    ################################################################################
    # type
    ################################################################################
    def test_type_1(self):
        self.checkExpect(
            expect=['ConjunctiveNormalForm', 'Formula'],
            actual=self.cnf1.type)

    def test_type_2(self):
        self.checkExpect(
            expect=['ConjunctiveNormalForm', 'Formula'],
            actual=self.cnf2.type)

    def test_type_3(self):
        self.checkExpect(
            expect=['ConjunctiveNormalForm', 'Formula'],
            actual=self.cnf3.type)

    def test_type_4(self):
        self.checkExpect(
            expect=['ConjunctiveNormalForm', 'Formula'],
            actual=self.cnf4.type)

    ################################################################################
    # display
    ################################################################################
    def test_display_1(self):
        self.checkExpect(
            expect='ConjunctiveNormalForm',
            actual=self.cnf1.type_name)

    def test_display_2(self):
        self.checkExpect(
            expect='ConjunctiveNormalForm',
            actual=self.cnf2.type_name)

    def test_display_3(self):
        self.checkExpect(
            expect='ConjunctiveNormalForm',
            actual=self.cnf3.type_name)

    def test_display_4(self):
        self.checkExpect(
            expect='ConjunctiveNormalForm',
            actual=self.cnf4.type_name)

    ################################################################################
    # data
    ################################################################################
    def test_data_1(self):
        self.checkExpect(
            expect={'value': [[1, 2], [3, 4]]},
            actual=self.cnf1.data)

    def test_data_2(self):
        self.checkExpect(
            expect={'value': [[1]]},
            actual=self.cnf2.data)

    def test_data_3(self):
        self.checkExpect(
            expect={'value': [[1], [1, 2]]},
            actual=self.cnf3.data)

    def test_data_4(self):
        self.checkExpect(
            expect={'value': [[-2, -1]]},
            actual=self.cnf4.data)

    ################################################################################
    # str
    ################################################################################
    def test_str_1(self):
        self.checkExpect(
            expect='[[1, 2], [3, 4]]',
            actual=str(self.cnf1))

    def test_str_2(self):
        self.checkExpect(
            expect='[[1]]',
            actual=str(self.cnf2))

    def test_str_3(self):
        self.checkExpect(
            expect='[[1], [1, 2]]',
            actual=str(self.cnf3))

    def test_str_4(self):
        self.checkExpect(
            expect='[[-2, -1]]',
            actual=str(self.cnf4))

    ################################################################################
    # repr
    ################################################################################
    def test_repr_1(self):
        self.checkExpect(
            expect='[[1, 2], [3, 4]]',
            actual=repr(self.cnf1))

    def test_repr_2(self):
        self.checkExpect(
            expect='[[1]]',
            actual=repr(self.cnf2))

    def test_repr_3(self):
        self.checkExpect(
            expect='[[1], [1, 2]]',
            actual=repr(self.cnf3))

    def test_repr_4(self):
        self.checkExpect(
            expect='[[-2, -1]]',
            actual=repr(self.cnf4))

    ################################################################################
    # Contains
    ################################################################################
    def test_contains_1(self):
        self.assertMembership(
            for_container=self.cnf1,
            elements=[Clause(1, 2), Clause(3, 4)],
            not_elements=[Clause(1)])

    def test_contains_2(self):
        self.assertMembership(
            for_container=self.cnf2,
            elements=[Clause(1)],
            not_elements=[Clause(1, 2)])

    def test_contains_3(self):
        self.assertMembership(
            for_container=self.cnf3,
            elements=[Clause(1), Clause(1, 2)],
            not_elements=[Clause(-4, -2)])

    def test_contains_4(self):
        self.assertMembership(
            for_container=self.cnf4,
            elements=[Clause(-1, -2)],
            not_elements=[Clause(1)])

    ################################################################################
    # len
    ################################################################################
    def test_len_1(self):
        self.checkExpect(
            expect=2,
            actual=len(self.cnf1))

    def test_len_2(self):
        self.checkExpect(
            expect=1,
            actual=len(self.cnf2))

    def test_len_3(self):
        self.checkExpect(
            expect=2,
            actual=len(self.cnf3))

    def test_len_4(self):
        self.checkExpect(
            expect=1,
            actual=len(self.cnf4))

    ################################################################################
    # Value
    ################################################################################
    def test_value_1(self):
        self.checkExpect(
            expect=[[1, 2], [3, 4]],
            actual=self.cnf1.value)

    def test_value_2(self):
        self.checkExpect(
            expect=[[1]],
            actual=self.cnf2.value)

    def test_value_3(self):
        self.checkExpect(
            expect=[[1], [1, 2]],
            actual=self.cnf3.value)

    def test_value_4(self):
        self.checkExpect(
            expect=[[-2, -1]],
            actual=self.cnf4.value)
 def test_eq_2(self):
     self.assertIsEqual(ConjunctiveNormalForm(Clause(1)), self.cnf2)
 def test_type_error_6(self):
     self.assertTypeError(lambda: ConjunctiveNormalForm(None))
 def test_type_error_5(self):
     self.assertTypeError(lambda: ConjunctiveNormalForm('ad'))
 def test_type_error_2(self):
     self.assertTypeError(lambda: ConjunctiveNormalForm(False))
 def test_empty_CNF_not_allowed(self):
     self.assertTypeError(lambda: ConjunctiveNormalForm())