*/
  public void testConstructor(Constructor<?> ctor) {
    Class<?> declaringClass = ctor.getDeclaringClass();
    checkArgument(
        Modifier.isStatic(declaringClass.getModifiers())
            || declaringClass.getEnclosingClass() == null,
        "Cannot test constructor of non-static inner class: %s",
        declaringClass.getName());
    Class<?>[] types = ctor.getParameterTypes();

    TestSuite suite = new TestSuite(AbstractFutureFallbackAtomicHelperTest.class.getName());
    for (Method method : AbstractFutureTest.class.getDeclaredMethods()) {
      if (Modifier.isPublic(method.getModifiers()) && method.getName().startsWith("test")) {
        suite.addTest(
            TestSuite.createTest(AbstractFutureFallbackAtomicHelperTest.class, method.getName()));
      }
    }
    return suite;
  }

      // Interfaces can have default methods that aren't abstract.
      // No need to verify them.
      // Can't check isDefault() for Android compatibility.
      if (!Modifier.isAbstract(method.getModifiers())) {
        continue;
      }
      // The interface could be package-private or private.
      // filter out equals/hashCode/toString
      if (method.getName().equals("equals")

                        if (isQualifiedForInterpolation(currentField, type)) {
                            if (String.class == type) {
                                if (!Modifier.isFinal(currentField.getModifiers())) {
                                    fields.add(new StringField(currentField));
                                }
                            } else if (List.class.isAssignableFrom(type)) {

      throws ParameterNotInstantiableException,
          IllegalAccessException,
          InvocationTargetException,
          FactoryMethodReturnsNullException {
    if (!Modifier.isAbstract(cls.getModifiers())) {
      nullPointerTester.testConstructors(cls, visibility);
    }
    nullPointerTester.testStaticMethods(cls, visibility);
    if (hasInstanceMethodToTestNulls(cls, visibility)) {

    }
  }

  private static <T> void callAllPublicMethods(TypeToken<T> type, T object)
      throws InvocationTargetException {
    for (Method method : type.getRawType().getMethods()) {
      if ((method.getModifiers() & STATIC) != 0) {
        continue;
      }
      ImmutableList<Parameter> parameters = type.method(method).getParameters();
      Object[] args = new Object[parameters.size()];

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

        for (final Method method : propertyType.getMethods()) {
            if (method.isBridge() || method.isSynthetic()) {
                continue;
            }
            if (ModifierUtil.isStatic(method.getModifiers()) && method.getName().equals("valueOf") && method.getParameterTypes().length == 1
                    && method.getParameterTypes()[0].equals(String.class)) {
                valueOfMethod = method;
                break;

   */
  public void testConstructor(Constructor<?> ctor) {
    Class<?> declaringClass = ctor.getDeclaringClass();
    checkArgument(
        Modifier.isStatic(declaringClass.getModifiers())
            || declaringClass.getEnclosingClass() == null,
        "Cannot test constructor of non-static inner class: %s",
        declaringClass.getName());
    Class<?>[] types = ctor.getParameterTypes();

        while (clazz != null && !clazz.equals(Object.class)) {
            for (Field field : clazz.getDeclaredFields()) {
                // Skip static fields and synthetic fields
                if (Modifier.isStatic(field.getModifiers()) || field.isSynthetic()) {
                    continue;
                }

                try {
                    field.setAccessible(true);
                    Object value = field.get(node);