From 6490c2070deb0755f8c0e11aa4b5c36717ed41aa Mon Sep 17 00:00:00 2001 From: nbhusare Date: Mon, 11 May 2020 16:10:29 +0530 Subject: [PATCH] Added support for Java stub generation Signed-off-by: nbhusare --- .../xtext/generator/junit/JUnitFragment.xtend | 106 ++++++++--- .../xtext/generator/junit/JUnitFragment.java | 165 +++++++++++++++++- 2 files changed, 246 insertions(+), 25 deletions(-) diff --git a/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/junit/JUnitFragment.xtend b/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/junit/JUnitFragment.xtend index b38b9bd39..5bedb5f6d 100644 --- a/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/junit/JUnitFragment.xtend +++ b/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/junit/JUnitFragment.xtend @@ -1,9 +1,9 @@ /******************************************************************************* - * Copyright (c) 2015, 2018 itemis AG (http://www.itemis.eu) and others. + * Copyright (c) 2015, 2020 itemis AG (http://www.itemis.eu) and others. * This program and the accompanying materials are made available under the * terms of the Eclipse Public License 2.0 which is available at * http://www.eclipse.org/legal/epl-2.0. - * + * * SPDX-License-Identifier: EPL-2.0 *******************************************************************************/ package org.eclipse.xtext.xtext.generator.junit @@ -25,33 +25,41 @@ import static extension org.eclipse.xtext.GrammarUtil.* * @since 2.14 */ class JUnitFragment extends AbstractStubGeneratingFragment { - + @Inject extension XtextGeneratorNaming @Inject FileAccessFactory fileAccessFactory - + @Accessors(PUBLIC_SETTER) boolean useDeprecatedClasses - + @Accessors(PUBLIC_SETTER) boolean skipXbaseTestingPackage - + JUnitVersion junitVersion = JUnitVersion.JUNIT_4 - - def void setJunitVersion (String version) { + + new() { + /** + * The old implementation generated JUnit stub by default. + * We set the value of generateXtendStub to true to remain backward compatible. + */ + generateXtendStub = true + } + + def void setJunitVersion(String version) { junitVersion = JUnitVersion.fromString(version) } - + def protected getTestingPackage() { if (useDeprecatedClasses) getUiTestingPackage() else "org.eclipse.xtext.testing" } - + protected def String getUiTestingPackage() { "org.eclipse.xtext.ui.testing" } - + def protected getXbaseTestingPackage() { if (skipXbaseTestingPackage) return "" @@ -60,13 +68,13 @@ class JUnitFragment extends AbstractStubGeneratingFragment { else "org.eclipse.xtext.xbase.testing" } - + protected def String getXbaseUiTestingPackage() { if (skipXbaseTestingPackage) return "" "org.eclipse.xtext.xbase.junit" } - + override generate() { if (projectConfig.runtimeTest.manifest !== null) { projectConfig.runtimeTest.manifest => [ @@ -75,7 +83,7 @@ class JUnitFragment extends AbstractStubGeneratingFragment { xbaseTestingPackage, 'org.eclipse.xtext.xbase.lib;bundle-version="'+projectConfig.runtime.xbaseLibVersionLowerBound+'"' ) - exportedPackages.add(grammar.runtimeTestBasePackage+";x-internal=true") + exportedPackages.add(grammar.runtimeTestBasePackage + ";x-internal=true") ] } if (projectConfig.eclipsePluginTest.manifest !== null) { @@ -88,26 +96,31 @@ class JUnitFragment extends AbstractStubGeneratingFragment { "org.eclipse.core.runtime", "org.eclipse.ui.workbench;resolution:=optional" ) - exportedPackages.add(grammar.eclipsePluginTestBasePackage+";x-internal=true") + exportedPackages.add(grammar.eclipsePluginTestBasePackage + ";x-internal=true") ] } if (projectConfig.eclipsePlugin.manifest !== null) { projectConfig.eclipsePlugin.manifest.exportedPackages.add(eclipsePluginActivator.packageName) } - + generateInjectorProvider.writeTo(projectConfig.runtimeTest.srcGen) - if (isGenerateStub) - generateExampleRuntimeTest.writeTo(projectConfig.runtimeTest.src) + if (isGenerateStub) { + if (generateXtendStub) { + generateExampleRuntimeTest.writeTo(projectConfig.runtimeTest.src) + } else { + generateJavaExampleRuntimeTest.writeTo(projectConfig.runtimeTest.src) + } + } if (projectConfig.eclipsePlugin.srcGen !== null) generateUiInjectorProvider.writeTo(projectConfig.eclipsePluginTest.srcGen) } - + def protected JavaFileAccess generateExampleRuntimeTest() { val xtextRunner = new TypeReference(testingPackage + ".XtextRunner") val runWith = new TypeReference("org.junit.runner.RunWith") val injectWith = new TypeReference(testingPackage + ".InjectWith") val extendWith = new TypeReference("org.junit.jupiter.api.^extension.ExtendWith") - val injectionExtension = new TypeReference("org.eclipse.xtext.testing.extensions.InjectionExtension") + val injectionExtension = new TypeReference("org.eclipse.xtext.testing.extensions.InjectionExtension") val parseHelper = new TypeReference(testingPackage + ".util.ParseHelper") val test = switch (junitVersion) { case JUnitVersion.JUNIT_4: new TypeReference("org.junit.Test") @@ -147,7 +160,54 @@ class JUnitFragment extends AbstractStubGeneratingFragment { } ''') } - + + def protected JavaFileAccess generateJavaExampleRuntimeTest() { + val xtextRunner = new TypeReference(testingPackage + ".XtextRunner") + val runWith = new TypeReference("org.junit.runner.RunWith") + val extendWith = new TypeReference("org.junit.jupiter.api.extension.ExtendWith") + val injectionExtension = new TypeReference("org.eclipse.xtext.testing.extensions.InjectionExtension") + val injectWith = new TypeReference(testingPackage + ".InjectWith") + val parseHelper = new TypeReference(testingPackage + ".util.ParseHelper") + val test = switch (junitVersion) { + case JUnitVersion.JUNIT_4: new TypeReference("org.junit.Test") + case JUnitVersion.JUNIT_5: new TypeReference("org.junit.jupiter.api.Test") + } + val assert = switch (junitVersion) { + case JUnitVersion.JUNIT_4: new TypeReference("org.junit.Assert") + case JUnitVersion.JUNIT_5: new TypeReference("org.junit.jupiter.api.Assertions") + } + val rootType = new TypeReference(grammar.rules.head.type.classifier as EClass, grammar.eResource.resourceSet) + val list = new TypeReference("java.util.List") + val diagnostic = new TypeReference("org.eclipse.emf.ecore.resource", "Resource.Diagnostic") + val iterableExtensions = new TypeReference("org.eclipse.xtext.xbase.lib.IterableExtensions") + return fileAccessFactory.createJavaFile(exampleRuntimeTest, ''' + «IF junitVersion==JUnitVersion.JUNIT_4» + @«runWith»(«xtextRunner».class) + «ENDIF» + «IF junitVersion==JUnitVersion.JUNIT_5» + @«extendWith»(«injectionExtension».class) + «ENDIF» + @«injectWith»(«injectorProvider».class) + public class «exampleRuntimeTest» { + @«Inject» + private «parseHelper»<«rootType»> parseHelper; + + @«test» + public void loadModel() throws Exception { + Model result = parseHelper.parse("Hello Xtext!"); + «assert».assertNotNull(result); + «list»<«diagnostic»> errors = result.eResource().getErrors(); + «IF junitVersion==JUnitVersion.JUNIT_4» + «assert».assertTrue("Unexpected errors: " + «iterableExtensions».join(errors, ", "), errors.isEmpty()); + «ENDIF» + «IF junitVersion==JUnitVersion.JUNIT_5» + «assert».assertTrue(errors.isEmpty(), "Unexpected errors: " + «iterableExtensions».join(errors, ", ")); + «ENDIF» + } + } + ''') + } + def protected exampleRuntimeTest() { new TypeReference(grammar.runtimeTestBasePackage, grammar.simpleName + "ParsingTest") } @@ -218,7 +278,7 @@ class JUnitFragment extends AbstractStubGeneratingFragment { ''' file } - + def protected TypeReference iInjectorProvider() { new TypeReference(testingPackage + ".IInjectorProvider") } @@ -245,4 +305,4 @@ class JUnitFragment extends AbstractStubGeneratingFragment { def protected TypeReference uiInjectorProvider() { new TypeReference(grammar.eclipsePluginTestBasePackage, grammar.simpleName + "UiInjectorProvider") } -} \ No newline at end of file +} diff --git a/org.eclipse.xtext.xtext.generator/xtend-gen/org/eclipse/xtext/xtext/generator/junit/JUnitFragment.java b/org.eclipse.xtext.xtext.generator/xtend-gen/org/eclipse/xtext/xtext/generator/junit/JUnitFragment.java index 940cf9019..fc397423e 100644 --- a/org.eclipse.xtext.xtext.generator/xtend-gen/org/eclipse/xtext/xtext/generator/junit/JUnitFragment.java +++ b/org.eclipse.xtext.xtext.generator/xtend-gen/org/eclipse/xtext/xtext/generator/junit/JUnitFragment.java @@ -1,5 +1,5 @@ /** - * Copyright (c) 2015, 2018 itemis AG (http://www.itemis.eu) and others. + * Copyright (c) 2015, 2020 itemis AG (http://www.itemis.eu) and others. * This program and the accompanying materials are made available under the * terms of the Eclipse Public License 2.0 which is available at * http://www.eclipse.org/legal/epl-2.0. @@ -53,6 +53,10 @@ public class JUnitFragment extends AbstractStubGeneratingFragment { private JUnitVersion junitVersion = JUnitVersion.JUNIT_4; + public JUnitFragment() { + this.setGenerateXtendStub(true); + } + public void setJunitVersion(final String version) { this.junitVersion = JUnitVersion.fromString(version); } @@ -144,7 +148,12 @@ public class JUnitFragment extends AbstractStubGeneratingFragment { this.generateInjectorProvider().writeTo(this.getProjectConfig().getRuntimeTest().getSrcGen()); boolean _isGenerateStub = this.isGenerateStub(); if (_isGenerateStub) { - this.generateExampleRuntimeTest().writeTo(this.getProjectConfig().getRuntimeTest().getSrc()); + boolean _isGenerateXtendStub = this.isGenerateXtendStub(); + if (_isGenerateXtendStub) { + this.generateExampleRuntimeTest().writeTo(this.getProjectConfig().getRuntimeTest().getSrc()); + } else { + this.generateJavaExampleRuntimeTest().writeTo(this.getProjectConfig().getRuntimeTest().getSrc()); + } } IXtextGeneratorFileSystemAccess _srcGen = this.getProjectConfig().getEclipsePlugin().getSrcGen(); boolean _tripleNotEquals_3 = (_srcGen != null); @@ -314,6 +323,158 @@ public class JUnitFragment extends AbstractStubGeneratingFragment { return this.fileAccessFactory.createXtendFile(_exampleRuntimeTest, _client); } + protected JavaFileAccess generateJavaExampleRuntimeTest() { + String _testingPackage = this.getTestingPackage(); + String _plus = (_testingPackage + ".XtextRunner"); + final TypeReference xtextRunner = new TypeReference(_plus); + final TypeReference runWith = new TypeReference("org.junit.runner.RunWith"); + final TypeReference extendWith = new TypeReference("org.junit.jupiter.api.extension.ExtendWith"); + final TypeReference injectionExtension = new TypeReference("org.eclipse.xtext.testing.extensions.InjectionExtension"); + String _testingPackage_1 = this.getTestingPackage(); + String _plus_1 = (_testingPackage_1 + ".InjectWith"); + final TypeReference injectWith = new TypeReference(_plus_1); + String _testingPackage_2 = this.getTestingPackage(); + String _plus_2 = (_testingPackage_2 + ".util.ParseHelper"); + final TypeReference parseHelper = new TypeReference(_plus_2); + TypeReference _switchResult = null; + final JUnitVersion junitVersion = this.junitVersion; + if (junitVersion != null) { + switch (junitVersion) { + case JUNIT_4: + _switchResult = new TypeReference("org.junit.Test"); + break; + case JUNIT_5: + _switchResult = new TypeReference("org.junit.jupiter.api.Test"); + break; + default: + break; + } + } + final TypeReference test = _switchResult; + TypeReference _switchResult_1 = null; + final JUnitVersion junitVersion_1 = this.junitVersion; + if (junitVersion_1 != null) { + switch (junitVersion_1) { + case JUNIT_4: + _switchResult_1 = new TypeReference("org.junit.Assert"); + break; + case JUNIT_5: + _switchResult_1 = new TypeReference("org.junit.jupiter.api.Assertions"); + break; + default: + break; + } + } + final TypeReference assert_ = _switchResult_1; + EClassifier _classifier = IterableExtensions.head(this.getGrammar().getRules()).getType().getClassifier(); + ResourceSet _resourceSet = this.getGrammar().eResource().getResourceSet(); + final TypeReference rootType = new TypeReference(((EClass) _classifier), _resourceSet); + final TypeReference list = new TypeReference("java.util.List"); + final TypeReference diagnostic = new TypeReference("org.eclipse.emf.ecore.resource", "Resource.Diagnostic"); + final TypeReference iterableExtensions = new TypeReference("org.eclipse.xtext.xbase.lib.IterableExtensions"); + TypeReference _exampleRuntimeTest = this.exampleRuntimeTest(); + StringConcatenationClient _client = new StringConcatenationClient() { + @Override + protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) { + { + boolean _equals = Objects.equal(JUnitFragment.this.junitVersion, JUnitVersion.JUNIT_4); + if (_equals) { + _builder.append("@"); + _builder.append(runWith); + _builder.append("("); + _builder.append(xtextRunner); + _builder.append(".class)"); + _builder.newLineIfNotEmpty(); + } + } + { + boolean _equals_1 = Objects.equal(JUnitFragment.this.junitVersion, JUnitVersion.JUNIT_5); + if (_equals_1) { + _builder.append("@"); + _builder.append(extendWith); + _builder.append("("); + _builder.append(injectionExtension); + _builder.append(".class)"); + _builder.newLineIfNotEmpty(); + } + } + _builder.append("@"); + _builder.append(injectWith); + _builder.append("("); + TypeReference _injectorProvider = JUnitFragment.this.injectorProvider(); + _builder.append(_injectorProvider); + _builder.append(".class)"); + _builder.newLineIfNotEmpty(); + _builder.append("public class "); + TypeReference _exampleRuntimeTest = JUnitFragment.this.exampleRuntimeTest(); + _builder.append(_exampleRuntimeTest); + _builder.append(" {"); + _builder.newLineIfNotEmpty(); + _builder.append("\t"); + _builder.append("@"); + _builder.append(Inject.class, "\t"); + _builder.newLineIfNotEmpty(); + _builder.append("\t"); + _builder.append("private "); + _builder.append(parseHelper, "\t"); + _builder.append("<"); + _builder.append(rootType, "\t"); + _builder.append("> parseHelper;"); + _builder.newLineIfNotEmpty(); + _builder.append("\t"); + _builder.newLine(); + _builder.append("\t"); + _builder.append("@"); + _builder.append(test, "\t"); + _builder.newLineIfNotEmpty(); + _builder.append("\t"); + _builder.append("public void loadModel() throws Exception {"); + _builder.newLine(); + _builder.append("\t\t"); + _builder.append("Model result = parseHelper.parse(\"Hello Xtext!\");"); + _builder.newLine(); + _builder.append("\t\t"); + _builder.append(assert_, "\t\t"); + _builder.append(".assertNotNull(result);"); + _builder.newLineIfNotEmpty(); + _builder.append("\t\t"); + _builder.append(list, "\t\t"); + _builder.append("<"); + _builder.append(diagnostic, "\t\t"); + _builder.append("> errors = result.eResource().getErrors();"); + _builder.newLineIfNotEmpty(); + { + boolean _equals_2 = Objects.equal(JUnitFragment.this.junitVersion, JUnitVersion.JUNIT_4); + if (_equals_2) { + _builder.append("\t\t"); + _builder.append(assert_, "\t\t"); + _builder.append(".assertTrue(\"Unexpected errors: \" + "); + _builder.append(iterableExtensions, "\t\t"); + _builder.append(".join(errors, \", \"), errors.isEmpty());"); + _builder.newLineIfNotEmpty(); + } + } + { + boolean _equals_3 = Objects.equal(JUnitFragment.this.junitVersion, JUnitVersion.JUNIT_5); + if (_equals_3) { + _builder.append("\t\t"); + _builder.append(assert_, "\t\t"); + _builder.append(".assertTrue(errors.isEmpty(), \"Unexpected errors: \" + "); + _builder.append(iterableExtensions, "\t\t"); + _builder.append(".join(errors, \", \"));"); + _builder.newLineIfNotEmpty(); + } + } + _builder.append("\t"); + _builder.append("}"); + _builder.newLine(); + _builder.append("}"); + _builder.newLine(); + } + }; + return this.fileAccessFactory.createJavaFile(_exampleRuntimeTest, _client); + } + protected TypeReference exampleRuntimeTest() { String _runtimeTestBasePackage = this._xtextGeneratorNaming.getRuntimeTestBasePackage(this.getGrammar()); String _simpleName = GrammarUtil.getSimpleName(this.getGrammar());