Merge c60d03e into c87e07f

javaparser-core-testing/src/test/java/com/github/javaparser/printer/lexicalpreservation/Issue2620Test.java

@@ -29,40 +29,37 @@
 import com.github.javaparser.ast.body.FieldDeclaration;
 import com.github.javaparser.ast.body.VariableDeclarator;
 import com.github.javaparser.ast.type.ClassOrInterfaceType;
+import com.github.javaparser.utils.LineEnding;
 import org.junit.jupiter.api.Test;
 
 import java.util.Optional;
 
 import static com.github.javaparser.utils.TestUtils.assertEqualsNoEol;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 
 public class Issue2620Test {
 
-    private static final String CR = "\r";
-    private static final String LF = "\n";
-    private static final String CRLF = CR + LF;
-
-
     @Test
     public void testWithCr() {
-        doTest(CR);
+        doTest(LineEnding.CR);
     }
 
     @Test
     public void testWithLf() {
-        doTest(LF);
+        doTest(LineEnding.LF);
     }
 
     @Test
     public void testWithCrLf() {
-        doTest(CRLF);
+        doTest(LineEnding.CRLF);
     }
 
 
     /*
      * This test case must prevent an UnsupportedOperation Removed throwed by LexicalPreservation when we try to replace an expression
      */
-    public void doTest(String eol) {
+    public void doTest(LineEnding eol) {
 
         final String original = "" +
                 "    public class Foo { //comment" + eol +
@@ -104,12 +101,16 @@ public void doTest(String eol) {
         final String actual = LexicalPreservingPrinter.print(cu);
         System.out.println("\n\nActual:\n" + actual);
 
+        LineEnding detectedLineEnding = LineEnding.detect(actual);
+
+        assertFalse(detectedLineEnding.equals(LineEnding.MIXED));
+        assertEquals(eol.escaped(), detectedLineEnding.escaped());
 
         assertEquals(normaliseNewlines(expected), normaliseNewlines(actual));
 
         // Commented out until #2661 is fixed (re: EOL characters of injected code)
-//        assertEqualsNoEol(escapeNewlines(expected), escapeNewlines(actual));
-//        assertEquals(expected, actual, "Failed due to EOL differences.");
+        assertEqualsNoEol(escapeNewlines(expected), escapeNewlines(actual));
+        assertEquals(expected, actual, "Failed due to EOL differences.");
     }
 
     private String escapeNewlines(String input) {

javaparser-core-testing/src/test/java/com/github/javaparser/utils/LineEndingTest.java

@@ -0,0 +1,97 @@
+package com.github.javaparser.utils;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+/**
+ * @author Roger Howell
+ */
+class LineEndingTest {
+
+    @Test
+    void escaped() {
+        assertEquals("\\r", LineEnding.CR.escaped());
+        assertEquals("\\n", LineEnding.LF.escaped());
+        assertEquals("\\r\\n", LineEnding.CRLF.escaped());
+    }
+
+    @Test
+    void lookup() {
+        assertEquals(LineEnding.CR, LineEnding.lookup("\r").get());
+        assertEquals(LineEnding.LF, LineEnding.lookup("\n").get());
+        assertEquals(LineEnding.CRLF, LineEnding.lookup("\r\n").get());
+
+        assertFalse(LineEnding.lookup("").isPresent());
+        assertFalse(LineEnding.lookup(" ").isPresent());
+        assertFalse(LineEnding.lookup("\\r").isPresent());
+        assertFalse(LineEnding.lookup("\\n").isPresent());
+        assertFalse(LineEnding.lookup(" \\r").isPresent());
+        assertFalse(LineEnding.lookup(" \\n").isPresent());
+        assertFalse(LineEnding.lookup("\\r ").isPresent());
+        assertFalse(LineEnding.lookup("\\n ").isPresent());
+        assertFalse(LineEnding.lookup("test 123 123").isPresent());
+        assertFalse(LineEnding.lookup("\r \n").isPresent());
+        assertFalse(LineEnding.lookup("\\r \\n").isPresent());
+    }
+
+    @Test
+    void lookupEscaped() {
+        assertEquals(LineEnding.CR, LineEnding.lookupEscaped("\\r").get());
+        assertEquals(LineEnding.LF, LineEnding.lookupEscaped("\\n").get());
+        assertEquals(LineEnding.CRLF, LineEnding.lookupEscaped("\\r\\n").get());
+
+        assertFalse(LineEnding.lookupEscaped("").isPresent());
+        assertFalse(LineEnding.lookupEscaped(" ").isPresent());
+        assertFalse(LineEnding.lookupEscaped("\r").isPresent());
+        assertFalse(LineEnding.lookupEscaped("\n").isPresent());
+        assertFalse(LineEnding.lookupEscaped(" \r").isPresent());
+        assertFalse(LineEnding.lookupEscaped(" \n").isPresent());
+        assertFalse(LineEnding.lookupEscaped("\r ").isPresent());
+        assertFalse(LineEnding.lookupEscaped("\n ").isPresent());
+        assertFalse(LineEnding.lookupEscaped("test 123 123").isPresent());
+        assertFalse(LineEnding.lookupEscaped("\r \n").isPresent());
+        assertFalse(LineEnding.lookupEscaped("\\r \\n").isPresent());
+    }
+
+    @Test
+    void detect() {
+        assertEquals(LineEnding.CR, LineEnding.detect("\r"));
+        assertEquals(LineEnding.LF, LineEnding.detect("\n"));
+        assertEquals(LineEnding.CRLF, LineEnding.detect("\r\n"));
+
+        assertEquals(LineEnding.NONE, LineEnding.detect(""));
+        assertEquals(LineEnding.NONE, LineEnding.detect("test 123 123"));
+
+        assertEquals(LineEnding.MIXED, LineEnding.detect("\r \n"));
+    }
+
+    @Test
+    void testToString() {
+        assertEquals("\r", LineEnding.CR.toString());
+        assertEquals("\n", LineEnding.LF.toString());
+        assertEquals("\r\n", LineEnding.CRLF.toString());
+
+        // Note that this represents an "arbitrary" line ending -- this test is to highlight any time that it changes.
+        assertEquals("\n", LineEnding.ARBITRARY.toString());
+    }
+
+    @Test
+    void values() {
+        assertEquals(8, LineEnding.values().length);
+    }
+
+    @Test
+    void valueOf() {
+        assertEquals(LineEnding.CR, LineEnding.valueOf("CR"));
+        assertEquals(LineEnding.LF, LineEnding.valueOf("LF"));
+        assertEquals(LineEnding.CRLF, LineEnding.valueOf("CRLF"));
+        assertEquals(LineEnding.NONE, LineEnding.valueOf("NONE"));
+        assertEquals(LineEnding.MIXED, LineEnding.valueOf("MIXED"));
+        assertEquals(LineEnding.SYSTEM, LineEnding.valueOf("SYSTEM"));
+        assertEquals(LineEnding.UNKNOWN, LineEnding.valueOf("UNKNOWN"));
+        assertEquals(LineEnding.ARBITRARY, LineEnding.valueOf("ARBITRARY"));
+    }
+
+}

javaparser-core-testing/src/test/java/com/github/javaparser/utils/TestUtils.java

@@ -21,13 +21,22 @@
 
 package com.github.javaparser.utils;
 
-import com.github.javaparser.*;
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseResult;
+import com.github.javaparser.ParseStart;
+import com.github.javaparser.ParserConfiguration;
+import com.github.javaparser.Problem;
 import com.github.javaparser.ast.expr.Expression;
 import okhttp3.OkHttpClient;
 import okhttp3.Request;
 import okhttp3.Response;
 
-import java.io.*;
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.nio.file.Files;
@@ -76,10 +85,33 @@ public static String readResource(String resourceName) {
             return null;
         }
     }
-
-    public static void assertEqualToTextResource(String resourceName, String actual){
+
+    /**
+     * Use this assertion if line endings are important, otherwise use {@link #assertEqualToTextResourceNoEol(String, String)}
+     */
+    public static void assertEqualToTextResource(String resourceName, String actual) {
+        String expected = readResource(resourceName);
+
+        // First test equality ignoring EOL chars
+        assertEqualsNoEol(expected, actual);
+
+        // If this passes but the next one fails, the failure is due only to EOL differences, allowing a more precise test failure message.
+        assertEquals(
+                expected,
+                actual,
+                String.format("failed due to line separator differences -- Expected: %s, but actual: %s",
+                        LineEnding.detect(expected),
+                        LineEnding.detect(actual)
+                )
+        );
+    }
+
+    /**
+     * If line endings are important, use {@link #assertEqualToTextResource(String, String)}
+     */
+    public static void assertEqualToTextResourceNoEol(String resourceName, String actual) {
         String expected = readResource(resourceName);
-        assertEquals(expected, actual);
+        assertEquals(expected, actual, "failed due to line separator differences");
     }
 
     public static String readTextResource(Class<?> relativeClass, String resourceName) {
@@ -194,13 +226,13 @@ public static void assertExpressionValid(String expression) {
      * Assert that "actual" equals "expected", and that any EOL characters in "actual" are correct for the platform.
      */
     public static void assertEqualsNoEol(String expected, String actual) {
-        assertEquals(normalizeEolInTextBlock(expected, EOL), actual);
+        assertEquals(normalizeEolInTextBlock(expected, EOL), normalizeEolInTextBlock(actual, EOL));
     }
 
     /**
      * Assert that "actual" equals "expected", and that any EOL characters in "actual" are correct for the platform.
      */
     public static void assertEqualsNoEol(String expected, String actual, String message) {
-        assertEquals(normalizeEolInTextBlock(expected, EOL), actual, message);
+        assertEquals(normalizeEolInTextBlock(expected, EOL), normalizeEolInTextBlock(actual, EOL), message);
     }
 }

javaparser-core/src/main/java/com/github/javaparser/JavaParser.java

@@ -38,6 +38,7 @@
 import com.github.javaparser.ast.type.ClassOrInterfaceType;
 import com.github.javaparser.ast.type.Type;
 import com.github.javaparser.ast.type.TypeParameter;
+import com.github.javaparser.utils.LineEnding;
 
 import java.io.*;
 import java.nio.charset.Charset;
@@ -100,6 +101,23 @@ private GeneratedJavaParser getParserForProvider(Provider provider) {
         return astParser;
     }
 
+    private String providerToString(Provider provider) {
+        // FIXME: Surely there's a better way...?
+        StringBuilder sb = new StringBuilder();
+        char[] buffer = new char[1];
+        try {
+            while(provider.read(buffer, 0, 1) != -1) {
+                sb.append(buffer[0]);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+//
+        // FIXME: Surely there's a better way...?
+        String x = sb.toString();
+        return x;
+    }
+
     /**
      * Parses source code.
      * It takes the source code from a Provider.
@@ -114,6 +132,18 @@ public <N extends Node> ParseResult<N> parse(ParseStart<N> start, Provider provi
         assertNotNull(start);
         assertNotNull(provider);
 
+        // FIXME: Surely there's a better way...?
+        String x = providerToString(provider);
+        // close the old provider then open a new one...
+        try {
+            provider.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        provider = new StringProvider(x);
+        LineEnding detectedLineEnding = LineEnding.detect(x);
+
+
         for (PreProcessor preProcessor : configuration.getPreProcessors()) {
             provider = preProcessor.process(provider);
         }
@@ -123,6 +153,10 @@ public <N extends Node> ParseResult<N> parse(ParseStart<N> start, Provider provi
             N resultNode = start.parse(parser);
             ParseResult<N> result = new ParseResult<>(resultNode, parser.problems, parser.getCommentsCollection());
 
+            resultNode.setData(Node.LINE_ENDING_KEY, detectedLineEnding);
+            resultNode.findAll(Node.class)
+                    .forEach(node -> node.setData(Node.LINE_ENDING_KEY, detectedLineEnding));
+
             configuration.getPostProcessors()
                     .forEach(postProcessor -> postProcessor.process(result, configuration));
 

javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java

@@ -21,14 +21,6 @@
 
 package com.github.javaparser;
 
-import static com.github.javaparser.ParserConfiguration.LanguageLevel.*;
-import static com.github.javaparser.utils.Utils.*;
-
-import java.nio.charset.Charset;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-
 import com.github.javaparser.ParseResult.PostProcessor;
 import com.github.javaparser.Providers.PreProcessor;
 import com.github.javaparser.UnicodeEscapeProcessingProvider.PositionMapping;
@@ -37,7 +29,19 @@
 import com.github.javaparser.ast.validator.*;
 import com.github.javaparser.printer.lexicalpreservation.LexicalPreservingPrinter;
 import com.github.javaparser.resolution.SymbolResolver;
-import com.github.javaparser.version.*;
+import com.github.javaparser.utils.LineEnding;
+import com.github.javaparser.version.Java10PostProcessor;
+import com.github.javaparser.version.Java11PostProcessor;
+import com.github.javaparser.version.Java12PostProcessor;
+import com.github.javaparser.version.Java13PostProcessor;
+import com.github.javaparser.version.Java14PostProcessor;
+
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import static com.github.javaparser.ParserConfiguration.LanguageLevel.JAVA_8;
 
 /**
  * The configuration that is used by the parser.