4 files changed, 195 insertions, 2 deletions
diff --git a/tests/plugins/encodings/all.py b/tests/plugins/encodings/all.py
new file mode 100644
index 0000000..a856ccb
--- /dev/null
+++ b/tests/plugins/encodings/all.py
@@ -0,0 +1,23 @@
+
+from chrysacase import ChrysalideTestCase
+from pychrysalide.plugins import encodings
+
+import base64
+
+
+class TestEncodingsModule(ChrysalideTestCase):
+    """TestCase for encodings plugin."""
+
+    def testBase64Encoding(self):
+        """Validate the base64 implementation."""
+
+        text = '0123456789abcdef'
+
+        for i in range(len(text) + 1):
+
+            src = text[:i].encode('ascii')
+
+            encoded = encodings.base64_encode(src)
+            ref = base64.b64encode(src)
+
+            self.assertEqual(encoded, ref)
diff --git a/tests/plugins/kaitai/__init__.py b/tests/plugins/kaitai/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/plugins/kaitai/__init__.py
diff --git a/tests/plugins/kaitai/language.py b/tests/plugins/kaitai/language.py
index b1e8881..43b6185 100644
--- a/tests/plugins/kaitai/language.py
+++ b/tests/plugins/kaitai/language.py
@@ -1312,8 +1312,8 @@ instances:
 
         self.assertEqual(parsed.result_0.value.value, b'\x01\x02\x03\x04\x05\x06\x07\x08\x09')
 
-        self.assertEqual(type(parsed.result_1).__name__, 'RecordValue')            # result_1
-        self.assertEqual(type(parsed.result_1.value).__name__, 'RecordValue')      # result_1.ref
+        self.assertEqual(type(parsed.result_1).__name__, 'RecordDelayed')          # result_1
+        self.assertEqual(type(parsed.result_1.value).__name__, 'RecordDelayed')    # result_1.ref
         self.assertEqual(type(parsed.result_1.value.value).__name__, 'RecordList') # result_1.ref.table
 
         self.assertEqual(parsed.result_1.value.value[3].value, 0x04)
diff --git a/tests/plugins/kaitai/rost.py b/tests/plugins/kaitai/rost.py
new file mode 100644
index 0000000..4a29ef8
--- /dev/null
+++ b/tests/plugins/kaitai/rost.py
@@ -0,0 +1,170 @@
+#!/usr/bin/python3-dbg
+# -*- coding: utf-8 -*-
+
+import locale
+
+from chrysacase import ChrysalideTestCase
+from pychrysalide.analysis.contents import MemoryContent
+from pychrysalide.analysis.scan import ContentScanner
+from pychrysalide.analysis.scan import ScanOptions
+from pychrysalide.analysis.scan.patterns.backends import AcismBackend
+from pychrysalide import core
+from pychrysalide.plugins.kaitai.parsers import KaitaiStruct
+from pychrysalide.plugins.kaitai.rost import KaitaiTrigger
+
+
+class TestScansWithKaitai(ChrysalideTestCase):
+    """TestCase for ROST scan with the KaitaiStruct parsing."""
+
+    @classmethod
+    def setUpClass(cls):
+
+        super(TestScansWithKaitai, cls).setUpClass()
+
+        cls._options = ScanOptions()
+        cls._options.backend_for_data = AcismBackend
+
+
+    def testSimpleKaitaiDefinitionForScanning(self):
+        """Rely on basic Kaitai simple definition for scanning."""
+
+        definitions = '''
+meta:
+  id: basic_test
+seq:
+  - id: field0
+    type: u1
+'''
+
+        kstruct = KaitaiStruct(definitions)
+
+        trigger = KaitaiTrigger(kstruct)
+
+        root_ns = core.get_rost_root_namespace()
+
+        ns = root_ns.resolve('kaitai')
+        ns.register_item(trigger)
+
+        ns = ns.resolve('basic_test')
+        self.assertEqual(ns, trigger)
+
+        cnt = MemoryContent(b'\x01\x02\x03')
+
+        rule = '''
+rule testing {
+
+   condition:
+      kaitai.basic_test.field0 == 1
+
+}
+'''
+
+        scanner = ContentScanner(rule)
+        ctx = scanner.analyze(self._options, cnt)
+
+        self.assertIsNotNone(ctx)
+
+        self.assertFalse(ctx.has_match_for_rule('no_such_rule'))
+
+        self.assertTrue(ctx.has_match_for_rule('testing'))
+
+
+        definitions = '''
+meta:
+  id: other_basic_test
+seq:
+  - id: field0
+    type: u1
+  - id: field1
+    type: u1
+'''
+
+        kstruct = KaitaiStruct(definitions)
+
+        trigger = KaitaiTrigger(kstruct)
+
+        root_ns = core.get_rost_root_namespace()
+
+        ns = root_ns.resolve('kaitai')
+        ns.register_item(trigger)
+
+        ns = ns.resolve('other_basic_test')
+        self.assertEqual(ns, trigger)
+
+        cnt = MemoryContent(b'\x01\x02\x03')
+
+        rule = '''
+rule testing {
+
+   condition:
+      kaitai.other_basic_test.field0 == 1 and kaitai.other_basic_test.field1 == 2
+
+}
+'''
+
+        scanner = ContentScanner(rule)
+        ctx = scanner.analyze(self._options, cnt)
+
+        self.assertIsNotNone(ctx)
+
+        self.assertTrue(ctx.has_match_for_rule('testing'))
+
+
+        rule = '''
+rule testing {
+
+   condition:
+      kaitai.other_basic_test.field0 == 1 and kaitai.other_basic_testXXXX.field1 == 2
+
+}
+'''
+
+        scanner = ContentScanner(rule)
+        ctx = scanner.analyze(self._options, cnt)
+
+        self.assertIsNotNone(ctx)
+
+        self.assertFalse(ctx.has_match_for_rule('testing'))
+
+
+    def testKaitaiDefinitionWithListForScanning(self):
+        """Access list items from Kaitai definition when scanning with ROST."""
+
+        definitions = '''
+meta:
+  id: test_with_list
+seq:
+  - id: field0
+    type: u1
+    repeat: eos
+'''
+
+        kstruct = KaitaiStruct(definitions)
+
+        trigger = KaitaiTrigger(kstruct)
+
+        root_ns = core.get_rost_root_namespace()
+
+        ns = root_ns.resolve('kaitai')
+        ns.register_item(trigger)
+
+        ns = ns.resolve('test_with_list')
+        self.assertEqual(ns, trigger)
+
+        cnt = MemoryContent(b'\x01\x02\x03')
+
+        rule = '''
+rule testing {
+
+   condition:
+      kaitai.test_with_list.field0[0] == 1 and kaitai.test_with_list.field0[1] == 2 and kaitai.test_with_list.field0[2] == 3
+
+}
+'''
+
+        scanner = ContentScanner(rule)
+        ctx = scanner.analyze(self._options, cnt)
+
+        self.assertIsNotNone(ctx)
+
+        self.assertTrue(ctx.has_match_for_rule('testing'))