status-go/vendor/github.com/robertkrimen/otto/terst/terst.go

// 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")
}