about summary refs log tree commit diff stats
path: root/test_apps
diff options
context:
space:
mode:
Diffstat (limited to 'test_apps')
-rwxr-xr-xtest_apps244
1 files changed, 116 insertions, 128 deletions
diff --git a/test_apps b/test_apps
index 129e429c..8f6253ba 100755
--- a/test_apps
+++ b/test_apps
@@ -1,180 +1,171 @@
 #!/bin/sh
-# Build and test all included SubX programs:
+# Build and test all included SubX programs on Linux:
 #   translate them into ELF binaries
 #   compare the generated binaries with what's already in git
-#   run/test the ELF binaries in emulated mode (unless $NO_EMULATION)
-#   run/test the ELF binaries in native mode (if on Linux)
+#   run/test the ELF binaries in emulated mode
+#   run/test the ELF binaries in native mode
 #
 # Example usage:
-#   test_apps  # compare generated binaries, run them in emulated and native mode
-#   test_apps record  # run binaries in emulated and native mode
-#   NO_EMULATION=1 test_apps  # compare generated binaries, run them in native mode
-#   NO_EMULATION=1 test_apps record  # run binaries just in native mode
+#   test_apps
+#   test_apps record  # don't compare with what's in git
 
 set -e
 cd `dirname $0`
 
-test $NO_EMULATION  ||  EMULATED=1
-test $EMULATED  &&  echo 'testing emulated runs'
-test `uname` = 'Linux'  &&  NATIVE=1
-test $NATIVE  &&  echo 'testing native runs'
-
 ./build
 
-export OS=${OS:-linux}
-
-echo "== translating and running using C++"
+echo "== translating using the bootstrap C++ translator"
 
 # example programs
 
 echo ex1
-./bootstrap translate init.$OS apps/ex1.subx  -o apps/ex1
+./bootstrap_bin translate init.linux apps/ex1.subx  -o apps/ex1
 test "$1" = 'record'  ||  git diff --exit-code apps/ex1
-test $EMULATED  &&  {
-  ./bootstrap run apps/ex1  ||  ret=$?
+{
+  ./bootstrap_bin run apps/ex1  ||  ret=$?
   test $ret -eq 42  # life, the universe and everything
 }
-test $NATIVE  &&  {
+{
   apps/ex1  ||  ret=$?
   test $ret -eq 42  # life, the universe and everything
 }
 
 echo ex2
-./bootstrap translate init.$OS apps/ex2.subx  -o apps/ex2
+./bootstrap_bin translate init.linux apps/ex2.subx  -o apps/ex2
 test "$1" = 'record'  ||  git diff --exit-code apps/ex2
-test $EMULATED  &&  {
-  ./bootstrap run apps/ex2  ||  ret=$?
+{
+  ./bootstrap_bin run apps/ex2  ||  ret=$?
   test $ret -eq 7  # 3 + 4
 }
-test $NATIVE  &&  {
+{
   apps/ex2  ||  ret=$?
   test $ret -eq 7  # 3 + 4
 }
 
 echo ex3
-./bootstrap translate init.$OS apps/ex3.subx  -o apps/ex3
+./bootstrap_bin translate init.linux apps/ex3.subx  -o apps/ex3
 test "$1" = 'record'  ||  git diff --exit-code apps/ex3
-test $EMULATED  &&  {
-  ./bootstrap run apps/ex3  ||  ret=$?
+{
+  ./bootstrap_bin run apps/ex3  ||  ret=$?
   test $ret -eq 55  # 1 + 2 + ... + 10
 }
-test $NATIVE  &&  {
+{
   apps/ex3  ||  ret=$?
   test $ret -eq 55  # 1 + 2 + ... + 10
 }
 
 echo ex4
-./bootstrap translate init.$OS apps/ex4.subx  -o apps/ex4
+./bootstrap_bin translate init.linux apps/ex4.subx  -o apps/ex4
 test "$1" = 'record'  ||  git diff --exit-code apps/ex4
-test $EMULATED  &&  {
-  echo a | ./bootstrap run apps/ex4 >ex4.out  ||  true
+{
+  echo a | ./bootstrap_bin run apps/ex4 >ex4.out  ||  true
   test `cat ex4.out` = 'a'
 }
-test $NATIVE  &&  {
+{
   echo a | apps/ex4 >ex4.out  ||  true
   test `cat ex4.out` = 'a'
 }
 
 echo ex5
-./bootstrap translate init.$OS apps/ex5.subx  -o apps/ex5
+./bootstrap_bin translate init.linux apps/ex5.subx  -o apps/ex5
 test "$1" = 'record'  ||  git diff --exit-code apps/ex5
-test $EMULATED  &&  {
-  echo a | ./bootstrap run apps/ex5 >ex5.out  ||  true
+{
+  echo a | ./bootstrap_bin run apps/ex5 >ex5.out  ||  true
   test `cat ex5.out` = 'a'
 }
-test $NATIVE  &&  {
+{
   echo a | apps/ex5 >ex5.out  ||  true
   test `cat ex5.out` = 'a'
 }
 
 echo ex6
-./bootstrap translate init.$OS apps/ex6.subx  -o apps/ex6
+./bootstrap_bin translate init.linux apps/ex6.subx  -o apps/ex6
 test "$1" = 'record'  ||  git diff --exit-code apps/ex6
-test $EMULATED  &&  {
-  ./bootstrap run apps/ex6 >ex6.out  ||  true
+{
+  ./bootstrap_bin run apps/ex6 >ex6.out  ||  true
   test "`cat ex6.out`" = 'Hello, world!'
 }
-test $NATIVE  &&  {
+{
   apps/ex6 >ex6.out  ||  true
   test "`cat ex6.out`" = 'Hello, world!'
 }
 
 echo ex7
-./bootstrap translate init.$OS apps/ex7.subx  -o apps/ex7
+./bootstrap_bin translate init.linux apps/ex7.subx  -o apps/ex7
 test "$1" = 'record'  ||  git diff --exit-code apps/ex7
-test $EMULATED  &&  {
-  ./bootstrap run apps/ex7  ||  ret=$?
+{
+  ./bootstrap_bin run apps/ex7  ||  ret=$?
   test $ret -eq 97  # 'a'
 }
-test $NATIVE  &&  {
+{
   apps/ex7  ||  ret=$?
   test $ret -eq 97  # 'a'
 }
 
 echo ex8
-./bootstrap translate init.$OS apps/ex8.subx  -o apps/ex8
+./bootstrap_bin translate init.linux apps/ex8.subx  -o apps/ex8
 test "$1" = 'record'  || git diff --exit-code apps/ex8
-test $EMULATED  &&  {
-  ./bootstrap run apps/ex8 abcd  ||  ret=$?
+{
+  ./bootstrap_bin run apps/ex8 abcd  ||  ret=$?
   test $ret -eq 4  # length('abcd')
 }
-test $NATIVE  &&  {
+{
   apps/ex8 abcd  ||  ret=$?
   test $ret -eq 4  # length('abcd')
 }
 
 echo ex9
-./bootstrap translate init.$OS apps/ex9.subx  -o apps/ex9
+./bootstrap_bin translate init.linux apps/ex9.subx  -o apps/ex9
 test "$1" = 'record'  || git diff --exit-code apps/ex9
-test $EMULATED  &&  {
-  ./bootstrap run apps/ex9 z x  ||  ret=$?
+{
+  ./bootstrap_bin run apps/ex9 z x  ||  ret=$?
   test $ret -eq 2  # 'z' - 'x'
 }
-test $NATIVE  &&  {
+{
   apps/ex9 z x  ||  ret=$?
   test $ret -eq 2  # 'z' - 'x'
 }
 
 echo ex10
-./bootstrap translate init.$OS apps/ex10.subx  -o apps/ex10
+./bootstrap_bin translate init.linux apps/ex10.subx  -o apps/ex10
 test "$1" = 'record'  || git diff --exit-code apps/ex10
-test $EMULATED  &&  {
-  ./bootstrap run apps/ex10 abc abc  ||  ret=$?
+{
+  ./bootstrap_bin run apps/ex10 abc abc  ||  ret=$?
   test $ret -eq 1  # equal
-  ./bootstrap run apps/ex10 abc abcd  # 0; not equal
+  ./bootstrap_bin run apps/ex10 abc abcd  # 0; not equal
 }
-test $NATIVE  &&  {
+{
   apps/ex10 abc abc  ||  ret=$?
   test $ret -eq 1  # equal
   apps/ex10 abc abcd  # 0; not equal
 }
 
 echo ex11
-./bootstrap translate init.$OS apps/ex11.subx  -o apps/ex11
+./bootstrap_bin translate init.linux apps/ex11.subx  -o apps/ex11
 test "$1" = 'record'  || git diff --exit-code apps/ex11
-test $EMULATED  &&  {
-  ./bootstrap run apps/ex11
+{
+  ./bootstrap_bin run apps/ex11
   echo
 }
-test $NATIVE  &&  {
+{
   apps/ex11
   echo
 }
 
 echo ex12
-./bootstrap translate init.$OS apps/ex12.subx  -o apps/ex12
+./bootstrap_bin translate init.linux apps/ex12.subx  -o apps/ex12
 test "$1" = 'record'  || git diff --exit-code apps/ex12
-test $EMULATED  &&  ./bootstrap run apps/ex12  # final byte of mmap'd address is well-nigh guaranteed to be 0
+test $EMULATED  &&  ./bootstrap_bin run apps/ex12  # final byte of mmap'd address is well-nigh guaranteed to be 0
 test $NATIVE  &&  apps/ex12
 
 echo ex13
-./bootstrap translate init.$OS apps/ex13.subx  -o apps/ex13
+./bootstrap_bin translate init.linux apps/ex13.subx  -o apps/ex13
 test "$1" = 'record'  ||  git diff --exit-code apps/ex13
-test $EMULATED  &&  {
-  ./bootstrap run apps/ex13  ||  ret=$?
+{
+  ./bootstrap_bin run apps/ex13  ||  ret=$?
   test $ret -eq 1  # 3 == 3
 }
-test $NATIVE  &&  {
+{
   apps/ex13  ||  ret=$?
   test $ret -eq 1  # 3 == 3
 }
@@ -182,15 +173,15 @@ test $NATIVE  &&  {
 # Larger apps that use the standard library.
 
 echo factorial
-./bootstrap translate init.$OS [01]*.subx apps/factorial.subx  -o apps/factorial
+./bootstrap_bin translate init.linux [01]*.subx apps/factorial.subx  -o apps/factorial
 test "$1" = 'record'  ||  git diff --exit-code apps/factorial
-test $EMULATED  &&  {
-  ./bootstrap run apps/factorial  ||  ret=$?
+{
+  ./bootstrap_bin run apps/factorial  ||  ret=$?
   test $ret -eq 120  # factorial(5)
-  ./bootstrap run apps/factorial test
+  ./bootstrap_bin run apps/factorial test
   echo
 }
-test $NATIVE  &&  {
+{
   apps/factorial  ||  ret=$?
   test $ret -eq 120  # factorial(5)
   apps/factorial test
@@ -198,25 +189,25 @@ test $NATIVE  &&  {
 }
 
 echo crenshaw2-1
-./bootstrap translate init.$OS [01]*.subx apps/crenshaw2-1.subx  -o apps/crenshaw2-1
+./bootstrap_bin translate init.linux [01]*.subx apps/crenshaw2-1.subx  -o apps/crenshaw2-1
 test "$1" = 'record'  ||  git diff --exit-code apps/crenshaw2-1
-test $EMULATED  &&  {
-  ./bootstrap run apps/crenshaw2-1 test
+{
+  ./bootstrap_bin run apps/crenshaw2-1 test
   echo
 }
-test $NATIVE  &&  {
+{
   apps/crenshaw2-1 test
   echo
 }
 
 echo crenshaw2-1b
-./bootstrap translate init.$OS [01]*.subx apps/crenshaw2-1b.subx  -o apps/crenshaw2-1b
+./bootstrap_bin translate init.linux [01]*.subx apps/crenshaw2-1b.subx  -o apps/crenshaw2-1b
 test "$1" = 'record'  ||  git diff --exit-code apps/crenshaw2-1b
-test $EMULATED  &&  {
-  ./bootstrap run apps/crenshaw2-1b test
+{
+  ./bootstrap_bin run apps/crenshaw2-1b test
   echo
 }
-test $NATIVE  &&  {
+{
   apps/crenshaw2-1b test
   echo
 }
@@ -226,13 +217,13 @@ test $NATIVE  &&  {
 for phase in hex survey pack assort dquotes tests
 do
   echo $phase
-  ./bootstrap translate init.$OS [01]*.subx apps/subx-params.subx apps/$phase.subx -o apps/$phase
+  ./bootstrap_bin translate init.linux [01]*.subx apps/subx-params.subx apps/$phase.subx -o apps/$phase
   test "$1" = 'record'  ||  git diff --exit-code apps/$phase
-  test $EMULATED  &&  {
-    ./bootstrap run apps/$phase test
+  {
+    ./bootstrap_bin run apps/$phase test
     echo
   }
-  test $NATIVE  &&  {
+  {
     apps/$phase test
     echo
   }
@@ -241,70 +232,67 @@ done
 # Higher-level syntax.
 
 # Certain phases of translation run native beyond this point. We're starting
-# to go beyond functionality of the C++ bootstrap.
+# to go beyond functionality of the C++ bootstrap_bin.
 
 echo sigils
-./bootstrap translate init.$OS [012]*.subx apps/subx-params.subx apps/sigils.subx  -o apps/sigils
+./bootstrap_bin translate init.linux [012]*.subx apps/subx-params.subx apps/sigils.subx  -o apps/sigils
 test "$1" = 'record'  ||  git diff --exit-code apps/sigils
-test $EMULATED  &&  {
-  ./bootstrap run apps/sigils test
+{
+  ./bootstrap_bin run apps/sigils test
   echo
 }
-test $NATIVE  &&  {
+{
   apps/sigils test
   echo
 }
 
-test $NATIVE  ||  { echo 'there are more tests, but you need Linux to run them'; exit 0; }
-
 echo calls
-cat init.$OS [012]*.subx apps/subx-params.subx apps/calls.subx  |  apps/sigils  > a.sigils
-./bootstrap translate a.sigils -o apps/calls
+cat init.linux [012]*.subx apps/subx-params.subx apps/calls.subx  |  apps/sigils  > a.sigils
+./bootstrap_bin translate a.sigils -o apps/calls
 test "$1" = 'record'  ||  git diff --exit-code apps/calls
-test $EMULATED  &&  {
-  ./bootstrap run apps/calls test
+{
+  ./bootstrap_bin run apps/calls test
   echo
 }
-test $NATIVE  &&  {
+{
   apps/calls test
   echo
 }
 
 echo braces
-cat init.$OS [012]*.subx apps/subx-params.subx apps/braces.subx  |  apps/calls  |  apps/sigils  > a.sigils
-./bootstrap translate a.sigils -o apps/braces
+cat init.linux [012]*.subx apps/subx-params.subx apps/braces.subx  |  apps/calls  |  apps/sigils  > a.sigils
+./bootstrap_bin translate a.sigils -o apps/braces
 test "$1" = 'record'  ||  git diff --exit-code apps/braces
-test $EMULATED  &&  {
-  ./bootstrap run apps/braces test
+{
+  ./bootstrap_bin run apps/braces test
   echo
 }
-test $NATIVE  &&  {
+{
   apps/braces test
   echo
 }
 
 echo mu
-cat init.$OS [0-2]*.subx apps/mu.subx  |  apps/braces  |  apps/calls  |  apps/sigils  > a.sigils
-./bootstrap translate a.sigils -o apps/mu
+cat init.linux [0-2]*.subx apps/mu.subx  |  apps/braces  |  apps/calls  |  apps/sigils  > a.sigils
+./bootstrap_bin translate a.sigils -o apps/mu
 test "$1" = 'record'  ||  git diff --exit-code apps/mu
-test $EMULATED  &&  {
-  ./bootstrap run apps/mu test
+{
+  ./bootstrap_bin run apps/mu test
   echo
 }
-test $NATIVE  &&  {
+{
   apps/mu test
   echo
 }
 
-test $NATIVE  ||  exit 0
-echo "== translating using SubX (native only)"
+echo "== translating using the self-hosted translator"
 
 # example programs
 
 for n in `seq 1 12`
 do
   echo ex$n
-  ./translate_subx init.$OS apps/ex$n.subx
+  ./translate_subx init.linux apps/ex$n.subx
   diff apps/ex$n a.elf
 done
 
@@ -313,7 +301,7 @@ done
 for app in factorial crenshaw2-1 crenshaw2-1b
 do
   echo $app
-  ./translate_subx init.$OS [01]*.subx apps/$app.subx
+  ./translate_subx init.linux [01]*.subx apps/$app.subx
   diff apps/$app a.elf
 done
 
@@ -322,77 +310,77 @@ done
 for app in hex survey pack assort dquotes tests
 do
   echo $app
-  ./translate_subx init.$OS [01]*.subx apps/subx-params.subx apps/$app.subx
+  ./translate_subx init.linux [01]*.subx apps/subx-params.subx apps/$app.subx
   diff apps/$app a.elf
 done
 
 for app in sigils calls braces
 do
   echo $app
-  ./translate_subx init.$OS [012]*.subx apps/subx-params.subx apps/$app.subx
+  ./translate_subx init.linux [012]*.subx apps/subx-params.subx apps/$app.subx
   diff apps/$app a.elf
 done
 
 # Mu translator
 echo mu
-./translate_subx init.$OS [0-2]*.subx apps/mu.subx
+./translate_subx init.linux [0-2]*.subx apps/mu.subx
 diff apps/mu a.elf
 
 # Mu programs
 
 echo ex1.mu
 ./translate_mu apps/ex1.mu
-test $EMULATED  &&  {
-  ./bootstrap run a.elf  ||  ret=$?
+{
+  ./bootstrap_bin run a.elf  ||  ret=$?
   test $ret -eq 42  # life, the universe and everything
 }
-test $NATIVE  &&  {
+{
   ./a.elf  ||  ret=$?
   test $ret -eq 42  # life, the universe and everything
 }
 
 echo ex2.mu
 ./translate_mu apps/ex2.mu
-test $EMULATED  &&  {
-  ./bootstrap run a.elf  ||  ret=$?
+{
+  ./bootstrap_bin run a.elf  ||  ret=$?
   test $ret -eq 7
 }
-test $NATIVE  &&  {
+{
   ./a.elf  ||  ret=$?
   test $ret -eq 7
 }
 
 echo ex3.mu
 ./translate_mu apps/ex3.mu
-test $EMULATED  &&  {
-  ./bootstrap run a.elf  ||  ret=$?
+{
+  ./bootstrap_bin run a.elf  ||  ret=$?
   test $ret -eq 55
 }
-test $NATIVE  &&  {
+{
   ./a.elf  ||  ret=$?
   test $ret -eq 55
 }
 
 echo ex3.2.mu
 ./translate_mu apps/ex3.2.mu
-test $EMULATED  &&  {
-  ./bootstrap run a.elf  ||  ret=$?
+{
+  ./bootstrap_bin run a.elf  ||  ret=$?
   test $ret -eq 55
 }
-test $NATIVE  &&  {
+{
   ./a.elf  ||  ret=$?
   test $ret -eq 55
 }
 
 echo factorial.mu
 ./translate_mu apps/factorial.mu
-test $EMULATED  &&  {
-  ./bootstrap run a.elf  ||  ret=$?
+{
+  ./bootstrap_bin run a.elf  ||  ret=$?
   test $ret -eq 120
-  ./bootstrap run a.elf test
+  ./bootstrap_bin run a.elf test
   echo
 }
-test $NATIVE  &&  {
+{
   ./a.elf  ||  ret=$?
   test $ret -eq 120
   ./a.elf test
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2025-02-17 02:31:10 +0000