1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
|
// Package tap provides support for automated Test Anything Protocol ("TAP")
// tests in Go. For example:
//
// package main
//
// import "github.com/mndrix/tap-go"
//
// func main() {
// t := tap.New()
// t.Header(2)
// t.Ok(true, "first test")
// t.Ok(true, "second test")
// }
//
// generates the following output
//
// TAP version 13
// 1..2
// ok 1 - first test
// ok 2 - second test
package tap
import (
"fmt"
"io"
"os"
"strings"
)
import "testing/quick"
// T is a type to encapsulate test state. Methods on this type generate TAP
// output.
type T struct {
nextTestNumber *int
// TODO toggles the TODO directive for Ok, Fail, Pass, and similar.
TODO bool
// Writer indicates where TAP output should be sent. The default is os.Stdout.
Writer io.Writer
}
// New creates a new Tap value
func New() *T {
nextTestNumber := 1
return &T{
nextTestNumber: &nextTestNumber,
}
}
func (t *T) w() io.Writer {
if t.Writer == nil {
return os.Stdout
}
return t.Writer
}
func (t *T) printf(format string, a ...interface{}) {
fmt.Fprintf(t.w(), format, a...)
}
// Header displays a TAP header including version number and expected
// number of tests to run. For an unknown number of tests, set
// testCount to zero (in which case the plan is not written); this is
// useful with AutoPlan.
func (t *T) Header(testCount int) {
t.printf("TAP version 13\n")
if testCount > 0 {
t.printf("1..%d\n", testCount)
}
}
// Ok generates TAP output indicating whether a test passed or failed.
func (t *T) Ok(test bool, description string) {
// did the test pass or not?
ok := "ok"
if !test {
ok = "not ok"
}
if t.TODO {
t.printf("%s %d # TODO %s\n", ok, *t.nextTestNumber, description)
} else {
t.printf("%s %d - %s\n", ok, *t.nextTestNumber, description)
}
(*t.nextTestNumber)++
}
// Fail indicates that a test has failed. This is typically only used when the
// logic is too complex to fit naturally into an Ok() call.
func (t *T) Fail(description string) {
t.Ok(false, description)
}
// Pass indicates that a test has passed. This is typically only used when the
// logic is too complex to fit naturally into an Ok() call.
func (t *T) Pass(description string) {
t.Ok(true, description)
}
// Check runs randomized tests against a function just as "testing/quick.Check"
// does. Success or failure generate appropriate TAP output.
func (t *T) Check(function interface{}, description string) {
err := quick.Check(function, nil)
if err == nil {
t.Ok(true, description)
return
}
t.Diagnostic(err.Error())
t.Ok(false, description)
}
// Count returns the number of tests completed so far.
func (t *T) Count() int {
return *t.nextTestNumber - 1
}
// AutoPlan generates a test plan based on the number of tests that were run.
func (t *T) AutoPlan() {
t.printf("1..%d\n", t.Count())
}
func escapeNewlines(s string) string {
return strings.Replace(strings.TrimRight(s, "\n"), "\n", "\n# ", -1)
}
// Todo returns copy of the test-state with TODO set.
func (t *T) Todo() *T {
newT := *t
newT.TODO = true
return &newT
}
// Skip indicates that a test has been skipped.
func (t *T) Skip(count int, description string) {
for i := 0; i < count; i++ {
t.printf("ok %d # SKIP %s\n", *t.nextTestNumber, description)
(*t.nextTestNumber)++
}
}
// Diagnostic generates a diagnostic from the message,
// which may span multiple lines.
func (t *T) Diagnostic(message string) {
t.printf("# %s\n", escapeNewlines(message))
}
// Diagnosticf generates a diagnostic from the format string and arguments,
// which may span multiple lines.
func (t *T) Diagnosticf(format string, a ...interface{}) {
t.printf("# "+escapeNewlines(format)+"\n", a...)
}
// YAML generates a YAML block from the message.
func (t *T) YAML(message interface{}) error {
bytes, err := yaml(message, " ")
if err != nil {
return err
}
t.printf(" ---\n ")
t.printf(string(bytes))
t.printf(" ...\n")
return nil
}
|