Add test command to tinygo

* Test command passes flag to compile indicating that a test binary
should be built
* Adds the test build tag
* Imports packages from test files

Stuck on how to find the TestMain that I have defined in my test file.
It is coming back nil.

Not sure how I would reflect on the functions defined in the test files
and then build up the test suite (M) in a basic block. First step I
figured was calling a simple predefined test suite though.

Author: carolynvs

Makefile

@@ -87,6 +87,10 @@ fmt:
 
 test:
 	@go test -v .
+	$(MAKE) tinygo-test
+
+tinygo-test: build/tinygo
+	cd tests/example1 && ../../build/tinygo test
 
 gen-device: gen-device-avr gen-device-nrf gen-device-sam gen-device-stm32
 

compiler/compiler.go

@@ -30,18 +30,24 @@ func init() {
 
 // Configure the compiler.
 type Config struct {
-	Triple    string   // LLVM target triple, e.g. x86_64-unknown-linux-gnu (empty string means default)
-	CPU       string   // LLVM CPU name, e.g. atmega328p (empty string means default)
-	GOOS      string   //
-	GOARCH    string   //
-	GC        string   // garbage collection strategy
-	CFlags    []string // cflags to pass to cgo
-	LDFlags   []string // ldflags to pass to cgo
-	DumpSSA   bool     // dump Go SSA, for compiler debugging
-	Debug     bool     // add debug symbols for gdb
-	RootDir   string   // GOROOT for TinyGo
-	GOPATH    string   // GOPATH, like `go env GOPATH`
-	BuildTags []string // build tags for TinyGo (empty means {Config.GOOS/Config.GOARCH})
+	Triple     string   // LLVM target triple, e.g. x86_64-unknown-linux-gnu (empty string means default)
+	CPU        string   // LLVM CPU name, e.g. atmega328p (empty string means default)
+	GOOS       string   //
+	GOARCH     string   //
+	GC         string   // garbage collection strategy
+	CFlags     []string // cflags to pass to cgo
+	LDFlags    []string // ldflags to pass to cgo
+	DumpSSA    bool     // dump Go SSA, for compiler debugging
+	Debug      bool     // add debug symbols for gdb
+	RootDir    string   // GOROOT for TinyGo
+	GOPATH     string   // GOPATH, like `go env GOPATH`
+	BuildTags  []string // build tags for TinyGo (empty means {Config.GOOS/Config.GOARCH})
+	TestConfig TestConfig
+}
+
+type TestConfig struct {
+	CompileTestBinary bool
+	// TODO: Filter the test functions to run, include verbose flag, etc
 }
 
 type Compiler struct {
@@ -205,12 +211,13 @@ func (c *Compiler) Compile(mainPath string) error {
 			return err
 		}
 	}
+
 	_, err = lprogram.Import("runtime", "")
 	if err != nil {
 		return err
 	}
 
-	err = lprogram.Parse()
+	err = lprogram.Parse(c.TestConfig.CompileTestBinary)
 	if err != nil {
 		return err
 	}
@@ -332,9 +339,16 @@ func (c *Compiler) Compile(mainPath string) error {
 	}
 	c.builder.CreateRetVoid()
 
+	realMain := c.mod.NamedFunction(c.ir.MainPkg().Pkg.Path() + ".main")
+
+	// Swap the main impl with the TestMain block
+	// TODO: generate a TestMain
+	//l := c.mod.NamedFunction(c.ir.MainPkg().Pkg.Path() + ".TestMain")
+	// TODO: why is this nil?
+	//fmt.Println("DEBUG TestMain: ", l)
+
 	// Conserve for goroutine lowering. Without marking these as external, they
 	// would be optimized away.
-	realMain := c.mod.NamedFunction(c.ir.MainPkg().Pkg.Path() + ".main")
 	realMain.SetLinkage(llvm.ExternalLinkage) // keep alive until goroutine lowering
 	c.mod.NamedFunction("runtime.alloc").SetLinkage(llvm.ExternalLinkage)
 	c.mod.NamedFunction("runtime.free").SetLinkage(llvm.ExternalLinkage)

loader/loader.go

@@ -53,6 +53,7 @@ func (p *Program) Import(path, srcDir string) (*Package, error) {
 	p.sorted = nil // invalidate the sorted order of packages
 	pkg := p.newPackage(buildPkg)
 	p.Packages[buildPkg.ImportPath] = pkg
+
 	return pkg, nil
 }
 
@@ -160,10 +161,10 @@ func (p *Program) sort() {
 // The returned error may be an Errors error, which contains a list of errors.
 //
 // Idempotent.
-func (p *Program) Parse() error {
+func (p *Program) Parse(includeTests bool) error {
 	// Load all imports
 	for _, pkg := range p.Sorted() {
-		err := pkg.importRecursively()
+		err := pkg.importRecursively(includeTests)
 		if err != nil {
 			if err, ok := err.(*ImportCycleError); ok {
 				if pkg.ImportPath != err.Packages[0] {
@@ -176,7 +177,7 @@ func (p *Program) Parse() error {
 
 	// Parse all packages.
 	for _, pkg := range p.Sorted() {
-		err := pkg.Parse()
+		err := pkg.Parse(includeTests)
 		if err != nil {
 			return err
 		}
@@ -217,7 +218,7 @@ func (p *Program) parseFile(path string, mode parser.Mode) (*ast.File, error) {
 // Parse parses and typechecks this package.
 //
 // Idempotent.
-func (p *Package) Parse() error {
+func (p *Package) Parse(includeTests bool) error {
 	if len(p.Files) != 0 {
 		return nil
 	}
@@ -231,7 +232,7 @@ func (p *Package) Parse() error {
 		return nil
 	}
 
-	files, err := p.parseFiles()
+	files, err := p.parseFiles(includeTests)
 	if err != nil {
 		return err
 	}
@@ -270,11 +271,21 @@ func (p *Package) Check() error {
 }
 
 // parseFiles parses the loaded list of files and returns this list.
-func (p *Package) parseFiles() ([]*ast.File, error) {
+func (p *Package) parseFiles(includeTests bool) ([]*ast.File, error) {
 	// TODO: do this concurrently.
 	var files []*ast.File
 	var fileErrs []error
-	for _, file := range p.GoFiles {
+
+	var gofiles []string
+	if includeTests {
+		gofiles = make([]string, 0, len(p.GoFiles)+len(p.TestGoFiles))
+		gofiles = append(gofiles, p.GoFiles...)
+		gofiles = append(gofiles, p.TestGoFiles...)
+	} else {
+		gofiles = p.GoFiles
+	}
+
+	for _, file := range gofiles {
 		f, err := p.parseFile(filepath.Join(p.Package.Dir, file), parser.ParseComments)
 		if err != nil {
 			fileErrs = append(fileErrs, err)
@@ -323,9 +334,15 @@ func (p *Package) Import(to string) (*types.Package, error) {
 // importRecursively() on the imported packages as well.
 //
 // Idempotent.
-func (p *Package) importRecursively() error {
+func (p *Package) importRecursively(includeTests bool) error {
 	p.Importing = true
-	for _, to := range p.Package.Imports {
+
+	imports := p.Package.Imports
+	if includeTests {
+		imports = append(imports, p.Package.TestImports...)
+	}
+
+	for _, to := range imports {
 		if to == "C" {
 			// Do Cgo processing in a later stage.
 			continue
@@ -343,7 +360,7 @@ func (p *Package) importRecursively() error {
 		if importedPkg.Importing {
 			return &ImportCycleError{[]string{p.ImportPath, importedPkg.ImportPath}, p.ImportPos[to]}
 		}
-		err = importedPkg.importRecursively()
+		err = importedPkg.importRecursively(includeTests)
 		if err != nil {
 			if err, ok := err.(*ImportCycleError); ok {
 				err.Packages = append([]string{p.ImportPath}, err.Packages...)

main.go

@@ -50,6 +50,7 @@ type BuildConfig struct {
 	cFlags     []string
 	ldFlags    []string
 	wasmAbi    string
+	testConfig compiler.TestConfig
 }
 
 // Helper function for Compiler object.
@@ -63,18 +64,19 @@ func Compile(pkgName, outpath string, spec *TargetSpec, config *BuildConfig, act
 	spec.LDFlags = append(spec.LDFlags, config.ldFlags...)
 
 	compilerConfig := compiler.Config{
-		Triple:    spec.Triple,
-		CPU:       spec.CPU,
-		GOOS:      spec.GOOS,
-		GOARCH:    spec.GOARCH,
-		GC:        config.gc,
-		CFlags:    spec.CFlags,
-		LDFlags:   spec.LDFlags,
-		Debug:     config.debug,
-		DumpSSA:   config.dumpSSA,
-		RootDir:   sourceDir(),
-		GOPATH:    getGopath(),
-		BuildTags: spec.BuildTags,
+		Triple:     spec.Triple,
+		CPU:        spec.CPU,
+		GOOS:       spec.GOOS,
+		GOARCH:     spec.GOARCH,
+		GC:         config.gc,
+		CFlags:     spec.CFlags,
+		LDFlags:    spec.LDFlags,
+		Debug:      config.debug,
+		DumpSSA:    config.dumpSSA,
+		RootDir:    sourceDir(),
+		GOPATH:     getGopath(),
+		BuildTags:  spec.BuildTags,
+		TestConfig: config.testConfig,
 	}
 	c, err := compiler.NewCompiler(pkgName, compilerConfig)
 	if err != nil {
@@ -312,6 +314,30 @@ func Build(pkgName, outpath, target string, config *BuildConfig) error {
 	})
 }
 
+func Test(pkgName, target string, config *BuildConfig) error {
+	spec, err := LoadTarget(target)
+	if err != nil {
+		return err
+	}
+
+	spec.BuildTags = append(spec.BuildTags, "test")
+	config.testConfig.CompileTestBinary = true
+	return Compile(pkgName, ".elf", spec, config, func(tmppath string) error {
+		cmd := exec.Command(tmppath)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		err := cmd.Run()
+		if err != nil {
+			if err, ok := err.(*exec.ExitError); ok && err.Exited() {
+				// Workaround for QEMU which always exits with an error.
+				return nil
+			}
+			return &commandError{"failed to run compiled binary", tmppath, err}
+		}
+		return nil
+	})
+}
+
 func Flash(pkgName, target, port string, config *BuildConfig) error {
 	spec, err := LoadTarget(target)
 	if err != nil {
@@ -608,8 +634,13 @@ func main() {
 		err := Run(flag.Arg(0), *target, config)
 		handleCompilerError(err)
 	case "test":
-		RunTests()
-		os.Exit(0)
+		pkgRoot, err := getPackageRoot()
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+		err = Test(pkgRoot, *target, config)
+		handleCompilerError(err)
 	case "clean":
 		// remove cache directory
 		dir := cacheDir()

src/os/proc.go

@@ -0,0 +1,11 @@
+package os
+
+import (
+	"syscall"
+)
+
+// Exit the current program with the specified status code.
+func Exit(code int) {
+	// TODO: This doesn't work, not sure what needs to be implemented to make it work?
+	syscall.Exit(code)
+}

src/reflect/value.go

@@ -92,7 +92,7 @@ func (v Value) Pointer() uintptr {
 }
 
 func (v Value) IsValid() bool {
-	panic("unimplemented: (reflect.Value).IsValid()")
+	return v.typecode != 0
 }
 
 func (v Value) CanInterface() bool {
@@ -335,7 +335,7 @@ func (v Value) Index(i int) Value {
 			typecode: v.Type().Elem(),
 			indirect: true,
 		}
-		addr := uintptr(slice.Data) + elem.Type().Size() * uintptr(i) // pointer to new value
+		addr := uintptr(slice.Data) + elem.Type().Size()*uintptr(i) // pointer to new value
 		elem.value = unsafe.Pointer(addr)
 		return elem
 	case String:
@@ -348,7 +348,7 @@ func (v Value) Index(i int) Value {
 		}
 		return Value{
 			typecode: Uint8.basicType(),
-			value: unsafe.Pointer(uintptr(*(*uint8)(unsafe.Pointer(s.Data + uintptr(i))))),
+			value:    unsafe.Pointer(uintptr(*(*uint8)(unsafe.Pointer(s.Data + uintptr(i))))),
 		}
 	case Array:
 		panic("unimplemented: (reflect.Value).Index()")

src/testing/doc.go

@@ -0,0 +1,6 @@
+package testing
+
+/*
+ This is a sad stub of the upstream testing package because it doesn't compile
+ with tinygo right now.
+*/

src/testing/testing.go

@@ -4,10 +4,51 @@ import (
 	"fmt"
 )
 
+// T is a test helper.
 type T struct {
+}
+
+// TestToCall is a reference to a test that should be called during a test suite run.
+type TestToCall struct {
+	// Name of the test to call.
+	Name string
+	// Function reference to the test.
+	Func func(*T)
+}
+
+// M is a test suite.
+type M struct {
+	// tests is a list of the test names to execute
+	Tests []TestToCall
+}
 
+// Run the test suite.
+func (m *M) Run() int {
+	for _, test := range m.Tests {
+		t := &T{}
+		test.Func(t)
+	}
+	// TODO: detect failures and return a failing exit code
+	// Right now we can't handle one anyway so it doesn't matter much
+	return 0
 }
 
+// Fatal is equivalent to Log followed by FailNow
 func (t *T) Fatal(args ...string) {
-	fmt.Println(args)
-}
+	// This doesn't print the same as in upstream go, but works good enough
+	fmt.Print(args)
+	//t.FailNow()
+}
+
+/*
+func (t *T) FailNow() {
+	// This fails with
+Undefined symbols for architecture x86_64:
+"_syscall.Exit", referenced from:
+  _main in main.o
+ld: symbol(s) not found for architecture x86_64
+clang: error: linker command failed with exit code 1 (use -v to see invocation)
+error: failed to link /var/folders/_t/fbw4wf_s42dfqdfjq7shdfm40000gn/T/tinygo382510652/main: exit status 1
+	os.Exit(12)
+}
+*/