From 6e7decbf3b9a30ce633c21d2ce70c009bfc7a12d Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Thu, 25 May 2017 19:02:15 +1000 Subject: [PATCH] Add "puffs test" to the puffs tool. --- cmd/puffs-test-c/main.go | 100 +++++++++++++++++++++++++++++++++++++++ cmd/puffs/gen.go | 57 ++++++++-------------- cmd/puffs/main.go | 26 ++++++++-- cmd/puffs/test.go | 98 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 242 insertions(+), 39 deletions(-) create mode 100644 cmd/puffs-test-c/main.go create mode 100644 cmd/puffs/test.go diff --git a/cmd/puffs-test-c/main.go b/cmd/puffs-test-c/main.go new file mode 100644 index 00000000..c6778c2d --- /dev/null +++ b/cmd/puffs-test-c/main.go @@ -0,0 +1,100 @@ +// Use of this source code is governed by a BSD-style license that can be found +// in the LICENSE file. + +// puffs-test-c runs directories of C test programs. +package main + +import ( + "flag" + "fmt" + "io/ioutil" + "os" + "os/exec" + "path/filepath" + "sort" + "strings" +) + +func main() { + if err := main1(); err != nil { + os.Stderr.WriteString(err.Error() + "\n") + os.Exit(1) + } +} + +func main1() error { + flag.Parse() + failed := false + for _, arg := range flag.Args() { + filenames, err := listDir(arg) + if err != nil { + return err + } + for _, filename := range filenames { + f, err := do(arg, filename) + if err != nil { + return err + } + failed = failed || f + } + } + if failed { + return fmt.Errorf("%s: some tests failed", os.Args[0]) + } + return nil +} + +func listDir(dirname string) (filenames []string, err error) { + f, err := os.Open(dirname) + if err != nil { + return nil, err + } + defer f.Close() + + infos, err := f.Readdir(-1) + if err != nil { + return nil, err + } + for _, o := range infos { + name := o.Name() + if strings.HasSuffix(name, ".c") { + filenames = append(filenames, name) + } + } + sort.Strings(filenames) + return filenames, nil +} + +func do(dirname string, filename string) (failed bool, err error) { + fmt.Printf(" %s:\n", filename) + workDir, err := ioutil.TempDir("", "puffs-test-c") + if err != nil { + return false, err + } + defer os.RemoveAll(workDir) + + for _, cc := range []string{"clang", "gcc"} { + in := filepath.Join(dirname, filename) + out := filepath.Join(workDir, cc+".out") + fmt.Printf(" %-8s", cc+":") + + ccCmd := exec.Command(cc, "-std=c99", "-Wall", "-Werror", "-o", out, in) + ccCmd.Stdout = os.Stdout + ccCmd.Stderr = os.Stderr + if err := ccCmd.Run(); err != nil { + return false, err + } + + outCmd := exec.Command(out) + outCmd.Stdout = os.Stdout + outCmd.Stderr = os.Stderr + if err := outCmd.Run(); err == nil { + // No-op. + } else if _, ok := err.(*exec.ExitError); ok { + failed = true + } else { + return false, err + } + } + return failed, nil +} diff --git a/cmd/puffs/gen.go b/cmd/puffs/gen.go index dcb75f3c..b02f999e 100644 --- a/cmd/puffs/gen.go +++ b/cmd/puffs/gen.go @@ -8,9 +8,9 @@ import ( "flag" "fmt" "io/ioutil" + "os" "os/exec" "path/filepath" - "sort" "strings" "github.com/google/puffs/lang/ast" @@ -40,8 +40,8 @@ func doGen(puffsRoot string, args []string) error { if recursive { arg = arg[:len(arg)-4] } - arg = filepath.FromSlash(arg) - if err := gen(puffsRoot, filepath.Join(puffsRoot, arg), langs, recursive); err != nil { + arg = filepath.Join(puffsRoot, filepath.FromSlash(arg)) + if err := gen(puffsRoot, arg, langs, recursive); err != nil { return err } } @@ -49,32 +49,17 @@ func doGen(puffsRoot string, args []string) error { } func gen(puffsRoot, dirname string, langs []string, recursive bool) error { - filenames, subDirs := []string(nil), []string(nil) - infos, err := readdir(dirname) + filenames, dirnames, err := listDir(dirname, recursive) if err != nil { return err } - for _, o := range infos { - name := o.Name() - if o.IsDir() { - if recursive { - subDirs = append(subDirs, name) - } - } else if strings.HasSuffix(name, ".puffs") { - filenames = append(filenames, name) - } - } - if len(filenames) > 0 { - sort.Strings(filenames) if err := genDir(puffsRoot, dirname, filenames, langs); err != nil { return err } } - - if len(subDirs) > 0 { - sort.Strings(subDirs) - for _, d := range subDirs { + if len(dirnames) > 0 { + for _, d := range dirnames { if err := gen(puffsRoot, filepath.Join(dirname, d), langs, recursive); err != nil { return err } @@ -84,6 +69,9 @@ func gen(puffsRoot, dirname string, langs []string, recursive bool) error { } func genDir(puffsRoot string, dirname string, filenames []string, langs []string) error { + // TODO: skip the generation if the output file already exists and its + // mtime is newer than all inputs and the puffs-gen-foo command. + idMap := &token.IDMap{} files := []*ast.File(nil) buf := &bytes.Buffer{} @@ -113,31 +101,28 @@ func genDir(puffsRoot string, dirname string, filenames []string, langs []string for _, lang := range langs { command := "puffs-gen-" + lang + stdout := &bytes.Buffer{} cmd := exec.Command(command, "-assume_already_checked") cmd.Stdin = bytes.NewReader(combinedSrc) - out, err := cmd.CombinedOutput() - if _, ok := err.(*exec.ExitError); ok && len(out) > 0 { - // Go error messages usually don't end in "\n". The caller, who sees - // the error we return here, usually adds the "\n" themselves. - if out[len(out)-1] == '\n' { - out = out[:len(out)-1] - } - // The exec.ExitError's Error message doesn't include stderr, so we - // return that explicitly. - return fmt.Errorf("%s: %s", command, out) - } - if err != nil { - return fmt.Errorf("%s: %v", command, err) + cmd.Stdout = stdout + cmd.Stderr = os.Stderr + if err := cmd.Run(); err == nil { + // No-op. + } else if _, ok := err.(*exec.ExitError); ok { + return fmt.Errorf("%s: failed", command) + } else { + return err } + out := stdout.Bytes() outFilename := filepath.Join(puffsRoot, "gen", lang, filepath.Base(dirname)+"."+lang) if existing, err := ioutil.ReadFile(outFilename); err == nil && bytes.Equal(existing, out) { - fmt.Println("unchanged:", outFilename) + fmt.Println("gen unchanged: ", outFilename) continue } if err := ioutil.WriteFile(outFilename, out, 0644); err != nil { return err } - fmt.Println("wrote: ", outFilename) + fmt.Println("gen wrote: ", outFilename) } return nil } diff --git a/cmd/puffs/main.go b/cmd/puffs/main.go index 135d5a2b..3f0071fd 100644 --- a/cmd/puffs/main.go +++ b/cmd/puffs/main.go @@ -11,6 +11,7 @@ import ( "go/build" "os" "path/filepath" + "sort" "strings" ) @@ -19,6 +20,7 @@ var commands = []struct { do func(puffsRoot string, args []string) error }{ {"gen", doGen}, + {"test", doTest}, } func main() { @@ -59,13 +61,31 @@ func findPuffsRoot() (string, error) { return "", errors.New("could not find Puffs root directory") } -func readdir(dirname string) ([]os.FileInfo, error) { +func listDir(dirname string, returnSubdirs bool) (filenames []string, dirnames []string, err error) { f, err := os.Open(dirname) if err != nil { - return nil, err + return nil, nil, err } defer f.Close() - return f.Readdir(-1) + + infos, err := f.Readdir(-1) + if err != nil { + return nil, nil, err + } + for _, o := range infos { + name := o.Name() + if o.IsDir() { + if returnSubdirs { + dirnames = append(dirnames, name) + } + } else if strings.HasSuffix(name, ".puffs") { + filenames = append(filenames, name) + } + } + + sort.Strings(filenames) + sort.Strings(dirnames) + return filenames, dirnames, nil } func usage() { diff --git a/cmd/puffs/test.go b/cmd/puffs/test.go new file mode 100644 index 00000000..983d109d --- /dev/null +++ b/cmd/puffs/test.go @@ -0,0 +1,98 @@ +// Use of this source code is governed by a BSD-style license that can be found +// in the LICENSE file. + +package main + +import ( + "errors" + "flag" + "fmt" + "os" + "os/exec" + "path/filepath" + "strings" +) + +func doTest(puffsRoot string, args []string) error { + flags := flag.NewFlagSet("test", flag.ExitOnError) + langsStr := flags.String("langs", "c", langsUsage) + if err := flags.Parse(args); err != nil { + return err + } + langs, err := parseLangs(*langsStr) + if err != nil { + return err + } + args = flags.Args() + if len(args) == 0 { + args = []string{"std/..."} + } + + failed := false + for _, arg := range args { + recursive := strings.HasSuffix(arg, "/...") + if recursive { + arg = arg[:len(arg)-4] + } + arg = filepath.Join(puffsRoot, filepath.FromSlash(arg)) + + // Ensure that we are testing the latest version of the generated code. + if err := gen(puffsRoot, arg, langs, recursive); err != nil { + return err + } + + // Proceed with testing the generated code. + f, err := test(puffsRoot, arg, langs, recursive) + if err != nil { + return err + } + failed = failed || f + } + if failed { + return errors.New("puffs test: some tests failed") + } + return nil +} + +func test(puffsRoot, dirname string, langs []string, recursive bool) (failed bool, err error) { + filenames, dirnames, err := listDir(dirname, recursive) + if err != nil { + return false, err + } + if len(filenames) > 0 { + f, err := testDir(puffsRoot, dirname, langs) + if err != nil { + return false, err + } + failed = failed || f + } + if len(dirnames) > 0 { + for _, d := range dirnames { + f, err := test(puffsRoot, filepath.Join(dirname, d), langs, recursive) + if err != nil { + return false, err + } + failed = failed || f + } + } + return failed, nil +} + +func testDir(puffsRoot string, dirname string, langs []string) (failed bool, err error) { + for _, lang := range langs { + command := "puffs-test-" + lang + testDirname := filepath.Join(puffsRoot, "test", lang, filepath.Base(dirname)) + fmt.Println("test: ", testDirname) + cmd := exec.Command(command, testDirname) + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + if err := cmd.Run(); err == nil { + // No-op. + } else if _, ok := err.(*exec.ExitError); ok { + failed = true + } else { + return false, err + } + } + return failed, nil +}