aiforge/vendor/github.com/smartystreets/assertions

• assertions
• • Usage
  • • • func GoConveyMode
      • func ShouldAlmostEqual
      • func ShouldBeBetween
      • func ShouldBeBetweenOrEqual
      • func ShouldBeBlank
      • func ShouldBeChronological
      • func ShouldBeEmpty
      • func ShouldBeFalse
      • func ShouldBeGreaterThan
      • func ShouldBeGreaterThanOrEqualTo
      • func ShouldBeIn
      • func ShouldBeLessThan
      • func ShouldBeLessThanOrEqualTo
      • func ShouldBeNil
      • func ShouldBeTrue
      • func ShouldBeZeroValue
      • func ShouldContain
      • func ShouldContainKey
      • func ShouldContainSubstring
      • func ShouldEndWith
      • func ShouldEqual
      • func ShouldEqualTrimSpace
      • func ShouldEqualWithout
      • func ShouldHappenAfter
      • func ShouldHappenBefore
      • func ShouldHappenBetween
      • func ShouldHappenOnOrAfter
      • func ShouldHappenOnOrBefore
      • func ShouldHappenOnOrBetween
      • func ShouldHappenWithin
      • func ShouldHaveLength
      • func ShouldHaveSameTypeAs
      • func ShouldImplement
      • func ShouldNotAlmostEqual
      • func ShouldNotBeBetween
      • func ShouldNotBeBetweenOrEqual
      • func ShouldNotBeBlank
      • func ShouldNotBeEmpty
      • func ShouldNotBeIn
      • func ShouldNotBeNil
      • func ShouldNotContain
      • func ShouldNotContainKey
      • func ShouldNotContainSubstring
      • func ShouldNotEndWith
      • func ShouldNotEqual
      • func ShouldNotHappenOnOrBetween
      • func ShouldNotHappenWithin
      • func ShouldNotHaveSameTypeAs
      • func ShouldNotImplement
      • func ShouldNotPanic
      • func ShouldNotPanicWith
      • func ShouldNotPointTo
      • func ShouldNotResemble
      • func ShouldNotStartWith
      • func ShouldPanic
      • func ShouldPanicWith
      • func ShouldPointTo
      • func ShouldResemble
      • func ShouldStartWith
      • func So
      • type Assertion
      • func New
      • func (*Assertion) Failed
      • func (*Assertion) So
      • type FailureView
      • type Serializer

assertions

--
import "github.com/smartystreets/assertions"

Package assertions contains the implementations for all assertions which are
referenced in goconvey's convey package
(github.com/smartystreets/goconvey/convey) and gunit
(github.com/smartystreets/gunit) for use with the So(...) method. They can also
be used in traditional Go test functions and even in applications.

Many of the assertions lean heavily on work done by Aaron Jacobs in his
excellent oglematchers library. (https://github.com/jacobsa/oglematchers) The
ShouldResemble assertion leans heavily on work done by Daniel Jacques in his
very helpful go-render library. (https://github.com/luci/go-render)

Usage

func GoConveyMode

func GoConveyMode(yes bool)

GoConveyMode provides control over JSON serialization of failures. When using
the assertions in this package from the convey package JSON results are very
helpful and can be rendered in a DIFF view. In that case, this function will be
called with a true value to enable the JSON serialization. By default, the
assertions in this package will not serializer a JSON result, making standalone
ussage more convenient.

func ShouldAlmostEqual

func ShouldAlmostEqual(actual interface{}, expected ...interface{}) string

ShouldAlmostEqual makes sure that two parameters are close enough to being
equal. The acceptable delta may be specified with a third argument, or a very
small default delta will be used.

func ShouldBeBetween

func ShouldBeBetween(actual interface{}, expected ...interface{}) string

ShouldBeBetween receives exactly three parameters: an actual value, a lower
bound, and an upper bound. It ensures that the actual value is between both
bounds (but not equal to either of them).

func ShouldBeBetweenOrEqual

func ShouldBeBetweenOrEqual(actual interface{}, expected ...interface{}) string

ShouldBeBetweenOrEqual receives exactly three parameters: an actual value, a
lower bound, and an upper bound. It ensures that the actual value is between
both bounds or equal to one of them.

func ShouldBeBlank

func ShouldBeBlank(actual interface{}, expected ...interface{}) string

ShouldBeBlank receives exactly 1 string parameter and ensures that it is equal
to "".

func ShouldBeChronological

func ShouldBeChronological(actual interface{}, expected ...interface{}) string

ShouldBeChronological receives a []time.Time slice and asserts that the are in
chronological order starting with the first time.Time as the earliest.

func ShouldBeEmpty

func ShouldBeEmpty(actual interface{}, expected ...interface{}) string

ShouldBeEmpty receives a single parameter (actual) and determines whether or not
calling len(actual) would return 0. It obeys the rules specified by the len
function for determining length: http://golang.org/pkg/builtin/#len

func ShouldBeFalse

func ShouldBeFalse(actual interface{}, expected ...interface{}) string

ShouldBeFalse receives a single parameter and ensures that it is false.

func ShouldBeGreaterThan

func ShouldBeGreaterThan(actual interface{}, expected ...interface{}) string

ShouldBeGreaterThan receives exactly two parameters and ensures that the first
is greater than the second.

func ShouldBeGreaterThanOrEqualTo

func ShouldBeGreaterThanOrEqualTo(actual interface{}, expected ...interface{}) string

ShouldBeGreaterThanOrEqualTo receives exactly two parameters and ensures that
the first is greater than or equal to the second.

func ShouldBeIn

func ShouldBeIn(actual interface{}, expected ...interface{}) string

ShouldBeIn receives at least 2 parameters. The first is a proposed member of the
collection that is passed in either as the second parameter, or of the
collection that is comprised of all the remaining parameters. This assertion
ensures that the proposed member is in the collection (using ShouldEqual).

func ShouldBeLessThan

func ShouldBeLessThan(actual interface{}, expected ...interface{}) string

ShouldBeLessThan receives exactly two parameters and ensures that the first is
less than the second.

func ShouldBeLessThanOrEqualTo

func ShouldBeLessThanOrEqualTo(actual interface{}, expected ...interface{}) string

ShouldBeLessThan receives exactly two parameters and ensures that the first is
less than or equal to the second.

func ShouldBeNil

func ShouldBeNil(actual interface{}, expected ...interface{}) string

ShouldBeNil receives a single parameter and ensures that it is nil.

func ShouldBeTrue

func ShouldBeTrue(actual interface{}, expected ...interface{}) string

ShouldBeTrue receives a single parameter and ensures that it is true.

func ShouldBeZeroValue

func ShouldBeZeroValue(actual interface{}, expected ...interface{}) string

ShouldBeZeroValue receives a single parameter and ensures that it is the Go
equivalent of the default value, or "zero" value.

func ShouldContain

func ShouldContain(actual interface{}, expected ...interface{}) string

ShouldContain receives exactly two parameters. The first is a slice and the
second is a proposed member. Membership is determined using ShouldEqual.

func ShouldContainKey

func ShouldContainKey(actual interface{}, expected ...interface{}) string

ShouldContainKey receives exactly two parameters. The first is a map and the
second is a proposed key. Keys are compared with a simple '=='.

func ShouldContainSubstring

func ShouldContainSubstring(actual interface{}, expected ...interface{}) string

ShouldContainSubstring receives exactly 2 string parameters and ensures that the
first contains the second as a substring.

func ShouldEndWith

func ShouldEndWith(actual interface{}, expected ...interface{}) string

ShouldEndWith receives exactly 2 string parameters and ensures that the first
ends with the second.

func ShouldEqual

func ShouldEqual(actual interface{}, expected ...interface{}) string

ShouldEqual receives exactly two parameters and does an equality check.

func ShouldEqualTrimSpace

func ShouldEqualTrimSpace(actual interface{}, expected ...interface{}) string

ShouldEqualTrimSpace receives exactly 2 string parameters and ensures that the
first is equal to the second after removing all leading and trailing whitespace
using strings.TrimSpace(first).

func ShouldEqualWithout

func ShouldEqualWithout(actual interface{}, expected ...interface{}) string

ShouldEqualWithout receives exactly 3 string parameters and ensures that the
first is equal to the second after removing all instances of the third from the
first using strings.Replace(first, third, "", -1).

func ShouldHappenAfter

func ShouldHappenAfter(actual interface{}, expected ...interface{}) string

ShouldHappenAfter receives exactly 2 time.Time arguments and asserts that the
first happens after the second.

func ShouldHappenBefore

func ShouldHappenBefore(actual interface{}, expected ...interface{}) string

ShouldHappenBefore receives exactly 2 time.Time arguments and asserts that the
first happens before the second.

func ShouldHappenBetween

func ShouldHappenBetween(actual interface{}, expected ...interface{}) string

ShouldHappenBetween receives exactly 3 time.Time arguments and asserts that the
first happens between (not on) the second and third.

func ShouldHappenOnOrAfter

func ShouldHappenOnOrAfter(actual interface{}, expected ...interface{}) string

ShouldHappenOnOrAfter receives exactly 2 time.Time arguments and asserts that
the first happens on or after the second.

func ShouldHappenOnOrBefore

func ShouldHappenOnOrBefore(actual interface{}, expected ...interface{}) string

ShouldHappenOnOrBefore receives exactly 2 time.Time arguments and asserts that
the first happens on or before the second.

func ShouldHappenOnOrBetween

func ShouldHappenOnOrBetween(actual interface{}, expected ...interface{}) string

ShouldHappenOnOrBetween receives exactly 3 time.Time arguments and asserts that
the first happens between or on the second and third.

func ShouldHappenWithin

func ShouldHappenWithin(actual interface{}, expected ...interface{}) string

ShouldHappenWithin receives a time.Time, a time.Duration, and a time.Time (3
arguments) and asserts that the first time.Time happens within or on the
duration specified relative to the other time.Time.

func ShouldHaveLength

func ShouldHaveLength(actual interface{}, expected ...interface{}) string

ShouldHaveLength receives 2 parameters. The first is a collection to check the
length of, the second being the expected length. It obeys the rules specified by
the len function for determining length: http://golang.org/pkg/builtin/#len

func ShouldHaveSameTypeAs

func ShouldHaveSameTypeAs(actual interface{}, expected ...interface{}) string

ShouldHaveSameTypeAs receives exactly two parameters and compares their
underlying types for equality.

func ShouldImplement

func ShouldImplement(actual interface{}, expectedList ...interface{}) string

ShouldImplement receives exactly two parameters and ensures that the first
implements the interface type of the second.

func ShouldNotAlmostEqual

func ShouldNotAlmostEqual(actual interface{}, expected ...interface{}) string

ShouldNotAlmostEqual is the inverse of ShouldAlmostEqual

func ShouldNotBeBetween

func ShouldNotBeBetween(actual interface{}, expected ...interface{}) string

ShouldNotBeBetween receives exactly three parameters: an actual value, a lower
bound, and an upper bound. It ensures that the actual value is NOT between both
bounds.

func ShouldNotBeBetweenOrEqual

func ShouldNotBeBetweenOrEqual(actual interface{}, expected ...interface{}) string

ShouldNotBeBetweenOrEqual receives exactly three parameters: an actual value, a
lower bound, and an upper bound. It ensures that the actual value is nopt
between the bounds nor equal to either of them.

func ShouldNotBeBlank

func ShouldNotBeBlank(actual interface{}, expected ...interface{}) string

ShouldNotBeBlank receives exactly 1 string parameter and ensures that it is
equal to "".

func ShouldNotBeEmpty

func ShouldNotBeEmpty(actual interface{}, expected ...interface{}) string

ShouldNotBeEmpty receives a single parameter (actual) and determines whether or
not calling len(actual) would return a value greater than zero. It obeys the
rules specified by the len function for determining length:
http://golang.org/pkg/builtin/#len

func ShouldNotBeIn

func ShouldNotBeIn(actual interface{}, expected ...interface{}) string

ShouldNotBeIn receives at least 2 parameters. The first is a proposed member of
the collection that is passed in either as the second parameter, or of the
collection that is comprised of all the remaining parameters. This assertion
ensures that the proposed member is NOT in the collection (using ShouldEqual).

func ShouldNotBeNil

func ShouldNotBeNil(actual interface{}, expected ...interface{}) string

ShouldNotBeNil receives a single parameter and ensures that it is not nil.

func ShouldNotContain

func ShouldNotContain(actual interface{}, expected ...interface{}) string

ShouldNotContain receives exactly two parameters. The first is a slice and the
second is a proposed member. Membership is determinied using ShouldEqual.

func ShouldNotContainKey

func ShouldNotContainKey(actual interface{}, expected ...interface{}) string

ShouldNotContainKey receives exactly two parameters. The first is a map and the
second is a proposed absent key. Keys are compared with a simple '=='.

func ShouldNotContainSubstring

func ShouldNotContainSubstring(actual interface{}, expected ...interface{}) string

ShouldNotContainSubstring receives exactly 2 string parameters and ensures that
the first does NOT contain the second as a substring.

func ShouldNotEndWith

func ShouldNotEndWith(actual interface{}, expected ...interface{}) string

ShouldEndWith receives exactly 2 string parameters and ensures that the first
does not end with the second.

func ShouldNotEqual

func ShouldNotEqual(actual interface{}, expected ...interface{}) string

ShouldNotEqual receives exactly two parameters and does an inequality check.

func ShouldNotHappenOnOrBetween

func ShouldNotHappenOnOrBetween(actual interface{}, expected ...interface{}) string

ShouldNotHappenOnOrBetween receives exactly 3 time.Time arguments and asserts
that the first does NOT happen between or on the second or third.

func ShouldNotHappenWithin

func ShouldNotHappenWithin(actual interface{}, expected ...interface{}) string

ShouldNotHappenWithin receives a time.Time, a time.Duration, and a time.Time (3
arguments) and asserts that the first time.Time does NOT happen within or on the
duration specified relative to the other time.Time.

func ShouldNotHaveSameTypeAs

func ShouldNotHaveSameTypeAs(actual interface{}, expected ...interface{}) string

ShouldNotHaveSameTypeAs receives exactly two parameters and compares their
underlying types for inequality.

func ShouldNotImplement

func ShouldNotImplement(actual interface{}, expectedList ...interface{}) string

ShouldNotImplement receives exactly two parameters and ensures that the first
does NOT implement the interface type of the second.

func ShouldNotPanic

func ShouldNotPanic(actual interface{}, expected ...interface{}) (message string)

ShouldNotPanic receives a void, niladic function and expects to execute the
function without any panic.

func ShouldNotPanicWith

func ShouldNotPanicWith(actual interface{}, expected ...interface{}) (message string)

ShouldNotPanicWith receives a void, niladic function and expects to recover a
panic whose content differs from the second argument.

func ShouldNotPointTo

func ShouldNotPointTo(actual interface{}, expected ...interface{}) string

ShouldNotPointTo receives exactly two parameters and checks to see that they
point to different addresess.

func ShouldNotResemble

func ShouldNotResemble(actual interface{}, expected ...interface{}) string

ShouldNotResemble receives exactly two parameters and does an inverse deep equal
check (see reflect.DeepEqual)

func ShouldNotStartWith

func ShouldNotStartWith(actual interface{}, expected ...interface{}) string

ShouldNotStartWith receives exactly 2 string parameters and ensures that the
first does not start with the second.

func ShouldPanic

func ShouldPanic(actual interface{}, expected ...interface{}) (message string)

ShouldPanic receives a void, niladic function and expects to recover a panic.

func ShouldPanicWith

func ShouldPanicWith(actual interface{}, expected ...interface{}) (message string)

ShouldPanicWith receives a void, niladic function and expects to recover a panic
with the second argument as the content.

func ShouldPointTo

func ShouldPointTo(actual interface{}, expected ...interface{}) string

ShouldPointTo receives exactly two parameters and checks to see that they point
to the same address.

func ShouldResemble

func ShouldResemble(actual interface{}, expected ...interface{}) string

ShouldResemble receives exactly two parameters and does a deep equal check (see
reflect.DeepEqual)

func ShouldStartWith

func ShouldStartWith(actual interface{}, expected ...interface{}) string

ShouldStartWith receives exactly 2 string parameters and ensures that the first
starts with the second.

func So

func So(actual interface{}, assert assertion, expected ...interface{}) (bool, string)

So is a convenience function (as opposed to an inconvenience function?) for
running assertions on arbitrary arguments in any context, be it for testing or
even application logging. It allows you to perform assertion-like behavior (and
get nicely formatted messages detailing discrepancies) but without the program
blowing up or panicking. All that is required is to import this package and call
So with one of the assertions exported by this package as the second
parameter. The first return parameter is a boolean indicating if the assertion
was true. The second return parameter is the well-formatted message showing why
an assertion was incorrect, or blank if the assertion was correct.

Example:

if ok, message := So(x, ShouldBeGreaterThan, y); !ok {
     log.Println(message)
}

type Assertion

type Assertion struct {
}

func New

func New(t testingT) *Assertion

New swallows the *testing.T struct and prints failed assertions using t.Error.
Example: assertions.New(t).So(1, should.Equal, 1)

func (*Assertion) Failed

func (this *Assertion) Failed() bool

Failed reports whether any calls to So (on this Assertion instance) have failed.

func (*Assertion) So

func (this *Assertion) So(actual interface{}, assert assertion, expected ...interface{}) bool

So calls the standalone So function and additionally, calls t.Error in failure
scenarios.

type FailureView

type FailureView struct {
	Message  string `json:"Message"`
	Expected string `json:"Expected"`
	Actual   string `json:"Actual"`
}

This struct is also declared in
github.com/smartystreets/goconvey/convey/reporting. The json struct tags should
be equal in both declarations.

type Serializer

type Serializer interface {
	// contains filtered or unexported methods
}