fspl/generator/test-common.go

package generator

import "io"
import "fmt"
import "testing"
import "strings"
import "git.tebibyte.media/sashakoshka/fspl/parser"
import "git.tebibyte.media/sashakoshka/fspl/analyzer"

func testString (test *testing.T, correct string, input string) {
	testReader(test, correct, strings.NewReader(input))
}

func testReader (test *testing.T, correct string, inputs ...io.Reader) {
	ast := parser.Tree { }
	for index, stream := range inputs {
		err := ast.Parse(fmt.Sprintf("stream%d.fspl", index), stream)
		if err != nil && err != io.EOF{
			test.Error("parser returned error:", err)
			return
		}
	}

	tree := analyzer.Tree { }
	err := tree.Analyze(ast)
	if err != nil {
		test.Error("analyzer returned error:", err)
		return
	}
	
	module, err := (&Target {
		WordSize: 64,
		Arch: "x86_64",
	}).Generate(tree)
	if err != nil {
		test.Error("generator returned error:", err)
		return
	}
	output := new(strings.Builder)
	_, err = module.WriteTo(output)
	if err != nil {
		test.Error("generator returned error:", err)
		return
	}

	printColumns := func (left, right string) {
		test.Logf("%-80v | %v", left, right)
	}

	printColumnsStyle := func (left, right string, style string) {
		test.Logf("\033[%s%-80v - %v\033[0m", style, left, right)
	}
	
	got := output.String()
	if got != correct {
		test.Logf("results do not match")

		got     = strings.ReplaceAll(got,     "\t", "        ")
		correct = strings.ReplaceAll(correct, "\t", "        ")
		
		got     := strings.Split(got,     "\n")
		correct := strings.Split(correct, "\n")
		length  := len(got)
		if len(correct) > len(got) { length = len(correct) }

		printColumns("CORRECT:", "GOT:")
		test.Log()
		for index := 0; index < length; index ++ {
			left  := ""
			right := ""
			if index < len(got)     { left  = got[index]     }
			if index < len(correct) { right = correct[index] }

			if left != right {
				printColumnsStyle(left, right, "31m")
			} else {
				printColumns(left, right)
			}
			
		}
		test.Fail()
	}
}