False asserts that the specified value is false. assert.False(t, myBool)

Error asserts that a function returned an error (i.e. not `nil`). actualObj, err := SomeFunction() if a.Error(err) { assert.Equal(t, expec

On chains a new expectation description onto the mocked interface. This allows syntax like. Mock. On("MyMethod", 1).Return(nil). On("MyOther

Equal asserts that two objects are equal. assert.Equal(t, 123, 123) Pointer variable equality is determined based on the equality of the referenced

Return specifies the return arguments for the expectation. Mock.On("DoSomething").Return(errors.New("failed"))

Fail reports a failure through

True asserts that the specified value is true. assert.True(t, myBool)

New makes a new Assertions object for the specified TestingT.

New makes a new Assertions object for the specified TestingT.

Called tells the mock object that a method has been called, and gets an array of arguments to return. Panics if the call is unexpected (i.e. not prec

Contains asserts that the specified string, list(array, slice...) or map contains the specified substring or element. assert.Contains(t, "Hello Worl

Equal asserts that two objects are equal. require.Equal(t, 123, 123) Pointer variable equality is determined based on the equality of the reference

Once indicates that the mock should only return the value once. Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Once()

Panics asserts that the code inside the specified PanicTestFunc panics. assert.Panics(t, func(){ GoCrazy() })

False asserts that the specified value is false. a.False(myBool)

True asserts that the specified value is true. a.True(myBool)

Error gets the argument at the specified index. Panics if there is no argument, or if the argument is of the wrong type.

Contains asserts that the specified string, list(array, slice...) or map contains the specified substring or element. a.Contains("Hello World", "Wor

Diff gets a string describing the differences between the arguments and the specified objects. Returns the diff string and number of differences foun

NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. assert.NotPanics(t, func(){ RemainCalm() })

Regexp asserts that a specified regexp matches a string. assert.Regexp(t, regexp.MustCompile("start"), "it's starting") assert.Regexp(t, "start...$

JSONEq asserts that two JSON strings are equivalent. assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)

NotNil asserts that the specified object is not nil. assert.NotNil(t, err)

YAMLEq asserts that two YAML strings are equivalent.

Get Returns the argument at the specified index.

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)

* Helper functions */ ObjectsAreEqual determines if two objects are considered equal. This function does no assertion of any kind.

JSONEq asserts that two JSON strings are equivalent. require.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)

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)

MatchedBy can be used to match a mock call based on only certain properties from a complex struct or some calculation. It takes a function that will b

YAMLEq asserts that two YAML strings are equivalent.

EqualError asserts that a function returned an error (i.e. not `nil`) and that it is equal to the provided error. actualObj, err := SomeFunction()

JSONEq asserts that two JSON strings are equivalent. a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)

JSONEq asserts that two JSON strings are equivalent. a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)

Nil asserts that the specified object is nil. assert.Nil(t, err)

String provides a %v format string for Mock. Note: this is used implicitly by Arguments.Diff if a Mock is passed. It exists because go's default %v fo

go:noinline

YAMLEq asserts that two YAML strings are equivalent.

YAMLEq asserts that two YAML strings are equivalent.

AnythingOfType returns a special value containing the name of the type to check for. The type name will be matched against the type name returned by [

NotEqual asserts that the specified values are NOT equal. assert.NotEqual(t, obj1, obj2) Pointer variable equality is determined based on the equal

Run takes a testing suite and runs all of the tests attached to it.

Equal asserts that two objects are equal. a.Equal(123, 123) Pointer variable equality is determined based on the equality of the referenced values

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

NotBefore indicates that the mock should only be called after the referenced calls have been called as expected. The referenced calls may be from the

NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. require.NotPanics(t, func(){ RemainCalm() })

Deprecated: Use [net/http/httptest] instead.

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

Twice indicates that the mock should only return the value twice. Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Twice()

diff returns a diff of both values as long as both are of the same type and are a struct, map, slice, array or string. Otherwise it returns an empty s

After sets how long to block until the call returns Mock.On("MyMethod", arg1, arg2).After(time.Second)

* CallerInfo is necessary because the assert functions use the testing object internally, causing it to print the file:line of the assert method, rath

Equal asserts that two objects are equal. a.Equal(123, 123) Pointer variable equality is determined based on the equality of the referenced values

Error asserts that a function returned an error (i.e. not `nil`). actualObj, err := SomeFunction() if assert.Error(t, err) { assert.Equal(

Eventually asserts that given condition will be met in waitFor time, periodically checking target function each tick. assert.Eventually(t, func() bo

HTTPSuccess asserts that a specified handler returns a success status code. assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)

InDelta asserts that the two numerals are within delta of each other. assert.InDelta(t, math.Pi, 22/7.0, 0.01)

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

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

ObjectsAreEqualValues gets whether two objects are equal, or if their values are equal.

Unset removes a mock handler from being called. test.On("func", mock.Anything).Unset()

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

didPanic returns true if the function passed to it panics. Otherwise, it returns false.

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)

FailNow fails test

FunctionalOptions returns an [FunctionalOptionsArgument] object containing the expected functional-options to check for. For example: args.Assert(t

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

GreaterOrEqual asserts that the first element is greater than or equal to the second assert.GreaterOrEqual(t, 2, 1) assert.GreaterOrEqual(t, 2, 2)

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

IsDecreasing asserts that the collection is decreasing assert.IsDecreasing(t, []int{2, 1, 0}) assert.IsDecreasing(t, []float{2, 1}) assert.IsDecre

IsIncreasing asserts that the collection is increasing assert.IsIncreasing(t, []int{1, 2, 3}) assert.IsIncreasing(t, []float{1, 2}) assert.IsIncre

IsNonDecreasing asserts that the collection is not decreasing assert.IsNonDecreasing(t, []int{1, 1, 2}) assert.IsNonDecreasing(t, []float{1, 2}) a

IsNonIncreasing asserts that the collection is not increasing assert.IsNonIncreasing(t, []int{2, 1, 1}) assert.IsNonIncreasing(t, []float{2, 1}) a

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

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

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.Less

Negative asserts that the specified element is negative assert.Negative(t, -1) assert.Negative(t, -1.23)

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

NotSubset asserts that the specified list(array, slice...) or map does NOT contain all elements given in the specified subset list(array, slice...) or

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

Positive asserts that the specified element is positive assert.Positive(t, 1) assert.Positive(t, 1.23)