assertions

func CallerInfo ¶

func CallerInfo() []string

CallerInfo returns an array of strings containing the file and line number of each stack frame leading from the current test to the assert call that failed.

func Condition ¶

func Condition(t T, comp Comparison, msgAndArgs ...any) bool

Condition uses a Comparison to assert a complex condition.

Usage ¶

assertions.Condition(t, func() bool { return myCondition })

Examples ¶

success:  func() bool { return true }
failure:  func() bool { return false }

func Contains ¶

func Contains(t T, s, contains any, msgAndArgs ...any) bool

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

Usage ¶

assertions.Contains(t, "Hello World", "World")
assertions.Contains(t, []string{"Hello", "World"}, "World")
assertions.Contains(t, map[string]string{"Hello": "World"}, "Hello")

Examples ¶

success: []string{"A","B"}, "A"
failure: []string{"A","B"}, "C"

func DirExists ¶

func DirExists(t T, path string, msgAndArgs ...any) bool

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.

Usage ¶

assertions.DirExists(t, "path/to/directory")

Examples ¶

success: filepath.Join(testDataPath(),"existing_dir")
failure: filepath.Join(testDataPath(),"non_existing_dir")

func ElementsMatch ¶

func ElementsMatch(t T, listA, listB any, msgAndArgs ...any) (ok bool)

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.

Usage ¶

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

Examples ¶

success: []int{1, 3, 2, 3}, []int{1, 3, 3, 2}
failure: []int{1, 2, 3}, []int{1, 2, 4}

func Empty ¶

func Empty(t T, object any, msgAndArgs ...any) bool

Empty asserts that the given value is "empty".

Zero values are "empty".

Arrays are "empty" if every element is the zero value of the type (stricter than "empty").

Slices, maps and channels with zero length are "empty".

Pointer values are "empty" if the pointer is nil or if the pointed value is "empty".

Usage ¶

assertions.Empty(t, obj)

Examples ¶

success: ""
failure: "not empty"

func Equal ¶

func Equal(t T, expected, actual any, msgAndArgs ...any) bool

Equal asserts that two objects are equal.

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.

Usage ¶

assertions.Equal(t, 123, 123)

Examples ¶

success: 123, 123
failure: 123, 456

func EqualError ¶

func EqualError(t T, theError error, errString string, msgAndArgs ...any) bool

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

Usage ¶

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

Examples ¶

success: ErrTest, "assert.ErrTest general error for testing"
failure: ErrTest, "wrong error message"

func EqualExportedValues ¶

func EqualExportedValues(t T, expected, actual any, msgAndArgs ...any) bool

EqualExportedValues asserts that the types of two objects are equal and their public fields are also equal. This is useful for comparing structs that have private fields that could potentially differ.

Usage ¶

 type S struct {
	Exported     	int
	notExported   	int
 }
assertions.EqualExportedValues(t, S{1, 2}, S{1, 3}) => true
assertions.EqualExportedValues(t, S{1, 2}, S{2, 3}) => false

Examples ¶

success: &dummyStruct{A: "a", b: 1}, &dummyStruct{A: "a", b: 2}
failure:  &dummyStruct{A: "a", b: 1}, &dummyStruct{A: "b", b: 1}

func EqualValues ¶

func EqualValues(t T, expected, actual any, msgAndArgs ...any) bool

EqualValues asserts that two objects are equal or convertible to the larger type and equal.

Usage ¶

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

Examples ¶

success: uint32(123), int32(123)
failure: uint32(123), int32(456)

func Error ¶

func Error(t T, err error, msgAndArgs ...any) bool

Error asserts that a function returned a non-nil error (ie. an error).

Usage ¶

actualObj, err := SomeFunction()
assertions.Error(t, err)

Examples ¶

success: ErrTest
failure: nil

func ErrorAs ¶

func ErrorAs(t T, err error, target any, msgAndArgs ...any) bool

ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value.

This is a wrapper for errors.As.

Usage ¶

assertions.ErrorAs(t, err, &target)

Examples ¶

success: fmt.Errorf("wrap: %w", &dummyError{}), new(*dummyError)
failure: ErrTest, new(*dummyError)

func ErrorContains ¶

func ErrorContains(t T, theError error, contains string, msgAndArgs ...any) bool

ErrorContains asserts that a function returned a non-nil error (i.e. an error) and that the error contains the specified substring.

Usage ¶

actualObj, err := SomeFunction()
assertions.ErrorContains(t, err,  expectedErrorSubString)

Examples ¶

success: ErrTest, "general error"
failure: ErrTest, "not in message"

func ErrorIs ¶

func ErrorIs(t T, err, target error, msgAndArgs ...any) bool

ErrorIs asserts that at least one of the errors in err's chain matches target.

This is a wrapper for errors.Is.

Usage ¶

assertions.ErrorIs(t, err, io.EOF)

Examples ¶

success: fmt.Errorf("wrap: %w", io.EOF), io.EOF
failure: ErrTest, io.EOF

func Eventually ¶

func Eventually(t T, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...any) bool

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

Usage ¶

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

Examples ¶

success:  func() bool { return true }, 100*time.Millisecond, 20*time.Millisecond
failure:  func() bool { return false }, 100*time.Millisecond, 20*time.Millisecond

func EventuallyWithT ¶

func EventuallyWithT(t T, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msgAndArgs ...any) bool

EventuallyWithT asserts that given condition will be met in waitFor time, periodically checking target function each tick. In contrast to Eventually, it supplies a CollectT to the condition function, so that the condition function can use the CollectT to call other assertions. The condition is considered "met" if no errors are raised in a tick. The supplied CollectT collects all errors from one tick (if there are any). If the condition is not met before waitFor, the collected errors of the last tick are copied to t.

Usage ¶

externalValue := false
go func() {
	time.Sleep(8*time.Second)
	externalValue = true
}()
assertions.EventuallyWithT(t, func(c *assertions.CollectT) {
	// add assertions as needed; any assertion failure will fail the current tick
	assertions.True(c, externalValue, "expected 'externalValue' to be true")
}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")

Examples ¶

success: func(c *CollectT) { True(c,true) }, 100*time.Millisecond, 20*time.Millisecond
failure: func(c *CollectT) { False(c,true) }, 100*time.Millisecond, 20*time.Millisecond

func Exactly ¶

func Exactly(t T, expected, actual any, msgAndArgs ...any) bool

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

Usage ¶

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

Examples ¶

success: int32(123), int32(123)
failure: int32(123), int64(123)

func Fail ¶

func Fail(t T, failureMessage string, msgAndArgs ...any) bool

Fail reports a failure through.

Usage ¶

assertions.Fail(t, "failed")

Examples ¶

failure: "failed"

func FailNow ¶

func FailNow(t T, failureMessage string, msgAndArgs ...any) bool

FailNow fails test.

Usage ¶

assertions.FailNow(t, "failed")

Examples ¶

failure: "failed"

func False ¶

func False(t T, value bool, msgAndArgs ...any) bool

False asserts that the specified value is false.

Usage ¶

assertions.False(t, myBool)

Examples ¶

success: 1 == 0
failure: 1 == 1

func FileEmpty ¶

func FileEmpty(t T, path string, msgAndArgs ...any) bool

FileEmpty checks whether a file exists in the given path and is empty. It fails if the file is not empty, if the path points to a directory or there is an error when trying to check the file.

Usage ¶

assertions.FileEmpty(t, "path/to/file")

Examples ¶

success: filepath.Join(testDataPath(),"empty_file")
failure: filepath.Join(testDataPath(),"existing_file")

func FileExists ¶

func FileExists(t T, path string, msgAndArgs ...any) bool

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.

Usage ¶

assertions.FileExists(t, "path/to/file")

Examples ¶

success: filepath.Join(testDataPath(),"existing_file")
failure: filepath.Join(testDataPath(),"non_existing_file")

func FileNotEmpty ¶

func FileNotEmpty(t T, path string, msgAndArgs ...any) bool

FileNotEmpty checks whether a file exists in the given path and is not empty. It fails if the file is empty, if the path points to a directory or there is an error when trying to check the file.

Usage ¶

assertions.FileNotEmpty(t, "path/to/file")

Examples ¶

success: filepath.Join(testDataPath(),"existing_file")
failure: filepath.Join(testDataPath(),"empty_file")

func Greater ¶

func Greater(t T, e1 any, e2 any, msgAndArgs ...any) bool

Greater asserts that the first element is strictly greater than the second.

Usage ¶

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

Examples ¶

success: 2, 1
failure: 1, 2

func GreaterOrEqual ¶

func GreaterOrEqual(t T, e1 any, e2 any, msgAndArgs ...any) bool

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

Usage ¶

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

Examples ¶

success: 2, 1
failure: 1, 2

func HTTPBody ¶

func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) string

HTTPBody is a helper that returns the HTTP body of the response. It returns the empty string if building a new request fails.

func HTTPBodyContains ¶

func HTTPBodyContains(t T, handler http.HandlerFunc, method, url string, values url.Values, str any, msgAndArgs ...any) bool

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

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

Usage ¶

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

Examples ¶

success: httpBody, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!"
failure: httpBody, "GET", "/", url.Values{"name": []string{"Bob"}}, "Hello, World!"

func HTTPBodyNotContains ¶

func HTTPBodyNotContains(t T, handler http.HandlerFunc, method, url string, values url.Values, str any, msgAndArgs ...any) bool

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

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

Usage ¶

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

Examples ¶

success: httpBody, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, Bob!"
failure: httpBody, "GET", "/", url.Values{"name": []string{"Bob"}}, "Hello, Bob!"

func HTTPError ¶

func HTTPError(t T, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...any) bool

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

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

Usage ¶

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

Examples ¶

success: httpError, "GET", "/", nil
failure: httpOK, "GET", "/", nil

func HTTPRedirect ¶

func HTTPRedirect(t T, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...any) bool

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

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

Usage ¶

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

Examples ¶

success: httpRedirect, "GET", "/", nil
failure: httpError, "GET", "/", nil

func HTTPStatusCode ¶

func HTTPStatusCode(t T, handler http.HandlerFunc, method, url string, values url.Values, statuscode int, msgAndArgs ...any) bool

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

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

Usage ¶

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

Examples ¶

success: httpOK, "GET", "/", nil, http.StatusOK
failure: httpError, "GET", "/", nil, http.StatusOK

func HTTPSuccess ¶

func HTTPSuccess(t T, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...any) bool

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

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

Usage ¶

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

Examples ¶

success: httpOK, "GET", "/", nil
failure: httpError, "GET", "/", nil

func Implements ¶

func Implements(t T, interfaceObject any, object any, msgAndArgs ...any) bool

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

Usage ¶

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

Examples ¶

success: ptr(dummyInterface), new(testing.T)
failure: (*error)(nil), new(testing.T)

func InDelta ¶

func InDelta(t T, expected, actual any, delta float64, msgAndArgs ...any) bool

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

Usage ¶

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

Examples ¶

success: 1.0, 1.01, 0.02
failure: 1.0, 1.1, 0.05

func InDeltaMapValues ¶

func InDeltaMapValues(t T, expected, actual any, delta float64, msgAndArgs ...any) bool

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

Usage ¶

assertions.InDeltaMapValues(t, map[string]float64{"a": 1.0}, map[string]float64{"a": 1.01}, 0.02)

Examples ¶

success: map[string]float64{"a": 1.0}, map[string]float64{"a": 1.01}, 0.02
failure: map[string]float64{"a": 1.0}, map[string]float64{"a": 1.1}, 0.05

func InDeltaSlice ¶

func InDeltaSlice(t T, expected, actual any, delta float64, msgAndArgs ...any) bool

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

Usage ¶

assertions.InDeltaSlice(t, []float64{1.0, 2.0}, []float64{1.01, 2.01}, 0.02)

Examples ¶

success: []float64{1.0, 2.0}, []float64{1.01, 2.01}, 0.02
failure: []float64{1.0, 2.0}, []float64{1.1, 2.1}, 0.05

func InEpsilon ¶

func InEpsilon(t T, expected, actual any, epsilon float64, msgAndArgs ...any) bool

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

Usage ¶

assertions.InEpsilon(t, 100.0, 101.0, 0.02)

Examples ¶

success: 100.0, 101.0, 0.02
failure: 100.0, 110.0, 0.05

func InEpsilonSlice ¶

func InEpsilonSlice(t T, expected, actual any, epsilon float64, msgAndArgs ...any) bool

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

Usage ¶

assertions.InEpsilonSlice(t, []float64{100.0, 200.0}, []float64{101.0, 202.0}, 0.02)

Examples ¶

success: []float64{100.0, 200.0}, []float64{101.0, 202.0}, 0.02
failure: []float64{100.0, 200.0}, []float64{110.0, 220.0}, 0.05

func IsDecreasing ¶

func IsDecreasing(t T, object any, msgAndArgs ...any) bool

IsDecreasing asserts that the collection is decreasing.

Usage ¶

assertions.IsDecreasing(t, []int{2, 1, 0})
assertions.IsDecreasing(t, []float{2, 1})
assertions.IsDecreasing(t, []string{"b", "a"})

Examples ¶

success: []int{3, 2, 1}
failure: []int{1, 2, 3}

func IsIncreasing ¶

func IsIncreasing(t T, object any, msgAndArgs ...any) bool

IsIncreasing asserts that the collection is increasing.

Usage ¶

assertions.IsIncreasing(t, []int{1, 2, 3})
assertions.IsIncreasing(t, []float{1, 2})
assertions.IsIncreasing(t, []string{"a", "b"})

Examples ¶

success: []int{1, 2, 3}
failure: []int{1, 1, 2}

func IsNonDecreasing ¶

func IsNonDecreasing(t T, object any, msgAndArgs ...any) bool

IsNonDecreasing asserts that the collection is not decreasing.

Usage ¶

assertions.IsNonDecreasing(t, []int{1, 1, 2})
assertions.IsNonDecreasing(t, []float{1, 2})
assertions.IsNonDecreasing(t, []string{"a", "b"})

Examples ¶

success: []int{1, 1, 2}
failure: []int{2, 1, 1}

func IsNonIncreasing ¶

func IsNonIncreasing(t T, object any, msgAndArgs ...any) bool

IsNonIncreasing asserts that the collection is not increasing.

Usage ¶

assertions.IsNonIncreasing(t, []int{2, 1, 1})
assertions.IsNonIncreasing(t, []float{2, 1})
assertions.IsNonIncreasing(t, []string{"b", "a"})

Examples ¶

success: []int{2, 1, 1}
failure: []int{1, 2, 3}

func IsNotType ¶

func IsNotType(t T, theType, object any, msgAndArgs ...any) bool

IsNotType asserts that the specified objects are not of the same type.

Usage ¶

assertions.IsNotType(t, &NotMyStruct{}, &MyStruct{})

Examples ¶

success: int32(123), int64(456)
failure: 123, 456

func IsType ¶

func IsType(t T, expectedType, object any, msgAndArgs ...any) bool

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

Usage ¶

assertions.IsType(t, &MyStruct{}, &MyStruct{})

Examples ¶

success: 123, 456
failure: int32(123), int64(456)

func JSONEq ¶

func JSONEq(t T, expected, actual string, msgAndArgs ...any) bool

JSONEq asserts that two JSON strings are equivalent.

Usage ¶

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

Examples ¶

success: `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`
failure: `{"hello": "world", "foo": "bar"}`, `[{"foo": "bar"}, {"hello": "world"}]`

func JSONEqBytes ¶

func JSONEqBytes(t T, expected, actual []byte, msgAndArgs ...any) bool

JSONEqBytes asserts that two JSON byte slices are equivalent.

Usage ¶

assertions.JSONEqBytes(t, []byte(`{"hello": "world", "foo": "bar"}`), []byte(`{"foo": "bar", "hello": "world"}`))

Examples ¶

success: []byte(`{"hello": "world", "foo": "bar"}`), []byte(`{"foo": "bar", "hello": "world"}`)
failure: []byte(`{"hello": "world", "foo": "bar"}`), []byte(`[{"foo": "bar"}, {"hello": "world"}]`)

func Len ¶

func Len(t T, object any, length int, msgAndArgs ...any) bool

Len asserts that the specified object has specific length.

Len also fails if the object has a type that len() does not accept.

The asserted object can be a string, a slice, a map, an array or a channel.

See also reflect.Len.

Usage ¶

assertions.Len(t, mySlice, 3)
assertions.Len(t, myString, 4)
assertions.Len(t, myMap, 5)

Examples ¶

success: []string{"A","B"}, 2
failure: []string{"A","B"}, 1

func Less ¶

func Less(t T, e1 any, e2 any, msgAndArgs ...any) bool

Less asserts that the first element is strictly less than the second.

Usage ¶

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

Examples ¶

success: 1, 2
failure: 2, 1

func LessOrEqual ¶

func LessOrEqual(t T, e1 any, e2 any, msgAndArgs ...any) bool

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

Usage ¶

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

Examples ¶

success: 1, 2
failure: 2, 1

func Negative ¶

func Negative(t T, e any, msgAndArgs ...any) bool

Negative asserts that the specified element is strictly negative.

Usage ¶

assertions.Negative(t, -1)
assertions.Negative(t, -1.23)

Examples ¶

success: -1
failure: 1

func Never ¶

func Never(t T, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...any) bool

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

Usage ¶

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

Examples ¶

success:  func() bool { return false }, 100*time.Millisecond, 20*time.Millisecond
failure:  func() bool { return true }, 100*time.Millisecond, 20*time.Millisecond

func Nil ¶

func Nil(t T, object any, msgAndArgs ...any) bool

Nil asserts that the specified object is nil.

Usage ¶

assertions.Nil(t, err)

Examples ¶

success: nil
failure: "not nil"

func NoDirExists ¶

func NoDirExists(t T, path string, msgAndArgs ...any) bool

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

Usage ¶

assertions.NoDirExists(t, "path/to/directory")

Examples ¶

success: filepath.Join(testDataPath(),"non_existing_dir")
failure: filepath.Join(testDataPath(),"existing_dir")

func NoError ¶

func NoError(t T, err error, msgAndArgs ...any) bool

NoError asserts that a function returned a nil error (ie. no error).

Usage ¶

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

Examples ¶

success: nil
failure: ErrTest

func NoFileExists ¶

func NoFileExists(t T, path string, msgAndArgs ...any) bool

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

Usage ¶

assertions.NoFileExists(t, "path/to/file")

Examples ¶

success: filepath.Join(testDataPath(),"non_existing_file")
failure: filepath.Join(testDataPath(),"existing_file")

func NotContains ¶

func NotContains(t T, s, contains any, msgAndArgs ...any) bool

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

Usage ¶

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

Examples ¶

success: []string{"A","B"}, "C"
failure: []string{"A","B"}, "B"

func NotElementsMatch ¶

func NotElementsMatch(t T, listA, listB any, msgAndArgs ...any) (ok bool)

NotElementsMatch asserts that the specified listA(array, slice...) is NOT 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 not match. This is an inverse of ElementsMatch.

Usage ¶

assertions.NotElementsMatch(t, [1, 1, 2, 3], [1, 1, 2, 3]) -> false
assertions.NotElementsMatch(t, [1, 1, 2, 3], [1, 2, 3]) -> true
assertions.NotElementsMatch(t, [1, 2, 3], [1, 2, 4]) -> true

Examples ¶

success: []int{1, 2, 3}, []int{1, 2, 4}
failure: []int{1, 3, 2, 3}, []int{1, 3, 3, 2}

func NotEmpty ¶

func NotEmpty(t T, object any, msgAndArgs ...any) bool

NotEmpty asserts that the specified object is NOT Empty.

Usage ¶

if assert.NotEmpty(t, obj) {
	assertions.Equal(t, "two", obj[1])
}

Examples ¶

success: "not empty"
failure: ""

func NotEqual ¶

func NotEqual(t T, expected, actual any, msgAndArgs ...any) bool

NotEqual asserts that the specified values are NOT equal.

Usage ¶

assertions.NotEqual(t, obj1, obj2)

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

Examples ¶

success: 123, 456
failure: 123, 123

func NotEqualValues ¶

func NotEqualValues(t T, expected, actual any, msgAndArgs ...any) bool

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

Usage ¶

assertions.NotEqualValues(t, obj1, obj2)

Examples ¶

success: uint32(123), int32(456)
failure: uint32(123), int32(123)

func NotErrorAs ¶

func NotErrorAs(t T, err error, target any, msgAndArgs ...any) bool

NotErrorAs asserts that none of the errors in err's chain matches target, but if so, sets target to that error value.

Usage ¶

assertions.NotErrorAs(t, err, &target)

Examples ¶

success: ErrTest, new(*dummyError)
failure: fmt.Errorf("wrap: %w", &dummyError{}), new(*dummyError)

func NotErrorIs ¶

func NotErrorIs(t T, err, target error, msgAndArgs ...any) bool

NotErrorIs asserts that none of the errors in err's chain matches target.

This is a wrapper for errors.Is.

Usage ¶

assertions.NotErrorIs(t, err, io.EOF)

Examples ¶

success: ErrTest, io.EOF
failure: fmt.Errorf("wrap: %w", io.EOF), io.EOF

func NotImplements ¶

func NotImplements(t T, interfaceObject any, object any, msgAndArgs ...any) bool

NotImplements asserts that an object does not implement the specified interface.

Usage ¶

assertions.NotImplements(t, (*MyInterface)(nil), new(MyObject))

Examples ¶

success: (*error)(nil), new(testing.T)
failure: ptr(dummyInterface), new(testing.T)

func NotNil ¶

func NotNil(t T, object any, msgAndArgs ...any) bool

NotNil asserts that the specified object is not nil.

Usage ¶

assertions.NotNil(t, err)

Examples ¶

success: "not nil"
failure: nil

func NotPanics ¶

func NotPanics(t T, f PanicTestFunc, msgAndArgs ...any) bool

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

Usage ¶

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

Examples ¶

success: func() { }
failure: func() { panic("panicking") }

func NotRegexp ¶

func NotRegexp(t T, rx any, str any, msgAndArgs ...any) bool

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

Usage ¶

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

Examples ¶

success: "^start", "not starting"
failure: "^start", "starting"

func NotSame ¶

func NotSame(t T, expected, actual any, msgAndArgs ...any) bool

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

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

Usage ¶

assertions.NotSame(t, ptr1, ptr2)

Examples ¶

success: &staticVar, ptr("static string")
failure: &staticVar, staticVarPtr

func NotSubset ¶

func NotSubset(t T, list, subset any, msgAndArgs ...any) (ok bool)

NotSubset asserts that the list (array, slice, or map) does NOT contain all elements given in the subset (array, slice, or map). Map elements are key-value pairs unless compared with an array or slice where only the map key is evaluated.

Usage ¶

assertions.NotSubset(t, [1, 3, 4], [1, 2])
assertions.NotSubset(t, {"x": 1, "y": 2}, {"z": 3})
assertions.NotSubset(t, [1, 3, 4], {1: "one", 2: "two"})
assertions.NotSubset(t, {"x": 1, "y": 2}, ["z"])

Examples ¶

success: []int{1, 2, 3}, []int{4, 5}
failure: []int{1, 2, 3}, []int{1, 2}

func NotZero ¶

func NotZero(t T, i any, msgAndArgs ...any) bool

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

Usage ¶

assertions.NotZero(t, obj)

Examples ¶

success: 1
failure: 0

func ObjectsAreEqual ¶

func ObjectsAreEqual(expected, actual any) bool

ObjectsAreEqual determines if two objects are considered equal.

This function does no assertion of any kind.

func ObjectsAreEqualValues ¶

func ObjectsAreEqualValues(expected, actual any) bool

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

func Panics ¶

func Panics(t T, f PanicTestFunc, msgAndArgs ...any) bool

Panics asserts that the code inside the specified PanicTestFunc panics.

Usage ¶

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

Examples ¶

success: func() { panic("panicking") }
failure: func() { }

func PanicsWithError ¶

func PanicsWithError(t T, errString string, f PanicTestFunc, msgAndArgs ...any) bool

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

Usage ¶

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

Examples ¶

success: ErrTest.Error(), func() { panic(ErrTest) }
failure: ErrTest.Error(), func() { }

func PanicsWithValue ¶

func PanicsWithValue(t T, expected any, f PanicTestFunc, msgAndArgs ...any) bool

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

Usage ¶

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

Examples ¶

success: "panicking", func() { panic("panicking") }
failure: "panicking", func() { }

func Positive ¶

func Positive(t T, e any, msgAndArgs ...any) bool

Positive asserts that the specified element is strictly positive.

Usage ¶

assertions.Positive(t, 1)
assertions.Positive(t, 1.23)

Examples ¶

success: 1
failure: -1

func Regexp ¶

func Regexp(t T, rx any, str any, msgAndArgs ...any) bool

Regexp asserts that a specified regexp matches a string.

Usage ¶

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

Examples ¶

success: "^start", "starting"
failure: "^start", "not starting"

func Same ¶

func Same(t T, expected, actual any, msgAndArgs ...any) bool

Same asserts that two pointers reference the same object.

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

Usage ¶

assertions.Same(t, ptr1, ptr2)

Examples ¶

success: &staticVar, staticVarPtr
failure: &staticVar, ptr("static string")

func Subset ¶

func Subset(t T, list, subset any, msgAndArgs ...any) (ok bool)

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

Map elements are key-value pairs unless compared with an array or slice where only the map key is evaluated.

Usage ¶

assertions.Subset(t, [1, 2, 3], [1, 2])
assertions.Subset(t, {"x": 1, "y": 2}, {"x": 1})
assertions.Subset(t, [1, 2, 3], {1: "one", 2: "two"})
assertions.Subset(t, {"x": 1, "y": 2}, ["x"])

Examples ¶

success: []int{1, 2, 3}, []int{1, 2}
failure: []int{1, 2, 3}, []int{4, 5}

func True ¶

func True(t T, value bool, msgAndArgs ...any) bool

True asserts that the specified value is true.

Usage ¶

assertions.True(t, myBool)

Examples ¶

success: 1 == 1
failure: 1 == 0

func WithinDuration ¶

func WithinDuration(t T, expected, actual time.Time, delta time.Duration, msgAndArgs ...any) bool

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

Usage ¶

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

Examples ¶

success: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 12, 0, 1, 0, time.UTC), 2*time.Second
failure: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 12, 0, 10, 0, time.UTC), 1*time.Second

func WithinRange ¶

func WithinRange(t T, actual, start, end time.Time, msgAndArgs ...any) bool

WithinRange asserts that a time is within a time range (inclusive).

Usage ¶

assertions.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))

Examples ¶

success: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 11, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 13, 0, 0, 0, time.UTC)
failure: time.Date(2024, 1, 1, 14, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 11, 0, 0, 0, time.UTC), time.Date(2024, 1, 1, 13, 0, 0, 0, time.UTC)

func YAMLEq ¶

func YAMLEq(t T, expected string, actual string, msgAndArgs ...any) bool

YAMLEq asserts that the first documents in the two YAML strings are equivalent.

Usage ¶

expected := `---
key: value
---
key: this is a second document, it is not evaluated
`
actual := `---
key: value
---
key: this is a subsequent document, it is not evaluated
`
assertions.YAMLEq(t, expected, actual)

Examples ¶

panic: "key: value", "key: value"
should panic without the yaml feature enabled.

func Zero ¶

func Zero(t T, i any, msgAndArgs ...any) bool

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

Usage ¶

assertions.Zero(t, obj)

Examples ¶

success: 0
failure: 1