String impl = properties.getProperty(slf4jBinding);
                    if (impl != null) {
                        return (Slf4jConfiguration)
                                Class.forName(impl).getDeclaredConstructor().newInstance();
                    }
                } catch (IOException
                        | ClassNotFoundException
                        | NoSuchMethodException

     * @see Class#getDeclaredConstructor(Class...)
     */
    public static <T> Constructor<T> getDeclaredConstructor(final Class<T> clazz, final Class<?>... argTypes)
            throws NoSuchConstructorRuntimeException {
        assertArgumentNotNull("clazz", clazz);

        try {
            return clazz.getDeclaredConstructor(argTypes);
        } catch (final NoSuchMethodException e) {

        void testConstructorInitialization() throws Exception {
            // Given
            int testMid = 42;

            // When
            Constructor<SmbComNtCancel> constructor = SmbComNtCancel.class.getDeclaredConstructor(Configuration.class, int.class);
            constructor.setAccessible(true);
            SmbComNtCancel cancel = constructor.newInstance(mockConfig, testMid);

            // Then
            assertNotNull(cancel);

    @Tested
    public final void publicFinalMethod() {}

    void notAnnotatedMethod() {}

    static Invokable<A, A> constructor() throws Exception {
      Constructor<A> constructor = A.class.getDeclaredConstructor(Object.class);
      Invokable<A, A> invokable = Invokable.from(constructor);
      assertThat(invokable.getName()).isEqualTo(constructor.getName());
      assertEquals(A.class, invokable.getDeclaringClass());

cpovirk <******@****.***> 1754701862 -0700

cpovirk <******@****.***> 1775141306 -0700

    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)

    void testNoConstructorLookup() {
        // Act & Assert: interfaces have no constructors
        assertThrows(NoSuchMethodException.class, () -> SessionSetupHandler.class.getDeclaredConstructor());
    }

    @Test
    @DisplayName("Invalid: resolving class by null name throws NPE")
    void testClassForNameWithNull() {

    // 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);

        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);
            }