do not exit repl if something went wrong

compiler/tests/org/jetbrains/jet/repl/ReplInterpreterTest.java

@@ -58,10 +58,17 @@ public class ReplInterpreterTest {
         ReplSessionTestFile file = ReplSessionTestFile.load(new File("compiler/testData/repl/" + relativePath));
         for (Pair<String, String> t : file.getLines()) {
             String code = t.first;
-            String expected = t.second;
+            String expected = t.second.replaceFirst("\r?\n$", "");
 
-            Object actual = repl.eval(code).getValue();
-            String actualString = actual != null ? actual.toString() : "null";
+            ReplInterpreter.LineResult lineResult = repl.eval(code);
+            Object actual;
+            if (lineResult.isSuccessful()) {
+                actual = lineResult.getValue();
+            }
+            else {
+                actual = lineResult.getErrorText();
+            }
+            String actualString = (actual != null ? actual.toString() : "null").replaceFirst("\r?\n$", "");
 
             Assert.assertEquals("after evaluation of: " + code, expected, actualString);
         }
@@ -113,4 +120,22 @@ public class ReplInterpreterTest {
     }
 
 
+    @Test
+    public void syntaxErrors() {
+        testFile("syntaxErrors.repl");
+    }
+
+    @Test
+    public void analyzeErrors() {
+        // TODO
+        //testFile("analyzeErrors.repl");
+    }
+
+    @Test
+    public void evaluationErrors() {
+        // TODO
+        //testFile("evaluationErrors.repl");
+    }
+
+
 }

compiler/tests/org/jetbrains/jet/repl/ReplSessionTestFile.java

@@ -17,7 +17,9 @@
 package org.jetbrains.jet.repl;
 
 import com.google.common.collect.Lists;
+import com.google.common.io.CharStreams;
 import com.intellij.openapi.util.Pair;
+import com.intellij.openapi.util.io.FileUtil;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.BufferedReader;
@@ -51,7 +53,8 @@ public class ReplSessionTestFile {
             FileInputStream inputStream = new FileInputStream(file);
             try {
                 BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
-                return load(reader);
+                List<String> lines = CharStreams.readLines(reader);
+                return load(new SimpleLinesParser(lines));
             } finally {
                 inputStream.close();
             }
@@ -60,28 +63,22 @@ public class ReplSessionTestFile {
         }
     }
 
-    private static ReplSessionTestFile load(@NotNull BufferedReader reader) throws IOException {
+    private static ReplSessionTestFile load(@NotNull SimpleLinesParser parser) throws IOException {
         List<Pair<String, String>> list = Lists.newArrayList();
-        while (true) {
-            String odd = reader.readLine();
-            if (odd == null) {
-                return new ReplSessionTestFile(list);
-            }
-
-            Pattern pattern = Pattern.compile(">>>( |$)(.*)");
-            Matcher matcher = pattern.matcher(odd);
-            if (!matcher.matches()) {
-                throw new IllegalStateException("odd lines must start with >>>");
-            }
+        while (!parser.lookingAtEof()) {
+            Pattern startPattern = Pattern.compile(">>>( |$)(.*)");
+            Matcher matcher = parser.next(startPattern);
             String code = matcher.group(2);
 
-            String even = reader.readLine();
-            if (even == null) {
-                throw new IllegalStateException("expecting even");
+            StringBuilder value = new StringBuilder();
+
+            while (!parser.lookingAtEof() && parser.lookingAt(startPattern) == null) {
+                value.append(parser.next()).append("\n");
             }
 
-            list.add(Pair.create(code, even));
+            list.add(Pair.create(code, value.toString()));
         }
+        return new ReplSessionTestFile(list);
     }
 
 }

compiler/tests/org/jetbrains/jet/repl/SimpleLinesParser.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2010-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.repl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * @author Stepan Koltsov
+ *
+ * @see org.jetbrains.jet.lang.types.ref.SimpleParser
+ */
+class SimpleLinesParser {
+
+    @NotNull
+    private final List<String> lines;
+    private int position;
+
+    SimpleLinesParser(@NotNull List<String> lines) {
+        this.lines = lines;
+    }
+
+    public boolean lookingAtEof() {
+        return position == lines.size();
+    }
+
+    public void checkNotEof() {
+        if (lookingAtEof()) {
+            throw new IllegalStateException("unexpected EOF");
+        }
+    }
+
+    @NotNull
+    public String lookahead() {
+        checkNotEof();
+        return lines.get(position);
+    }
+
+    @Nullable
+    public Matcher lookingAt(@NotNull Pattern pattern) {
+        if (lookingAtEof()) {
+            return null;
+        }
+        Matcher matcher = pattern.matcher(lookahead());
+        if (matcher.matches()) {
+            return matcher;
+        }
+        else {
+            return null;
+        }
+    }
+
+    @NotNull
+    public Matcher next(@NotNull Pattern pattern) {
+        Matcher r = lookingAt(pattern);
+        if (r == null) {
+            throw new IllegalStateException("line " + position + " must match " + pattern);
+        }
+        ++position;
+        return r;
+    }
+
+    @NotNull
+    public String next() {
+        String r = lookahead();
+        ++position;
+        return r;
+    }
+}