aboutsummaryrefslogtreecommitdiffstats
path: root/Godeps/_workspace/src/github.com/robertkrimen/otto/terst/terst.go
diff options
context:
space:
mode:
Diffstat (limited to 'Godeps/_workspace/src/github.com/robertkrimen/otto/terst/terst.go')
-rw-r--r--Godeps/_workspace/src/github.com/robertkrimen/otto/terst/terst.go669
1 files changed, 0 insertions, 669 deletions
diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/terst/terst.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/terst/terst.go
deleted file mode 100644
index a25ca8b9c..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/terst/terst.go
+++ /dev/null
@@ -1,669 +0,0 @@
-// This file was AUTOMATICALLY GENERATED by terst-import (smuggol) from github.com/robertkrimen/terst
-
-/*
-Package terst is a terse (terst = test + terse), easy-to-use testing library for Go.
-
-terst is compatible with (and works via) the standard testing package: http://golang.org/pkg/testing
-
- var is = terst.Is
-
- func Test(t *testing.T) {
- terst.Terst(t, func() {
- is("abc", "abc")
-
- is(1, ">", 0)
-
- var abc []int
- is(abc, nil)
- }
- }
-
-Do not import terst directly, instead use `terst-import` to copy it into your testing environment:
-
-https://github.com/robertkrimen/terst/tree/master/terst-import
-
- $ go get github.com/robertkrimen/terst/terst-import
-
- $ terst-import
-
-*/
-package terst
-
-import (
- "bytes"
- "errors"
- "fmt"
- "math/big"
- "reflect"
- "regexp"
- "runtime"
- "strings"
- "sync"
- "testing"
- "time"
-)
-
-// Is compares two values (got & expect) and returns true if the comparison is true,
-// false otherwise. In addition, if the comparison is false, Is will report the error
-// in a manner similar to testing.T.Error(...). Is also takes an optional argument,
-// a comparator, that changes how the comparison is made. The following
-// comparators are available:
-//
-// == # got == expect (default)
-// != # got != expect
-//
-// > # got > expect (float32, uint, uint16, int, int64, ...)
-// >= # got >= expect
-// < # got < expect
-// <= # got <= expect
-//
-// =~ # regexp.MustCompile(expect).Match{String}(got)
-// !~ # !regexp.MustCompile(expect).Match{String}(got)
-//
-// Basic usage with the default comparator (==):
-//
-// Is(<got>, <expect>)
-//
-// Specifying a different comparator:
-//
-// Is(<got>, <comparator>, <expect>)
-//
-// A simple comparison:
-//
-// Is(2 + 2, 4)
-//
-// A bit trickier:
-//
-// Is(1, ">", 0)
-// Is(2 + 2, "!=", 5)
-// Is("Nothing happens.", "=~", `ing(\s+)happens\.$`)
-//
-// Is should only be called under a Terst(t, ...) call. For a standalone version,
-// use IsErr. If no scope is found and the comparison is false, then Is will panic the error.
-//
-func Is(arguments ...interface{}) bool {
- err := IsErr(arguments...)
- if err != nil {
- call := Caller()
- if call == nil {
- panic(err)
- }
- call.Error(err)
- return false
- }
- return true
-}
-
-type (
- // ErrFail indicates a comparison failure (e.g. 0 > 1).
- ErrFail error
-
- // ErrInvalid indicates an invalid comparison (e.g. bool == string).
- ErrInvalid error
-)
-
-var errInvalid = errors.New("invalid")
-
-var registry = struct {
- table map[uintptr]*_scope
- lock sync.RWMutex
-}{
- table: map[uintptr]*_scope{},
-}
-
-func registerScope(pc uintptr, scope *_scope) {
- registry.lock.Lock()
- defer registry.lock.Unlock()
- registry.table[pc] = scope
-}
-
-func scope() *_scope {
- scope, _ := findScope()
- return scope
-}
-
-func floatCompare(a float64, b float64) int {
- if a > b {
- return 1
- } else if a < b {
- return -1
- }
- // NaN == NaN
- return 0
-}
-
-func bigIntCompare(a *big.Int, b *big.Int) int {
- return a.Cmp(b)
-}
-
-func bigInt(value int64) *big.Int {
- return big.NewInt(value)
-}
-
-func bigUint(value uint64) *big.Int {
- return big.NewInt(0).SetUint64(value)
-}
-
-type _toString interface {
- String() string
-}
-
-func toString(value interface{}) (string, error) {
- switch value := value.(type) {
- case string:
- return value, nil
- case _toString:
- return value.String(), nil
- case error:
- return value.Error(), nil
- }
- return "", errInvalid
-}
-
-func matchString(got string, expect *regexp.Regexp) (int, error) {
- if expect.MatchString(got) {
- return 0, nil
- }
- return -1, nil
-}
-
-func match(got []byte, expect *regexp.Regexp) (int, error) {
- if expect.Match(got) {
- return 0, nil
- }
- return -1, nil
-}
-
-func compareMatch(got, expect interface{}) (int, error) {
- switch got := got.(type) {
- case []byte:
- switch expect := expect.(type) {
- case string:
- matcher, err := regexp.Compile(expect)
- if err != nil {
- return 0, err
- }
- return match(got, matcher)
- case *regexp.Regexp:
- return match(got, expect)
- }
- default:
- if got, err := toString(got); err == nil {
- switch expect := expect.(type) {
- case string:
- matcher, err := regexp.Compile(expect)
- if err != nil {
- return 0, err
- }
- return matchString(got, matcher)
- case *regexp.Regexp:
- return matchString(got, expect)
- }
- } else {
- return 0, err
- }
- }
- return 0, errInvalid
-}
-
-func floatPromote(value reflect.Value) (float64, error) {
- kind := value.Kind()
- if reflect.Int <= kind && kind <= reflect.Int64 {
- return float64(value.Int()), nil
- }
- if reflect.Uint <= kind && kind <= reflect.Uint64 {
- return float64(value.Uint()), nil
- }
- if reflect.Float32 <= kind && kind <= reflect.Float64 {
- return value.Float(), nil
- }
- return 0, errInvalid
-}
-
-func bigIntPromote(value reflect.Value) (*big.Int, error) {
- kind := value.Kind()
- if reflect.Int <= kind && kind <= reflect.Int64 {
- return bigInt(value.Int()), nil
- }
- if reflect.Uint <= kind && kind <= reflect.Uint64 {
- return bigUint(value.Uint()), nil
- }
- return nil, errInvalid
-}
-
-func compareOther(got, expect interface{}) (int, error) {
- {
- switch expect.(type) {
- case float32, float64:
- return compareNumber(got, expect)
- case uint, uint8, uint16, uint32, uint64:
- return compareNumber(got, expect)
- case int, int8, int16, int32, int64:
- return compareNumber(got, expect)
- case string:
- var err error
- got, err = toString(got)
- if err != nil {
- return 0, err
- }
- case nil:
- got := reflect.ValueOf(got)
- switch got.Kind() {
- case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface:
- if got.IsNil() {
- return 0, nil
- }
- return -1, nil
- case reflect.Invalid: // reflect.Invalid: var abc interface{} = nil
- return 0, nil
- }
- return 0, errInvalid
- }
- }
-
- if reflect.ValueOf(got).Type() != reflect.ValueOf(expect).Type() {
- return 0, errInvalid
- }
-
- if reflect.DeepEqual(got, expect) {
- return 0, nil
- }
- return -1, nil
-}
-
-func compareNumber(got, expect interface{}) (int, error) {
- {
- got := reflect.ValueOf(got)
- k0 := got.Kind()
- expect := reflect.ValueOf(expect)
- k1 := expect.Kind()
- if reflect.Float32 <= k0 && k0 <= reflect.Float64 ||
- reflect.Float32 <= k1 && k1 <= reflect.Float64 {
- got, err := floatPromote(got)
- if err != nil {
- return 0, err
- }
- expect, err := floatPromote(expect)
- if err != nil {
- return 0, err
- }
- return floatCompare(got, expect), nil
- } else {
- got, err := bigIntPromote(got)
- if err != nil {
- return 0, err
- }
- expect, err := bigIntPromote(expect)
- if err != nil {
- return 0, err
- }
- return got.Cmp(expect), nil
- }
- }
-
- return 0, errInvalid
-}
-
-// IsErr compares two values (got & expect) and returns nil if the comparison is true, an ErrFail if
-// the comparison is false, or an ErrInvalid if the comparison is invalid. IsErr also
-// takes an optional argument, a comparator, that changes how the comparison is made.
-//
-// Is & IsErr are similar but different:
-//
-// Is(...) // Should only be called within a Terst(...) call
-// IsErr(...) // A standalone comparator, the same as Is, just without the automatic reporting
-//
-func IsErr(arguments ...interface{}) error {
- var got, expect interface{}
- comparator := "=="
- switch len(arguments) {
- case 0, 1:
- return fmt.Errorf("invalid number of arguments to IsErr: %d", len(arguments))
- case 2:
- got, expect = arguments[0], arguments[1]
- default:
- if value, ok := arguments[1].(string); ok {
- comparator = value
- } else {
- return fmt.Errorf("invalid comparator: %v", arguments[1])
- }
- got, expect = arguments[0], arguments[2]
- }
-
- var result int
- var err error
-
- switch comparator {
- case "<", "<=", ">", ">=":
- result, err = compareNumber(got, expect)
- case "=~", "!~":
- result, err = compareMatch(got, expect)
- case "==", "!=":
- result, err = compareOther(got, expect)
- default:
- return fmt.Errorf("invalid comparator: %s", comparator)
- }
-
- if err == errInvalid {
- return ErrInvalid(fmt.Errorf(
- "\nINVALID (%s):\n got: %v (%T)\n expected: %v (%T)",
- comparator,
- got, got,
- expect, expect,
- ))
- } else if err != nil {
- return err
- }
-
- equality, pass := false, false
-
- switch comparator {
- case "==", "=~":
- equality = true
- pass = result == 0
- case "!=", "!~":
- equality = true
- pass = result != 0
- case "<":
- pass = result < 0
- case "<=":
- pass = result <= 0
- case ">":
- pass = result > 0
- case ">=":
- pass = result >= 0
- }
-
- if !pass {
- if equality {
- if comparator[1] == '~' {
- if value, ok := got.([]byte); ok {
- return ErrFail(fmt.Errorf(
- "\nFAIL (%s)\n got: %s %v%s\nexpected: %v%s",
- comparator,
- value, got, typeKindString(got),
- expect, typeKindString(expect),
- ))
- }
- }
- return ErrFail(fmt.Errorf(
- "\nFAIL (%s)\n got: %v%s\nexpected: %v%s",
- comparator,
- got, typeKindString(got),
- expect, typeKindString(expect),
- ))
- }
- return ErrFail(fmt.Errorf(
- "\nFAIL (%s)\n got: %v%s\nexpected: %s %v%s",
- comparator,
- got, typeKindString(got),
- comparator, expect, typeKindString(expect),
- ))
- }
-
- return nil
-}
-
-func typeKindString(value interface{}) string {
- reflectValue := reflect.ValueOf(value)
- kind := reflectValue.Kind().String()
- result := fmt.Sprintf("%T", value)
- if kind == result {
- if kind == "string" {
- return ""
- }
- return fmt.Sprintf(" (%T)", value)
- }
- return fmt.Sprintf(" (%T=%s)", value, kind)
-}
-
-func (scope *_scope) reset() {
- scope.name = ""
- scope.output = scope.output[:]
- scope.start = time.Time{}
- scope.duration = 0
-}
-
-// Terst creates a testing scope, where Is can be called and errors will be reported
-// according to the top-level location of the comparison, and not where the Is call
-// actually takes place. For example:
-//
-// func test(value int) {
-// Is(value, 5) // <--- This failure is reported below.
-// }
-//
-// Terst(t, func(){
-//
-// Is(2, ">", 3) // <--- An error is reported here.
-//
-// test(5) // <--- An error is reported here.
-//
-// })
-//
-func Terst(t *testing.T, arguments ...func()) {
- scope := &_scope{
- t: t,
- }
-
- pc, _, _, ok := runtime.Caller(1) // TODO Associate with the Test... func
- if !ok {
- panic("Here be dragons.")
- }
-
- _, scope.testFunc = findTestFunc()
-
- registerScope(pc, scope)
-
- for _, fn := range arguments {
- func() {
- scope.reset()
- name := scope.testFunc.Name()
- index := strings.LastIndex(scope.testFunc.Name(), ".")
- if index >= 0 {
- name = name[index+1:] + "(Terst)"
- } else {
- name = "(Terst)"
- }
- name = "(Terst)"
- scope.name = name
- scope.start = time.Now()
- defer func() {
- scope.duration = time.Now().Sub(scope.start)
- if err := recover(); err != nil {
- scope.t.Fail()
- scope.report()
- panic(err)
- }
- scope.report()
- }()
- fn()
- }()
- }
-}
-
-// From "testing"
-func (scope *_scope) report() {
- format := "~~~ %s: (Terst)\n%s"
- if scope.t.Failed() {
- fmt.Printf(format, "FAIL", scope.output)
- } else if testing.Verbose() && len(scope.output) > 0 {
- fmt.Printf(format, "PASS", scope.output)
- }
-}
-
-func (scope *_scope) log(call _entry, str string) {
- scope.mu.Lock()
- defer scope.mu.Unlock()
- scope.output = append(scope.output, decorate(call, str)...)
-}
-
-// decorate prefixes the string with the file and line of the call site
-// and inserts the final newline if needed and indentation tabs for formascing.
-func decorate(call _entry, s string) string {
-
- file, line := call.File, call.Line
- if call.PC > 0 {
- // Truncate file name at last file name separator.
- if index := strings.LastIndex(file, "/"); index >= 0 {
- file = file[index+1:]
- } else if index = strings.LastIndex(file, "\\"); index >= 0 {
- file = file[index+1:]
- }
- } else {
- file = "???"
- line = 1
- }
- buf := new(bytes.Buffer)
- // Every line is indented at least one tab.
- buf.WriteByte('\t')
- fmt.Fprintf(buf, "%s:%d: ", file, line)
- lines := strings.Split(s, "\n")
- if l := len(lines); l > 1 && lines[l-1] == "" {
- lines = lines[:l-1]
- }
- for i, line := range lines {
- if i > 0 {
- // Second and subsequent lines are indented an extra tab.
- buf.WriteString("\n\t\t")
- }
- buf.WriteString(line)
- }
- buf.WriteByte('\n')
- return buf.String()
-}
-
-func findScope() (*_scope, _entry) {
- registry.lock.RLock()
- defer registry.lock.RUnlock()
- table := registry.table
- depth := 2 // Starting depth
- call := _entry{}
- for {
- pc, _, _, ok := runtime.Caller(depth)
- if !ok {
- break
- }
- if scope, exists := table[pc]; exists {
- pc, file, line, _ := runtime.Caller(depth - 3) // Terst(...) + func(){}() + fn() => ???()
- call.PC = pc
- call.File = file
- call.Line = line
- return scope, call
- }
- depth++
- }
- return nil, _entry{}
-}
-
-// Call is a reference to a line immediately under a Terst testing scope.
-type Call struct {
- scope *_scope
- entry _entry
-}
-
-// Caller will search the stack, looking for a Terst testing scope. If a scope
-// is found, then Caller returns a Call for logging errors, accessing testing.T, etc.
-// If no scope is found, Caller returns nil.
-func Caller() *Call {
- scope, entry := findScope()
- if scope == nil {
- return nil
- }
- return &Call{
- scope: scope,
- entry: entry,
- }
-}
-
-// TestFunc returns the *runtime.Func entry for the top-level Test...(t testing.T)
-// function.
-func (cl *Call) TestFunc() *runtime.Func {
- return cl.scope.testFunc
-}
-
-// T returns the original testing.T passed to Terst(...)
-func (cl *Call) T() *testing.T {
- return cl.scope.t
-}
-
-// Log is the terst version of `testing.T.Log`
-func (cl *Call) Log(arguments ...interface{}) {
- cl.scope.log(cl.entry, fmt.Sprintln(arguments...))
-}
-
-// Logf is the terst version of `testing.T.Logf`
-func (cl *Call) Logf(format string, arguments ...interface{}) {
- cl.scope.log(cl.entry, fmt.Sprintf(format, arguments...))
-}
-
-// Error is the terst version of `testing.T.Error`
-func (cl *Call) Error(arguments ...interface{}) {
- cl.scope.log(cl.entry, fmt.Sprintln(arguments...))
- cl.scope.t.Fail()
-}
-
-// Errorf is the terst version of `testing.T.Errorf`
-func (cl *Call) Errorf(format string, arguments ...interface{}) {
- cl.scope.log(cl.entry, fmt.Sprintf(format, arguments...))
- cl.scope.t.Fail()
-}
-
-// Skip is the terst version of `testing.T.Skip`
-func (cl *Call) Skip(arguments ...interface{}) {
- cl.scope.log(cl.entry, fmt.Sprintln(arguments...))
- cl.scope.t.SkipNow()
-}
-
-// Skipf is the terst version of `testing.T.Skipf`
-func (cl *Call) Skipf(format string, arguments ...interface{}) {
- cl.scope.log(cl.entry, fmt.Sprintf(format, arguments...))
- cl.scope.t.SkipNow()
-}
-
-type _scope struct {
- t *testing.T
- testFunc *runtime.Func
- name string
- mu sync.RWMutex
- output []byte
- start time.Time
- duration time.Duration
-}
-
-type _entry struct {
- PC uintptr
- File string
- Line int
- Func *runtime.Func
-}
-
-func _findFunc(match string) (_entry, *runtime.Func) {
- depth := 2 // Starting depth
- for {
- pc, file, line, ok := runtime.Caller(depth)
- if !ok {
- break
- }
- fn := runtime.FuncForPC(pc)
- name := fn.Name()
- if index := strings.LastIndex(name, match); index >= 0 {
- // Assume we have an instance of TestXyzzy in a _test file
- return _entry{
- PC: pc,
- File: file,
- Line: line,
- Func: fn,
- }, fn
- }
- depth++
- }
- return _entry{}, nil
-}
-
-func findTestFunc() (_entry, *runtime.Func) {
- return _findFunc(".Test")
-}
-
-func findTerstFunc() (_entry, *runtime.Func) {
- return _findFunc(".Terst")
-}
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-23 18:29:49 +0800