unittests/remaster-tests.go - gollvm - Git at Google

 // Copyright 2020 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 // Rudimentary program for remastering unit test expected outputs,
 // typically useful in situations where there are large numbers
 // of outputs that have changed as a result of a difference in
 // the LLVM IR dumper. Usage:
 //
 // $ GOLLVM_UNITTESTS_EMIT_REMASTER_SCRIPT=1 \
 //     ./tools/gollvm/unittests/BackendCore/GoBackendCoreTests
 // <test output>
 // ... emitting remaster inputs to file '/tmp/remaster-inputs.txt'
 // $ go build remaster-tests.go
 // $ ./remaster-tests /tmp/remaster-inputs.txt
 //
 // WARNING WARNING WARNING: this program overwrites the unit test
 // source files in place, so it should be used with caution.
 //

 package main

 import (
 	"bufio"
 	"flag"
 	"fmt"
 	"io/ioutil"
 	"log"
 	"os"
 	"sort"
 	"strconv"
 	"strings"
 )

 var verbflag = flag.Int("v", 0, "Verbose trace output level")
 var dryrunflag = flag.Bool("dryrun", false, "Show actions but don't overwrite sources.")

 func verb(vlevel int, s string, a ...interface{}) {
 	if *verbflag >= vlevel {
 		fmt.Printf(s, a...)
 		fmt.Printf("\n")
 	}
 }

 func usage(msg string) {
 	if len(msg) > 0 {
 		fmt.Fprintf(os.Stderr, "error: %s\n", msg)
 	}
 	fmt.Fprintf(os.Stderr, "usage: remaster-tests [flags] <inputfile>\n")
 	flag.PrintDefaults()
 	os.Exit(2)
 }

 type Change struct {
 	expected string
 	actual   string
 	line     int
 	mls      bool // macro line at start (vs end)
 }

 type FileChanges struct {
 	changes []Change
 }

 // readInput reads in the /tmp/remaster-inputs.txt file and inserts
 // the changes it describes into a handy map.
 func readInput(inf *os.File) map[string]FileChanges {
 	fm := make(map[string]FileChanges)
 	scanner := bufio.NewScanner(inf)
 	lno := 1
 	for scanner.Scan() {
 		line := scanner.Text()
 		verb(3, "=-= line is %s", line)
 		tokens := strings.Split(line, " ")
 		if len(tokens) != 5 {
 			panic(fmt.Sprintf("malformed line %d in input file: %s", lno, line))
 		}
 		macroLineAtStart, errm := strconv.ParseInt(tokens[0], 10, 64)
 		if errm != nil {
 			panic(fmt.Sprintf("malformed srcline in input line %d: %s", lno, line))
 		}
 		mls := false
 		if macroLineAtStart == 1 {
 			mls = true
 		}
 		srcfile := tokens[1]
 		spot, err := strconv.ParseInt(tokens[2], 10, 64)
 		if err != nil {
 			panic(fmt.Sprintf("malformed srcline in input line %d: %s", lno, line))
 		}
 		exp := tokens[3]
 		act := tokens[4]
 		fc := fm[srcfile]
 		newchange := Change{
 			expected: exp,
 			actual:   act,
 			line:     int(spot),
 			mls:      mls,
 		}
 		fc.changes = append(fc.changes, newchange)
 		fm[srcfile] = fc
 	}
 	return fm
 }

 func filesHaveSameContent(f1 string, f2 string) bool {
 	content1, err1 := ioutil.ReadFile(f1)
 	if err1 != nil {
 		log.Fatal(err1)
 	}
 	content2, err2 := ioutil.ReadFile(f2)
 	if err2 != nil {
 		log.Fatal(err2)
 	}
 	return string(content1) == string(content2)
 }

 func isWhite(s string) bool {
 	return strings.TrimSpace(s) == ""
 }

 func readFile(fn string) []string {
 	// Read
 	inf, err := os.Open(fn)
 	if err != nil {
 		log.Fatalf("error: opening %s: %v\n", fn, err)
 	}
 	contents := []string{}
 	scanner := bufio.NewScanner(inf)
 	for scanner.Scan() {
 		contents = append(contents, scanner.Text())
 	}
 	return contents
 }

 // readAndNormalizeDump reads in an expected or actual dump and
 // normalizes it by removing any leading/trailing space, and
 // applying a consistent level of indentation.
 func readAndNormalizeDump(fn string) []string {
 	contents := readFile(fn)

 	// Chop off leading and trailing whitespace lines.
 	var st int
 	var en int
 	for st = 0; st < len(contents); st++ {
 		if !isWhite(contents[st]) {
 			break
 		}
 	}
 	for en = len(contents) - 1; en != 0; en-- {
 		if !isWhite(contents[en]) {
 			break
 		}
 	}
 	contents = contents[st : en+1]

 	// Indent.
 	for i := 0; i < len(contents); i++ {
 		sp := "  "
 		if i == 0 {
 			sp = "    "
 		}
 		contents[i] = sp + contents[i]
 	}
 	return contents
 }

 // applyChange applies a single remastering change to the specified
 // source file. Since previous remasterings may have added or removed
 // lines previously in the file, it takes a delta param to account
 // for any previous additions/subtractions prior to the change
 // at this line.
 func applyChange(srcfile string, change Change, delta int) int {

 	// Read actual and expected dumps.
 	ca := readAndNormalizeDump(change.actual)
 	ce := readAndNormalizeDump(change.expected)

 	// Read source file and create an updated version of it.
 	srclines := readFile(srcfile)
 	verb(2, "%s has %d lines", srcfile, len(srclines))
 	newlines := []string{}

 	if *dryrunflag {
 		fmt.Fprintf(os.Stderr, "dry run: applyChange stubbed out for change to %s line %d\n", srcfile, change.line)
 		return 0
 	}

 	// Add content before the result.
 	var startres int
 	if change.mls {
 		startres = change.line + delta
 	} else {
 		startres = change.line + delta - len(ca) - 1
 	}
 	verb(2, "startres = %d", startres)
 	newlines = append(newlines, srclines[0:startres]...)

 	// Add new test result.
 	newlines = append(newlines, ca...)

 	// Add file content after the result.
 	after := startres + len(ce)
 	newlines = append(newlines, srclines[after:]...)

 	// Emit updated file

 	f, err := os.OpenFile(srcfile, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
 	if err != nil {
 		log.Fatal(err)
 	}
 	for _, s := range newlines {
 		if _, err := f.WriteString(s + "\n"); err != nil {
 			log.Fatalf("error writing update to %s: %v", srcfile, err)
 		}
 	}
 	if err := f.Close(); err != nil {
 		log.Fatal(err)
 	}

 	// Return updated delta.
 	delta += len(ca) - len(ce)
 	verb(2, "finished change at line %d, delta=%d", change.line, delta)
 	return delta
 }

 // fixupFile applies all of the changes in the input that apply
 // to the specified source file.
 func fixupFile(file string, fc FileChanges) {
 	// Sort changes by increasing line number.
 	sort.SliceStable(fc.changes, func(i, j int) bool {
 		ci := fc.changes[i]
 		cj := fc.changes[j]
 		if ci.line != cj.line {
 			return ci.line < cj.line
 		}
 		return ci.actual < cj.actual
 	})

 	// Process each change. Some unit tests run once per calling
 	// convention, meaning that we may encounter multiple failures
 	// each at the same source line; handle this by verifying that the
 	// new outputs are the same.
 	delta := 0
 	for k := 0; k < len(fc.changes); k++ {
 		for nxt := k + 1; nxt < len(fc.changes); nxt++ {
 			if fc.changes[nxt].line == fc.changes[k].line {
 				// Check that actual outputs match
 				if !filesHaveSameContent(fc.changes[nxt].actual,
 					fc.changes[k].actual) {
 					log.Fatalf("error: multiple non-identical unit test actual results found, file=%s, line=%d, dumps: %s %s\n", file, fc.changes[k].line, fc.changes[nxt].actual, fc.changes[k].actual)
 				}
 				k = nxt
 			}
 		}
 		change := fc.changes[k]

 		// Apply the change.
 		verb(1, "change: file=%s line=%d act=%s exp=%s\n",
 			file, change.line, change.actual, change.expected)
 		delta = applyChange(file, change, delta)
 	}
 }

 // perform reads in the "remaster inputs" file, builds up
 // a table of updates to perform, and then applies the updates.
 func perform(inf *os.File) {
 	// Slurp in the input
 	fm := readInput(inf)

 	// Build up a list of srcfiles, then sort it
 	srcs := []string{}
 	for k := range fm {
 		srcs = append(srcs, k)
 	}
 	sort.Strings(srcs)
 	if len(srcs) == 0 {
 		verb(0, "warning: no changes found in input file")
 	}

 	// Process updates for each source file.
 	for _, s := range srcs {
 		verb(1, "fixup for %s", s)
 		fixupFile(s, fm[s])
 	}
 }

 func main() {
 	log.SetFlags(0)
 	log.SetPrefix("remaster-tests: ")
 	flag.Parse()
 	verb(1, "entering main")
 	if flag.NArg() != 1 {
 		usage("please supply a single argument (file with remaster inputs)")
 	}
 	args := flag.Args()
 	inputfile := args[0]
 	f, err := os.Open(inputfile)
 	if err != nil {
 		log.Fatalf("error: opening %s: %v\n", inputfile, err)
 	}
 	defer f.Close()
 	perform(f)
 	verb(1, "leaving main")
 }
	// Copyright 2020 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	// Rudimentary program for remastering unit test expected outputs,
	// typically useful in situations where there are large numbers
	// of outputs that have changed as a result of a difference in
	// the LLVM IR dumper. Usage:
	//
	// $ GOLLVM_UNITTESTS_EMIT_REMASTER_SCRIPT=1 \
	// ./tools/gollvm/unittests/BackendCore/GoBackendCoreTests
	// <test output>
	// ... emitting remaster inputs to file '/tmp/remaster-inputs.txt'
	// $ go build remaster-tests.go
	// $ ./remaster-tests /tmp/remaster-inputs.txt
	//
	// WARNING WARNING WARNING: this program overwrites the unit test
	// source files in place, so it should be used with caution.
	//

	package main

	import (
	"bufio"
	"flag"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"sort"
	"strconv"
	"strings"
	)

	var verbflag = flag.Int("v", 0, "Verbose trace output level")
	var dryrunflag = flag.Bool("dryrun", false, "Show actions but don't overwrite sources.")

	func verb(vlevel int, s string, a ...interface{}) {
	if *verbflag >= vlevel {
	fmt.Printf(s, a...)
	fmt.Printf("\n")
	}
	}

	func usage(msg string) {
	if len(msg) > 0 {
	fmt.Fprintf(os.Stderr, "error: %s\n", msg)
	}
	fmt.Fprintf(os.Stderr, "usage: remaster-tests [flags] <inputfile>\n")
	flag.PrintDefaults()
	os.Exit(2)
	}

	type Change struct {
	expected string
	actual string
	line int
	mls bool // macro line at start (vs end)
	}

	type FileChanges struct {
	changes []Change
	}

	// readInput reads in the /tmp/remaster-inputs.txt file and inserts
	// the changes it describes into a handy map.
	func readInput(inf *os.File) map[string]FileChanges {
	fm := make(map[string]FileChanges)
	scanner := bufio.NewScanner(inf)
	lno := 1
	for scanner.Scan() {
	line := scanner.Text()
	verb(3, "=-= line is %s", line)
	tokens := strings.Split(line, " ")
	if len(tokens) != 5 {
	panic(fmt.Sprintf("malformed line %d in input file: %s", lno, line))
	}
	macroLineAtStart, errm := strconv.ParseInt(tokens[0], 10, 64)
	if errm != nil {
	panic(fmt.Sprintf("malformed srcline in input line %d: %s", lno, line))
	}
	mls := false
	if macroLineAtStart == 1 {
	mls = true
	}
	srcfile := tokens[1]
	spot, err := strconv.ParseInt(tokens[2], 10, 64)
	if err != nil {
	panic(fmt.Sprintf("malformed srcline in input line %d: %s", lno, line))
	}
	exp := tokens[3]
	act := tokens[4]
	fc := fm[srcfile]
	newchange := Change{
	expected: exp,
	actual: act,
	line: int(spot),
	mls: mls,
	}
	fc.changes = append(fc.changes, newchange)
	fm[srcfile] = fc
	}
	return fm
	}

	func filesHaveSameContent(f1 string, f2 string) bool {
	content1, err1 := ioutil.ReadFile(f1)
	if err1 != nil {
	log.Fatal(err1)
	}
	content2, err2 := ioutil.ReadFile(f2)
	if err2 != nil {
	log.Fatal(err2)
	}
	return string(content1) == string(content2)
	}

	func isWhite(s string) bool {
	return strings.TrimSpace(s) == ""
	}

	func readFile(fn string) []string {
	// Read
	inf, err := os.Open(fn)
	if err != nil {
	log.Fatalf("error: opening %s: %v\n", fn, err)
	}
	contents := []string{}
	scanner := bufio.NewScanner(inf)
	for scanner.Scan() {
	contents = append(contents, scanner.Text())
	}
	return contents
	}

	// readAndNormalizeDump reads in an expected or actual dump and
	// normalizes it by removing any leading/trailing space, and
	// applying a consistent level of indentation.
	func readAndNormalizeDump(fn string) []string {
	contents := readFile(fn)

	// Chop off leading and trailing whitespace lines.
	var st int
	var en int
	for st = 0; st < len(contents); st++ {
	if !isWhite(contents[st]) {
	break
	}
	}
	for en = len(contents) - 1; en != 0; en-- {
	if !isWhite(contents[en]) {
	break
	}
	}
	contents = contents[st : en+1]

	// Indent.
	for i := 0; i < len(contents); i++ {
	sp := " "
	if i == 0 {
	sp = " "
	}
	contents[i] = sp + contents[i]
	}
	return contents
	}

	// applyChange applies a single remastering change to the specified
	// source file. Since previous remasterings may have added or removed
	// lines previously in the file, it takes a delta param to account
	// for any previous additions/subtractions prior to the change
	// at this line.
	func applyChange(srcfile string, change Change, delta int) int {

	// Read actual and expected dumps.
	ca := readAndNormalizeDump(change.actual)
	ce := readAndNormalizeDump(change.expected)

	// Read source file and create an updated version of it.
	srclines := readFile(srcfile)
	verb(2, "%s has %d lines", srcfile, len(srclines))
	newlines := []string{}

	if *dryrunflag {
	fmt.Fprintf(os.Stderr, "dry run: applyChange stubbed out for change to %s line %d\n", srcfile, change.line)
	return 0
	}

	// Add content before the result.
	var startres int
	if change.mls {
	startres = change.line + delta
	} else {
	startres = change.line + delta - len(ca) - 1
	}
	verb(2, "startres = %d", startres)
	newlines = append(newlines, srclines[0:startres]...)

	// Add new test result.
	newlines = append(newlines, ca...)

	// Add file content after the result.
	after := startres + len(ce)
	newlines = append(newlines, srclines[after:]...)

	// Emit updated file

	f, err := os.OpenFile(srcfile, os.O_RDWR\|os.O_CREATE\|os.O_TRUNC, 0644)
	if err != nil {
	log.Fatal(err)
	}
	for _, s := range newlines {
	if _, err := f.WriteString(s + "\n"); err != nil {
	log.Fatalf("error writing update to %s: %v", srcfile, err)
	}
	}
	if err := f.Close(); err != nil {
	log.Fatal(err)
	}

	// Return updated delta.
	delta += len(ca) - len(ce)
	verb(2, "finished change at line %d, delta=%d", change.line, delta)
	return delta
	}

	// fixupFile applies all of the changes in the input that apply
	// to the specified source file.
	func fixupFile(file string, fc FileChanges) {
	// Sort changes by increasing line number.
	sort.SliceStable(fc.changes, func(i, j int) bool {
	ci := fc.changes[i]
	cj := fc.changes[j]
	if ci.line != cj.line {
	return ci.line < cj.line
	}
	return ci.actual < cj.actual
	})

	// Process each change. Some unit tests run once per calling
	// convention, meaning that we may encounter multiple failures
	// each at the same source line; handle this by verifying that the
	// new outputs are the same.
	delta := 0
	for k := 0; k < len(fc.changes); k++ {
	for nxt := k + 1; nxt < len(fc.changes); nxt++ {
	if fc.changes[nxt].line == fc.changes[k].line {
	// Check that actual outputs match
	if !filesHaveSameContent(fc.changes[nxt].actual,
	fc.changes[k].actual) {
	log.Fatalf("error: multiple non-identical unit test actual results found, file=%s, line=%d, dumps: %s %s\n", file, fc.changes[k].line, fc.changes[nxt].actual, fc.changes[k].actual)
	}
	k = nxt
	}
	}
	change := fc.changes[k]

	// Apply the change.
	verb(1, "change: file=%s line=%d act=%s exp=%s\n",
	file, change.line, change.actual, change.expected)
	delta = applyChange(file, change, delta)
	}
	}

	// perform reads in the "remaster inputs" file, builds up
	// a table of updates to perform, and then applies the updates.
	func perform(inf *os.File) {
	// Slurp in the input
	fm := readInput(inf)

	// Build up a list of srcfiles, then sort it
	srcs := []string{}
	for k := range fm {
	srcs = append(srcs, k)
	}
	sort.Strings(srcs)
	if len(srcs) == 0 {
	verb(0, "warning: no changes found in input file")
	}

	// Process updates for each source file.
	for _, s := range srcs {
	verb(1, "fixup for %s", s)
	fixupFile(s, fm[s])
	}
	}

	func main() {
	log.SetFlags(0)
	log.SetPrefix("remaster-tests: ")
	flag.Parse()
	verb(1, "entering main")
	if flag.NArg() != 1 {
	usage("please supply a single argument (file with remaster inputs)")
	}
	args := flag.Args()
	inputfile := args[0]
	f, err := os.Open(inputfile)
	if err != nil {
	log.Fatalf("error: opening %s: %v\n", inputfile, err)
	}
	defer f.Close()
	perform(f)
	verb(1, "leaving main")
	}