mirror of
https://github.com/Kugelschieber/asl.git
synced 2026-01-18 12:00:25 +00:00
328 lines
8.2 KiB
Go
328 lines
8.2 KiB
Go
package main
|
|
|
|
import (
|
|
"io/ioutil"
|
|
"testing"
|
|
)
|
|
|
|
type Want struct {
|
|
tokens []string
|
|
parser string
|
|
}
|
|
|
|
type Got struct {
|
|
tokens []Token
|
|
parser string
|
|
}
|
|
|
|
func TestArray(t *testing.T) {
|
|
got := getCompiled(t, "test/array.asl")
|
|
want := &Want{
|
|
[]string{"var","x","=","[","1",",","2",",","3","]",";","var","y","=","x","[","1","]",";"},
|
|
"x = [1,2,3];\r\ny = (x select (1));\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestAssignResult(t *testing.T) {
|
|
got := getCompiled(t, "test/assign_result.asl")
|
|
want := &Want{
|
|
[]string{"var", "x", "=", "foo", "(", "1", ",", "2", ",", "3", ")", ";", "y", "=", "bar", "(", "1", ",", "2", ",", "3", ")", ";"},
|
|
"x = ([1, 2, 3] call foo);\r\ny = ([1, 2, 3] call bar);\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestAssignment(t *testing.T) {
|
|
got := getCompiled(t, "test/assignment.asl")
|
|
want := &Want{
|
|
[]string{"x", "=", "1", ";"},
|
|
"x = 1;\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestBuildinFunctionCall(t *testing.T) {
|
|
got := getCompiled(t, "test/buildin_func.asl")
|
|
want := &Want{
|
|
[]string{"var","_x","=","setHit","(","getVar","(","player",",","foo",")","(","bar",")",")","(","\"head\"",",","\"tail\"",")",";"},
|
|
"_x = (([player, foo] getVar bar) setHit [\"head\", \"tail\"]);\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestCode(t *testing.T) {
|
|
got := getCompiled(t, "test/code.asl")
|
|
want := &Want{
|
|
[]string{"var", "x", "=", "code", "(", "\"var x = 5;\"", ")", ";"},
|
|
"x = {x = 5;};\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestComment(t *testing.T) {
|
|
got := getCompiled(t, "test/comment.asl")
|
|
want := &Want{
|
|
[]string{"var","x","=","1",";"},
|
|
"x = 1;\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
|
|
func TestExitWith(t *testing.T) {
|
|
got := getCompiled(t, "test/exitwith.asl")
|
|
want := &Want{
|
|
[]string{"exitwith","{","}"},
|
|
"if (true) exitWith {\r\n};\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestExpression1(t *testing.T) {
|
|
got := getCompiled(t, "test/expression1.asl")
|
|
want := &Want{
|
|
[]string{"x","=","(","(","1","+","2","+","3",")","*","4","/","2",")","+","foo","(","1",",","2",",","3",")",";"},
|
|
"x = ((1+2+3)*4/2)+([1, 2, 3] call foo);\r\n",
|
|
}
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestExpression2(t *testing.T) {
|
|
got := getCompiled(t, "test/expression2.asl")
|
|
want := &Want{
|
|
[]string{"var","x","=","true","|","|","(","3",">","=","4","&","&","5","<","8",")",";"},
|
|
"x = true||(3>=4&&5<8);\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestExpression3(t *testing.T) {
|
|
got := getCompiled(t, "test/expression3.asl")
|
|
want := &Want{
|
|
[]string{"var","x","=","-","(","1","+","(","2","+","3",")",")","/","(","6","*","(","someVariable","+","99","-","100",")",")","-","(","20",")","+","!","anotherVariable","+","foo","(",")",";"},
|
|
"x = -(1+(2+3))/(6*(someVariable+99-100))-(20)+!anotherVariable+([] call foo);\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestFor(t *testing.T) {
|
|
got := getCompiled(t, "test/for.asl")
|
|
want := &Want{
|
|
[]string{"for","var","i","=","0",";","i","<","100",";","i","=","i","+","1","{","}"},
|
|
"for [{i=0}, {i<100}, {i=i+1}] do {\r\n};\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestForeach(t *testing.T) {
|
|
got := getCompiled(t, "test/foreach.asl")
|
|
want := &Want{
|
|
[]string{"foreach", "unit", "=", ">", "allUnits", "{", "}"},
|
|
"{\r\nunit = _x;\r\n} forEach (allUnits);\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestFunction(t *testing.T) {
|
|
got := getCompiled(t, "test/func.asl")
|
|
want := &Want{
|
|
[]string{"func", "TestFunction", "(", "param0", ",", "param1", ")", "{", "return", "true", ";", "}"},
|
|
"TestFunction = {\r\nparams [\"param0\",\"param1\"];\r\nreturn true;\r\n};\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestFunctionCall(t *testing.T) {
|
|
got := getCompiled(t, "test/func_call.asl")
|
|
want := &Want{
|
|
[]string{"func","myFunc","(","a",",","b",")","{","return","a",">","b",";","}","myFunc","(","1","+","3","/","4",",","2","-","(","66","*","22",")","/","3","-","(","(","123",")",")",")",";"},
|
|
"myFunc = {\r\nparams [\"a\",\"b\"];\r\nreturn a>b;\r\n};\r\n[1+3/4, 2-(66*22)/3-((123))] call myFunc;\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestFunctionParams(t *testing.T) {
|
|
got := getCompiled(t, "test/func_params.asl")
|
|
want := &Want{
|
|
[]string{"func","myFunc","(","a","=","1",",","b","=","2",")","{","return","a","+","b",";","}"},
|
|
"myFunc = {\r\nparams [[\"a\",1],[\"b\",2]];\r\nreturn a+b;\r\n};\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestIdentifier(t *testing.T) {
|
|
got := getCompiled(t, "test/identifier.asl")
|
|
want := &Want{
|
|
[]string{"var","format","=","\"should not be for mat!\"",";"},
|
|
"format = \"should not be for mat!\";\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestIf(t *testing.T) {
|
|
got := getCompiled(t, "test/if.asl")
|
|
want := &Want{
|
|
[]string{"if","a","<","b","{","}"},
|
|
"if (a<b) then {\r\n};\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestInlineCode(t *testing.T) {
|
|
got := getCompiled(t, "test/inline_code.asl")
|
|
want := &Want{
|
|
[]string{"var","inline_code","=","code","(","\"var a = 1;var b = 2;if a < b {foo();}\"",")",";"},
|
|
"inline_code = {a = 1;b = 2;if (a<b) then {[] call foo;};};\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestNegation(t *testing.T) {
|
|
got := getCompiled(t, "test/negation.asl")
|
|
want := &Want{
|
|
[]string{"var","x","=","!","foo","(",")",";"},
|
|
"x = !([] call foo);\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestOperator(t *testing.T) {
|
|
got := getCompiled(t, "test/operator.asl")
|
|
want := &Want{
|
|
[]string{"if","x","=","=","y","&","&","x","!","=","y","&","&","x","<","=","y","&","&","x",">","=","y","&","&","x","<","y","&","&","x",">","y","{","}"},
|
|
"if (x==y&&x!=y&&x<=y&&x>=y&&x<y&&x>y) then {\r\n};\r\n",
|
|
}
|
|
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestPreprocessor(t *testing.T) {
|
|
got := getCompiled(t, "test/preprocessor.asl")
|
|
want := &Want{
|
|
[]string{"#define HELLO_WORLD \"Hello World!\"", "hint", "(", ")", "(", "HELLO_WORLD", ")", ";"},
|
|
"\r\n#define HELLO_WORLD \"Hello World!\"\r\nhint HELLO_WORLD;\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestSwitch(t *testing.T) {
|
|
got := getCompiled(t, "test/switch.asl")
|
|
want := &Want{
|
|
[]string{"switch","x","{","case","1",":","x","=","1",";","case","2",":","x","=","2",";","default",":","x","=","3",";","}"},
|
|
"switch (x) do {\r\ncase 1:\r\n{\r\nx = 1;\r\n};\r\ncase 2:\r\n{\r\nx = 2;\r\n};\r\ndefault:\r\n{\r\nx = 3;\r\n};\r\n};\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestTryCatch(t *testing.T) {
|
|
got := getCompiled(t, "test/try_catch.asl")
|
|
want := &Want{
|
|
[]string{"try","{","}","catch","{","}"},
|
|
"try {\r\n} catch {\r\n};\r\n",
|
|
}
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func TestWaitUntil(t *testing.T) {
|
|
got := getCompiled(t, "test/waituntil.asl")
|
|
want := &Want{
|
|
[]string{"waituntil","(","x","=","x","+","1",";","x","<","100",")",";"},
|
|
"waitUntil {x=x+1;x<100};\r\n",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
|
|
func TestWhile(t *testing.T) {
|
|
got := getCompiled(t, "test/while.asl")
|
|
want := &Want{
|
|
[]string{"while", "true", "{", "}"},
|
|
"while {true} do {\r\n};",
|
|
}
|
|
|
|
equal(t, got, want)
|
|
}
|
|
|
|
func getCompiled(t *testing.T, file string) *Got {
|
|
code, err := ioutil.ReadFile(file)
|
|
|
|
if err != nil {
|
|
t.Error("Could not read test file: " + file)
|
|
t.FailNow()
|
|
}
|
|
|
|
tokens := Tokenize(code)
|
|
compiler := Compiler{}
|
|
parsed := compiler.Parse(tokens, true)
|
|
|
|
got := &Got{tokens, parsed}
|
|
|
|
return got
|
|
}
|
|
|
|
func compareLength(t *testing.T, got *Got, want *Want) {
|
|
if len(got.tokens) != len(want.tokens) {
|
|
t.Error("Length of tokens got and expected tokens not equal, was:")
|
|
gotlist, wantlist := "", ""
|
|
|
|
for i := range got.tokens {
|
|
gotlist += (got.tokens)[i].Token + " "
|
|
}
|
|
|
|
for i := range want.tokens {
|
|
wantlist += (want.tokens)[i] + " "
|
|
}
|
|
|
|
t.Log(gotlist)
|
|
t.Log("expected:")
|
|
t.Log(wantlist)
|
|
t.FailNow()
|
|
}
|
|
|
|
|
|
}
|
|
|
|
func compareTokens(t *testing.T, got *Got, want *Want) {
|
|
for i := range got.tokens {
|
|
if (got.tokens)[i].Token != (want.tokens)[i] {
|
|
t.Error("Tokens do not match: " + (got.tokens)[i].Token + " != " + (want.tokens)[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
func equal(t *testing.T, got *Got, want *Want) {
|
|
compareLength(t, got, want)
|
|
compareTokens(t, got, want)
|
|
|
|
if got.parser != want.parser {
|
|
t.Error("Parsed does not equal, got:")
|
|
t.Log(got.parser)
|
|
t.Log("expected:")
|
|
t.Log(want.parser)
|
|
t.FailNow()
|
|
}
|
|
}
|