Java Code Examples for com.openpojo.reflection.impl.PojoClassFactory#getPojoClass()

@Test(expected = UnsupportedOperationException.class)
public void shouldNotBeAbleToConstruct() {
  try {
    PojoClass pojoClass = PojoClassFactory.getPojoClass(ClassReaderFactory.class);
    org.testng.Assert.assertEquals(1, pojoClass.getPojoConstructors().size());
    InstanceFactory.getLeastCompleteInstance(pojoClass);
  } catch (ReflectionException re) {
    Throwable cause = re.getCause();
    while (cause != null) {
      if (cause instanceof UnsupportedOperationException)
        throw (UnsupportedOperationException) cause;
      cause = cause.getCause();
    }
  }
  Assert.fail("Should have not been able to construct");
}
 

@Test(expected = UnsupportedOperationException.class)
public void shouldNotBeAbleToConstruct() {
  try {
    PojoClass classUtilPojoClass = PojoClassFactory.getPojoClass(ClassUtil.class);
    Assert.assertEquals(1, classUtilPojoClass.getPojoConstructors().size());
    InstanceFactory.getLeastCompleteInstance(classUtilPojoClass);
  } catch (ReflectionException re) {
    Throwable cause = re.getCause();
    while (cause != null) {
      if (cause instanceof UnsupportedOperationException)
        throw (UnsupportedOperationException) cause;
      cause = cause.getCause();
    }
  }
  Assert.fail("Should have not been able to construct");
}
 

@Test
public void testBooleanVariations() {
  PojoClass pojoClass = PojoClassFactory.getPojoClass(ClassWithBooleanFields.class);

  Affirm.affirmEquals("Fields must be 4", 4, pojoClass.getPojoFields().size());

  int countOfbooleans = 0;
  int countOfBooleans = 0;

  for (PojoField pojoField : pojoClass.getPojoFields()) {
    if (pojoField.isPrimitive() && pojoField.getType() == boolean.class) {
      countOfbooleans++;
    }
    if (!pojoField.isPrimitive() && pojoField.getType() == Boolean.class) {
      countOfBooleans++;
    }
  }

  Affirm.affirmEquals("2 boolean fields must exist", 2, countOfbooleans);
  Affirm.affirmEquals("2 Boolean fields must exist", 2, countOfBooleans);

  Validator pojoValidator = ValidatorBuilder.create()
      .with(new GetterMustExistRule())
      .with(new SetterMustExistRule())
      .with(new GetterTester())
      .with(new SetterTester())
      .build();

  pojoValidator.validate(pojoClass);
}
 

@Test
public void givenAnAbstractClassWithConstructorShouldConstruct() {
  PojoClass pojoClass = PojoClassFactory.getPojoClass(AnAbstractClassWithConstructor.class);
  Class<?> subClass = getSubClass(pojoClass.getClazz());

  assertIsConcreteAndConstructable(subClass);
}
 

@Test
public void shouldPassWhenEqualsAndHashCodeAreImplemented() {
  PojoClass aClassImplementingEqualsAndHashcode = PojoClassFactory.getPojoClass(AClassImplementingEqualsAndHashCode.class);
  List<PojoMethod> methods = aClassImplementingEqualsAndHashcode.getPojoMethods();

  Assert.assertEquals(3, methods.size());

  boolean constructorFound = false;
  boolean equalsFound = false;
  boolean hashCodeFound = false;

  for (PojoMethod method : methods) {
    if (method.isConstructor())
      constructorFound = true;
    if (method.getName().equals("hashCode")
        && method.getPojoParameters().size() == 0
        && method.getReturnType().equals(int.class))
      hashCodeFound = true;
    if (method.getName().equals("equals")
        && method.getPojoParameters().size() == 1
        && method.getReturnType().equals(boolean.class))
      equalsFound = true;
  }

  Assert.assertTrue("Constructor not found", constructorFound);
  Assert.assertTrue("Equals not found", equalsFound);
  Assert.assertTrue("hashCode not found", hashCodeFound);

  rule.evaluate(aClassImplementingEqualsAndHashcode);
}
 

@Test
public void shouldInvokeUsingConstructorArgs() {
  final Class<AbstractClassWithConstructorArgs> type = AbstractClassWithConstructorArgs.class;
  PojoClass pojoClass = PojoClassFactory.getPojoClass(type);

  assertThat(pojoClass.isAbstract(), is(true));
  assertThat(pojoClass.getPojoConstructors().size(), is(1));
  final List<PojoParameter> constructorParameters = pojoClass.getPojoConstructors().get(0).getPojoParameters();

  assertThat(constructorParameters .size(), is(12));
  int index = 0;

  assertType(constructorParameters.get(index++).getType(), String.class);
  assertType(constructorParameters.get(index++).getType(), boolean.class);
  assertType(constructorParameters.get(index++).getType(), byte.class);
  assertType(constructorParameters.get(index++).getType(), char.class);
  assertType(constructorParameters.get(index++).getType(), double.class);
  assertType(constructorParameters.get(index++).getType(), float.class);
  assertType(constructorParameters.get(index++).getType(), int.class);
  assertType(constructorParameters.get(index++).getType(), long.class);
  assertType(constructorParameters.get(index++).getType(), short.class);
  assertType(constructorParameters.get(index++).getType(), int[].class);
  assertType(constructorParameters.get(index++).getType(), String[].class);
  assertType(constructorParameters.get(index).getType(), List.class);

  AbstractClassWithConstructorArgs ap = getRandomValue(type);
  assertThat(ap, notNullValue());
}
 

@Test
public void shouldNotFailIfNonSerializableIsTransient() {
  Class clazz = SerializableTest_SerializableWithTransientNonSerializableField.class;
  PojoClass pojoClass = PojoClassFactory.getPojoClass(clazz);

  serializableTester.run(pojoClass);
}
 

@Test
public void testIsStaticFinal() {
  PojoClass pojoClass = PojoClassFactory.getPojoClass(StaticFinalData.class);
  List<PojoField> pojoFields = pojoClass.getPojoFields();
  Assert.assertEquals(4, pojoFields.size());
  for (PojoField fieldEntry : pojoFields) {
    if (fieldEntry.getName().equals("staticAndNotFinal")) {
      Assert.assertTrue("Static and not Final test failed!!",
          fieldEntry.isStatic()
              && !fieldEntry.isFinal()
              && !ValidationHelper.isStaticFinal(fieldEntry));
    }
    if (fieldEntry.getName().equals("notStaticAndNotFinal")) {
      Assert.assertTrue("Not static OR final test failed!!",
          !fieldEntry.isStatic()
              && !fieldEntry.isFinal()
              && !ValidationHelper.isStaticFinal(fieldEntry));
    }
    if (fieldEntry.getName().equals("STATIC_AND_FINAL")) {
      Assert.assertTrue("Static AND Final test failed!!!",
          fieldEntry.isStatic()
              && fieldEntry.isFinal()
              && ValidationHelper.isStaticFinal(fieldEntry));
    }
    if (fieldEntry.getName().equals("finalAndNotStatic")) {
      Assert.assertTrue("Final and not Static test failed!!",
          !fieldEntry.isStatic()
              && fieldEntry.isFinal()
              && !ValidationHelper.isStaticFinal(fieldEntry));
    }
  }
}
 

public Object doGenerate(final Class<?> type) {
  final PojoClass pojoClass = PojoClassFactory.getPojoClass(type);

  final Enum<?>[] values = getValues(pojoClass);
  if (values.length == 0)
    throw RandomGeneratorException.getInstance("Can't generate random value for Enum class [" + type + "] enum doesn't " +
        "define any values");
  return values[RANDOM.nextInt(values.length)];
}
 

@Test
public void ensureAChildWithFieldShadowingIsAccurateWW() {
  PojoClass aChildWithFieldShadowing = PojoClassFactory.getPojoClass(NoShadowAChildWithFieldShadowing.class);
  List<PojoField> pojoFields = aChildWithFieldShadowing.getPojoFields();
  Assert.assertThat(pojoFields.size(), is(1));
  Assert.assertThat(pojoFields.get(0).getName(), is("aField"));
}
 

@Test
public void exhaustiveTest() {
  PojoClass pojoClass = PojoClassFactory.getPojoClass(AClassWithExhaustiveCollection.class);
  Validator pojoValidator = ValidatorBuilder.create()
      .with(new SetterMustExistRule())
      .with(new SetterTester())
      .build();

  pojoValidator.validate(pojoClass);
}
 

public Object doGenerate(Class<?> type) {
  try {
    PojoClass pojoClass = PojoClassFactory.getPojoClass(principalNameClass);
    return InstanceFactory.getInstance(pojoClass, getPrincipleParsableString());
  } catch (Exception e) {
    throw RandomGeneratorException.getInstance("Failed to generate " + TYPE + " instance.", e);
  }
}
 

@Test
public void givenAnAbstractClassWithGenericConstructorShouldConstruct() {
  PojoClass pojoClass = PojoClassFactory.getPojoClass(AnAbstractClassWithGenericConstructor.class);
  Class<?> subClass = getSubClass(pojoClass.getClazz());

  assertIsConcreteAndConstructable(subClass);
}
 

private PojoField getPojoField() {
  PojoClass pojoClass = PojoClassFactory.getPojoClass(sampleClass);
  return pojoClass.getPojoFields().get(0);
}
 

protected PojoClass getPojoClass() {
  return PojoClassFactory.getPojoClass(PrincipalNameRandomGenerator.class);
}
 

protected void testStructureAndBehavior(final Class<?> clazz) {
    final PojoClass pojoClass = PojoClassFactory.getPojoClass(clazz);
    this.pojoValidator.validate(pojoClass);
}
 

@Test(expected = AssertionError.class)
public void shouldFailValidationWithIntegerFieldAndPrimitiveIntParameterSetter() {
  final PojoClass pojoClass = PojoClassFactory.getPojoClass(ClassWithIntegerFieldAndPrimitiveIntParameterSetter.class);
  final Validator pojoValidator = ValidatorBuilder.create().with(new SetterMustExistRule()).build();
  pojoValidator.validate(pojoClass);
}
 

@Before
public void setUp() {
  pojoClass = PojoClassFactory.getPojoClass(ClassAggregatingAbstractClass.class);
  RandomGeneratorService randomGeneratorService = ServiceRegistrar.getInstance().getRandomGeneratorService();
  randomGeneratorService.registerRandomGenerator(new AbstractClassRandomGenerator());
}
 

private static PojoClass wrapAbstractClass(final PojoClass pojoClass) {
  return PojoClassFactory.getPojoClass(ByteCodeFactory.getSubClass(pojoClass.getClazz()));
}
 

@Test(expected = AssertionError.class)
public void shouldFailValidationWithPrimitiveIntFieldAndIntegerParameterSetter() {
  final PojoClass pojoClass = PojoClassFactory.getPojoClass(ClassWithPrimitiveIntFieldAndIntegerParameterSetter.class);
  final Validator pojoValidator = ValidatorBuilder.create().with(new SetterMustExistRule()).build();
  pojoValidator.validate(pojoClass);
}