assignment-codeval 0.0.29__tar.gz → 0.0.30__tar.gz

{assignment_codeval-0.0.29 → assignment_codeval-0.0.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assignment-codeval
-Version: 0.0.29
+Version: 0.0.30
 Summary: CodEval for evaluating programming assignments
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -69,7 +69,8 @@ Tags used in a spec file (\<course name>.codeval)
 | CTO | Compile Timeout | Timeout in seconds for the compile command to run |
 | RUN | Run Script | Specifies the script to use to evaluate the specification file. Defaults to evaluate.sh. |
 | Z | Download Zip | Will be followed by zip files to download from Canvas to use when running the test cases. |
-| CF | Check Function | Will be followed by a function name and a list of files to check to ensure that the function is used by one of those files. |
+| CF | Check Function | `CF <function_name> [filename]` — checks that the function is used. The filename is **optional** and omitting it (e.g. `CF strtol`) is the preferred usage; source files are inferred from the most recent `C` tag and the check uses compiled-artifact inspection only (objdump/javap/ast). Providing a filename (e.g. `CF strtol mycalc.c`) is supported for backwards compatibility and additionally enables a regex fallback when no compiled artifact is found. |
+| NCF | Check Not Function | `NCF <function_name> [filename]` — checks that the function is **not** used. The filename is **optional** (same behaviour as CF). |
 | CC | Check Container | Will be followed by a function name and a list of files to check to ensure that a container is used by one of those files. Primarily supports C++ containers such as std::vector |
 | CO | Check Object | Will be followed by a function name and a list of files to check to ensure that an object is used by one of those files. Primarily support C++ stream operations |
 | PRINT | Print Label | Prints a label/message to stdout. Cleaner alternative to `CMD echo "..."` for section labels. |
@@ -82,6 +83,7 @@ Tags used in a spec file (\<course name>.codeval)
 | TO | Timeout | Specifies the time limit in seconds for a test case to run. Defaults to 20 seconds. |
 | X | Exit Code | Specifies the expected exit code for a test case. Defaults to zero. |
 | SS | Start Server | Command containing timeout (wait until server starts), kill timeout (wait to kill the server), and the command to start a server |
+| TEMP | Temp File | Registers a file to be deleted before the next T, HT, or TCMD test runs (clean state) and again after it completes (cleanup). Only applies to the immediately following test — use a new TEMP tag for each test that needs it. |
 
 Refer to a sample spec file [here](samples/assignment-name.codeval)
 

{assignment_codeval-0.0.29 → assignment_codeval-0.0.30}/README.md

@@ -49,7 +49,8 @@ Tags used in a spec file (\<course name>.codeval)
 | CTO | Compile Timeout | Timeout in seconds for the compile command to run |
 | RUN | Run Script | Specifies the script to use to evaluate the specification file. Defaults to evaluate.sh. |
 | Z | Download Zip | Will be followed by zip files to download from Canvas to use when running the test cases. |
-| CF | Check Function | Will be followed by a function name and a list of files to check to ensure that the function is used by one of those files. |
+| CF | Check Function | `CF <function_name> [filename]` — checks that the function is used. The filename is **optional** and omitting it (e.g. `CF strtol`) is the preferred usage; source files are inferred from the most recent `C` tag and the check uses compiled-artifact inspection only (objdump/javap/ast). Providing a filename (e.g. `CF strtol mycalc.c`) is supported for backwards compatibility and additionally enables a regex fallback when no compiled artifact is found. |
+| NCF | Check Not Function | `NCF <function_name> [filename]` — checks that the function is **not** used. The filename is **optional** (same behaviour as CF). |
 | CC | Check Container | Will be followed by a function name and a list of files to check to ensure that a container is used by one of those files. Primarily supports C++ containers such as std::vector |
 | CO | Check Object | Will be followed by a function name and a list of files to check to ensure that an object is used by one of those files. Primarily support C++ stream operations |
 | PRINT | Print Label | Prints a label/message to stdout. Cleaner alternative to `CMD echo "..."` for section labels. |
@@ -62,6 +63,7 @@ Tags used in a spec file (\<course name>.codeval)
 | TO | Timeout | Specifies the time limit in seconds for a test case to run. Defaults to 20 seconds. |
 | X | Exit Code | Specifies the expected exit code for a test case. Defaults to zero. |
 | SS | Start Server | Command containing timeout (wait until server starts), kill timeout (wait to kill the server), and the command to start a server |
+| TEMP | Temp File | Registers a file to be deleted before the next T, HT, or TCMD test runs (clean state) and again after it completes (cleanup). Only applies to the immediately following test — use a new TEMP tag for each test that needs it. |
 
 Refer to a sample spec file [here](samples/assignment-name.codeval)
 

{assignment_codeval-0.0.29 → assignment_codeval-0.0.30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "assignment-codeval"
-version = "0.0.29"
+version = "0.0.30"
 description = "CodEval for evaluating programming assignments"
 readme = "README.md"
 requires-python = ">=3.12"

{assignment_codeval-0.0.29 → assignment_codeval-0.0.30}/src/assignment_codeval/canvas_utils.py

@@ -98,7 +98,7 @@ def get_assignment(course, assignment_name):
             error(fr"    {a.name}")
         sys.exit(2)
     elif len(assignments) > 1:
-        strict_name_assignments = [a for a in assignments if a.name == assignment_name]
+        strict_name_assignments = [a for a in assignments if despace(a.name) == assignment_name]
         if len(strict_name_assignments) == 1:
             assignments = strict_name_assignments
         else:

{assignment_codeval-0.0.29 → assignment_codeval-0.0.30}/src/assignment_codeval/evaluate.py

@@ -38,11 +38,23 @@ num_failed = 0
 is_hidden_testcase = False
 is_verbose = False
 compilelog = []
+last_compile_command = ""
+temp_files = []
+_active_temp_files = []
 
 ###########################################################
 # Specification Tags to Function Mapping
 ###########################################################
 
+# Shell commands that likely indicate a missing CMD prefix when found untagged
+_BARE_SHELL_COMMANDS = {
+    'echo', 'rm', 'cp', 'mv', 'mkdir', 'rmdir', 'cat', 'ls', 'grep',
+    'sed', 'awk', 'find', 'chmod', 'chown', 'touch', 'ln', 'diff',
+    'sort', 'head', 'tail', 'cut', 'tr', 'wc', 'bash', 'sh', 'python',
+    'python3', 'make', 'export', 'source', 'kill', 'pkill', 'sleep',
+    'printf', 'read', 'unzip', 'tar', 'curl', 'wget',
+}
+
 
 def compile_code(compile_command):
     """Specifies the command to compile the submission code
@@ -53,6 +65,9 @@ def compile_code(compile_command):
     Returns:
         None
     """
+    global last_compile_command
+    last_compile_command = compile_command
+
     if test_case_count != 0:
         check_test()
 
@@ -112,6 +127,44 @@ def _find_compiled_artifact(source_file):
     return None
 
 
+def _extract_executable_from_compile(compile_command):
+    """Extract the output executable name from a compile command (looks for -o <name>).
+
+    Returns the executable name, or None if not found.
+    """
+    parts = compile_command.split()
+    for i, part in enumerate(parts):
+        if part == '-o' and i + 1 < len(parts):
+            return parts[i + 1]
+    return None
+
+
+def _extract_source_files_from_compile(compile_command):
+    """Extract source file arguments from a compile command.
+
+    Recognises common source file extensions (.c, .cpp, .cc, .cxx, .java, .py)
+    and skips option arguments that consume the following token as a value
+    (e.g. -o, -I, -L, -l, -include, -isystem, -MF, -MT, -MQ).
+
+    Returns a list of source file paths found in the command.
+    """
+    source_exts = ('.c', '.cpp', '.cc', '.cxx', '.java', '.py')
+    value_flags = {'-o', '-I', '-L', '-l', '-include', '-isystem', '-MF', '-MT', '-MQ'}
+    parts = compile_command.split()
+    files = []
+    skip_next = False
+    for part in parts:
+        if skip_next:
+            skip_next = False
+            continue
+        if part in value_flags:
+            skip_next = True
+            continue
+        if not part.startswith('-') and any(part.endswith(ext) for ext in source_exts):
+            files.append(part)
+    return files
+
+
 def _function_used_in_c_cpp(function_name, files):
     """Use objdump on compiled artifacts to detect C/C++ function usage.
 
@@ -209,14 +262,20 @@ def _function_used_regex(function_name, files):
     return result.returncode == 0
 
 
-def _is_function_used(function_name, files):
+def _is_function_used(function_name, files, allow_regex_fallback=True):
     """Detect whether function_name is used in the given files.
 
     Dispatches to the appropriate tool based on file language:
-      - C/C++:  objdump on compiled artifact (falls back to regex if none found)
-      - Java:   javap on .class file (falls back to regex if none found)
+      - C/C++:  objdump on compiled artifact (falls back to regex if none found
+                and allow_regex_fallback is True)
+      - Java:   javap on .class file (falls back to regex if none found
+                and allow_regex_fallback is True)
       - Python: ast module on source
-      - Other:  regex on source
+      - Other:  regex on source (only when allow_regex_fallback is True)
+
+    When allow_regex_fallback is False (used when no filename was given in the
+    CF tag), the function relies solely on compiled-artifact inspection and
+    returns False rather than falling back to regex.
     """
     lang = _detect_language(files)
     if lang == 'python':
@@ -224,36 +283,56 @@ def _is_function_used(function_name, files):
     if lang == 'java':
         result = _function_used_in_java(function_name, files)
         if result is None:
-            return _function_used_regex(function_name, files)
+            return _function_used_regex(function_name, files) if allow_regex_fallback else False
         return result
     if lang == 'c_cpp':
         result = _function_used_in_c_cpp(function_name, files)
         if result is None:
-            return _function_used_regex(function_name, files)
+            return _function_used_regex(function_name, files) if allow_regex_fallback else False
         return result
-    return _function_used_regex(function_name, files)
+    if allow_regex_fallback:
+        return _function_used_regex(function_name, files)
+    return False
 
 
 def check_function(args):
-    """Will be followed by a function name and a list of files to check to ensure that the function
-    is used by one of those files.
+    """Will be followed by a function name and an optional list of files to check to ensure that
+    the function is used by one of those files.
+
+    When no filename is provided (preferred usage), the source files are derived from the most
+    recent C (compile) tag.  The check then relies solely on compiled-artifact inspection
+    (objdump for C/C++, javap for Java, ast for Python) with no regex fallback.
+
+    When a filename is provided (legacy usage), the same compiled-artifact inspection is used
+    first, but a regex scan of the source file is available as a fallback when no compiled
+    artifact can be found.
 
     Arguments:
         function_name: the function name to check files for usage of
-        *files: the files to check for the function name
+        *files: (optional) the files to check for the function name.  If omitted, source
+                files are inferred from the most recent C tag.
 
     Returns:
         None
     """
     check_test()
-    args = args.split()
-    function_name = args[0]
-    files = args[1:]
-
-    if _is_function_used(function_name, files):
-        print(f"Used {function_name} PASSED")
+    args_list = args.split()
+    function_name = args_list[0]
+    files = args_list[1:]
+
+    if not files:
+        # No filename provided — derive source files from the compile command and
+        # disable the regex fallback (compiled-artifact check only).
+        files = _extract_source_files_from_compile(last_compile_command)
+        if _is_function_used(function_name, files, allow_regex_fallback=False):
+            print(f"Used {function_name} PASSED")
+        else:
+            print(f"Not using {function_name} FAILED")
     else:
-        print(f"Not using {function_name} FAILED")
+        if _is_function_used(function_name, files):
+            print(f"Used {function_name} PASSED")
+        else:
+            print(f"Not using {function_name} FAILED")
 
 def check_object(args):
     """Will be followed by an object and a list of files to ensure that the function is
@@ -352,22 +431,38 @@ def check_container(args):
     
 
 def check_not_function(args):
-    """Will be followed by a function name and a list of files to check to ensure that the function
-    is not used by any of those files.
+    """Will be followed by a function name and an optional list of files to check to ensure that
+    the function is not used by any of those files.
+
+    When no filename is provided (preferred usage), the source files are derived from the most
+    recent C (compile) tag.  The check relies solely on compiled-artifact inspection with no
+    regex fallback.
+
+    When a filename is provided (legacy usage), compiled-artifact inspection is used first with
+    a regex fallback when no compiled artifact is found.
 
     Arguments:
         function_name: the function name to check files for usage of
-        *files: the files to check for the function name
+        *files: (optional) the files to check for the function name.  If omitted, source
+                files are inferred from the most recent C tag.
 
     Returns:
         None
     """
     check_test()
-    args = args.split()
-    function_name = args[0]
-    files = args[1:]
+    args_list = args.split()
+    function_name = args_list[0]
+    files = args_list[1:]
+
+    if not files:
+        # No filename provided — derive source files from the compile command and
+        # disable the regex fallback (compiled-artifact check only).
+        files = _extract_source_files_from_compile(last_compile_command)
+        used = _is_function_used(function_name, files, allow_regex_fallback=False)
+    else:
+        used = _is_function_used(function_name, files)
 
-    if _is_function_used(function_name, files):
+    if used:
         print(f"Used {function_name} FAILED")
     else:
         print(f"Not using {function_name} PASSED")
@@ -412,6 +507,7 @@ def run_command_noerror(command):
         None
     """
     check_test()
+    _pre_test_temp_cleanup()
 
     # Run as test case
     global test_case_count
@@ -460,6 +556,7 @@ def test_case(test_case_command):
         None
     """
     check_test()
+    _pre_test_temp_cleanup()
 
     # Clear hint
     global test_case_hint
@@ -488,6 +585,7 @@ def test_case_hidden(test_case_command):
         None
     """
     check_test()
+    _pre_test_temp_cleanup()
 
     # Clear hint
     global test_case_hint
@@ -585,9 +683,10 @@ def check_output_file(output_file):
     Returns:
         None
     """
+    output_length(os.path.getsize(output_file)) 
     with open(output_file, "r") as infile:
         output_lines = infile.readlines()
-
+        
     with open(get_testing_path("expectedoutput"), "a") as outfile:
         outfile.writelines(output_lines)
 
@@ -631,6 +730,48 @@ def hint(hints):
     test_case_hint = hints
 
 
+def register_temp_file(filename):
+    """Registers a file to be deleted before and after the next T, HT, or TCMD test.
+
+    Arguments:
+        filename: the file to delete before and after the next test
+
+    Returns:
+        None
+    """
+    global temp_files
+    temp_files.append(filename.strip())
+
+
+def _cleanup_temp_files():
+    """Delete all registered temp files and reset the list."""
+    global temp_files
+    for f in temp_files:
+        try:
+            os.remove(f)
+        except FileNotFoundError:
+            pass
+    temp_files = []
+
+
+def _pre_test_temp_cleanup():
+    """Before a test: delete registered temp files and save the list for post-test cleanup."""
+    global temp_files, _active_temp_files
+    _active_temp_files = list(temp_files)
+    _cleanup_temp_files()
+
+
+def _post_test_temp_cleanup():
+    """After a test: delete the files that were registered when the test started."""
+    global _active_temp_files
+    for f in _active_temp_files:
+        try:
+            os.remove(f)
+        except FileNotFoundError:
+            pass
+    _active_temp_files = []
+
+
 def timeout(timeout_sec):
     """Specifies the time limit in seconds for a test case to run. Defaults to 20 seconds.
 
@@ -743,6 +884,7 @@ tag_func_map = {
     "OLEN": output_length,
     "X": exit_code,
     "SS": start_server,
+    "TEMP": register_temp_file,
 }
 
 
@@ -840,6 +982,13 @@ def parse_tags(tags: list[str]):
                     print(f"  {line_num}: {tag_line.rstrip()}")
                     print(f"  Valid tags are: {', '.join(sorted(valid_tags))}")
                     sys.exit(1)
+            else:
+                # Check if this looks like a bare shell command missing a CMD prefix
+                first_word = tag_line.split()[0] if tag_line.split() else ""
+                if first_word.lower() in _BARE_SHELL_COMMANDS:
+                    print(f"Warning on line {line_num}: bare shell command without CMD prefix, shell commands will be ignored")
+                    print(f"  {line_num}: {tag_line.rstrip()}")
+                    print(f"  Did you mean: CMD {tag_line.rstrip()}")
             continue
 
         tag = tag_match.group(1)
@@ -1138,10 +1287,14 @@ def check_test():
                                 if len(lines) > 22:
                                     print(f"    ... ({len(lines) - 22} more lines)")
 
+        _post_test_temp_cleanup()
+        cleanup()
+
         # Exit program after failed test case
         sys.exit(2)
 
     # reinitialize test variables and files here
+    _post_test_temp_cleanup()
     setup()
 
 

{assignment_codeval-0.0.29 → assignment_codeval-0.0.30}/src/assignment_codeval/submissions.py

@@ -605,7 +605,8 @@ def get_submissions_by_id(assignment):
 
 @click.command()
 @click.argument("course_name", metavar="COURSE", required=False)
-def list_codeval_assignments(course_name):
+@click.option("--path", is_flag=True, help="Show the path to the codeval file")
+def list_codeval_assignments(course_name, path):
     """
     List all assignments that have corresponding codeval files.
 
@@ -646,10 +647,18 @@ def list_codeval_assignments(course_name):
             assignment_key = despace(assignment.name).lower()
             if assignment_key in codeval_files:
                 matched_codeval_keys.add(assignment_key)
-                info(f"{course.name}: {assignment.name}")
+                codeval_path = os.path.join(codeval_dir, f"{codeval_files[assignment_key]}.codeval")
+                if path:
+                    info(f"{course.name}: {assignment.name} [{codeval_path}]")
+                else:
+                    info(f"{course.name}: {assignment.name}")
             elif assignment_key in codeval_titles:
                 matched_codeval_keys.add(codeval_titles[assignment_key].lower())
-                info(f"{course.name}: {assignment.name}")
+                codeval_path = os.path.join(codeval_dir, f"{codeval_titles[assignment_key]}.codeval")
+                if path:
+                    info(f"{course.name}: {assignment.name} [{codeval_path}]")
+                else:
+                    info(f"{course.name}: {assignment.name}")
 
     # Report codeval files that don't match any assignment
     unmatched_keys = set(codeval_files.keys()) - matched_codeval_keys

{assignment_codeval-0.0.29 → assignment_codeval-0.0.30}/src/assignment_codeval.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assignment-codeval
-Version: 0.0.29
+Version: 0.0.30
 Summary: CodEval for evaluating programming assignments
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -69,7 +69,8 @@ Tags used in a spec file (\<course name>.codeval)
 | CTO | Compile Timeout | Timeout in seconds for the compile command to run |
 | RUN | Run Script | Specifies the script to use to evaluate the specification file. Defaults to evaluate.sh. |
 | Z | Download Zip | Will be followed by zip files to download from Canvas to use when running the test cases. |
-| CF | Check Function | Will be followed by a function name and a list of files to check to ensure that the function is used by one of those files. |
+| CF | Check Function | `CF <function_name> [filename]` — checks that the function is used. The filename is **optional** and omitting it (e.g. `CF strtol`) is the preferred usage; source files are inferred from the most recent `C` tag and the check uses compiled-artifact inspection only (objdump/javap/ast). Providing a filename (e.g. `CF strtol mycalc.c`) is supported for backwards compatibility and additionally enables a regex fallback when no compiled artifact is found. |
+| NCF | Check Not Function | `NCF <function_name> [filename]` — checks that the function is **not** used. The filename is **optional** (same behaviour as CF). |
 | CC | Check Container | Will be followed by a function name and a list of files to check to ensure that a container is used by one of those files. Primarily supports C++ containers such as std::vector |
 | CO | Check Object | Will be followed by a function name and a list of files to check to ensure that an object is used by one of those files. Primarily support C++ stream operations |
 | PRINT | Print Label | Prints a label/message to stdout. Cleaner alternative to `CMD echo "..."` for section labels. |
@@ -82,6 +83,7 @@ Tags used in a spec file (\<course name>.codeval)
 | TO | Timeout | Specifies the time limit in seconds for a test case to run. Defaults to 20 seconds. |
 | X | Exit Code | Specifies the expected exit code for a test case. Defaults to zero. |
 | SS | Start Server | Command containing timeout (wait until server starts), kill timeout (wait to kill the server), and the command to start a server |
+| TEMP | Temp File | Registers a file to be deleted before the next T, HT, or TCMD test runs (clean state) and again after it completes (cleanup). Only applies to the immediately following test — use a new TEMP tag for each test that needs it. |
 
 Refer to a sample spec file [here](samples/assignment-name.codeval)
 

{assignment_codeval-0.0.29 → assignment_codeval-0.0.30}/tests/test_codeval.py

@@ -1,6 +1,7 @@
 """Pytest tests for CodEval test files."""
 import glob
 import os
+import shutil
 import subprocess
 import pytest
 
@@ -10,6 +11,31 @@ from assignment_codeval.evaluate import _render_diff_output
 TEST_DIR = os.path.dirname(os.path.abspath(__file__))
 CODEVAL_FILES = sorted(glob.glob(os.path.join(TEST_DIR, "*.codeval")))
 
+def _tool_works(*cmd):
+    """Return True if cmd exits with code 0 (handles macOS stub wrappers)."""
+    try:
+        return subprocess.run(list(cmd), capture_output=True, timeout=10).returncode == 0
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+# Tools that codeval files may declare as requirements via "# REQUIRES: <tool>"
+_TOOL_AVAILABLE = {
+    "java": _tool_works("javac", "--version") and _tool_works("java", "-version"),
+}
+
+
+def _parse_requires(codeval_file):
+    """Return the set of tools declared with '# REQUIRES: <tool>' in a codeval file."""
+    required = set()
+    with open(codeval_file) as f:
+        for line in f:
+            line = line.strip()
+            if line.startswith("# REQUIRES:"):
+                tool = line.split(":", 1)[1].strip().lower()
+                required.add(tool)
+    return required
+
 
 def get_test_ids():
     """Generate test IDs from filenames."""
@@ -21,6 +47,10 @@ def test_codeval(codeval_file):
     """Run a .codeval test file and verify it passes."""
     test_name = os.path.basename(codeval_file)
 
+    for tool in _parse_requires(codeval_file):
+        if not _TOOL_AVAILABLE.get(tool, shutil.which(tool) is not None):
+            pytest.skip(f"{tool} not available")
+
     result = subprocess.run(
         ["assignment-codeval", "run-evaluation", test_name],
         cwd=TEST_DIR,

assignment_codeval-0.0.30/tests/test_function_detection.py

@@ -0,0 +1,411 @@
+"""Unit tests for CF/NCF function detection helpers.
+
+Tests the three detection paths introduced in evaluate.py:
+  - C/C++:  objdump -t on compiled artifact
+  - Java:   javap -c on .class file
+  - Python: ast module on source
+
+C++ and Java tests are skipped automatically when the required tools
+are not available (e.g. on macOS without a full JDK install).
+"""
+
+import os
+import shutil
+import subprocess
+import tempfile
+
+import pytest
+
+
+# ---------------------------------------------------------------------------
+# Tool availability guards
+# ---------------------------------------------------------------------------
+
+def _tool_works(*cmd):
+    """Return True if cmd exits with code 0."""
+    try:
+        result = subprocess.run(list(cmd), capture_output=True, timeout=10)
+        return result.returncode == 0
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+HAS_GPP_OBJDUMP = (
+    shutil.which("g++") is not None
+    and shutil.which("objdump") is not None
+    and _tool_works("g++", "--version")
+)
+
+HAS_JAVA = _tool_works("javac", "--version") and _tool_works("javap", "-version")
+
+
+# ---------------------------------------------------------------------------
+# C++ — objdump path
+# ---------------------------------------------------------------------------
+
+CPP_SOURCE = """\
+#include <iostream>
+void greet() { std::cout << "Hello World" << std::endl; }
+int main() { greet(); return 0; }
+"""
+
+
+@pytest.mark.skipif(not HAS_GPP_OBJDUMP, reason="g++ or objdump not available")
+class TestCppFunctionDetection:
+    """_function_used_in_c_cpp uses objdump -t on the compiled artifact."""
+
+    def setup_method(self):
+        self.tmpdir = tempfile.mkdtemp()
+        self.src = os.path.join(self.tmpdir, "sample.cpp")
+        self.exe = os.path.join(self.tmpdir, "sample")
+        with open(self.src, "w") as f:
+            f.write(CPP_SOURCE)
+        subprocess.run(
+            ["g++", "-o", self.exe, self.src],
+            check=True,
+            capture_output=True,
+        )
+
+    def teardown_method(self):
+        shutil.rmtree(self.tmpdir, ignore_errors=True)
+
+    def test_detects_used_function(self):
+        from assignment_codeval.evaluate import _function_used_in_c_cpp
+        assert _function_used_in_c_cpp("greet", [self.src]) is True
+
+    def test_returns_false_for_unused_function(self):
+        from assignment_codeval.evaluate import _function_used_in_c_cpp
+        assert _function_used_in_c_cpp("forbidden_func", [self.src]) is False
+
+    def test_returns_none_when_no_artifact(self):
+        """No compiled artifact → caller should fall back to regex."""
+        from assignment_codeval.evaluate import _function_used_in_c_cpp
+        with tempfile.TemporaryDirectory() as tmpdir:
+            src = os.path.join(tmpdir, "uncompiled.cpp")
+            with open(src, "w") as f:
+                f.write("int main() { return 0; }\n")
+            assert _function_used_in_c_cpp("greet", [src]) is None
+
+
+# ---------------------------------------------------------------------------
+# Java — javap path
+# ---------------------------------------------------------------------------
+
+JAVA_SOURCE = """\
+public class SampleCfDetect {
+    public static void greet() { System.out.println("Hello World"); }
+    public static void main(String[] args) { greet(); }
+}
+"""
+
+
+@pytest.mark.skipif(not HAS_JAVA, reason="javac or javap not available")
+class TestJavaFunctionDetection:
+    """_function_used_in_java uses javap -c on the compiled .class file."""
+
+    def setup_method(self):
+        self.tmpdir = tempfile.mkdtemp()
+        self.src = os.path.join(self.tmpdir, "SampleCfDetect.java")
+        with open(self.src, "w") as f:
+            f.write(JAVA_SOURCE)
+        subprocess.run(
+            ["javac", self.src],
+            check=True,
+            capture_output=True,
+            cwd=self.tmpdir,
+        )
+
+    def teardown_method(self):
+        shutil.rmtree(self.tmpdir, ignore_errors=True)
+
+    def test_detects_used_method(self):
+        from assignment_codeval.evaluate import _function_used_in_java
+        assert _function_used_in_java("greet", [self.src]) is True
+
+    def test_returns_false_for_unused_method(self):
+        from assignment_codeval.evaluate import _function_used_in_java
+        assert _function_used_in_java("forbidden_func", [self.src]) is False
+
+    def test_returns_none_when_no_class_file(self):
+        """No .class file → caller should fall back to regex."""
+        from assignment_codeval.evaluate import _function_used_in_java
+        with tempfile.TemporaryDirectory() as tmpdir:
+            src = os.path.join(tmpdir, "Uncompiled.java")
+            with open(src, "w") as f:
+                f.write(
+                    "public class Uncompiled { public static void main(String[] a) {} }\n"
+                )
+            assert _function_used_in_java("greet", [src]) is None
+
+    def test_cf_no_filename_detects_used_method(self, capsys):
+        import assignment_codeval.evaluate as ev
+        old_cmd = ev.last_compile_command
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(self.tmpdir)
+            ev.last_compile_command = f"javac SampleCfDetect.java"
+            ev.test_case_count = 0
+            ev.check_function("greet")
+        finally:
+            ev.last_compile_command = old_cmd
+            os.chdir(old_cwd)
+        captured = capsys.readouterr()
+        assert "PASSED" in captured.out
+
+    def test_cf_no_filename_fails_for_unused_method(self, capsys):
+        import assignment_codeval.evaluate as ev
+        old_cmd = ev.last_compile_command
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(self.tmpdir)
+            ev.last_compile_command = f"javac SampleCfDetect.java"
+            ev.test_case_count = 0
+            ev.check_function("forbidden_func")
+        finally:
+            ev.last_compile_command = old_cmd
+            os.chdir(old_cwd)
+        captured = capsys.readouterr()
+        assert "FAILED" in captured.out
+
+    def test_ncf_no_filename_passes_for_absent_method(self, capsys):
+        import assignment_codeval.evaluate as ev
+        old_cmd = ev.last_compile_command
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(self.tmpdir)
+            ev.last_compile_command = f"javac SampleCfDetect.java"
+            ev.test_case_count = 0
+            ev.check_not_function("forbidden_func")
+        finally:
+            ev.last_compile_command = old_cmd
+            os.chdir(old_cwd)
+        captured = capsys.readouterr()
+        assert "PASSED" in captured.out
+
+
+# ---------------------------------------------------------------------------
+# Python — ast path
+# ---------------------------------------------------------------------------
+
+class TestPythonFunctionDetection:
+    """_function_used_in_python uses the ast module; no external tools needed."""
+
+    def _write_source(self, code):
+        f = tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False)
+        f.write(code)
+        f.close()
+        return f.name
+
+    def test_detects_direct_call(self):
+        from assignment_codeval.evaluate import _function_used_in_python
+        fname = self._write_source("print('hello')\nlen([1, 2])\n")
+        try:
+            assert _function_used_in_python("print", [fname]) is True
+            assert _function_used_in_python("len", [fname]) is True
+        finally:
+            os.unlink(fname)
+
+    def test_detects_attribute_call(self):
+        from assignment_codeval.evaluate import _function_used_in_python
+        fname = self._write_source("items = []\nitems.append(1)\n")
+        try:
+            assert _function_used_in_python("append", [fname]) is True
+        finally:
+            os.unlink(fname)
+
+    def test_returns_false_for_unused_function(self):
+        from assignment_codeval.evaluate import _function_used_in_python
+        fname = self._write_source("print('hello')\n")
+        try:
+            assert _function_used_in_python("eval", [fname]) is False
+        finally:
+            os.unlink(fname)
+
+    def test_ignores_function_name_in_string(self):
+        """A function name that only appears inside a string is not a call."""
+        from assignment_codeval.evaluate import _function_used_in_python
+        fname = self._write_source('x = "eval is dangerous"\n')
+        try:
+            assert _function_used_in_python("eval", [fname]) is False
+        finally:
+            os.unlink(fname)
+
+    def test_ignores_function_name_in_comment(self):
+        """A function name that only appears in a comment is not a call."""
+        from assignment_codeval.evaluate import _function_used_in_python
+        fname = self._write_source("# eval would be bad here\nx = 1\n")
+        try:
+            assert _function_used_in_python("eval", [fname]) is False
+        finally:
+            os.unlink(fname)
+
+
+# ---------------------------------------------------------------------------
+# Compile-command helpers
+# ---------------------------------------------------------------------------
+
+class TestExtractExecutableFromCompile:
+    """_extract_executable_from_compile returns the -o argument."""
+
+    def test_simple_c_compile(self):
+        from assignment_codeval.evaluate import _extract_executable_from_compile
+        assert _extract_executable_from_compile("cc -o mycalc --std=gnu11 mycalc.c") == "mycalc"
+
+    def test_cpp_compile(self):
+        from assignment_codeval.evaluate import _extract_executable_from_compile
+        assert _extract_executable_from_compile("g++ -o sample_cf_functions sample_cf_functions.cpp") == "sample_cf_functions"
+
+    def test_no_output_flag(self):
+        from assignment_codeval.evaluate import _extract_executable_from_compile
+        assert _extract_executable_from_compile("cc mycalc.c") is None
+
+    def test_empty_command(self):
+        from assignment_codeval.evaluate import _extract_executable_from_compile
+        assert _extract_executable_from_compile("") is None
+
+
+class TestExtractSourceFilesFromCompile:
+    """_extract_source_files_from_compile returns source file arguments."""
+
+    def test_single_c_file(self):
+        from assignment_codeval.evaluate import _extract_source_files_from_compile
+        assert _extract_source_files_from_compile("cc -o mycalc --std=gnu11 mycalc.c") == ["mycalc.c"]
+
+    def test_cpp_file(self):
+        from assignment_codeval.evaluate import _extract_source_files_from_compile
+        assert _extract_source_files_from_compile("g++ -o out sample.cpp") == ["sample.cpp"]
+
+    def test_multiple_source_files(self):
+        from assignment_codeval.evaluate import _extract_source_files_from_compile
+        result = _extract_source_files_from_compile("cc -o prog main.c util.c helper.c")
+        assert result == ["main.c", "util.c", "helper.c"]
+
+    def test_python_file(self):
+        from assignment_codeval.evaluate import _extract_source_files_from_compile
+        assert _extract_source_files_from_compile("python3 myscript.py") == ["myscript.py"]
+
+    def test_java_file(self):
+        from assignment_codeval.evaluate import _extract_source_files_from_compile
+        assert _extract_source_files_from_compile("javac MyClass.java") == ["MyClass.java"]
+
+    def test_skips_output_flag_value(self):
+        """The value after -o should not be treated as a source file."""
+        from assignment_codeval.evaluate import _extract_source_files_from_compile
+        result = _extract_source_files_from_compile("cc -o mycalc.exe mycalc.c")
+        assert "mycalc.exe" not in result
+        assert "mycalc.c" in result
+
+    def test_empty_command(self):
+        from assignment_codeval.evaluate import _extract_source_files_from_compile
+        assert _extract_source_files_from_compile("") == []
+
+
+# ---------------------------------------------------------------------------
+# CF / NCF no-filename path (check_function / check_not_function)
+# ---------------------------------------------------------------------------
+
+class TestCheckFunctionNoFilename:
+    """check_function and check_not_function infer source files from last_compile_command."""
+
+    @pytest.mark.skipif(not HAS_GPP_OBJDUMP, reason="g++ or objdump not available")
+    def test_cf_no_filename_detects_used_function(self, capsys):
+        import assignment_codeval.evaluate as ev
+        with tempfile.TemporaryDirectory() as tmpdir:
+            src = os.path.join(tmpdir, "sample.cpp")
+            exe = os.path.join(tmpdir, "sample")
+            with open(src, "w") as f:
+                f.write(CPP_SOURCE)
+            subprocess.run(["g++", "-o", exe, src], check=True, capture_output=True)
+            old_cmd = ev.last_compile_command
+            old_cwd = os.getcwd()
+            try:
+                os.chdir(tmpdir)
+                ev.last_compile_command = f"g++ -o sample sample.cpp"
+                ev.test_case_count = 0
+                ev.check_function("greet")
+            finally:
+                ev.last_compile_command = old_cmd
+                os.chdir(old_cwd)
+        captured = capsys.readouterr()
+        assert "PASSED" in captured.out
+
+    @pytest.mark.skipif(not HAS_GPP_OBJDUMP, reason="g++ or objdump not available")
+    def test_cf_no_filename_fails_for_unused_function(self, capsys):
+        import assignment_codeval.evaluate as ev
+        with tempfile.TemporaryDirectory() as tmpdir:
+            src = os.path.join(tmpdir, "sample.cpp")
+            exe = os.path.join(tmpdir, "sample")
+            with open(src, "w") as f:
+                f.write(CPP_SOURCE)
+            subprocess.run(["g++", "-o", exe, src], check=True, capture_output=True)
+            old_cmd = ev.last_compile_command
+            old_cwd = os.getcwd()
+            try:
+                os.chdir(tmpdir)
+                ev.last_compile_command = f"g++ -o sample sample.cpp"
+                ev.test_case_count = 0
+                ev.check_function("forbidden_func")
+            finally:
+                ev.last_compile_command = old_cmd
+                os.chdir(old_cwd)
+        captured = capsys.readouterr()
+        assert "FAILED" in captured.out
+
+    def test_cf_no_filename_python_detects_used_function(self, capsys):
+        """Python uses ast — no compiled artifact needed; no-filename path works."""
+        import assignment_codeval.evaluate as ev
+        with tempfile.TemporaryDirectory() as tmpdir:
+            src = os.path.join(tmpdir, "myscript.py")
+            with open(src, "w") as f:
+                f.write("print('hello')\nlen([1, 2])\n")
+            old_cmd = ev.last_compile_command
+            old_cwd = os.getcwd()
+            try:
+                os.chdir(tmpdir)
+                ev.last_compile_command = "python3 -m py_compile myscript.py"
+                ev.test_case_count = 0
+                ev.check_function("print")
+            finally:
+                ev.last_compile_command = old_cmd
+                os.chdir(old_cwd)
+        captured = capsys.readouterr()
+        assert "PASSED" in captured.out
+
+    def test_cf_no_filename_python_fails_for_unused_function(self, capsys):
+        import assignment_codeval.evaluate as ev
+        with tempfile.TemporaryDirectory() as tmpdir:
+            src = os.path.join(tmpdir, "myscript.py")
+            with open(src, "w") as f:
+                f.write("print('hello')\n")
+            old_cmd = ev.last_compile_command
+            old_cwd = os.getcwd()
+            try:
+                os.chdir(tmpdir)
+                ev.last_compile_command = "python3 -m py_compile myscript.py"
+                ev.test_case_count = 0
+                ev.check_function("eval")
+            finally:
+                ev.last_compile_command = old_cmd
+                os.chdir(old_cwd)
+        captured = capsys.readouterr()
+        assert "FAILED" in captured.out
+
+    def test_ncf_no_filename_python(self, capsys):
+        """NCF without filename works for Python via the ast path."""
+        import assignment_codeval.evaluate as ev
+        with tempfile.TemporaryDirectory() as tmpdir:
+            src = os.path.join(tmpdir, "myscript.py")
+            with open(src, "w") as f:
+                f.write("print('hello')\n")
+            old_cmd = ev.last_compile_command
+            old_cwd = os.getcwd()
+            try:
+                os.chdir(tmpdir)
+                ev.last_compile_command = "python3 -m py_compile myscript.py"
+                ev.test_case_count = 0
+                ev.check_not_function("eval")
+            finally:
+                ev.last_compile_command = old_cmd
+                os.chdir(old_cwd)
+        captured = capsys.readouterr()
+        assert "PASSED" in captured.out

assignment_codeval-0.0.29/tests/test_function_detection.py

@@ -1,195 +0,0 @@
-"""Unit tests for CF/NCF function detection helpers.
-
-Tests the three detection paths introduced in evaluate.py:
-  - C/C++:  objdump -t on compiled artifact
-  - Java:   javap -c on .class file
-  - Python: ast module on source
-
-C++ and Java tests are skipped automatically when the required tools
-are not available (e.g. on macOS without a full JDK install).
-"""
-
-import os
-import shutil
-import subprocess
-import tempfile
-
-import pytest
-
-
-# ---------------------------------------------------------------------------
-# Tool availability guards
-# ---------------------------------------------------------------------------
-
-def _tool_works(*cmd):
-    """Return True if cmd exits with code 0."""
-    try:
-        result = subprocess.run(list(cmd), capture_output=True, timeout=10)
-        return result.returncode == 0
-    except (FileNotFoundError, subprocess.TimeoutExpired):
-        return False
-
-
-HAS_GPP_OBJDUMP = (
-    shutil.which("g++") is not None
-    and shutil.which("objdump") is not None
-    and _tool_works("g++", "--version")
-)
-
-HAS_JAVA = _tool_works("javac", "--version") and _tool_works("javap", "-version")
-
-
-# ---------------------------------------------------------------------------
-# C++ — objdump path
-# ---------------------------------------------------------------------------
-
-CPP_SOURCE = """\
-#include <iostream>
-void greet() { std::cout << "Hello World" << std::endl; }
-int main() { greet(); return 0; }
-"""
-
-
-@pytest.mark.skipif(not HAS_GPP_OBJDUMP, reason="g++ or objdump not available")
-class TestCppFunctionDetection:
-    """_function_used_in_c_cpp uses objdump -t on the compiled artifact."""
-
-    def setup_method(self):
-        self.tmpdir = tempfile.mkdtemp()
-        self.src = os.path.join(self.tmpdir, "sample.cpp")
-        self.exe = os.path.join(self.tmpdir, "sample")
-        with open(self.src, "w") as f:
-            f.write(CPP_SOURCE)
-        subprocess.run(
-            ["g++", "-o", self.exe, self.src],
-            check=True,
-            capture_output=True,
-        )
-
-    def teardown_method(self):
-        shutil.rmtree(self.tmpdir, ignore_errors=True)
-
-    def test_detects_used_function(self):
-        from assignment_codeval.evaluate import _function_used_in_c_cpp
-        assert _function_used_in_c_cpp("greet", [self.src]) is True
-
-    def test_returns_false_for_unused_function(self):
-        from assignment_codeval.evaluate import _function_used_in_c_cpp
-        assert _function_used_in_c_cpp("forbidden_func", [self.src]) is False
-
-    def test_returns_none_when_no_artifact(self):
-        """No compiled artifact → caller should fall back to regex."""
-        from assignment_codeval.evaluate import _function_used_in_c_cpp
-        with tempfile.TemporaryDirectory() as tmpdir:
-            src = os.path.join(tmpdir, "uncompiled.cpp")
-            with open(src, "w") as f:
-                f.write("int main() { return 0; }\n")
-            assert _function_used_in_c_cpp("greet", [src]) is None
-
-
-# ---------------------------------------------------------------------------
-# Java — javap path
-# ---------------------------------------------------------------------------
-
-JAVA_SOURCE = """\
-public class SampleCfDetect {
-    public static void greet() { System.out.println("Hello World"); }
-    public static void main(String[] args) { greet(); }
-}
-"""
-
-
-@pytest.mark.skipif(not HAS_JAVA, reason="javac or javap not available")
-class TestJavaFunctionDetection:
-    """_function_used_in_java uses javap -c on the compiled .class file."""
-
-    def setup_method(self):
-        self.tmpdir = tempfile.mkdtemp()
-        self.src = os.path.join(self.tmpdir, "SampleCfDetect.java")
-        with open(self.src, "w") as f:
-            f.write(JAVA_SOURCE)
-        subprocess.run(
-            ["javac", self.src],
-            check=True,
-            capture_output=True,
-            cwd=self.tmpdir,
-        )
-
-    def teardown_method(self):
-        shutil.rmtree(self.tmpdir, ignore_errors=True)
-
-    def test_detects_used_method(self):
-        from assignment_codeval.evaluate import _function_used_in_java
-        assert _function_used_in_java("greet", [self.src]) is True
-
-    def test_returns_false_for_unused_method(self):
-        from assignment_codeval.evaluate import _function_used_in_java
-        assert _function_used_in_java("forbidden_func", [self.src]) is False
-
-    def test_returns_none_when_no_class_file(self):
-        """No .class file → caller should fall back to regex."""
-        from assignment_codeval.evaluate import _function_used_in_java
-        with tempfile.TemporaryDirectory() as tmpdir:
-            src = os.path.join(tmpdir, "Uncompiled.java")
-            with open(src, "w") as f:
-                f.write(
-                    "public class Uncompiled { public static void main(String[] a) {} }\n"
-                )
-            assert _function_used_in_java("greet", [src]) is None
-
-
-# ---------------------------------------------------------------------------
-# Python — ast path
-# ---------------------------------------------------------------------------
-
-class TestPythonFunctionDetection:
-    """_function_used_in_python uses the ast module; no external tools needed."""
-
-    def _write_source(self, code):
-        f = tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False)
-        f.write(code)
-        f.close()
-        return f.name
-
-    def test_detects_direct_call(self):
-        from assignment_codeval.evaluate import _function_used_in_python
-        fname = self._write_source("print('hello')\nlen([1, 2])\n")
-        try:
-            assert _function_used_in_python("print", [fname]) is True
-            assert _function_used_in_python("len", [fname]) is True
-        finally:
-            os.unlink(fname)
-
-    def test_detects_attribute_call(self):
-        from assignment_codeval.evaluate import _function_used_in_python
-        fname = self._write_source("items = []\nitems.append(1)\n")
-        try:
-            assert _function_used_in_python("append", [fname]) is True
-        finally:
-            os.unlink(fname)
-
-    def test_returns_false_for_unused_function(self):
-        from assignment_codeval.evaluate import _function_used_in_python
-        fname = self._write_source("print('hello')\n")
-        try:
-            assert _function_used_in_python("eval", [fname]) is False
-        finally:
-            os.unlink(fname)
-
-    def test_ignores_function_name_in_string(self):
-        """A function name that only appears inside a string is not a call."""
-        from assignment_codeval.evaluate import _function_used_in_python
-        fname = self._write_source('x = "eval is dangerous"\n')
-        try:
-            assert _function_used_in_python("eval", [fname]) is False
-        finally:
-            os.unlink(fname)
-
-    def test_ignores_function_name_in_comment(self):
-        """A function name that only appears in a comment is not a call."""
-        from assignment_codeval.evaluate import _function_used_in_python
-        fname = self._write_source("# eval would be bad here\nx = 1\n")
-        try:
-            assert _function_used_in_python("eval", [fname]) is False
-        finally:
-            os.unlink(fname)