⚡️ Speed up method JavaImportResolver._is_external_library by 148% in PR #1199 (omni-java)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1199

If you approve this dependent PR, these changes will be merged into the original PR branch omni-java.

This PR will be automatically closed if the original PR is merged.

---

📄 148% (1.48x) speedup for JavaImportResolver._is_external_library in codeflash/languages/java/import_resolver.py

⏱️ Runtime : 584 microseconds → 236 microseconds (best of 177 runs)

📝 Explanation and details

The optimized code achieves a 147% speedup (from 584μs to 236μs) by introducing two key optimizations:

1. Caching Previously-Seen Results
The optimization adds self._external_library_cache: dict[str, bool] to memoize results of previous _is_external_library calls. This is particularly effective because:

• Java projects often check the same imports repeatedly across multiple files
• The test results show dramatic speedups for repeated checks: 610% faster for external packages and 704% faster for internal packages when called 100 times
• Even single calls benefit from cache hits when the same package is checked multiple times during analysis

2. Set-Based Membership Tests Instead of Linear String Scanning
The original code used for prefix in self.COMMON_EXTERNAL_PREFIXES with startswith() checks, performing linear iteration and string concatenation (prefix + ".") on every call. The optimization:

• Converts COMMON_EXTERNAL_PREFIXES to frozenset for O(1) membership tests
• Builds package prefixes incrementally ("org" → "org.apache" → "org.apache.commons") and checks each against the set
• Eliminates repeated string concatenations in the hot loop (the line profiler shows the original prefix + "." operation consumed 61.7% of total time)

Performance Characteristics by Test Case:

• Exact prefix matches: 100-380% faster (e.g., "org.apache", "lombok") due to early set lookup
• Short dotted paths: 20-60% faster for 2-3 segment packages
• Nested paths with cache misses: Slightly slower (up to 71%) on first call due to prefix-building overhead, but subsequent calls are 100%+ faster via caching
• Batch operations: 38-88% faster when processing many similar packages, demonstrating cache effectiveness

The optimization is especially valuable in real-world scenarios where:

• Import resolution happens across multiple files in a project (cache hits accumulate)
• Common frameworks like Spring, JUnit, or Apache Commons are heavily used (high cache hit rate)
• The resolver is called repeatedly during code analysis or build processes

The trade-off is minimal: slightly increased memory usage for the cache (proportional to unique imports seen) and marginal first-call overhead for deeply nested external packages, both negligible compared to the massive gains in repeated-check scenarios.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 412 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Click to see Generated Regression Tests

from pathlib import Path  # to construct a project root path for the resolver
from typing import List

import codeflash.languages.java.import_resolver as import_resolver_module
# imports
import pytest  # used for our unit tests
from codeflash.languages.java.import_resolver import JavaImportResolver

# NOTE: JavaImportResolver.__init__ calls functions that were imported at module
# import time (get_project_info, find_source_root, find_test_root). To avoid
# unpredictable file system interactions during instantiation, we patch those
# names inside the import_resolver module to stable, side-effect-free callables.
# We use the pytest monkeypatch fixture in each test to ensure isolation and to
# avoid modifying the function under test (_is_external_library).

def _patch_discovery_to_none(monkeypatch):
    """
    Helper to set discovery functions to return None so that the resolver's
    _discover_roots logic falls back without touching the file system.
    This patches the names inside the imported module (where the class looks them up).
    """
    monkeypatch.setattr(import_resolver_module, "get_project_info", lambda project_root: None)
    monkeypatch.setattr(import_resolver_module, "find_source_root", lambda project_root: None)
    monkeypatch.setattr(import_resolver_module, "find_test_root", lambda project_root: None)

def test_basic_external_and_internal_cases(monkeypatch):
    """
    Basic functionality: Confirm that imports with known common external prefixes
    are detected as external, and project-specific packages are considered internal.
    """
    # Ensure discovery doesn't perform file system work
    _patch_discovery_to_none(monkeypatch)

    # Create resolver instance with a temporary path; __init__ will run but discovery is patched.
    resolver = JavaImportResolver(Path("."))

    # Examples that should be flagged as external (prefix matches and dotted suffix)
    codeflash_output = resolver._is_external_library("org.junit.Assert") # 2.90μs -> 2.37μs (21.9% faster)
    codeflash_output = resolver._is_external_library("com.google.gson") # 481ns -> 1.16μs (58.6% slower)
    codeflash_output = resolver._is_external_library("lombok") # 1.29μs -> 511ns (153% faster)
    codeflash_output = resolver._is_external_library("lombok.experimental") # 1.29μs -> 732ns (76.5% faster)

    # Examples that should NOT be flagged as external (project-internal or unrelated)
    codeflash_output = resolver._is_external_library("com.mycompany.project.util") # 1.80μs -> 1.67μs (7.77% faster)
    codeflash_output = resolver._is_external_library("myorg.org.junit.fake") # 1.70μs -> 1.54μs (10.4% faster)

def test_edge_cases_substring_and_boundary_conditions(monkeypatch):
    """
    Edge cases around prefix boundaries:
    - A prefix that is a substring but not a dot-boundary should NOT match.
    - Exact prefix without trailing dot should match.
    - Empty string should return False (not an external library).
    """
    _patch_discovery_to_none(monkeypatch)
    resolver = JavaImportResolver(Path("."))

    # Should match when exactly equal to a known prefix
    codeflash_output = resolver._is_external_library("org.mockito") # 1.75μs -> 872ns (101% faster)

    # Should match when prefix is followed by a dot and more path
    codeflash_output = resolver._is_external_library("org.mockito.internal.stubbing") # 922ns -> 1.85μs (50.2% slower)

    # Should NOT match when the import starts with the prefix characters but is not the prefix
    # followed by a dot (e.g., 'org.mockitox' is not 'org.mockito' + '.' nor exact 'org.mockito')
    codeflash_output = resolver._is_external_library("org.mockitox.Foo") # 1.88μs -> 1.42μs (32.5% faster)
    codeflash_output = resolver._is_external_library("org.mockitoextra") # 1.61μs -> 982ns (64.3% faster)

    # Similar check for a prefix substring example
    codeflash_output = resolver._is_external_library("org.junitx.SomeTest") # 1.74μs -> 1.14μs (52.6% faster)

    # Empty import path should be safe and considered non-external
    codeflash_output = resolver._is_external_library("") # 1.68μs -> 931ns (80.8% faster)

def test_standard_java_packages_not_considered_by_this_method(monkeypatch):
    """
    Confirm current implementation's behavior with standard Java packages:
    - The class defines STANDARD_PACKAGES, but the actual method checks only
      COMMON_EXTERNAL_PREFIXES. This test documents and asserts that behavior.
    If implementation were changed to include STANDARD_PACKAGES, this test would fail,
    which is desired (mutation testing).
    """
    _patch_discovery_to_none(monkeypatch)
    resolver = JavaImportResolver(Path("."))

    # Even though 'java' is a standard package, the current method does not check STANDARD_PACKAGES.
    # So java.* should return False according to the present implementation.
    codeflash_output = resolver._is_external_library("java.util") # 2.84μs -> 2.05μs (38.1% faster)
    codeflash_output = resolver._is_external_library("javax.swing") # 1.93μs -> 1.19μs (62.1% faster)

    # For comparison, commons external prefixes should remain True
    codeflash_output = resolver._is_external_library("org.apache.commons.lang3") # 1.56μs -> 1.13μs (38.2% faster)

def test_prefix_boundary_similar_names(monkeypatch):
    """
    Test names that are similar to known prefixes to ensure only exact prefix or prefix+dot match.
    This protects against false positives where a package name starts with the same characters.
    """
    _patch_discovery_to_none(monkeypatch)
    resolver = JavaImportResolver(Path("."))

    # Known prefix matches
    codeflash_output = resolver._is_external_library("com.google") # 1.21μs -> 812ns (49.3% faster)
    codeflash_output = resolver._is_external_library("com.google.maps") # 521ns -> 1.80μs (71.1% slower)

    # Similar but different names should not match
    codeflash_output = resolver._is_external_library("com.googlex.maps") # 1.95μs -> 1.33μs (46.7% faster)
    codeflash_output = resolver._is_external_library("com.googleextra") # 1.70μs -> 941ns (81.0% faster)

    # Another known prefix
    codeflash_output = resolver._is_external_library("org.apache") # 1.54μs -> 321ns (381% faster)
    codeflash_output = resolver._is_external_library("org.apache.commons") # 1.46μs -> 1.14μs (28.0% faster)

    # Similar non-matching variants
    codeflash_output = resolver._is_external_library("org.apache2.utils") # 1.72μs -> 952ns (81.0% faster)
    codeflash_output = resolver._is_external_library("org.apachex") # 1.67μs -> 751ns (123% faster)

def test_large_scale_mixed_inputs(monkeypatch):
    """
    Large-scale test: generate a moderate number of import strings (500) mixing external
    and internal packages to verify correctness and scalability. We keep the number
    under 1000 items to respect test resource constraints.
    """
    _patch_discovery_to_none(monkeypatch)
    resolver = JavaImportResolver(Path("."))

    # Collect prefixes from the resolver to build test cases.
    # We convert the frozenset into a list to have deterministic ordering for expected counts.
    external_prefixes: List[str] = sorted(list(resolver.COMMON_EXTERNAL_PREFIXES))

    # Prepare 500 items: half should be external, half internal.
    NUM_ITEMS = 500
    half = NUM_ITEMS // 2

    inputs: List[str] = []
    expected_results: List[bool] = []

    # Create external examples using known prefixes with numeric suffixes
    for i in range(half):
        prefix = external_prefixes[i % len(external_prefixes)]
        if i % 2 == 0:
            # exact prefix occasionally
            imp = prefix
        else:
            # prefix + suffix
            imp = f"{prefix}.module{i}"
        inputs.append(imp)
        expected_results.append(True)

    # Create internal (non-external) examples under a company namespace
    for i in range(half):
        imp = f"com.mycompany.project.submodule{i}"
        inputs.append(imp)
        expected_results.append(False)

    # Run the checks and collect actual results
    actual_results = [resolver._is_external_library(imp) for imp in inputs]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from pathlib import Path

import pytest
from codeflash.languages.java.import_resolver import JavaImportResolver

class TestIsExternalLibraryBasic:
    """Basic test cases for JavaImportResolver._is_external_library function."""

    def test_exact_match_common_external_prefix(self):
        """Test that exact matches to known external prefixes are recognized as external."""
        resolver = JavaImportResolver(Path("/tmp"))
        # org.junit is in COMMON_EXTERNAL_PREFIXES
        codeflash_output = resolver._is_external_library("org.junit") # 3.23μs -> 932ns (246% faster)

    def test_prefixed_common_external_package(self):
        """Test that packages starting with known external prefixes are recognized as external."""
        resolver = JavaImportResolver(Path("/tmp"))
        # org.junit.* should be recognized as external
        codeflash_output = resolver._is_external_library("org.junit.framework") # 3.14μs -> 2.07μs (51.2% faster)

    def test_deeply_nested_external_package(self):
        """Test that deeply nested packages under external prefixes are recognized as external."""
        resolver = JavaImportResolver(Path("/tmp"))
        # org.apache.commons.lang3 should be external
        codeflash_output = resolver._is_external_library("org.apache.commons.lang3") # 2.71μs -> 2.09μs (29.2% faster)

    def test_internal_package_not_matching_any_prefix(self):
        """Test that packages not matching any external prefix are not recognized as external."""
        resolver = JavaImportResolver(Path("/tmp"))
        # com.mycompany is not in the external prefixes list
        codeflash_output = resolver._is_external_library("com.mycompany") # 2.99μs -> 1.95μs (52.8% faster)

    def test_internal_package_with_similar_name(self):
        """Test that internal packages with names similar to external ones are not marked external."""
        resolver = JavaImportResolver(Path("/tmp"))
        # org.apache is external, but org.mypackage is not
        codeflash_output = resolver._is_external_library("org.mypackage") # 3.01μs -> 1.92μs (56.3% faster)

    def test_springframework_prefix(self):
        """Test recognition of Spring Framework packages."""
        resolver = JavaImportResolver(Path("/tmp"))
        codeflash_output = resolver._is_external_library("org.springframework") # 2.34μs -> 932ns (152% faster)
        codeflash_output = resolver._is_external_library("org.springframework.web.servlet") # 1.41μs -> 1.85μs (23.8% slower)

    def test_google_libraries(self):
        """Test recognition of Google libraries."""
        resolver = JavaImportResolver(Path("/tmp"))
        codeflash_output = resolver._is_external_library("com.google") # 1.39μs -> 921ns (51.1% faster)
        codeflash_output = resolver._is_external_library("com.google.guava") # 591ns -> 1.64μs (64.0% slower)

    def test_mockito_libraries(self):
        """Test recognition of Mockito testing library."""
        resolver = JavaImportResolver(Path("/tmp"))
        codeflash_output = resolver._is_external_library("org.mockito") # 1.88μs -> 892ns (111% faster)
        codeflash_output = resolver._is_external_library("org.mockito.internal.util") # 1.00μs -> 1.62μs (38.3% slower)

    def test_lombok_library(self):
        """Test recognition of Lombok library."""
        resolver = JavaImportResolver(Path("/tmp"))
        codeflash_output = resolver._is_external_library("lombok") # 2.42μs -> 862ns (180% faster)
        codeflash_output = resolver._is_external_library("lombok.experimental") # 1.56μs -> 1.16μs (34.5% faster)

    def test_fasterxml_json_library(self):
        """Test recognition of FasterXML Jackson library."""
        resolver = JavaImportResolver(Path("/tmp"))
        codeflash_output = resolver._is_external_library("com.fasterxml") # 1.97μs -> 882ns (124% faster)
        codeflash_output = resolver._is_external_library("com.fasterxml.jackson.databind") # 1.13μs -> 1.77μs (36.2% slower)

class TestIsExternalLibraryEdgeCases:
    """Edge case test cases for JavaImportResolver._is_external_library function."""

    def test_empty_string(self):
        """Test behavior with empty string input."""
        resolver = JavaImportResolver(Path("/tmp"))
        # Empty string should not match any prefix
        codeflash_output = resolver._is_external_library("") # 2.90μs -> 1.50μs (92.7% faster)

    def test_single_word_not_external(self):
        """Test single word packages that are not in external prefixes."""
        resolver = JavaImportResolver(Path("/tmp"))
        # Single word like "myapp" should not be external
        codeflash_output = resolver._is_external_library("myapp") # 2.85μs -> 1.57μs (80.9% faster)

    def test_single_word_lombok_is_external(self):
        """Test single word 'lombok' which is in external prefixes."""
        resolver = JavaImportResolver(Path("/tmp"))
        # lombok is a special case - it's a single word in COMMON_EXTERNAL_PREFIXES
        codeflash_output = resolver._is_external_library("lombok") # 2.35μs -> 891ns (164% faster)

    def test_prefix_without_dot_separator_not_matching(self):
        """Test that prefix must be followed by dot or be exact match."""
        resolver = JavaImportResolver(Path("/tmp"))
        # org.junitX should not match org.junit (missing dot)
        codeflash_output = resolver._is_external_library("org.junitX") # 3.10μs -> 2.01μs (53.7% faster)

    def test_case_sensitive_matching(self):
        """Test that matching is case-sensitive."""
        resolver = JavaImportResolver(Path("/tmp"))
        # Org.junit (capital O) should not match org.junit
        codeflash_output = resolver._is_external_library("Org.junit") # 3.06μs -> 1.91μs (59.7% faster)

    def test_uppercase_variant(self):
        """Test uppercase variants are not matched."""
        resolver = JavaImportResolver(Path("/tmp"))
        # ORG.JUNIT should not match org.junit
        codeflash_output = resolver._is_external_library("ORG.JUNIT") # 3.00μs -> 1.79μs (67.1% faster)

    def test_prefix_with_trailing_dot_without_suffix(self):
        """Test exact match with trailing dot does not occur naturally."""
        resolver = JavaImportResolver(Path("/tmp"))
        # org.junit. (ending with dot) should not match
        codeflash_output = resolver._is_external_library("org.junit.") # 3.11μs -> 2.07μs (49.8% faster)

    def test_very_long_package_name(self):
        """Test with very long package names."""
        resolver = JavaImportResolver(Path("/tmp"))
        # Long nested package under external prefix
        long_package = "org.apache.commons.lang3.time.FastDateFormat.Instance"
        codeflash_output = resolver._is_external_library(long_package) # 2.75μs -> 2.23μs (22.9% faster)

    def test_package_starting_similar_to_external_but_not_exact(self):
        """Test packages that start with similar characters but differ."""
        resolver = JavaImportResolver(Path("/tmp"))
        # org.junitX differs from org.junit
        codeflash_output = resolver._is_external_library("org.junitX") # 3.09μs -> 1.90μs (62.1% faster)

    def test_special_characters_in_package_name(self):
        """Test package names with special characters (non-standard but possible)."""
        resolver = JavaImportResolver(Path("/tmp"))
        # Package with underscore is unusual but should not match
        codeflash_output = resolver._is_external_library("org.apache_commons") # 3.02μs -> 2.04μs (47.6% faster)

    def test_numeric_characters_in_package(self):
        """Test package names containing numeric characters."""
        resolver = JavaImportResolver(Path("/tmp"))
        # org.apache.commons.lang3 has numeric suffix
        codeflash_output = resolver._is_external_library("org.apache.commons.lang3") # 2.67μs -> 2.10μs (26.7% faster)

    def test_io_netty_prefix(self):
        """Test recognition of Netty I/O library."""
        resolver = JavaImportResolver(Path("/tmp"))
        codeflash_output = resolver._is_external_library("io.netty") # 2.50μs -> 901ns (178% faster)
        codeflash_output = resolver._is_external_library("io.netty.handler.codec") # 1.70μs -> 1.77μs (3.95% slower)

    def test_io_github_prefix(self):
        """Test recognition of io.github packages."""
        resolver = JavaImportResolver(Path("/tmp"))
        codeflash_output = resolver._is_external_library("io.github") # 1.53μs -> 972ns (57.7% faster)
        codeflash_output = resolver._is_external_library("io.github.myproject.utils") # 742ns -> 1.72μs (56.9% slower)

    def test_slf4j_logging(self):
        """Test recognition of SLF4J logging library."""
        resolver = JavaImportResolver(Path("/tmp"))
        codeflash_output = resolver._is_external_library("org.slf4j") # 2.15μs -> 891ns (142% faster)
        codeflash_output = resolver._is_external_library("org.slf4j.Logger") # 1.30μs -> 1.64μs (20.8% slower)

    def test_assertj_library(self):
        """Test recognition of AssertJ testing library."""
        resolver = JavaImportResolver(Path("/tmp"))
        codeflash_output = resolver._is_external_library("org.assertj") # 2.93μs -> 891ns (228% faster)
        codeflash_output = resolver._is_external_library("org.assertj.core.api") # 1.96μs -> 1.63μs (20.2% faster)

    def test_hamcrest_library(self):
        """Test recognition of Hamcrest testing library."""
        resolver = JavaImportResolver(Path("/tmp"))
        codeflash_output = resolver._is_external_library("org.hamcrest") # 1.73μs -> 911ns (90.3% faster)
        codeflash_output = resolver._is_external_library("org.hamcrest.Matcher") # 861ns -> 1.63μs (47.3% slower)

    def test_package_name_with_numbers_only_suffix(self):
        """Test package with numeric-only suffix (common in versioning)."""
        resolver = JavaImportResolver(Path("/tmp"))
        # org.apache.commons.lang3 - 3 is a number
        codeflash_output = resolver._is_external_library("org.apache.commons.lang3") # 2.75μs -> 2.10μs (31.0% faster)

    def test_partial_match_at_wrong_position(self):
        """Test that substring matches don't work unless at the start."""
        resolver = JavaImportResolver(Path("/tmp"))
        # myorg.junit is not the same as org.junit at the start
        codeflash_output = resolver._is_external_library("myorg.junit") # 3.14μs -> 1.91μs (63.8% faster)

    def test_single_dot_package(self):
        """Test malformed package name with just a dot."""
        resolver = JavaImportResolver(Path("/tmp"))
        codeflash_output = resolver._is_external_library(".") # 2.88μs -> 1.74μs (64.9% faster)

    def test_multiple_consecutive_dots(self):
        """Test package with consecutive dots (malformed)."""
        resolver = JavaImportResolver(Path("/tmp"))
        # org..apache should not match (consecutive dots)
        codeflash_output = resolver._is_external_library("org..apache") # 3.09μs -> 2.22μs (38.8% faster)

    def test_leading_dot_in_package(self):
        """Test package with leading dot (malformed)."""
        resolver = JavaImportResolver(Path("/tmp"))
        codeflash_output = resolver._is_external_library(".org.junit") # 3.04μs -> 2.23μs (36.4% faster)

    def test_substring_does_not_match_middle(self):
        """Test that external prefix in the middle doesn't count."""
        resolver = JavaImportResolver(Path("/tmp"))
        # com.myorg.junit is not external (org.junit is in middle, not start)
        codeflash_output = resolver._is_external_library("com.myorg.junit") # 3.00μs -> 2.17μs (38.2% faster)

class TestIsExternalLibraryLargeScale:
    """Large scale test cases for JavaImportResolver._is_external_library function."""

    def test_batch_processing_many_external_packages(self):
        """Test processing a large batch of external package names."""
        resolver = JavaImportResolver(Path("/tmp"))
        external_packages = [
            "org.junit.runner.Runner",
            "org.junit.runners.Parameterized",
            "org.junit.Before",
            "org.mockito.ArgumentMatchers",
            "org.mockito.InOrder",
            "org.assertj.core.api.Assertions",
            "org.slf4j.LoggerFactory",
            "org.springframework.boot.SpringApplication",
            "org.springframework.web.bind.annotation.RestController",
            "com.google.common.base.Preconditions",
            "com.fasterxml.jackson.databind.ObjectMapper",
            "io.netty.channel.Channel",
            "io.github.project.util.Helper",
            "lombok.Data",
        ]
        # All of these should be recognized as external
        for package in external_packages:
            codeflash_output = resolver._is_external_library(package) # 17.2μs -> 14.2μs (20.6% faster)

    def test_batch_processing_many_internal_packages(self):
        """Test processing a large batch of internal package names."""
        resolver = JavaImportResolver(Path("/tmp"))
        internal_packages = [
            "com.mycompany.app",
            "com.mycompany.services.UserService",
            "com.mycompany.models.User",
            "com.acme.util.StringHelper",
            "com.acme.dao.UserDAO",
            "app.controller.HomeController",
            "myapp.ui.MainWindow",
            "internal.package.impl.Factory",
            "company.project.service",
            "org.myproject.beans",
            "org.myapp.api.client",
            "io.mycompany.service",
        ]
        # None of these should be recognized as external
        for package in internal_packages:
            codeflash_output = resolver._is_external_library(package) # 22.2μs -> 15.2μs (46.3% faster)

    def test_mixed_batch_classification(self):
        """Test classification of mixed internal and external packages in one batch."""
        resolver = JavaImportResolver(Path("/tmp"))
        test_cases = [
            ("org.junit.Test", True),
            ("com.mycompany.test.TestRunner", False),
            ("org.springframework.stereotype.Component", True),
            ("com.example.component.MyComponent", False),
            ("org.apache.commons.io.IOUtils", True),
            ("io.myapp.utils.FileHelper", False),
            ("lombok.extern.slf4j.Slf4j", True),
            ("lombok.internal.Handler", True),
        ]
        # Verify each package is classified correctly
        for package, expected_external in test_cases:
            codeflash_output = resolver._is_external_library(package) # 13.6μs -> 9.82μs (38.6% faster)

    def test_all_common_external_prefixes_individually(self):
        """Test that each prefix in COMMON_EXTERNAL_PREFIXES is properly recognized."""
        resolver = JavaImportResolver(Path("/tmp"))
        # Verify all prefixes from the class definition
        expected_prefixes = [
            "org.junit",
            "org.mockito",
            "org.assertj",
            "org.hamcrest",
            "org.slf4j",
            "org.apache",
            "org.springframework",
            "com.google",
            "com.fasterxml",
            "io.netty",
            "io.github",
            "lombok",
        ]
        for prefix in expected_prefixes:
            # Exact match
            codeflash_output = resolver._is_external_library(prefix) # 14.1μs -> 4.52μs (212% faster)
            # With one level of nesting
            codeflash_output = resolver._is_external_library(f"{prefix}.subpackage")

    def test_stress_test_with_many_similar_packages(self):
        """Test with many similar package names to ensure no false positives."""
        resolver = JavaImportResolver(Path("/tmp"))
        # Create variations that should NOT match
        similar_non_matching = [
            "org.myjunit",
            "org.junitx",
            "org.junit_framework",
            "org2.junit",
            "orgx.junit",
            "org.junitx.runner",
            "com.mygoogle",
            "com.googleplay",
            "io.mynetty",
            "io.nettyx",
        ]
        for package in similar_non_matching:
            codeflash_output = resolver._is_external_library(package) # 19.2μs -> 10.2μs (88.4% faster)

    def test_deeply_nested_packages_limit(self):
        """Test packages with very deep nesting levels under external prefixes."""
        resolver = JavaImportResolver(Path("/tmp"))
        # Create a deeply nested package path (up to 10 levels)
        deep_packages = [
            "org.apache.level1.level2.level3.level4.level5",
            "org.springframework.boot.autoconfigure.condition.matcher.level6",
            "com.google.common.collect.immutable.ordered.nested",
            "io.netty.handler.codec.http.multipart.factory.impl.v1",
        ]
        for package in deep_packages:
            codeflash_output = resolver._is_external_library(package) # 5.76μs -> 6.01μs (4.14% slower)

    def test_performance_with_repeated_checks(self):
        """Test that repeated checks on same package work correctly."""
        resolver = JavaImportResolver(Path("/tmp"))
        test_package = "org.apache.commons.lang3.StringUtils"
        # Call multiple times - should consistently return True
        for _ in range(100):
            codeflash_output = resolver._is_external_library(test_package) # 141μs -> 19.9μs (610% faster)

    def test_performance_with_internal_package_repeated_checks(self):
        """Test that repeated checks on internal packages work correctly."""
        resolver = JavaImportResolver(Path("/tmp"))
        test_package = "com.mycompany.services.impl.UserServiceImpl"
        # Call multiple times - should consistently return False
        for _ in range(100):
            codeflash_output = resolver._is_external_library(test_package) # 165μs -> 20.5μs (704% faster)

    def test_boundary_cases_with_multiple_instances(self):
        """Test that multiple resolver instances produce consistent results."""
        resolver1 = JavaImportResolver(Path("/tmp"))
        resolver2 = JavaImportResolver(Path("/home/user/project"))
        
        test_packages = [
            "org.junit.Test",
            "com.mycompany.app",
            "org.springframework.boot.Application",
            "internal.service.Handler",
        ]
        
        # Both resolvers should give same results regardless of project_root
        for package in test_packages:
            codeflash_output = resolver1._is_external_library(package); result1 = codeflash_output # 7.93μs -> 5.70μs (39.2% faster)
            codeflash_output = resolver2._is_external_library(package); result2 = codeflash_output # 6.48μs -> 3.46μs (87.4% faster)

    def test_all_test_frameworks_recognized(self):
        """Test recognition of all common Java test frameworks and tools."""
        resolver = JavaImportResolver(Path("/tmp"))
        test_frameworks = [
            ("org.junit", True),
            ("org.junit.jupiter.api.Test", True),
            ("org.testng.annotations.Test", False),  # TestNG not in list
            ("org.mockito.Mockito", True),
            ("org.assertj.core.api.Assertions", True),
            ("org.hamcrest.MatcherAssert", True),
        ]
        for package, expected in test_frameworks:
            codeflash_output = resolver._is_external_library(package) # 10.0μs -> 7.40μs (35.3% faster)

    def test_common_utility_libraries_recognized(self):
        """Test recognition of common utility libraries."""
        resolver = JavaImportResolver(Path("/tmp"))
        utility_libraries = [
            "org.apache.commons.io.IOUtils",
            "org.apache.commons.lang3.StringUtils",
            "org.apache.commons.collections4.CollectionUtils",
            "com.google.common.base.Preconditions",
            "com.google.common.collect.Lists",
            "com.fasterxml.jackson.databind.ObjectMapper",
            "com.fasterxml.jackson.annotation.JsonProperty",
        ]
        for package in utility_libraries:
            codeflash_output = resolver._is_external_library(package) # 8.18μs -> 8.01μs (2.21% faster)

    def test_web_framework_packages_recognized(self):
        """Test recognition of common web framework packages."""
        resolver = JavaImportResolver(Path("/tmp"))
        web_packages = [
            "org.springframework.web.servlet.mvc.Controller",
            "org.springframework.boot.SpringApplication",
            "org.springframework.data.jpa.repository.JpaRepository",
            "org.springframework.security.crypto.password.PasswordEncoder",
        ]
        for package in web_packages:
            codeflash_output = resolver._is_external_library(package) # 5.64μs -> 5.13μs (9.96% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-pr1199-2026-02-04T05.47.50 and push.