diff options
Diffstat (limited to 'tests/analysis/scan/expr.py')
-rw-r--r-- | tests/analysis/scan/expr.py | 169 |
1 files changed, 169 insertions, 0 deletions
diff --git a/tests/analysis/scan/expr.py b/tests/analysis/scan/expr.py new file mode 100644 index 0000000..dbe8c55 --- /dev/null +++ b/tests/analysis/scan/expr.py @@ -0,0 +1,169 @@ + + +from chrysacase import ChrysalideTestCase +from pychrysalide.analysis.scan import ScanExpression +from pychrysalide.glibext import ComparableItem + + +class TestScanExpression(ChrysalideTestCase): + """TestCase for analysis.scan.ScanExpression.""" + + + def testDirectInstances(self): + """Reject direct instances.""" + + with self.assertRaisesRegex(RuntimeError, 'pychrysalide.analysis.scan.ScanExpression is an abstract class'): + + e = ScanExpression() + + + def testBooleanComparison(self): + """Compare custom scan expressions.""" + + class StrLenExpr(ScanExpression): + + def __init__(self, value): + super().__init__(ScanExpression.ExprValueType.STRING) + self._value = value + + def _cmp_rich(self, other, op): + + if op == ComparableItem.RichCmpOperation.EQ: + return len(self._value) == len(other._value) + + + e0 = StrLenExpr('00000000000') + + e1 = StrLenExpr('00000000000') + + e2 = StrLenExpr('000000000000000000000000000') + + self.assertTrue(e0 == e1) + + # !? + # Python teste e0 != e1 (non implémenté), puis e1 != e0 (pareil) et en déduit une différence ! + # self.assertFalse(e0 != e1) + + self.assertFalse(e0 == e2) + + # TypeError: '<' not supported between instances of 'StrLenExpr' and 'StrLenExpr' + with self.assertRaisesRegex(TypeError, '\'<\' not supported between instances'): + self.assertTrue(e0 < e1) + + + + + + + # def testTypeSubclassing(self): + # """Verify the data type subclassing is working.""" + + # class MyType(DataType): + + # def __init__(self, num): + # super(MyType, self).__init__() + # self._num = num + + # def _to_string(self, include): + # return '%x' % self._num + + # def _dup(self): + # return MyType(self._num) + + # tp = MyType(0x123) + + # self.assertEqual(str(tp), '123') + + # tp2 = tp.dup() + + # self.assertEqual(str(tp), str(tp2)) + + + # def testTypeDefaultProperties(self): + # """Check for default values of some type properties.""" + + # class MyPropType(DataType): + # pass + + # tp = MyPropType() + + # self.assertTrue(tp.handle_namespaces) + + # self.assertFalse(tp.is_pointer) + + # self.assertFalse(tp.is_reference) + + # class MyPropType2(DataType): + + # def _handle_namespaces(self): + # return True + + # def _is_pointer(self): + # return 123 < 1234 + + # def _is_reference(self): + # return False + + # tp2 = MyPropType2() + + # self.assertTrue(tp.handle_namespaces) + + # self.assertTrue(tp2.is_pointer) + + # self.assertFalse(tp2.is_reference) + + + # def testTypeNamespaces(self): + # """Test the type namespace property.""" + + # class MyNSType(DataType): + + # def __init__(self, name): + # super(MyNSType, self).__init__() + # self._name = name + + # def _to_string(self, include): + # return self._name + + # tp = MyNSType('TP') + # ns = MyNSType('NS') + + # self.assertIsNone(tp.namespace) + + # tp.namespace = (ns, '.') + + # self.assertEqual(str(tp), 'NS.TP') + + # self.assertEqual(tp.namespace, (ns, '.')) + + + # def testTypeHash(self): + # """Hash a user-defined type.""" + + # class MyUserType(DataType): + + # def __init__(self, name): + # super(MyUserType, self).__init__() + # self._name = name + + # def _hash(self): + # return hash(self._name) + + # tp = MyUserType('random') + + # self.assertEqual(tp.hash, hash('random') & ((1 << 32) - 1)) + + # class MyOutOfRangeUserType(DataType): + + # hard_coded_hash = -8752470794866657507 + + # def __init__(self, name): + # super(MyOutOfRangeUserType, self).__init__() + # self._name = name + + # def _hash(self): + # return self.hard_coded_hash + + # tp = MyOutOfRangeUserType('out-of-range') + + # self.assertEqual(tp.hash, MyOutOfRangeUserType.hard_coded_hash & ((1 << 32) - 1)) |