Java Code Examples for com.sun.codemodel.JAnnotationUse#param()

The following examples show how to use com.sun.codemodel.JAnnotationUse#param() . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.

Example 1

Source File: AnnotationInspectorTest.java From jpa-unit with Apache License 2.0

6 votes

@BeforeClass
public static void generateModel() throws Exception {
    final JCodeModel jCodeModel = new JCodeModel();
    final JPackage jp = jCodeModel.rootPackage();
    final JDefinedClass jClass = jp._class(JMod.PUBLIC, "ClassUnderTest");
    JAnnotationUse jAnnotationUse = jClass.annotate(InitialDataSets.class);
    jAnnotationUse.param("value", "Script.file");
    jClass.annotate(Cleanup.class);
    final JFieldVar jField = jClass.field(JMod.PRIVATE, String.class, "testField");
    jField.annotate(PersistenceContext.class);
    final JMethod jMethod = jClass.method(JMod.PUBLIC, jCodeModel.VOID, "testMethod");
    jAnnotationUse = jMethod.annotate(InitialDataSets.class);
    jAnnotationUse.param("value", "InitialDataSets.file");
    jAnnotationUse = jMethod.annotate(ApplyScriptsAfter.class);
    jAnnotationUse.param("value", "ApplyScriptsAfter.file");

    buildModel(testFolder.getRoot(), jCodeModel);

    compileModel(testFolder.getRoot());

    cut = loadClass(testFolder.getRoot(), jClass.name());
}

Example 2

Source File: ImplementationBuilder.java From aem-component-generator with Apache License 2.0

6 votes

private void addSlingAnnotations(JDefinedClass jDefinedClass, JClass adapterClass, String resourceType) {
    JAnnotationUse jAUse = jDefinedClass.annotate(codeModel.ref(Model.class));
    JAnnotationArrayMember adaptablesArray = jAUse.paramArray("adaptables");
    for (String adaptable : adaptables) {
        if ("resource".equalsIgnoreCase(adaptable)) {
            adaptablesArray.param(codeModel.ref(Resource.class));
        }
        if ("request".equalsIgnoreCase(adaptable)) {
            adaptablesArray.param(codeModel.ref(SlingHttpServletRequest.class));
        }
    }
    if (this.isAllowExporting) {
        jAUse.paramArray("adapters").param(adapterClass).param(codeModel.ref(ComponentExporter.class));
    } else {
        jAUse.param("adapters", adapterClass);
    }
    if (StringUtils.isNotBlank(resourceType)) {
        jAUse.param("resourceType", resourceType);
    }
    if (this.isAllowExporting) {
        jAUse = jDefinedClass.annotate(codeModel.ref(Exporter.class));
        jAUse.param("name", codeModel.ref(ExporterConstants.class).staticRef(SLING_MODEL_EXPORTER_NAME));
        jAUse.param("extensions", codeModel.ref(ExporterConstants.class).staticRef(SLING_MODEL_EXTENSION));
    }
}

Example 3

Source File: JpaUnitRunnerTest.java From jpa-unit with Apache License 2.0

5 votes

@Test
public void testClassWithPersistenceContextWithoutUnitNameSpecified() throws Exception {
    // GIVEN
    final JCodeModel jCodeModel = new JCodeModel();
    final JPackage jp = jCodeModel.rootPackage();
    final JDefinedClass jClass = jp._class(JMod.PUBLIC, "ClassUnderTest");
    final JAnnotationUse jAnnotationUse = jClass.annotate(RunWith.class);
    jAnnotationUse.param("value", JpaUnitRunner.class);
    final JFieldVar emField = jClass.field(JMod.PRIVATE, EntityManager.class, "em");
    emField.annotate(PersistenceContext.class);
    final JMethod jMethod = jClass.method(JMod.PUBLIC, jCodeModel.VOID, "testMethod");
    jMethod.annotate(Test.class);

    buildModel(testFolder.getRoot(), jCodeModel);
    compileModel(testFolder.getRoot());

    final Class<?> cut = loadClass(testFolder.getRoot(), jClass.name());

    final RunListener listener = mock(RunListener.class);
    final RunNotifier notifier = new RunNotifier();
    notifier.addListener(listener);

    final JpaUnitRunner runner = new JpaUnitRunner(cut);

    // WHEN
    runner.run(notifier);

    // THEN
    final ArgumentCaptor<Failure> failureCaptor = ArgumentCaptor.forClass(Failure.class);
    verify(listener).testFailure(failureCaptor.capture());

    final Failure failure = failureCaptor.getValue();
    assertThat(failure.getException().getClass(), equalTo(JpaUnitException.class));
    assertThat(failure.getException().getMessage(), containsString("No Persistence"));
}

Example 4

Source File: SpringFeignClientClassAnnotationRule.java From springmvc-raml-plugin with Apache License 2.0

5 votes

@Override
public JAnnotationUse apply(ApiResourceMetadata controllerMetadata, JDefinedClass generatableType) {
	JAnnotationUse feignClient = generatableType.annotate(FeignClient.class);

	feignClient.param("path", controllerMetadata.getControllerUrl());
	feignClient.param("name", getClientName(controllerMetadata));

	return feignClient;
}

Example 5

Source File: SpringRequestMappingClassAnnotationRule.java From springmvc-raml-plugin with Apache License 2.0

5 votes

@Override
public JAnnotationUse apply(ApiResourceMetadata controllerMetadata, JDefinedClass generatableType) {
	JAnnotationUse requestMapping = generatableType.annotate(RequestMapping.class);
	requestMapping.param("value", controllerMetadata.getControllerUrl());
	try {
		String mediaType = generateMediaType(controllerMetadata);
		if (mediaType != null) {
			requestMapping.param("produces", mediaType);
		}
	} catch (Exception e) {
		throw new InvalidCodeModelException("Your model contains an invalid media type", e);
	}

	return requestMapping;
}

Example 6

Source File: RamlTypeHelper.java From springmvc-raml-plugin with Apache License 2.0

5 votes

/**
 * Adds appropriate <code>pattern</code> attribute to provided annotation on
 * {@link Date} property.
 * 
 * @param jAnnotationUse
 *            annotation to add pattern. Can be for: {@link JsonFormat} or
 *            {@link DateTimeFormat}
 * @param type
 *            RAML type of the property
 * @param format
 *            of date if specified
 */
public static void annotateDateWithPattern(JAnnotationUse jAnnotationUse, String type, String format) {

	String param = type.toUpperCase();
	switch (param) {
		case "DATE-ONLY":
			// example: 2013-09-29
			jAnnotationUse.param("pattern", "yyyy-MM-dd");
			break;
		case "TIME-ONLY":
			// example: 19:46:19
			jAnnotationUse.param("pattern", "HH:mm:ss");
			break;
		case "DATETIME-ONLY":
			// example: 2013-09-29T19:46:19
			jAnnotationUse.param("pattern", "yyyy-MM-dd'T'HH:mm:ss");
			break;
		case "DATETIME":
			if ("rfc2616".equalsIgnoreCase(format)) {
				// example: Tue, 15 Nov 1994 12:45:26 GMT
				jAnnotationUse.param("pattern", "EEE, dd MMM yyyy HH:mm:ss z");
			} else {
				jAnnotationUse.param("pattern", "yyyy-MM-dd'T'HH:mm:ssXXX");
			}
			break;
		default:
			jAnnotationUse.param("pattern", "yyyy-MM-dd'T'HH:mm:ss");
	}
}

Example 7

Source File: SpringShortcutMappingMethodAnnotationRule.java From springmvc-raml-plugin with Apache License 2.0

5 votes

@Override
public JAnnotationUse apply(ApiActionMetadata endpointMetadata, JMethod generatableType) {
	JAnnotationUse requestMappingAnnotation;
	switch (RequestMethod.valueOf(endpointMetadata.getActionType().name())) {
		case GET:
			requestMappingAnnotation = generatableType.annotate(GetMapping.class);
			break;
		case POST:
			requestMappingAnnotation = generatableType.annotate(PostMapping.class);
			break;
		case PUT:
			requestMappingAnnotation = generatableType.annotate(PutMapping.class);
			break;
		case PATCH:
			requestMappingAnnotation = generatableType.annotate(PatchMapping.class);
			break;
		case DELETE:
			requestMappingAnnotation = generatableType.annotate(DeleteMapping.class);
			break;
		default:
			requestMappingAnnotation = generatableType.annotate(RequestMapping.class);
			requestMappingAnnotation.param("method", RequestMethod.valueOf(endpointMetadata.getActionType().name()));
	}

	if (StringUtils.isNotBlank(endpointMetadata.getUrl())) {
		requestMappingAnnotation.param("value", endpointMetadata.getUrl());
	}
	return requestMappingAnnotation;
}

Example 8

Source File: ImmutableJaxbGenerator.java From rice with Educational Community License v2.0

5 votes

private void renderField(JDefinedClass classModel, FieldModel fieldModel) {
	JFieldVar field = classModel.field(JMod.PRIVATE | JMod.FINAL, fieldModel.fieldType, fieldModel.fieldName);
	JAnnotationUse annotation = field.annotate(XmlElement.class);
	if (Util.isCommonElement(fieldModel.fieldName)) {
		JClass coreConstants = codeModel.ref(CoreConstants.class);
		JFieldRef commonElementsRef = coreConstants.staticRef("CommonElements");
		annotation.param("name", commonElementsRef.ref(Util.toConstantsVariable(fieldModel.fieldName)));
	} else {
		JClass elementsClass = codeModel.ref(Util.ELEMENTS_CLASS_NAME);
		JFieldRef fieldXmlNameRef = elementsClass.staticRef(Util.toConstantsVariable(fieldModel.fieldName));
		annotation.param("name", fieldXmlNameRef);
	}
	annotation.param("required", false);
}

Example 9

Source File: ImmutableJaxbGenerator.java From rice with Educational Community License v2.0

5 votes

private void renderFutureElementsField(JDefinedClass classModel) throws Exception {
	JType collectionType = codeModel.parseType("java.util.Collection<org.w3c.dom.Element>");
	JFieldVar field = classModel.field(JMod.PRIVATE | JMod.FINAL, collectionType, "_futureElements");
	field.init(JExpr._null());
	JAnnotationUse annotation = field.annotate(SuppressWarnings.class);
	annotation.param("value", "unused");
	field.annotate(XmlAnyElement.class);
}

Example 10

Source File: JpaUnitRunnerTest.java From jpa-unit with Apache License 2.0

5 votes

@Test
public void testClassWithPersistenceContextWithKonfiguredUnitNameSpecified() throws Exception {
    // GIVEN
    final JCodeModel jCodeModel = new JCodeModel();
    final JPackage jp = jCodeModel.rootPackage();
    final JDefinedClass jClass = jp._class(JMod.PUBLIC, "ClassUnderTest");
    final JAnnotationUse jAnnotationUse = jClass.annotate(RunWith.class);
    jAnnotationUse.param("value", JpaUnitRunner.class);
    final JFieldVar emField = jClass.field(JMod.PRIVATE, EntityManager.class, "em");
    final JAnnotationUse jAnnotation = emField.annotate(PersistenceContext.class);
    jAnnotation.param("unitName", "test-unit-1");
    final JMethod jMethod = jClass.method(JMod.PUBLIC, jCodeModel.VOID, "testMethod");
    jMethod.annotate(Test.class);

    buildModel(testFolder.getRoot(), jCodeModel);
    compileModel(testFolder.getRoot());

    final Class<?> cut = loadClass(testFolder.getRoot(), jClass.name());
    final JpaUnitRunner runner = new JpaUnitRunner(cut);

    final RunListener listener = mock(RunListener.class);
    final RunNotifier notifier = new RunNotifier();
    notifier.addListener(listener);

    // WHEN
    runner.run(notifier);

    // THEN
    final ArgumentCaptor<Description> descriptionCaptor = ArgumentCaptor.forClass(Description.class);
    verify(listener).testStarted(descriptionCaptor.capture());
    assertThat(descriptionCaptor.getValue().getClassName(), equalTo("ClassUnderTest"));
    assertThat(descriptionCaptor.getValue().getMethodName(), equalTo("testMethod"));

    verify(listener).testFinished(descriptionCaptor.capture());
    assertThat(descriptionCaptor.getValue().getClassName(), equalTo("ClassUnderTest"));
    assertThat(descriptionCaptor.getValue().getMethodName(), equalTo("testMethod"));
}

Example 11

Source File: JpaUnitRunnerTest.java From jpa-unit with Apache License 2.0

5 votes

@Test
public void testClassWithPersistenceUnitWithoutUnitNameSpecified() throws Exception {
    // GIVEN
    final JCodeModel jCodeModel = new JCodeModel();
    final JPackage jp = jCodeModel.rootPackage();
    final JDefinedClass jClass = jp._class(JMod.PUBLIC, "ClassUnderTest");
    final JAnnotationUse jAnnotationUse = jClass.annotate(RunWith.class);
    jAnnotationUse.param("value", JpaUnitRunner.class);
    final JFieldVar emField = jClass.field(JMod.PRIVATE, EntityManagerFactory.class, "emf");
    emField.annotate(PersistenceUnit.class);
    final JMethod jMethod = jClass.method(JMod.PUBLIC, jCodeModel.VOID, "testMethod");
    jMethod.annotate(Test.class);

    buildModel(testFolder.getRoot(), jCodeModel);
    compileModel(testFolder.getRoot());

    final Class<?> cut = loadClass(testFolder.getRoot(), jClass.name());

    final RunListener listener = mock(RunListener.class);
    final RunNotifier notifier = new RunNotifier();
    notifier.addListener(listener);

    final JpaUnitRunner runner = new JpaUnitRunner(cut);

    // WHEN
    runner.run(notifier);

    // THEN
    final ArgumentCaptor<Failure> failureCaptor = ArgumentCaptor.forClass(Failure.class);
    verify(listener).testFailure(failureCaptor.capture());

    final Failure failure = failureCaptor.getValue();
    assertThat(failure.getException().getClass(), equalTo(JpaUnitException.class));
    assertThat(failure.getException().getMessage(), containsString("No Persistence"));
}

Example 12

Source File: JpaUnitRunnerTest.java From jpa-unit with Apache License 2.0

5 votes

@Test
public void testClassWithPersistenceUnitFieldOfWrongType() throws Exception {
    // GIVEN
    final JCodeModel jCodeModel = new JCodeModel();
    final JPackage jp = jCodeModel.rootPackage();
    final JDefinedClass jClass = jp._class(JMod.PUBLIC, "ClassUnderTest");
    final JAnnotationUse jAnnotationUse = jClass.annotate(RunWith.class);
    jAnnotationUse.param("value", JpaUnitRunner.class);
    final JFieldVar emField = jClass.field(JMod.PRIVATE, EntityManager.class, "emf");
    emField.annotate(PersistenceUnit.class);
    final JMethod jMethod = jClass.method(JMod.PUBLIC, jCodeModel.VOID, "testMethod");
    jMethod.annotate(Test.class);

    buildModel(testFolder.getRoot(), jCodeModel);
    compileModel(testFolder.getRoot());

    final Class<?> cut = loadClass(testFolder.getRoot(), jClass.name());

    final RunListener listener = mock(RunListener.class);
    final RunNotifier notifier = new RunNotifier();
    notifier.addListener(listener);

    final JpaUnitRunner runner = new JpaUnitRunner(cut);

    // WHEN
    runner.run(notifier);

    // THEN
    final ArgumentCaptor<Failure> failureCaptor = ArgumentCaptor.forClass(Failure.class);
    verify(listener).testFailure(failureCaptor.capture());

    final Failure failure = failureCaptor.getValue();
    assertThat(failure.getException().getClass(), equalTo(IllegalArgumentException.class));
    assertThat(failure.getException().getMessage(),
            containsString("annotated with @PersistenceUnit is not of type EntityManagerFactory"));
}

Example 13

Source File: ImmutableJaxbGenerator.java From rice with Educational Community License v2.0

5 votes

private void renderClassLevelAnnotations(JDefinedClass classModel, List<FieldModel> fields) throws Exception {
	JFieldRef constantsClass = classModel.staticRef(Util.CONSTANTS_CLASS_NAME);
	JFieldRef elementsClass = classModel.staticRef(Util.ELEMENTS_CLASS_NAME);
	JClass coreConstants = codeModel.ref(CoreConstants.class);
	JFieldRef commonElementsRef = coreConstants.staticRef("CommonElements");
	
	// XmlRootElement
	JAnnotationUse rootElementAnnotation = classModel.annotate(XmlRootElement.class);
	rootElementAnnotation.param("name", constantsClass.ref(Util.ROOT_ELEMENT_NAME_FIELD));
	
	// XmlAccessorType
	JAnnotationUse xmlAccessorTypeAnnotation = classModel.annotate(XmlAccessorType.class);
	xmlAccessorTypeAnnotation.param("value", XmlAccessType.NONE);
	
	// XmlType
	JAnnotationUse xmlTypeAnnotation = classModel.annotate(XmlType.class);
	xmlTypeAnnotation.param("name", constantsClass.ref(Util.TYPE_NAME_FIELD));
	JAnnotationArrayMember propOrderMember = xmlTypeAnnotation.paramArray("propOrder");
	for (FieldModel field : fields) {
		if (Util.isCommonElement(field.fieldName)) {
			propOrderMember.param(commonElementsRef.ref(Util.toConstantsVariable(field.fieldName)));
		} else {
			propOrderMember.param(elementsClass.ref(Util.toConstantsVariable(field.fieldName)));
		}
	}
	propOrderMember.param(commonElementsRef.ref("FUTURE_ELEMENTS"));
}

Example 14

Source File: JpaUnitRunnerTest.java From jpa-unit with Apache License 2.0

5 votes

@Test
public void testClassWithPersistenceContextAndPersistenceUnitFields() throws Exception {
    // GIVEN
    final JCodeModel jCodeModel = new JCodeModel();
    final JPackage jp = jCodeModel.rootPackage();
    final JDefinedClass jClass = jp._class(JMod.PUBLIC, "ClassUnderTest");
    final JAnnotationUse jAnnotationUse = jClass.annotate(RunWith.class);
    jAnnotationUse.param("value", JpaUnitRunner.class);
    final JFieldVar emf1Field = jClass.field(JMod.PRIVATE, EntityManager.class, "em");
    emf1Field.annotate(PersistenceContext.class);
    final JFieldVar emf2Field = jClass.field(JMod.PRIVATE, EntityManagerFactory.class, "emf");
    emf2Field.annotate(PersistenceUnit.class);
    final JMethod jMethod = jClass.method(JMod.PUBLIC, jCodeModel.VOID, "testMethod");
    jMethod.annotate(Test.class);

    buildModel(testFolder.getRoot(), jCodeModel);
    compileModel(testFolder.getRoot());

    final Class<?> cut = loadClass(testFolder.getRoot(), jClass.name());

    final RunListener listener = mock(RunListener.class);
    final RunNotifier notifier = new RunNotifier();
    notifier.addListener(listener);

    final JpaUnitRunner runner = new JpaUnitRunner(cut);

    // WHEN
    runner.run(notifier);

    // THEN
    final ArgumentCaptor<Failure> failureCaptor = ArgumentCaptor.forClass(Failure.class);
    verify(listener).testFailure(failureCaptor.capture());

    final Failure failure = failureCaptor.getValue();
    assertThat(failure.getException().getClass(), equalTo(IllegalArgumentException.class));
    assertThat(failure.getException().getMessage(), containsString("either @PersistenceUnit or @PersistenceContext"));
}

Example 15

Source File: JaxbValidationsPlugins.java From krasa-jaxb-tools with Apache License 2.0

5 votes

private void annotateMultiplePattern(final List<XSFacet> patternList, final JAnnotationUse patternAnnotation) {
    StringBuilder sb = new StringBuilder();
    for (XSFacet xsFacet : patternList) {
        final String value = xsFacet.getValue().value;
        // cxf-codegen fix
        if (!"\\c+".equals(value)) {
            sb.append("(").append(replaceXmlProprietals(value)).append(")|");
        }
    }
    patternAnnotation.param("regexp", sb.substring(0, sb.length() - 1));
}

Example 16

Source File: JpaUnitRunnerTest.java From jpa-unit with Apache License 2.0

5 votes

@Test
public void testClassWithoutPersistenceContextField() throws Exception {
    // GIVEN
    final JCodeModel jCodeModel = new JCodeModel();
    final JPackage jp = jCodeModel.rootPackage();
    final JDefinedClass jClass = jp._class(JMod.PUBLIC, "ClassUnderTest");
    final JAnnotationUse jAnnotationUse = jClass.annotate(RunWith.class);
    jAnnotationUse.param("value", JpaUnitRunner.class);
    final JMethod jMethod = jClass.method(JMod.PUBLIC, jCodeModel.VOID, "testMethod");
    jMethod.annotate(Test.class);

    buildModel(testFolder.getRoot(), jCodeModel);
    compileModel(testFolder.getRoot());

    final Class<?> cut = loadClass(testFolder.getRoot(), jClass.name());
    final RunListener listener = mock(RunListener.class);
    final RunNotifier notifier = new RunNotifier();
    notifier.addListener(listener);

    final JpaUnitRunner runner = new JpaUnitRunner(cut);

    // WHEN
    runner.run(notifier);

    // THEN
    final ArgumentCaptor<Failure> failureCaptor = ArgumentCaptor.forClass(Failure.class);
    verify(listener).testFailure(failureCaptor.capture());

    final Failure failure = failureCaptor.getValue();
    assertThat(failure.getException().getClass(), equalTo(IllegalArgumentException.class));
    assertThat(failure.getException().getMessage(), containsString("EntityManagerFactory or EntityManager field annotated"));
}

Example 17

Source File: JpaUnitRuleTest.java From jpa-unit with Apache License 2.0

5 votes

@Test
public void testClassWithPersistenceUnitWithKonfiguredUnitNameSpecified() throws Exception {
    // GIVEN
    final JCodeModel jCodeModel = new JCodeModel();
    final JPackage jp = jCodeModel.rootPackage();
    final JDefinedClass jClass = jp._class(JMod.PUBLIC, "ClassUnderTest");
    final JFieldVar ruleField = jClass.field(JMod.PUBLIC, JpaUnitRule.class, "rule");
    ruleField.annotate(Rule.class);
    final JInvocation instance = JExpr._new(jCodeModel.ref(JpaUnitRule.class)).arg(JExpr.direct("getClass()"));
    ruleField.init(instance);
    final JFieldVar emField = jClass.field(JMod.PRIVATE, EntityManagerFactory.class, "emf");
    final JAnnotationUse jAnnotation = emField.annotate(PersistenceUnit.class);
    jAnnotation.param("unitName", "test-unit-1");
    final JMethod jMethod = jClass.method(JMod.PUBLIC, jCodeModel.VOID, "testMethod");
    jMethod.annotate(Test.class);

    buildModel(testFolder.getRoot(), jCodeModel);
    compileModel(testFolder.getRoot());

    final Class<?> cut = loadClass(testFolder.getRoot(), jClass.name());
    final BlockJUnit4ClassRunner runner = new BlockJUnit4ClassRunner(cut);

    final RunListener listener = mock(RunListener.class);
    final RunNotifier notifier = new RunNotifier();
    notifier.addListener(listener);

    // WHEN
    runner.run(notifier);

    // THEN
    final ArgumentCaptor<Description> descriptionCaptor = ArgumentCaptor.forClass(Description.class);
    verify(listener).testStarted(descriptionCaptor.capture());
    assertThat(descriptionCaptor.getValue().getClassName(), equalTo("ClassUnderTest"));
    assertThat(descriptionCaptor.getValue().getMethodName(), equalTo("testMethod"));

    verify(listener).testFinished(descriptionCaptor.capture());
    assertThat(descriptionCaptor.getValue().getClassName(), equalTo("ClassUnderTest"));
    assertThat(descriptionCaptor.getValue().getMethodName(), equalTo("testMethod"));
}

Example 18

Source File: MethodParamsRule.java From springmvc-raml-plugin with Apache License 2.0

4 votes

protected JVar paramQueryForm(ApiParameterMetadata paramMetaData, CodeModelHelper.JExtMethod generatableType,
		ApiActionMetadata endpointMetadata) {

	String javaName = paramMetaData.getJavaName();

	if (addParameterJavadoc) {
		String paramComment = "";
		if (paramMetaData.getRamlParam() != null && StringUtils.hasText(paramMetaData.getRamlParam().getDescription())) {
			paramComment = NamingHelper.cleanForJavadoc(paramMetaData.getRamlParam().getDescription());
		}
		generatableType.get().javadoc().addParam(javaName + " " + paramComment);
	}

	JClass type = null;
	if (paramMetaData.getRamlParam() instanceof RJP10V2RamlUriParameter && paramMetaData.isNullable()) {
		// for optional uri parameters use java.util.Optional since Spring
		// doesn't support optional uri parameters
		type = generatableType.owner().ref(Optional.class).narrow(paramMetaData.getType());
	}
	if (type == null) {
		type = generatableType.owner().ref(paramMetaData.getType());
	}

	if (!allowArrayParameters && paramMetaData.isArray()) {
		type = generatableType.owner().ref(paramMetaData.getType().getComponentType());
	} else {
		// TODO should this be blank?
	}

	JVar jVar = null;

	// data types as query parameters
	RamlAbstractParam ramlParam = paramMetaData.getRamlParam();
	if (ramlParam.getType() == RamlParamType.DATA_TYPE && ramlParam instanceof RJP10V2RamlQueryParameter) {
		JClass jc = findFirstClassBySimpleName(paramMetaData.getCodeModel(), ramlParam.getRawType());
		jVar = generatableType.get().param(jc, paramMetaData.getName());

		if (Config.getPojoConfig().isIncludeJsr303Annotations() && !RamlActionType.PATCH.equals(endpointMetadata.getActionType())
				&& jVar.type() instanceof JDefinedClass) {
			// skip Valid annotation for PATCH actions since it's a partial
			// update so some required fields might be omitted
			boolean isPOJO = ((JDefinedClass) jVar.type())._package().name().startsWith(Config.getBasePackage());
			if (isPOJO) {
				jVar.annotate(Valid.class);
			}
		}
		return jVar;
	}

	jVar = generatableType.get().param(type, javaName);
	if (paramMetaData.getRamlParam().getPattern() != null) {
		jVar.annotate(Pattern.class).param("regexp", paramMetaData.getRamlParam().getPattern());
	}

	if (paramMetaData.getRamlParam().getMinLength() != null || paramMetaData.getRamlParam().getMaxLength() != null) {
		JAnnotationUse jAnnotationUse = jVar.annotate(Size.class);
		if (paramMetaData.getRamlParam().getMinLength() != null) {
			jAnnotationUse.param("min", paramMetaData.getRamlParam().getMinLength());
		}
		if (paramMetaData.getRamlParam().getMaxLength() != null) {
			jAnnotationUse.param("max", paramMetaData.getRamlParam().getMaxLength());
		}
	}

	if (paramMetaData.getRamlParam().getMinimum() != null) {
		jVar.annotate(Min.class).param("value", paramMetaData.getRamlParam().getMinimum().longValue());
	}
	if (paramMetaData.getRamlParam().getMaximum() != null) {
		jVar.annotate(Max.class).param("value", paramMetaData.getRamlParam().getMaximum().longValue());
	}

	return jVar;
}

Example 19

Source File: JpaUnitRuleTest.java From jpa-unit with Apache License 2.0

4 votes

@Test
public void testClassWithPersistenceContextWithWithOverwrittenConfiguration() throws Exception {
    // GIVEN
    final JCodeModel jCodeModel = new JCodeModel();
    final JPackage jp = jCodeModel.rootPackage();
    final JDefinedClass jClass = jp._class(JMod.PUBLIC, "ClassUnderTest");
    final JFieldVar ruleField = jClass.field(JMod.PUBLIC, JpaUnitRule.class, "rule");
    ruleField.annotate(Rule.class);
    final JInvocation instance = JExpr._new(jCodeModel.ref(JpaUnitRule.class)).arg(JExpr.direct("getClass()"));
    ruleField.init(instance);
    final JFieldVar emField = jClass.field(JMod.PRIVATE, EntityManager.class, "em");
    final JAnnotationUse jAnnotation = emField.annotate(PersistenceContext.class);
    jAnnotation.param("unitName", "test-unit-1");
    final JAnnotationArrayMember propArray = jAnnotation.paramArray("properties");
    propArray.annotate(PersistenceProperty.class).param("name", "javax.persistence.jdbc.url").param("value",
            "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1");
    propArray.annotate(PersistenceProperty.class).param("name", "javax.persistence.jdbc.driver").param("value", "org.h2.Driver");
    propArray.annotate(PersistenceProperty.class).param("name", "javax.persistence.jdbc.password").param("value", "test");
    propArray.annotate(PersistenceProperty.class).param("name", "javax.persistence.jdbc.user").param("value", "test");
    final JMethod jMethod = jClass.method(JMod.PUBLIC, jCodeModel.VOID, "testMethod");
    jMethod.annotate(Test.class);

    buildModel(testFolder.getRoot(), jCodeModel);
    compileModel(testFolder.getRoot());

    final Class<?> cut = loadClass(testFolder.getRoot(), jClass.name());
    final BlockJUnit4ClassRunner runner = new BlockJUnit4ClassRunner(cut);

    final RunListener listener = mock(RunListener.class);
    final RunNotifier notifier = new RunNotifier();
    notifier.addListener(listener);

    // WHEN
    runner.run(notifier);

    // THEN
    final ArgumentCaptor<Description> descriptionCaptor = ArgumentCaptor.forClass(Description.class);
    verify(listener).testStarted(descriptionCaptor.capture());
    assertThat(descriptionCaptor.getValue().getClassName(), equalTo("ClassUnderTest"));
    assertThat(descriptionCaptor.getValue().getMethodName(), equalTo("testMethod"));

    verify(listener).testFinished(descriptionCaptor.capture());
    assertThat(descriptionCaptor.getValue().getClassName(), equalTo("ClassUnderTest"));
    assertThat(descriptionCaptor.getValue().getMethodName(), equalTo("testMethod"));
}

Example 20

Source File: CodeCreator.java From jaxb-visitor with Apache License 2.0

4 votes

void setOutput(JDefinedClass output) {
    JAnnotationUse annotationUse = output.annotate(Generated.class);
    annotationUse.param("value", "Generated by jaxb-visitor");
    this.output = output;
}