forth-stuff/tests.lua

415 lines
16 KiB
Lua

local istream = require("InputStream")
local ds = require("DataStructures")
local Stack, Dictionary, WordInfo, Environment = ds.Stack, ds.Dictionary, ds.WordInfo, ds.Environment
local CoreHelpers = require("CoreHelpers")
local CoreWords = require("CoreWords")
local interpreters = require("Interpreters")
local TEST_REPEAT_COUNT = 200
local NUM_RANGE = 100000000000000
local STACK_RANGE = 100
function pushThree(s)
s:push(1)
s:push(2)
s:push(3)
end
math.randomseed( os.time())
describe("Stack Tests", function()
local stack = Stack:new()
it("fails on stack underflow", function()
stack = Stack:new()
assert.has.errors(function()
stack:pop()
end)
end)
it("pushes three items properly", function()
stack = Stack:new()
pushThree(stack)
assert.are.same(stack.contents, {1,2,3})
end)
it("pops three items properly", function()
stack = Stack:new()
pushThree(stack)
assert.are.same(stack.contents, {1,2,3})
assert(3 == stack:pop())
assert.are.same(stack.contents, {1,2})
assert(2 == stack:pop())
assert.are.same(stack.contents, {1})
assert(1 == stack:pop())
assert.are.same(stack.contents, {})
assert.has.errors(function()
stack:pop()
end)
end)
it("PUSH 1, 2, 3, POP = 3, PUSH 4 = {1,2,4}", function()
stack = Stack:new()
pushThree(stack)
assert(3 == stack:pop())
assert.are.same(stack.contents, {1, 2})
stack:push(4)
assert.are.same(stack.contents, {1, 2, 4})
end)
end)
local function dummyInput()
return "1234567890"
end
describe("InputStream tests", function()
local input = istream:new(dummyInput)
it("gets a new refill accurately", function()
input = istream:new(dummyInput)
assert.are.equal(input.refill, dummyInput)
end)
it("reads text properly", function()
input = istream:new(dummyInput)
local inputString = dummyInput()
for i = 0, 100 do
local j = i % #inputString + 1
assert.are.same(inputString:sub(j, j), input:next())
end
end)
describe("Tests with ends of input", function()
it("handles a single line", function()
local inputstr = "TEST TEST TEST"
input = CoreHelpers.oneReadInputStream(inputstr)
for i = 1, #inputstr do
assert.are.same(inputstr:sub(i, i), input:next())
end
for i = 1, TEST_REPEAT_COUNT do
assert.are.same(nil, input:next())
end
end)
it("handles multiple lines", function()
local inputstr = "TEST\nTEST\nTEST\nTEST\nTEST\nTEST51515151"
input = CoreHelpers.oneReadInputStream(inputstr)
input:curr()
for i = 1, #inputstr do
assert.are.same(inputstr:sub(i, i), input:next())
end
for i = 1, TEST_REPEAT_COUNT do
assert.are.same(nil, input:next())
end
end)
it("can do files", function()
local fname = "./filetest.txt"
input = CoreHelpers.fileStream(fname)
local expected_output = io.open(fname, "r"):read("*all")
for i = 1, #expected_output do
assert.are.same(expected_output:sub(i,i), input:next())
end
for i = 1, TEST_REPEAT_COUNT do
assert.are.same(nil, input:next())
end
end)
end)
end)
describe("WordInfo tests", function()
local Environment = ds.Environment
local WordInfo = ds.WordInfo
it("creates and doesn't crash", function()
local env = Environment:new()
wi = WordInfo:new(function(env) end, false)
end)
end)
describe("Dictionary tests", function()
local Dictionary = ds.Dictionary
local WordInfo = ds.WordInfo
local Environment = ds.Environment
it("defines without breaking",function()
local env = Environment:new()
local dict = Dictionary:new()
local wi = WordInfo:new(function(env) end, false)
dict:define("TEST",wi)
end)
it("can get WordInfo back after it being defined", function()
local env = Environment:new()
local dict = Dictionary:new()
local wi = WordInfo:new(function(env) end, false)
dict:define("TEST",wi)
assert.are.same(dict:lookup("TEST"),wi)
end)
end)
function buildEnvironment(testString)
local testEnv = Environment:new(CoreHelpers.oneReadInputStream(testString), {CoreWords})
return testEnv
end
local twoRandom = function() return math.random(-NUM_RANGE, NUM_RANGE), math.random(-NUM_RANGE, NUM_RANGE) end
local function randomDataStackEnv(lowerRange, upperRange)
local stackDepth = math.random(lowerRange, upperRange)
local stackTop = 0
local testEnv = Environment:new(nil, {CoreWords})
for j = 1, stackDepth do
stackTop = math.random(-NUM_RANGE,NUM_RANGE)
testEnv.activeDataStack:push(stackTop)
end
return testEnv, stackDepth
end
describe("Interpreter tests", function()
describe("Arithmetic tests", function()
it("can add two numbers, and leave the sum on the stack", function()
for i=1, TEST_REPEAT_COUNT do
local a, b = twoRandom()
local expected_sum = a + b
local testString = a.." "..b.." +"
local testEnv = buildEnvironment(testString)
interpreters.start(testEnv)
assert.are.same(testEnv.activeDataStack.contents[1], expected_sum)
end
end)
it("can subtract two numbers, and leave the difference on the stack", function()
for i=1, TEST_REPEAT_COUNT do
local a, b = twoRandom()
local expected_diff = a -b
local testString = a.." "..b.." -"
local testEnv = buildEnvironment(testString)
interpreters.start(testEnv)
assert.are.same(testEnv.activeDataStack.contents[1], expected_diff)
end
end)
it("can multiply two numbers, leaving product on the stack", function()
for i = 1, TEST_REPEAT_COUNT do
local a, b = twoRandom()
local expected_prod = a*b
local testString = a.." "..b.." *"
local testEnv = buildEnvironment(testString)
interpreters.start(testEnv)
assert.are.same(testEnv.activeDataStack.contents[1], expected_prod)
end
end)
it("can divide two numbers, leaving the quotient on the stack", function()
for i = 1, TEST_REPEAT_COUNT do
local a, b = twoRandom()
local expected_quo = a/b
local testString = a.." "..b.." /"
local testEnv = buildEnvironment(testString)
interpreters.start(testEnv)
assert.are.same(testEnv.activeDataStack.contents[1], expected_quo)
end
end)
it("can evaluate a arithmetic expression with multiple operations", function()
for i = 1, TEST_REPEAT_COUNT do
operands = {math.random(-NUM_RANGE,NUM_RANGE), math.random(-NUM_RANGE,NUM_RANGE), math.random(-NUM_RANGE,NUM_RANGE), math.random(-NUM_RANGE,NUM_RANGE)}
local operations = {math.random(4), math.random(4), math.random(4)}
local testString = ""..operands[1]
local expectedResult = operands[1]
for j, op in ipairs(operations) do
if op == 1 then
testString = testString.." "..operands[j + 1].." +"
expectedResult = expectedResult + operands[j+1]
elseif op == 2 then
testString = testString.." "..operands[j + 1].." -"
expectedResult = expectedResult - operands[j+1]
elseif op == 3 then
testString = testString.." "..operands[j + 1].." *"
expectedResult = expectedResult * operands[j+1]
else
testString = testString.." "..operands[j + 1].." /"
expectedResult = expectedResult / operands[j+1]
end
end
local testEnv = buildEnvironment(testString)
interpreters.start(testEnv)
assert.are.same(expectedResult,testEnv.activeDataStack.contents[1])
end
end)
end)
describe("Core word tests", function()
describe("DUP tests", function()
it("DUPs the top item of a stack with one item on it.", function()
local testEnv = buildEnvironment("1 DUP")
interpreters.start(testEnv)
assert.are.same(1, testEnv.activeDataStack.contents[2])
end)
it("DUPs the top item of a stack with random quantities of random numbers on it.", function()
for i = 1, TEST_REPEAT_COUNT do
local stackDepth = math.random(STACK_RANGE)
local stackTop = 0
local testEnv = buildEnvironment("DUP")
for j = 1, stackDepth do
stackTop = math.random(-NUM_RANGE,NUM_RANGE)
testEnv.activeDataStack:push(stackTop)
end
interpreters.start(testEnv)
assert.are.same(stackTop, testEnv.activeDataStack.contents[stackDepth+1])
end
end)
end)
describe("SWAP tests", function()
it("SWAPS the top two items of a stack with two items on it.", function()
local testEnv = buildEnvironment("1 2 SWAP")
interpreters.start(testEnv)
assert.are.same(2, testEnv.activeDataStack.contents[1])
assert.are.same(1, testEnv.activeDataStack.contents[2])
end)
it("SWAPS the top two items of a stack with random quantities of random numbers on it.", function()
for i = 1, TEST_REPEAT_COUNT do
local testEnv, stackDepth = randomDataStackEnv(2, STACK_RANGE)
testEnv.activeInputStream = CoreHelpers.oneReadInputStream("SWAP")
local a = testEnv.activeDataStack.contents[stackDepth]
local b = testEnv.activeDataStack.contents[stackDepth-1]
interpreters.start(testEnv)
assert.are.equal(testEnv.activeDataStack.contents[stackDepth-1], a)
assert.are.equal(testEnv.activeDataStack.contents[stackDepth], b)
end
end)
end)
describe("ROT tests", function()
it("ROTs the top three items of a stack with three items on it.", function()
local testEnv = buildEnvironment("1 2 3 ROT")
interpreters.start(testEnv)
assert.are.same({2, 3, 1}, testEnv.activeDataStack.contents)
end)
end)
describe("DROP tests", function()
it("Drops the top item of the stack, when stack size is 1.", function()
local testEnv = buildEnvironment("1 DROP")
interpreters.start(testEnv)
assert.are.same(nil, testEnv.activeDataStack.contents[1])
end)
-- TODO: add better tests
end)
describe("OVER tests", function()
it("Places a copy of the item below the top of the stack onto the top, when stack size is 2.", function()
local testEnv = buildEnvironment("1 2 OVER")
interpreters.start(testEnv)
assert.are.same({1, 2, 1}, testEnv.activeDataStack.contents)
end)
end)
-- TODO: test output of DOT.
describe("DOT tests", function()
it("Drops the top item of the stack.", function()
local testEnv = buildEnvironment("1 .")
interpreters.start(testEnv)
assert.are.same({}, testEnv.activeDataStack.contents)
end)
end)
describe("2DUP tests", function()
it("Duplicates the top two items on the stack.", function()
local testEnv = buildEnvironment("1 2 2DUP")
interpreters.start(testEnv)
assert.are.same({1, 2, 1, 2}, testEnv.activeDataStack.contents)
end)
end)
describe("2SWAP tests", function()
it("Exchanges the top two cell pairs.", function()
local testEnv = buildEnvironment("1 2 3 4 2SWAP")
interpreters.start(testEnv)
assert.are.same({3, 4, 1, 2}, testEnv.activeDataStack.contents)
end)
end)
describe("2OVER tests", function()
it("copies the two items below the top two items onto the top of the stack.", function()
local testEnv = buildEnvironment("1 2 3 4 2OVER")
interpreters.start(testEnv)
assert.are.same({1, 2, 3, 4, 1, 2}, testEnv.activeDataStack.contents)
end)
end)
describe("NIP tests", function()
it("drops the first item below the top of stack, when stack size == 2", function()
local testEnv = buildEnvironment("1 2 NIP")
interpreters.start(testEnv)
assert.are.same({2}, testEnv.activeDataStack.contents)
end)
end)
describe("TUCK tests", function()
it("Copies the top below the item just below the top, in a stack of size 2.", function()
local testEnv = buildEnvironment("1 2 TUCK")
interpreters.start(testEnv)
assert.are.same({2, 1, 2}, testEnv.activeDataStack.contents)
end)
end)
describe("ROLL tests", function()
it("is NOOP when u = 0", function()
local testEnv = buildEnvironment("1 2 4 1 1 0 ROLL")
interpreters.start(testEnv)
assert.are.same({1, 2, 4, 1, 1}, testEnv.activeDataStack.contents)
end)
it("is SWAP when u = 1", function()
local testEnv = buildEnvironment("1 2 3 4 5 1 ROLL")
interpreters.start(testEnv)
assert.are.same({1, 2, 3, 5, 4}, testEnv.activeDataStack.contents)
end)
it("is ROT when u = 2", function()
local testEnv = buildEnvironment("1 2 3 4 5 2 ROLL")
interpreters.start(testEnv)
assert.are.same({1, 2, 4, 5, 3}, testEnv.activeDataStack.contents)
end)
it("works properly for u = [3, 100]", function()
local testStr = ""
local expected_output = {}
for i = 3, 100 do
for j = 1, i+1 do
testStr = testStr.." "..j
table.insert(expected_output, j)
end
testStr = testStr.." "..i.." ROLL"
local bottom = table.remove(expected_output, #expected_output - i)
table.insert(expected_output, bottom)
local testEnv = buildEnvironment(testStr)
interpreters.start(testEnv)
assert.are.same(expected_output, testEnv.activeDataStack.contents)
end
end)
end)
describe("' tests", function()
it("places an xt on top of the stack replacing the next word", function()
local cw = CoreWords
local testFunc = function(env) local a, b return a + b end
local customWord = CoreHelpers.defineWord(cw, "TEST", testFunc, false)
local testEnv = buildEnvironment("' TEST")
interpreters.start(testEnv)
assert.are.same(testFunc, testEnv.activeDataStack.contents[1])
end)
end)
describe("EXECUTE tests", function()
it("Given an `add` XT on top of the stack with two numbers beneath it, execute it.", function()
local testEnv = buildEnvironment("1 2 ' + EXECUTE")
interpreters.start(testEnv)
assert.are.equal(3, testEnv.activeDataStack.contents[1])
end)
end)
describe("[ tests", function()
it("Switches the environment's state to interpretation mode.", function()
local testEnv = buildEnvironment("[")
testEnv.compileState = true
interpreters.start(testEnv)
assert.are.equal(false, testEnv.compileState)
end)
end)
describe("] tests", function()
it("Switches the environment's state to compilation mode.", function()
local testEnv = buildEnvironment("]")
testEnv.compileState = false
interpreters.start(testEnv)
assert.are.equal(true, testEnv.compileState)
end)
end)
end)
end)