Documentation

Overview

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

Constants

This section is empty.

Variables

View Source
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.

    Functions

    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 TestingT, comp Comparison, msgAndArgs ...interface{}) bool

        Condition uses a Comparison to assert a complex condition.

        func Contains

        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", "But 'Hello World' does contain 'World'")
          assert.Contains(t, ["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'")
          assert.Contains(t, {"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'")
          

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

          func Empty

          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 Equal

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

              Equal asserts that two objects are equal.

              assert.Equal(t, 123, 123, "123 and 123 should be equal")
              

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

              func EqualError

              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()
                  if assert.Error(t, err, "An error was expected") {
                	   assert.Equal(t, err, expectedError)
                  }
                

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

                func EqualValues

                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), "123 and 123 should be equal")
                  

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

                  func Error

                  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, "An error was expected") {
                    	   assert.Equal(t, err, expectedError)
                      }
                    

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

                    func Exactly

                    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), "123 and 123 should NOT be equal")
                      

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

                      func Fail

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

                        Fail reports a failure through

                        func False

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

                          False asserts that the specified value is false.

                          assert.False(t, myBool, "myBool should be false")
                          

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

                          func HTTPBody

                          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

                            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 HTTPBodyNotContains

                              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 HTTPError

                                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 HTTPRedirect

                                  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 HTTPSuccess

                                    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 Implements

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

                                        func InDelta

                                        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

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

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

                                            func InEpsilon

                                            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

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

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

                                                func IsType

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

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

                                                  func JSONEq

                                                  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 Len

                                                    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, "The size of slice is not 3")
                                                      

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

                                                      func Nil

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

                                                        Nil asserts that the specified object is nil.

                                                        assert.Nil(t, err, "err should be nothing")
                                                        

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

                                                        func NoError

                                                        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, actualObj, expectedObj)
                                                            }
                                                          

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

                                                          func NotContains

                                                          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", "But 'Hello World' does NOT contain 'Earth'")
                                                            assert.NotContains(t, ["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'")
                                                            assert.NotContains(t, {"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'")
                                                            

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

                                                            func NotEmpty

                                                            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 NotEqual

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

                                                                NotEqual asserts that the specified values are NOT equal.

                                                                assert.NotEqual(t, obj1, obj2, "two objects shouldn't be equal")
                                                                

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

                                                                func NotNil

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

                                                                  NotNil asserts that the specified object is not nil.

                                                                  assert.NotNil(t, err, "err should be something")
                                                                  

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

                                                                  func NotPanics

                                                                  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()
                                                                    }, "Calling RemainCalm() should NOT panic")
                                                                    

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

                                                                    func NotRegexp

                                                                    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 NotZero

                                                                      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 ObjectsAreEqual

                                                                        func ObjectsAreEqual(expected, actual interface{}) bool

                                                                          ObjectsAreEqual determines if two objects are considered equal.

                                                                          This function does no assertion of any kind.

                                                                          func ObjectsAreEqualValues

                                                                          func ObjectsAreEqualValues(expected, actual interface{}) bool

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

                                                                            func Panics

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

                                                                              Panics asserts that the code inside the specified PanicTestFunc panics.

                                                                              assert.Panics(t, func(){
                                                                                GoCrazy()
                                                                              }, "Calling GoCrazy() should panic")
                                                                              

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

                                                                              func Regexp

                                                                              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 True

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

                                                                                  True asserts that the specified value is true.

                                                                                  assert.True(t, myBool, "myBool should be true")
                                                                                  

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

                                                                                  func WithinDuration

                                                                                  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, "The difference should not be more than 10s")
                                                                                    

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

                                                                                    func Zero

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

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

                                                                                      Types

                                                                                      type Assertions

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

                                                                                        Assertions provides assertion methods around the TestingT interface.

                                                                                        func New

                                                                                        func New(t TestingT) *Assertions

                                                                                          New makes a new Assertions object for the specified TestingT.

                                                                                          func (*Assertions) Condition

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

                                                                                            Condition uses a Comparison to assert a complex condition.

                                                                                            func (*Assertions) Contains

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

                                                                                              Contains asserts that the specified string contains the specified substring.

                                                                                              assert.Contains("Hello World", "World", "But 'Hello World' does contain 'World'")
                                                                                              

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

                                                                                              func (*Assertions) Empty

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

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

                                                                                                assert.Empty(obj)
                                                                                                

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

                                                                                                func (*Assertions) Equal

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

                                                                                                  Equal asserts that two objects are equal.

                                                                                                  assert.Equal(123, 123, "123 and 123 should be equal")
                                                                                                  

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

                                                                                                  func (*Assertions) EqualError

                                                                                                  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()
                                                                                                      if assert.Error(err, "An error was expected") {
                                                                                                    	   assert.Equal(err, expectedError)
                                                                                                      }
                                                                                                    

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

                                                                                                    func (*Assertions) EqualValues

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

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

                                                                                                      assert.EqualValues(uint32(123), int32(123), "123 and 123 should be equal")
                                                                                                      

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

                                                                                                      func (*Assertions) Error

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

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

                                                                                                          actualObj, err := SomeFunction()
                                                                                                          if assert.Error(err, "An error was expected") {
                                                                                                        	   assert.Equal(err, expectedError)
                                                                                                          }
                                                                                                        

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

                                                                                                        func (*Assertions) Exactly

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

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

                                                                                                          assert.Exactly(int32(123), int64(123), "123 and 123 should NOT be equal")
                                                                                                          

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

                                                                                                          func (*Assertions) Fail

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

                                                                                                            Fail reports a failure through

                                                                                                            func (*Assertions) False

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

                                                                                                              False asserts that the specified value is false.

                                                                                                              assert.False(myBool, "myBool should be false")
                                                                                                              

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

                                                                                                              func (*Assertions) HTTPBodyContains

                                                                                                              func (a *Assertions) HTTPBodyContains(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 (*Assertions) HTTPBodyNotContains

                                                                                                                func (a *Assertions) HTTPBodyNotContains(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 (*Assertions) HTTPError

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

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

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

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

                                                                                                                    func (*Assertions) HTTPRedirect

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

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

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

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

                                                                                                                      func (*Assertions) HTTPSuccess

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

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

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

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

                                                                                                                        func (*Assertions) Implements

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

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

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

                                                                                                                          func (*Assertions) InDelta

                                                                                                                          func (a *Assertions) InDelta(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 (*Assertions) InEpsilon

                                                                                                                            func (a *Assertions) InEpsilon(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 (*Assertions) IsType

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

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

                                                                                                                                func (*Assertions) JSONEq

                                                                                                                                func (a *Assertions) JSONEq(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 (*Assertions) Len

                                                                                                                                  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.

                                                                                                                                    assert.Len(mySlice, 3, "The size of slice is not 3")
                                                                                                                                    

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

                                                                                                                                    func (*Assertions) Nil

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

                                                                                                                                      Nil asserts that the specified object is nil.

                                                                                                                                      assert.Nil(err, "err should be nothing")
                                                                                                                                      

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

                                                                                                                                      func (*Assertions) NoError

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

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

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

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

                                                                                                                                        func (*Assertions) NotContains

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

                                                                                                                                          NotContains asserts that the specified string does NOT contain the specified substring.

                                                                                                                                          assert.NotContains("Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
                                                                                                                                          

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

                                                                                                                                          func (*Assertions) NotEmpty

                                                                                                                                          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 a slice with len == 0.

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

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

                                                                                                                                            func (*Assertions) NotEqual

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

                                                                                                                                              NotEqual asserts that the specified values are NOT equal.

                                                                                                                                              assert.NotEqual(obj1, obj2, "two objects shouldn't be equal")
                                                                                                                                              

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

                                                                                                                                              func (*Assertions) NotNil

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

                                                                                                                                                NotNil asserts that the specified object is not nil.

                                                                                                                                                assert.NotNil(err, "err should be something")
                                                                                                                                                

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

                                                                                                                                                func (*Assertions) NotPanics

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

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

                                                                                                                                                  assert.NotPanics(func(){
                                                                                                                                                    RemainCalm()
                                                                                                                                                  }, "Calling RemainCalm() should NOT panic")
                                                                                                                                                  

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

                                                                                                                                                  func (*Assertions) NotRegexp

                                                                                                                                                  func (a *Assertions) NotRegexp(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 (*Assertions) NotZero

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

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

                                                                                                                                                        Panics asserts that the code inside the specified PanicTestFunc panics.

                                                                                                                                                        assert.Panics(func(){
                                                                                                                                                          GoCrazy()
                                                                                                                                                        }, "Calling GoCrazy() should panic")
                                                                                                                                                        

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

                                                                                                                                                        func (*Assertions) Regexp

                                                                                                                                                        func (a *Assertions) Regexp(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 (*Assertions) True

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

                                                                                                                                                            True asserts that the specified value is true.

                                                                                                                                                            assert.True(myBool, "myBool should be true")
                                                                                                                                                            

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

                                                                                                                                                            func (*Assertions) WithinDuration

                                                                                                                                                            func (a *Assertions) WithinDuration(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(time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")
                                                                                                                                                              

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

                                                                                                                                                              func (*Assertions) Zero

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

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

                                                                                                                                                                type Comparison

                                                                                                                                                                type Comparison func() (success bool)

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

                                                                                                                                                                  type PanicTestFunc

                                                                                                                                                                  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

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

                                                                                                                                                                      TestingT is an interface wrapper around *testing.T