final ConstructorDesc ctor = beanDesc.getConstructorDesc();
        assertThat(ctor, is(notNullValue()));
        assertThat(ctor.getBeanDesc(), is(sameInstance(beanDesc)));
        assertThat(ctor.getConstructor(), is((Constructor) MyBean.class.getConstructor()));
        assertThat(ctor.getParameterTypes().length, is(0));
        assertThat(ctor.isPublic(), is(true));
        final MyBean myBean = ctor.newInstance();

        useMonitor ? "com.google.common.util.concurrent.MonitorBased" : "java.util.concurrent.";
    String className = prefix + queueType + "BlockingQueue";
    Constructor<?> constructor = Class.forName(className).getConstructor(int.class);
    queue = (BlockingQueue<String>) constructor.newInstance(capacity);

    strings = new String[capacity];
    for (int i = 0; i < capacity; i++) {
      strings[i] = String.valueOf(Math.random());
    }

     */
    BeanDesc getBeanDesc();

    /**
     * Returns the constructor.
     *
     * @param <T>
     *            The type of the Bean
     * @return The constructor
     */
    <T> Constructor<T> getConstructor();

    /**
     * Returns an array of the parameter types of the constructor.
     *
     * @return An array of the parameter types of the constructor
     */
    Class<?>[] getParameterTypes();

    /**

    }

    /**
     *
     */
    @Test(expected = NoSuchConstructorRuntimeException.class)
    public void testGetConstructor() {
        ClassUtil.getConstructor(ClassUtilTest.class, Integer.class);
    }

    /**
     *
     */
    @Test(expected = NoSuchFieldRuntimeException.class)
    public void testGetField() {

        }
    }

    @Override
    public BeanDesc getBeanDesc() {
        return beanDesc;
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> Constructor<T> getConstructor() {
        return (Constructor<T>) constructor;
    }

    @Override
    public Class<?>[] getParameterTypes() {
        return parameterTypes;
    }

    @Override
    public boolean isPublic() {

     *             If a matching constructor is not found
     * @see Class#getConstructor(Class...)
     */
    public static <T> Constructor<T> getConstructor(final Class<T> clazz, final Class<?>... argTypes)
            throws NoSuchConstructorRuntimeException {
        assertArgumentNotNull("clazz", clazz);

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

    Constructor<String> constructor = String.class.getConstructor();
    assertThrows(
        IllegalArgumentException.class, () -> TypeToken.of(Object.class).constructor(constructor));
  }

  public void testConstructor_declaredBySuperclass() throws NoSuchMethodException {
    Constructor<Object> constructor = Object.class.getConstructor();
    assertThrows(

        new AtomicReference<Object>(sepFrqC.getDeclaredConstructor().newInstance());
    Class<?> sepFwrC = sepLoader.loadClass(MyFinalizableWeakReference.class.getName());
    Constructor<?> sepFwrCons = sepFwrC.getConstructor(Object.class, sepFrqC);
    // The object that we will wrap in FinalizableWeakReference is a Stopwatch.
    Class<?> sepStopwatchC = sepLoader.loadClass(Stopwatch.class.getName());

              + "inherit thread local values.");
      return null;
    }
  }

  private static @Nullable Constructor<Thread> getBigThreadConstructor() {
    try {
      return Thread.class.getConstructor(
          ThreadGroup.class, Runnable.class, String.class, long.class, boolean.class);
    } catch (Throwable t) {
      // Probably pre Java 9. We'll fall back to Thread.inheritableThreadLocals.
      return null;

     * @return Instance of given implementation, constructed using the given string
     */
    private static <T> T newImplementation(final Class<T> clazz, final String value) {
        try {
            return clazz.getConstructor(String.class).newInstance(value);
        } catch (final Exception e) {
            final Throwable cause = e instanceof InvocationTargetException ? e.getCause() : e;