Added more tests

tests/benchmarks_test.go

@@ -1,26 +0,0 @@
-package tests_test
-
-import (
-	"testing"
-
-	"git.akyoto.dev/cli/q/src/build"
-	"git.akyoto.dev/go/assert"
-)
-
-func BenchmarkEmpty(b *testing.B) {
-	compiler := build.New("benchmarks/empty.q")
-
-	for i := 0; i < b.N; i++ {
-		_, err := compiler.Run()
-		assert.Nil(b, err)
-	}
-}
-
-func BenchmarkExpressions(b *testing.B) {
-	compiler := build.New("benchmarks/expressions.q")
-
-	for i := 0; i < b.N; i++ {
-		_, err := compiler.Run()
-		assert.Nil(b, err)
-	}
-}

tests/errors_test.go

@@ -10,34 +10,34 @@ import (
 	"git.akyoto.dev/go/assert"
 )
 
-func TestErrors(t *testing.T) {
+var errs = []struct {
-	tests := []struct {
+	File          string
-		File          string
+	ExpectedError error
-		ExpectedError error
+}{
-	}{
+	{"ExpectedFunctionDefinition.q", errors.ExpectedFunctionDefinition},
-		{"ExpectedFunctionDefinition.q", errors.ExpectedFunctionDefinition},
+	{"ExpectedFunctionName.q", errors.ExpectedFunctionName},
-		{"ExpectedFunctionName.q", errors.ExpectedFunctionName},
+	{"ExpectedFunctionParameters.q", errors.ExpectedFunctionParameters},
-		{"ExpectedFunctionParameters.q", errors.ExpectedFunctionParameters},
+	{"InvalidInstructionIdentifier.q", &errors.InvalidInstruction{Instruction: "abc"}},
-		{"InvalidInstructionIdentifier.q", &errors.InvalidInstruction{Instruction: "abc"}},
+	{"InvalidInstructionNumber.q", &errors.InvalidInstruction{Instruction: "123"}},
-		{"InvalidInstructionNumber.q", &errors.InvalidInstruction{Instruction: "123"}},
+	{"InvalidExpression.q", errors.InvalidExpression},
-		{"InvalidExpression.q", errors.InvalidExpression},
+	{"InvalidOperator.q", &errors.InvalidOperator{Operator: "+++"}},
-		{"InvalidOperator.q", &errors.InvalidOperator{Operator: "+++"}},
+	{"InvalidCharacter.q", &errors.InvalidCharacter{Character: "@"}},
-		{"InvalidCharacter.q", &errors.InvalidCharacter{Character: "@"}},
+	{"InvalidCharacter2.q", &errors.InvalidCharacter{Character: "@"}},
-		{"InvalidCharacter2.q", &errors.InvalidCharacter{Character: "@"}},
+	{"InvalidCharacter3.q", &errors.InvalidCharacter{Character: "@"}},
-		{"InvalidCharacter3.q", &errors.InvalidCharacter{Character: "@"}},
+	{"MissingAssignValue.q", errors.MissingAssignValue},
-		{"MissingAssignValue.q", errors.MissingAssignValue},
+	{"MissingBlockEnd.q", errors.MissingBlockEnd},
-		{"MissingBlockEnd.q", errors.MissingBlockEnd},
+	{"MissingBlockStart.q", errors.MissingBlockStart},
-		{"MissingBlockStart.q", errors.MissingBlockStart},
+	{"MissingGroupEnd.q", errors.MissingGroupEnd},
-		{"MissingGroupEnd.q", errors.MissingGroupEnd},
+	{"MissingGroupStart.q", errors.MissingGroupStart},
-		{"MissingGroupStart.q", errors.MissingGroupStart},
+	{"MissingMainFunction.q", errors.MissingMainFunction},
-		{"MissingMainFunction.q", errors.MissingMainFunction},
+	{"VariableAlreadyExists.q", &errors.VariableAlreadyExists{Name: "x"}},
-		{"VariableAlreadyExists.q", &errors.VariableAlreadyExists{Name: "x"}},
+	{"UnknownIdentifier.q", &errors.UnknownIdentifier{Name: "x"}},
-		{"UnknownIdentifier.q", &errors.UnknownIdentifier{Name: "x"}},
+	{"UnknownIdentifier2.q", &errors.UnknownIdentifier{Name: "x"}},
-		{"UnknownIdentifier2.q", &errors.UnknownIdentifier{Name: "x"}},
+	{"UnusedVariable.q", &errors.UnusedVariable{Name: "x"}},
-		{"UnusedVariable.q", &errors.UnusedVariable{Name: "x"}},
+}
-	}
 
-	for _, test := range tests {
+func TestErrors(t *testing.T) {
+	for _, test := range errs {
 		name := strings.TrimSuffix(test.File, ".q")
 
 		t.Run(name, func(t *testing.T) {

tests/examples_test.go

@@ -5,17 +5,17 @@ import (
 	"testing"
 )
 
-func TestExamples(t *testing.T) {
+var examples = []struct {
-	var tests = []struct {
+	Name             string
-		Name             string
+	ExpectedOutput   string
-		ExpectedOutput   string
+	ExpectedExitCode int
-		ExpectedExitCode int
+}{
-	}{
+	{"hello", "", 9},
-		{"hello", "", 9},
+	{"write", "ELF", 0},
-		{"write", "ELF", 0},
+}
-	}
 
-	for _, test := range tests {
+func TestExamples(t *testing.T) {
+	for _, test := range examples {
 		t.Run(test.Name, func(t *testing.T) {
 			run(t, filepath.Join("..", "examples", test.Name), test.ExpectedOutput, test.ExpectedExitCode)
 		})

tests/programs_test.go

@@ -10,16 +10,31 @@ import (
 	"git.akyoto.dev/go/assert"
 )
 
-func TestPrograms(t *testing.T) {
+var programs = []struct {
-	var tests = []struct {
+	Name             string
-		Name             string
+	ExpectedOutput   string
-		ExpectedOutput   string
+	ExpectedExitCode int
-		ExpectedExitCode int
+}{
-	}{
+	{"empty.q", "", 0},
-		{"successive-calls.q", "", 9},
+	{"square-sum.q", "", 25},
-	}
+	{"multi-calls.q", "", 9},
+}
 
-	for _, test := range tests {
+func BenchmarkPrograms(b *testing.B) {
+	for _, test := range programs {
+		b.Run(test.Name, func(b *testing.B) {
+			compiler := build.New(filepath.Join("programs", test.Name))
+
+			for i := 0; i < b.N; i++ {
+				_, err := compiler.Run()
+				assert.Nil(b, err)
+			}
+		})
+	}
+}
+
+func TestPrograms(t *testing.T) {
+	for _, test := range programs {
 		t.Run(test.Name, func(t *testing.T) {
 			run(t, filepath.Join("programs", test.Name), test.ExpectedOutput, test.ExpectedExitCode)
 		})