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

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

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

Fail reports a failure through

New makes a new Assertions object for the specified TestingT.

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

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

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

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

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

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

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

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

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)

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

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

Execute takes an ASTNode and input data and interprets the AST directly. It will produce the result of applying the JMESPath expression associated wit

String gets the argument at the specified index. Panics if there is no argument, or if the argument is of the wrong type. If no index is provided, St

isEmpty gets whether the specified object is considered empty or not.

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

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

Search evaluates a JMESPath expression against input data and returns the result.

ElementsMatch asserts that the specified listA(array, slice...) is equal to specified listB(array, slice...) ignoring the order of the elements. If th

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)

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

AnythingOfType returns an AnythingOfTypeArgument object containing the name of the type to check for. Used in Diff and Assert. For example: Assert(

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

Get Returns the argument at the specified index.

Parse will compile a JMESPath expression.

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

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

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

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

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

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

containsElement try loop over the list check if the list includes the element. return (false, false) if impossible. return (true, false) if element wa

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

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

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

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

IsFalse determines if an object is false based on the JMESPath spec. JMESPath defines false values to be any of: - An empty string array, or hash. - T

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

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

YAMLEq asserts that two YAML strings are equivalent.

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

JSONEq asserts that two JSON strings are equivalent. assert.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)

Subset asserts that the specified list(array, slice...) contains all elements given in the specified subset(array, slice...). assert.Subset(t, [1, 2,

WithinDuration asserts that the two times are within duration delta of each other. assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second)

YAMLEq asserts that two YAML strings are equivalent.

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)

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

NewParser creates a new JMESPath parser.

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

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)

YAMLEq asserts that two YAML strings are equivalent.

YAMLEq asserts that two YAML strings are equivalent.

ObjsEqual is a generic object equality check. It will take two arbitrary objects and recursively determine if they are equal.

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

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 wh

Exactly asserts that two objects are equal in value and type. assert.Exactly(t, int32(123), int64(123))

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 t

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

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

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

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

WithinDuration asserts that the two times are within duration delta of each other. a.WithinDuration(time.Now(), time.Now(), 10*time.Second)

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

AssertCalled asserts that the method was called. It can produce a false result when an argument is a pointer type and the underlying value changed aft

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

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

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

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

NotRegexp asserts that a specified regexp does not match a string. assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting") assert.NotRegex

NotSame asserts that two pointers do not reference the same object. assert.NotSame(t, ptr1, ptr2) Both arguments must be pointer variables. Pointer

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

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

Same asserts that two pointers reference the same object. assert.Same(t, ptr1, ptr2) Both arguments must be pointer variables. Pointer variable same