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

        try {
            final CachedScript cached = getOrCompile(template);
            final Script script = cached.scriptClass.getDeclaredConstructor().newInstance();
            script.setBinding(new Binding(bindingMap));

            if (logger.isDebugEnabled()) {
                logger.debug("Evaluating Groovy script: template={}", template);
            }

    }

    // Test annotation on constructor parameter
    @Test
    public void test_annotationOnConstructor() throws Exception {
        java.lang.reflect.Constructor<?> constructor = TestConstructor.class.getDeclaredConstructor(String.class);
        Annotation[][] paramAnnotations = constructor.getParameterAnnotations();

        assertEquals(1, paramAnnotations.length);
        boolean hasCronExpression = false;

    Thread.currentThread().setContextClassLoader(classLoader);
    try {
      Class<?> test = classLoader.loadClass(FuturesTest.class.getName());
      Object testInstance = test.getDeclaredConstructor().newInstance();
      test.getMethod("setUp").invoke(testInstance);
      test.getMethod(getName()).invoke(testInstance);
      test.getMethod("tearDown").invoke(testInstance);
    } finally {

    Thread.currentThread().setContextClassLoader(classLoader);
    try {
      Class<?> test = classLoader.loadClass(FuturesTest.class.getName());
      Object testInstance = test.getDeclaredConstructor().newInstance();
      test.getMethod("setUp").invoke(testInstance);
      test.getMethod(getName()).invoke(testInstance);
      test.getMethod("tearDown").invoke(testInstance);
    } finally {

    public void test_constructor_isPrivate() {
        // Verify that SystemUtil has a private constructor (utility class pattern)
        try {
            Constructor<SystemUtil> constructor = SystemUtil.class.getDeclaredConstructor();
            assertTrue("Constructor should be private", java.lang.reflect.Modifier.isPrivate(constructor.getModifiers()));

            // Test that constructor is accessible when made accessible

    Thread.currentThread().setContextClassLoader(classLoader);
    try {
      Class<?> test = classLoader.loadClass(AbstractFutureTest.class.getName());
      test.getMethod(getName()).invoke(test.getDeclaredConstructor().newInstance());
    } finally {
      Thread.currentThread().setContextClassLoader(oldClassLoader);
    }
  }

  private void checkHelperVersion(ClassLoader classLoader, String expectedHelperClassName)

        // ## Test that protected constructor can be accessed via reflection ##

        // ## Act ##
        final Constructor<Curl> constructor = Curl.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        final Curl instance = constructor.newInstance();

        // ## Assert ##
        assertNotNull(instance);
    }

    @Test

    // exercise some classes from the parallel ClassLoader.
    AtomicReference<Object> sepFrqA =
        new AtomicReference<Object>(sepFrqC.getDeclaredConstructor().newInstance());
    Class<?> sepFwrC = sepLoader.loadClass(MyFinalizableWeakReference.class.getName());
    Constructor<?> sepFwrCons = sepFwrC.getConstructor(Object.class, sepFrqC);

    }

    @Test
    public void test_utility_class_instantiation() {
        // Verify that SearchEngineUtil is a utility class with private constructor
        try {
            SearchEngineUtil.class.getDeclaredConstructor().newInstance();
            fail("Should not be able to instantiate utility class");
        } catch (Exception e) {
            // Expected - utility classes should have private constructors

    void testPrivateConstructor() throws Exception {
        // Verify constructor is private
        Constructor<Smb2Constants> constructor = Smb2Constants.class.getDeclaredConstructor();
        assertTrue(Modifier.isPrivate(constructor.getModifiers()), "Constructor should be private");

        // Force accessibility and create instance to achieve coverage
        constructor.setAccessible(true);