CI: Unit tests && fix bugs.

Author: JohnRichard4096

.github/ISSUE_TEMPLATE/bug.yml

@@ -27,7 +27,7 @@ body:
     id: AmritaSense-version
     attributes:
       label: AmritaSense Version
-      description: Check with `pip show amrita_core`
+      description: Check with `pip show amrita_sense`
       placeholder: 0.1.0
     validations:
       required: true

.github/ISSUE_TEMPLATE/question.yml

@@ -27,7 +27,7 @@ body:
     id: AmritaSense-version
     attributes:
       label: AmritaSense Version
-      description: Check with `pip show amrita_core` command
+      description: Check with `pip show amrita_sense` command
       placeholder: 0.1.0
     validations:
       required: false

.github/workflows/CI.yml

@@ -47,8 +47,7 @@ jobs:
           pylance-version: latest-release
 
       - name: Run Unit Tests with JUnit XML output
-        run: uv run pytest tests/ --cov=src/amrita_core --cov-report=term-missing
-          --cov-report=xml --junitxml=test-results.xml -v
+        run: uv run pytest tests/ --cov=src/amrita_sense --cov-report=term-missing --cov-report=xml --junitxml=test-results.xml -v
 
       - name: Publish Test Report
         uses: dorny/test-reporter@v1

.gitignore

@@ -361,3 +361,6 @@ test-results.xml
 # Editor
 *.swp
 
+# Pytest
+
+test-results.xml

src/amrita_sense/types.py

@@ -167,7 +167,7 @@ def offset_far(self, offset: list[int]) -> Self:
         """
         with self._lock:
             offset = offset.copy()
-            ptr: list[int] = self.base_addr
+            ptr: list[int] = self.base_addr.copy()
             len_off: int = len(offset)
             len_ptr: int = len(ptr)
             len_diff: int = len_ptr - len_off

tests/test_alias.py

@@ -0,0 +1,58 @@
+from amrita_sense.instructions.alias import ALIAS, AliasNode
+from amrita_sense.node.wrapper import Node as NodeDecorator
+
+
+class TestAliasNode:
+    """Test cases for the AliasNode class."""
+
+    def test_alias_node_creation(self):
+        """Test creating an AliasNode with a wrapped node."""
+
+        @NodeDecorator()
+        def original_node():
+            return "original"
+
+        alias_node = AliasNode(original_node, "my_alias")
+
+        assert alias_node.node is original_node
+        assert alias_node.alias == "my_alias"
+        assert alias_node.address_able is True
+
+    def test_alias_node_execution(self):
+        """Test that AliasNode executes the wrapped node correctly."""
+
+        @NodeDecorator()
+        def original_node():
+            return "wrapped_result"
+
+        alias_node = AliasNode(original_node, "test_alias")
+        result = alias_node()
+        assert result == "wrapped_result"
+
+    def test_alias_node_with_arguments(self):
+        """Test AliasNode execution with arguments."""
+
+        @NodeDecorator()
+        def original_node(x: int, y: str) -> str:
+            return f"{x}:{y}"
+
+        alias_node = AliasNode(original_node, "arg_alias")
+        result = alias_node(42, "test")
+        assert result == "42:test"
+
+
+class TestALIAS:
+    """Test cases for the ALIAS instruction."""
+
+    def test_alias_instruction_creation(self):
+        """Test creating an ALIAS instruction."""
+
+        @NodeDecorator()
+        def target_node():
+            return "target"
+
+        alias_instruction = ALIAS(target_node, "my_alias_name")
+
+        assert isinstance(alias_instruction, AliasNode)
+        assert alias_instruction.alias == "my_alias_name"
+        assert alias_instruction.node is target_node

tests/test_core_nodes.py

@@ -0,0 +1,120 @@
+from amrita_sense.node.core import BaseNode, Node, NodeCompose, NodeComposeRendered
+from amrita_sense.node.wrapper import Node as NodeDecorator
+
+
+class TestBaseNode:
+    """Test cases for the BaseNode class."""
+
+    def test_base_node_direct_instantiation(self):
+        """Test that BaseNode can be instantiated directly with required parameters."""
+        import inspect
+
+        def dummy_func():
+            return "dummy"
+
+        frame = inspect.currentframe()
+        node = BaseNode()
+        node._init(
+            func=dummy_func,
+            tag="test_node",
+            wrap_to_async=True,
+            address_able=False,
+            frame=frame,
+        )
+
+        assert node.func == dummy_func
+        assert node.tag == "test_node"
+        assert node.wrap_to_async is True
+        assert node.address_able is False
+
+
+class TestNode:
+    """Test cases for the Node class."""
+
+    def test_node_creation_with_decorator(self):
+        """Test creating a Node using the @Node decorator."""
+
+        @NodeDecorator()
+        def simple_function():
+            return 42
+
+        assert isinstance(simple_function, Node)
+        assert simple_function() == 42
+
+    def test_node_creation_with_parameters(self):
+        """Test creating a Node with custom parameters."""
+
+        @NodeDecorator(tag="custom_tag", wrap_to_async=False, address_able=True)
+        def parameterized_function(x: int) -> int:
+            return x * 2
+
+        node = parameterized_function
+        assert node.tag == "custom_tag"
+        assert node.wrap_to_async is False
+        assert node.address_able is True
+        assert node(5) == 10
+
+    def test_node_with_arguments(self):
+        """Test Node execution with arguments."""
+
+        @NodeDecorator()
+        def function_with_args(a: int, b: str = "default") -> str:
+            return f"{a}:{b}"
+
+        result = function_with_args(42, "test")
+        assert result == "42:test"
+
+        result_default = function_with_args(42)
+        assert result_default == "42:default"
+
+
+class TestNodeCompose:
+    """Test cases for the NodeCompose class."""
+
+    def test_node_compose_creation(self):
+        """Test creating a NodeCompose with multiple nodes."""
+
+        @NodeDecorator()
+        def node1():
+            return "node1"
+
+        @NodeDecorator()
+        def node2():
+            return "node2"
+
+        compose = NodeCompose(node1, node2)
+        assert len(compose._graph) == 2
+        assert compose._graph[0] is node1
+        assert compose._graph[1] is node2
+
+    def test_node_compose_empty(self):
+        """Test creating an empty NodeCompose."""
+        compose = NodeCompose()
+        assert len(compose._graph) == 0
+
+    def test_node_compose_render(self):
+        """Test that NodeCompose can be rendered."""
+
+        @NodeDecorator()
+        def test_node():
+            return "test"
+
+        compose = NodeCompose(test_node)
+        rendered = compose.render()
+        assert isinstance(rendered, NodeComposeRendered)
+
+
+class TestNodeComposeRendered:
+    """Test cases for the NodeComposeRendered class."""
+
+    def test_node_compose_rendered_creation(self):
+        """Test creating a NodeComposeRendered instance via render()."""
+
+        @NodeDecorator()
+        def test_node():
+            return "test"
+
+        workflow = NodeCompose(test_node)
+        rendered = workflow.render()
+
+        rendered.alias2vector_map

tests/test_deps_extra.py

@@ -0,0 +1,46 @@
+import pytest
+
+from amrita_sense.runtime.deps import ADDR, FAR_OFFSET, NEAR_OFFSET, POINTER_DEPENDS
+from amrita_sense.types import PointerVector
+
+
+class _FakePointer:
+    def __init__(self, pointer, alias_map):
+        self._pointer = PointerVector(pointer)
+        self._alias_map = alias_map
+
+    def find_addr_alias(self, name):
+        return self._alias_map[name]
+
+
+def test_pointer_depends_returns_same():
+    pc = object()
+    assert POINTER_DEPENDS(pc) is pc
+
+
+def test_addr_returns_pointervector():
+    pc = _FakePointer([1, 2], {"t": [1, 2]})
+    addr = ADDR("t")(pc)
+    assert isinstance(addr, PointerVector)
+    assert addr == PointerVector([1, 2])
+
+
+def test_far_offset_computation():
+    pc = _FakePointer([3, 4], {"t": [1, 1]})
+    res = FAR_OFFSET("t")(pc)
+    assert isinstance(res, PointerVector)
+    assert res == PointerVector([2, 3])
+
+
+def test_near_offset_same_level():
+    pc = _FakePointer([1, 5], {"t": [1, 2]})
+    # When the target alias is at the same nesting level, the near offset
+    # should return the last dimension difference without raising.
+    assert NEAR_OFFSET("t")(pc) == 3
+
+
+def test_near_offset_different_level_raises():
+    pc = _FakePointer([2, 5], {"t": [1, 2, 0]})
+    # A far offset in the higher dimensions is considered invalid for NEAR_OFFSET.
+    with pytest.raises(RuntimeError):
+        NEAR_OFFSET("t")(pc)

tests/test_exceptions.py

@@ -0,0 +1,48 @@
+from amrita_sense.exceptions import (
+    BreakLoop,
+    DependsException,
+    DependsInjectFailed,
+    DependsResolveFailed,
+    InterruptNotice,
+    NullPointerException,
+)
+
+
+class TestExceptions:
+    """Test cases for AmritaSense exception hierarchy."""
+
+    def test_interrupt_notice_inheritance(self):
+        """Test that InterruptNotice inherits from BaseException."""
+        exc = InterruptNotice("test message")
+        assert isinstance(exc, BaseException)
+        assert not isinstance(exc, Exception)
+        assert str(exc) == "InterruptNotice test message"
+
+    def test_interrupt_notice_no_message(self):
+        """Test InterruptNotice with no message."""
+        exc = InterruptNotice()
+        assert str(exc) == "InterruptNotice "
+
+    def test_null_pointer_exception(self):
+        """Test NullPointerException basic functionality."""
+        exc = NullPointerException()
+        assert isinstance(exc, Exception)
+
+    def test_break_loop_exception(self):
+        """Test BreakLoop exception."""
+        exc = BreakLoop()
+        assert isinstance(exc, Exception)
+
+    def test_depends_exception_hierarchy(self):
+        """Test DependsException inheritance hierarchy."""
+        base_exc = DependsException()
+        resolve_exc = DependsResolveFailed()
+        inject_exc = DependsInjectFailed()
+
+        # All should inherit from their respective bases
+        assert isinstance(resolve_exc, DependsResolveFailed)
+        assert isinstance(inject_exc, DependsInjectFailed)
+        assert isinstance(base_exc, DependsException)
+
+        # DependsException should inherit from Exception
+        assert isinstance(base_exc, Exception)

tests/test_if_extra.py

@@ -0,0 +1,40 @@
+from amrita_sense.instructions.if_clause import IF
+from amrita_sense.instructions.workfl_ctrl import NOP
+from amrita_sense.node.wrapper import Node as NodeDecorator
+
+
+def _make_node(ret):
+    @NodeDecorator()
+    def fn():
+        return ret
+
+    return fn
+
+
+def test_if_simple_extract():
+    """Simple IF clause should render a 3-chunk plus NOP composition."""
+    cond = _make_node(True)
+    action = _make_node("ok")
+
+    if_clause = IF(cond, action)
+    extracted = if_clause.extract()
+
+    # Base IF chunk: ConditionJumpNode, condition, do, then NOP
+    assert len(extracted._graph) == 4
+    assert extracted._graph[-1] is NOP
+
+
+def test_if_with_elif_else_extract():
+    """IF with ELIF chains and ELSE should produce expanded chunks and final NOP."""
+    cond1 = _make_node(False)
+    do1 = _make_node(1)
+    cond2 = _make_node(False)
+    do2 = _make_node(2)
+    else_do = _make_node(3)
+
+    composed = IF(cond1, do1).ELIF(cond2, do2).ELSE(else_do)
+    extracted = composed.extract()
+
+    # There should be more than the base 4 elements and end with NOP
+    assert len(extracted._graph) >= 7
+    assert extracted._graph[-1] is NOP