jaclang 0.7.22__py3-none-any.whl → 0.7.25__py3-none-any.whl

jaclang/tests/fixtures/builtin_dotgen.jac

@@ -27,11 +27,11 @@ with entry{
     d3=dotgen(b[2],edge_limit=5,depth=5);l3=d3|>len; #generate dot for all connected with b[1] node
     d4=dotgen(b[1],bfs=True,edge_type= ["Edge1"],node_limit=100,edge_limit=900,depth=300);l4=d4|>len; #generate dot from nodes with depth 3 connected with b[1] node
     d5=dotgen(b[1],node_limit=10,edge_limit=90);l5:=d5|>len; #generate dot from nodes with depth 3 connected with b[1] node
-    print(d1.count('a(val')==12,d1.count('#FFFFE0')==3,'Root' in d1,d1.count('GenericEdge')==30);
-    print(d2.count('a(val')==19,d2.count('#F5E5FF')==2 ,'Edge1' not in d2,d2.count('GenericEdge')==42);
-    print(d3.count('a(val')==6,d3.count("GenericEdge")==5,d3.count('#F5E5FF')==1);
-    print(d4.count("a(val")==25,d4.count("GenericEdge")==66,d4.count('#FFF0F')==3);
-    print(d5.count("Edge1(val=6)")==2, d5.count("GenericEdge()")==24);
+    print(d1.count('a(val')==12,d1.count('#FFFFE0')==3,'Root' in d1,d1.count('label=""')==30);
+    print(d2.count('a(val')==19,d2.count('#F5E5FF')==2 ,'Edge1' not in d2,d2.count('label=""')==42);
+    print(d3.count('a(val')==6,d3.count('label=""')==5,d3.count('#F5E5FF')==1);
+    print(d4.count("a(val")==25,d4.count('label=""')==66,d4.count('#FFF0F')==3);
+    print(d5.count("Edge1(val=6)")==2, d5.count('label=""')==24);
     # print(l3<l2);
     # print(d1);
     # print(d2);
@@ -39,4 +39,4 @@ with entry{
     # print(d4);
     # print(dotgen(node=b[2],bfs=True,depth=3.96,edge_limit=12,node_limit=12.96));
 
-}
+}

jaclang/tests/fixtures/create_dynamic_architype.jac

@@ -0,0 +1,35 @@
+import:py from jaclang.runtimelib.machine { JacMachine }
+# Dynamically create a node architype
+glob source_code = """
+node dynamic_node {
+has value:int;
+can print_value with entry {
+print("Dynamic Node Value:", f'{self.value}');
+}
+}
+""";
+
+# Create a new walker architype dynamically
+glob walker_code = """
+walker dynamic_walker {
+can visit_nodes with entry {
+visit [-->](`?dynamic_node);
+}
+}
+""";
+
+with entry {
+    node_arch = JacMachine.get().create_architype_from_source(source_code);
+    walker_arch = JacMachine.get().create_architype_from_source(walker_code);
+
+    node_obj = JacMachine.get().spawn_node(
+        'dynamic_node',
+        {'value': 99},
+        node_arch.__name__
+    );
+    walker_obj = JacMachine.get().spawn_walker(
+        'dynamic_walker',
+        module_name=walker_arch.__name__
+    );
+    node_obj spawn walker_obj;
+}

jaclang/tests/fixtures/edge_node_walk.jac

@@ -37,7 +37,7 @@ edge Edge_c {
 
 with entry {
     print(root spawn creator());
-    print(root.__jac__.gen_dot());
+    print(Jac.node_dot(root));
     print([root-:Edge_a:->]);
     print([root-:Edge_c:->]);
     print([root-:Edge_a:->-:Edge_b:->]);

jaclang/tests/fixtures/edges_walk.jac

@@ -30,7 +30,7 @@ edge Edge_c{
 
 with entry{
     print(root spawn creator());
-    print(root.__jac__.gen_dot());
+    print(Jac.node_dot(root));
     print([root -:Edge_a:->]);
     print([root -:Edge_c:->]);
     print([root -:Edge_a:-> -:Edge_b:->]);

jaclang/tests/fixtures/enum_inside_archtype.jac

@@ -1,20 +1,25 @@
-obj outer{
-    has o1:int=9;
+obj outer {
+    has o1: int = 9;
 
-    obj inner{
-        has i1:int=8;
+    obj inner {
+        has i1: int = 8;
     }
-    can foo(){
+    can foo() {
         return 'foo';
     }
-    enum color{
+    enum  color {
         red,
         green,
-        blue
+        blue,
+        with entry {
+            print('Initializing role system..');
+        },
+        can foo -> str {
+            return 'Accessing privileged Data';
         }
-
+    }
 }
 
-with entry{
-    print(outer.color.green.value);
-}
+with entry {
+    print(outer.color.green.value, outer.color.foo());
+}

jaclang/tests/fixtures/expr_type.jac

@@ -0,0 +1,54 @@
+with entry {
+    a = 4;
+    b = 7;
+    c = a + b; # OpExpr.
+    d = a + b + c;
+
+    h = float(a); # CallExpr.
+
+    (1 < 2);  # ComparisonExpr.
+    ('a' + 'b').upper(); # CallExpr.
+    [1,2][0]; # IndexExpr.
+    not False; # UnaryExpr.
+    "a" if True else "b"; # ConditionalExpr.
+    [i for i in range(10)]; # ListComprehension.
+}
+
+# Remaining expressions to test:
+# AssertTypeExpr,
+# AssignmentExpr,
+# AwaitExpr,
+# BytesExpr,
+# CastExpr,
+# ComplexExpr,
+# DictionaryComprehension,
+# DictExpr,
+# EllipsisExpr,
+# EnumCallExpr,
+# Expression,
+# FloatExpr,
+# GeneratorExpr,
+# IntExpr,
+# LambdaExpr,
+# ListExpr,
+# MemberExpr,
+# NamedTupleExpr,
+# NameExpr,
+# NewTypeExpr,
+# ParamSpecExpr,
+# PromoteExpr,
+# RefExpr,
+# RevealExpr,
+# SetComprehension,
+# SetExpr,
+# SliceExpr,
+# StarExpr,
+# StrExpr,
+# SuperExpr,
+# TupleExpr,
+# TypeAliasExpr,
+# TypedDictExpr,
+# TypeVarExpr,
+# TypeVarTupleExpr,
+# YieldExpr,
+# YieldFromExpr,

jaclang/tests/fixtures/gendot_bubble_sort.jac

@@ -73,5 +73,5 @@ with entry {
     root spawn walker1();
     root spawn walker2();
     root spawn walker3();
-    print(root.__jac__.gen_dot());
+    print(Jac.node_dot(root));
 }

jaclang/tests/fixtures/glob_multivar_statement.jac

@@ -0,0 +1,15 @@
+glob a: str, b: str;
+glob c: str;
+
+can do() {
+    :g: a, b, c ;
+
+    (a, b, c) = ("Welcome", "to", "Jaseci!");
+}
+
+with entry {
+    (a, b, c) = ("Hello", "World", "!");
+    print(a, b, c);
+    do();
+    print(a, b, c);
+}

jaclang/tests/fixtures/registry.jac

@@ -13,16 +13,16 @@ Person {
 
 enum 'Personality of the Person'
 Personality {
-   INTROVERT: 'Person who is shy and reticent' = 9,
-   EXTROVERT: 'Person who is outgoing and socially confident'
+    INTROVERT: 'Person who is shy and reticent' = 9,
+    EXTROVERT: 'Person who is outgoing and socially confident'
 }
 
-glob personality_examples: 'Personality Information of Famous People': dict[str, Personality|None] = {
+glob personality_examples: 'Personality Information of Famous People': dict[str, Personality | None] = {
     'Albert Einstein': Personality.INTROVERT,
     'Barack Obama': Personality.EXTROVERT
 };
 
-glob person_value : list[tuple[dict[str, Personality], int]] =(-90);
+glob person_value: list[tuple[dict[str, Personality], int]] = (-90);
 
 can 'GenAI ability'
 genai_ability(x: 'Something': str) -> 'Something Else': str by llm();
@@ -34,13 +34,25 @@ normal_ability(x: 'Something': str) -> 'Something Else': str {
 }
 
 can foo() {
-   person_value=22;
-   can bar() {
-       person_value=33;
-   }
+    person_value = 22;
+    can bar() {
+        person_value = 33;
+    }
 }
 with entry {
     einstein_age: int = 75;
     einstein_age += 1;
     einstein = Person('Albert Einstein', einstein_age);
 }
+
+import from jaclang.runtimelib.machine { JacMachine }
+
+with entry {
+    registry = JacMachine.get().jac_program.sem_ir;
+
+    print(len(registry.registry));
+    print(len(list(registry.registry.items())[0][1]));
+    print(list(registry.registry.items())[3][0].scope);
+    (_, sem_info) = registry.lookup(name="normal_ability");
+    print(len(sem_info.get_children(registry)));
+}

jaclang/tests/fixtures/visit_order.jac

@@ -0,0 +1,20 @@
+node MyNode{
+    has Name:str;
+}
+
+edge a{}
+
+edge b{}
+
+with entry{
+    Start = MyNode("Start");
+    End = MyNode("End");
+    mid = MyNode("Middle");
+    root <+:a:+ Start;
+    root +:a:+> End;
+    root +:b:+> mid;
+    root +:a:+> mid;
+
+    print([root-->]);
+
+}

jaclang/tests/main.jac

@@ -0,0 +1,2 @@
+import foo;
+

jaclang/tests/test_cli.py

@@ -1,5 +1,6 @@
 """Test Jac cli module."""
 
+import contextlib
 import inspect
 import io
 import os
@@ -55,10 +56,8 @@ class JacCliTests(TestCase):
         sys.stdout = captured_output
         sys.stderr = captured_output
 
-        try:
+        with contextlib.suppress(Exception):
             cli.run(self.fixture_abs_path("err_runtime.jac"))
-        except Exception as e:
-            print(f"Error: {e}")
 
         sys.stdout = sys.__stdout__
         sys.stderr = sys.__stderr__
@@ -71,7 +70,6 @@ class JacCliTests(TestCase):
             "  at foo() ",
             "  at <module> ",
         )
-
         logger_capture = "\n".join([rec.message for rec in self.caplog.records])
         for exp in expected_stdout_values:
             self.assertIn(exp, logger_capture)
@@ -217,6 +215,42 @@ class JacCliTests(TestCase):
             r"13\:12 \- 13\:18.*Name - append - .*SymbolPath: builtins_test.builtins.list.append",
         )
 
+    def test_expr_types(self) -> None:
+        """Testing for print AstTool."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.tool("ir", ["ast", f"{self.fixture_abs_path('expr_type.jac')}"])
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+
+        self.assertRegex(
+            stdout_value, r"4\:9 \- 4\:14.*BinaryExpr \- Type\: builtins.int"
+        )
+        self.assertRegex(
+            stdout_value, r"7\:9 \- 7\:17.*FuncCall \- Type\: builtins.float"
+        )
+        self.assertRegex(
+            stdout_value, r"9\:6 \- 9\:11.*CompareExpr \- Type\: builtins.bool"
+        )
+        self.assertRegex(
+            stdout_value, r"10\:6 - 10\:15.*BinaryExpr \- Type\: builtins.str"
+        )
+        self.assertRegex(
+            stdout_value, r"11\:5 \- 11\:13.*AtomTrailer \- Type\: builtins.int"
+        )
+        self.assertRegex(
+            stdout_value, r"12\:5 \- 12\:14.*UnaryExpr \- Type\: builtins.bool"
+        )
+        self.assertRegex(
+            stdout_value, r"13\:5 \- 13\:25.*IfElseExpr \- Type\: Literal\['a']\?"
+        )
+        self.assertRegex(
+            stdout_value,
+            r"14\:5 \- 14\:27.*ListCompr - \[ListCompr] \- Type\: builtins.list\[builtins.int]",
+        )
+
     def test_ast_dotgen(self) -> None:
         """Testing for print AstTool."""
         captured_output = io.StringIO()
@@ -247,6 +281,8 @@ class JacCliTests(TestCase):
         self.assertEqual(stdout_value.count("type_info.ServerWrapper"), 7)
         self.assertEqual(stdout_value.count("builtins.int"), 3)
         self.assertEqual(stdout_value.count("builtins.str"), 10)
+        self.assertIn("Literal['test_server']", stdout_value)
+        self.assertIn("Literal['1']", stdout_value)
 
     def test_build_and_run(self) -> None:
         """Testing for print AstTool."""
@@ -368,3 +404,31 @@ class JacCliTests(TestCase):
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("can my_print(x: object) -> None", stdout_value)
+
+    def test_caching_issue(self) -> None:
+        """Test for Caching Issue."""
+        test_file = self.fixture_abs_path("test_caching_issue.jac")
+        test_cases = [(10, True), (11, False)]
+        for x, is_passed in test_cases:
+            with open(test_file, "w") as f:
+                f.write(
+                    f"""
+                test mytest{{
+                    check 10 == {x};
+                }}
+                """
+                )
+            process = subprocess.Popen(
+                ["jac", "test", test_file],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            stdout, stderr = process.communicate()
+            if is_passed:
+                self.assertIn("Passed successfully.", stdout)
+                self.assertIn(".", stderr)
+            else:
+                self.assertNotIn("Passed successfully.", stdout)
+                self.assertIn("F", stderr)
+        os.remove(test_file)

jaclang/tests/test_language.py

@@ -2,7 +2,6 @@
 
 import io
 import os
-import pickle
 import sys
 import sysconfig
 
@@ -24,7 +23,7 @@ class JacLanguageTests(TestCase):
         """Set up test."""
         SUPER_ROOT_ANCHOR.edges.clear()
         JacMachine(self.fixture_abs_path("./")).attach_program(
-            JacProgram(mod_bundle=None, bytecode=None)
+            JacProgram(mod_bundle=None, bytecode=None, sem_ir=None)
         )
         return super().setUp()
 
@@ -80,6 +79,18 @@ class JacLanguageTests(TestCase):
             "\nValue: 5\nValue: 6\nValue: 7\nFinal Value: 8\nDone walking.\n",
         )
 
+    def test_simple_walk_by_edge(self) -> None:
+        """Parse micro jac file."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("micro.simple_walk_by_edge", base_path=self.examples_abs_path(""))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertEqual(
+            stdout_value,
+            "Visited 1\nVisited 2\n",
+        )
+
     def test_guess_game(self) -> None:
         """Parse micro jac file."""
         captured_output = io.StringIO()
@@ -197,8 +208,10 @@ class JacLanguageTests(TestCase):
         """Test semstring."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
+        sys.stderr = captured_output
         jac_import("semstr", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
         stdout_value = captured_output.getvalue()
         self.assertNotIn("Error", stdout_value)
 
@@ -225,6 +238,7 @@ class JacLanguageTests(TestCase):
         self.assertEqual(stdout_value.split("\n")[0], "11 13 12 12 11 12 12")
         self.assertEqual(stdout_value.split("\n")[1], '12 12 """hello"""  18 18')
         self.assertEqual(stdout_value.split("\n")[2], "11 12 11 12 11 18 23")
+        self.assertEqual(stdout_value.split("\n")[3], 'hello klkl"""')
 
     def test_deep_imports(self) -> None:
         """Parse micro jac file."""
@@ -453,24 +467,22 @@ class JacLanguageTests(TestCase):
         """Test Jac registry feature."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
+        sys.stderr = captured_output
         jac_import("registry", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
         stdout_value = captured_output.getvalue()
         self.assertNotIn("Error", stdout_value)
 
-        with open(
-            os.path.join(
-                self.fixture_abs_path("./"), "__jac_gen__", "registry.registry.pkl"
-            ),
-            "rb",
-        ) as f:
-            registry = pickle.load(f)
+        output_lines = stdout_value.strip().split("\n")
+        outputs = [
+            int(output_lines[i]) if i != 2 else output_lines[i] for i in range(4)
+        ]
 
-        self.assertEqual(len(registry.registry), 9)
-        self.assertEqual(len(list(registry.registry.items())[0][1]), 2)
-        self.assertEqual(list(registry.registry.items())[3][0].scope, "Person")
-        _, sem_info = registry.lookup(name="normal_ability")
-        self.assertEqual(len(sem_info.get_children(registry)), 2)
+        self.assertEqual(outputs[0], 9)
+        self.assertEqual(outputs[1], 2)
+        self.assertEqual(outputs[2], "Person")
+        self.assertEqual(outputs[3], 2)
 
     def test_enum_inside_arch(self) -> None:
         """Test Enum as member stmt."""
@@ -479,7 +491,7 @@ class JacLanguageTests(TestCase):
         jac_import("enum_inside_archtype", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
-        self.assertEqual("2\n", stdout_value)
+        self.assertIn("2 Accessing privileged Data", stdout_value)
 
     def test_needs_import_1(self) -> None:
         """Test py ast to Jac ast conversion output."""
@@ -491,10 +503,13 @@ class JacLanguageTests(TestCase):
         import jaclang.compiler.absyntree as ast
 
         with open(file_name, "r") as f:
-            parsed_ast = py_ast.parse(f.read())
+            file_source = f.read()
+            parsed_ast = py_ast.parse(file_source)
             try:
                 py_ast_build_pass = PyastBuildPass(
-                    input_ir=ast.PythonModuleAst(parsed_ast, mod_path=file_name),
+                    input_ir=ast.PythonModuleAst(
+                        parsed_ast, orig_src=ast.JacSource(file_source, file_name)
+                    ),
                 )
             except Exception as e:
                 return f"Error While Jac to Py AST conversion: {e}"
@@ -516,9 +531,11 @@ class JacLanguageTests(TestCase):
 
         py_out_path = os.path.join(self.fixture_abs_path("./"), "pyfunc_1.py")
         with open(py_out_path) as f:
+            file_source = f.read()
             output = PyastBuildPass(
                 input_ir=ast.PythonModuleAst(
-                    py_ast.parse(f.read()), mod_path=py_out_path
+                    py_ast.parse(file_source),
+                    orig_src=ast.JacSource(file_source, py_out_path),
                 ),
             ).ir.unparse()
         # print(output)
@@ -547,10 +564,14 @@ class JacLanguageTests(TestCase):
         import jaclang.compiler.absyntree as ast
 
         with open(file_name, "r") as f:
-            parsed_ast = py_ast.parse(f.read())
+            file_source = f.read()
+            parsed_ast = py_ast.parse(file_source)
             try:
                 py_ast_build_pass = PyastBuildPass(
-                    input_ir=ast.PythonModuleAst(parsed_ast, mod_path=file_name),
+                    input_ir=ast.PythonModuleAst(
+                        parsed_ast,
+                        orig_src=ast.JacSource(file_source, file_name),
+                    ),
                 )
             except Exception as e:
                 return f"Error While Jac to Py AST conversion: {e}"
@@ -575,9 +596,11 @@ class JacLanguageTests(TestCase):
 
         py_out_path = os.path.join(self.fixture_abs_path("./"), "pyfunc_2.py")
         with open(py_out_path) as f:
+            file_source = f.read()
             output = PyastBuildPass(
                 input_ir=ast.PythonModuleAst(
-                    py_ast.parse(f.read()), mod_path=py_out_path
+                    py_ast.parse(file_source),
+                    orig_src=ast.JacSource(file_source, py_out_path),
                 ),
             ).ir.unparse()
         self.assertIn("class X {\n    with entry {\n\n        a_b = 67;", output)
@@ -595,10 +618,14 @@ class JacLanguageTests(TestCase):
         import jaclang.compiler.absyntree as ast
 
         with open(file_name, "r") as f:
-            parsed_ast = py_ast.parse(f.read())
+            file_source = f.read()
+            parsed_ast = py_ast.parse(file_source)
             try:
                 py_ast_build_pass = PyastBuildPass(
-                    input_ir=ast.PythonModuleAst(parsed_ast, mod_path=file_name),
+                    input_ir=ast.PythonModuleAst(
+                        parsed_ast,
+                        orig_src=ast.JacSource(file_source, file_name),
+                    ),
                 )
             except Exception as e:
                 return f"Error While Jac to Py AST conversion: {e}"
@@ -622,9 +649,11 @@ class JacLanguageTests(TestCase):
 
         py_out_path = os.path.join(self.fixture_abs_path("./"), "pyfunc_3.py")
         with open(py_out_path) as f:
+            file_source = f.read()
             output = PyastBuildPass(
                 input_ir=ast.PythonModuleAst(
-                    py_ast.parse(f.read()), mod_path=py_out_path
+                    py_ast.parse(file_source),
+                    orig_src=ast.JacSource(file_source, py_out_path),
                 ),
             ).ir.unparse()
         self.assertIn("if 0 <= x<= 5 {", output)
@@ -749,9 +778,11 @@ class JacLanguageTests(TestCase):
                 module_path + ".py",
             )
             with open(file_path) as f:
+                file_source = f.read()
                 jac_ast = PyastBuildPass(
                     input_ir=ast.PythonModuleAst(
-                        py_ast.parse(f.read()), mod_path=file_path
+                        py_ast.parse(file_source),
+                        orig_src=ast.JacSource(file_source, file_path),
                     )
                 )
             settings.print_py_raised_ast = True
@@ -774,11 +805,13 @@ class JacLanguageTests(TestCase):
         """Test for access tags working."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
+        sys.stderr = captured_output
         cli.check(
             self.fixture_abs_path("../../tests/fixtures/access_modifier.jac"),
             print_errs=True,
         )
         sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count("Invalid access"), 18)
 
@@ -796,10 +829,12 @@ class JacLanguageTests(TestCase):
             parsed_ast = py_ast.parse(f.read())
             try:
                 py_ast_build_pass = PyastBuildPass(
-                    input_ir=ast.PythonModuleAst(parsed_ast, mod_path=file_name),
+                    input_ir=ast.PythonModuleAst(
+                        parsed_ast, orig_src=ast.JacSource(f.read(), file_name)
+                    )
                 )
             except Exception as e:
-                return f"Error While Jac to Py AST conversion: {e}"
+                raise Exception(f"Error While Jac to Py AST conversion: {e}")
 
         settings.print_py_raised_ast = True
         ir = jac_pass_to_pass(py_ast_build_pass, schedule=py_code_gen_typed).ir
@@ -1070,6 +1105,38 @@ class JacLanguageTests(TestCase):
                 f"Expected '{val}' to appear 2 times, but found {len(occurrences)}.",
             )
 
+    def test_dynamic_architype_creation(self) -> None:
+        """Test that the walker and node can be created dynamically."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("create_dynamic_architype.jac"))
+
+        output = captured_output.getvalue().strip()
+        # Expected outputs for spawned entities
+        expected_spawned_walker = "Dynamic Node Value: 99"
+
+        # Check for the spawned messages
+        self.assertTrue(
+            expected_spawned_walker in output,
+            f"Expected '{expected_spawned_walker}' in output.",
+        )
+
+    def test_dynamic_architype_creation_rel_import(self) -> None:
+        """Test that the walker and node can be created dynamically, with relative import."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("arch_rel_import_creation.jac"))
+
+        output = captured_output.getvalue().strip().splitlines()
+        # Expected outputs for spawned entities
+        expected_values = ["DynamicWalker Started", "UtilityNode Data: 42"]
+        for val in expected_values:
+            # Check for the spawned messages
+            self.assertTrue(
+                val in output,
+                f"Expected '{val}' in output.",
+            )
+
     def test_object_ref_interface(self) -> None:
         """Test class method output."""
         captured_output = io.StringIO()
@@ -1103,3 +1170,22 @@ class JacLanguageTests(TestCase):
         self.assertIn(
             "Exiting at the end of walker:  test_node(value=", stdout_value[11]
         )
+
+    def test_visit_order(self) -> None:
+        """Test entry and exit behavior of walker."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("visit_order", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertEqual("[MyNode(Name='End'), MyNode(Name='Middle')]\n", stdout_value)
+
+    def test_global_multivar(self) -> None:
+        """Test supporting multiple global variable in a statement."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("glob_multivar_statement", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertIn("Hello World !", stdout_value[0])
+        self.assertIn("Welcome to Jaseci!", stdout_value[1])