Init Commit: Moved bproto to seperate repo

test/compiler/backend/test_comiler_c.py

@@ -0,0 +1,26 @@
+import sys
+from compiler import BprotoCompiler
+sys.path.append('src/')
+
+from errors import BprotoCompilerError
+from backend.rendering.cBackend import CBackendRenderer
+from backend.fsOutput import BackendFileSystemOutput
+
+
+def test_compiler_c_smoke_test():
+    # Load Refernces
+    with open("test/test_protocol.bproto") as f:
+        source_text = f.read()
+
+    # Comile Stuff
+    compiler = BprotoCompiler([
+        CBackendRenderer(".")
+    ], "template")
+
+    try:
+        output: BackendFileSystemOutput = compiler.compile(source_text, ".")
+    except BprotoCompilerError:
+        assert False, "This should run througth"
+
+    output.saveToDisk("test/backend_output/c")
+    output.toString()

test/compiler/backend/test_compiler_python.py

@@ -0,0 +1,59 @@
+import sys
+import pytest
+from compiler import BprotoCompiler
+sys.path.append('src/')
+
+from errors import BprotoCompilerError
+from backend.rendering.pythonBackend import PythonBackendRenderer
+from backend.fsOutput import BackendFileSystemOutput
+
+
+@pytest.mark.skip()
+def test_compiler_python_against_ref():
+    # Load Refernces
+    with open("test/test_protocol.bproto") as f:
+        source_text = f.read()
+
+    # Comile Stuff
+    compiler = BprotoCompiler([
+        PythonBackendRenderer(".")
+    ], "template")
+
+    try:
+        output: BackendFileSystemOutput = compiler.compile(source_text, ".")
+    except BprotoCompilerError:
+        assert False, "This should run througth"
+
+    output.saveToDisk("test/backend_output/python")
+    string_output = output.toString()
+
+    with open("test/reference/python/HCP_protocol_enum.py") as f:
+        assert f.read() == string_output.get("HCP_protocol_enum.py")
+
+    with open("test/reference/python/HCP_protocol_bitfield.py") as f:
+        assert f.read() == string_output.get("HCP_protocol_bitfield.py")
+
+    with open("test/reference/python/HCP_protocol_message_ids.py") as f:
+        assert f.read() == string_output.get("HCP_protocol_message_ids.py")
+
+    with open("test/reference/python/HCP_protocol_packets.py") as f:
+        assert f.read() == string_output.get("HCP_protocol_packets.py")
+
+
+def test_compiler_python_smoke_test():
+    # Load Refernces
+    with open("test/test_protocol.bproto") as f:
+        source_text = f.read()
+
+    # Comile Stuff
+    compiler = BprotoCompiler([
+        PythonBackendRenderer(".")
+    ], "template")
+
+    try:
+        output: BackendFileSystemOutput = compiler.compile(source_text, ".")
+    except BprotoCompilerError:
+        assert False, "This should run througth"
+
+    output.saveToDisk("test/backend_output/python")
+    output.toString()

test/compiler/backend/test_compiler_txt.py

@@ -0,0 +1,32 @@
+import sys
+from compiler import BprotoCompiler
+sys.path.append('src/')
+
+from errors import BprotoCompilerError
+from backend.rendering.txtBackend import TxtBackendRenderer
+from backend.fsOutput import BackendFileSystemOutput
+
+
+def test_compiler_txt_against_ref():
+    with open("test/test_protocol.bproto") as f:
+        source_text = f.read()
+
+    # Comile Stuff
+    compiler = BprotoCompiler([
+        TxtBackendRenderer(".")
+    ], "template")
+
+    try:
+        output: BackendFileSystemOutput = compiler.compile(source_text, ".")
+    except BprotoCompilerError:
+        assert False, "This should run througth"
+    
+    string_output = output.toString()
+    output.saveToDisk("test/backend_output/txt")
+
+    # Load Refernces
+    with open("test/reference/txt/protocolSummary.txt") as f:
+        expected_output = f.read()
+
+    assert isinstance(string_output.get("protocolSummary.txt"), str)
+    assert string_output.get("protocolSummary.txt") == expected_output

test/compiler/backend/test_fsOutput.py

@@ -0,0 +1,168 @@
+import sys
+import os
+import pytest
+import shutil
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+sys.path.append('src/')
+
+from backend.fsOutput import BackendFSOutFile, BackendFSOutStaticConent, BackendFSOutFolder, BackendFSOutputJinjaFile
+
+TEST_FOLDER = "/tmp/protocolGenerator_test_data"
+
+
+@pytest.fixture
+def filesystem_folder():
+    yield TEST_FOLDER
+    shutil.rmtree(TEST_FOLDER)
+
+    print("Cleanup done")
+
+
+def test_fsOutput_saveToDisk(filesystem_folder: str):
+    jinja_env = Environment(
+        loader=FileSystemLoader("test/data/templates/"),
+        autoescape=select_autoescape()
+    )
+
+    # Setup
+    root_folder = BackendFSOutFolder("root", [
+        BackendFSOutFile("file1", "some content"),
+        BackendFSOutFile("file2", "some other content"),
+        BackendFSOutFolder("subfolder", [
+            BackendFSOutFile("file3", "some more content #2"),
+            BackendFSOutFile("file4", "even more content"),
+        ]),
+        BackendFSOutStaticConent("test/data/static_folder/static_content2.txt", "static_content2.txt"),
+        BackendFSOutStaticConent("test/data/static_content1.txt", "static_content1.txt"),
+        BackendFSOutputJinjaFile(jinja_env, "template.jinja2", "template.txt", {"name": "World"})
+    ])
+
+    root_folder.saveToDisk(filesystem_folder)
+
+    # Test Structure
+    assert os.path.isdir(filesystem_folder)
+    assert os.path.isfile(filesystem_folder + "/root/file1")
+    assert os.path.isfile(filesystem_folder + "/root/file2")
+    assert os.path.isdir(filesystem_folder + "/root/subfolder")
+    assert os.path.isfile(filesystem_folder + "/root/subfolder/file3")
+    assert os.path.isfile(filesystem_folder + "/root/subfolder/file4")
+    assert os.path.isfile(filesystem_folder + "/root/static_content1.txt")
+    assert os.path.isfile(filesystem_folder + "/root/static_content2.txt")
+
+    assert os.path.isfile(filesystem_folder + "/root/template.txt")
+
+    # Test Content
+
+    with open(filesystem_folder + "/root/file1", "r") as f:
+        assert f.read() == "some content"
+
+    with open(filesystem_folder + "/root/file2", "r") as f:
+        assert f.read() == "some other content"
+
+    with open(filesystem_folder + "/root/subfolder/file3", "r") as f:
+        assert f.read() == "some more content #2"
+    
+    with open(filesystem_folder + "/root/subfolder/file4", "r") as f:
+        assert f.read() == "even more content"
+
+    with open(filesystem_folder + "/root/static_content1.txt", "r") as f:
+        assert f.read() == "test1"
+
+    with open(filesystem_folder + "/root/static_content2.txt", "r") as f:
+        assert f.read() == "test2"
+
+    with open(filesystem_folder + "/root/template.txt", "r") as f:
+        assert f.read() == "Hello World!"
+
+
+def test_fsOutput_treeString():
+    jinja_env = Environment(
+        loader=FileSystemLoader("test/data/templates/"),
+        autoescape=select_autoescape()
+    )
+
+    root_folder = BackendFSOutFolder("root", [
+        BackendFSOutFile("file1", "some content"),
+        BackendFSOutFile("file2", "some other content"),
+        BackendFSOutFolder("subfolder", [
+            BackendFSOutFile("file3", "some more content #2"),
+            BackendFSOutFile("file4", "even more content"),
+            BackendFSOutputJinjaFile(jinja_env, "template.jinja", "generate", {"name": "Jinja2"})
+        ]),
+        BackendFSOutStaticConent("test/data/static_folder", "data"),
+        BackendFSOutputJinjaFile(jinja_env, "template.jinja", None, {"name": "World"})
+    ])
+
+    string = root_folder.assemble_file_tree_string()
+    assert string == """└── root
+    ├── [file1]
+    ├── [file2]
+    ├── subfolder
+    │   ├── [file3]
+    │   ├── [file4]
+    │   └── Template [generate]
+    ├── Static [data]
+    └── Template [template]
+"""
+
+
+def test_fsOutput_toString():
+    jinja_env = Environment(
+        loader=FileSystemLoader("test/data/templates/"),
+        autoescape=select_autoescape()
+    )
+
+    root_folder = BackendFSOutFolder("root", [
+        BackendFSOutFile("file1", "some content"),
+        BackendFSOutFile("file2", "some other content"),
+        BackendFSOutFolder("subfolder", [
+            BackendFSOutFile("file3", "some more content #2"),
+            BackendFSOutFile("file4", "even more content"),
+            BackendFSOutputJinjaFile(jinja_env, "template.jinja2", "generate", {"name": "Jinja2"})
+        ]),
+        BackendFSOutStaticConent("test/data/static_folder", "data/static_folder"),
+        BackendFSOutStaticConent("test/data/static_content1.txt", "data"),
+        BackendFSOutputJinjaFile(jinja_env, "template.jinja2", None, {"name": "World"})
+    ])
+
+    res = root_folder.toString()
+
+    assert res == {
+        "root/file1": "some content",
+        "root/file2": "some other content",
+        "root/subfolder/file3": "some more content #2",
+        "root/subfolder/file4": "even more content",
+        "root/subfolder/generate": "Hello Jinja2!",
+        "root/data/static_content1.txt": "test1",
+        "root/data/static_folder/static_content2.txt": "test2",
+        "root/template": "Hello World!"
+    }
+
+
+def test_fsOutput_pathnormalization(filesystem_folder: str):
+    
+    root_folder = BackendFSOutFolder(".", [
+        BackendFSOutFolder(".", [
+            BackendFSOutFile("file2", "some other content"),
+        ]),
+        BackendFSOutFile("file1", "some content"),
+    ])
+
+    # Check if this works for toString
+    res = root_folder.toString()
+    assert res == {
+        "file2": "some other content",
+        "file1": "some content"
+    }
+
+    # Check if this works for saveToDisk
+    root_folder.saveToDisk(filesystem_folder)
+
+    assert os.path.isfile(filesystem_folder + "/file1")
+    assert os.path.isfile(filesystem_folder + "/file2")
+
+    with open(filesystem_folder + "/file1", "r") as f:
+        assert f.read() == "some content"
+
+    with open(filesystem_folder + "/file2", "r") as f:
+        assert f.read() == "some other content"