Added all single-file functionality to the lj script (#79)

* Added testing of files to lj script

* Replaced error message of programs not having main with a warning, and stopped the lj script from running programs without a main function

* Rebuilt dotests.sh so it works with the lj script where all output is in a single file (fixes #50)

* Reset all test outputs to match the new format.

* Set the travis file to call dotests.sh over the entire tests directory

* Added the exit 1 condition for any failing outputs in dotests.sh (travis will fail incorrect outputs)

* Fixed the primitive-numbers test and removed it from the failing directory

* Fixed incorrect io tests that didn't match the language and reset their output.

* Added .in files for any io tests that required them and were lacking them.

* Updated the README

Author: MrBartWolf

.travis.yml

@@ -9,22 +9,4 @@ cache:
 install:
   - ./gradlew clean build
 script:
-  - ./compile.sh tests/bracket-access.lj && ./test.sh
-  - ./compile.sh tests/comp/3np1for.lj && ./test.sh
-  - ./compile.sh tests/comp/3np1while.lj && ./test.sh
-  - ./compile.sh tests/comp/different.lj && ./test.sh
-  - ./compile.sh tests/comp/oddgnome.lj && ./test.sh
-  - ./compile.sh tests/collections.lj && ./test.sh
-  - ./compile.sh tests/demo.lj && ./test.sh
-  - ./compile.sh tests/dog.lj && ./test.sh
-  - ./compile.sh tests/eqtests.lj && ./test.sh
-  - ./compile.sh tests/fact.lj && ./test.sh
-  - ./compile.sh tests/forloop.lj && ./test.sh
-  - ./compile.sh tests/format.lj && ./test.sh
-  - ./compile.sh tests/fp.lj && ./test.sh
-  - ./compile.sh tests/oop.lj && ./test.sh
-  - ./compile.sh tests/precedence.lj && ./test.sh
-  - ./compile.sh tests/quicksort.lj && ./test.sh
-  - ./compile.sh tests/shadow.lj && ./test.sh
-  - ./compile.sh tests/type-inference.lj && ./test.sh
-  - ./compile.sh tests/unit-test.lj && ./test.sh
+  - ./dotests.sh -r tests/

README.md

@@ -18,69 +18,31 @@ Gradle wrapper so installing Gradle is not necessary.
 ```
 ./gradlew build
 ````
-### Compiling a Less-Java Program
-
-A script is provided to compile any Less-Java program, and there are several
-examples in the `tests/` directory. Compiling is fairly straightforward.
+### Compiling and Running a Less-Java Program
 
+A script is provided to compile, run, and test any Less-Java program with a single command.
 ```
-./compile.sh <file-name>
+./lj <file-name>
 ````
 
 For example,
 
 ```
-./compile.sh tests/fact.lj
-```
-## Running
-
-It is possible to just run the most recently compiled program, or run a specific
-previously compiled Less-Java program.
-
-### Running A Less-Java Program
-
-Ensure that the program you wish to run has already been compiled following the
-instructions above. To run the most recently compiled or ran program, simply type:
-
-```
-./run.sh
-```
-
-To run a specific Less-Java program, use the name of the file you compiled. The
-extension is optional. For example:
-
-```
-./run.sh fact.lj
+./lj tests/fact.lj
 ```
 
 You will need to make sure that your program has a `main()` method if you want to
-run it. If it does not have a `main()` method, you will receive an error similar
+run it. If it does not have a `main()` method, you will receive a warning similar
 to the following.
 
 ```
-Error: Main method not found in class Main, please define the main method as:
-   public static void main(String[] args)
-or a JavaFX application class must extend javafx.application.Application
-```
-
-You can also compile and run a Less-Java program with a single instruction using the 
-go script. It works the same way as compilation:
-
-```
-./go.sh tests/fact.lj
+Warning: This program does not contain a main() function and will not be run
 ```
 
+The program will still be compiled and tested correctly even without a main() method, but no program output
+will be released.
 ##Testing
 
-### Running Tests From A File
-
-Ensure that the file you wish to run the test from has been compiled following the
-instructions above. Then simply run:
-
-```
-./test.sh
-```
-
 ### Running All Tests
 
 It is possible to run all the tests in the `tests/` directory and to set the

compile.sh

@@ -11,11 +11,6 @@ help() {
     echo "        If -s option not present, LJ file output will be compared to the previous expected output"
 }
 
-# Takes the name of a file. If the input file is a LJ file, compile and run it.
-# If the -s option is used, copy the outputs to the expected outputs file.
-# Otherwise, show a diff between the expected and actual output.
-# If the input file is a directory and the -r option is given, call test on the
-# directory's contents
 test() {
     local file=${1%"/"}
     if [ -f $file ] && [[ $file =~ .*\.lj ]]; then
@@ -25,64 +20,40 @@ test() {
         outdir=$parent/outputs
         base=$outdir/$name
         mkdir -p $outdir
-        echo "Compiling $file"
-        ./compile.sh $file 2>&1 | grep -wvi time > $base\_compile.out
-        echo "Done compiling"
-        echo
-        if [ -n "$(grep "main(" $file)" ]; then
-            echo "Running $file"
-            if [ -e "$parent/$name.in" ]; then
-                ./run.sh < "$parent/$name.in" 2>&1 | tee $base\_run.out
-            else
-                ./run.sh 2>&1 | tee $base\_run.out
-            fi
-            echo "Done running"
-            echo
+        echo "***************************************"
+        echo "Compiling, Running, and Testing $file"
+        if [ -e "$parent/$name.in" ]; then
+            ./lj $file < "$parent/$name.in" 2>&1 > $base.out
+        else
+            ./lj $file 2>&1 | grep -wvi time > $base.out
         fi
-        echo "Running tests for $file"
-        ./test.sh 2>&1 | grep -wvi time > $base\_test.out
-        echo "Done testing"
+        echo "Finished"
         echo
         if $set_expected; then
-            cp $base\_compile.out $base\_compile.exp
-            cp $base\_run.out $base\_run.exp
-            cp $base\_test.out $base\_test.exp
+            cp $base.out $base.exp
+            echo "Setting the expected output of $file to this actual output."
+            echo
         else
-            touch $base\_compile.exp
-            touch $base\_run.exp
-            touch $base\_test.exp
-            diff -uB $base\_compile.out $base\_compile.exp > $base\_compile.diff
-            if [ -s $base\_compile.diff ]; then
-                ((changes_found += 1))
-                echo "Changes detected in compile output; use -s option to set expected output"
+            #touch $base.out
+            diff -uB $base.out $base.exp > $base.diff
+            if [ -s $base.diff ]; then
+                echo "Differences detected in actual output; use -s option to set the expected output."
                 echo
-                cat $base\_compile.diff
+                cat $base.diff
                 echo
-            fi
-            if [ -s "$(grep "main(" $file)" ]; then
-                diff -uB $base\_run.out $base\_run.exp > $base\_run.diff
-                if [ -s $base\_run.diff ]; then
-                    ((changes_found += 1))
-                    echo "Changes detected in run output; use -s option to set expected output"
-                    echo
-                    cat $base\_run.diff
-                    echo
-                fi
-            fi
-            diff -uB $base\_test.out $base\_test.exp > $base\_test.diff
-            if [ -s $base\_test.diff ]; then
-                ((changes_found += 1))
-                echo "Changes detected in test output; use -s option to set expected output"
-                echo
-                cat $base\_test.diff
+                exit 1
+            else
+                echo "No differences detected between expected and actual output."
                 echo
             fi
         fi
     elif [ -d $file ] && $recursive; then
         for sub in $(ls $file); do
-            test $file/$sub
+            if [ ! "$(basename $file)" == "failing" ]; then
+                test $file/$sub
+            fi
         done
-    fi
+    fi           
 }
 
 help_flag=false
@@ -105,7 +76,7 @@ while getopts :hrs flag; do
             echo "Unexpected flag $OPTARG" 1>&2
             echo
             help
-            exit
+            exit 1
             ;;
     esac
 done
@@ -121,17 +92,9 @@ if [ $# == 0 ]; then
     echo "Expecting at least one file" 1>&2
     echo
     help
-    exit
+    exit 1
 fi
 
-changes_found=0
-
-# For each input file f:
 for f in $@; do
     test $f
 done
-
-# Show how many changes were detected
-if [ $set_expected == false ]; then
-    echo "Detected $changes_found changed outputs"
-fi

dotests.sh

@@ -49,8 +49,37 @@ fi
 
 args="${args} -Ptestfile=${1}"
 "$GRADLE_WRAPPER" $args
+
+# If the less-java file contains the string "main()", attempt to run it.
+# Otherwise, release a warning and continue
+parent=$(dirname $1)
 base=$(basename $1)
-upbase="$(tr '[:lower:]' '[:upper:]' <<< ${base:0:1})${base:1}"
-name="LJ${upbase%.*}"
-java -cp generated $name 
-exit
+name=${base%.*}
+count=$(grep -c "main()" "$1")
+if [ "$count" -gt "0" ];
+then
+    if [ -e "$parent/$name.in" ];
+    then
+        java -cp generated Main < "$parent/$name.in"
+    else
+        java -cp generated Main
+    fi
+else
+    echo "Warning: This program does not contain a main() function and will not be run"
+fi
+
+# --class-path allows specifying where JUnit should look for tests
+# --include-classname allows the name to be anything
+# --disable-banner disables the banner asking contributing to JUnit
+# --scan-class-path checks the full classpath for tests
+# Get the output but do not print it yet
+test_output="$(java -jar libs/junit-platform-console-standalone-1.4.2.jar --class-path ".:generated" --include-classname='.*' --disable-banner --scan-class-path)"
+# Preserve  the exit code of the tests
+test_status="$?"
+
+# The grep -v filter removes lines that are unnecessary or potentially
+#    confusing to an end user.
+echo "$test_output" | grep -v -e '\[.*containers.*\]' -e 'JUnit Vintage' -e 'Test run finished after'
+
+# Ensure the exit code from the tests is the exit code of the script
+exit "$test_status"

lj

@@ -78,7 +78,7 @@ public static void main(String[] args) throws IOException {
         BuildSymbolTables buildSymbolTables = new BuildSymbolTables();
         LJASTInferTypes inferTypes = new LJASTInferTypes();
         // PrintDebugTree printTree = new PrintDebugTree();
-        LJGenerateJava generateJava = new LJGenerateJava(fileName);
+        LJGenerateJava generateJava = new LJGenerateJava();
         LJASTCheckTypesHaveChanged checkTypesHaveChanged = new LJASTCheckTypesHaveChanged();
         LJInstantiateFunctions instantiateFunctions = new LJInstantiateFunctions();
         LJASTInferConstructors inferConstructors = new LJASTInferConstructors();

run.sh

@@ -45,14 +45,9 @@
 
 public class LJGenerateJava extends LJDefaultASTVisitor {
 
-    private String baseName = null;
-
-    public LJGenerateJava(String filename)
+    public LJGenerateJava()
     {
-        String[] parts = filename.split("[\\.\\\\\\/]");
-        baseName = parts[parts.length-2];
-        baseName = baseName.substring(0, 1).toUpperCase() + baseName.substring(1);
-        mainFile = Paths.get("generated/LJ" + baseName + ".java");
+        mainFile = Paths.get("generated/Main.java");
     }
 
     // Create generated directory if it doesn't exist
@@ -100,7 +95,7 @@ public void preVisit(ASTProgram node) {
 
         lines.addAll(Arrays.asList(imports));
 
-        lines.add("public class LJ" + baseName);
+        lines.add("public class Main");
         lines.add("{");
     }