example.go

Documentation: testing

		 1  // Copyright 2009 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package testing
		 6  
		 7  import (
		 8  	"fmt"
		 9  	"os"
		10  	"sort"
		11  	"strings"
		12  	"time"
		13  )
		14  
		15  type InternalExample struct {
		16  	Name			string
		17  	F				 func()
		18  	Output		string
		19  	Unordered bool
		20  }
		21  
		22  // RunExamples is an internal function but exported because it is cross-package;
		23  // it is part of the implementation of the "go test" command.
		24  func RunExamples(matchString func(pat, str string) (bool, error), examples []InternalExample) (ok bool) {
		25  	_, ok = runExamples(matchString, examples)
		26  	return ok
		27  }
		28  
		29  func runExamples(matchString func(pat, str string) (bool, error), examples []InternalExample) (ran, ok bool) {
		30  	ok = true
		31  
		32  	var eg InternalExample
		33  
		34  	for _, eg = range examples {
		35  		matched, err := matchString(*match, eg.Name)
		36  		if err != nil {
		37  			fmt.Fprintf(os.Stderr, "testing: invalid regexp for -test.run: %s\n", err)
		38  			os.Exit(1)
		39  		}
		40  		if !matched {
		41  			continue
		42  		}
		43  		ran = true
		44  		if !runExample(eg) {
		45  			ok = false
		46  		}
		47  	}
		48  
		49  	return ran, ok
		50  }
		51  
		52  func sortLines(output string) string {
		53  	lines := strings.Split(output, "\n")
		54  	sort.Strings(lines)
		55  	return strings.Join(lines, "\n")
		56  }
		57  
		58  // processRunResult computes a summary and status of the result of running an example test.
		59  // stdout is the captured output from stdout of the test.
		60  // recovered is the result of invoking recover after running the test, in case it panicked.
		61  //
		62  // If stdout doesn't match the expected output or if recovered is non-nil, it'll print the cause of failure to stdout.
		63  // If the test is chatty/verbose, it'll print a success message to stdout.
		64  // If recovered is non-nil, it'll panic with that value.
		65  // If the test panicked with nil, or invoked runtime.Goexit, it'll be
		66  // made to fail and panic with errNilPanicOrGoexit
		67  func (eg *InternalExample) processRunResult(stdout string, timeSpent time.Duration, finished bool, recovered interface{}) (passed bool) {
		68  	passed = true
		69  	dstr := fmtDuration(timeSpent)
		70  	var fail string
		71  	got := strings.TrimSpace(stdout)
		72  	want := strings.TrimSpace(eg.Output)
		73  	if eg.Unordered {
		74  		if sortLines(got) != sortLines(want) && recovered == nil {
		75  			fail = fmt.Sprintf("got:\n%s\nwant (unordered):\n%s\n", stdout, eg.Output)
		76  		}
		77  	} else {
		78  		if got != want && recovered == nil {
		79  			fail = fmt.Sprintf("got:\n%s\nwant:\n%s\n", got, want)
		80  		}
		81  	}
		82  	if fail != "" || !finished || recovered != nil {
		83  		fmt.Printf("--- FAIL: %s (%s)\n%s", eg.Name, dstr, fail)
		84  		passed = false
		85  	} else if *chatty {
		86  		fmt.Printf("--- PASS: %s (%s)\n", eg.Name, dstr)
		87  	}
		88  
		89  	if recovered != nil {
		90  		// Propagate the previously recovered result, by panicking.
		91  		panic(recovered)
		92  	}
		93  	if !finished && recovered == nil {
		94  		panic(errNilPanicOrGoexit)
		95  	}
		96  
		97  	return
		98  }
		99
View as plain text