@Override public int compare(FrameworkField o1, FrameworkField o2) { return Integer.compare(o1.getAnnotation(Service.class).value(), o2.getAnnotation(Service.class).value()); } });
@Override public int compare(FrameworkField o1, FrameworkField o2) { return Integer.compare(o1.getAnnotation(Service.class).value(), o2.getAnnotation(Service.class).value()); } });
private static void inflateCustom(FrameworkField field, Object target) throws IllegalArgumentException, IllegalAccessException { GenerateCustom annotation = field.getAnnotation(GenerateCustom.class); AlchemyGenerator<?> generator = GenerateCustom.Values.createGeneratorFor(annotation); Object value = generator.get(); inflate(field, target, value); }
private static void inflateInteger(FrameworkField field, Object target) throws IllegalArgumentException, IllegalAccessException { GenerateInteger annotation = field.getAnnotation(GenerateInteger.class); checkNotNull(annotation, "missing annotation"); AlchemyGenerator<Integer> generator = GenerateInteger.Values.createGeneratorFor(annotation); Integer value = generator.get(); inflate(field, target, value); }
private static void inflatePojo(FrameworkField field, Object target) throws IllegalArgumentException, IllegalAccessException { Class<?> typeOfPojo = field.getType(); GeneratePojo annotation = field.getAnnotation(GeneratePojo.class); AlchemyGenerator<?> generator = GeneratePojo.Values.createGeneratorFor(annotation, typeOfPojo); Object value = generator.get(); inflate(field, target, value); }
private static void inflateEnum(FrameworkField field, Object target) throws IllegalArgumentException, IllegalAccessException { Class<?> typeOfField = field.getType(); checkThat(typeOfField.isEnum(), "@GenerateEnum can only be used on Enum Types"); Class<? extends Enum> typeOfEnum = (Class<? extends Enum>) typeOfField; GenerateEnum annotation = field.getAnnotation(GenerateEnum.class); AlchemyGenerator<?> generator = GenerateEnum.Values.createGeneratorFor(annotation, typeOfEnum); Object value = generator.get(); inflate(field, target, value); }
private static void inflateList(FrameworkField field, Object target) throws IllegalArgumentException, IllegalAccessException { Class<?> typeOfField = field.getType(); checkThat(List.class.isAssignableFrom(typeOfField), "@GenerateList can only be used on List Types"); GenerateList annotation = field.getAnnotation(GenerateList.class); AlchemyGenerator<?> generator = GenerateList.Values.createGeneratorFor(annotation); Object value = generator.get(); inflate(field, target, value); }
private static void inflateFloat(FrameworkField field, Object target) throws IllegalAccessException { GenerateFloat annotation = field.getAnnotation(GenerateFloat.class); checkNotNull(annotation, "missing annotation"); AlchemyGenerator<Float> generator = GenerateFloat.Values.createGeneratorFor(annotation); Float value = generator.get(); inflate(field, target, value); }
private static void inflateBoolean(FrameworkField field, Object target) throws IllegalArgumentException, IllegalAccessException { GenerateBoolean annotation = field.getAnnotation(GenerateBoolean.class); checkNotNull(annotation, "missing annotation: @GenerateBoolean"); AlchemyGenerator<Boolean> generator = GenerateBoolean.Values.createGeneratorFor(annotation); Boolean value = generator.get(); inflate(field, target, value); }
private static void inflateUrl(FrameworkField field, Object target) throws IllegalAccessException { GenerateURL annotation = field.getAnnotation(GenerateURL.class); checkNotNull(annotation, "missing annotation"); AlchemyGenerator<URL> generator = GenerateURL.Values.createGeneratorFor(annotation); URL value = generator.get(); inflate(field, target, value); }
private static void inflateString(FrameworkField field, Object target) throws IllegalArgumentException, IllegalAccessException { GenerateString annotation = field.getAnnotation(GenerateString.class); checkNotNull(annotation, "missing annotation"); AlchemyGenerator<String> generator = GenerateString.Values.createGeneratorFor(annotation); String value = generator.get(); inflate(field, target, value); }
private static void inflateLong(FrameworkField field, Object target) throws IllegalAccessException { GenerateLong annotation = field.getAnnotation(GenerateLong.class); checkNotNull(annotation, "missing annotation"); AlchemyGenerator<Long> generator = GenerateLong.Values.createGeneratorFor(annotation); Long value = generator.get(); inflate(field, target, value); }
private static void inflateDouble(FrameworkField field, Object target) throws IllegalAccessException { GenerateDouble annotation = field.getAnnotation(GenerateDouble.class); checkNotNull(annotation, "missing annotation"); AlchemyGenerator<Double> generator = GenerateDouble.Values.createGeneratorFor(annotation); Double value = generator.get(); inflate(field, target, value); }
errors.add(new Exception("Param Getter Field " + f.getName() + " should be final.")); xdean.junit.ex.param.annotation.Param anno = f.getAnnotation(xdean.junit.ex.param.annotation.Param.class); if (!isParamProviderType(anno, field.getGenericType())) { errors.add(new Exception("Param Getter Field " + f.getName() + " should be "
/******************************************************************************/ @SuppressWarnings("unchecked") protected List<P> getParamValues() { List<Pair<ParamType, Object>> list = new ArrayList<>(); getTestClass().getAnnotatedFields(xdean.junit.ex.param.annotation.Param.class) .forEach(f -> list.add(Pair.of(f.getAnnotation(xdean.junit.ex.param.annotation.Param.class).value(), uncheck(() -> f.get(null))))); getTestClass().getAnnotatedMethods(xdean.junit.ex.param.annotation.Param.class) .forEach(m -> list.add(Pair.of(m.getAnnotation(xdean.junit.ex.param.annotation.Param.class).value(), invoke(m)))); return list.stream().flatMap(pair -> { ParamType type = pair.getLeft(); Object value = pair.getRight(); switch (type) { case VALUE: return Stream.of((P) value); case ARRAY: return Stream.of((P[]) PrimitiveTypeUtil.toWrapperArray(value)); case LIST: return ((List<P>) value).stream(); case UNDEFINED: default: throw new Error("Never happened"); } }).collect(Collectors.toList()); }
private static void inflateDate(FrameworkField field, Object target) throws IllegalArgumentException, IllegalAccessException { GenerateDate annotation = field.getAnnotation(GenerateDate.class); checkNotNull(annotation, "missing annotation"); AlchemyGenerator<Date> generator = GenerateDate.Values.createGeneratorFor(annotation); Object value; if (field.getType() == java.sql.Timestamp.class) { AlchemyGenerator<Timestamp> timestampGenerator = DateGeneratorsKt.asSqlTimestampGenerator(generator); value = timestampGenerator.get(); } else if (field.getType() == java.sql.Date.class) { AlchemyGenerator<java.sql.Date> sqlGenerator = DateGeneratorsKt.asSqlDateGenerator(generator); value = sqlGenerator.get(); } else { value = generator.get(); } inflate(field, target, value); }