tavor: github.com/zimmski/tavor/test/assert Index | Files

package assert

import "github.com/zimmski/tavor/test/assert"

Index

Package Files

assert.go

func CallerInfo Uses

func CallerInfo() string

CallerInfo returns a string containing the file and line number of the assert call that failed.

func Condition Uses

func Condition(t TestingT, comp Comparison, msgAndArgs ...interface{}) bool

Condition uses a Comparison to assert a complex condition.

func Contains Uses

func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool

Contains asserts that the specified string or list(array, slice...) contains the specified substring or element.

assert.Contains(t, "Hello World", "World", "But 'Hello World' does contain 'World'")
assert.Contains(t, ["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'")

Returns whether the assertion was successful (true) or not (false).

func Empty Uses

func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool

Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either a slice or a channel with len == 0.

assert.Empty(t, obj)

Returns whether the assertion was successful (true) or not (false).

func Equal Uses

func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool

Equal asserts that two objects are equal.

assert.Equal(t, 123, 123, "123 and 123 should be equal")

Returns whether the assertion was successful (true) or not (false).

func EqualError Uses

func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool

EqualError asserts that a function returned an error (i.e. not `nil`) and that it is equal to the provided error.

  actualObj, err := SomeFunction()
  if assert.Error(t, err, "An error was expected") {
	   assert.Equal(t, err, expectedError)
  }

Returns whether the assertion was successful (true) or not (false).

func Exactly Uses

func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool

Exactly asserts that two objects are equal is value and type.

assert.Exactly(t, int32(123), int64(123), "123 and 123 should NOT be equal")

Returns whether the assertion was successful (true) or not (false).

func Fail Uses

func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool

Fail reports a failure through

func False Uses

func False(t TestingT, value bool, msgAndArgs ...interface{}) bool

False asserts that the specified value is true.

assert.False(t, myBool, "myBool should be false")

Returns whether the assertion was successful (true) or not (false).

func Implements Uses

func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool

Implements asserts that an object is implemented by the specified interface.

assert.Implements(t, (*MyInterface)(nil), new(MyObject), "MyObject")

func InDelta Uses

func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool

InDelta asserts that the two numerals are within delta of each other.

assert.InDelta(t, math.Pi, (22 / 7.0), 0.01)

Returns whether the assertion was successful (true) or not (false).

func InEpsilon Uses

func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool

InEpsilon asserts that expected and actual have a relative error less than epsilon

Returns whether the assertion was successful (true) or not (false).

func IsType Uses

func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool

IsType asserts that the specified objects are of the same type.

func Nil Uses

func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool

Nil asserts that the specified object is nil.

assert.Nil(t, err, "err should be nothing")

Returns whether the assertion was successful (true) or not (false).

func NoError Uses

func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool

NoError asserts that a function returned no error (i.e. `nil`).

  actualObj, err := SomeFunction()
  if assert.NoError(t, err) {
	   assert.Equal(t, actualObj, expectedObj)
  }

Returns whether the assertion was successful (true) or not (false).

func NotContains Uses

func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool

NotContains asserts that the specified string or list(array, slice...) does NOT contain the specified substring or element.

assert.NotContains(t, "Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
assert.NotContains(t, ["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'")

Returns whether the assertion was successful (true) or not (false).

func NotEmpty Uses

func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool

NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either a slice or a channel with len == 0.

if assert.NotEmpty(t, obj) {

assert.Equal(t, "two", obj[1])

}

Returns whether the assertion was successful (true) or not (false).

func NotEqual Uses

func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool

NotEqual asserts that the specified values are NOT equal.

assert.NotEqual(t, obj1, obj2, "two objects shouldn't be equal")

Returns whether the assertion was successful (true) or not (false).

func NotNil Uses

func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool

NotNil asserts that the specified object is not nil.

assert.NotNil(t, err, "err should be something")

Returns whether the assertion was successful (true) or not (false).

func NotPanics Uses

func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool

NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.

assert.NotPanics(t, func(){
  RemainCalm()
}, "Calling RemainCalm() should NOT panic")

Returns whether the assertion was successful (true) or not (false).

func NotRegexp Uses

func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool

NotRegexp asserts that a specified regexp does not match a string.

assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
assert.NotRegexp(t, "^start", "it's not starting")

Returns whether the assertion was successful (true) or not (false).

func ObjectsAreEqual Uses

func ObjectsAreEqual(expected, actual interface{}) bool

ObjectsAreEqual determines if two objects are considered equal.

This function does no assertion of any kind.

func Panics Uses

func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool

Panics asserts that the code inside the specified PanicTestFunc panics.

assert.Panics(t, func(){
  GoCrazy()
}, "Calling GoCrazy() should panic")

Returns whether the assertion was successful (true) or not (false).

func Regexp Uses

func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool

Regexp asserts that a specified regexp matches a string.

assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
assert.Regexp(t, "start...$", "it's not starting")

Returns whether the assertion was successful (true) or not (false).

func True Uses

func True(t TestingT, value bool, msgAndArgs ...interface{}) bool

True asserts that the specified value is true.

assert.True(t, myBool, "myBool should be true")

Returns whether the assertion was successful (true) or not (false).

func WithinDuration Uses

func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool

WithinDuration asserts that the two times are within duration delta of each other.

assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")

Returns whether the assertion was successful (true) or not (false).

type Comparison Uses

type Comparison func() (success bool)

Comparison a custom function that returns true on success and false on failure

type PanicTestFunc Uses

type PanicTestFunc func()

PanicTestFunc defines a func that should be passed to the assert.Panics and assert.NotPanics methods, and represents a simple func that takes no arguments, and returns nothing.

type TestingT Uses

type TestingT interface {
    Errorf(format string, args ...interface{})
}

TestingT is an interface wrapper around *testing.T

Package assert imports 8 packages (graph). Updated 2018-12-11. Refresh now. Tools for package owners.