Java Code Examples for com.openpojo.validation.affirm.Affirm#affirmTrue()

@Test
public void multipleAnnotationsShouldBeReturned() {
  for (PojoMethod pojoMethod : pojoMethods) {
    if (pojoMethod.getName().equals("methodWithMultipleAnnotations")) {
      Affirm.affirmEquals(String.format("Annotations added/removed from method=[%s]", pojoMethod),
          2,
          pojoMethod.getAnnotations().size());
      List<Class<?>> expectedAnnotations = new LinkedList<Class<?>>();
      expectedAnnotations.add(SomeAnnotation.class);
      expectedAnnotations.add(AnotherAnnotation.class);
      for (Annotation annotation : pojoMethod.getAnnotations()) {
        Affirm.affirmTrue(String.format("Expected annotations [%s] not found, instead found [%s]",
            expectedAnnotations, annotation.annotationType()), expectedAnnotations.contains(annotation.annotationType()));
      }
      return;
    }
  }
  Affirm.fail(String.format("methodWithMultipleAnnotations renamed? expected in [%s]", pojoClass));
}
 

@Test
public final void shouldGetJarSubClasses() {
  JARPackageLoader jarPackage = getJarPackageLoader(packageName);

  Set<String> classesNames = new LinkedHashSet<String>();
  for (Type type : jarPackage.getTypes()) {
    classesNames.add(((Class<?>) type).getName());
  }

  Affirm.affirmEquals(MessageFormatter.format("Classes added/removed to {0} found[{1}]?!", packageName, classesNames),
      expectedClassesNames.length, classesNames.size());

  for (String expectedClassName : classesNames) {
    Affirm.affirmTrue(MessageFormatter.format("Expected class[{0}] not found", expectedClassName),
        classesNames.contains(expectedClassName));
  }
}
 

@Test
@SuppressWarnings("ConstantConditions")
public void shouldGenerateRandomEnum() {
  RandomGenerator randomGenerator = EnumRandomGenerator.getInstance();
  Enum someEnum = (Enum) randomGenerator.doGenerate(Enum.class);

  Affirm.affirmTrue("should never generate null", someEnum != null);

  Enum anotherEnum = (Enum) randomGenerator.doGenerate(Enum.class);

  try {
    Affirm.affirmFalse("Enum's should be different", someEnum.equals(anotherEnum));
  } catch (AssertionError error) {
    // on occasion they may be the same - 1% chance, try one more time.
    anotherEnum = (Enum) randomGenerator.doGenerate(Enum.class);
    Affirm.affirmFalse("Enum's should be different", someEnum.equals(anotherEnum));
  }
}
 

@Test
public void testCopy() {
  final AClassWithEquality first = new AClassWithEquality(RandomFactory.getRandomValue(String.class), RandomFactory
      .getRandomValue(Integer.class));

  final AClassWithEquality second = new AClassWithEquality();

  Affirm.affirmFalse(String.format("Class with data=[%s], evaluated equals to one without=[%s]!!", BusinessIdentity.toString
      (first), BusinessIdentity.toString(second)), first.equals(second));

  final PojoClass pojoClass = getPojoClassImplForClass(first.getClass());
  pojoClass.copy(first, second);
  Affirm.affirmTrue(String.format("Class=[%s] copied to=[%s] and still equals returned false using PojoClass" + " " +
      "implementation=[%s]!!", BusinessIdentity.toString(first), BusinessIdentity.toString(second), pojoClass), first.equals
      (second));
}
 

@Test
@SuppressWarnings("ConstantConditions")
public void endToEndTest() {
  Enum someEnum = RandomFactory.getRandomValue(Enum.class);
  Affirm.affirmNotNull("Should generate Enum", someEnum);
  Affirm.affirmTrue("Should use SomeEnum when generating", someEnum.getClass() == SomeEnum.class);
}
 

@Test
public void shouldReturnAnnotationList() {
  final PojoPackage pojoPackage = PojoPackageFactory.getPojoPackage(this.getClass().getPackage().getName()
      + ".packagemanyannotations");
  Affirm.affirmEquals(String.format("Annotations added/removed? [%s]", pojoPackage), 2, pojoPackage.getAnnotations().size());

  final List<Class<?>> expectedAnnotations = new LinkedList<Class<?>>();
  expectedAnnotations.add(SomeAnnotation.class);
  expectedAnnotations.add(AnotherAnnotation.class);
  for (final Annotation annotation : pojoPackage.getAnnotations()) {
    Affirm.affirmTrue(String.format("Expected annotations [%s] not found, instead found [%s]", expectedAnnotations,
        annotation.annotationType()), expectedAnnotations.contains(annotation.annotationType()));
  }
}
 

@Test
public void shouldImplementAccuratetoStringAndhashCode() {
  final String toString = aSimpleInterface.toString();
  Affirm.affirmNotNull("toString() on proxy returned null", toString);
  Affirm.affirmTrue(String.format("toString returned [%s] expected it to begin with [%s] and contain [@]", toString, "$Proxy"),
      toString.contains("$Proxy") && toString.contains("@"));

  Affirm.affirmTrue("toString() doesn't end with hashCode()", toString.endsWith(String.valueOf(aSimpleInterface.hashCode())));

  final ASimpleInterface anotherSimpleInterface = proxyGenerator.doGenerate(ASimpleInterface.class);
  Affirm.affirmTrue("Generated Proxy hashCode() should not return equal values across instances",
      aSimpleInterface.hashCode() != anotherSimpleInterface.hashCode());
}
 

/**
 * Test method for {@link com.openpojo.reflection.impl.PojoMethodImpl#isFinal()}.
 */
@Test
public void testIsFinal() {
  for (PojoMethod pojoMethod : pojoMethods) {
    if (pojoMethod.getName().equals("finalMethod")) {
      Affirm.affirmTrue("Failed to check final", pojoMethod.isFinal());
      return;
    }
  }
  Affirm.fail("finalMethod missing!!");
}
 

@Test
public void canGetEnclosingClass() {
  PojoClass aClassWithNested = PojoClassFactory.getPojoClass(AClassWithNestedClass.class);
  PojoClass nestedClass = PojoClassFactory.getPojoClass(AClassWithNestedClass.NestedClass.class);
  Affirm.affirmTrue("Class should be nested", nestedClass.isNestedClass());

  PojoClass enclosingClass = nestedClass.getEnclosingClass();
  Affirm.affirmNotNull("Enclosing should not be null", enclosingClass);
  Affirm.affirmTrue("Invalid enclosing class", enclosingClass.getClazz().equals(aClassWithNested.getClazz()));
}
 

@Test
public void isPrivateClass() {
  PojoClass pojoclass = getClass(SAMPLE_CLASSES_PKG + ".AccessibilityClass$PrivateClass");
  Affirm.affirmNotNull("class not found", pojoclass);

  Affirm.affirmTrue("isPrivate() check on class=[" + pojoclass + "] returned true!!", pojoclass.isPrivate());
  Affirm.affirmFalse("isPackagePrivate() check on class=[" + pojoclass + "] returned true!!", pojoclass.isPackagePrivate());
  Affirm.affirmFalse("isProtected() check on class=[" + pojoclass + "] returned true!!", pojoclass.isProtected());
  Affirm.affirmFalse("isPublic() check on class=[" + pojoclass + "] returned true!!", pojoclass.isPublic());
}
 

@Test
public void testExtendz() {
  final Class<?> aClassExtendingAnInterfaceAndAbstract = AClassExtendingAnInterface.class;
  final Class<?> anInterface = AnInterfaceClass.class;

  final PojoClass pojoClass = getPojoClassImplForClass(aClassExtendingAnInterfaceAndAbstract);
  Affirm.affirmTrue(String.format("Failed to validate Class=[%s] extending an interface=[%s]" + " for PojoClass " +
      "Implementation=[%s]", aClassExtendingAnInterfaceAndAbstract, anInterface, pojoClass), pojoClass.extendz(anInterface));
}
 

@Test
public void canAccessGetter() {
  boolean found = false;
  for (PojoField pojoField : pojoClass.getPojoFields()) {
    if (pojoField.hasGetter()) {
      PojoMethod getter = pojoField.getGetter();
      Affirm.affirmNotNull("Getter can't be retrieved", getter);
      Object randomInstance = RandomFactory.getRandomValue(pojoField.getType());
      pojoField.set(pojoClassInstance, randomInstance);
      Affirm.affirmSame("Expected same object in and out", randomInstance, getter.invoke(pojoClassInstance));
      found = true;
    }
  }
  Affirm.affirmTrue("No getters were found!", found);
}
 

@Test
public void isPublicClass() {
  PojoClass pojoclass = getClass(SAMPLE_CLASSES_PKG + ".AccessibilityClass$PublicClass");
  Affirm.affirmNotNull("class not found", pojoclass);

  Affirm.affirmTrue("isPublic() check on class=[" + pojoclass + "] returned false!!", pojoclass.isPublic());
  Affirm.affirmFalse("isProtected() check on class=[" + pojoclass + "] returned true!!", pojoclass.isProtected());
  Affirm.affirmFalse("isPrivate() check on class=[" + pojoclass + "] returned true!!", pojoclass.isPrivate());
  Affirm.affirmFalse("isPackagePrivate() check on class=[" + pojoclass + "] returned true!!", pojoclass.isPackagePrivate());
}
 

@Test
public void testToString() {
  Logger log = LoggerFactory.getLogger(getCategory());
  Affirm.affirmTrue(String.format("toString() failed on [%s] got [%s]!", JavaLogger.class.getName(), log.toString()), log
      .toString().startsWith("com.openpojo.log.impl.JavaLogger [@") && log.toString().contains(": logger=java.util" + "" +
      ".logging.Logger@") && log.toString().endsWith("]"));
}
 

@Test
public void testIsPublic() {
  String prefix = "public";
  PojoField pojoField = getFieldStartingWith(prefix);
  Affirm.affirmNotNull("Field not found [" + prefix + "]", pojoField);
  Affirm.affirmTrue("isPublic() check on field=[" + pojoField + "] returned false!!", pojoField.isPublic());
  Affirm.affirmFalse("isPrivate() check on field=[" + pojoField + "] returned true!!", pojoField.isPrivate());
  Affirm.affirmFalse("isPackagePrivate() check on field=[" + pojoField + "] returned true!!", pojoField.isPackagePrivate());
  Affirm.affirmFalse("isProtected() check on field=[" + pojoField + "] returned true!!", pojoField.isProtected());
}
 

@Test
@SuppressWarnings("RedundantArrayCreation")
public void shouldCreateUsingDefaultConstructor() {
  final Class<?> clazz = ClassWithNoDeclaredConstructor.class;
  final Object obj1 = getInstance(clazz, (Object[]) null);
  Affirm.affirmNotNull("Should have created an object", obj1);

  final Object obj2 = getInstance(clazz, new Object[] {});
  Affirm.affirmTrue("Should have created a different object", obj1 != obj2);
}
 

@Test
@SuppressWarnings("unchecked")
public final void shouldReturnSetLogger() throws ClassNotFoundException {
  for (String logger : supportedLoggers) {
    Class<Logger> loggerClass = (Class<Logger>) Class.forName(logger);
    LoggerFactory.setActiveLogger(loggerClass);
    Affirm.affirmTrue(String.format("Expected LoggerFactory to be set to [%s] but was [%s]", loggerClass,
        LoggerFactory.getLogger((String) null)), LoggerFactory.getLogger((String) null).getClass().equals(loggerClass));
  }
}
 

@Test
public void testIsTransient() {
  for (PojoField pojoField : pojoClass.getPojoFields()) {
    if (pojoField.getName().equals("transientString")) {
      Affirm.affirmTrue(String.format("isTransient() check on field=[%s] returned false!!", pojoField), pojoField.isTransient
          ());
    }
  }

}
 

@Test
public final void shouldGetJarSubPackages() {

  JARPackageLoader jarPackage = getJarPackageLoader(packageName);

  Set<String> subPackagesNames = jarPackage.getSubPackages();

  Affirm.affirmEquals(MessageFormatter.format("SubPackages added/removed to {0} found[{1}]?!", packageName, subPackagesNames)
      , expectedSubPackagesNames.length, subPackagesNames.size());

  for (String expectedPackageName : expectedSubPackagesNames) {
    Affirm.affirmTrue(MessageFormatter.format("Expected package[{0}] not found", expectedPackageName),
        subPackagesNames.contains(expectedPackageName));
  }
}
 

@Test
public void isPackagePrivate() {
  String prefix = "packagePrivate";
  PojoField pojoField = getFieldStartingWith(prefix);
  Affirm.affirmNotNull("Field not found [" + prefix + "]", pojoField);
  Affirm.affirmTrue("isPackagePrivate() check on field=[" + pojoField + "] returned false!!", pojoField.isPackagePrivate());
  Affirm.affirmFalse("isPrivate() check on field=[" + pojoField + "] returned true!!", pojoField.isPrivate());
  Affirm.affirmFalse("isPublic() check on field=[" + pojoField + "] returned true!!", pojoField.isPublic());
  Affirm.affirmFalse("isProtected() check on field=[" + pojoField + "] returned true!!", pojoField.isProtected());
}