Miroirs/waforth
1
0
Fork 0
mirror of https://github.com/remko/waforth synced 2024-12-28 10:00:06 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
waforth/tests/tests.js

1250 lines
32 KiB
JavaScript
Raw Normal View History

Add command-line unit test runner
2019-03-10 10:37:01 +01:00
import WAForth from "../src/shell/WAForth";
import sieve from "../src/shell/sieve";
import { expect } from "chai";
function loadTests(wasmModule) {
describe("WAForth", () => {
let forth, stack, output, core, memory, memory8;
beforeEach(() => {
forth = new WAForth(wasmModule);
forth.onEmit = c => {
output = output + String.fromCharCode(c);
};
const x = forth.start({ skipPrelude: true }).then(
() => {
core = forth.core.exports;
output = "";
memory = new Int32Array(core.memory.buffer, 0, 0x30000);
memory8 = new Uint8Array(core.memory.buffer, 0, 0x30000);
// dictionary = new Uint8Array(core.memory.buffer, 0x1000, 0x1000);
stack = new Int32Array(core.memory.buffer, core.tos(), 0x100);
},
err => {
console.error(err);
}
);
return x;
});
// eslint-disable-next-line no-unused-vars
function dumpTable() {
for (let i = 0; i < core.table.length; ++i) {
console.log("table", i, core.table.get(i));
}
}
function getString(p, n) {
let name = [];
for (let i = 0; i < n; ++i) {
name.push(String.fromCharCode(memory8[p + i]));
}
return name.join("");
}
// function getCountedString(p) {
// return getString(p + 4, memory[p / 4]);
// }
function loadString(s) {
run("HERE");
run(`${s.length} ,`);
for (let i = 0; i < s.length; ++i) {
run(`${s.charCodeAt(i)} C,`);
}
}
// eslint-disable-next-line no-unused-vars
function dumpWord(w) {
let end = here();
let p = latest();
while (p != w) {
console.log("SEARCH", p, w);
end = p;
p = memory[p / 4];
}
const previous = memory[p / 4];
const length = memory8[p + 4];
const name = getString(p + 4 + 1, length);
const codeP = (p + 4 + 1 + length + 3) & ~3;
const code = memory[codeP / 4];
const data = [];
for (let i = codeP + 4; i < end; ++i) {
data.push(memory8[i]);
}
console.log("Entry:", p, previous, length, name, code, data, end);
}
function run(s) {
const r = forth.run(s);
expect(r).to.not.be.below(0);
output = output.substr(0, output.length - 3); // Strip 'ok\n' from output
return r;
}
function here() {
run("HERE");
const result = memory[core.tos() / 4 - 1];
run("DROP");
return result;
}
function latest() {
run("LATEST");
const result = memory[core.tos() / 4 - 1];
run("DROP");
return result;
}
describe("leb128", () => {
it("should convert 0x0", () => {
const r = core.leb128(0x0, 0x0);
expect(r).to.eql(0x1);
expect(memory8[0]).to.eql(0x0);
});
it("should convert 0x17", () => {
const r = core.leb128(0x0, 0x17);
expect(r).to.eql(0x1);
expect(memory8[0]).to.eql(0x17);
});
it("should convert 0x80", () => {
const r = core.leb128(0x0, 0x80);
expect(r).to.eql(0x2);
expect(memory8[0]).to.eql(0x80);
expect(memory8[1]).to.eql(0x01);
});
it("should convert 0x12345", () => {
const r = core.leb128(0x0, 0x12345);
expect(r).to.eql(0x3);
expect(memory8[0]).to.eql(0xc5);
expect(memory8[1]).to.eql(0xc6);
expect(memory8[2]).to.eql(0x04);
});
it("should convert -1", () => {
const r = core.leb128(0x0, -1);
expect(r).to.eql(0x1);
expect(memory8[0]).to.eql(0x7f);
});
it("should convert -0x12345", () => {
const r = core.leb128(0x0, -0x12345);
expect(r).to.eql(0x3);
expect(memory8[0]).to.eql(0xbb);
expect(memory8[1]).to.eql(0xb9);
expect(memory8[2]).to.eql(0x7b);
});
});
describe("leb128-4p", () => {
it("should convert 0x0", () => {
expect(core.leb128_4p(0x0)).to.eql(0x808080);
});
it("should convert 0x17", () => {
expect(core.leb128_4p(0x17)).to.eql(0x808097);
});
it("should convert 0x80", () => {
expect(core.leb128_4p(0x80)).to.eql(0x808180);
});
it("should convert 0xBADF00D", () => {
expect(core.leb128_4p(0xbadf00d)).to.eql(0x5db7e08d);
});
it("should convert 0xFFFFFFF", () => {
expect(core.leb128_4p(0xfffffff)).to.eql(0x7fffffff);
});
});
describe("interpret", () => {
it("should return an error when word is not found", () => {
forth.read("BADWORD");
expect(core.interpret()).to.eql(-1);
});
it("should interpret a positive number", () => {
forth.read("123");
expect(core.interpret()).to.eql(0);
expect(stack[0]).to.eql(123);
});
it("should interpret a negative number", () => {
forth.read("-123");
expect(core.interpret()).to.eql(0);
expect(stack[0]).to.eql(-123);
});
it("should interpret a hex", () => {
forth.read("16 BASE ! DF");
expect(core.interpret()).to.eql(0);
expect(stack[0]).to.eql(223);
});
it("should not interpret hex in decimal mode", () => {
forth.read("DF");
expect(core.interpret()).to.eql(-1);
});
it("should fail on half a word", () => {
forth.read("23FOO");
expect(core.interpret()).to.eql(-1);
});
});
describe("DUP", () => {
it("should work", () => {
run("121");
run("DUP");
expect(stack[0]).to.eql(121);
expect(stack[1]).to.eql(121);
});
});
describe("?DUP", () => {
it("should duplicate when not 0", () => {
run("121");
run("?DUP 5");
expect(stack[0]).to.eql(121);
expect(stack[1]).to.eql(121);
expect(stack[2]).to.eql(5);
});
it("should not duplicate when 0", () => {
run("0");
run("?DUP 5");
expect(stack[0]).to.eql(0);
expect(stack[1]).to.eql(5);
});
});
describe("2DUP", () => {
it("should work", () => {
run("222");
run("173");
run("2DUP");
run("5");
expect(stack[0]).to.eql(222);
expect(stack[1]).to.eql(173);
expect(stack[2]).to.eql(222);
expect(stack[3]).to.eql(173);
expect(stack[4]).to.eql(5);
});
});
describe("ROT", () => {
it("should work", () => {
run("1 2 3 ROT 5");
expect(stack[0]).to.eql(2);
expect(stack[1]).to.eql(3);
expect(stack[2]).to.eql(1);
expect(stack[3]).to.eql(5);
});
});
describe("*", () => {
it("should multiply", () => {
run("3");
run("4");
run("*");
run("5");
expect(stack[0]).to.eql(12);
expect(stack[1]).to.eql(5);
});
it("should multiply negative", () => {
run("-3");
run("4");
run("*");
run("5");
expect(stack[0]).to.eql(-12);
expect(stack[1]).to.eql(5);
});
});
describe("+", () => {
it("should add", () => {
run("3");
run("4");
run("+");
run("5");
expect(stack[0]).to.eql(7);
expect(stack[1]).to.eql(5);
});
});
describe("-", () => {
it("should subtract", () => {
run("8 5 - 5");
expect(stack[0]).to.eql(3);
expect(stack[1]).to.eql(5);
});
it("should subtract to negative", () => {
run("8 13 - 5");
expect(stack[0]).to.eql(-5);
expect(stack[1]).to.eql(5);
});
it("should subtract negative", () => {
run("8 -3 - 5");
expect(stack[0]).to.eql(11);
expect(stack[1]).to.eql(5);
});
});
describe("/", () => {
it("should divide", () => {
run("15 5 / 5");
expect(stack[0]).to.eql(3);
expect(stack[1]).to.eql(5);
});
it("should divide negative", () => {
run("15 -5 / 5");
expect(stack[0]).to.eql(-3);
expect(stack[1]).to.eql(5);
});
});
describe("/MOD", () => {
it("should work", () => {
run("15 6 /MOD 5");
expect(stack[0]).to.eql(3);
expect(stack[1]).to.eql(2);
expect(stack[2]).to.eql(5);
});
});
describe("*/", () => {
it("should work with small numbers", () => {
run("10 3 5 */ 5");
expect(stack[0]).to.eql(6);
expect(stack[1]).to.eql(5);
});
it("should work with large numbers", () => {
run("268435455 1000 5000 */");
expect(stack[0]).to.eql(53687091);
});
});
describe("*/MOD", () => {
it("should work with small numbers", () => {
run("9 3 5 */MOD 7");
expect(stack[0]).to.eql(2);
expect(stack[1]).to.eql(5);
expect(stack[2]).to.eql(7);
});
it("should work with large numbers", () => {
run("268435455 1000 3333 */MOD");
expect(stack[0]).to.eql(1230);
expect(stack[1]).to.eql(80538690);
});
});
describe("1+", () => {
it("should work with positive numbers", () => {
run("3");
run("1+");
run("5");
expect(stack[0]).to.eql(4);
expect(stack[1]).to.eql(5);
});
it("should work with negative numbers", () => {
run("-3");
run("1+");
run("5");
expect(stack[0]).to.eql(-2);
expect(stack[1]).to.eql(5);
});
});
describe("1-", () => {
it("should work with positive numbers", () => {
run("3");
run("1-");
run("5");
expect(stack[0]).to.eql(2);
expect(stack[1]).to.eql(5);
});
it("should work with negative numbers", () => {
run("-3");
run("1-");
run("5");
expect(stack[0]).to.eql(-4);
expect(stack[1]).to.eql(5);
});
});
describe(">", () => {
it("should test true when greater", () => {
run("5");
run("3");
run(">");
run("5");
expect(stack[0]).to.eql(-1);
expect(stack[1]).to.eql(5);
});
it("should test false when smaller", () => {
run("3");
run("5");
run(">");
run("5");
expect(stack[0]).to.eql(0);
expect(stack[1]).to.eql(5);
});
it("should test false when equal", () => {
run("5");
run("5");
run(">");
run("5");
expect(stack[0]).to.eql(0);
expect(stack[1]).to.eql(5);
});
it("should work with negative numbers", () => {
run("5");
run("-3");
run(">");
run("5");
expect(stack[0]).to.eql(-1);
expect(stack[1]).to.eql(5);
});
});
describe("NEGATE", () => {
it("should negate positive number", () => {
run("7 NEGATE 5");
expect(stack[0]).to.eql(-7);
expect(stack[1]).to.eql(5);
});
it("should negate negative number", () => {
run("-7 NEGATE 5");
expect(stack[0]).to.eql(7);
expect(stack[1]).to.eql(5);
});
it("should negate negative zero", () => {
run("0 NEGATE 5");
expect(stack[0]).to.eql(0);
expect(stack[1]).to.eql(5);
});
});
describe("0=", () => {
it("should test true", () => {
run("0");
run("0=");
run("5");
expect(stack[0]).to.eql(-1);
expect(stack[1]).to.eql(5);
});
it("should test false", () => {
run("23");
run("0=");
run("5");
expect(stack[0]).to.eql(0);
expect(stack[1]).to.eql(5);
});
});
describe("0>", () => {
it("should test true", () => {
run("2");
run("0>");
run("5");
expect(stack[0]).to.eql(-1);
expect(stack[1]).to.eql(5);
});
it("should test false", () => {
run("-3");
run("0>");
run("5");
expect(stack[0]).to.eql(0);
expect(stack[1]).to.eql(5);
});
});
describe("OVER", () => {
it("should work", () => {
run("12");
run("34");
run("OVER");
run("5");
expect(stack[0]).to.eql(12);
expect(stack[1]).to.eql(34);
expect(stack[2]).to.eql(12);
expect(stack[3]).to.eql(5);
});
});
describe("SWAP", () => {
it("should work", () => {
run("12");
run("34");
run("SWAP");
run("5");
expect(stack[0]).to.eql(34);
expect(stack[1]).to.eql(12);
expect(stack[2]).to.eql(5);
});
});
describe("EMIT", () => {
it("should work once", () => {
run("87");
run("EMIT");
expect(output).to.eql("W");
});
it("should work twice", () => {
run("97");
run("87");
run("EMIT");
run("EMIT");
expect(output).to.eql("Wa");
});
});
describe("DROP", () => {
it("should drop", () => {
run("222");
run("173");
run("DROP");
run("190");
expect(stack[0]).to.eql(222);
expect(stack[1]).to.eql(190);
});
});
describe("ERASE", () => {
it("should erase", () => {
const ptr = here();
memory8[ptr] = 222;
memory8[ptr + 1] = 173;
memory8[ptr + 2] = 190;
memory8[ptr + 3] = 239;
run((ptr + 1).toString(10));
run("2 ERASE 5");
expect(memory8[ptr + 0]).to.eql(222);
expect(memory8[ptr + 1]).to.eql(0x00);
expect(memory8[ptr + 2]).to.eql(0x00);
expect(memory8[ptr + 3]).to.eql(239);
expect(stack[0]).to.eql(5);
});
});
describe("IF/ELSE/THEN", () => {
it("should take the then branch without else", () => {
run(`: FOO IF 8 THEN ;`);
run("1 FOO 5");
expect(stack[0]).to.eql(8);
expect(stack[1]).to.eql(5);
});
it("should not take the then branch without else", () => {
run(": FOO");
run("IF");
run("8");
run("THEN");
run("0");
run(";");
run("FOO");
run("5");
expect(stack[0]).to.eql(5);
});
it("should take the then branch with else", () => {
run(": FOO");
run("IF");
run("8");
run("ELSE");
run("9");
run("THEN");
run(";");
run("1");
run("FOO");
run("5");
expect(stack[0]).to.eql(8);
expect(stack[1]).to.eql(5);
});
it("should take the else branch with else", () => {
run(": FOO");
run("IF");
run("8");
run("ELSE");
run("9");
run("THEN");
run(";");
run("0");
run("FOO");
run("5");
expect(stack[0]).to.eql(9);
expect(stack[1]).to.eql(5);
});
it("should support nested if", () => {
run(`: FOO
IF
IF 8 ELSE 9 THEN
10
ELSE
11
THEN
;`);
run("0 1 FOO 5");
expect(stack[0]).to.eql(9);
expect(stack[1]).to.eql(10);
expect(stack[2]).to.eql(5);
});
});
describe("DO/LOOP", () => {
it("should run a loop", () => {
run(`: FOO 4 0 DO 3 LOOP ;`);
run("FOO 5");
expect(stack[0]).to.eql(3);
expect(stack[1]).to.eql(3);
expect(stack[2]).to.eql(3);
expect(stack[3]).to.eql(3);
expect(stack[4]).to.eql(5);
});
it("should run a nested loop", () => {
run(`: FOO 3 0 DO 2 0 DO 3 LOOP LOOP ;`);
run("FOO 5");
expect(stack[0]).to.eql(3);
expect(stack[1]).to.eql(3);
expect(stack[2]).to.eql(3);
expect(stack[3]).to.eql(3);
expect(stack[4]).to.eql(3);
expect(stack[5]).to.eql(3);
expect(stack[6]).to.eql(5);
});
});
describe("LEAVE", () => {
it("should leave", () => {
run(`: FOO 4 0 DO 3 LEAVE 6 LOOP 4 ;`);
run("FOO 5");
expect(stack[0]).to.eql(3);
expect(stack[1]).to.eql(4);
expect(stack[2]).to.eql(5);
});
});
describe("+LOOP", () => {
it("should increment a loop", () => {
run(`: FOO 10 0 DO 3 2 +LOOP ;`);
run("FOO 5");
expect(stack[0]).to.eql(3);
expect(stack[1]).to.eql(3);
expect(stack[2]).to.eql(3);
expect(stack[3]).to.eql(3);
expect(stack[4]).to.eql(3);
expect(stack[5]).to.eql(5);
});
it("should increment a loop beyond the index", () => {
run(`: FOO 10 0 DO 3 8 +LOOP ;`);
run("FOO 5");
expect(stack[0]).to.eql(3);
expect(stack[1]).to.eql(3);
expect(stack[2]).to.eql(5);
});
});
describe("I", () => {
it("should work", () => {
run(`: FOO 4 0 DO I LOOP ;`);
run("FOO 5");
expect(stack[0]).to.eql(0);
expect(stack[1]).to.eql(1);
expect(stack[2]).to.eql(2);
expect(stack[3]).to.eql(3);
expect(stack[4]).to.eql(5);
});
it("should work in a nested loop", () => {
run(`: FOO 3 0 DO 2 0 DO I LOOP LOOP ;`);
run("FOO 5");
expect(stack[0]).to.eql(0);
expect(stack[1]).to.eql(1);
expect(stack[2]).to.eql(0);
expect(stack[3]).to.eql(1);
expect(stack[4]).to.eql(0);
expect(stack[5]).to.eql(1);
expect(stack[6]).to.eql(5);
});
});
describe("J", () => {
it("should work", () => {
run(`: FOO 3 0 DO 2 0 DO J LOOP LOOP ;`);
run("FOO 5");
expect(stack[0]).to.eql(0);
expect(stack[1]).to.eql(0);
expect(stack[2]).to.eql(1);
expect(stack[3]).to.eql(1);
expect(stack[4]).to.eql(2);
expect(stack[5]).to.eql(2);
expect(stack[6]).to.eql(5);
});
it("should work in a nested loop", () => {
run(`: FOO 3 0 DO 2 0 DO J LOOP LOOP ;`);
run("FOO 5");
expect(stack[0]).to.eql(0);
expect(stack[1]).to.eql(0);
expect(stack[2]).to.eql(1);
expect(stack[3]).to.eql(1);
expect(stack[4]).to.eql(2);
expect(stack[5]).to.eql(2);
expect(stack[6]).to.eql(5);
});
});
describe("BEGIN / WHILE / REPEAT", () => {
it("should work", () => {
run(`: FOO BEGIN DUP 2 * DUP 16 < WHILE DUP REPEAT 7 ;`);
run("1 FOO 5");
expect(stack[0]).to.eql(1);
expect(stack[1]).to.eql(2);
expect(stack[2]).to.eql(2);
expect(stack[3]).to.eql(4);
expect(stack[4]).to.eql(4);
expect(stack[5]).to.eql(8);
expect(stack[6]).to.eql(8);
expect(stack[7]).to.eql(16);
expect(stack[8]).to.eql(7);
expect(stack[9]).to.eql(5);
});
});
describe("BEGIN / UNTIL", () => {
it("should work", () => {
run(`: FOO BEGIN DUP 2 * DUP 16 > UNTIL 7 ;`);
run("1 FOO 5");
expect(stack[0]).to.eql(1);
expect(stack[1]).to.eql(2);
expect(stack[2]).to.eql(4);
expect(stack[3]).to.eql(8);
expect(stack[4]).to.eql(16);
expect(stack[5]).to.eql(32);
expect(stack[6]).to.eql(7);
expect(stack[7]).to.eql(5);
});
});
describe("EXIT", () => {
it("should work", () => {
run(`: FOO IF 3 EXIT 4 THEN 5 ;`);
run("1 FOO 6");
expect(stack[0]).to.eql(3);
expect(stack[1]).to.eql(6);
});
});
describe("( / )", () => {
beforeEach(() => {
core.loadPrelude();
});
it("should work", () => {
run(": FOO ( bad -- x ) 7 ;");
run("1 FOO 5");
expect(stack[0]).to.eql(1);
expect(stack[1]).to.eql(7);
expect(stack[2]).to.eql(5);
});
});
describe("CHAR", () => {
it("should work with a single character", () => {
run("CHAR A 5");
expect(stack[0]).to.eql(65);
expect(stack[1]).to.eql(5);
});
it("should work with multiple characters", () => {
run("CHAR ABC 5");
expect(stack[0]).to.eql(65);
expect(stack[1]).to.eql(5);
});
});
// describe("word", () => {
// it("should read a word", () => {
// forth.read(" FOO BAR BAZ ");
// core.WORD();
// expect(getCountedString(stack[0])).to.eql("FOO");
// });
//
// it("should read two words", () => {
// forth.read(" FOO BAR BAZ ");
// core.WORD();
// core.WORD();
// expect(getCountedString(stack[1])).to.eql("BAR");
// });
//
// it("should skip comments", () => {
// forth.read(" \\ FOO BAZ\n BART BAZ");
// core.WORD();
// expect(getCountedString(stack[0])).to.eql("BART");
// });
//
// it("should stop at end of buffer while parsing word", () => {
// forth.read("FOO");
// core.WORD();
// expect(getCountedString(stack[0])).to.eql("FOO");
// });
//
// it("should stop at end of buffer while parsing comments", () => {
// forth.read(" \\FOO");
// core.WORD();
// expect(getCountedString()).to.eql("");
// });
//
// it("should stop when parsing empty line", () => {
// forth.read(" ");
// core.WORD();
// expect(getCountedString()).to.eql("");
// });
//
// it("should stop when parsing nothing", () => {
// forth.read("");
// core.WORD();
// expect(getCountedString()).to.eql("");
// });
// });
describe("FIND", () => {
it("should find a word", () => {
loadString("DUP");
run("FIND");
expect(stack[0]).to.eql(131768);
expect(stack[1]).to.eql(-1);
});
it("should find a short word", () => {
loadString("!");
run("FIND");
expect(stack[0]).to.eql(131072);
expect(stack[1]).to.eql(-1);
});
it("should find an immediate word", () => {
loadString("+LOOP");
run("FIND");
expect(stack[0]).to.eql(131160);
expect(stack[1]).to.eql(1);
});
it("should not find an unexisting word", () => {
loadString("BADWORD");
run("FIND");
expect(stack[1]).to.eql(0);
});
it("should not find a very long unexisting word", () => {
loadString("VERYVERYVERYBADWORD");
run("FIND");
expect(stack[1]).to.eql(0);
});
});
describe("BASE", () => {
it("should contain the base", () => {
run("BASE @ 5");
expect(stack[0]).to.eql(10);
expect(stack[1]).to.eql(5);
});
});
describe("KEY", () => {
it("should read a key", () => {
run("KEY F");
run("5");
expect(stack[0]).to.eql(70);
expect(stack[1]).to.eql(5);
});
});
describe("LITERAL", () => {
it("should put a literal on the stack", () => {
run("20 : FOO LITERAL ;");
run("5 FOO");
expect(stack[0]).to.eql(5);
expect(stack[1]).to.eql(20);
});
});
describe("[ ]", () => {
it("should work", () => {
run(": FOO [ 20 5 * ] LITERAL ;");
run("5 FOO 6");
expect(stack[0]).to.eql(5);
expect(stack[1]).to.eql(100);
expect(stack[2]).to.eql(6);
});
});
describe("C@", () => {
it("should fetch an aligned character", () => {
const ptr = here();
memory8[ptr] = 222;
memory8[ptr + 1] = 173;
run(ptr.toString());
run("C@");
expect(stack[0]).to.eql(222);
});
it("should fetch an unaligned character", () => {
const ptr = here();
memory8[ptr] = 222;
memory8[ptr + 1] = 173;
run((ptr + 1).toString());
run("C@");
expect(stack[0]).to.eql(173);
});
});
describe("C!", () => {
it("should store an aligned character", () => {
const ptr = here();
memory8[ptr] = 222;
memory8[ptr + 1] = 173;
run("190");
run(ptr.toString());
run("C! 5");
expect(stack[0]).to.eql(5);
expect(memory8[ptr]).to.eql(190);
expect(memory8[ptr + 1]).to.eql(173);
});
it("should store an unaligned character", () => {
const ptr = here();
memory8[ptr] = 222;
memory8[ptr + 1] = 173;
run("190");
run((ptr + 1).toString());
run("C! 5");
expect(stack[0]).to.eql(5);
expect(memory8[ptr]).to.eql(222);
expect(memory8[ptr + 1]).to.eql(190);
});
});
describe("@", () => {
it("should fetch", () => {
const ptr = here();
memory[ptr / 4] = 123456;
run(ptr.toString());
run("@ 5");
expect(stack[0]).to.eql(123456);
expect(stack[1]).to.eql(5);
});
});
describe("!", () => {
it("should store", () => {
const ptr = here();
run("12345");
run(ptr.toString());
run("! 5");
expect(stack[0]).to.eql(5);
expect(memory[ptr / 4]).to.eql(12345);
});
});
describe(",", () => {
it("should add word", () => {
run("HERE");
run("1234");
run(",");
run("HERE");
expect(stack[1] - stack[0]).to.eql(4);
expect(memory[stack[0] / 4]).to.eql(1234);
});
});
describe('S"', () => {
it("should work", () => {
run(': FOO S" Foo Bar" ;');
run("FOO");
expect(stack[1]).to.eql(7);
expect(getString(stack[0], stack[1])).to.eql("Foo Bar");
});
it("should work with 2 strings", () => {
run(': FOO S" Foo Bar" ;');
run(': BAR S" Baz Ba" ;');
run("FOO BAR 5");
expect(stack[1]).to.eql(7);
expect(getString(stack[0], stack[1])).to.eql("Foo Bar");
expect(stack[3]).to.eql(6);
expect(getString(stack[2], stack[3])).to.eql("Baz Ba");
});
});
describe('."', () => {
it("should work", () => {
run(': FOO ." Foo Bar" ;');
run("FOO 5");
expect(stack[0]).to.eql(5);
expect(output).to.eql("Foo Bar");
});
});
describe("MOVE", () => {
it("should work with non-overlapping regions", () => {
const ptr = here();
memory8[ptr] = 1;
memory8[ptr + 1] = 2;
memory8[ptr + 2] = 3;
memory8[ptr + 3] = 4;
memory8[ptr + 4] = 5;
run("HERE HERE 10 + 4 MOVE 5");
expect(stack[0]).to.eql(5);
expect(memory8[ptr + 10]).to.eql(1);
expect(memory8[ptr + 11]).to.eql(2);
expect(memory8[ptr + 12]).to.eql(3);
expect(memory8[ptr + 13]).to.eql(4);
expect(memory8[ptr + 14]).to.eql(0);
});
it("should work with begin-overlapping regions", () => {
const ptr = here();
memory8[ptr] = 1;
memory8[ptr + 1] = 2;
memory8[ptr + 2] = 3;
memory8[ptr + 3] = 4;
memory8[ptr + 4] = 5;
run("HERE HERE 2 + 4 MOVE 5");
expect(stack[0]).to.eql(5);
expect(memory8[ptr + 0]).to.eql(1);
expect(memory8[ptr + 1]).to.eql(2);
expect(memory8[ptr + 2]).to.eql(1);
expect(memory8[ptr + 3]).to.eql(2);
expect(memory8[ptr + 4]).to.eql(3);
expect(memory8[ptr + 5]).to.eql(4);
expect(memory8[ptr + 6]).to.eql(0);
});
it("should work with end-overlapping regions", () => {
const ptr = here();
memory8[ptr + 10] = 1;
memory8[ptr + 11] = 2;
memory8[ptr + 12] = 3;
memory8[ptr + 13] = 4;
memory8[ptr + 14] = 5;
run("HERE 10 + DUP 2 - 4 MOVE 5");
expect(stack[0]).to.eql(5);
expect(memory8[ptr + 8]).to.eql(1);
expect(memory8[ptr + 9]).to.eql(2);
expect(memory8[ptr + 10]).to.eql(3);
expect(memory8[ptr + 11]).to.eql(4);
expect(memory8[ptr + 12]).to.eql(3);
expect(memory8[ptr + 13]).to.eql(4);
expect(memory8[ptr + 14]).to.eql(5);
});
});
describe("RECURSE", () => {
it("should recurse", () => {
run(": FOO DUP 4 < IF DUP 1+ RECURSE ELSE 12 THEN 13 ;");
run("1 FOO 5");
expect(stack[0]).to.eql(1);
expect(stack[1]).to.eql(2);
expect(stack[2]).to.eql(3);
expect(stack[3]).to.eql(4);
expect(stack[4]).to.eql(12);
expect(stack[5]).to.eql(13);
expect(stack[6]).to.eql(13);
expect(stack[7]).to.eql(13);
expect(stack[8]).to.eql(13);
expect(stack[9]).to.eql(5);
});
});
describe("CREATE", () => {
it("should create words", () => {
run("HERE");
run("LATEST");
run("CREATE DUP");
run("HERE");
run("LATEST");
expect(stack[2] - stack[0]).to.eql(4 + 4 + 4);
expect(stack[3]).to.eql(stack[0]);
expect(stack[3]).to.not.eql(stack[1]);
});
it("should create findable words", () => {
run("CREATE FOOBAR");
run("LATEST");
run("CREATE BAM");
loadString("FOOBAR");
run("FIND");
expect(stack[1]).to.eql(stack[0]);
expect(stack[2]).to.eql(-1);
});
it("should align unaligned words", () => {
run("CREATE DUPE");
run("HERE");
expect(stack[0] % 4).to.eql(0);
});
it("should align aligned words", () => {
run("CREATE DUP");
run("HERE");
expect(stack[0] % 4).to.eql(0);
});
});
describe("IMMEDIATE", () => {
it("should make words immediate", () => {
run("CREATE FOOBAR IMMEDIATE");
loadString("FOOBAR");
run("FIND");
expect(stack[1]).to.eql(1);
});
});
describe(":", () => {
it("should compile multiple instructions", () => {
run(": FOOBAR 4 * ;");
run("3 FOOBAR");
expect(stack[0]).to.eql(12);
});
it("should compile negative numbers", () => {
run(": FOOBAR -4 * ;");
run("3 FOOBAR");
expect(stack[0]).to.eql(-12);
});
it("should compile large numbers", () => {
run(": FOOBAR 111111 * ;");
run("3 FOOBAR");
expect(stack[0]).to.eql(333333);
});
it("should skip comments", () => {
run(": FOOBAR\n\n \\ Test string \n 4 * ;");
run("3 FOOBAR 5");
expect(stack[0]).to.eql(12);
expect(stack[1]).to.eql(5);
});
it("should override", () => {
run(": FOOBAR 3 ;");
run(": FOOBAR FOOBAR 4 ;");
run("FOOBAR 5");
expect(stack[0]).to.eql(3);
expect(stack[1]).to.eql(4);
expect(stack[2]).to.eql(5);
});
it("should compile a name with an illegal WASM character", () => {
run(': F" 3 0 DO 2 LOOP ;');
});
});
describe("VARIABLE", () => {
it("should work with one variable", () => {
run("VARIABLE FOO");
run("12 FOO !");
run("FOO @ 5");
expect(stack[0]).to.eql(12);
expect(stack[1]).to.eql(5);
});
it("should work with two variables", () => {
run("VARIABLE FOO VARIABLE BAR");
run("12 FOO ! 13 BAR !");
run("FOO @ BAR @ 5");
expect(stack[0]).to.eql(12);
expect(stack[1]).to.eql(13);
expect(stack[2]).to.eql(5);
});
});
describe("CONSTANT", () => {
it("should work", () => {
run("12 CONSTANT FOO");
run("FOO 5");
expect(stack[0]).to.eql(12);
expect(stack[1]).to.eql(5);
});
});
describe("VALUE", () => {
it("should store a value", () => {
run("12 VALUE FOO");
run("FOO 5");
expect(stack[0]).to.eql(12);
expect(stack[1]).to.eql(5);
});
it("should update a value", () => {
run("12 VALUE FOO");
run("13 TO FOO");
run("FOO 5");
expect(stack[0]).to.eql(13);
expect(stack[1]).to.eql(5);
});
});
// describe.only("DOES>", () => {
// it("should work", () => {
// run(": ID CREATE 1 , DOES> @");
// });
// });
describe("UWIDTH", () => {
beforeEach(() => {
core.loadPrelude();
});
it("should work with 3 digits", () => {
run("123 UWIDTH");
expect(stack[0]).to.eql(3);
});
it("should work with 4 digits", () => {
run("1234 UWIDTH");
expect(stack[0]).to.eql(4);
});
});
describe("system", () => {
beforeEach(() => {
core.loadPrelude();
});
it("should run sieve", () => {
run(sieve);
run("100 sieve");
expect(output.trim()).to.eql("97");
});
it("should run direct sieve", () => {
run(sieve);
run("100 sieve_direct");
expect(stack[0]).to.eql(97);
});
});
});
}
export default loadTests;
Reference in a new issue Copy permalink