- test_unused_helper_revert.py

from __future__ import annotations

import ast
import sys
from collections import defaultdict
from pathlib import Path
from types import SimpleNamespace

# imports
import pytest
from codeflash.cli_cmds.console import logger
from codeflash.context.unused_definition_remover import \
    detect_unused_helper_functions
from codeflash.models.models import CodeOptimizationContext, FunctionSource


# FunctionSource and CodeOptimizationContext mocks for testing
class FunctionSource:
    def __init__(
        self,
        only_function_name,
        qualified_name,
        fully_qualified_name,
        file_path,
        jedi_definition,
    ):
        self.only_function_name = only_function_name
        self.qualified_name = qualified_name
        self.fully_qualified_name = fully_qualified_name
        self.file_path = Path(file_path)
        self.jedi_definition = jedi_definition

class JediDef:
    def __init__(self, type_):
        self.type = type_

class CodeOptimizationContext:
    def __init__(self, helper_functions):
        self.helper_functions = helper_functions
from codeflash.context.unused_definition_remover import \
    detect_unused_helper_functions


# Helper for test function_to_optimize
class EntrypointFunction:
    def __init__(self, function_name, file_path, parents=None):
        self.function_name = function_name
        self.file_path = Path(file_path)
        self.parents = parents if parents is not None else []

# -------------------------- UNIT TESTS --------------------------

# BASIC TESTS

def test_no_helpers():
    """No helper functions: should return empty list."""
    ctx = CodeOptimizationContext(helper_functions=[])
    entry = EntrypointFunction("main", "main.py")
    code = "def main():\n    pass"
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_one_helper_used():
    """One helper function, used in entrypoint."""
    helper = FunctionSource(
        only_function_name="helper",
        qualified_name="helper",
        fully_qualified_name="main.helper",
        file_path="main.py",
        jedi_definition=JediDef("function"),
    )
    ctx = CodeOptimizationContext([helper])
    entry = EntrypointFunction("main", "main.py")
    code = "def helper(): pass\ndef main():\n    helper()"
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_one_helper_unused():
    """One helper function, not used in entrypoint."""
    helper = FunctionSource(
        only_function_name="helper",
        qualified_name="helper",
        fully_qualified_name="main.helper",
        file_path="main.py",
        jedi_definition=JediDef("function"),
    )
    ctx = CodeOptimizationContext([helper])
    entry = EntrypointFunction("main", "main.py")
    code = "def helper(): pass\ndef main():\n    pass"
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_multiple_helpers_some_unused():
    """Multiple helpers, some used, some unused."""
    h1 = FunctionSource("h1", "h1", "main.h1", "main.py", JediDef("function"))
    h2 = FunctionSource("h2", "h2", "main.h2", "main.py", JediDef("function"))
    h3 = FunctionSource("h3", "h3", "main.h3", "main.py", JediDef("function"))
    ctx = CodeOptimizationContext([h1, h2, h3])
    entry = EntrypointFunction("main", "main.py")
    code = "def h1(): pass\ndef h2(): pass\ndef h3(): pass\ndef main():\n    h2()"
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_helper_called_by_qualified_name():
    """Helper called as module.function (cross-file)."""
    helper = FunctionSource(
        only_function_name="foo",
        qualified_name="foo",
        fully_qualified_name="utils.foo",
        file_path="utils.py",
        jedi_definition=JediDef("function"),
    )
    ctx = CodeOptimizationContext([helper])
    entry = EntrypointFunction("main", "main.py")
    code = (
        "import utils\n"
        "def main():\n"
        "    utils.foo()"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_helper_imported_from():
    """Helper imported with 'from module import func' and called."""
    helper = FunctionSource(
        only_function_name="foo",
        qualified_name="foo",
        fully_qualified_name="utils.foo",
        file_path="utils.py",
        jedi_definition=JediDef("function"),
    )
    ctx = CodeOptimizationContext([helper])
    entry = EntrypointFunction("main", "main.py")
    code = (
        "from utils import foo\n"
        "def main():\n"
        "    foo()"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_helper_imported_with_as():
    """Helper imported with 'from module import func as alias' and called by alias."""
    helper = FunctionSource(
        only_function_name="foo",
        qualified_name="foo",
        fully_qualified_name="utils.foo",
        file_path="utils.py",
        jedi_definition=JediDef("function"),
    )
    ctx = CodeOptimizationContext([helper])
    entry = EntrypointFunction("main", "main.py")
    code = (
        "from utils import foo as bar\n"
        "def main():\n"
        "    bar()"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_helper_imported_module_as():
    """Helper imported with 'import module as m' and called as m.func()."""
    helper = FunctionSource(
        only_function_name="foo",
        qualified_name="foo",
        fully_qualified_name="utils.foo",
        file_path="utils.py",
        jedi_definition=JediDef("function"),
    )
    ctx = CodeOptimizationContext([helper])
    entry = EntrypointFunction("main", "main.py")
    code = (
        "import utils as ut\n"
        "def main():\n"
        "    ut.foo()"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

# EDGE CASES

def test_entrypoint_not_found():
    """Entrypoint function not present in optimized code."""
    helper = FunctionSource(
        only_function_name="helper",
        qualified_name="helper",
        fully_qualified_name="main.helper",
        file_path="main.py",
        jedi_definition=JediDef("function"),
    )
    ctx = CodeOptimizationContext([helper])
    entry = EntrypointFunction("main", "main.py")
    code = "def not_main(): pass"
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_helper_is_class_should_ignore():
    """Helper with type 'class' should not be reported as unused."""
    helper = FunctionSource(
        only_function_name="HelperClass",
        qualified_name="HelperClass",
        fully_qualified_name="main.HelperClass",
        file_path="main.py",
        jedi_definition=JediDef("class"),
    )
    ctx = CodeOptimizationContext([helper])
    entry = EntrypointFunction("main", "main.py")
    code = "class HelperClass: pass\ndef main(): pass"
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_helper_called_by_fully_qualified_name():
    """Helper called by fully qualified name."""
    helper = FunctionSource(
        only_function_name="foo",
        qualified_name="foo",
        fully_qualified_name="utils.foo",
        file_path="utils.py",
        jedi_definition=JediDef("function"),
    )
    ctx = CodeOptimizationContext([helper])
    entry = EntrypointFunction("main", "main.py")
    code = (
        "from utils import foo\n"
        "def main():\n"
        "    utils.foo()"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_helper_with_similar_names():
    """Helpers with similar names, only the correct one is called."""
    h1 = FunctionSource("foo", "foo", "main.foo", "main.py", JediDef("function"))
    h2 = FunctionSource("foobar", "foobar", "main.foobar", "main.py", JediDef("function"))
    ctx = CodeOptimizationContext([h1, h2])
    entry = EntrypointFunction("main", "main.py")
    code = "def foo(): pass\ndef foobar(): pass\ndef main():\n    foo()"
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_helper_called_as_method_of_self():
    """Helper called as self.helper() in a class."""
    class Parent:
        name = "MyClass"
    helper = FunctionSource(
        only_function_name="helper",
        qualified_name="helper",
        fully_qualified_name="main.helper",
        file_path="main.py",
        jedi_definition=JediDef("function"),
    )
    ctx = CodeOptimizationContext([helper])
    entry = EntrypointFunction("main", "main.py", parents=[Parent()])
    code = (
        "class MyClass:\n"
        "    def helper(self): pass\n"
        "    def main(self):\n"
        "        self.helper()"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_helper_called_as_class_method():
    """Helper called as ClassName.helper() in a class."""
    class Parent:
        name = "MyClass"
    helper = FunctionSource(
        only_function_name="helper",
        qualified_name="helper",
        fully_qualified_name="main.helper",
        file_path="main.py",
        jedi_definition=JediDef("function"),
    )
    ctx = CodeOptimizationContext([helper])
    entry = EntrypointFunction("main", "main.py", parents=[Parent()])
    code = (
        "class MyClass:\n"
        "    @classmethod\n"
        "    def helper(cls): pass\n"
        "    def main(self):\n"
        "        MyClass.helper()"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_helper_not_called_but_called_in_other_func():
    """Helper called in another function, not in entrypoint."""
    helper = FunctionSource(
        only_function_name="foo",
        qualified_name="foo",
        fully_qualified_name="main.foo",
        file_path="main.py",
        jedi_definition=JediDef("function"),
    )
    ctx = CodeOptimizationContext([helper])
    entry = EntrypointFunction("main", "main.py")
    code = (
        "def foo(): pass\n"
        "def other(): foo()\n"
        "def main(): pass"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_helper_called_in_nested_call():
    """Helper called inside a nested call in entrypoint."""
    helper = FunctionSource(
        only_function_name="foo",
        qualified_name="foo",
        fully_qualified_name="main.foo",
        file_path="main.py",
        jedi_definition=JediDef("function"),
    )
    ctx = CodeOptimizationContext([helper])
    entry = EntrypointFunction("main", "main.py")
    code = (
        "def foo(): pass\n"
        "def main():\n"
        "    print(foo())"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_helper_called_multiple_times():
    """Helper called multiple times in entrypoint."""
    helper = FunctionSource(
        only_function_name="foo",
        qualified_name="foo",
        fully_qualified_name="main.foo",
        file_path="main.py",
        jedi_definition=JediDef("function"),
    )
    ctx = CodeOptimizationContext([helper])
    entry = EntrypointFunction("main", "main.py")
    code = (
        "def foo(): pass\n"
        "def main():\n"
        "    foo()\n"
        "    foo()"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

# LARGE SCALE TESTS

def test_many_helpers_some_unused():
    """Test with a large number of helpers, only a few used."""
    helpers = []
    for i in range(100):
        helpers.append(FunctionSource(
            only_function_name=f"helper_{i}",
            qualified_name=f"helper_{i}",
            fully_qualified_name=f"main.helper_{i}",
            file_path="main.py",
            jedi_definition=JediDef("function"),
        ))
    ctx = CodeOptimizationContext(helpers)
    entry = EntrypointFunction("main", "main.py")
    used = [0, 10, 50, 99]
    code = "def main():\n" + "\n".join([f"    helper_{i}()" for i in used])
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output
    unused = set(helpers) - {helpers[i] for i in used}

def test_many_helpers_all_used():
    """Test with a large number of helpers, all used."""
    helpers = []
    for i in range(200):
        helpers.append(FunctionSource(
            only_function_name=f"helper_{i}",
            qualified_name=f"helper_{i}",
            fully_qualified_name=f"main.helper_{i}",
            file_path="main.py",
            jedi_definition=JediDef("function"),
        ))
    ctx = CodeOptimizationContext(helpers)
    entry = EntrypointFunction("main", "main.py")
    code = "def main():\n" + "\n".join([f"    helper_{i}()" for i in range(200)])
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output

def test_large_cross_file_helpers():
    """Test with many helpers, some in another file, called via import."""
    helpers = []
    for i in range(50):
        helpers.append(FunctionSource(
            only_function_name=f"foo_{i}",
            qualified_name=f"foo_{i}",
            fully_qualified_name=f"utils.foo_{i}",
            file_path="utils.py",
            jedi_definition=JediDef("function"),
        ))
    ctx = CodeOptimizationContext(helpers)
    entry = EntrypointFunction("main", "main.py")
    code = "import utils\n" + "def main():\n" + "\n".join([f"    utils.foo_{i}()" for i in range(0, 50, 2)])
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output
    used = {helpers[i] for i in range(0, 50, 2)}
    unused = set(helpers) - used

def test_large_imported_from_helpers():
    """Test with many helpers imported using 'from utils import ...'."""
    helpers = []
    for i in range(30):
        helpers.append(FunctionSource(
            only_function_name=f"bar_{i}",
            qualified_name=f"bar_{i}",
            fully_qualified_name=f"utils.bar_{i}",
            file_path="utils.py",
            jedi_definition=JediDef("function"),
        ))
    ctx = CodeOptimizationContext(helpers)
    entry = EntrypointFunction("main", "main.py")
    import_line = "from utils import " + ", ".join([f"bar_{i}" for i in range(0, 30, 3)])
    code = import_line + "\ndef main():\n" + "\n".join([f"    bar_{i}()" for i in range(0, 30, 3)])
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output
    used = {helpers[i] for i in range(0, 30, 3)}
    unused = set(helpers) - used

def test_large_unused_helpers():
    """Test with many helpers, none used."""
    helpers = []
    for i in range(100):
        helpers.append(FunctionSource(
            only_function_name=f"unused_{i}",
            qualified_name=f"unused_{i}",
            fully_qualified_name=f"main.unused_{i}",
            file_path="main.py",
            jedi_definition=JediDef("function"),
        ))
    ctx = CodeOptimizationContext(helpers)
    entry = EntrypointFunction("main", "main.py")
    code = "def main():\n    pass"
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); result = codeflash_output
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from __future__ import annotations

import ast
import types
from collections import defaultdict
from pathlib import Path

# imports
import pytest
from codeflash.cli_cmds.console import logger
from codeflash.context.unused_definition_remover import \
    detect_unused_helper_functions
from codeflash.models.models import CodeOptimizationContext, FunctionSource

# ---- MOCKS ----

class DummyJediDef:
    def __init__(self, type_):
        self.type = type_

class DummyFunctionSource:
    def __init__(
        self,
        only_function_name,
        qualified_name=None,
        fully_qualified_name=None,
        file_path=None,
        jedi_type="function",
        parents=None
    ):
        self.only_function_name = only_function_name
        self.qualified_name = qualified_name or only_function_name
        self.fully_qualified_name = fully_qualified_name or only_function_name
        self.file_path = file_path or Path("main.py")
        self.jedi_definition = DummyJediDef(jedi_type)
        self.parents = parents or []

class DummyClassDef:
    def __init__(self, name):
        self.name = name

class DummyCodeOptimizationContext:
    def __init__(self, helper_functions):
        self.helper_functions = helper_functions

# ---- TESTS ----

# 1. BASIC TEST CASES

def test_no_helpers():
    # No helper functions at all
    entry = DummyFunctionSource("main_func")
    ctx = DummyCodeOptimizationContext([])
    code = "def main_func():\n    return 42"
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_all_helpers_used():
    # All helpers are called directly
    h1 = DummyFunctionSource("foo")
    h2 = DummyFunctionSource("bar")
    entry = DummyFunctionSource("main_func")
    ctx = DummyCodeOptimizationContext([h1, h2])
    code = (
        "def main_func():\n"
        "    foo()\n"
        "    bar()\n"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_some_helpers_unused():
    # Only one helper is called
    h1 = DummyFunctionSource("foo")
    h2 = DummyFunctionSource("bar")
    entry = DummyFunctionSource("main_func")
    ctx = DummyCodeOptimizationContext([h1, h2])
    code = (
        "def main_func():\n"
        "    foo()\n"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_helper_called_by_qualified_name():
    # Helper is called as module.function
    h1 = DummyFunctionSource("foo", file_path=Path("helpers.py"))
    entry = DummyFunctionSource("main_func", file_path=Path("main.py"))
    ctx = DummyCodeOptimizationContext([h1])
    code = (
        "import helpers\n"
        "def main_func():\n"
        "    helpers.foo()\n"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_helper_called_by_from_import():
    # Helper is called as imported name
    h1 = DummyFunctionSource("foo", file_path=Path("helpers.py"))
    entry = DummyFunctionSource("main_func", file_path=Path("main.py"))
    ctx = DummyCodeOptimizationContext([h1])
    code = (
        "from helpers import foo\n"
        "def main_func():\n"
        "    foo()\n"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_helper_imported_as_alias():
    # Helper is imported as alias and called
    h1 = DummyFunctionSource("foo", file_path=Path("helpers.py"))
    entry = DummyFunctionSource("main_func", file_path=Path("main.py"))
    ctx = DummyCodeOptimizationContext([h1])
    code = (
        "from helpers import foo as bar\n"
        "def main_func():\n"
        "    bar()\n"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_unused_helper_with_import():
    # Helper is imported but not called
    h1 = DummyFunctionSource("foo", file_path=Path("helpers.py"))
    entry = DummyFunctionSource("main_func", file_path=Path("main.py"))
    ctx = DummyCodeOptimizationContext([h1])
    code = (
        "from helpers import foo\n"
        "def main_func():\n"
        "    pass\n"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

# 2. EDGE TEST CASES

def test_entrypoint_not_found():
    # Entrypoint function missing from code
    h1 = DummyFunctionSource("foo")
    entry = DummyFunctionSource("main_func")
    ctx = DummyCodeOptimizationContext([h1])
    code = "def not_main_func():\n    foo()"
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_helper_is_class_not_function():
    # Helper is a class, not a function, should not be reported
    h1 = DummyFunctionSource("Foo", jedi_type="class")
    entry = DummyFunctionSource("main_func")
    ctx = DummyCodeOptimizationContext([h1])
    code = "def main_func():\n    pass"
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_helper_called_as_method_of_self():
    # Helper is called as self.method() and is a method of a class
    parent = DummyClassDef("MyClass")
    h1 = DummyFunctionSource("foo", qualified_name="MyClass.foo", parents=[parent])
    entry = DummyFunctionSource("main_func", parents=[parent])
    ctx = DummyCodeOptimizationContext([h1])
    code = (
        "class MyClass:\n"
        "    def main_func(self):\n"
        "        self.foo()\n"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_helper_called_as_class_method():
    # Helper is called as ClassName.method()
    parent = DummyClassDef("MyClass")
    h1 = DummyFunctionSource("foo", qualified_name="MyClass.foo", parents=[parent])
    entry = DummyFunctionSource("main_func", parents=[parent])
    ctx = DummyCodeOptimizationContext([h1])
    code = (
        "class MyClass:\n"
        "    def main_func(self):\n"
        "        MyClass.foo(self)\n"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_helper_called_as_nested_attribute():
    # Helper called as obj.attr.foo()
    h1 = DummyFunctionSource("foo")
    entry = DummyFunctionSource("main_func")
    ctx = DummyCodeOptimizationContext([h1])
    code = (
        "def main_func():\n"
        "    obj.attr.foo()\n"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_helper_with_same_name_in_multiple_files():
    # Two helpers with same name in different files, only one is used
    h1 = DummyFunctionSource("foo", file_path=Path("helpers1.py"))
    h2 = DummyFunctionSource("foo", file_path=Path("helpers2.py"))
    entry = DummyFunctionSource("main_func", file_path=Path("main.py"))
    ctx = DummyCodeOptimizationContext([h1, h2])
    code = (
        "import helpers1\n"
        "def main_func():\n"
        "    helpers1.foo()\n"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_helper_called_by_fully_qualified_name():
    # Helper is called by its fully qualified name
    h1 = DummyFunctionSource("foo", qualified_name="helpers.foo", fully_qualified_name="helpers.foo", file_path=Path("helpers.py"))
    entry = DummyFunctionSource("main_func", file_path=Path("main.py"))
    ctx = DummyCodeOptimizationContext([h1])
    code = (
        "import helpers\n"
        "def main_func():\n"
        "    helpers.foo()\n"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_helper_with_asname_import_and_call():
    # Helper imported as alias and called as module alias
    h1 = DummyFunctionSource("foo", file_path=Path("helpers.py"))
    entry = DummyFunctionSource("main_func", file_path=Path("main.py"))
    ctx = DummyCodeOptimizationContext([h1])
    code = (
        "import helpers as hp\n"
        "def main_func():\n"
        "    hp.foo()\n"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_helper_called_within_nested_function():
    # Helper is called from a nested function inside entrypoint
    h1 = DummyFunctionSource("foo")
    entry = DummyFunctionSource("main_func")
    ctx = DummyCodeOptimizationContext([h1])
    code = (
        "def main_func():\n"
        "    def inner():\n"
        "        foo()\n"
        "    inner()\n"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_helper_with_non_ascii_names():
    # Helper with non-ascii name
    h1 = DummyFunctionSource("föö")
    entry = DummyFunctionSource("main_func")
    ctx = DummyCodeOptimizationContext([h1])
    code = (
        "def main_func():\n"
        "    föö()\n"
    )
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

# 3. LARGE SCALE TEST CASES

def test_large_number_of_helpers_all_used():
    # 100 helpers, all are called
    helpers = [DummyFunctionSource(f"foo{i}") for i in range(100)]
    entry = DummyFunctionSource("main_func")
    ctx = DummyCodeOptimizationContext(helpers)
    code = "def main_func():\n" + "".join([f"    foo{i}()\n" for i in range(100)])
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_large_number_of_helpers_half_unused():
    # 100 helpers, only even ones are called
    helpers = [DummyFunctionSource(f"foo{i}") for i in range(100)]
    entry = DummyFunctionSource("main_func")
    ctx = DummyCodeOptimizationContext(helpers)
    code = "def main_func():\n" + "".join([f"    foo{i}()\n" for i in range(0,100,2)])
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output
    expected_unused = [helpers[i] for i in range(1,100,2)]

def test_large_number_of_helpers_with_imports():
    # 100 helpers, all in helpers.py, called as helpers.fooX()
    helpers = [DummyFunctionSource(f"foo{i}", file_path=Path("helpers.py")) for i in range(100)]
    entry = DummyFunctionSource("main_func", file_path=Path("main.py"))
    ctx = DummyCodeOptimizationContext(helpers)
    code = "import helpers\n" + "def main_func():\n" + "".join([f"    helpers.foo{i}()\n" for i in range(100)])
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_large_number_of_helpers_with_partial_imports():
    # 100 helpers, only foo0..foo49 are called as helpers.fooX()
    helpers = [DummyFunctionSource(f"foo{i}", file_path=Path("helpers.py")) for i in range(100)]
    entry = DummyFunctionSource("main_func", file_path=Path("main.py"))
    ctx = DummyCodeOptimizationContext(helpers)
    code = "import helpers\n" + "def main_func():\n" + "".join([f"    helpers.foo{i}()\n" for i in range(50)])
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output
    expected_unused = [helpers[i] for i in range(50,100)]

def test_large_number_of_helpers_with_from_imports():
    # 100 helpers, imported via from helpers import foo0, ..., foo99, all called
    helpers = [DummyFunctionSource(f"foo{i}", file_path=Path("helpers.py")) for i in range(100)]
    entry = DummyFunctionSource("main_func", file_path=Path("main.py"))
    ctx = DummyCodeOptimizationContext(helpers)
    import_line = "from helpers import " + ", ".join([f"foo{i}" for i in range(100)]) + "\n"
    code = import_line + "def main_func():\n" + "".join([f"    foo{i}()\n" for i in range(100)])
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_large_number_of_helpers_with_alias_imports():
    # 100 helpers, imported via from helpers import fooX as barX, all called as barX
    helpers = [DummyFunctionSource(f"foo{i}", file_path=Path("helpers.py")) for i in range(100)]
    entry = DummyFunctionSource("main_func", file_path=Path("main.py"))
    ctx = DummyCodeOptimizationContext(helpers)
    import_line = "from helpers import " + ", ".join([f"foo{i} as bar{i}" for i in range(100)]) + "\n"
    code = import_line + "def main_func():\n" + "".join([f"    bar{i}()\n" for i in range(100)])
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output

def test_large_number_of_helpers_with_random_usage():
    # 100 helpers, randomly called
    import random
    random.seed(0)
    helpers = [DummyFunctionSource(f"foo{i}", file_path=Path("helpers.py")) for i in range(100)]
    used_indices = set(random.sample(range(100), 60))
    entry = DummyFunctionSource("main_func", file_path=Path("main.py"))
    ctx = DummyCodeOptimizationContext(helpers)
    code = "import helpers\n" + "def main_func():\n" + "".join([f"    helpers.foo{i}()\n" for i in used_indices])
    codeflash_output = detect_unused_helper_functions(entry, ctx, code); unused = codeflash_output
    expected_unused = [helpers[i] for i in range(100) if i not in used_indices]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.