jaclang 0.8.7__py3-none-any.whl → 0.8.9__py3-none-any.whl

jaclang/tests/test_cli.py

@@ -7,6 +7,7 @@ import os
 import re
 import subprocess
 import sys
+import tempfile
 import traceback
 import unittest
 from jaclang.cli import cli
@@ -127,12 +128,15 @@ class JacCliTests(TestCase):
         sys.stdout = captured_output
         sys.stderr = captured_output
 
-        with contextlib.suppress(Exception):
+        with self.assertRaises(SystemExit) as cm:
             cli.run(self.fixture_abs_path("err_runtime.jac"))
 
         sys.stdout = sys.__stdout__
         sys.stderr = sys.__stderr__
 
+        # Verify exit code is 1
+        self.assertEqual(cm.exception.code, 1)
+
         expected_stdout_values = (
             "Error: list index out of range",
             "    print(some_list[invalid_index]);",
@@ -385,13 +389,13 @@ class JacCliTests(TestCase):
         """Test for graph CLI cmd."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        cli.dot(f"{self.examples_abs_path('reference/connect_expressions.jac')}")
+        cli.dot(f"{self.examples_abs_path('reference/connect_expressions_(osp).jac')}")
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
-        if os.path.exists("connect_expressions.dot"):
-            os.remove("connect_expressions.dot")
-        self.assertIn("11\n13\n15\n>>> Graph content saved to", stdout_value)
-        self.assertIn("connect_expressions.dot\n", stdout_value)
+        if os.path.exists("connect_expressions_(osp).dot"):
+            os.remove("connect_expressions_(osp).dot")
+        self.assertIn(">>> Graph content saved to", stdout_value)
+        self.assertIn("connect_expressions_(osp).dot\n", stdout_value)
 
     def test_py_to_jac(self) -> None:
         """Test for graph CLI cmd."""
@@ -432,6 +436,53 @@ class JacCliTests(TestCase):
             "sorted(users, key=lambda x: x['email'], reverse=True)", stdout_value
         )
 
+    def test_param_arg(self) -> None:
+        """Test for lambda argument annotation."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        from jaclang.compiler.program import JacProgram
+
+        filename = self.fixture_abs_path(
+            "../../tests/fixtures/params/test_complex_params.jac"
+        )
+        cli.jac2py(
+            f"{self.fixture_abs_path('../../tests/fixtures/params/test_complex_params.jac')}"
+        )
+        py_code = JacProgram().compile(file_path=filename).gen.py
+
+        # Create temporary Python file
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".py", delete=False
+        ) as temp_file:
+            temp_file.write(py_code)
+            py_file_path = temp_file.name
+
+        try:
+            jac_code = (
+                JacProgram().compile(use_str=py_code, file_path=py_file_path).unparse()
+            )
+            # Create temporary Jac file
+            with tempfile.NamedTemporaryFile(
+                mode="w", suffix=".jac", delete=False
+            ) as temp_file:
+                temp_file.write(jac_code)
+                jac_file_path = temp_file.name
+            cli.run(jac_file_path)
+        finally:
+            os.remove(py_file_path)
+            os.remove(jac_file_path)
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertEqual("ULTIMATE_MIN: 1|def|2.5|0|test|100|0", stdout_value[-7])
+        self.assertEqual("ULTIMATE_FULL: 1|custom|3.14|3|req|200|1", stdout_value[-6])
+        self.assertEqual("SEPARATORS: 42", stdout_value[-5])
+        self.assertEqual("EDGE_MIX: 1-test-2-True-1", stdout_value[-4])
+        self.assertEqual("RECURSIVE: 7 11", stdout_value[-3])
+        self.assertEqual(
+            "VALIDATION: x:1,y:2.5,z:10,args:1,w:True,kwargs:1", stdout_value[-2]
+        )
+
     def test_caching_issue(self) -> None:
         """Test for Caching Issue."""
         test_file = self.fixture_abs_path("test_caching_issue.jac")
@@ -441,7 +492,7 @@ class JacCliTests(TestCase):
                 f.write(
                     f"""
                 test mytest{{
-                    check 10 == {x};
+                    assert 10 == {x};
                 }}
                 """
                 )
@@ -609,3 +660,104 @@ class JacCliTests(TestCase):
         )
         stdout, stderr = process.communicate()
         self.assertIn("Hello World!", stdout)
+
+    def test_cli_error_exit_codes(self) -> None:
+        """Test that CLI commands return non-zero exit codes on errors."""
+        # Test run command with syntax error
+        process = subprocess.Popen(
+            ["jac", "run", self.fixture_abs_path("err2.jac")],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertEqual(
+            process.returncode, 1, "run command should exit with code 1 on syntax error"
+        )
+        self.assertIn("Error running", stderr)
+
+        # Test build command with syntax error
+        process = subprocess.Popen(
+            ["jac", "build", self.fixture_abs_path("err2.jac")],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertEqual(
+            process.returncode,
+            1,
+            "build command should exit with code 1 on compilation error",
+        )
+
+        # Test check command with syntax error
+        process = subprocess.Popen(
+            ["jac", "check", self.fixture_abs_path("err2.jac")],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertEqual(
+            process.returncode,
+            1,
+            "check command should exit with code 1 on type check error",
+        )
+
+        # Test format command with non-existent file
+        process = subprocess.Popen(
+            ["jac", "format", "/nonexistent.jac"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertEqual(
+            process.returncode,
+            1,
+            "format command should exit with code 1 on missing file",
+        )
+        self.assertIn("does not exist", stderr)
+
+        # Test check command with invalid file type
+        process = subprocess.Popen(
+            ["jac", "check", "/nonexistent.txt"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertEqual(
+            process.returncode,
+            1,
+            "check command should exit with code 1 on invalid file type",
+        )
+        self.assertIn("Not a .jac file", stderr)
+
+        # Test tool command with non-existent tool
+        process = subprocess.Popen(
+            ["jac", "tool", "nonexistent_tool"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertEqual(
+            process.returncode,
+            1,
+            "tool command should exit with code 1 on non-existent tool",
+        )
+        self.assertIn("not found", stderr)
+
+        # Test successful run returns exit code 0
+        process = subprocess.Popen(
+            ["jac", "run", self.fixture_abs_path("hello.jac")],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = process.communicate()
+        self.assertEqual(
+            process.returncode, 0, "run command should exit with code 0 on success"
+        )
+        self.assertIn("Hello World!", stdout)

jaclang/tests/test_language.py

@@ -3,7 +3,7 @@
 import io
 import os
 import sys
-import sysconfig
+import pytest
 import tempfile
 import subprocess
 from pathlib import Path
@@ -133,8 +133,17 @@ class JacLanguageTests(TestCase):
 
         for edge in edges:
             label = edge["label"]
-            self.assertIn(label, ["E(val=1)", "E(val=1)", "E(val=1)", "E(val=0)", "E(val=0)", "E(val=0)"])
-
+            self.assertIn(
+                label,
+                [
+                    "E(val=1)",
+                    "E(val=1)",
+                    "E(val=1)",
+                    "E(val=0)",
+                    "E(val=0)",
+                    "E(val=0)",
+                ],
+            )
 
     def test_printgraph_mermaid(self) -> None:
         """Test the mermaid gen of builtin function."""
@@ -201,11 +210,26 @@ class JacLanguageTests(TestCase):
         )
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        exec(compile(prog.gen.py_ast[0], "test.py", "exec"))
+        exec(compile(prog.gen.py_ast[0], "test.jac", "exec"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value, "-5\n")
 
+    def test_assignment_list_no_infinite_loop(self) -> None:
+        """Test that assignment list parsing doesn't cause infinite loop."""
+        # This syntax previously caused an infinite loop in two places:
+        # 1. Grammar: assignment_list: (assignment_list COMMA)? (assignment | named_ref)
+        #    Fixed by: assignment_list: (assignment | named_ref) (COMMA (assignment | named_ref))* COMMA?
+        # 2. Error recovery: feed_current_token() had unbounded while loop
+        #    Fixed by: adding max_attempts limit in parser.py
+        code = "with entry { p1, p2 = (10, 20); }"
+        # Compilation should complete quickly (even though syntax is invalid)
+        jac_prog = JacProgram()
+        result = jac_prog.compile(use_str=code, file_path="test.jac")
+        # Should have errors (invalid syntax) but not hang
+        self.assertIsNotNone(result)  # Returns a Module object
+        self.assertGreater(len(jac_prog.errors_had), 0)  # Check errors on program
+
     def test_need_import(self) -> None:
         """Test importing python."""
         captured_output = io.StringIO()
@@ -215,18 +239,6 @@ class JacLanguageTests(TestCase):
         stdout_value = captured_output.getvalue()
         self.assertIn("<module 'pyfunc' from", stdout_value)
 
-    def test_filter_compr(self) -> None:
-        """Testing filter comprehension."""
-        captured_output = io.StringIO()
-        sys.stdout = captured_output
-        Jac.jac_import(
-            "reference.special_comprehensions",
-            base_path=self.examples_abs_path(""),
-        )
-        sys.stdout = sys.__stdout__
-        stdout_value = captured_output.getvalue()
-        self.assertIn("True", stdout_value)
-
     def test_gen_dot_bubble(self) -> None:
         """Test the dot gen of nodes and edges of bubblesort."""
         captured_output = io.StringIO()
@@ -514,14 +526,13 @@ class JacLanguageTests(TestCase):
                 ),
                 prog=JacProgram(),
             ).ir_out.unparse()
-        self.assertIn("def greet2(**kwargs: Any)", output)
+        self.assertIn("def greet2( **kwargs: Any) {", output)
         self.assertEqual(output.count("with entry {"), 14)
-        self.assertIn("assert (x == 5) , 'x should be equal to 5' ;", output)
+        self.assertIn("assert (x == 5) , 'x should be equal to 5';", output)
         self.assertIn("if not (x == y) {", output)
-        self.assertIn("def greet2(**kwargs: Any) {", output)
-        self.assertIn("squares_dict = { x : (x ** 2) for x in numbers };", output)
+        self.assertIn("squares_dict = {x : (x ** 2) for x in numbers};", output)
         self.assertIn(
-            '\n\n"""Say hello"""\n@ my_decorator\n\n def say_hello() {', output
+            '\n\n"""Say hello"""\n@my_decorator\n\n def say_hello() {', output
         )
 
     def test_pyfunc_2(self) -> None:
@@ -589,6 +600,52 @@ class JacLanguageTests(TestCase):
         self.assertIn("case Container(inner = Inner(x = a, y = b)):\n", output)
         self.assertIn("case _:\n", output)
 
+    def test_py2jac_params(self) -> None:
+        """Test py ast to Jac ast conversion."""
+        from jaclang.compiler.passes.main import PyastBuildPass
+        import jaclang.compiler.unitree as ast
+        import ast as py_ast
+
+        py_out_path = os.path.join(self.fixture_abs_path("./"), "py2jac_params.py")
+        with open(py_out_path) as f:
+            file_source = f.read()
+            output = PyastBuildPass(
+                ir_in=ast.PythonModuleAst(
+                    py_ast.parse(file_source),
+                    orig_src=ast.Source(file_source, py_out_path),
+                ),
+                prog=None,
+            ).ir_out.unparse()
+        self.assertIn(
+            "def isinstance( <>obj: object , class_or_tuple: _ClassInfo , /)  -> bool {",
+            output,
+        )
+        self.assertIn(
+            "def len(<>obj: Sized, astt: Any, /, z: int, j: str, a: Any = 90) -> int {",
+            output,
+        )
+
+    def test_py2jac_empty_file(self) -> None:
+        """Test py ast to Jac ast conversion."""
+        from jaclang.compiler.passes.main import PyastBuildPass
+        import jaclang.compiler.unitree as ast
+        import ast as py_ast
+
+        py_out_path = os.path.join(self.fixture_abs_path("./"), "py2jac_empty.py")
+        with open(py_out_path) as f:
+            file_source = f.read()
+            converted_ast = PyastBuildPass(
+                ir_in=ast.PythonModuleAst(
+                    py_ast.parse(file_source),
+                    orig_src=ast.Source(file_source, py_out_path),
+                ),
+                prog=None,
+            ).ir_out
+        self.assertIsInstance(
+            converted_ast,
+            ast.Module
+        )
+
     def test_refs_target(self) -> None:
         """Test py ast to Jac ast conversion output."""
         captured_output = io.StringIO()
@@ -712,6 +769,7 @@ class JacLanguageTests(TestCase):
         mypass = JacProgram().compile(self.fixture_abs_path("byllmissue.jac"))
         self.assertIn("2:5 - 4:8", mypass.pp())
 
+    @pytest.mark.xfail(reason="TODO: Support symtable for inheritance")
     def test_inherit_baseclass_sym(self) -> None:
         """Basic test for symtable support for inheritance."""
         mypass = JacProgram().compile(
@@ -746,6 +804,53 @@ class JacLanguageTests(TestCase):
         stdout_value = captured_output.getvalue()
         self.assertIn("i work", stdout_value)
 
+    def test_kwonly_params(self) -> None:
+        """Test importing python."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import(
+            "test_kwonly_params", base_path=self.fixture_abs_path("./params")
+        )
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertEqual("KW_SIMPLE: 42", stdout_value[0])
+        self.assertEqual("KW_DEF: 10-def 20-def", stdout_value[1])
+        self.assertEqual("REG_KW: 10|test", stdout_value[2])
+        self.assertEqual("MIXED_KW: 1-def-2.5-True 2-custom-3.5-False", stdout_value[3])
+        self.assertEqual("ALL_KW: 100:test:1.0 200:hi:9.9", stdout_value[4])
+
+    def test_complex_params(self) -> None:
+        """Test importing python."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import(
+            "test_complex_params", base_path=self.fixture_abs_path("./params")
+        )
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertEqual("ULTIMATE_MIN: 1|def|2.5|0|test|100|0", stdout_value[0])
+        self.assertEqual("ULTIMATE_FULL: 1|custom|3.14|3|req|200|1", stdout_value[1])
+        self.assertEqual("SEPARATORS: 42", stdout_value[2])
+        self.assertEqual("EDGE_MIX: 1-test-2-True-1", stdout_value[3])
+        self.assertEqual("RECURSIVE: 7 11", stdout_value[4])
+        self.assertEqual(
+            "VALIDATION: x:1,y:2.5,z:10,args:1,w:True,kwargs:1", stdout_value[5]
+        )
+
+    def test_param_failing(self) -> None:
+        """Test importing python."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        for i in [
+            "test_failing_posonly",
+            "test_failing_kwonly",
+            "test_failing_varargs",
+        ]:
+            Jac.jac_import(i, base_path=self.fixture_abs_path("./params"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertNotIn("FAILED", stdout_value)
+
     def test_double_import_exec(self) -> None:
         """Test importing python."""
         captured_output = io.StringIO()
@@ -1238,9 +1343,9 @@ class JacLanguageTests(TestCase):
             ).ir_out.unparse()
         self.assertIn("(prev_token_index is None)", output)
         self.assertIn("(next_token_index is None)", output)
-        self.assertIn("(tok[ 0 ] > change_end_line)", output)
-        self.assertIn("(tok[ 0 ] == change_end_line)", output)
-        self.assertIn("(tok[ 1 ] > change_end_char)", output)
+        self.assertIn("(tok[0] > change_end_line)", output)
+        self.assertIn("(tok[0] == change_end_line)", output)
+        self.assertIn("(tok[1] > change_end_char)", output)
 
     def test_here_visitor_usage(self) -> None:
         """Test visitor, here keyword usage in jaclang."""
@@ -1257,9 +1362,11 @@ class JacLanguageTests(TestCase):
         captured_output = io.StringIO()
         sys.stdout = captured_output
         sys.stderr = captured_output
-        cli.run(self.fixture_abs_path("here_usage_error.jac"))
+        with self.assertRaises(SystemExit) as cm:
+            cli.run(self.fixture_abs_path("here_usage_error.jac"))
         sys.stdout = sys.__stdout__
         sys.stderr = sys.__stderr__
+        self.assertEqual(cm.exception.code, 1)
         stdout_value = captured_output.getvalue()
         self.assertIn("'here' is not defined", stdout_value)
 
@@ -1374,11 +1481,11 @@ class JacLanguageTests(TestCase):
 
     def test_read_file_with_encoding_utf8(self) -> None:
         """Test reading UTF-8 encoded file."""
-        with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', delete=False) as f:
+        with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", delete=False) as f:
             test_content = "Hello, 世界! 🌍 Testing UTF-8 encoding."
             f.write(test_content)
             temp_path = f.name
-        
+
         try:
             result = read_file_with_encoding(temp_path)
             self.assertEqual(result, test_content)
@@ -1387,11 +1494,13 @@ class JacLanguageTests(TestCase):
 
     def test_read_file_with_encoding_utf16(self) -> None:
         """Test reading UTF-16 encoded file when UTF-8 fails."""
-        with tempfile.NamedTemporaryFile(delete=False, mode="w", encoding="utf-16") as f:
+        with tempfile.NamedTemporaryFile(
+            delete=False, mode="w", encoding="utf-16"
+        ) as f:
             test_content = "Hello, 世界! UTF-16 encoding test."
             f.write(test_content)
             temp_path = f.name
-        
+
         try:
             result = read_file_with_encoding(temp_path)
             self.assertEqual(result, test_content)
@@ -1400,11 +1509,13 @@ class JacLanguageTests(TestCase):
 
     def test_read_file_with_encoding_utf8_bom(self) -> None:
         """Test reading UTF-8 with BOM encoded file."""
-        with tempfile.NamedTemporaryFile(delete=False, mode='w', encoding='utf-8-sig') as f:
+        with tempfile.NamedTemporaryFile(
+            delete=False, mode="w", encoding="utf-8-sig"
+        ) as f:
             test_content = "Hello, UTF-8 BOM test! 🚀"
             f.write(test_content)
             temp_path = f.name
-        
+
         try:
             result = read_file_with_encoding(temp_path)
             self.assertEqual(result, test_content)
@@ -1431,9 +1542,9 @@ class JacLanguageTests(TestCase):
         with tempfile.NamedTemporaryFile(delete=False) as f:
             binary_data = bytes([0xFF, 0xFE, 0x00, 0x48, 0x65, 0x6C, 0x6C, 0x6F])
             f.write(binary_data)
-            f.flush()  
+            f.flush()
             temp_path = f.name
-        
+
         try:
             result = read_file_with_encoding(temp_path)
             self.assertIsInstance(result, str)
@@ -1443,18 +1554,18 @@ class JacLanguageTests(TestCase):
 
     def test_read_file_with_encoding_special_characters(self) -> None:
         """Test reading file with various special characters."""
-        with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', delete=False) as f:
+        with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", delete=False) as f:
             test_content = (
                 "Special chars: åäö ñ ü ç é\n"
-                "Symbols: ©®™ §¶†‡•\n" 
+                "Symbols: ©®™ §¶†‡•\n"
                 "Math: ∑∏∫√±≤≥≠\n"
                 "Arrows: ←→↑↓↔\n"
                 "Emoji: 😀😍🎉🔥💯\n"
             )
             f.write(test_content)
-            f.flush()  
+            f.flush()
             temp_path = f.name
-        
+
         try:
             result = read_file_with_encoding(temp_path)
 
@@ -1464,4 +1575,68 @@ class JacLanguageTests(TestCase):
             self.assertIn("∑∏∫", result)
             self.assertIn("😀😍", result)
         finally:
-            os.unlink(temp_path)
+            os.unlink(temp_path)
+
+    def test_funccall_genexpr(self) -> None:
+        """Test function call with generator expression in both Jac and py2jac."""
+        # Test language support
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import("funccall_genexpr", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("Result: 30", stdout_value[0])
+        
+        # Test py2jac conversion
+        py_file_path = f"{self.fixture_abs_path('../../tests/fixtures/funccall_genexpr.py')}"
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.py2jac(py_file_path)
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("result = total((x * x) for x in range(5));", stdout_value)
+
+    def test_attr_pattern_case(self) -> None:
+        """Test attribute pattern matching."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        Jac.jac_import("attr_pattern_case", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("Matched a.b.c Hello Jaseci!", stdout_value[0])
+        
+    def test_known_builtins_matches_actual(self) -> None:
+        """Test that KNOWN_BUILTINS in PyastGenPass matches actual builtins."""
+        from jaclang.compiler.passes.main.pyast_gen_pass import PyastGenPass
+        import jaclang.runtimelib.builtin as builtin_module
+
+        # Get actual builtins from the module (excluding private members)
+        actual_builtins = {
+            name for name in builtin_module.__all__
+            if not name.startswith('_')
+        }
+
+        # Exceptions: builtins that are imported from other sources
+        # - Enum: imported via needs_enum() from standard library's enum module
+        exceptions = {'Enum'}
+        actual_builtins_to_check = actual_builtins - exceptions
+
+        # Get the KNOWN_BUILTINS set from PyastGenPass
+        known_builtins = PyastGenPass.KNOWN_BUILTINS
+
+        # Find missing and extra builtins
+        missing = actual_builtins_to_check - known_builtins
+        extra = known_builtins - actual_builtins_to_check
+
+        # Build error message
+        error_msg = []
+        if missing:
+            error_msg.append(f"Missing from KNOWN_BUILTINS: {sorted(missing)}")
+        if extra:
+            error_msg.append(f"Extra in KNOWN_BUILTINS (not in builtin module): {sorted(extra)}")
+
+        # Assert they match
+        self.assertEqual(
+            known_builtins, actual_builtins_to_check,
+            "\n".join(error_msg) if error_msg else ""
+        )

jaclang/tests/test_reference.py

@@ -50,6 +50,8 @@ class JacReferenceTests(TestCase):
 
     def micro_suite_test(self, filename: str) -> None:
         """Test file."""
+        # Reset machine at the start of each test to ensure clean state
+        Jac.reset_machine()
 
         def execute_and_capture_output(code: str | bytes, filename: str = "") -> str:
             f = io.StringIO()
@@ -83,12 +85,12 @@ class JacReferenceTests(TestCase):
             # print(f"\nPython Output:\n{output_py}")
 
             self.assertGreater(len(output_py), 0)
-            self.assertEqual(len(output_jac.split("\n")), len(output_py.split("\n")))
             # doing like below for concurrent_expressions.jac and other current tests
             for i in output_py.split("\n"):
                 self.assertIn(i, output_jac)
             for i in output_jac.split("\n"):
                 self.assertIn(i, output_py)
+            self.assertEqual(len(output_jac.split("\n")), len(output_py.split("\n")))
             # self.assertEqual(output_py, output_jac)
         except Exception as e:
             # print(f"\nJAC Output:\n{output_jac}")