testify: github.com/stretchr/testify/assert Index | Files

package assert

import "github.com/stretchr/testify/assert"

Package assert provides a set of comprehensive testing tools for use with the normal Go testing system.

Example Usage

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

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

func TestSomething(t *testing.T) {

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

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

}

if you assert many times, use the format below:

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

func TestSomething(t *testing.T) {
  assert := assert.New(t)

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

  assert.Equal(a, b, "The two words should be the same.")
}

Assertions

Assertions allow you to easily write test code, and are global funcs in the `assert` package. All assertion functions take, as the first argument, the `*testing.T` object provided by the testing framework. This allows the assertion funcs to write the failings and other details to the correct place.

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

Package Files

assertion_format.go assertion_forward.go assertions.go doc.go errors.go forward_assertions.go http_assertions.go

Variables

var AnError = errors.New("assert.AnError general error for testing")

AnError is an error instance useful for testing. If the code does not care about error specifics, and only needs to return the error for example, this error should be used to make the test code more readable.

func CallerInfo Uses

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 Uses

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

Condition uses a Comparison to assert a complex condition.

func Conditionf Uses

func Conditionf(t TestingT, comp Comparison, msg string, args ...interface{}) bool

Conditionf uses a Comparison to assert a complex condition.

func Contains Uses

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

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

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

func Containsf Uses

func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool

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

assert.Containsf(t, "Hello World", "World", "error message %s", "formatted")
assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted")
assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted")

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

func Empty Uses

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

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)

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

func Emptyf Uses

func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool

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

assert.Emptyf(t, obj, "error message %s", "formatted")

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

func Equal Uses

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

Equal asserts that two objects are equal.

assert.Equal(t, 123, 123)

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

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 Uses

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

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)

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

func EqualErrorf Uses

func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) bool

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

actualObj, err := SomeFunction()
assert.EqualErrorf(t, err,  expectedErrorString, "error message %s", "formatted")

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

func EqualValues Uses

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

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

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

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

func EqualValuesf Uses

func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool

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

assert.EqualValuesf(t, uint32(123, "error message %s", "formatted"), int32(123))

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

func Equalf Uses

func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool

Equalf asserts that two objects are equal.

assert.Equalf(t, 123, 123, "error message %s", "formatted")

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

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 Error Uses

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

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

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

func Errorf Uses

func Errorf(t TestingT, err error, msg string, args ...interface{}) bool

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

  actualObj, err := SomeFunction()
  if assert.Errorf(t, err, "error message %s", "formatted") {
	   assert.Equal(t, expectedErrorf, err)
  }

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

func Exactly Uses

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

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

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

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

func Exactlyf Uses

func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool

Exactlyf asserts that two objects are equal is value and type.

assert.Exactlyf(t, int32(123, "error message %s", "formatted"), int64(123))

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

func Fail Uses

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

Fail reports a failure through

func FailNow Uses

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

FailNow fails test

func FailNowf Uses

func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}) bool

FailNowf fails test

func Failf Uses

func Failf(t TestingT, failureMessage string, msg string, args ...interface{}) bool

Failf reports a failure through

func False Uses

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

False asserts that the specified value is false.

assert.False(t, myBool)

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

func Falsef Uses

func Falsef(t TestingT, value bool, msg string, args ...interface{}) bool

Falsef asserts that the specified value is false.

assert.Falsef(t, myBool, "error message %s", "formatted")

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

func HTTPBody Uses

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

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

func HTTPBodyContains Uses

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

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

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

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

func HTTPBodyContainsf Uses

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

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

assert.HTTPBodyContainsf(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")

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

func HTTPBodyNotContains Uses

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

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

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

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

func HTTPBodyNotContainsf Uses

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

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

assert.HTTPBodyNotContainsf(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")

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

func HTTPError Uses

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

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 HTTPErrorf Uses

func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) bool

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

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

Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false).

func HTTPRedirect Uses

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

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 HTTPRedirectf Uses

func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) bool

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

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

Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false).

func HTTPSuccess Uses

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

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 HTTPSuccessf Uses

func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) bool

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

assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")

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

func Implements Uses

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

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

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

func Implementsf Uses

func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool

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

assert.Implementsf(t, (*MyInterface, "error message %s", "formatted")(nil), new(MyObject))

func InDelta Uses

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

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

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

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

func InDeltaSlice Uses

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

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

func InDeltaSlicef Uses

func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool

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

func InDeltaf Uses

func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool

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

assert.InDeltaf(t, math.Pi, (22 / 7.0, "error message %s", "formatted"), 0.01)

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

func InEpsilon Uses

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

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

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

func InEpsilonSlice Uses

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

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

func InEpsilonSlicef Uses

func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool

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

func InEpsilonf Uses

func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool

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

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

func IsType Uses

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

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

func IsTypef Uses

func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg string, args ...interface{}) bool

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

func JSONEq Uses

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

JSONEq asserts that two JSON strings are equivalent.

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

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

func JSONEqf Uses

func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool

JSONEqf asserts that two JSON strings are equivalent.

assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")

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

func Len Uses

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

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)

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

func Lenf Uses

func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) bool

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

assert.Lenf(t, mySlice, 3, "error message %s", "formatted")

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

func Nil Uses

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

Nil asserts that the specified object is nil.

assert.Nil(t, err)

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

func Nilf Uses

func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) bool

Nilf asserts that the specified object is nil.

assert.Nilf(t, err, "error message %s", "formatted")

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

func NoError Uses

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

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

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

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

func NoErrorf Uses

func NoErrorf(t TestingT, err error, msg string, args ...interface{}) bool

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

  actualObj, err := SomeFunction()
  if assert.NoErrorf(t, err, "error message %s", "formatted") {
	   assert.Equal(t, expectedObj, actualObj)
  }

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

func NotContains Uses

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

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

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

func NotContainsf Uses

func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool

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

assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted")
assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted")
assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted")

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

func NotEmpty Uses

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

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

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

func NotEmptyf Uses

func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool

NotEmptyf 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.NotEmptyf(t, obj, "error message %s", "formatted") {
  assert.Equal(t, "two", obj[1])
}

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

func NotEqual Uses

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

NotEqual asserts that the specified values are NOT equal.

assert.NotEqual(t, obj1, obj2)

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

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

func NotEqualf Uses

func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool

NotEqualf asserts that the specified values are NOT equal.

assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted")

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

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

func NotNil Uses

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

NotNil asserts that the specified object is not nil.

assert.NotNil(t, err)

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

func NotNilf Uses

func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bool

NotNilf asserts that the specified object is not nil.

assert.NotNilf(t, err, "error message %s", "formatted")

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

func NotPanics Uses

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

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

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

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

func NotPanicsf Uses

func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool

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

assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted")

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

func NotRegexp Uses

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

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

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

func NotRegexpf Uses

func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool

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

assert.NotRegexpf(t, regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting")
assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted")

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

func NotSubset Uses

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

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

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

func NotSubsetf Uses

func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool

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

assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")

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

func NotZero Uses

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

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

func NotZerof Uses

func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) bool

NotZerof asserts that i is not the zero value for its type and returns the truth.

func ObjectsAreEqual Uses

func ObjectsAreEqual(expected, actual interface{}) bool

ObjectsAreEqual determines if two objects are considered equal.

This function does no assertion of any kind.

func ObjectsAreEqualValues Uses

func ObjectsAreEqualValues(expected, actual interface{}) bool

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

func Panics Uses

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

Panics asserts that the code inside the specified PanicTestFunc panics.

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

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

func PanicsWithValue Uses

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

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

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

func PanicsWithValuef Uses

func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool

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

assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")

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

func Panicsf Uses

func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool

Panicsf asserts that the code inside the specified PanicTestFunc panics.

assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted")

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

func Regexp Uses

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

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

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

func Regexpf Uses

func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool

Regexpf asserts that a specified regexp matches a string.

assert.Regexpf(t, regexp.MustCompile("start", "error message %s", "formatted"), "it's starting")
assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted")

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

func Subset Uses

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

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

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

func Subsetf Uses

func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool

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

assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")

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

func True Uses

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

True asserts that the specified value is true.

assert.True(t, myBool)

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

func Truef Uses

func Truef(t TestingT, value bool, msg string, args ...interface{}) bool

Truef asserts that the specified value is true.

assert.Truef(t, myBool, "error message %s", "formatted")

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

func WithinDuration Uses

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

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

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

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

func WithinDurationf Uses

func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool

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

assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")

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

func Zero Uses

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

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

func Zerof Uses

func Zerof(t TestingT, i interface{}, msg string, args ...interface{}) bool

Zerof asserts that i is the zero value for its type and returns the truth.

type Assertions Uses

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

Assertions provides assertion methods around the TestingT interface.

func New Uses

func New(t TestingT) *Assertions

New makes a new Assertions object for the specified TestingT.

func (*Assertions) Condition Uses

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

Condition uses a Comparison to assert a complex condition.

func (*Assertions) Conditionf Uses

func (a *Assertions) Conditionf(comp Comparison, msg string, args ...interface{}) bool

Conditionf uses a Comparison to assert a complex condition.

func (*Assertions) Contains Uses

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

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

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

func (*Assertions) Containsf Uses

func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool

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

a.Containsf("Hello World", "World", "error message %s", "formatted")
a.Containsf(["Hello", "World"], "World", "error message %s", "formatted")
a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted")

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

func (*Assertions) Empty Uses

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

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)

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

func (*Assertions) Emptyf Uses

func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) bool

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

a.Emptyf(obj, "error message %s", "formatted")

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

func (*Assertions) Equal Uses

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

Equal asserts that two objects are equal.

a.Equal(123, 123)

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

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 Uses

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

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)

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

func (*Assertions) EqualErrorf Uses

func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) bool

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

actualObj, err := SomeFunction()
a.EqualErrorf(err,  expectedErrorString, "error message %s", "formatted")

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

func (*Assertions) EqualValues Uses

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

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

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

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

func (*Assertions) EqualValuesf Uses

func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool

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

a.EqualValuesf(uint32(123, "error message %s", "formatted"), int32(123))

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

func (*Assertions) Equalf Uses

func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool

Equalf asserts that two objects are equal.

a.Equalf(123, 123, "error message %s", "formatted")

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

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) Error Uses

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

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

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

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

func (*Assertions) Errorf Uses

func (a *Assertions) Errorf(err error, msg string, args ...interface{}) bool

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

  actualObj, err := SomeFunction()
  if a.Errorf(err, "error message %s", "formatted") {
	   assert.Equal(t, expectedErrorf, err)
  }

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

func (*Assertions) Exactly Uses

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

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

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

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

func (*Assertions) Exactlyf Uses

func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool

Exactlyf asserts that two objects are equal is value and type.

a.Exactlyf(int32(123, "error message %s", "formatted"), int64(123))

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

func (*Assertions) Fail Uses

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

Fail reports a failure through

func (*Assertions) FailNow Uses

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

FailNow fails test

func (*Assertions) FailNowf Uses

func (a *Assertions) FailNowf(failureMessage string, msg string, args ...interface{}) bool

FailNowf fails test

func (*Assertions) Failf Uses

func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{}) bool

Failf reports a failure through

func (*Assertions) False Uses

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

False asserts that the specified value is false.

a.False(myBool)

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

func (*Assertions) Falsef Uses

func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) bool

Falsef asserts that the specified value is false.

a.Falsef(myBool, "error message %s", "formatted")

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

func (*Assertions) HTTPBodyContains Uses

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

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

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

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

func (*Assertions) HTTPBodyContainsf Uses

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

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

a.HTTPBodyContainsf(myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")

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

func (*Assertions) HTTPBodyNotContains Uses

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

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

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

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

func (*Assertions) HTTPBodyNotContainsf Uses

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

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

a.HTTPBodyNotContainsf(myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")

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

func (*Assertions) HTTPError Uses

func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values) bool

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) HTTPErrorf Uses

func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values) bool

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

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

Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false).

func (*Assertions) HTTPRedirect Uses

func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values) bool

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) HTTPRedirectf Uses

func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values) bool

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

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

Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false).

func (*Assertions) HTTPSuccess Uses

func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values) bool

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) HTTPSuccessf Uses

func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values) bool

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

a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")

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

func (*Assertions) Implements Uses

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

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

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

func (*Assertions) Implementsf Uses

func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool

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

a.Implementsf((*MyInterface, "error message %s", "formatted")(nil), new(MyObject))

func (*Assertions) InDelta Uses

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

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

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

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

func (*Assertions) InDeltaSlice Uses

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

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

func (*Assertions) InDeltaSlicef Uses

func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool

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

func (*Assertions) InDeltaf Uses

func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool

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

a.InDeltaf(math.Pi, (22 / 7.0, "error message %s", "formatted"), 0.01)

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

func (*Assertions) InEpsilon Uses

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

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

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

func (*Assertions) InEpsilonSlice Uses

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

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

func (*Assertions) InEpsilonSlicef Uses

func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool

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

func (*Assertions) InEpsilonf Uses

func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool

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

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

func (*Assertions) IsType Uses

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

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

func (*Assertions) IsTypef Uses

func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg string, args ...interface{}) bool

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

func (*Assertions) JSONEq Uses

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

JSONEq asserts that two JSON strings are equivalent.

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

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

func (*Assertions) JSONEqf Uses

func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) bool

JSONEqf asserts that two JSON strings are equivalent.

a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")

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

func (*Assertions) Len Uses

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

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)

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

func (*Assertions) Lenf Uses

func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) bool

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

a.Lenf(mySlice, 3, "error message %s", "formatted")

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

func (*Assertions) Nil Uses

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

Nil asserts that the specified object is nil.

a.Nil(err)

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

func (*Assertions) Nilf Uses

func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) bool

Nilf asserts that the specified object is nil.

a.Nilf(err, "error message %s", "formatted")

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

func (*Assertions) NoError Uses

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

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

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

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

func (*Assertions) NoErrorf Uses

func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) bool

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

  actualObj, err := SomeFunction()
  if a.NoErrorf(err, "error message %s", "formatted") {
	   assert.Equal(t, expectedObj, actualObj)
  }

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

func (*Assertions) NotContains Uses

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

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

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

func (*Assertions) NotContainsf Uses

func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool

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

a.NotContainsf("Hello World", "Earth", "error message %s", "formatted")
a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted")
a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted")

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

func (*Assertions) NotEmpty Uses

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

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

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

func (*Assertions) NotEmptyf Uses

func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) bool

NotEmptyf 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.NotEmptyf(obj, "error message %s", "formatted") {
  assert.Equal(t, "two", obj[1])
}

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

func (*Assertions) NotEqual Uses

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

NotEqual asserts that the specified values are NOT equal.

a.NotEqual(obj1, obj2)

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

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

func (*Assertions) NotEqualf Uses

func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool

NotEqualf asserts that the specified values are NOT equal.

a.NotEqualf(obj1, obj2, "error message %s", "formatted")

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

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

func (*Assertions) NotNil Uses

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

NotNil asserts that the specified object is not nil.

a.NotNil(err)

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

func (*Assertions) NotNilf Uses

func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) bool

NotNilf asserts that the specified object is not nil.

a.NotNilf(err, "error message %s", "formatted")

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

func (*Assertions) NotPanics Uses

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

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

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

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

func (*Assertions) NotPanicsf Uses

func (a *Assertions) NotPanicsf(f PanicTestFunc, msg string, args ...interface{}) bool

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

a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted")

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

func (*Assertions) NotRegexp Uses

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

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

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

func (*Assertions) NotRegexpf Uses

func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool

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

a.NotRegexpf(regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting")
a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted")

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

func (*Assertions) NotSubset Uses

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

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

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

func (*Assertions) NotSubsetf Uses

func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool

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

a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")

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

func (*Assertions) NotZero Uses

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

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

func (*Assertions) NotZerof Uses

func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) bool

NotZerof asserts that i is not the zero value for its type and returns the truth.

func (*Assertions) Panics Uses

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

Panics asserts that the code inside the specified PanicTestFunc panics.

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

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

func (*Assertions) PanicsWithValue Uses

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

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

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

func (*Assertions) PanicsWithValuef Uses

func (a *Assertions) PanicsWithValuef(expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool

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

a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")

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

func (*Assertions) Panicsf Uses

func (a *Assertions) Panicsf(f PanicTestFunc, msg string, args ...interface{}) bool

Panicsf asserts that the code inside the specified PanicTestFunc panics.

a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted")

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

func (*Assertions) Regexp Uses

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

Regexp asserts that a specified regexp matches a string.

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

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

func (*Assertions) Regexpf Uses

func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool

Regexpf asserts that a specified regexp matches a string.

a.Regexpf(regexp.MustCompile("start", "error message %s", "formatted"), "it's starting")
a.Regexpf("start...$", "it's not starting", "error message %s", "formatted")

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

func (*Assertions) Subset Uses

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

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

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

func (*Assertions) Subsetf Uses

func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool

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

a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")

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

func (*Assertions) True Uses

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

True asserts that the specified value is true.

a.True(myBool)

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

func (*Assertions) Truef Uses

func (a *Assertions) Truef(value bool, msg string, args ...interface{}) bool

Truef asserts that the specified value is true.

a.Truef(myBool, "error message %s", "formatted")

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

func (*Assertions) WithinDuration Uses

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

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

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

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

func (*Assertions) WithinDurationf Uses

func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool

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

a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")

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

func (*Assertions) Zero Uses

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

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

func (*Assertions) Zerof Uses

func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) bool

Zerof asserts that i is the zero value for its type and returns the truth.

type Comparison Uses

type Comparison func() (success bool)

Comparison a custom function that returns true on success and false on failure

type PanicTestFunc Uses

type PanicTestFunc func()

PanicTestFunc defines a func that should be passed to the assert.Panics and assert.NotPanics methods, and represents a simple func that takes no arguments, and returns nothing.

type TestingT Uses

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

TestingT is an interface wrapper around *testing.T

Package assert imports 18 packages (graph) and is imported by 896 packages. Updated 2017-11-13. Refresh now. Tools for package owners.