};

    cache.put(0, 10);

    assertThat(cache.get(0, loader)).isEqualTo(10);
    assertThat(cache.get(20, loader)).isEqualTo(1);
    assertThat(cache.get(34, loader)).isEqualTo(2);

    cache.invalidate(0);
    assertThat(cache.get(0, loader)).isEqualTo(3);

    cache.put(0, 10);
    cache.invalidateAll();
    assertThat(cache.get(0, loader)).isEqualTo(4);
  }

  @Test
  public void sizeConstraint() {

   *       CacheLoader#loadAll bulk loading implementations}
   * </ul>
   *
   * <p><b>Warning:</b> For any given key, every {@code loader} used with it should compute the same
   * value. Otherwise, a call that passes one {@code loader} may return the result of another call
   * with a differently behaving {@code loader}. For example, a call that requests a short timeout
   * for an RPC may wait for a similar call that requests a long timeout, or a call by an

        dir.resolve(classFilePath).takeIf { it.isFile }?.let { classFile -> { classFile.readBytes() } }
    }

    private
    fun loaderClassBytesIndexFor(loader: ClassLoader): ClassBytesIndex = { classFilePath ->
        loader.getResource(classFilePath)?.let {
            { loader.getResourceAsStream(classFilePath).use { it!!.readBytes() } }
        }
    }

    private
    fun openJarFile(file: File) =

        bindingMap.put("container", SingletonLaContainerFactory.getContainer());

        // Create GroovyShell with custom class loader for proper resource management
        GroovyClassLoader classLoader = null;
        try {
            // Get parent class loader with fallback to ensure robustness across threading contexts
            ClassLoader parentClassLoader = Thread.currentThread().getContextClassLoader();

    private final ClassLoader loader;
    private final ExpressionEvaluator evaluator;
    private final ConfigurationListener listener;

    /**
     * Holds information about a method including its parameter type.
     */
    private record MethodInfo(Method method, Type parameterType) {}

    public EnhancedCompositeBeanHelper(

   * loaded by this test and that will obviously remain loaded for as long as the test is running.
   * So in order to check ClassLoader garbage collection we need to create a new ClassLoader and
   * make it load its own version of FinalizableReferenceQueue. Then we need to interact with that
   * parallel version through reflection in order to exercise the parallel

  </description>

  <build>
    <pluginManagement>
      <plugins>
        <plugin>
          <groupId>org.apache.maven.its.plugins</groupId>
          <artifactId>maven-it-plugin-class-loader</artifactId>
          <version>2.1-SNAPSHOT</version>
          <dependencies>
            <dependency>
              <groupId>org.apache.maven.its.mng3906</groupId>
              <artifactId>e</artifactId>

  dependencies:
    minimist "^1.2.3"

karma-sourcemap-loader@0.4.0:
  version "0.4.0"
  resolved "https://registry.yarnpkg.com/karma-sourcemap-loader/-/karma-sourcemap-loader-0.4.0.tgz#b01d73f8f688f533bcc8f5d273d43458e13b5488"
  integrity sha512-xCRL3/pmhAYF3I6qOrcn0uhbQevitc2DERMPH82FMnG+4WReoGcGFZb1pURf2a5apyrOHRdvD+O6K7NljqKHyA==

  }

  private static ResourceInfo resourceInfo(Class<?> cls) {
    String resource = cls.getName().replace('.', '/') + ".class";
    ClassLoader loader = cls.getClassLoader();
    return ResourceInfo.of(FILE, resource, loader);
  }

  private static ClassInfo classInfo(Class<?> cls) {
    return classInfo(cls, cls.getClassLoader());
  }

  </description>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.its.plugins</groupId>
        <artifactId>maven-it-plugin-class-loader</artifactId>
        <version>2.1-SNAPSHOT</version>
        <dependencies>
          <dependency>
            <groupId>org.apache.maven.its.mng3906</groupId>
            <artifactId>c</artifactId>