From 1259e5672fe2a00b3a01258d4edc6c3111ee6733 Mon Sep 17 00:00:00 2001 From: Federico Tomassetti Date: Sat, 18 Feb 2017 16:10:14 +0100 Subject: issue124: add LexicalDifferenceCalculatorTest --- .../LexicalDifferenceCalculatorTest.java | 36 ++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java new file mode 100644 index 000000000..f0dd7b232 --- /dev/null +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -0,0 +1,36 @@ +package com.github.javaparser.printer.lexicalpreservation; + +import com.github.javaparser.ast.PackageDeclaration; +import com.github.javaparser.ast.expr.Name; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.printer.ConcreteSyntaxModel; +import com.github.javaparser.printer.concretesyntaxmodel.CsmElement; +import com.github.javaparser.printer.concretesyntaxmodel.CsmToken; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTest { + + @Test + public void compilationUnitExampleOriginal() { + considerCode("class A {}"); + CsmElement element = ConcreteSyntaxModel.forClass(cu.getClass()); + LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, cu); + assertEquals(2, csmOriginal.elements.size()); + assertEquals(new LexicalDifferenceCalculator.CsmChild(cu.getType(0)), csmOriginal.elements.get(0)); + assertEquals(new CsmToken(3), csmOriginal.elements.get(1)); + } + + @Test + public void compilationUnitExampleWithPackageSet() { + considerCode("class A {}"); + CsmElement element = ConcreteSyntaxModel.forClass(cu.getClass()); + PackageDeclaration packageDeclaration = new PackageDeclaration(new Name(new Name("foo"), "bar")); + LexicalDifferenceCalculator.CalculatedSyntaxModel csmChanged = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, cu, ObservableProperty.PACKAGE_DECLARATION, null, packageDeclaration); + assertEquals(3, csmChanged.elements.size()); + assertEquals(new LexicalDifferenceCalculator.CsmChild(packageDeclaration), csmChanged.elements.get(0)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(cu.getType(0)), csmChanged.elements.get(1)); + assertEquals(new CsmToken(3), csmChanged.elements.get(2)); + } +} -- cgit v1.2.3 From 3ef3b074469908766d12e2ec2623ea5857f7dc58 Mon Sep 17 00:00:00 2001 From: Federico Tomassetti Date: Sat, 18 Feb 2017 19:20:38 +0100 Subject: issue124: more tests on AnnotationDeclarationTransformation --- .../LexicalDifferenceCalculatorTest.java | 74 ++++++++++++++++++++++ 1 file changed, 74 insertions(+) (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index f0dd7b232..a505c4685 100644 --- a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -1,6 +1,9 @@ package com.github.javaparser.printer.lexicalpreservation; +import com.github.javaparser.ASTParserConstants; +import com.github.javaparser.ast.Modifier; import com.github.javaparser.ast.PackageDeclaration; +import com.github.javaparser.ast.body.AnnotationDeclaration; import com.github.javaparser.ast.expr.Name; import com.github.javaparser.ast.observer.ObservableProperty; import com.github.javaparser.printer.ConcreteSyntaxModel; @@ -8,6 +11,9 @@ import com.github.javaparser.printer.concretesyntaxmodel.CsmElement; import com.github.javaparser.printer.concretesyntaxmodel.CsmToken; import org.junit.Test; +import java.io.IOException; +import java.util.EnumSet; + import static org.junit.Assert.assertEquals; public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTest { @@ -33,4 +39,72 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new LexicalDifferenceCalculator.CsmChild(cu.getType(0)), csmChanged.elements.get(1)); assertEquals(new CsmToken(3), csmChanged.elements.get(2)); } + + @Test + public void annotationDeclarationModifiersExampleOriginal() throws IOException { + considerExample("AnnotationDeclaration_Example1_original"); + AnnotationDeclaration annotationDeclaration = (AnnotationDeclaration)cu.getType(0); + CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); + LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, annotationDeclaration); + assertEquals(24, csm.elements.size()); + assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(0)); + assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(1)); + assertEquals(new CsmToken(32), csm.elements.get(2)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(3)); + assertEquals(new CsmToken(32), csm.elements.get(4)); + assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(5)); + assertEquals(new CsmToken(3), csm.elements.get(6)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(7)); + assertEquals(new CsmToken(3), csm.elements.get(8)); + assertEquals(new CsmToken(3), csm.elements.get(9)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(10)); + assertEquals(new CsmToken(3), csm.elements.get(11)); + assertEquals(new CsmToken(3), csm.elements.get(12)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(13)); + assertEquals(new CsmToken(3), csm.elements.get(14)); + assertEquals(new CsmToken(3), csm.elements.get(15)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(16)); + assertEquals(new CsmToken(3), csm.elements.get(17)); + assertEquals(new CsmToken(3), csm.elements.get(18)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(19)); + assertEquals(new CsmToken(3), csm.elements.get(20)); + assertEquals(new CsmToken(3), csm.elements.get(21)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(22)); + assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(23)); + } + + @Test + public void annotationDeclarationModifiersExampleModified() throws IOException { + considerExample("AnnotationDeclaration_Example1_original"); + AnnotationDeclaration annotationDeclaration = (AnnotationDeclaration)cu.getType(0); + CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); + LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.MODIFIERS, EnumSet.noneOf(Modifier.class), EnumSet.of(Modifier.PUBLIC)); + assertEquals(26, csm.elements.size()); + assertEquals(new CsmToken(ASTParserConstants.PUBLIC), csm.elements.get(0)); + assertEquals(new CsmToken(32), csm.elements.get(1)); + assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(2)); + assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(3)); + assertEquals(new CsmToken(32), csm.elements.get(4)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(5)); + assertEquals(new CsmToken(32), csm.elements.get(6)); + assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(7)); + assertEquals(new CsmToken(3), csm.elements.get(8)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(9)); + assertEquals(new CsmToken(3), csm.elements.get(10)); + assertEquals(new CsmToken(3), csm.elements.get(11)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(12)); + assertEquals(new CsmToken(3), csm.elements.get(13)); + assertEquals(new CsmToken(3), csm.elements.get(14)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(15)); + assertEquals(new CsmToken(3), csm.elements.get(16)); + assertEquals(new CsmToken(3), csm.elements.get(17)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(18)); + assertEquals(new CsmToken(3), csm.elements.get(19)); + assertEquals(new CsmToken(3), csm.elements.get(20)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(21)); + assertEquals(new CsmToken(3), csm.elements.get(22)); + assertEquals(new CsmToken(3), csm.elements.get(23)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(24)); + assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(25)); + } } -- cgit v1.2.3 From b062cd703845b9a2d65e423e912d4e245f185ed4 Mon Sep 17 00:00:00 2001 From: Federico Tomassetti Date: Sun, 19 Feb 2017 08:51:44 +0100 Subject: issue124: more tests on AnnotationDeclaration differences --- .../LexicalDifferenceCalculatorTest.java | 36 ++++++++++++++++++++++ 1 file changed, 36 insertions(+) (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index a505c4685..cecc3c769 100644 --- a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -5,6 +5,7 @@ import com.github.javaparser.ast.Modifier; import com.github.javaparser.ast.PackageDeclaration; import com.github.javaparser.ast.body.AnnotationDeclaration; import com.github.javaparser.ast.expr.Name; +import com.github.javaparser.ast.expr.SimpleName; import com.github.javaparser.ast.observer.ObservableProperty; import com.github.javaparser.printer.ConcreteSyntaxModel; import com.github.javaparser.printer.concretesyntaxmodel.CsmElement; @@ -107,4 +108,39 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(24)); assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(25)); } + + @Test + public void annotationDeclarationNameExampleModified() throws IOException { + considerExample("AnnotationDeclaration_Example1_original"); + AnnotationDeclaration annotationDeclaration = (AnnotationDeclaration)cu.getType(0); + CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); + SimpleName newName = new SimpleName("NewName"); + LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.NAME, + annotationDeclaration.getName(), newName); + assertEquals(24, csm.elements.size()); + assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(0)); + assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(1)); + assertEquals(new CsmToken(32), csm.elements.get(2)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(newName), csm.elements.get(3)); + assertEquals(new CsmToken(32), csm.elements.get(4)); + assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(5)); + assertEquals(new CsmToken(3), csm.elements.get(6)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(7)); + assertEquals(new CsmToken(3), csm.elements.get(8)); + assertEquals(new CsmToken(3), csm.elements.get(9)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(10)); + assertEquals(new CsmToken(3), csm.elements.get(11)); + assertEquals(new CsmToken(3), csm.elements.get(12)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(13)); + assertEquals(new CsmToken(3), csm.elements.get(14)); + assertEquals(new CsmToken(3), csm.elements.get(15)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(16)); + assertEquals(new CsmToken(3), csm.elements.get(17)); + assertEquals(new CsmToken(3), csm.elements.get(18)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(19)); + assertEquals(new CsmToken(3), csm.elements.get(20)); + assertEquals(new CsmToken(3), csm.elements.get(21)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(22)); + assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(23)); + } } -- cgit v1.2.3 From f0f313058c4389cd48052112e3fb906c060be30f Mon Sep 17 00:00:00 2001 From: Federico Tomassetti Date: Sun, 19 Feb 2017 10:41:37 +0100 Subject: issue124: improving how JavadocComment is handled --- .../LexicalDifferenceCalculatorTest.java | 76 ++++++++++++++++++++++ 1 file changed, 76 insertions(+) (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index cecc3c769..526ba3a47 100644 --- a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -4,6 +4,7 @@ import com.github.javaparser.ASTParserConstants; import com.github.javaparser.ast.Modifier; import com.github.javaparser.ast.PackageDeclaration; import com.github.javaparser.ast.body.AnnotationDeclaration; +import com.github.javaparser.ast.comments.JavadocComment; import com.github.javaparser.ast.expr.Name; import com.github.javaparser.ast.expr.SimpleName; import com.github.javaparser.ast.observer.ObservableProperty; @@ -143,4 +144,79 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(22)); assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(23)); } + + @Test + public void annotationDeclaratioJavadocExampleOriginal() throws IOException { + considerExample("AnnotationDeclaration_Example3_original"); + AnnotationDeclaration annotationDeclaration = (AnnotationDeclaration)cu.getType(0); + CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); + LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, annotationDeclaration); + assertEquals(26, csm.elements.size()); + int i = 0; + assertEquals(new CsmToken(ASTParserConstants.PUBLIC), csm.elements.get(i++)); + assertEquals(new CsmToken(32), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(i++)); + assertEquals(new CsmToken(32), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); + assertEquals(new CsmToken(32), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(i++)); + } + + @Test + public void annotationDeclaratioJavadocExampleAddingJavadoc() throws IOException { + considerExample("AnnotationDeclaration_Example3_original"); + AnnotationDeclaration annotationDeclaration = (AnnotationDeclaration)cu.getType(0); + CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); + JavadocComment comment = new JavadocComment("Cool this annotation!"); + LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.COMMENT, null, comment); + assertEquals(28, csm.elements.size()); + int i = 0; + assertEquals(new CsmToken(ASTParserConstants.JAVA_DOC_COMMENT, "/**Cool this annotation!*/"), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.PUBLIC), csm.elements.get(i++)); + assertEquals(new CsmToken(32), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(i++)); + assertEquals(new CsmToken(32), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); + assertEquals(new CsmToken(32), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(i++)); + } } -- cgit v1.2.3 From 85a12837d7f23f696d693830cc45227036f12925 Mon Sep 17 00:00:00 2001 From: Federico Tomassetti Date: Sun, 19 Feb 2017 11:37:15 +0100 Subject: issue124: improving support for whitespace --- .../lexicalpreservation/LexicalDifferenceCalculatorTest.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index 526ba3a47..d9316c144 100644 --- a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -193,12 +193,12 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new CsmToken(ASTParserConstants.JAVA_DOC_COMMENT, "/**Cool this annotation!*/"), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new CsmToken(ASTParserConstants.PUBLIC), csm.elements.get(i++)); - assertEquals(new CsmToken(32), csm.elements.get(i++)); + assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(i++)); assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(i++)); - assertEquals(new CsmToken(32), csm.elements.get(i++)); + assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); - assertEquals(new CsmToken(32), csm.elements.get(i++)); + assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); -- cgit v1.2.3 From 888ad0486616d38f8f01ab260bdb4caa77197670 Mon Sep 17 00:00:00 2001 From: Federico Tomassetti Date: Sun, 19 Feb 2017 13:42:15 +0100 Subject: issue124: correct how isNullOrEmpty is calculated --- .../LexicalDifferenceCalculatorTest.java | 37 ++++++++++++++++------ 1 file changed, 27 insertions(+), 10 deletions(-) (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index d9316c144..90e007bb8 100644 --- a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -4,6 +4,8 @@ import com.github.javaparser.ASTParserConstants; import com.github.javaparser.ast.Modifier; import com.github.javaparser.ast.PackageDeclaration; import com.github.javaparser.ast.body.AnnotationDeclaration; +import com.github.javaparser.ast.body.EnumConstantDeclaration; +import com.github.javaparser.ast.body.EnumDeclaration; import com.github.javaparser.ast.comments.JavadocComment; import com.github.javaparser.ast.expr.Name; import com.github.javaparser.ast.expr.SimpleName; @@ -51,9 +53,9 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(24, csm.elements.size()); assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(0)); assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(1)); - assertEquals(new CsmToken(32), csm.elements.get(2)); + assertEquals(new CsmToken(1), csm.elements.get(2)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(3)); - assertEquals(new CsmToken(32), csm.elements.get(4)); + assertEquals(new CsmToken(1), csm.elements.get(4)); assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(5)); assertEquals(new CsmToken(3), csm.elements.get(6)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(7)); @@ -83,12 +85,12 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.MODIFIERS, EnumSet.noneOf(Modifier.class), EnumSet.of(Modifier.PUBLIC)); assertEquals(26, csm.elements.size()); assertEquals(new CsmToken(ASTParserConstants.PUBLIC), csm.elements.get(0)); - assertEquals(new CsmToken(32), csm.elements.get(1)); + assertEquals(new CsmToken(1), csm.elements.get(1)); assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(2)); assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(3)); - assertEquals(new CsmToken(32), csm.elements.get(4)); + assertEquals(new CsmToken(1), csm.elements.get(4)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(5)); - assertEquals(new CsmToken(32), csm.elements.get(6)); + assertEquals(new CsmToken(1), csm.elements.get(6)); assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(7)); assertEquals(new CsmToken(3), csm.elements.get(8)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(9)); @@ -121,9 +123,9 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(24, csm.elements.size()); assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(0)); assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(1)); - assertEquals(new CsmToken(32), csm.elements.get(2)); + assertEquals(new CsmToken(1), csm.elements.get(2)); assertEquals(new LexicalDifferenceCalculator.CsmChild(newName), csm.elements.get(3)); - assertEquals(new CsmToken(32), csm.elements.get(4)); + assertEquals(new CsmToken(1), csm.elements.get(4)); assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(5)); assertEquals(new CsmToken(3), csm.elements.get(6)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(7)); @@ -154,12 +156,12 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(26, csm.elements.size()); int i = 0; assertEquals(new CsmToken(ASTParserConstants.PUBLIC), csm.elements.get(i++)); - assertEquals(new CsmToken(32), csm.elements.get(i++)); + assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(i++)); assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(i++)); - assertEquals(new CsmToken(32), csm.elements.get(i++)); + assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); - assertEquals(new CsmToken(32), csm.elements.get(i++)); + assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); @@ -219,4 +221,19 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(i++)); } + + @Test + public void simpleEnumConstantDeclaration() throws IOException { + EnumConstantDeclaration ecd = considerEcd("A"); + LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(ecd); + + int i = 0; + assertEquals(new LexicalDifferenceCalculator.CsmChild(ecd.getName()), csm.elements.get(i++)); + assertEquals(i, csm.elements.size()); + } + + protected EnumConstantDeclaration considerEcd(String code) { + considerCode("enum A { " + code + " }"); + return ((EnumDeclaration)cu.getType(0)).getEntries().get(0); + } } -- cgit v1.2.3 From 08bd6db12a6e7a8c9eebba117981bbde6399d4ff Mon Sep 17 00:00:00 2001 From: Federico Tomassetti Date: Sun, 19 Feb 2017 15:40:51 +0100 Subject: issue124: handling comments --- .../lexicalpreservation/LexicalDifferenceCalculatorTest.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index 90e007bb8..4e76c4bd0 100644 --- a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -190,10 +190,10 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); JavadocComment comment = new JavadocComment("Cool this annotation!"); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.COMMENT, null, comment); - assertEquals(28, csm.elements.size()); + assertEquals(26, csm.elements.size()); int i = 0; - assertEquals(new CsmToken(ASTParserConstants.JAVA_DOC_COMMENT, "/**Cool this annotation!*/"), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + //assertEquals(new CsmToken(ASTParserConstants.JAVA_DOC_COMMENT, "/**Cool this annotation!*/"), csm.elements.get(i++)); + //assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new CsmToken(ASTParserConstants.PUBLIC), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(i++)); -- cgit v1.2.3 From 9141bc3357263b19d42e966366cfd57db3b9ebad Mon Sep 17 00:00:00 2001 From: Federico Tomassetti Date: Mon, 20 Feb 2017 17:39:16 +0100 Subject: issue124: correct CSM for AnnotationDeclaration --- .../LexicalDifferenceCalculatorTest.java | 163 +++++++++------------ 1 file changed, 72 insertions(+), 91 deletions(-) (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index 4e76c4bd0..65648b3c6 100644 --- a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -50,31 +50,28 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe AnnotationDeclaration annotationDeclaration = (AnnotationDeclaration)cu.getType(0); CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, annotationDeclaration); - assertEquals(24, csm.elements.size()); - assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(0)); - assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(1)); - assertEquals(new CsmToken(1), csm.elements.get(2)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(3)); - assertEquals(new CsmToken(1), csm.elements.get(4)); - assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(5)); - assertEquals(new CsmToken(3), csm.elements.get(6)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(7)); - assertEquals(new CsmToken(3), csm.elements.get(8)); - assertEquals(new CsmToken(3), csm.elements.get(9)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(10)); - assertEquals(new CsmToken(3), csm.elements.get(11)); - assertEquals(new CsmToken(3), csm.elements.get(12)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(13)); - assertEquals(new CsmToken(3), csm.elements.get(14)); - assertEquals(new CsmToken(3), csm.elements.get(15)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(16)); - assertEquals(new CsmToken(3), csm.elements.get(17)); - assertEquals(new CsmToken(3), csm.elements.get(18)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(19)); - assertEquals(new CsmToken(3), csm.elements.get(20)); - assertEquals(new CsmToken(3), csm.elements.get(21)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(22)); - assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(23)); + int i = 0; + assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(i++)); + assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); + assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(i++)); + assertEquals(i, csm.elements.size()); } @Test @@ -83,33 +80,30 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe AnnotationDeclaration annotationDeclaration = (AnnotationDeclaration)cu.getType(0); CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.MODIFIERS, EnumSet.noneOf(Modifier.class), EnumSet.of(Modifier.PUBLIC)); - assertEquals(26, csm.elements.size()); - assertEquals(new CsmToken(ASTParserConstants.PUBLIC), csm.elements.get(0)); - assertEquals(new CsmToken(1), csm.elements.get(1)); - assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(2)); - assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(3)); - assertEquals(new CsmToken(1), csm.elements.get(4)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(5)); - assertEquals(new CsmToken(1), csm.elements.get(6)); - assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(7)); - assertEquals(new CsmToken(3), csm.elements.get(8)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(9)); - assertEquals(new CsmToken(3), csm.elements.get(10)); - assertEquals(new CsmToken(3), csm.elements.get(11)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(12)); - assertEquals(new CsmToken(3), csm.elements.get(13)); - assertEquals(new CsmToken(3), csm.elements.get(14)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(15)); - assertEquals(new CsmToken(3), csm.elements.get(16)); - assertEquals(new CsmToken(3), csm.elements.get(17)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(18)); - assertEquals(new CsmToken(3), csm.elements.get(19)); - assertEquals(new CsmToken(3), csm.elements.get(20)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(21)); - assertEquals(new CsmToken(3), csm.elements.get(22)); - assertEquals(new CsmToken(3), csm.elements.get(23)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(24)); - assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(25)); + int i = 0; + assertEquals(new CsmToken(ASTParserConstants.PUBLIC), csm.elements.get(i++)); + assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(i++)); + assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); + assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(i++)); + assertEquals(i, csm.elements.size()); } @Test @@ -120,31 +114,28 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe SimpleName newName = new SimpleName("NewName"); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.NAME, annotationDeclaration.getName(), newName); - assertEquals(24, csm.elements.size()); - assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(0)); - assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(1)); - assertEquals(new CsmToken(1), csm.elements.get(2)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(newName), csm.elements.get(3)); - assertEquals(new CsmToken(1), csm.elements.get(4)); - assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(5)); - assertEquals(new CsmToken(3), csm.elements.get(6)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(7)); - assertEquals(new CsmToken(3), csm.elements.get(8)); - assertEquals(new CsmToken(3), csm.elements.get(9)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(10)); - assertEquals(new CsmToken(3), csm.elements.get(11)); - assertEquals(new CsmToken(3), csm.elements.get(12)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(13)); - assertEquals(new CsmToken(3), csm.elements.get(14)); - assertEquals(new CsmToken(3), csm.elements.get(15)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(16)); - assertEquals(new CsmToken(3), csm.elements.get(17)); - assertEquals(new CsmToken(3), csm.elements.get(18)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(19)); - assertEquals(new CsmToken(3), csm.elements.get(20)); - assertEquals(new CsmToken(3), csm.elements.get(21)); - assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(22)); - assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(23)); + int i = 0; + assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(i++)); + assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(newName), csm.elements.get(i++)); + assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(i++)); + assertEquals(i, csm.elements.size()); } @Test @@ -153,7 +144,6 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe AnnotationDeclaration annotationDeclaration = (AnnotationDeclaration)cu.getType(0); CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, annotationDeclaration); - assertEquals(26, csm.elements.size()); int i = 0; assertEquals(new CsmToken(ASTParserConstants.PUBLIC), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); @@ -166,21 +156,18 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(i++)); + assertEquals(i, csm.elements.size()); } @Test @@ -190,10 +177,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); JavadocComment comment = new JavadocComment("Cool this annotation!"); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.COMMENT, null, comment); - assertEquals(26, csm.elements.size()); int i = 0; - //assertEquals(new CsmToken(ASTParserConstants.JAVA_DOC_COMMENT, "/**Cool this annotation!*/"), csm.elements.get(i++)); - //assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new CsmToken(ASTParserConstants.PUBLIC), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(i++)); @@ -205,21 +189,18 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); + assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(i++)); + assertEquals(i, csm.elements.size()); } @Test -- cgit v1.2.3 From b937b69f15008d33811ba33c6f76619acfadf9fb Mon Sep 17 00:00:00 2001 From: Danny van Bruggen Date: Mon, 27 Feb 2017 17:42:36 +0100 Subject: Try to merge in lex pres. --- .../LexicalDifferenceCalculatorTest.java | 48 +++++++++++----------- 1 file changed, 24 insertions(+), 24 deletions(-) (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index 65648b3c6..530e7d679 100644 --- a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -1,6 +1,6 @@ package com.github.javaparser.printer.lexicalpreservation; -import com.github.javaparser.ASTParserConstants; +import com.github.javaparser.GeneratedModuleInfoParserConstants; import com.github.javaparser.ast.Modifier; import com.github.javaparser.ast.PackageDeclaration; import com.github.javaparser.ast.body.AnnotationDeclaration; @@ -51,12 +51,12 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, annotationDeclaration); int i = 0; - assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.AT), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.INTERFACE), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.LBRACE), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); @@ -70,7 +70,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -81,14 +81,14 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.MODIFIERS, EnumSet.noneOf(Modifier.class), EnumSet.of(Modifier.PUBLIC)); int i = 0; - assertEquals(new CsmToken(ASTParserConstants.PUBLIC), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.PUBLIC), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.AT), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.INTERFACE), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.LBRACE), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); @@ -102,7 +102,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -115,12 +115,12 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.NAME, annotationDeclaration.getName(), newName); int i = 0; - assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.AT), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.INTERFACE), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(newName), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.LBRACE), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); @@ -134,7 +134,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -145,14 +145,14 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, annotationDeclaration); int i = 0; - assertEquals(new CsmToken(ASTParserConstants.PUBLIC), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.PUBLIC), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.AT), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.INTERFACE), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.LBRACE), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); @@ -166,7 +166,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -178,14 +178,14 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe JavadocComment comment = new JavadocComment("Cool this annotation!"); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.COMMENT, null, comment); int i = 0; - assertEquals(new CsmToken(ASTParserConstants.PUBLIC), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.PUBLIC), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.AT), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.INTERFACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.AT), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.INTERFACE), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.LBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.LBRACE), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); @@ -199,7 +199,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(ASTParserConstants.RBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } -- cgit v1.2.3 From de2adb51f6f0465024755f034fe27de56c651ffd Mon Sep 17 00:00:00 2001 From: Danny van Bruggen Date: Mon, 27 Feb 2017 20:50:11 +0100 Subject: Merge everything back into one grammar and use the "special keywords are actually just identifiers" trick right. --- .../LexicalDifferenceCalculatorTest.java | 48 +++++++++++----------- 1 file changed, 24 insertions(+), 24 deletions(-) (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index 530e7d679..d5a6e58c8 100644 --- a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -1,6 +1,6 @@ package com.github.javaparser.printer.lexicalpreservation; -import com.github.javaparser.GeneratedModuleInfoParserConstants; +import com.github.javaparser.GeneratedJavaParserConstants; import com.github.javaparser.ast.Modifier; import com.github.javaparser.ast.PackageDeclaration; import com.github.javaparser.ast.body.AnnotationDeclaration; @@ -51,12 +51,12 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, annotationDeclaration); int i = 0; - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.AT), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.INTERFACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.LBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.LBRACE), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); @@ -70,7 +70,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.RBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -81,14 +81,14 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.MODIFIERS, EnumSet.noneOf(Modifier.class), EnumSet.of(Modifier.PUBLIC)); int i = 0; - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.PUBLIC), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.PUBLIC), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.AT), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.INTERFACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.LBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.LBRACE), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); @@ -102,7 +102,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.RBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -115,12 +115,12 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.NAME, annotationDeclaration.getName(), newName); int i = 0; - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.AT), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.INTERFACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(newName), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.LBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.LBRACE), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); @@ -134,7 +134,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.RBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -145,14 +145,14 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, annotationDeclaration); int i = 0; - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.PUBLIC), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.PUBLIC), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.AT), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.INTERFACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.LBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.LBRACE), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); @@ -166,7 +166,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.RBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -178,14 +178,14 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe JavadocComment comment = new JavadocComment("Cool this annotation!"); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.COMMENT, null, comment); int i = 0; - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.PUBLIC), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.PUBLIC), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.AT), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.INTERFACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); assertEquals(new CsmToken(1), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.LBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.LBRACE), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); @@ -199,7 +199,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(new CsmToken(3), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); assertEquals(new CsmToken(3), csm.elements.get(i++)); - assertEquals(new CsmToken(GeneratedModuleInfoParserConstants.RBRACE), csm.elements.get(i++)); + assertEquals(new CsmToken(GeneratedJavaParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } -- cgit v1.2.3 From 9192b9d17903947058b755b987d1c57a05821e58 Mon Sep 17 00:00:00 2001 From: Danny van Bruggen Date: Mon, 6 Mar 2017 17:15:04 +0100 Subject: * explicitly match \r\n in the grammar * centralize token handling --- .../LexicalDifferenceCalculatorTest.java | 102 +++++++++++---------- 1 file changed, 52 insertions(+), 50 deletions(-) (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index d5a6e58c8..3eb10dc43 100644 --- a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -18,6 +18,8 @@ import org.junit.Test; import java.io.IOException; import java.util.EnumSet; +import static com.github.javaparser.printer.TokenConstants.eolToken; +import static com.github.javaparser.printer.TokenConstants.spaceToken; import static org.junit.Assert.assertEquals; public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTest { @@ -29,7 +31,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, cu); assertEquals(2, csmOriginal.elements.size()); assertEquals(new LexicalDifferenceCalculator.CsmChild(cu.getType(0)), csmOriginal.elements.get(0)); - assertEquals(new CsmToken(3), csmOriginal.elements.get(1)); + assertEquals(new CsmToken(eolToken()), csmOriginal.elements.get(1)); } @Test @@ -41,7 +43,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(3, csmChanged.elements.size()); assertEquals(new LexicalDifferenceCalculator.CsmChild(packageDeclaration), csmChanged.elements.get(0)); assertEquals(new LexicalDifferenceCalculator.CsmChild(cu.getType(0)), csmChanged.elements.get(1)); - assertEquals(new CsmToken(3), csmChanged.elements.get(2)); + assertEquals(new CsmToken(eolToken()), csmChanged.elements.get(2)); } @Test @@ -53,23 +55,23 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe int i = 0; assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); - assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); - assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.LBRACE), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -82,26 +84,26 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.MODIFIERS, EnumSet.noneOf(Modifier.class), EnumSet.of(Modifier.PUBLIC)); int i = 0; assertEquals(new CsmToken(GeneratedJavaParserConstants.PUBLIC), csm.elements.get(i++)); - assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); - assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); - assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.LBRACE), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -117,23 +119,23 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe int i = 0; assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); - assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(newName), csm.elements.get(i++)); - assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.LBRACE), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -146,26 +148,26 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, annotationDeclaration); int i = 0; assertEquals(new CsmToken(GeneratedJavaParserConstants.PUBLIC), csm.elements.get(i++)); - assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); - assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); - assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.LBRACE), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -179,26 +181,26 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.COMMENT, null, comment); int i = 0; assertEquals(new CsmToken(GeneratedJavaParserConstants.PUBLIC), csm.elements.get(i++)); - assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); - assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); - assertEquals(new CsmToken(1), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.LBRACE), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); - assertEquals(new CsmToken(3), csm.elements.get(i++)); + assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } -- cgit v1.2.3 From b29a465257afcf2cc720c9423c2ddedd1edd31a3 Mon Sep 17 00:00:00 2001 From: Danny van Bruggen Date: Mon, 6 Mar 2017 17:35:48 +0100 Subject: Move TokenConstants around --- .../printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index 3eb10dc43..2016ce73d 100644 --- a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -18,8 +18,8 @@ import org.junit.Test; import java.io.IOException; import java.util.EnumSet; -import static com.github.javaparser.printer.TokenConstants.eolToken; -import static com.github.javaparser.printer.TokenConstants.spaceToken; +import static com.github.javaparser.TokenTypes.eolToken; +import static com.github.javaparser.TokenTypes.spaceToken; import static org.junit.Assert.assertEquals; public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTest { -- cgit v1.2.3 From 488ccb1191c3b71644bdc9176712394220b9252b Mon Sep 17 00:00:00 2001 From: Federico Tomassetti Date: Sun, 14 May 2017 12:26:10 +0200 Subject: propagating CsmIndent and CsmUnindent --- .../LexicalDifferenceCalculatorTest.java | 57 +++++++++++++++++++++- 1 file changed, 55 insertions(+), 2 deletions(-) (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index 2016ce73d..05dcd6fd8 100644 --- a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -2,17 +2,22 @@ package com.github.javaparser.printer.lexicalpreservation; import com.github.javaparser.GeneratedJavaParserConstants; import com.github.javaparser.ast.Modifier; +import com.github.javaparser.ast.Node; import com.github.javaparser.ast.PackageDeclaration; import com.github.javaparser.ast.body.AnnotationDeclaration; import com.github.javaparser.ast.body.EnumConstantDeclaration; import com.github.javaparser.ast.body.EnumDeclaration; +import com.github.javaparser.ast.body.MethodDeclaration; import com.github.javaparser.ast.comments.JavadocComment; -import com.github.javaparser.ast.expr.Name; -import com.github.javaparser.ast.expr.SimpleName; +import com.github.javaparser.ast.expr.*; import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.stmt.BlockStmt; +import com.github.javaparser.ast.stmt.ExpressionStmt; +import com.github.javaparser.ast.stmt.Statement; import com.github.javaparser.printer.ConcreteSyntaxModel; import com.github.javaparser.printer.concretesyntaxmodel.CsmElement; import com.github.javaparser.printer.concretesyntaxmodel.CsmToken; +import com.sun.tools.javac.jvm.Gen; import org.junit.Test; import java.io.IOException; @@ -21,6 +26,7 @@ import java.util.EnumSet; import static com.github.javaparser.TokenTypes.eolToken; import static com.github.javaparser.TokenTypes.spaceToken; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTest { @@ -52,6 +58,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe AnnotationDeclaration annotationDeclaration = (AnnotationDeclaration)cu.getType(0); CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, annotationDeclaration); + csm.removeIndentationElements(); int i = 0; assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); @@ -82,6 +89,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe AnnotationDeclaration annotationDeclaration = (AnnotationDeclaration)cu.getType(0); CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.MODIFIERS, EnumSet.noneOf(Modifier.class), EnumSet.of(Modifier.PUBLIC)); + csm.removeIndentationElements(); int i = 0; assertEquals(new CsmToken(GeneratedJavaParserConstants.PUBLIC), csm.elements.get(i++)); assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); @@ -116,6 +124,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe SimpleName newName = new SimpleName("NewName"); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.NAME, annotationDeclaration.getName(), newName); + csm.removeIndentationElements(); int i = 0; assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); @@ -146,6 +155,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe AnnotationDeclaration annotationDeclaration = (AnnotationDeclaration)cu.getType(0); CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, annotationDeclaration); + csm.removeIndentationElements(); int i = 0; assertEquals(new CsmToken(GeneratedJavaParserConstants.PUBLIC), csm.elements.get(i++)); assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); @@ -179,6 +189,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe CsmElement element = ConcreteSyntaxModel.forClass(annotationDeclaration.getClass()); JavadocComment comment = new JavadocComment("Cool this annotation!"); LexicalDifferenceCalculator.CalculatedSyntaxModel csm = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, annotationDeclaration, ObservableProperty.COMMENT, null, comment); + csm.removeIndentationElements(); int i = 0; assertEquals(new CsmToken(GeneratedJavaParserConstants.PUBLIC), csm.elements.get(i++)); assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); @@ -215,6 +226,48 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(i, csm.elements.size()); } + @Test + public void addingStatementToEmptyBlock() throws IOException { + LexicalDifferenceCalculator ldc = new LexicalDifferenceCalculator(); + considerExample("ASimpleClassWithMoreFormatting_step3"); + + MethodDeclaration setter = cu.getClassByName("MyRenamedClass").get() + .getMethodsByName("setAField").get(0); + Statement assignStatement = new ExpressionStmt( + new AssignExpr( + new FieldAccessExpr(new ThisExpr(),"aField"), + new NameExpr("aField"), + AssignExpr.Operator.ASSIGN + )); + LexicalDifferenceCalculator.CalculatedSyntaxModel calculatedSyntaxModel = + ldc.calculatedSyntaxModelAfterListAddition( + ConcreteSyntaxModel.forClass(BlockStmt.class), + ObservableProperty.STATEMENTS, + setter.getBody().get().getStatements(), + 0, + assignStatement); + calculatedSyntaxModel.removeIndentationElements(); + int index = 0; + assertEquals(CsmElement.token(GeneratedJavaParserConstants.LBRACE), calculatedSyntaxModel.elements.get(index++)); + assertEquals(CsmElement.newline(), calculatedSyntaxModel.elements.get(index++)); + assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); + assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); + assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); + assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); + assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); + assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); + assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); + assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); + assertTrue(isChild(calculatedSyntaxModel.elements.get(index++), ExpressionStmt.class)); + assertEquals(CsmElement.newline(), calculatedSyntaxModel.elements.get(index++)); + assertEquals(CsmElement.token(GeneratedJavaParserConstants.RBRACE), calculatedSyntaxModel.elements.get(index++)); + assertEquals(index, calculatedSyntaxModel.elements.size()); + } + + private boolean isChild(CsmElement element, Class childClass) { + return element instanceof LexicalDifferenceCalculator.CsmChild && childClass.isInstance(((LexicalDifferenceCalculator.CsmChild)element).getChild()); + } + protected EnumConstantDeclaration considerEcd(String code) { considerCode("enum A { " + code + " }"); return ((EnumDeclaration)cu.getType(0)).getEntries().get(0); -- cgit v1.2.3 From a31908d22bc52d1bf24e00d3bc1bc709224156fd Mon Sep 17 00:00:00 2001 From: Federico Tomassetti Date: Sun, 14 May 2017 12:46:54 +0200 Subject: initial handling of indent/unindent in Difference --- .../LexicalDifferenceCalculatorTest.java | 46 +++++++++++++++++----- 1 file changed, 36 insertions(+), 10 deletions(-) (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index 05dcd6fd8..f481414d8 100644 --- a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -227,7 +227,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe } @Test - public void addingStatementToEmptyBlock() throws IOException { + public void csmModelAfterAddingStatementToEmptyBlock() throws IOException { LexicalDifferenceCalculator ldc = new LexicalDifferenceCalculator(); considerExample("ASimpleClassWithMoreFormatting_step3"); @@ -246,24 +246,50 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe setter.getBody().get().getStatements(), 0, assignStatement); - calculatedSyntaxModel.removeIndentationElements(); int index = 0; assertEquals(CsmElement.token(GeneratedJavaParserConstants.LBRACE), calculatedSyntaxModel.elements.get(index++)); assertEquals(CsmElement.newline(), calculatedSyntaxModel.elements.get(index++)); - assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); - assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); - assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); - assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); - assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); - assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); - assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); - assertEquals(CsmElement.space(), calculatedSyntaxModel.elements.get(index++)); + assertEquals(CsmElement.indent(), calculatedSyntaxModel.elements.get(index++)); assertTrue(isChild(calculatedSyntaxModel.elements.get(index++), ExpressionStmt.class)); assertEquals(CsmElement.newline(), calculatedSyntaxModel.elements.get(index++)); + assertEquals(CsmElement.unindent(), calculatedSyntaxModel.elements.get(index++)); assertEquals(CsmElement.token(GeneratedJavaParserConstants.RBRACE), calculatedSyntaxModel.elements.get(index++)); assertEquals(index, calculatedSyntaxModel.elements.size()); } + @Test + public void differenceAfterddingStatementToEmptyBlock() throws IOException { + LexicalDifferenceCalculator ldc = new LexicalDifferenceCalculator(); + considerExample("ASimpleClassWithMoreFormatting_step3"); + + MethodDeclaration setter = cu.getClassByName("MyRenamedClass").get() + .getMethodsByName("setAField").get(0); + Statement assignStatement = new ExpressionStmt( + new AssignExpr( + new FieldAccessExpr(new ThisExpr(),"aField"), + new NameExpr("aField"), + AssignExpr.Operator.ASSIGN + )); + Difference diff = ldc.calculateListAdditionDifference( + ObservableProperty.STATEMENTS, + setter.getBody().get().getStatements(), + 0, + assignStatement); + int index = 0; + assertEquals(Difference.DifferenceElement.kept(CsmElement.token(GeneratedJavaParserConstants.LBRACE)), diff.getElements().get(index++)); + assertEquals(Difference.DifferenceElement.kept(CsmElement.newline()), diff.getElements().get(index++)); + assertEquals(Difference.DifferenceElement.added(CsmElement.indent()), diff.getElements().get(index++)); + assertTrue(isAddedChild(diff.getElements().get(index++), ExpressionStmt.class)); + assertEquals(Difference.DifferenceElement.added(CsmElement.newline()), diff.getElements().get(index++)); + assertEquals(Difference.DifferenceElement.added(CsmElement.unindent()), diff.getElements().get(index++)); + assertEquals(Difference.DifferenceElement.kept(CsmElement.token(GeneratedJavaParserConstants.RBRACE)), diff.getElements().get(index++)); + assertEquals(index, diff.getElements().size()); + } + + private boolean isAddedChild(Difference.DifferenceElement element, Class childClass) { + return element.isAdded() && isChild(element.getElement(), childClass); + } + private boolean isChild(CsmElement element, Class childClass) { return element instanceof LexicalDifferenceCalculator.CsmChild && childClass.isInstance(((LexicalDifferenceCalculator.CsmChild)element).getChild()); } -- cgit v1.2.3 From 9e051634c8fd2ae4cd29dc4324bd0042a1851603 Mon Sep 17 00:00:00 2001 From: Federico Tomassetti Date: Sun, 14 May 2017 15:08:26 +0200 Subject: removing inappropriate import --- .../printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java | 1 - 1 file changed, 1 deletion(-) (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index f481414d8..cb78bb678 100644 --- a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -17,7 +17,6 @@ import com.github.javaparser.ast.stmt.Statement; import com.github.javaparser.printer.ConcreteSyntaxModel; import com.github.javaparser.printer.concretesyntaxmodel.CsmElement; import com.github.javaparser.printer.concretesyntaxmodel.CsmToken; -import com.sun.tools.javac.jvm.Gen; import org.junit.Test; import java.io.IOException; -- cgit v1.2.3 From 6a1ee724c337694ee28b2a09af41c236b880ba66 Mon Sep 17 00:00:00 2001 From: Danny van Bruggen Date: Tue, 18 Jul 2017 21:42:54 +0200 Subject: Take TokenType into consideration --- .../LexicalDifferenceCalculatorTest.java | 104 ++++++++++----------- 1 file changed, 52 insertions(+), 52 deletions(-) (limited to 'javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java') diff --git a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java index cb78bb678..d3e5490c0 100644 --- a/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java +++ b/javaparser-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java @@ -22,8 +22,8 @@ import org.junit.Test; import java.io.IOException; import java.util.EnumSet; -import static com.github.javaparser.TokenTypes.eolToken; -import static com.github.javaparser.TokenTypes.spaceToken; +import static com.github.javaparser.TokenTypes.eolTokenKind; +import static com.github.javaparser.TokenTypes.spaceTokenKind; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -36,7 +36,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, cu); assertEquals(2, csmOriginal.elements.size()); assertEquals(new LexicalDifferenceCalculator.CsmChild(cu.getType(0)), csmOriginal.elements.get(0)); - assertEquals(new CsmToken(eolToken()), csmOriginal.elements.get(1)); + assertEquals(new CsmToken(eolTokenKind()), csmOriginal.elements.get(1)); } @Test @@ -48,7 +48,7 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe assertEquals(3, csmChanged.elements.size()); assertEquals(new LexicalDifferenceCalculator.CsmChild(packageDeclaration), csmChanged.elements.get(0)); assertEquals(new LexicalDifferenceCalculator.CsmChild(cu.getType(0)), csmChanged.elements.get(1)); - assertEquals(new CsmToken(eolToken()), csmChanged.elements.get(2)); + assertEquals(new CsmToken(eolTokenKind()), csmChanged.elements.get(2)); } @Test @@ -61,23 +61,23 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe int i = 0; assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); - assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); - assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceTokenKind()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.LBRACE), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -91,26 +91,26 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe csm.removeIndentationElements(); int i = 0; assertEquals(new CsmToken(GeneratedJavaParserConstants.PUBLIC), csm.elements.get(i++)); - assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceTokenKind()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); - assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); - assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceTokenKind()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.LBRACE), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -127,23 +127,23 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe int i = 0; assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); - assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(newName), csm.elements.get(i++)); - assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceTokenKind()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.LBRACE), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -157,26 +157,26 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe csm.removeIndentationElements(); int i = 0; assertEquals(new CsmToken(GeneratedJavaParserConstants.PUBLIC), csm.elements.get(i++)); - assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceTokenKind()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); - assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); - assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceTokenKind()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.LBRACE), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } @@ -191,26 +191,26 @@ public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTe csm.removeIndentationElements(); int i = 0; assertEquals(new CsmToken(GeneratedJavaParserConstants.PUBLIC), csm.elements.get(i++)); - assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceTokenKind()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.AT), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.INTERFACE), csm.elements.get(i++)); - assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getName()), csm.elements.get(i++)); - assertEquals(new CsmToken(spaceToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(spaceTokenKind()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.LBRACE), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(0)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(1)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(2)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(3)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(4)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new LexicalDifferenceCalculator.CsmChild(annotationDeclaration.getMember(5)), csm.elements.get(i++)); - assertEquals(new CsmToken(eolToken()), csm.elements.get(i++)); + assertEquals(new CsmToken(eolTokenKind()), csm.elements.get(i++)); assertEquals(new CsmToken(GeneratedJavaParserConstants.RBRACE), csm.elements.get(i++)); assertEquals(i, csm.elements.size()); } -- cgit v1.2.3