How to use

getDeclaredConstructors

method

in

java.lang.Class

  private Constructor<?> biggestConstructor(Class<?> clazz) {
    final List<? extends Constructor<?>> constructors = Arrays.asList(clazz.getDeclaredConstructors());
    Collections.sort(constructors, byParameterNumber);
    Constructor<?> constructor = constructors.get(0);
    checkParameterized(constructor, field);
    return constructor;
  }
}

/**
 * Runs {@link #testConstructor} on every constructor in class {@code c} that has at least {@code
 * minimalVisibility}.
 */
public void testConstructors(Class<?> c, Visibility minimalVisibility) {
 for (Constructor<?> constructor : c.getDeclaredConstructors()) {
  if (minimalVisibility.isVisible(constructor) && !isIgnored(constructor)) {
   testConstructor(constructor);
  }
 }
}

 AnonymousClassInConstructor() {
  final int i = 1;
  final String s = "hello world";
  Class<?> anonymous =
    new Runnable() {
     @Override
     public void run() {
      System.out.println(s + i);
     }
    }.getClass();
  Constructor<?> constructor = anonymous.getDeclaredConstructors()[0];
  assertEquals(0, Invokable.from(constructor).getParameters().size());
 }
}

public void testPrivateClass() {
 NullPointerTester tester = new NullPointerTester();
 for (Constructor<?> constructor :
   PrivateClassWithPrivateConstructor.class.getDeclaredConstructors()) {
  tester.testConstructor(constructor);
 }
}

public void testAnonymousClassWithTwoParametersConstructor() {
 abstract class Base {
  @SuppressWarnings("unused") // called by reflection
  Base(String s, int i) {}
 }
 Class<?> anonymous = new Base("test", 0) {}.getClass();
 Constructor<?> constructor = anonymous.getDeclaredConstructors()[0];
 assertEquals(2, Invokable.from(constructor).getParameters().size());
}

public void testAnonymousClassDefaultConstructor() {
 final int i = 1;
 final String s = "hello world";
 Class<?> anonymous =
   new Runnable() {
    @Override
    public void run() {
     System.out.println(s + i);
    }
   }.getClass();
 Constructor<?> constructor = anonymous.getDeclaredConstructors()[0];
 assertEquals(0, Invokable.from(constructor).getParameters().size());
}

private static void doTestStaticAnonymousClassDefaultConstructor() {
 final int i = 1;
 final String s = "hello world";
 Class<?> anonymous =
   new Runnable() {
    @Override
    public void run() {
     System.out.println(s + i);
    }
   }.getClass();
 Constructor<?> constructor = anonymous.getDeclaredConstructors()[0];
 assertEquals(0, Invokable.from(constructor).getParameters().size());
}

public void testLocalClassDefaultConstructor() {
 final int i = 1;
 final String s = "hello world";
 class LocalWithDefaultConstructor implements Runnable {
  @Override
  public void run() {
   System.out.println(s + i);
  }
 }
 Constructor<?> constructor = LocalWithDefaultConstructor.class.getDeclaredConstructors()[0];
 assertEquals(0, Invokable.from(constructor).getParameters().size());
}

public void testNestedInnerClassDefaultConstructor() {
 Constructor<?> constructor =
   InnerWithDefaultConstructor.NestedInner.class.getDeclaredConstructors()[0];
 assertEquals(0, Invokable.from(constructor).getParameters().size());
}

public void testInnerClassDefaultConstructor() {
 Constructor<?> constructor = InnerWithDefaultConstructor.class.getDeclaredConstructors()[0];
 assertEquals(0, Invokable.from(constructor).getParameters().size());
}

public void testInnerClassWithAnnotatedConstructorParameter() {
 Constructor<?> constructor =
   InnerWithAnnotatedConstructorParameter.class.getDeclaredConstructors()[0];
 Invokable<?, ?> invokable = Invokable.from(constructor);
 assertEquals(1, invokable.getParameters().size());
 assertEquals(TypeToken.of(String.class), invokable.getParameters().get(0).getType());
}

public void testLocalClassWithAnnotatedConstructorParameter() throws Exception {
 class LocalWithAnnotatedConstructorParameter {
  @SuppressWarnings("unused") // called by reflection
  LocalWithAnnotatedConstructorParameter(@Nullable String s) {}
 }
 Constructor<?> constructor =
   LocalWithAnnotatedConstructorParameter.class.getDeclaredConstructors()[0];
 Invokable<?, ?> invokable = Invokable.from(constructor);
 assertEquals(1, invokable.getParameters().size());
 assertEquals(TypeToken.of(String.class), invokable.getParameters().get(0).getType());
}

public void testInnerClassWithOneParameterConstructor() {
 Constructor<?> constructor =
   InnerWithOneParameterConstructor.class.getDeclaredConstructors()[0];
 Invokable<?, ?> invokable = Invokable.from(constructor);
 assertEquals(1, invokable.getParameters().size());
 assertEquals(TypeToken.of(String.class), invokable.getParameters().get(0).getType());
}

@Test
public void testConstructor() {
  assertNotNull(new ObjectUtils());
  final Constructor<?>[] cons = ObjectUtils.class.getDeclaredConstructors();
  assertEquals(1, cons.length);
  assertTrue(Modifier.isPublic(cons[0].getModifiers()));
  assertTrue(Modifier.isPublic(ObjectUtils.class.getModifiers()));
  assertFalse(Modifier.isFinal(ObjectUtils.class.getModifiers()));
}

@Test
public void testConstructor() {
  assertNotNull(new CharSequenceUtils());
  final Constructor<?>[] cons = CharSequenceUtils.class.getDeclaredConstructors();
  assertEquals(1, cons.length);
  assertTrue(Modifier.isPublic(cons[0].getModifiers()));
  assertTrue(Modifier.isPublic(CharSequenceUtils.class.getModifiers()));
  assertFalse(Modifier.isFinal(CharSequenceUtils.class.getModifiers()));
}

/**
 * Test that constructors are public, and work, etc.
 */
@Test
public void testConstructor() {
  assertNotNull(new LocaleUtils());
  final Constructor<?>[] cons = LocaleUtils.class.getDeclaredConstructors();
  assertEquals(1, cons.length);
  assertTrue(Modifier.isPublic(cons[0].getModifiers()));
  assertTrue(Modifier.isPublic(LocaleUtils.class.getModifiers()));
  assertFalse(Modifier.isFinal(LocaleUtils.class.getModifiers()));
}

@Test
public void testConstructor() {
  assertNotNull(new StringUtils());
  final Constructor<?>[] cons = StringUtils.class.getDeclaredConstructors();
  assertEquals(1, cons.length);
  assertTrue(Modifier.isPublic(cons[0].getModifiers()));
  assertTrue(Modifier.isPublic(StringUtils.class.getModifiers()));
  assertFalse(Modifier.isFinal(StringUtils.class.getModifiers()));
}

public void testLocalClassWithOneParameterConstructor() throws Exception {
 final int i = 1;
 final String s = "hello world";
 class LocalWithOneParameterConstructor {
  @SuppressWarnings("unused") // called by reflection
  public LocalWithOneParameterConstructor(String x) {
   System.out.println(s + i);
  }
 }
 Constructor<?> constructor =
   LocalWithOneParameterConstructor.class.getDeclaredConstructors()[0];
 Invokable<?, ?> invokable = Invokable.from(constructor);
 assertEquals(1, invokable.getParameters().size());
 assertEquals(TypeToken.of(String.class), invokable.getParameters().get(0).getType());
}

public void testInnerClassWithGenericConstructorParameter() {
 Constructor<?> constructor =
   InnerWithGenericConstructorParameter.class.getDeclaredConstructors()[0];
 Invokable<?, ?> invokable = Invokable.from(constructor);
 assertEquals(2, invokable.getParameters().size());
 assertEquals(new TypeToken<Iterable<String>>() {}, invokable.getParameters().get(0).getType());
 assertEquals(TypeToken.of(String.class), invokable.getParameters().get(1).getType());
}

public void testLocalClassWithGenericConstructorParameter() throws Exception {
 class LocalWithGenericConstructorParameter {
  @SuppressWarnings("unused") // called by reflection
  LocalWithGenericConstructorParameter(Iterable<String> it, String s) {}
 }
 Constructor<?> constructor =
   LocalWithGenericConstructorParameter.class.getDeclaredConstructors()[0];
 Invokable<?, ?> invokable = Invokable.from(constructor);
 assertEquals(2, invokable.getParameters().size());
 assertEquals(new TypeToken<Iterable<String>>() {}, invokable.getParameters().get(0).getType());
 assertEquals(TypeToken.of(String.class), invokable.getParameters().get(1).getType());
}