From 01a09ff15955bac17d940175cfb56b4f56744580 Mon Sep 17 00:00:00 2001 From: treenwang Date: Thu, 7 Jul 2022 18:42:17 +0800 Subject: [PATCH 1/2] Added testParsingInlineQualifiedClassName test. --- src/test/java/spoon/test/api/APITest.java | 28 +++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/src/test/java/spoon/test/api/APITest.java b/src/test/java/spoon/test/api/APITest.java index 8cac5d505b6..3fc77b2213c 100644 --- a/src/test/java/spoon/test/api/APITest.java +++ b/src/test/java/spoon/test/api/APITest.java @@ -447,6 +447,34 @@ public void testOneLinerIntro() { assertEquals("System.out.println(\"yeah\")", l.getMethodsByName("m").get(0).getBody().getStatement(0).toString()); } + @Test + public void testParsingInlineQualifiedClassName() { + String code1 = "package io.example.pack1.pack2;\n" + + " public class Example{\n" + + " void add(io.example.other.Class1 value){\n" + + " }\n" + + " }\n"; + CtClass class1 = Launcher.parseClass(code1); + List> add = class1.getMethodsByName("add").get(0).getParameters(); + assertEquals(1, add.size()); + assertEquals("value", add.get(0).getSimpleName()); + assertEquals("io.example.other.Class1", add.get(0).getType().getQualifiedName()); + assertEquals(1, add.get(0).getType().getActualTypeArguments().size()); + assertEquals("io.example.other.Class2", add.get(0).getType().getActualTypeArguments().get(0).getQualifiedName()); + String code2 = "package io.example.pack1.pack2;\n" + + " public class Example{\n" + + " void add(io.example.pack1.Class1 value){\n" + + " }\n" + + " }\n"; + CtClass class2 = Launcher.parseClass(code2); + List> add2 = class2.getMethodsByName("add").get(0).getParameters(); + assertEquals(1, add2.size()); + assertEquals("value", add2.get(0).getSimpleName()); + assertEquals("io.example.pack1.Class1", add2.get(0).getType().getQualifiedName()); + assertEquals(1, add2.get(0).getType().getActualTypeArguments().size()); + assertEquals("io.example.pack1.Class2", add2.get(0).getType().getActualTypeArguments().get(0).getQualifiedName()); + } + @Test public void testSourceClasspathDoesNotAcceptDotClass() { // contract: setSourceClassPath does not accept .class files From 2807636f2486cdc5ec6d60906e39667c1a3021be Mon Sep 17 00:00:00 2001 From: treenwang Date: Wed, 20 Jul 2022 16:13:06 +0800 Subject: [PATCH 2/2] Added failed case for parsing constants. --- src/test/java/spoon/test/api/APITest.java | 91 +++++++++++++++++++ .../api/testclasses/constants/Constants.java | 9 ++ .../constants/ImportConstants.java | 16 ++++ 3 files changed, 116 insertions(+) create mode 100644 src/test/java/spoon/test/api/testclasses/constants/Constants.java create mode 100644 src/test/java/spoon/test/api/testclasses/constants/ImportConstants.java diff --git a/src/test/java/spoon/test/api/APITest.java b/src/test/java/spoon/test/api/APITest.java index 3fc77b2213c..3b103ec2be7 100644 --- a/src/test/java/spoon/test/api/APITest.java +++ b/src/test/java/spoon/test/api/APITest.java @@ -21,6 +21,7 @@ import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; +import java.nio.file.Paths; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; @@ -40,8 +41,14 @@ import spoon.SpoonException; import spoon.compiler.Environment; import spoon.compiler.InvalidClassPathException; +import spoon.reflect.code.CtExpression; +import spoon.reflect.code.CtFieldRead; import spoon.reflect.code.CtIf; +import spoon.reflect.code.CtInvocation; +import spoon.reflect.code.CtLocalVariable; +import spoon.reflect.code.CtReturn; import spoon.reflect.code.CtStatement; +import spoon.reflect.code.CtTypeAccess; import spoon.reflect.code.CtVariableAccess; import spoon.reflect.cu.CompilationUnit; import spoon.reflect.declaration.CtClass; @@ -63,15 +70,18 @@ import spoon.support.OutputDestinationHandler; import spoon.support.UnsettableProperty; import spoon.support.compiler.SnippetCompilationError; +import spoon.support.compiler.VirtualFile; import spoon.support.reflect.declaration.CtElementImpl; import spoon.template.Local; import spoon.template.TemplateMatcher; import spoon.template.TemplateParameter; import spoon.test.api.processors.AwesomeProcessor; import spoon.test.api.testclasses.Bar; +import spoon.test.api.testclasses.constants.ImportConstants; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertThrows; @@ -475,6 +485,87 @@ public void testParsingInlineQualifiedClassName() { assertEquals("io.example.pack1.Class2", add2.get(0).getType().getActualTypeArguments().get(0).getQualifiedName()); } + @Test + public void testParsingConstants() { + + // Successful case + final Launcher launcher = new Launcher(); + Environment environment = launcher.getEnvironment(); + + environment.setNoClasspath(true); + environment.setAutoImports(true); + environment.setComplianceLevel(11); + Path basePath = Paths.get("src/test/java/"); + Path filePath = Paths.get("spoon/test/api/testclasses/constants/ImportConstants.java"); + launcher.addInputResource(basePath.resolve(filePath).toString()); + launcher.run(); + + CtType ctClass = launcher.getFactory().Type().get(ImportConstants.class); + CtMethod concatConstants = ctClass.getMethodsByName("concatConstants").get(0); + CtStatement middle = concatConstants.getBody().getStatement(0); + assertInstanceOf(CtLocalVariable.class, middle); + assertEquals("java.lang.String", ((CtLocalVariable) middle).getType().getQualifiedName()); + CtFieldRead defaultExpression2 = (CtFieldRead) ((CtLocalVariable) middle).getDefaultExpression(); + assertEquals("spoon.test.api.testclasses.constants.Constants", ((CtTypeAccess) defaultExpression2.getTarget()).getAccessedType().getQualifiedName()); + + assertInstanceOf(CtReturn.class, concatConstants.getBody().getStatement(1)); + CtExpression returnedExpression = ((CtReturn) concatConstants.getBody().getStatement(1)).getReturnedExpression(); + assertInstanceOf(CtInvocation.class, returnedExpression); + CtFieldRead first = (CtFieldRead) ((CtInvocation) returnedExpression).getArguments().get(0); + assertInstanceOf(CtTypeAccess.class, first.getTarget()); + assertEquals("spoon.test.api.testclasses.constants.Constants", ((CtTypeAccess) first.getTarget()).getAccessedType().getQualifiedName()); + CtFieldRead last = (CtFieldRead) ((CtInvocation) returnedExpression).getArguments().get(2); + assertInstanceOf(CtTypeAccess.class, last.getTarget()); + assertEquals("spoon.test.api.testclasses.constants.Constants", ((CtTypeAccess) last.getTarget()).getAccessedType().getQualifiedName()); + + // Failed case with the same check + String code1 = "package io.example.pack2;\n" + + " import io.example.Constants;\n" + + " import static io.example.Constants.LAST;\n" + + "package io.example.pack;\n" + + "\n" + + "import io.example.Constants;\n" + + "import static io.example.Constants.LAST;\n" + + "\n" + + "public class ImportConstants {\n" + + "\n" + + " public String concatConstants(){\n" + + " String middle = Constants.MIDDLE;\n" + + " return concat(Constants.FIRST, middle, LAST);\n" + + " }\n" + + "\n" + + " public String concat(String prefix, String middle, String suffix){\n" + + " return prefix + middle + suffix;\n" + + " }\n" + + "}"; + + Launcher launcher1 = new Launcher(); + launcher1.addInputResource(new VirtualFile(code1)); + launcher1.getEnvironment().setNoClasspath(true); + launcher1.getEnvironment().setAutoImports(true); + launcher1.getEnvironment().setComplianceLevel(11); + Collection> allTypes = launcher1.buildModel().getAllTypes(); + CtClass class1 = (CtClass) allTypes.stream().findFirst().get(); + CtMethod concatConstants1 = class1.getMethodsByName("concatConstants").get(0); + CtStatement middle1 = concatConstants1.getBody().getStatement(0); + assertInstanceOf(CtLocalVariable.class, middle1); + assertEquals("java.lang.String", ((CtLocalVariable) middle1).getType().getQualifiedName()); + CtFieldRead defaultExpression1 = (CtFieldRead) ((CtLocalVariable) middle1).getDefaultExpression(); + assertEquals("io.example.Constants", ((CtTypeAccess)defaultExpression1.getTarget()).getAccessedType().getQualifiedName()); + + assertInstanceOf(CtReturn.class, concatConstants1.getBody().getStatement(1)); + CtExpression returnedExpression1 = ((CtReturn) concatConstants1.getBody().getStatement(1)).getReturnedExpression(); + assertInstanceOf(CtInvocation.class, returnedExpression1); + assertInstanceOf(CtFieldRead.class, ((CtInvocation) returnedExpression1).getArguments().get(0)); + CtFieldRead first1 = (CtFieldRead) ((CtInvocation) returnedExpression1).getArguments().get(0); + assertInstanceOf(CtTypeAccess.class, first1.getTarget()); + assertEquals("io.example.Constants", ((CtTypeAccess)first1.getTarget()).getAccessedType().getQualifiedName()); + assertInstanceOf(CtFieldRead.class, ((CtInvocation) returnedExpression1).getArguments().get(2)); + CtFieldRead last1 = (CtFieldRead) ((CtInvocation) returnedExpression1).getArguments().get(2); + assertInstanceOf(CtTypeAccess.class, last1.getTarget()); + assertEquals("io.example.Constants", ((CtTypeAccess)last1.getTarget()).getAccessedType().getQualifiedName()); + } + @Test public void testSourceClasspathDoesNotAcceptDotClass() { // contract: setSourceClassPath does not accept .class files diff --git a/src/test/java/spoon/test/api/testclasses/constants/Constants.java b/src/test/java/spoon/test/api/testclasses/constants/Constants.java new file mode 100644 index 00000000000..2130c5b903b --- /dev/null +++ b/src/test/java/spoon/test/api/testclasses/constants/Constants.java @@ -0,0 +1,9 @@ +package spoon.test.api.testclasses.constants; + +public class Constants { + + public static String FIRST = "first"; + public static String MIDDLE = "middle"; + public static String LAST = "last"; + +} \ No newline at end of file diff --git a/src/test/java/spoon/test/api/testclasses/constants/ImportConstants.java b/src/test/java/spoon/test/api/testclasses/constants/ImportConstants.java new file mode 100644 index 00000000000..5db78f5689f --- /dev/null +++ b/src/test/java/spoon/test/api/testclasses/constants/ImportConstants.java @@ -0,0 +1,16 @@ +package spoon.test.api.testclasses.constants; + +import spoon.test.api.testclasses.constants.Constants; +import static spoon.test.api.testclasses.constants.Constants.LAST; + +public class ImportConstants { + + public String concatConstants(){ + var middle = Constants.MIDDLE; + return concat(Constants.FIRST, middle, LAST); + } + + public String concat(String prefix, String middle, String suffix){ + return prefix + middle + suffix; + } +}