jaclang 0.7.2__py3-none-any.whl → 0.7.5__py3-none-any.whl

jaclang/core/test.py

@@ -0,0 +1,90 @@
+"""Core constructs for Jac Language."""
+
+from __future__ import annotations
+
+import unittest
+from typing import Callable, Optional
+
+
+class JacTestResult(unittest.TextTestResult):
+    """Jac test result class."""
+
+    def __init__(
+        self,
+        stream,  # noqa
+        descriptions,  # noqa
+        verbosity: int,
+        max_failures: Optional[int] = None,
+    ) -> None:
+        """Initialize FailFastTestResult object."""
+        super().__init__(stream, descriptions, verbosity)  # noqa
+        self.failures_count = JacTestCheck.failcount
+        self.max_failures = max_failures
+
+    def addFailure(self, test, err) -> None:  # noqa
+        """Count failures and stop."""
+        super().addFailure(test, err)
+        self.failures_count += 1
+        if self.max_failures is not None and self.failures_count >= self.max_failures:
+            self.stop()
+
+    def stop(self) -> None:
+        """Stop the test execution."""
+        self.shouldStop = True
+
+
+class JacTextTestRunner(unittest.TextTestRunner):
+    """Jac test runner class."""
+
+    def __init__(self, max_failures: Optional[int] = None, **kwargs) -> None:  # noqa
+        """Initialize JacTextTestRunner object."""
+        self.max_failures = max_failures
+        super().__init__(**kwargs)
+
+    def _makeResult(self) -> JacTestResult:  # noqa
+        """Override the method to return an instance of JacTestResult."""
+        return JacTestResult(
+            self.stream,
+            self.descriptions,
+            self.verbosity,
+            max_failures=self.max_failures,
+        )
+
+
+class JacTestCheck:
+    """Jac Testing and Checking."""
+
+    test_case = unittest.TestCase()
+    test_suite = unittest.TestSuite()
+    breaker = False
+    failcount = 0
+
+    @staticmethod
+    def reset() -> None:
+        """Clear the test suite."""
+        JacTestCheck.test_case = unittest.TestCase()
+        JacTestCheck.test_suite = unittest.TestSuite()
+
+    @staticmethod
+    def run_test(xit: bool, maxfail: int | None, verbose: bool) -> None:
+        """Run the test suite."""
+        verb = 2 if verbose else 1
+        runner = JacTextTestRunner(max_failures=maxfail, failfast=xit, verbosity=verb)
+        result = runner.run(JacTestCheck.test_suite)
+        if result.wasSuccessful():
+            print("Passed successfully.")
+        else:
+            fails = len(result.failures)
+            JacTestCheck.failcount += fails
+            JacTestCheck.breaker = (
+                (JacTestCheck.failcount >= maxfail) if maxfail else True
+            )
+
+    @staticmethod
+    def add_test(test_fun: Callable) -> None:
+        """Create a new test."""
+        JacTestCheck.test_suite.addTest(unittest.FunctionTestCase(test_fun))
+
+    def __getattr__(self, name: str) -> object:
+        """Make convenient check.Equal(...) etc."""
+        return getattr(JacTestCheck.test_case, name)

jaclang/core/utils.py

@@ -8,10 +8,10 @@ from contextlib import contextmanager
 from typing import Callable, Iterator, TYPE_CHECKING
 
 import jaclang.compiler.absyntree as ast
-from jaclang.core.registry import SemScope
+from jaclang.compiler.semtable import SemScope
 
 if TYPE_CHECKING:
-    from jaclang.core.construct import NodeAnchor, NodeArchitype
+    from jaclang.core.constructs import NodeAnchor, NodeArchitype
 
 
 @contextmanager

jaclang/langserve/engine.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import logging
 from enum import IntEnum
 from hashlib import md5
-from typing import Optional, Sequence
+from typing import Optional
 
 
 import jaclang.compiler.absyntree as ast
@@ -40,8 +40,8 @@ class ModuleInfo:
     def __init__(
         self,
         ir: ast.Module,
-        errors: Sequence[Alert],
-        warnings: Sequence[Alert],
+        errors: list[Alert],
+        warnings: list[Alert],
         alev: ALev,
         parent: Optional[ModuleInfo] = None,
     ) -> None:
@@ -63,6 +63,14 @@ class ModuleInfo:
         """Return if there are syntax errors."""
         return len(self.errors) > 0 and self.alev == ALev.QUICK
 
+    def update_with(self, new_info: ModuleInfo) -> None:
+        """Update module info."""
+        self.ir = new_info.ir
+        self.errors += [i for i in new_info.errors if i not in self.errors]
+        self.warnings += [i for i in new_info.warnings if i not in self.warnings]
+        self.alev = new_info.alev
+        self.diagnostics = self.gen_diagnostics()
+
     def gen_diagnostics(self) -> list[lspt.Diagnostic]:
         """Return diagnostics."""
         return [
@@ -124,15 +132,14 @@ class JacLangServer(LanguageServer):
                 self.quick_check(file_path)
         return file_path
 
-    def update_modules(self, file_path: str, build: Pass, alev: ALev) -> None:
+    def update_modules(
+        self, file_path: str, build: Pass, alev: ALev, refresh: bool = False
+    ) -> None:
         """Update modules."""
         if not isinstance(build.ir, ast.Module):
             self.log_error("Error with module build.")
             return
-        save_parent = (
-            self.modules[file_path].parent if file_path in self.modules else None
-        )
-        self.modules[file_path] = ModuleInfo(
+        new_mod = ModuleInfo(
             ir=build.ir,
             errors=[
                 i
@@ -146,15 +153,22 @@ class JacLangServer(LanguageServer):
             ],
             alev=alev,
         )
-        self.modules[file_path].parent = save_parent
+        if not refresh and file_path in self.modules:
+            self.modules[file_path].update_with(new_mod)
+        else:
+            self.modules[file_path] = new_mod
         for p in build.ir.mod_deps.keys():
             uri = uris.from_fs_path(p)
-            self.modules[uri] = ModuleInfo(
+            new_mod = ModuleInfo(
                 ir=build.ir.mod_deps[p],
                 errors=[i for i in build.errors_had if i.loc.mod_path == p],
                 warnings=[i for i in build.warnings_had if i.loc.mod_path == p],
                 alev=alev,
             )
+            if not refresh and uri in self.modules:
+                self.modules[uri].update_with(new_mod)
+            else:
+                self.modules[uri] = new_mod
             self.modules[uri].parent = (
                 self.modules[file_path] if file_path != uri else None
             )
@@ -170,7 +184,7 @@ class JacLangServer(LanguageServer):
             )
         except Exception as e:
             self.log_error(f"Error during syntax check: {e}")
-        self.update_modules(file_path, build, ALev.QUICK)
+        self.update_modules(file_path, build, ALev.QUICK, refresh=True)
 
     def deep_check(self, file_path: str, force: bool = False) -> None:
         """Rebuild a file and its dependencies."""
@@ -275,21 +289,20 @@ class JacLangServer(LanguageServer):
     def get_node_info(self, node: ast.AstSymbolNode) -> Optional[str]:
         """Extract meaningful information from the AST node."""
         try:
-            if isinstance(node, ast.NameSpec):
+            if isinstance(node, ast.NameAtom):
                 node = node.name_of
-            access = node.sym_link.access.value + " " if node.sym_link else None
+            access = node.sym.access.value + " " if node.sym else None
             node_info = (
-                f"({access if access else ''}{node.sym_type.value}) {node.sym_name}"
+                f"({access if access else ''}{node.sym_category.value}) {node.sym_name}"
             )
-            if node.sym_info.clean_type:
-                node_info += f": {node.sym_info.clean_type}"
+            if node.name_spec.clean_type:
+                node_info += f": {node.name_spec.clean_type}"
             if isinstance(node, ast.AstSemStrNode) and node.semstr:
                 node_info += f"\n{node.semstr.value}"
             if isinstance(node, ast.AstDocNode) and node.doc:
                 node_info += f"\n{node.doc.value}"
             if isinstance(node, ast.Ability) and node.signature:
                 node_info += f"\n{node.signature.unparse()}"
-            self.log_py(node.pp())
             self.log_py(f"mypy_node: {node.gen.mypy_ast}")
         except AttributeError as e:
             self.log_warning(f"Attribute error when accessing node attributes: {e}")
@@ -318,8 +331,8 @@ class JacLangServer(LanguageServer):
                 and isinstance(node_selected.parent, ast.AstImplNeedingNode)
                 and isinstance(node_selected.parent.body, ast.AstImplOnlyNode)
                 else (
-                    node_selected.sym_link.decl
-                    if (node_selected.sym_link and node_selected.sym_link.decl)
+                    node_selected.sym.decl
+                    if (node_selected.sym and node_selected.sym.decl)
                     else node_selected
                 )
             )

jaclang/langserve/tests/fixtures/circle.jac

@@ -18,9 +18,9 @@ Below we have the demonstration of a class to calculate the area of a circle.
 *#
 
 """Enum for shape types"""
-enum ShapeType  {
-    CIRCLE="Circle",
-    UNKNOWN="Unknown"
+enum ShapeType {
+    CIRCLE = "Circle",
+    UNKNOWN = "Unknown"
 }
 
 """Base class for a shape."""
@@ -50,24 +50,28 @@ with entry {
 # Global also works here
 
 with entry:__main__ {
-# To run the program functionality
-print(f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}");
-print(f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}");
+    # To run the program functionality
+    print(
+        f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}"
+    );
+    print(
+        f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}"
+    );
 }
 # Unit Tests!
 
 glob expected_area = 78.53981633974483;
 
-test calc_area   {
-    check.assertAlmostEqual(calculate_area(RAD), expected_area);
+test calc_area {
+    check assertAlmostEqual(calculate_area(RAD), expected_area);
 }
 
-test circle_area   {
+test circle_area {
     c = Circle(RAD);
-    check.assertAlmostEqual(c.area(), expected_area);
+    check assertAlmostEqual(c.area(), expected_area);
 }
 
-test circle_type   {
+test circle_type {
     c = Circle(RAD);
-    check.assertEqual(c.shape_type, ShapeType.CIRCLE);
+    check assertEqual(c.shape_type, ShapeType.CIRCLE);
 }

jaclang/langserve/tests/fixtures/circle_err.jac

@@ -59,15 +59,15 @@ print(f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}
 glob expected_area = 78.53981633974483;
 
 test calc_area   {
-    check.assertAlmostEqual(calculate_area(RAD), expected_area);
+    check assertAlmostEqual(calculate_area(RAD), expected_area);
 }
 
 test circle_area   {
     c = Circle(RAD);
-    check.assertAlmostEqual(c.area(), expected_area);
+    check assertAlmostEqual(c.area(), expected_area);
 }
 
 test circle_type   {
     c = Circle(RAD);
-    check.assertEqual(c.shape_type, ShapeType.CIRCLE);
+    check assertEqual(c.shape_type, ShapeType.CIRCLE);
 }

jaclang/langserve/tests/test_server.py

@@ -143,16 +143,7 @@ class TestJacLangServer(TestCase):
         lsp.quick_check(circle_file)
         lsp.deep_check(circle_file)
         lsp.type_check(circle_file)
-        expected_string = (
-            "DocumentSymbol(name='calculate_area', kind=<SymbolKind.Function: 12>, range=9:0-9:43, "
-            "selection_range=9:0-9:43, detail=None, tags=None, deprecated=None, children=["
-            "DocumentSymbol(name='radius', kind=<SymbolKind.Variable: 13>, range=9:1-9:14, "
-            "selection_range=9:1-9:14, detail=None, tags=None, deprecated=None, children=[])])"
-        )
-        self.assertEqual(
-            expected_string, str((lsp.get_document_symbols(circle_file))[6])
-        )
-        self.assertEqual(10, len(lsp.get_document_symbols(circle_file)))
+        self.assertEqual(8, len(lsp.get_document_symbols(circle_file)))
 
     def test_go_to_definition(self) -> None:
         """Test that the go to definition is correct."""
@@ -169,7 +160,7 @@ class TestJacLangServer(TestCase):
             str(lsp.get_definition(circle_file, lspt.Position(9, 16))),
         )
         self.assertIn(
-            "fixtures/circle_pure.jac:12:0-17:1",
+            "fixtures/circle_pure.jac:13:11-13:16",
             str(lsp.get_definition(circle_file, lspt.Position(20, 17))),
         )
 
@@ -186,6 +177,6 @@ class TestJacLangServer(TestCase):
         lsp.deep_check(guess_game_file)
         lsp.type_check(guess_game_file)
         self.assertIn(
-            "guess_game4.jac:27:4-27:34",
+            "guess_game4.jac:27:8-27:21",
             str(lsp.get_definition(guess_game_file, lspt.Position(46, 45))),
         )

jaclang/langserve/utils.py

@@ -106,23 +106,27 @@ def collect_symbols(node: SymbolTable) -> list[lspt.DocumentSymbol]:
         return symbols
 
     for key, item in node.tab.items():
-        if key in dir(builtins):
-            continue
-        if item in [owner_sym(tab) for tab in node.kid]:
+        if (
+            key in dir(builtins)
+            or item in [owner_sym(tab) for tab in node.kid]
+            or item.decl.loc.mod_path != node.owner.loc.mod_path
+        ):
             continue
         else:
 
-            pos = create_range(item.defn[0].loc)
+            pos = create_range(item.decl.loc)
             symbol = lspt.DocumentSymbol(
                 name=key,
-                kind=kind_map(item.defn[0]),
+                kind=kind_map(item.decl),
                 range=pos,
                 selection_range=pos,
                 children=[],
             )
             symbols.append(symbol)
 
-    for sub_tab in node.kid:
+    for sub_tab in [
+        i for i in node.kid if i.owner.loc.mod_path == node.owner.loc.mod_path
+    ]:
         sub_symbols = collect_symbols(sub_tab)
 
         if isinstance(

jaclang/plugin/builtin.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Optional
-    from jaclang.core.construct import NodeArchitype
+    from jaclang.core.constructs import NodeArchitype
 
 
 def dotgen(

jaclang/plugin/default.py

@@ -14,6 +14,7 @@ from typing import Any, Callable, Optional, Type, Union
 
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.constant import EdgeDir, colors
+from jaclang.compiler.semtable import SemInfo, SemRegistry, SemScope
 from jaclang.core.aott import (
     aott_raise,
     extract_non_primary_type,
@@ -21,7 +22,7 @@ from jaclang.core.aott import (
     get_info_types,
     get_input_information,
 )
-from jaclang.core.construct import (
+from jaclang.core.constructs import (
     Architype,
     DSFunc,
     EdgeAnchor,
@@ -39,7 +40,6 @@ from jaclang.core.construct import (
     exec_context,
 )
 from jaclang.core.importer import jac_importer
-from jaclang.core.registry import SemInfo, SemRegistry, SemScope
 from jaclang.core.utils import traverse_graph
 from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.plugin.spec import T
@@ -110,7 +110,9 @@ class JacFeatureDefaults:
         """Create a new architype."""
         for i in on_entry + on_exit:
             i.resolve(cls)
-        if not issubclass(cls, arch_base):
+        if not hasattr(cls, "_jac_entry_funcs_") or not hasattr(
+            cls, "_jac_exit_funcs_"
+        ):
             # Saving the module path and reassign it after creating cls
             # So the jac modules are part of the correct module
             cur_module = cls.__module__
@@ -216,7 +218,7 @@ class JacFeatureDefaults:
         cachable: bool,
         mdl_alias: Optional[str],
         override_name: Optional[str],
-        mod_bundle: Optional[Module],
+        mod_bundle: Optional[Module | str],
         lng: Optional[str],
         items: Optional[dict[str, Union[str, bool]]],
     ) -> Optional[types.ModuleType]:
@@ -335,7 +337,13 @@ class JacFeatureDefaults:
     @hookimpl
     def ignore(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:
         """Jac's ignore stmt feature."""
         return walker._jac_.ignore_node(expr)
@@ -344,7 +352,13 @@ class JacFeatureDefaults:
     @hookimpl
     def visit_node(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:
         """Jac's visit stmt feature."""
         if isinstance(walker, WalkerArchitype):
@@ -649,7 +663,7 @@ class JacFeatureDefaults:
 
         inputs_information = get_input_information(inputs, type_collector)
 
-        output_information = f"{outputs[0]} ({outputs[1]})"
+        output_information = f"{outputs[0]} ({outputs[1]})".strip()
         type_collector.extend(extract_non_primary_type(outputs[1]))
         output_type_explanations = "\n".join(
             list(

jaclang/plugin/feature.py

@@ -3,10 +3,10 @@
 from __future__ import annotations
 
 import types
-from typing import Any, Callable, Optional, Type, Union
+from typing import Any, Callable, Optional, Type, TypeAlias, Union
 
 from jaclang.compiler.absyntree import Module
-from jaclang.core.construct import (
+from jaclang.core.constructs import (
     Architype,
     EdgeArchitype,
     Memory,
@@ -31,7 +31,13 @@ class JacFeature:
 
     import abc
     from jaclang.compiler.constant import EdgeDir
-    from jaclang.plugin.spec import DSFunc
+    from jaclang.core.constructs import DSFunc
+
+    RootType: TypeAlias = Root
+    Obj: TypeAlias = Architype
+    Node: TypeAlias = NodeArchitype
+    Edge: TypeAlias = EdgeArchitype
+    Walker: TypeAlias = WalkerArchitype
 
     @staticmethod
     def context(session: str = "") -> ExecutionContext:
@@ -96,7 +102,7 @@ class JacFeature:
         cachable: bool = True,
         mdl_alias: Optional[str] = None,
         override_name: Optional[str] = None,
-        mod_bundle: Optional[Module] = None,
+        mod_bundle: Optional[Module | str] = None,
         lng: Optional[str] = "jac",
         items: Optional[dict[str, Union[str, bool]]] = None,
     ) -> Optional[types.ModuleType]:
@@ -160,7 +166,13 @@ class JacFeature:
     @staticmethod
     def ignore(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:  # noqa: ANN401
         """Jac's ignore stmt feature."""
         return pm.hook.ignore(walker=walker, expr=expr)
@@ -168,7 +180,13 @@ class JacFeature:
     @staticmethod
     def visit_node(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:  # noqa: ANN401
         """Jac's visit stmt feature."""
         return pm.hook.visit_node(walker=walker, expr=expr)

jaclang/plugin/spec.py

@@ -3,19 +3,19 @@
 from __future__ import annotations
 
 import types
-from dataclasses import dataclass
 from typing import Any, Callable, Optional, TYPE_CHECKING, Type, TypeVar, Union
 
 from jaclang.compiler.absyntree import Module
 
 if TYPE_CHECKING:
-    from jaclang.core.construct import EdgeArchitype, NodeArchitype
+    from jaclang.core.constructs import EdgeArchitype, NodeArchitype
     from jaclang.plugin.default import (
         Architype,
         EdgeDir,
         ExecutionContext,
         WalkerArchitype,
         Root,
+        DSFunc,
     )
     from jaclang.core.memory import Memory
 
@@ -26,20 +26,6 @@ hookspec = pluggy.HookspecMarker("jac")
 T = TypeVar("T")
 
 
-# TODO: DSFunc should be moved into jaclang/core
-@dataclass(eq=False)
-class DSFunc:
-    """Data Spatial Function."""
-
-    name: str
-    trigger: type | types.UnionType | tuple[type | types.UnionType, ...] | None
-    func: Callable[[Any, Any], Any] | None = None
-
-    def resolve(self, cls: type) -> None:
-        """Resolve the function."""
-        self.func = getattr(cls, self.name)
-
-
 class JacFeatureSpec:
     """Jac Feature."""
 
@@ -113,7 +99,7 @@ class JacFeatureSpec:
         cachable: bool,
         mdl_alias: Optional[str],
         override_name: Optional[str],
-        mod_bundle: Optional[Module],
+        mod_bundle: Optional[Module | str],
         lng: Optional[str],
         items: Optional[dict[str, Union[str, bool]]],
     ) -> Optional[types.ModuleType]:
@@ -167,7 +153,13 @@ class JacFeatureSpec:
     @hookspec(firstresult=True)
     def ignore(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:
         """Jac's ignore stmt feature."""
         raise NotImplementedError
@@ -176,7 +168,13 @@ class JacFeatureSpec:
     @hookspec(firstresult=True)
     def visit_node(
         walker: WalkerArchitype,
-        expr: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:  # noqa: ANN401
         """Jac's visit stmt feature."""
         raise NotImplementedError

jaclang/settings.py

@@ -18,6 +18,9 @@ class Settings:
     py_raise: bool = False
     py_raise_deep: bool = False
 
+    # LSP configuration
+    lsp_debug: bool = False
+
     def __post_init__(self) -> None:
         """Initialize settings."""
         home_dir = os.path.expanduser("~")

jaclang/tests/fixtures/abc.jac

@@ -18,9 +18,9 @@ Below we have the demonstration of a class to calculate the area of a circle.
 *#
 
 """Enum for shape types"""
-enum ShapeType  {
-    CIRCLE="Circle",
-    UNKNOWN="Unknown"
+enum ShapeType {
+    CIRCLE = "Circle",
+    UNKNOWN = "Unknown"
 }
 
 """Base class for a shape."""
@@ -50,24 +50,28 @@ with entry {
 # Global also works here
 
 with entry:__main__ {
-# To run the program functionality
-print(f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}");
-print(f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}");
+    # To run the program functionality
+    print(
+        f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}"
+    );
+    print(
+        f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}"
+    );
 }
 # Unit Tests!
 
 glob expected_area = 78.53981633974483;
 
-test calc_area   {
-    check.assertAlmostEqual(calculate_area(RAD), expected_area);
+test calc_area {
+    check assertAlmostEqual(calculate_area(RAD), expected_area);
 }
 
-test circle_area   {
+test circle_area {
     c = Circle(RAD);
-    check.assertAlmostEqual(c.area(), expected_area);
+    check assertAlmostEqual(c.area(), expected_area);
 }
 
-test circle_type   {
+test circle_type {
     c = Circle(RAD);
-    check.assertEqual(c.shape_type, ShapeType.CIRCLE);
+    check assertEqual(c.shape_type, ShapeType.CIRCLE);
 }