assert

package module
v0.0.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 8, 2020 License: MIT Imports: 4 Imported by: 62

README

assert GoDoc

Assertion pkg for Go, copied from github.com/stretchr/testify's require package.

I find early errors more useful than the t.Errorf() calls, which often fall through to nil pointers causing panics etc.

Documentation

Overview

Package assert implements the same assertions as the `assert` package but stops test execution when a test fails.

Example Usage

The following is a complete example using require in a standard test function: 

import (
  "testing"
  "github.com/stretchr/testify/require"
)

func TestSomething(t *testing.T) {

  var a string = "Hello"
  var b string = "Hello"

  require.Equal(t, a, b, "The two words should be the same.")

}

Assertions

The `require` package have same global functions as in the `assert` package, but instead of returning a boolean result they call `t.FailNow()`.

Every assertion function also takes an optional string message as the final argument, allowing custom error messages to be appended to the message the assertion method outputs.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Condition 

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

Condition uses a Comparison to assert a complex condition.

func Contains 

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

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

assert.Contains(t, "Hello World", "World")
assert.Contains(t, ["Hello", "World"], "World")
assert.Contains(t, {"Hello": "World"}, "Hello")

func DirExists 

func DirExists(t TestingT, path string, msgAndArgs ...interface{})

DirExists checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists.

func ElementsMatch 

func ElementsMatch(t TestingT, listA interface{}, listB interface{}, msgAndArgs ...interface{})

ElementsMatch asserts that the specified listA(array, slice...) is equal to specified listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, the number of appearances of each of them in both lists should match.

assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2])

func Empty 

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

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)

func Equal 

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

Equal asserts that two objects are equal. 

assert.Equal(t, 123, 123)

Pointer variable equality is determined based on the equality of the referenced values (as opposed to the memory addresses). Function equality cannot be determined and will always fail.

func EqualError 

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

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

actualObj, err := SomeFunction()
assert.EqualError(t, err,  expectedErrorString)

func EqualValues 

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

EqualValues asserts that two objects are equal or convertable to the same types and equal. 

assert.EqualValues(t, uint32(123), int32(123))

func Error 

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

Error asserts that a function returned an error (i.e. not `nil`). 

  actualObj, err := SomeFunction()
  if assert.Error(t, err) {
	   assert.Equal(t, expectedError, err)
  }

func Eventually 

func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{})

Eventually asserts that given condition will be met in waitFor time, periodically checking target function each tick. 

assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond)

func Exactly 

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

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

assert.Exactly(t, int32(123), int64(123))

func Fail 

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

Fail reports a failure through

func FailNow 

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

FailNow fails test

func False 

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

False asserts that the specified value is false. 

assert.False(t, myBool)

func FileExists 

func FileExists(t TestingT, path string, msgAndArgs ...interface{})

FileExists checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file.

func Greater 

func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{})

Greater asserts that the first element is greater than the second 

assert.Greater(t, 2, 1)
assert.Greater(t, float64(2), float64(1))
assert.Greater(t, "b", "a")

func GreaterOrEqual 

func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{})

GreaterOrEqual asserts that the first element is greater than or equal to the second 

assert.GreaterOrEqual(t, 2, 1)
assert.GreaterOrEqual(t, 2, 2)
assert.GreaterOrEqual(t, "b", "a")
assert.GreaterOrEqual(t, "b", "b")

func HTTPBodyContains 

func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{})

HTTPBodyContains asserts that a specified handler returns a body that contains a string. 

assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")

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

func HTTPBodyNotContains 

func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{})

HTTPBodyNotContains asserts that a specified handler returns a body that does not contain a string. 

assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")

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

func HTTPError 

func HTTPError(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{})

HTTPError asserts that a specified handler returns an error status code. 

assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}

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

func HTTPRedirect 

func HTTPRedirect(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{})

HTTPRedirect asserts that a specified handler returns a redirect status code. 

assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}

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

func HTTPStatusCode 

func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{})

HTTPStatusCode asserts that a specified handler returns a specified status code. 

assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)

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

func HTTPSuccess 

func HTTPSuccess(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{})

HTTPSuccess asserts that a specified handler returns a success status code. 

assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)

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

func Implements 

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

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

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

func InDelta 

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

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

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

func InDeltaMapValues 

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

InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.

func InDeltaSlice 

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

InDeltaSlice is the same as InDelta, except it compares two slices.

func InEpsilon 

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

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

func InEpsilonSlice 

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

InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.

func IsType 

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

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

func JSONEq 

func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{})

JSONEq asserts that two JSON strings are equivalent. 

assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)

func Len 

func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{})

Len asserts that the specified object has specific length. Len also fails if the object has a type that len() not accept. 

assert.Len(t, mySlice, 3)

func Less 

func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{})

Less asserts that the first element is less than the second 

assert.Less(t, 1, 2)
assert.Less(t, float64(1), float64(2))
assert.Less(t, "a", "b")

func LessOrEqual 

func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{})

LessOrEqual asserts that the first element is less than or equal to the second 

assert.LessOrEqual(t, 1, 2)
assert.LessOrEqual(t, 2, 2)
assert.LessOrEqual(t, "a", "b")
assert.LessOrEqual(t, "b", "b")

func Never 

func Never(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{})

Never asserts that the given condition doesn't satisfy in waitFor time, periodically checking the target function each tick. 

assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond)

func Nil 

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

Nil asserts that the specified object is nil. 

assert.Nil(t, err)

func NoDirExists 

func NoDirExists(t TestingT, path string, msgAndArgs ...interface{})

NoDirExists checks whether a directory does not exist in the given path. It fails if the path points to an existing _directory_ only.

func NoError 

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

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

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

func NoFileExists 

func NoFileExists(t TestingT, path string, msgAndArgs ...interface{})

NoFileExists checks whether a file does not exist in a given path. It fails if the path points to an existing _file_ only.

func NotContains 

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

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

assert.NotContains(t, "Hello World", "Earth")
assert.NotContains(t, ["Hello", "World"], "Earth")
assert.NotContains(t, {"Hello": "World"}, "Earth")

func NotEmpty 

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

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])
}

func NotEqual 

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

NotEqual asserts that the specified values are NOT equal. 

assert.NotEqual(t, obj1, obj2)

Pointer variable equality is determined based on the equality of the referenced values (as opposed to the memory addresses).

func NotEqualValues 

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

NotEqualValues asserts that two objects are not equal even when converted to the same type 

assert.NotEqualValues(t, obj1, obj2)

func NotNil 

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

NotNil asserts that the specified object is not nil. 

assert.NotNil(t, err)

func NotPanics 

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

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

assert.NotPanics(t, func(){ RemainCalm() })

func NotRegexp 

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

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

func NotSame 

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

NotSame asserts that two pointers do not reference the same object. 

assert.NotSame(t, ptr1, ptr2)

Both arguments must be pointer variables. Pointer variable sameness is determined based on the equality of both type and value.

func NotSubset 

func NotSubset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{})

NotSubset asserts that the specified list(array, slice...) contains not all elements given in the specified subset(array, slice...). 

assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")

func NotZero 

func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{})

NotZero asserts that i is not the zero value for its type.

func Panics 

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

Panics asserts that the code inside the specified PanicTestFunc panics. 

assert.Panics(t, func(){ GoCrazy() })

func PanicsWithError 

func PanicsWithError(t TestingT, errString string, f assert.PanicTestFunc, msgAndArgs ...interface{})

PanicsWithError asserts that the code inside the specified PanicTestFunc panics, and that the recovered panic value is an error that satisfies the EqualError comparison. 

assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() })

func PanicsWithValue 

func PanicsWithValue(t TestingT, expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{})

PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that the recovered panic value equals the expected panic value. 

assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() })

func Regexp 

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

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

func Same 

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

Same asserts that two pointers reference the same object. 

assert.Same(t, ptr1, ptr2)

Both arguments must be pointer variables. Pointer variable sameness is determined based on the equality of both type and value.

func Subset 

func Subset(t TestingT, list interface{}, subset interface{}, msgAndArgs ...interface{})

Subset asserts that the specified list(array, slice...) contains all elements given in the specified subset(array, slice...). 

assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")

func True 

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

True asserts that the specified value is true. 

assert.True(t, myBool)

func WithinDuration 

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

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

assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second)

func YAMLEq 

func YAMLEq(t TestingT, expected string, actual string, msgAndArgs ...interface{})

YAMLEq asserts that two YAML strings are equivalent.

func Zero 

func Zero(t TestingT, i interface{}, msgAndArgs ...interface{})

Zero asserts that i is the zero value for its type.

Types

type Assertions 

type Assertions struct {
	// contains filtered or unexported fields
}

Assertions provides assertion methods around the TestingT interface.

func New 

func New(t TestingT) *Assertions

New makes a new Assertions object for the specified TestingT.

func (*Assertions) Condition 

func (a *Assertions) Condition(comp assert.Comparison, msgAndArgs ...interface{})

Condition uses a Comparison to assert a complex condition.

func (*Assertions) Contains 

func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{})

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

a.Contains("Hello World", "World")
a.Contains(["Hello", "World"], "World")
a.Contains({"Hello": "World"}, "Hello")

func (*Assertions) DirExists 

func (a *Assertions) DirExists(path string, msgAndArgs ...interface{})

DirExists checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists.

func (*Assertions) ElementsMatch 

func (a *Assertions) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{})

ElementsMatch asserts that the specified listA(array, slice...) is equal to specified listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, the number of appearances of each of them in both lists should match.

a.ElementsMatch([1, 3, 2, 3], [1, 3, 3, 2])

func (*Assertions) Empty 

func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{})

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

a.Empty(obj)

func (*Assertions) Equal 

func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{})

Equal asserts that two objects are equal. 

a.Equal(123, 123)

Pointer variable equality is determined based on the equality of the referenced values (as opposed to the memory addresses). Function equality cannot be determined and will always fail.

func (*Assertions) EqualError 

func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{})

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

actualObj, err := SomeFunction()
a.EqualError(err,  expectedErrorString)

func (*Assertions) EqualValues 

func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{})

EqualValues asserts that two objects are equal or convertable to the same types and equal. 

a.EqualValues(uint32(123), int32(123))

func (*Assertions) Error 

func (a *Assertions) Error(err error, msgAndArgs ...interface{})

Error asserts that a function returned an error (i.e. not `nil`). 

  actualObj, err := SomeFunction()
  if a.Error(err) {
	   assert.Equal(t, expectedError, err)
  }

func (*Assertions) Eventually 

func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{})

Eventually asserts that given condition will be met in waitFor time, periodically checking target function each tick. 

a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond)

func (*Assertions) Exactly 

func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{})

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

a.Exactly(int32(123), int64(123))

func (*Assertions) Fail 

func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{})

Fail reports a failure through

func (*Assertions) FailNow 

func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{})

FailNow fails test

func (*Assertions) False 

func (a *Assertions) False(value bool, msgAndArgs ...interface{})

False asserts that the specified value is false. 

a.False(myBool)

func (*Assertions) FileExists 

func (a *Assertions) FileExists(path string, msgAndArgs ...interface{})

FileExists checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file.

func (*Assertions) Greater 

func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...interface{})

Greater asserts that the first element is greater than the second 

a.Greater(2, 1)
a.Greater(float64(2), float64(1))
a.Greater("b", "a")

func (*Assertions) GreaterOrEqual 

func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{})

GreaterOrEqual asserts that the first element is greater than or equal to the second 

a.GreaterOrEqual(2, 1)
a.GreaterOrEqual(2, 2)
a.GreaterOrEqual("b", "a")
a.GreaterOrEqual("b", "b")

func (*Assertions) HTTPBodyContains 

func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{})

HTTPBodyContains asserts that a specified handler returns a body that contains a string. 

a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")

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

func (*Assertions) HTTPBodyNotContains 

func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{})

HTTPBodyNotContains asserts that a specified handler returns a body that does not contain a string. 

a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")

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

func (*Assertions) HTTPError 

func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{})

HTTPError asserts that a specified handler returns an error status code. 

a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}

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

func (*Assertions) HTTPRedirect 

func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{})

HTTPRedirect asserts that a specified handler returns a redirect status code. 

a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}

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

func (*Assertions) HTTPStatusCode 

func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{})

HTTPStatusCode asserts that a specified handler returns a specified status code. 

a.HTTPStatusCode(myHandler, "GET", "/notImplemented", nil, 501)

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

func (*Assertions) HTTPSuccess 

func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{})

HTTPSuccess asserts that a specified handler returns a success status code. 

a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)

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

func (*Assertions) Implements 

func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{})

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

a.Implements((*MyInterface)(nil), new(MyObject))

func (*Assertions) InDelta 

func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{})

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

a.InDelta(math.Pi, 22/7.0, 0.01)

func (*Assertions) InDeltaMapValues 

func (a *Assertions) InDeltaMapValues(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{})

InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.

func (*Assertions) InDeltaSlice 

func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{})

InDeltaSlice is the same as InDelta, except it compares two slices.

func (*Assertions) InEpsilon 

func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{})

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

func (*Assertions) InEpsilonSlice 

func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{})

InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.

func (*Assertions) IsType 

func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{})

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

func (*Assertions) JSONEq 

func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{})

JSONEq asserts that two JSON strings are equivalent. 

a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)

func (*Assertions) Len 

func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{})

Len asserts that the specified object has specific length. Len also fails if the object has a type that len() not accept. 

a.Len(mySlice, 3)

func (*Assertions) Less 

func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interface{})

Less asserts that the first element is less than the second 

a.Less(1, 2)
a.Less(float64(1), float64(2))
a.Less("a", "b")

func (*Assertions) LessOrEqual 

func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{})

LessOrEqual asserts that the first element is less than or equal to the second 

a.LessOrEqual(1, 2)
a.LessOrEqual(2, 2)
a.LessOrEqual("a", "b")
a.LessOrEqual("b", "b")

func (*Assertions) Never 

func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{})

Never asserts that the given condition doesn't satisfy in waitFor time, periodically checking the target function each tick. 

a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond)

func (*Assertions) Nil 

func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{})

Nil asserts that the specified object is nil. 

a.Nil(err)

func (*Assertions) NoDirExists 

func (a *Assertions) NoDirExists(path string, msgAndArgs ...interface{})

NoDirExists checks whether a directory does not exist in the given path. It fails if the path points to an existing _directory_ only.

func (*Assertions) NoError 

func (a *Assertions) NoError(err error, msgAndArgs ...interface{})

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

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

func (*Assertions) NoFileExists 

func (a *Assertions) NoFileExists(path string, msgAndArgs ...interface{})

NoFileExists checks whether a file does not exist in a given path. It fails if the path points to an existing _file_ only.

func (*Assertions) NotContains 

func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{})

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

a.NotContains("Hello World", "Earth")
a.NotContains(["Hello", "World"], "Earth")
a.NotContains({"Hello": "World"}, "Earth")

func (*Assertions) NotEmpty 

func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{})

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 a.NotEmpty(obj) {
  assert.Equal(t, "two", obj[1])
}

func (*Assertions) NotEqual 

func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{})

NotEqual asserts that the specified values are NOT equal. 

a.NotEqual(obj1, obj2)

Pointer variable equality is determined based on the equality of the referenced values (as opposed to the memory addresses).

func (*Assertions) NotEqualValues 

func (a *Assertions) NotEqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{})

NotEqualValues asserts that two objects are not equal even when converted to the same type 

a.NotEqualValues(obj1, obj2)

func (*Assertions) NotNil 

func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{})

NotNil asserts that the specified object is not nil. 

a.NotNil(err)

func (*Assertions) NotPanics 

func (a *Assertions) NotPanics(f assert.PanicTestFunc, msgAndArgs ...interface{})

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

a.NotPanics(func(){ RemainCalm() })

func (*Assertions) NotRegexp 

func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{})

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

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

func (*Assertions) NotSame 

func (a *Assertions) NotSame(expected interface{}, actual interface{}, msgAndArgs ...interface{})

NotSame asserts that two pointers do not reference the same object. 

a.NotSame(ptr1, ptr2)

Both arguments must be pointer variables. Pointer variable sameness is determined based on the equality of both type and value.

func (*Assertions) NotSubset 

func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{})

NotSubset asserts that the specified list(array, slice...) contains not all elements given in the specified subset(array, slice...). 

a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")

func (*Assertions) NotZero 

func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{})

NotZero asserts that i is not the zero value for its type.

func (*Assertions) Panics 

func (a *Assertions) Panics(f assert.PanicTestFunc, msgAndArgs ...interface{})

Panics asserts that the code inside the specified PanicTestFunc panics. 

a.Panics(func(){ GoCrazy() })

func (*Assertions) PanicsWithError 

func (a *Assertions) PanicsWithError(errString string, f assert.PanicTestFunc, msgAndArgs ...interface{})

PanicsWithError asserts that the code inside the specified PanicTestFunc panics, and that the recovered panic value is an error that satisfies the EqualError comparison. 

a.PanicsWithError("crazy error", func(){ GoCrazy() })

func (*Assertions) PanicsWithValue 

func (a *Assertions) PanicsWithValue(expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{})

PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that the recovered panic value equals the expected panic value. 

a.PanicsWithValue("crazy error", func(){ GoCrazy() })

func (*Assertions) Regexp 

func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{})

Regexp asserts that a specified regexp matches a string. 

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

func (*Assertions) Same 

func (a *Assertions) Same(expected interface{}, actual interface{}, msgAndArgs ...interface{})

Same asserts that two pointers reference the same object. 

a.Same(ptr1, ptr2)

Both arguments must be pointer variables. Pointer variable sameness is determined based on the equality of both type and value.

func (*Assertions) Subset 

func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{})

Subset asserts that the specified list(array, slice...) contains all elements given in the specified subset(array, slice...). 

a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")

func (*Assertions) True 

func (a *Assertions) True(value bool, msgAndArgs ...interface{})

True asserts that the specified value is true. 

a.True(myBool)

func (*Assertions) WithinDuration 

func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{})

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

a.WithinDuration(time.Now(), time.Now(), 10*time.Second)

func (*Assertions) YAMLEq 

func (a *Assertions) YAMLEq(expected string, actual string, msgAndArgs ...interface{})

YAMLEq asserts that two YAML strings are equivalent.

func (*Assertions) Zero 

func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{})

Zero asserts that i is the zero value for its type.

type TestingT 

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

TestingT is an interface wrapper around *testing.T

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.