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

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

AllowUndefinedVariables allows to use undefined variables inside expressions. This can be used with expr.Env option to partially define a few variable

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

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

Sdump returns a string with the passed arguments formatted exactly the same as Dump.

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

Patch adds visitor to list of visitors what will be applied before compiling AST to bytecode.

Sprint is a wrapper for fmt.Sprint that treats each argument as if it were passed with a Formatter interface returned by c.NewFormatter. It returns t

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

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

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

AsBool tells the compiler to expect a boolean result.

CreateNew creates new config with default values.

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)

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

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

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

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

Patch replaces the node with a new one. Location information is preserved. Type information is lost.

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

WithinRange asserts that a time is within a time range (inclusive). assert.WithinRange(t, time.Now(), time.Now().Add(-time.Second), time.Now().Add(t

convertArgs accepts a slice of arguments and returns a slice of the same length with each argument converted to a default spew Formatter interface.

convertArgs accepts a slice of arguments and returns a slice of the same length with each argument converted to a spew Formatter interface using the C

Array returns a type that represents an array of the given type.

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

NatureOf returns a Nature describing "i". If "i" is nil then it returns a Nature describing the value "nil".

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

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

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

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

Println is a wrapper for fmt.Println that treats each argument as if it were passed with a Formatter interface returned by c.NewFormatter. It returns

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

indent performs indentation according to the depth level and cs.Indent option.

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

Disassemble returns opcodes as a string.

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

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)

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

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.

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

WithContext passes context to all functions calls with a context.Context argument.

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

formatUnequalValues takes two values of arbitrary types and returns string representations appropriate to be presented to the user. If the values are

ConstExpr defines func expression as constant. If all argument to this function is constants, then it can be replaced by result of this func call on c

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

ErrorContains asserts that a function returned an error (i.e. not `nil`) and that the error contains the specified substring. actualObj, err := Some

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

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

HTTPBodyContains asserts that a specified handler returns a body that contains a string. assert.HTTPBodyContains(t, myHandler, "GET", "www.google.co

HTTPError asserts that a specified handler returns an error status code. assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"

HTTPRedirect asserts that a specified handler returns a redirect status code. assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []s

HTTPStatusCode asserts that a specified handler returns a specified status code. assert.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil,

Implements asserts that an object is implemented by the specified interface. a.Implements((*MyInterface)(nil), new(MyObject))

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.