Update test suite.

tests/standard-testsuite/core.f.js

@@ -1,7 +1,5 @@
 export default `
 
-: FOO ." Hello World" CR ;
-
 CR
 TESTING CORE WORDS
 
@@ -9,12 +7,268 @@ TESTING CORE WORDS
 TESTING BASIC ASSUMPTIONS
 
 T{ -> }T               \\ START WITH CLEAN SLATE
-( TEST IF ANY BITS ARE SET; ANSWER IN BASE 1 )
+
+\\ TEST IF ANY BITS ARE SET; ANSWER IN BASE 1
 T{ : BITSSET? IF 0 0 ELSE 0 THEN ; -> }T
-T{  0 BITSSET? -> 0 }T      ( ZERO IS ALL BITS CLEAR )
-T{  1 BITSSET? -> 0 0 }T      ( OTHER NUMBER HAVE AT LEAST ONE BIT )
+T{  0 BITSSET? -> 0 }T  \\ ( ZERO IS ALL BITS CLEAR )
+T{  1 BITSSET? -> 0 0 }T \\ ( OTHER NUMBER HAVE AT LEAST ONE BIT )
 T{ -1 BITSSET? -> 0 0 }T
 
-FOO
+\\ ------------------------------------------------------------------------
+TESTING BOOLEANS: INVERT AND OR XOR
+
+T{ 0 0 AND -> 0 }T
+T{ 0 1 AND -> 0 }T
+T{ 1 0 AND -> 0 }T
+T{ 1 1 AND -> 1 }T
+
+T{ 0 INVERT 1 AND -> 1 }T
+T{ 1 INVERT 1 AND -> 0 }T
+
+0    CONSTANT 0S
+0 INVERT CONSTANT 1S
+
+T{ 0S INVERT -> 1S }T
+T{ 1S INVERT -> 0S }T
+
+T{ 0S 0S AND -> 0S }T
+T{ 0S 1S AND -> 0S }T
+T{ 1S 0S AND -> 0S }T
+T{ 1S 1S AND -> 1S }T
+
+T{ 0S 0S OR -> 0S }T
+T{ 0S 1S OR -> 1S }T
+T{ 1S 0S OR -> 1S }T
+T{ 1S 1S OR -> 1S }T
+
+T{ 0S 0S XOR -> 0S }T
+T{ 0S 1S XOR -> 1S }T
+T{ 1S 0S XOR -> 1S }T
+T{ 1S 1S XOR -> 0S }T
+
+\\ ------------------------------------------------------------------------
+TESTING 2* 2/ LSHIFT RSHIFT
+
+\\ ( WE TRUST 1S, INVERT, AND BITSSET?; WE WILL CONFIRM RSHIFT LATER )
+1S 1 RSHIFT INVERT CONSTANT MSB
+T{ MSB BITSSET? -> 0 0 }T
+
+T{ 0S 2* -> 0S }T
+T{ 1 2* -> 2 }T
+T{ 4000 2* -> 8000 }T
+T{ 1S 2* 1 XOR -> 1S }T
+T{ MSB 2* -> 0S }T
+
+T{ 0S 2/ -> 0S }T
+T{ 1 2/ -> 0 }T
+T{ 4000 2/ -> 2000 }T
+T{ 1S 2/ -> 1S }T            \\ MSB PROPOGATED
+T{ 1S 1 XOR 2/ -> 1S }T
+T{ MSB 2/ MSB AND -> MSB }T
+
+T{ 1 0 LSHIFT -> 1 }T
+T{ 1 1 LSHIFT -> 2 }T
+T{ 1 2 LSHIFT -> 4 }T
+T{ 1 F LSHIFT -> 8000 }T         \\ BIGGEST GUARANTEED SHIFT
+T{ 1S 1 LSHIFT 1 XOR -> 1S }T
+T{ MSB 1 LSHIFT -> 0 }T
+
+T{ 1 0 RSHIFT -> 1 }T
+T{ 1 1 RSHIFT -> 0 }T
+T{ 2 1 RSHIFT -> 1 }T
+T{ 4 2 RSHIFT -> 1 }T
+T{ 8000 F RSHIFT -> 1 }T         \\ BIGGEST
+T{ MSB 1 RSHIFT MSB AND -> 0 }T      \\ RSHIFT ZERO FILLS MSBS
+T{ MSB 1 RSHIFT 2* -> MSB }T
+
+\\ ------------------------------------------------------------------------
+TESTING COMPARISONS: 0= = 0< < > U< MIN MAX
+0 INVERT         CONSTANT MAX-UINT
+0 INVERT 1 RSHIFT      CONSTANT MAX-INT
+0 INVERT 1 RSHIFT INVERT   CONSTANT MIN-INT
+0 INVERT 1 RSHIFT      CONSTANT MID-UINT
+0 INVERT 1 RSHIFT INVERT   CONSTANT MID-UINT+1
+
+0S CONSTANT <FALSE>
+1S CONSTANT <TRUE>
+
+T{ 0 0= -> <TRUE> }T
+T{ 1 0= -> <FALSE> }T
+T{ 2 0= -> <FALSE> }T
+T{ -1 0= -> <FALSE> }T
+T{ MAX-UINT 0= -> <FALSE> }T
+T{ MIN-INT 0= -> <FALSE> }T
+T{ MAX-INT 0= -> <FALSE> }T
+
+T{ 0 0 = -> <TRUE> }T
+T{ 1 1 = -> <TRUE> }T
+T{ -1 -1 = -> <TRUE> }T
+T{ 1 0 = -> <FALSE> }T
+T{ -1 0 = -> <FALSE> }T
+T{ 0 1 = -> <FALSE> }T
+T{ 0 -1 = -> <FALSE> }T
+
+T{ 0 0< -> <FALSE> }T
+T{ -1 0< -> <TRUE> }T
+T{ MIN-INT 0< -> <TRUE> }T
+T{ 1 0< -> <FALSE> }T
+T{ MAX-INT 0< -> <FALSE> }T
+
+T{ 0 1 < -> <TRUE> }T
+T{ 1 2 < -> <TRUE> }T
+T{ -1 0 < -> <TRUE> }T
+T{ -1 1 < -> <TRUE> }T
+T{ MIN-INT 0 < -> <TRUE> }T
+T{ MIN-INT MAX-INT < -> <TRUE> }T
+T{ 0 MAX-INT < -> <TRUE> }T
+T{ 0 0 < -> <FALSE> }T
+T{ 1 1 < -> <FALSE> }T
+T{ 1 0 < -> <FALSE> }T
+T{ 2 1 < -> <FALSE> }T
+T{ 0 -1 < -> <FALSE> }T
+T{ 1 -1 < -> <FALSE> }T
+T{ 0 MIN-INT < -> <FALSE> }T
+T{ MAX-INT MIN-INT < -> <FALSE> }T
+T{ MAX-INT 0 < -> <FALSE> }T
+
+T{ 0 1 > -> <FALSE> }T
+T{ 1 2 > -> <FALSE> }T
+T{ -1 0 > -> <FALSE> }T
+T{ -1 1 > -> <FALSE> }T
+T{ MIN-INT 0 > -> <FALSE> }T
+T{ MIN-INT MAX-INT > -> <FALSE> }T
+T{ 0 MAX-INT > -> <FALSE> }T
+T{ 0 0 > -> <FALSE> }T
+T{ 1 1 > -> <FALSE> }T
+T{ 1 0 > -> <TRUE> }T
+T{ 2 1 > -> <TRUE> }T
+T{ 0 -1 > -> <TRUE> }T
+T{ 1 -1 > -> <TRUE> }T
+T{ 0 MIN-INT > -> <TRUE> }T
+T{ MAX-INT MIN-INT > -> <TRUE> }T
+T{ MAX-INT 0 > -> <TRUE> }T
+
+T{ 0 1 U< -> <TRUE> }T
+T{ 1 2 U< -> <TRUE> }T
+T{ 0 MID-UINT U< -> <TRUE> }T
+T{ 0 MAX-UINT U< -> <TRUE> }T
+T{ MID-UINT MAX-UINT U< -> <TRUE> }T
+T{ 0 0 U< -> <FALSE> }T
+T{ 1 1 U< -> <FALSE> }T
+T{ 1 0 U< -> <FALSE> }T
+T{ 2 1 U< -> <FALSE> }T
+T{ MID-UINT 0 U< -> <FALSE> }T
+T{ MAX-UINT 0 U< -> <FALSE> }T
+T{ MAX-UINT MID-UINT U< -> <FALSE> }T
+
+T{ 0 1 MIN -> 0 }T
+T{ 1 2 MIN -> 1 }T
+T{ -1 0 MIN -> -1 }T
+T{ -1 1 MIN -> -1 }T
+T{ MIN-INT 0 MIN -> MIN-INT }T
+T{ MIN-INT MAX-INT MIN -> MIN-INT }T
+T{ 0 MAX-INT MIN -> 0 }T
+T{ 0 0 MIN -> 0 }T
+T{ 1 1 MIN -> 1 }T
+T{ 1 0 MIN -> 0 }T
+T{ 2 1 MIN -> 1 }T
+T{ 0 -1 MIN -> -1 }T
+T{ 1 -1 MIN -> -1 }T
+T{ 0 MIN-INT MIN -> MIN-INT }T
+T{ MAX-INT MIN-INT MIN -> MIN-INT }T
+T{ MAX-INT 0 MIN -> 0 }T
+
+T{ 0 1 MAX -> 1 }T
+T{ 1 2 MAX -> 2 }T
+T{ -1 0 MAX -> 0 }T
+T{ -1 1 MAX -> 1 }T
+T{ MIN-INT 0 MAX -> 0 }T
+T{ MIN-INT MAX-INT MAX -> MAX-INT }T
+T{ 0 MAX-INT MAX -> MAX-INT }T
+T{ 0 0 MAX -> 0 }T
+T{ 1 1 MAX -> 1 }T
+T{ 1 0 MAX -> 1 }T
+T{ 2 1 MAX -> 2 }T
+T{ 0 -1 MAX -> 0 }T
+T{ 1 -1 MAX -> 1 }T
+T{ 0 MIN-INT MAX -> 0 }T
+T{ MAX-INT MIN-INT MAX -> MAX-INT }T
+T{ MAX-INT 0 MAX -> MAX-INT }T
+
+\\ ------------------------------------------------------------------------
+TESTING STACK OPS: 2DROP 2DUP 2OVER 2SWAP ?DUP DEPTH DROP DUP OVER ROT SWAP
+
+T{ 1 2 2DROP -> }T
+T{ 1 2 2DUP -> 1 2 1 2 }T
+T{ 1 2 3 4 2OVER -> 1 2 3 4 1 2 }T
+T{ 1 2 3 4 2SWAP -> 3 4 1 2 }T
+T{ 0 ?DUP -> 0 }T
+T{ 1 ?DUP -> 1 1 }T
+T{ -1 ?DUP -> -1 -1 }T
+T{ DEPTH -> 0 }T
+T{ 0 DEPTH -> 0 1 }T
+T{ 0 1 DEPTH -> 0 1 2 }T
+T{ 0 DROP -> }T
+T{ 1 2 DROP -> 1 }T
+T{ 1 DUP -> 1 1 }T
+T{ 1 2 OVER -> 1 2 1 }T
+T{ 1 2 3 ROT -> 2 3 1 }T
+T{ 1 2 SWAP -> 2 1 }T
+
+\\ ------------------------------------------------------------------------
+TESTING >R R> R@
+
+T{ : GR1 >R R> ; -> }T
+T{ : GR2 >R R@ R> DROP ; -> }T
+T{ 123 GR1 -> 123 }T
+T{ 123 GR2 -> 123 }T
+T{ 1S GR1 -> 1S }T   \\ ( RETURN STACK HOLDS CELLS )
+
+\\ ------------------------------------------------------------------------
+TESTING ADD/SUBTRACT: + - 1+ 1- ABS NEGATE
+
+T{ 0 5 + -> 5 }T
+T{ 5 0 + -> 5 }T
+T{ 0 -5 + -> -5 }T
+T{ -5 0 + -> -5 }T
+T{ 1 2 + -> 3 }T
+T{ 1 -2 + -> -1 }T
+T{ -1 2 + -> 1 }T
+T{ -1 -2 + -> -3 }T
+T{ -1 1 + -> 0 }T
+T{ MID-UINT 1 + -> MID-UINT+1 }T
+
+T{ 0 5 - -> -5 }T
+T{ 5 0 - -> 5 }T
+T{ 0 -5 - -> 5 }T
+T{ -5 0 - -> -5 }T
+T{ 1 2 - -> -1 }T
+T{ 1 -2 - -> 3 }T
+T{ -1 2 - -> -3 }T
+T{ -1 -2 - -> 1 }T
+T{ 0 1 - -> -1 }T
+T{ MID-UINT+1 1 - -> MID-UINT }T
+
+T{ 0 1+ -> 1 }T
+T{ -1 1+ -> 0 }T
+T{ 1 1+ -> 2 }T
+T{ MID-UINT 1+ -> MID-UINT+1 }T
+
+T{ 2 1- -> 1 }T
+T{ 1 1- -> 0 }T
+T{ 0 1- -> -1 }T
+T{ MID-UINT+1 1- -> MID-UINT }T
+
+T{ 0 NEGATE -> 0 }T
+T{ 1 NEGATE -> -1 }T
+T{ -1 NEGATE -> 1 }T
+T{ 2 NEGATE -> -2 }T
+T{ -2 NEGATE -> 2 }T
+
+T{ 0 ABS -> 0 }T
+T{ 1 ABS -> 1 }T
+T{ -1 ABS -> 1 }T
+T{ MIN-INT ABS -> MID-UINT+1 }T
+
 
 `;

tests/tests.js

@@ -2,7 +2,7 @@ import WAForth from "../src/shell/WAForth";
 import sieve from "../src/shell/sieve";
 import standardTestSuiteTester from "./standard-testsuite/tester.f";
 import standardCoreWordsTestSuite from "./standard-testsuite/core.f";
-import { expect } from "chai";
+import { expect, assert } from "chai";
 
 function loadTests(wasmModule, arrayToBase64) {
   describe("WAForth", () => {
@@ -80,6 +80,7 @@ function loadTests(wasmModule, arrayToBase64) {
 
     function run(ss, expectErrors = false) {
       ss.split("\n").forEach(s => {
+        // console.log("Running: ", s);
         const r = forth.run(s);
         if (expectErrors) {
           expect(r).to.be.undefined;
@@ -105,6 +106,10 @@ function loadTests(wasmModule, arrayToBase64) {
       return result;
     }
 
+    function tosValue() {
+      return memory[core.tos() / 4 - 1];
+    }
+
     describe("leb128", () => {
       it("should convert 0x0", () => {
         const r = core.leb128(0x0, 0x0);
@@ -1363,15 +1368,19 @@ function loadTests(wasmModule, arrayToBase64) {
       });
     });
 
-    describe.skip("standard test suite", () => {
+    describe("standard test suite", () => {
       beforeEach(() => {
         core.loadPrelude();
         run(standardTestSuiteTester);
+        run("TRUE VERBOSE !");
       });
 
       it("should run core word tests", () => {
         run(standardCoreWordsTestSuite);
-        console.log("Output: ", output);
+        run("#ERRORS @");
+        if (tosValue() !== 0) {
+          assert.fail(output);
+        }
       });
     });
   });