jaclang 0.7.2__py3-none-any.whl → 0.7.8__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

@@ -4,8 +4,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
@@ -19,6 +18,8 @@ from jaclang.langserve.utils import (
     collect_symbols,
     create_range,
     find_deepest_symbol_node_at_pos,
+    get_item_path,
+    get_mod_path,
 )
 from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.server import LanguageServer
@@ -27,7 +28,7 @@ import lsprotocol.types as lspt
 
 
 class ALev(IntEnum):
-    """Analysis Level."""
+    """Analysis Level successfully completed."""
 
     QUICK = 1
     DEEP = 2
@@ -40,8 +41,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:
@@ -52,6 +53,7 @@ class ModuleInfo:
         self.alev = alev
         self.parent: Optional[ModuleInfo] = parent
         self.diagnostics = self.gen_diagnostics()
+        self.sem_tokens: list[int] = self.gen_sem_tokens()
 
     @property
     def uri(self) -> str:
@@ -63,6 +65,20 @@ 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, refresh: bool = False) -> None:
+        """Update module info."""
+        self.ir = new_info.ir
+        if refresh:
+            self.errors = new_info.errors
+            self.warnings = new_info.warnings
+        else:
+            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()
+        if self.alev == ALev.TYPE:
+            self.sem_tokens = self.gen_sem_tokens()
+
     def gen_diagnostics(self) -> list[lspt.Diagnostic]:
         """Return diagnostics."""
         return [
@@ -81,6 +97,27 @@ class ModuleInfo:
             for warning in self.warnings
         ]
 
+    def gen_sem_tokens(self) -> list[int]:
+        """Return semantic tokens."""
+        tokens = []
+        prev_line, prev_col = 0, 0
+        for node in self.ir._in_mod_nodes:
+            if isinstance(node, ast.NameAtom) and node.sem_token:
+                line, col_start, col_end = (
+                    node.loc.first_line - 1,
+                    node.loc.col_start - 1,
+                    node.loc.col_end - 1,
+                )
+                length = col_end - col_start
+                tokens += [
+                    line - prev_line,
+                    col_start if line != prev_line else col_start - prev_col,
+                    length,
+                    *node.sem_token,
+                ]
+                prev_line, prev_col = line, col_start
+        return tokens
+
 
 class JacLangServer(LanguageServer):
     """Class for managing workspace."""
@@ -90,19 +127,6 @@ class JacLangServer(LanguageServer):
         super().__init__("jac-lsp", "v0.1")
         self.modules: dict[str, ModuleInfo] = {}
 
-    def module_not_diff(self, uri: str, alev: ALev) -> bool:
-        """Check if module was changed."""
-        doc = self.workspace.get_text_document(uri)
-        return (
-            doc.uri in self.modules
-            and self.modules[doc.uri].ir.source.hash
-            == md5(doc.source.encode()).hexdigest()
-            and (
-                self.modules[doc.uri].alev >= alev
-                or self.modules[doc.uri].has_syntax_error
-            )
-        )
-
     def push_diagnostics(self, file_path: str) -> None:
         """Push diagnostics for a file."""
         if file_path in self.modules:
@@ -124,15 +148,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,23 +169,28 @@ class JacLangServer(LanguageServer):
             ],
             alev=alev,
         )
-        self.modules[file_path].parent = save_parent
+        if file_path in self.modules:
+            self.modules[file_path].update_with(new_mod, refresh=refresh)
+        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
             )
 
-    def quick_check(self, file_path: str, force: bool = False) -> None:
+    def quick_check(self, file_path: str) -> bool:
         """Rebuild a file."""
-        if not force and self.module_not_diff(file_path, ALev.QUICK):
-            return
         try:
             document = self.workspace.get_text_document(file_path)
             build = jac_str_to_pass(
@@ -170,27 +198,27 @@ class JacLangServer(LanguageServer):
             )
         except Exception as e:
             self.log_error(f"Error during syntax check: {e}")
-        self.update_modules(file_path, build, ALev.QUICK)
+            return False
+        self.update_modules(file_path, build, ALev.QUICK, refresh=True)
+        return len(self.modules[file_path].errors) == 0
 
-    def deep_check(self, file_path: str, force: bool = False) -> None:
+    def deep_check(self, file_path: str) -> bool:
         """Rebuild a file and its dependencies."""
-        if file_path in self.modules:
-            self.quick_check(file_path, force=force)
-        if not force and self.module_not_diff(file_path, ALev.DEEP):
-            return
+        if file_path not in self.modules:
+            self.quick_check(file_path)
         try:
             file_path = self.unwind_to_parent(file_path)
             build = jac_ir_to_pass(ir=self.modules[file_path].ir)
         except Exception as e:
             self.log_error(f"Error during syntax check: {e}")
+            return False
         self.update_modules(file_path, build, ALev.DEEP)
+        return len(self.modules[file_path].errors) == 0
 
-    def type_check(self, file_path: str, force: bool = False) -> None:
+    def type_check(self, file_path: str) -> bool:
         """Rebuild a file and its dependencies."""
         if file_path not in self.modules:
-            self.deep_check(file_path, force=force)
-        if not force and self.module_not_diff(file_path, ALev.TYPE):
-            return
+            self.deep_check(file_path)
         try:
             file_path = self.unwind_to_parent(file_path)
             build = jac_ir_to_pass(
@@ -198,7 +226,21 @@ class JacLangServer(LanguageServer):
             )
         except Exception as e:
             self.log_error(f"Error during type check: {e}")
+            return False
         self.update_modules(file_path, build, ALev.TYPE)
+        return len(self.modules[file_path].errors) == 0
+
+    def analyze_and_publish(self, uri: str, level: int = 2) -> None:
+        """Analyze and publish diagnostics."""
+        self.log_py(f"Analyzing {uri}...")
+        success = self.quick_check(uri)
+        self.push_diagnostics(uri)
+        if success and level > 0:
+            success = self.deep_check(uri)
+            self.push_diagnostics(uri)
+            if level > 1:
+                self.type_check(uri)
+                self.push_diagnostics(uri)
 
     def get_completion(
         self, file_path: str, position: lspt.Position
@@ -275,21 +317,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}")
@@ -297,8 +338,7 @@ class JacLangServer(LanguageServer):
 
     def get_document_symbols(self, file_path: str) -> list[lspt.DocumentSymbol]:
         """Return document symbols for a file."""
-        root_node = self.modules[file_path].ir.sym_tab
-        if root_node:
+        if root_node := self.modules[file_path].ir._sym_tab:
             return collect_symbols(root_node)
         return []
 
@@ -310,7 +350,39 @@ class JacLangServer(LanguageServer):
             self.modules[file_path].ir, position.line, position.character
         )
         if node_selected:
-            if isinstance(node_selected, (ast.ElementStmt, ast.BuiltinType)):
+            if (
+                isinstance(node_selected, ast.Name)
+                and node_selected.parent
+                and isinstance(node_selected.parent, ast.ModulePath)
+            ):
+                spec = get_mod_path(node_selected.parent, node_selected)
+                if spec:
+                    return lspt.Location(
+                        uri=uris.from_fs_path(spec),
+                        range=lspt.Range(
+                            start=lspt.Position(line=0, character=0),
+                            end=lspt.Position(line=0, character=0),
+                        ),
+                    )
+                else:
+                    return None
+            elif node_selected.parent and isinstance(
+                node_selected.parent, ast.ModuleItem
+            ):
+                path_range = get_item_path(node_selected.parent)
+                if path_range:
+                    path, range = path_range
+                    if path and range:
+                        return lspt.Location(
+                            uri=uris.from_fs_path(path),
+                            range=lspt.Range(
+                                start=lspt.Position(line=range[0], character=0),
+                                end=lspt.Position(line=range[1], character=5),
+                            ),
+                        )
+                else:
+                    return None
+            elif isinstance(node_selected, (ast.ElementStmt, ast.BuiltinType)):
                 return None
             decl_node = (
                 node_selected.parent.body.target
@@ -318,8 +390,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
                 )
             )
@@ -336,9 +408,14 @@ class JacLangServer(LanguageServer):
 
             return decl_location
         else:
-            self.log_info("No declaration found for the selected node.")
             return None
 
+    def get_semantic_tokens(self, file_path: str) -> lspt.SemanticTokens:
+        """Return semantic tokens for a file."""
+        if file_path not in self.modules:
+            return lspt.SemanticTokens(data=[])
+        return lspt.SemanticTokens(data=self.modules[file_path].sem_tokens)
+
     def log_error(self, message: str) -> None:
         """Log an error message."""
         self.show_message_log(message, lspt.MessageType.Error)

jaclang/langserve/server.py

@@ -2,68 +2,37 @@
 
 from __future__ import annotations
 
-import threading
 from typing import Optional
 
+from jaclang.compiler.constant import (
+    JacSemTokenModifier as SemTokMod,
+    JacSemTokenType as SemTokType,
+)
 from jaclang.langserve.engine import JacLangServer
 from jaclang.langserve.utils import debounce
 
 import lsprotocol.types as lspt
 
 server = JacLangServer()
-analysis_thread: Optional[threading.Thread] = None
-analysis_stop_event = threading.Event()
-
-
-def analyze_and_publish(ls: JacLangServer, uri: str, level: int = 2) -> None:
-    """Analyze and publish diagnostics."""
-    global analysis_thread, analysis_stop_event
-
-    def run_analysis() -> None:
-        ls.quick_check(uri)
-        ls.push_diagnostics(uri)
-        if not analysis_stop_event.is_set() and level > 0:
-            ls.deep_check(uri)
-            ls.push_diagnostics(uri)
-            if not analysis_stop_event.is_set() and level > 1:
-                ls.type_check(uri)
-                ls.push_diagnostics(uri)
-
-    analysis_thread = threading.Thread(target=run_analysis)
-    analysis_thread.start()
-
-
-def stop_analysis() -> None:
-    """Stop analysis."""
-    global analysis_thread, analysis_stop_event
-    if analysis_thread is not None:
-        analysis_stop_event.set()
-        analysis_thread.join()
-        analysis_stop_event.clear()
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DID_OPEN)
-async def did_open(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
+@server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
+def did_open(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
     """Check syntax on change."""
-    stop_analysis()
-    analyze_and_publish(ls, params.text_document.uri)
+    ls.analyze_and_publish(params.text_document.uri)
+    # token_params = lspt.SemanticTokensParams(
+    #     text_document=lspt.TextDocumentIdentifier(uri=params.text_document.uri)
+    # )
+    # tokens = semantic_tokens_full(ls, token_params)
+    # ls.send_notification("textDocument/publishSemanticTokens", tokens)
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DID_CHANGE)
 @debounce(0.1)
-async def did_change(
-    ls: JacLangServer, params: lspt.DidChangeTextDocumentParams
-) -> None:
+async def did_change(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
     """Check syntax on change."""
-    stop_analysis()
-    analyze_and_publish(ls, params.text_document.uri)
-
-
-@server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
-async def did_save(ls: JacLangServer, params: lspt.DidSaveTextDocumentParams) -> None:
-    """Check syntax on save."""
-    stop_analysis()
-    analyze_and_publish(ls, params.text_document.uri)
+    ls.analyze_and_publish(params.text_document.uri, level=0)
 
 
 @server.feature(
@@ -74,11 +43,8 @@ async def did_save(ls: JacLangServer, params: lspt.DidSaveTextDocumentParams) ->
         ]
     ),
 )
-async def did_create_files(ls: JacLangServer, params: lspt.CreateFilesParams) -> None:
+def did_create_files(ls: JacLangServer, params: lspt.CreateFilesParams) -> None:
     """Check syntax on file creation."""
-    for file in params.files:
-        ls.quick_check(file.uri)
-        ls.push_diagnostics(file.uri)
 
 
 @server.feature(
@@ -89,13 +55,12 @@ async def did_create_files(ls: JacLangServer, params: lspt.CreateFilesParams) ->
         ]
     ),
 )
-async def did_rename_files(ls: JacLangServer, params: lspt.RenameFilesParams) -> None:
+def did_rename_files(ls: JacLangServer, params: lspt.RenameFilesParams) -> None:
     """Check syntax on file rename."""
     new_uris = [file.new_uri for file in params.files]
     old_uris = [file.old_uri for file in params.files]
     for i in range(len(new_uris)):
         ls.rename_module(old_uris[i], new_uris[i])
-        ls.quick_check(new_uris[i])
 
 
 @server.feature(
@@ -106,7 +71,7 @@ async def did_rename_files(ls: JacLangServer, params: lspt.RenameFilesParams) ->
         ]
     ),
 )
-async def did_delete_files(ls: JacLangServer, params: lspt.DeleteFilesParams) -> None:
+def did_delete_files(ls: JacLangServer, params: lspt.DeleteFilesParams) -> None:
     """Check syntax on file delete."""
     for file in params.files:
         ls.delete_module(file.uri)
@@ -116,9 +81,7 @@ async def did_delete_files(ls: JacLangServer, params: lspt.DeleteFilesParams) ->
     lspt.TEXT_DOCUMENT_COMPLETION,
     lspt.CompletionOptions(trigger_characters=[".", ":", ""]),
 )
-async def completion(
-    ls: JacLangServer, params: lspt.CompletionParams
-) -> lspt.CompletionList:
+def completion(ls: JacLangServer, params: lspt.CompletionParams) -> lspt.CompletionList:
     """Provide completion."""
     return ls.get_completion(params.text_document.uri, params.position)
 
@@ -140,25 +103,35 @@ def hover(
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DOCUMENT_SYMBOL)
-async def document_symbol(
+def document_symbol(
     ls: JacLangServer, params: lspt.DocumentSymbolParams
 ) -> list[lspt.DocumentSymbol]:
     """Provide document symbols."""
-    stop_analysis()
-    analyze_and_publish(ls, params.text_document.uri)
     return ls.get_document_symbols(params.text_document.uri)
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DEFINITION)
-async def definition(
+def definition(
     ls: JacLangServer, params: lspt.TextDocumentPositionParams
 ) -> Optional[lspt.Location]:
     """Provide definition."""
-    stop_analysis()
-    analyze_and_publish(ls, params.text_document.uri, level=1)
     return ls.get_definition(params.text_document.uri, params.position)
 
 
+@server.feature(
+    lspt.TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL,
+    lspt.SemanticTokensLegend(
+        token_types=SemTokType.as_str_list(),
+        token_modifiers=SemTokMod.as_str_list(),
+    ),
+)
+def semantic_tokens_full(
+    ls: JacLangServer, params: lspt.SemanticTokensParams
+) -> lspt.SemanticTokens:
+    """Provide semantic tokens."""
+    return ls.get_semantic_tokens(params.text_document.uri)
+
+
 def run_lang_server() -> None:
     """Run the language server."""
     server.start_io()

jaclang/langserve/tests/fixtures/base_module_structure.jac

@@ -0,0 +1,28 @@
+"""A Docstring can be added the head of any module.
+
+Any element in the module can also have a docstring.
+If there is only one docstring before the first element,
+it is assumed to be a module docstring.
+"""
+
+"""A docstring for add function"""
+can add(a: int, b: int) -> int {
+    return a + b;
+}
+# No docstring for subtract function
+
+can subtract(a: int, b: int) -> int {
+    return a - b;
+}
+
+with entry:__main__ {
+    print(add(1, subtract(3, 1)));
+}
+
+glob x: int = 10;
+
+enum Color {
+    RED,
+    GREEN,
+    BLUE
+}

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);
 }