diff options
author | Manoj Palat | 2019-09-19 08:30:33 +0000 |
---|---|---|
committer | Sarika Sinha | 2019-09-19 09:48:37 +0000 |
commit | a3466b0f64e8842e5ed6a3a28165da341fb76cc0 (patch) | |
tree | adc5e09ee603628bfbb88a247a105743b26d47fc /org.eclipse.jdt.compiler.apt.tests | |
parent | c842004634d661ef8d9d485e77e9c84af231e888 (diff) | |
download | eclipse.jdt.core-a3466b0f64e8842e5ed6a3a28165da341fb76cc0.tar.gz eclipse.jdt.core-a3466b0f64e8842e5ed6a3a28165da341fb76cc0.tar.xz eclipse.jdt.core-a3466b0f64e8842e5ed6a3a28165da341fb76cc0.zip |
Merge remote-tracking branch 'origin/BETA_JAVA13'I20190919-1800I20190919-0850
# Conflicts:
# org.eclipse.jdt.compiler.apt/META-INF/MANIFEST.MF
# org.eclipse.jdt.compiler.apt/pom.xml
# org.eclipse.jdt.core.tests.compiler/META-INF/MANIFEST.MF
# org.eclipse.jdt.core.tests.compiler/pom.xml
# org.eclipse.jdt.core.tests.model/META-INF/MANIFEST.MF
# org.eclipse.jdt.core.tests.model/pom.xml
# org.eclipse.jdt.core/META-INF/MANIFEST.MF
# org.eclipse.jdt.core/pom.xml
Change-Id: I2562d3b2833b1b63e3b8cfc46eb533bffcae6bd9
Diffstat (limited to 'org.eclipse.jdt.compiler.apt.tests')
11 files changed, 357 insertions, 7 deletions
diff --git a/org.eclipse.jdt.compiler.apt.tests/.classpath b/org.eclipse.jdt.compiler.apt.tests/.classpath index 8102373411..6d7726d275 100644 --- a/org.eclipse.jdt.compiler.apt.tests/.classpath +++ b/org.eclipse.jdt.compiler.apt.tests/.classpath @@ -16,7 +16,7 @@ </attributes> </classpathentry> <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/> - <classpathentry kind="lib" path="lib/java10api.jar"/> + <classpathentry kind="lib" path="lib/java13api.jar"/> <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/> <classpathentry kind="output" path="bin"/> </classpath> diff --git a/org.eclipse.jdt.compiler.apt.tests/META-INF/MANIFEST.MF b/org.eclipse.jdt.compiler.apt.tests/META-INF/MANIFEST.MF index 1a73c03f52..6c7e345b25 100644 --- a/org.eclipse.jdt.compiler.apt.tests/META-INF/MANIFEST.MF +++ b/org.eclipse.jdt.compiler.apt.tests/META-INF/MANIFEST.MF @@ -2,7 +2,7 @@ Manifest-Version: 1.0 Bundle-ManifestVersion: 2 Bundle-Name: %pluginName Bundle-SymbolicName: org.eclipse.jdt.compiler.apt.tests;singleton:=true -Bundle-Version: 1.1.900.qualifier +Bundle-Version: 1.1.850.qualifier Bundle-Vendor: %providerName Bundle-Localization: plugin Bundle-RequiredExecutionEnvironment: JavaSE-1.8 @@ -19,6 +19,6 @@ Export-Package: org.eclipse.jdt.compiler.apt.tests, org.eclipse.jdt.compiler.apt.tests.processors.visitors Import-Package: org.eclipse.jdt.internal.compiler.tool;resolution:=optional Eclipse-BundleShape: dir -Bundle-ClassPath: lib/java10api.jar, +Bundle-ClassPath: lib/java13api.jar, . Automatic-Module-Name: org.eclipse.jdt.compiler.apt.tests diff --git a/org.eclipse.jdt.compiler.apt.tests/build.properties b/org.eclipse.jdt.compiler.apt.tests/build.properties index e9a85ccd3b..cddfe5d640 100644 --- a/org.eclipse.jdt.compiler.apt.tests/build.properties +++ b/org.eclipse.jdt.compiler.apt.tests/build.properties @@ -27,4 +27,4 @@ bin.includes = about.html,\ . src.includes = about.html compilerArg=-proc:none -jars.extra.classpath = lib/java10api.jar +jars.extra.classpath = lib/java13api.jar diff --git a/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors8.jar b/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors8.jar Binary files differindex e51a6bcf7f..c0e46191a6 100644 --- a/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors8.jar +++ b/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors8.jar diff --git a/org.eclipse.jdt.compiler.apt.tests/lib/java10api.jar b/org.eclipse.jdt.compiler.apt.tests/lib/java13api.jar Binary files differindex 464b69134f..d8bbb8b501 100644 --- a/org.eclipse.jdt.compiler.apt.tests/lib/java10api.jar +++ b/org.eclipse.jdt.compiler.apt.tests/lib/java13api.jar diff --git a/org.eclipse.jdt.compiler.apt.tests/pom.xml b/org.eclipse.jdt.compiler.apt.tests/pom.xml index 8406059ff3..06f74dd605 100644 --- a/org.eclipse.jdt.compiler.apt.tests/pom.xml +++ b/org.eclipse.jdt.compiler.apt.tests/pom.xml @@ -20,7 +20,7 @@ </parent> <groupId>org.eclipse.jdt</groupId> <artifactId>org.eclipse.jdt.compiler.apt.tests</artifactId> - <version>1.1.900-SNAPSHOT</version> + <version>1.1.850-SNAPSHOT</version> <packaging>eclipse-test-plugin</packaging> <properties> diff --git a/org.eclipse.jdt.compiler.apt.tests/processors8/META-INF/services/javax.annotation.processing.Processor b/org.eclipse.jdt.compiler.apt.tests/processors8/META-INF/services/javax.annotation.processing.Processor index 22707a258c..f706af86b9 100644 --- a/org.eclipse.jdt.compiler.apt.tests/processors8/META-INF/services/javax.annotation.processing.Processor +++ b/org.eclipse.jdt.compiler.apt.tests/processors8/META-INF/services/javax.annotation.processing.Processor @@ -2,3 +2,4 @@ org.eclipse.jdt.compiler.apt.tests.processors.elements.Java8ElementProcessor org.eclipse.jdt.compiler.apt.tests.processors.elements.Java9ElementProcessor
org.eclipse.jdt.compiler.apt.tests.processors.elements.Java11ElementProcessor
org.eclipse.jdt.compiler.apt.tests.processors.elements.Java12ElementProcessor
+org.eclipse.jdt.compiler.apt.tests.processors.elements.Java13ElementProcessor
diff --git a/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java11ElementProcessor.java b/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java11ElementProcessor.java index 590205e9d7..71cae2d8e7 100644 --- a/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java11ElementProcessor.java +++ b/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java11ElementProcessor.java @@ -33,7 +33,7 @@ import javax.tools.JavaFileObject; import org.eclipse.jdt.compiler.apt.tests.processors.base.BaseProcessor; /** - * A processor that explores the java 9 specific elements and validates the lambda and + * A processor that explores the java 11 specific elements and validates the lambda and * type annotated elements. To enable this processor, add * -Aorg.eclipse.jdt.compiler.apt.tests.processors.elements.Java11ElementProcessor to the command line. * @since 3.14 diff --git a/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java12ElementProcessor.java b/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java12ElementProcessor.java index f8699c6b7c..51c634a4f8 100644 --- a/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java12ElementProcessor.java +++ b/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java12ElementProcessor.java @@ -40,7 +40,7 @@ import javax.lang.model.element.TypeElement; import org.eclipse.jdt.compiler.apt.tests.processors.base.BaseProcessor; /** - * A processor that explores the java 9 specific elements and validates the lambda and + * A processor that explores the java 12 specific elements and validates the lambda and * type annotated elements. To enable this processor, add * -Aorg.eclipse.jdt.compiler.apt.tests.processors.elements.Java11ElementProcessor to the command line. * @since 3.14 diff --git a/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java13ElementProcessor.java b/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java13ElementProcessor.java new file mode 100644 index 0000000000..5dcb8be92a --- /dev/null +++ b/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java13ElementProcessor.java @@ -0,0 +1,251 @@ +/******************************************************************************* + * Copyright (c) 2019 IBM Corporation. + * + * This program and the accompanying materials + * are made available under the terms of the Eclipse Public License 2.0 + * which accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ + +package org.eclipse.jdt.compiler.apt.tests.processors.elements; + +import java.io.IOException; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.annotation.processing.Filer; +import javax.annotation.processing.Messager; +import javax.annotation.processing.ProcessingEnvironment; +import javax.annotation.processing.RoundEnvironment; +import javax.annotation.processing.SupportedAnnotationTypes; +import javax.lang.model.element.Element; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.ModuleElement; +import javax.lang.model.element.PackageElement; +import javax.lang.model.element.TypeElement; + +import org.eclipse.jdt.internal.compiler.apt.dispatch.BaseProcessingEnvImpl; +import org.eclipse.jdt.compiler.apt.tests.processors.base.BaseProcessor; + +/** + * A processor that explores the java 13 specific elements and validates the lambda and + * type annotated elements. To enable this processor, add + * -Aorg.eclipse.jdt.compiler.apt.tests.processors.elements.Java11ElementProcessor to the command line. + * @since 3.14 + */ +@SupportedAnnotationTypes("*") +public class Java13ElementProcessor extends BaseProcessor { + boolean reportSuccessAlready = true; + RoundEnvironment roundEnv = null; + Messager _messager = null; + Filer _filer = null; + boolean isBinaryMode = false; + String mode; + @Override + public synchronized void init(ProcessingEnvironment processingEnv) { + super.init(processingEnv); + _elementUtils = processingEnv.getElementUtils(); + _messager = processingEnv.getMessager(); + _filer = processingEnv.getFiler(); + } + // Always return false from this processor, because it supports "*". + // The return value does not signify success or failure! + @Override + public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { + if (roundEnv.processingOver()) { + return false; + } + + this.roundEnv = roundEnv; + Map<String, String> options = processingEnv.getOptions(); + if (!options.containsKey(this.getClass().getName())) { + // Disable this processor unless we are intentionally performing the test. + return false; + } else { + try { + if (options.containsKey("binary")) { + this.isBinaryMode = true; + this.mode = "binary"; + } else { + this.mode = "source"; + } + if (!invokeTestMethods(options)) { + testAll(); + } + if (this.reportSuccessAlready) { + super.reportSuccess(); + } + } catch (AssertionFailedError e) { + super.reportError(getExceptionStackTrace(e)); + } catch (Throwable e) { + e.printStackTrace(); + } + } + return false; + } + + private boolean invokeTestMethods(Map<String, String> options) throws Throwable { + Method testMethod = null; + Set<String> keys = options.keySet(); + boolean testsFound = false; + for (String option : keys) { + if (option.startsWith("test")) { + try { + testMethod = this.getClass().getDeclaredMethod(option, new Class[0]); + if (testMethod != null) { + testsFound = true; + testMethod.invoke(this, new Object[0]); + } + } catch (InvocationTargetException e) { + throw e.getCause(); + } catch (Exception e) { + super.reportError(getExceptionStackTrace(e)); + } + } + } + return testsFound; + } + + public void testAll() throws AssertionFailedError, IOException { + testPreviewFlagTrue(); + testPreviewFlagFalse(); + } + + public void testPreviewFlagTrue() throws IOException { + if (this.processingEnv instanceof BaseProcessingEnvImpl) { + boolean preview = ((BaseProcessingEnvImpl) this.processingEnv).isPreviewEnabled(); + assertTrue("Preview flag not seen as enabled", preview); + } + } + public void testPreviewFlagFalse() throws IOException { + if (this.processingEnv instanceof BaseProcessingEnvImpl) { + boolean preview = ((BaseProcessingEnvImpl) this.processingEnv).isPreviewEnabled(); + assertFalse("Preview flag not seen as enabled", preview); + } + } + + @Override + public void reportError(String msg) { + throw new AssertionFailedError(msg); + } + private String getExceptionStackTrace(Throwable t) { + StringBuffer buf = new StringBuffer(t.getMessage()); + StackTraceElement[] traces = t.getStackTrace(); + for (int i = 0; i < traces.length; i++) { + StackTraceElement trace = traces[i]; + buf.append("\n\tat " + trace); + if (i == 12) + break; // Don't dump all stacks + } + return buf.toString(); + } + protected String getElementsAsString(List<? extends Element> list) { + StringBuilder builder = new StringBuilder("["); + for (Element element : list) { + if (element instanceof PackageElement) { + builder.append(((PackageElement) element).getQualifiedName()); + } else if (element instanceof ModuleElement) { + builder.append(((ModuleElement) element).getQualifiedName()); + } else if (element instanceof TypeElement) { + builder.append(((TypeElement) element).getQualifiedName()); + } else { + builder.append(element.getSimpleName()); + } + builder.append(", "); + } + builder.append("]"); + return builder.toString(); + } + public void assertModifiers(Set<Modifier> modifiers, String[] expected) { + assertEquals("Incorrect no of modifiers", modifiers.size(), expected.length); + Set<String> actual = new HashSet<String>(expected.length); + for (Modifier modifier : modifiers) { + actual.add(modifier.toString()); + } + for(int i = 0, length = expected.length; i < length; i++) { + boolean result = actual.remove(expected[i]); + if (!result) reportError("Modifier not present :" + expected[i]); + } + if (!actual.isEmpty()) { + reportError("Unexpected modifiers present:" + actual.toString()); + } + } + public void assertTrue(String msg, boolean value) { + if (!value) reportError(msg); + } + public void assertFalse(String msg, boolean value) { + if (value) reportError(msg); + } + public void assertSame(String msg, Object obj1, Object obj2) { + if (obj1 != obj2) { + reportError(msg + ", should be " + obj1.toString() + " but " + obj2.toString()); + } + } + public void assertNotSame(String msg, Object obj1, Object obj2) { + if (obj1 == obj2) { + reportError(msg + ", " + obj1.toString() + " should not be same as " + obj2.toString()); + } + } + public void assertNotNull(String msg, Object obj) { + if (obj == null) { + reportError(msg); + } + } + public void assertNull(String msg, Object obj) { + if (obj != null) { + reportError(msg); + } + } + public void assertEquals(String message, Object expected, Object actual) { + if (equalsRegardingNull(expected, actual)) { + return; + } else { + reportError(message + ", expected " + expected.toString() + " but was " + actual.toString()); + } + } + + public void assertEquals(String message, Object expected, Object alternateExpected, Object actual) { + if (equalsRegardingNull(expected, actual) || equalsRegardingNull(alternateExpected, actual)) { + return; + } else { + reportError(message + ", expected " + expected.toString() + " but was " + actual.toString()); + } + } + + static boolean equalsRegardingNull(Object expected, Object actual) { + if (expected == null) { + return actual == null; + } + return expected.equals(actual); + } + + public void assertEquals(String msg, int expected, int actual) { + if (expected != actual) { + StringBuffer buf = new StringBuffer(); + buf.append(msg); + buf.append(", expected " + expected + " but was " + actual); + reportError(buf.toString()); + } + } + public void assertEquals(Object expected, Object actual) { + if (expected != actual) { + + } + } + private class AssertionFailedError extends Error { + private static final long serialVersionUID = 1L; + + public AssertionFailedError(String msg) { + super(msg); + } + } +} diff --git a/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/Java13ElementsTests.java b/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/Java13ElementsTests.java new file mode 100644 index 0000000000..78aa8b7204 --- /dev/null +++ b/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/Java13ElementsTests.java @@ -0,0 +1,98 @@ +/******************************************************************************* + * Copyright (c) 2019 IBM Corporation. + * + * This program and the accompanying materials + * are made available under the terms of the Eclipse Public License 2.0 + * which accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ + +package org.eclipse.jdt.compiler.apt.tests; + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import javax.lang.model.SourceVersion; +import javax.tools.JavaCompiler; + +import org.eclipse.jdt.internal.compiler.tool.EclipseCompiler; + +import junit.framework.TestCase; + +public class Java13ElementsTests extends TestCase { + private static final String MODULE_PROC = "org.eclipse.jdt.compiler.apt.tests.processors.elements.Java13ElementProcessor"; + + public void testPreviewFlagTrue() throws IOException { + JavaCompiler compiler = BatchTestUtils.getEclipseCompiler(); + internalTestWithPreview(compiler, MODULE_PROC, "13", "testPreviewFlagTrue", null, "modules2", true); + } + public void testPreviewFlagFalse() throws IOException { + JavaCompiler compiler = BatchTestUtils.getEclipseCompiler(); + internalTestWithPreview(compiler, MODULE_PROC, "13", "testPreviewFlagFalse", null, "modules2", false); + } + + protected void internalTestWithPreview(JavaCompiler compiler, String processor, String compliance, + String testMethod, String testClass, String resourceArea, boolean preview) throws IOException { + if (!canRunJava13()) { + return; + } + System.clearProperty(processor); + File targetFolder = TestUtils.concatPath(BatchTestUtils.getSrcFolderName(), "mod_locations", resourceArea); + if (testClass == null || testClass.equals("")) { + BatchTestUtils.copyResources("mod_locations/" + resourceArea, targetFolder); + } else { + BatchTestUtils.copyResource("mod_locations/" + resourceArea + "/" + testClass, targetFolder); + } + + List<String> options = new ArrayList<String>(); + options.add("-A" + processor); + options.add("-A" + testMethod); + options.add("-processor"); + options.add(processor); + // Javac 1.8 doesn't (yet?) support the -1.8 option + if (compiler instanceof EclipseCompiler) { + options.add("-" + compliance); + } else { + options.add("-source"); + options.add(compliance); + } + if (preview) + options.add("--enable-preview"); + BatchTestUtils.compileInModuleMode(compiler, options, processor, targetFolder, null, true); + // If it succeeded, the processor will have set this property to "succeeded"; + // if not, it will set it to an error value. + assertEquals("succeeded", System.getProperty(processor)); + } + public boolean canRunJava13() { + try { + SourceVersion.valueOf("RELEASE_13"); + } catch(IllegalArgumentException iae) { + return false; + } + return true; + } + /* (non-Javadoc) + * @see junit.framework.TestCase#setUp() + */ + @Override + protected void setUp() throws Exception { + super.setUp(); + BatchTestUtils.init(); + } + + /* (non-Javadoc) + * @see junit.framework.TestCase#tearDown() + */ + @Override + protected void tearDown() throws Exception { + super.tearDown(); + } + +}
\ No newline at end of file |