listtests.go

package main

import (
	"bufio"
	"bytes"
	"flag"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"sort"
	"strings"

	"log"
)

var reLine = regexp.MustCompile("^\\s*(\\w+)\\s+(\\w+)\\s+(.+)$")

func main() {
	log.SetFlags(0)

	dir := flag.String("dir", "", "the directory that contains the binary; if empty, the same as the first argument")
	prefix := flag.String("prefix", "", "the function prefix to scan for; if not specified will use *<dirBasename>.Test*")
	help := flag.Bool("help", false, "display help")
	flag.Parse()

	if *help {
		flag.PrintDefaults()
		return
	}

	args := flag.Args()
	if len(args) == 0 {
		log.Fatalf("Must specify the name of a single directory, e.g. ./test/integration")
	}

	path := args[0]
	_ = args[1:]
	base := filepath.Base(path)

	execDir := path
	if len(*dir) > 0 {
		execDir = *dir
	}

	pkg := filepath.Join(execDir, fmt.Sprintf("%s.test", base))
	test, err := filepath.Abs(pkg)
	if err != nil {
		log.Fatalf("Unable to make path %q absolute: %v", execDir, err)
	}
	if _, err := os.Stat(test); err != nil {
		log.Fatalf("No test executable %q exits, did you run `go test -c` on the named package?", test)
	}

	cmd := exec.Command("go", "tool", "nm", "-sort", "name", "-n", test)
	out, err := cmd.CombinedOutput()
	if err != nil {
		log.Fatalf("Can't get `go tool nm` output from %q: %v", test, err)
	}

	names := []string{}

	scanner := bufio.NewScanner(bytes.NewReader(out))
	for scanner.Scan() {
		line := scanner.Text()
		match := reLine.FindStringSubmatch(line)
		if len(match) == 0 {
			//log.Printf("mismatch: %s", line)
			continue
		}
		// ignore non code segments
		if match[2] != "t" && match[2] != "T" {
			// log.Printf("non-code line: %s",line)
			continue
		}
		name := match[3]
		// there are always two segments per function, ignore the extra one
		if strings.HasSuffix(name, ".f") {
			continue
		}

		segments := strings.SplitAfter(name, "/")
		// expect a package and name
		if len(segments) < 2 {
			//log.Printf("root_package: %s", name)
			continue
		}
		last := segments[len(segments)-1]
		_ = segments[len(segments)-2]

		// two parts
		parts := strings.Split(last, ".")
		if len(parts) != 2 {
			//log.Printf("bad_name: %s", last)
			continue
		}
		if parts[0] != base {
			//log.Printf("ignore: %s", last)
			continue
		}

		test := parts[1]
		if len(*prefix) == 0 {
			if !strings.HasPrefix(test, "Test") {
				continue
			}
		} else {
			if !strings.HasPrefix(name, *prefix) {
				continue
			}
		}
		names = append(names, test)
	}

	if len(names) == 0 {
		log.Fatalf("No tests found!")
	}
	sort.Sort(sort.StringSlice(names))
	for _, test := range names {
		fmt.Printf("%s\n", test)
	}

	if err := scanner.Err(); err != nil {
		log.Fatalf("Unable to scan the symbol output: %v", err)
	}
}