Esempio n. 1
0
    def test_get_logic_key(self):

        logic = has_all([1, 2, 3], True)
        self.assertEqual(
            get_logic_key(logic),
            'x[e{1&2&3}]:y'
        )

        logic = has_count([is_ge(1), [5, 6, 7, 8, 9]])
        self.assertEqual(
            get_logic_key(logic),
            'x[(5,6,7,8,9){>=1}]:y'
        )

        logic = not_count([is_ge(1), [5, 6, 7, 8, 9]])
        self.assertEqual(
            get_logic_key(logic),
            'x[(5,6,7,8,9)~{>=1}]:y'
        )

        logic = union([
            has_any([1, 2]),
            has_all([3, 4]),
            not_any([5, 6])
        ])
        self.assertEqual(
            get_logic_key(logic),
            'x[({1,2},{3&4},~{5,6})]:y'
        )

        logic = union([
            intersection([
                has_any([1, 2]),
                not_any([3])
            ]),
            {'Wave': has_any([1,2])}
        ])
        self.assertEqual(
            get_logic_key(logic, self.example_data_A_data),
            'x[(({1,2}&~{3}),Wave={1,2})]:y'
        )
Esempio n. 2
0
    def test_has_not_any_errors(self):

        # Test values not given as a list
        gender = self.example_data_A_data['gender']
        for test_values in [1, 'wrong!']:
            # Test has version
            with self.assertRaises(TypeError) as error:
                # Test _has_all raises TypeError
                func, values = has_any(test_values)
            self.assertEqual(
                error.exception.message[:54],
                "The values given to has_any() must be given as a list."
            )
            # Test not version
            with self.assertRaises(TypeError) as error:
                # Test _has_all raises TypeError
                func, values = not_any(test_values)
            self.assertEqual(
                error.exception.message[:54],
                "The values given to not_any() must be given as a list."
            )

        # Test values inside the values are not int
        gender = self.example_data_A_data['gender']
        for test_values in [['1'], [1.9, 2, 3]]:
            # Test has version
            with self.assertRaises(TypeError) as error:
                # Test _has_all raises TypeError
                func, values = has_any(test_values)
            self.assertEqual(
                error.exception.message[:54],
                "The values given to has_any() are not correctly typed."
            )
            # Test not version
            with self.assertRaises(TypeError) as error:
                # Test _has_all raises TypeError
                func, values = not_any(test_values)
            self.assertEqual(
                error.exception.message[:54],
                "The values given to not_any() are not correctly typed."
            )
    def test_has_not_any_errors(self):
        
        # Test values not given as a list
        gender = self.example_data_A_data['gender']
        for test_values in [1, 'wrong!']:
            # Test has version
            with self.assertRaises(TypeError) as error:
                # Test _has_all raises TypeError
                func, values = has_any(test_values)
            self.assertEqual(
                error.exception.message[:54],
                "The values given to has_any() must be given as a list."
            )
            # Test not version
            with self.assertRaises(TypeError) as error:
                # Test _has_all raises TypeError
                func, values = not_any(test_values)
            self.assertEqual(
                error.exception.message[:54],
                "The values given to not_any() must be given as a list."
            )
 
        # Test values inside the values are not int
        gender = self.example_data_A_data['gender']
        for test_values in [['1'], [1.9, 2, 3]]:
            # Test has version
            with self.assertRaises(TypeError) as error:
                # Test _has_all raises TypeError
                func, values = has_any(test_values)
            self.assertEqual(
                error.exception.message[:54],
                "The values given to has_any() are not correctly typed."
            )
            # Test not version
            with self.assertRaises(TypeError) as error:
                # Test _has_all raises TypeError
                func, values = not_any(test_values)
            self.assertEqual(
                error.exception.message[:54],
                "The values given to not_any() are not correctly typed."
            )
 def test_get_logic_key(self):
     
     logic = has_all([1, 2, 3], True)
     self.assertEqual(
         get_logic_key(logic),
         'x[e(1&2&3)]:y'
     )
     
     logic = has_count([is_ge(1), [5, 6, 7, 8, 9]])
     self.assertEqual(
         get_logic_key(logic),
         'x[(5,6,7,8,9){>=1}]:y'
     )
     
     logic = not_count([is_ge(1), [5, 6, 7, 8, 9]])
     self.assertEqual(
         get_logic_key(logic),
         'x[(5,6,7,8,9)~{>=1}]:y'
     )
     
     logic = union([
         has_any([1, 2]), 
         has_all([3, 4]), 
         not_any([5, 6])
     ])
     self.assertEqual(
         get_logic_key(logic),
         'x[((1,2),(3&4),~(5,6))]:y'
     )
     
     logic = union([
         intersection([
             has_any([1, 2]),
             not_any([3])
         ]),
         {'Wave': has_any([1,2])}
     ])
     self.assertEqual(
         get_logic_key(logic, self.example_data_A_data),
         'x[(((1,2)&~(3)),Wave=(1,2))]:y'
     )
Esempio n. 5
0
    def test_get_logic_key(self):

        logic = has_all([1, 2, 3], True)
        self.assertEqual(get_logic_key(logic), 'x[e(1&2&3)]:y')

        logic = has_count([is_ge(1), [5, 6, 7, 8, 9]])
        self.assertEqual(get_logic_key(logic), 'x[(5,6,7,8,9){>=1}]:y')

        logic = not_count([is_ge(1), [5, 6, 7, 8, 9]])
        self.assertEqual(get_logic_key(logic), 'x[(5,6,7,8,9)~{>=1}]:y')

        logic = union([has_any([1, 2]), has_all([3, 4]), not_any([5, 6])])
        self.assertEqual(get_logic_key(logic), 'x[((1,2),(3&4),~(5,6))]:y')

        logic = union([
            intersection([has_any([1, 2]), not_any([3])]), {
                'Wave': has_any([1, 2])
            }
        ])
        self.assertEqual(get_logic_key(logic, self.example_data_A_data),
                         'x[(((1,2)&~(3)),Wave=(1,2))]:y')
Esempio n. 6
0
    def test_has_not_any(self):
        # Test has version
        test_values = [1, 3, 5]
        func, values, exclusive = has_any(test_values)
        self.assertEqual(func, _has_any)
        self.assertEqual(values, test_values)
        self.assertEqual(exclusive, False)

        # Test not version
        test_values = [1, 3, 5]
        func, values, exclusive = not_any(test_values)
        self.assertEqual(func, _not_any)
        self.assertEqual(values, test_values)
        self.assertEqual(exclusive, False)
    def test_has_not_any(self):
        # Test has version
        test_values = [1, 3, 5]
        func, values, exclusive = has_any(test_values)
        self.assertEqual(func, _has_any)
        self.assertEqual(values, test_values)
        self.assertEqual(exclusive, False)

        # Test not version
        test_values = [1, 3, 5]
        func, values, exclusive = not_any(test_values)
        self.assertEqual(func, _not_any)
        self.assertEqual(values, test_values)
        self.assertEqual(exclusive, False)