assertions

package
v3.0.2+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 16, 2016 License: MIT, Apache-2.0 Imports: 9 Imported by: 0

Documentation

Overview

Package assertions contains the implementations for all assertions which are referenced in the convey package for use with the So(...) method.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

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

This function is not used by the goconvey library. It's actually a convenience method for running assertions on arbitrary arguments outside of any testing context, like for application logging. It allows you to perform assertion-like behavior (and get nicely formatted messages detailing discrepancies) but without the probram 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)
}

Types

type Serializer 

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

Source Files

View all Source files

Directories

Path Synopsis
Package oglematchers provides a set of matchers useful in a testing or mocking framework.
 Package oglematchers provides a set of matchers useful in a testing or mocking framework.
createmock
createmock is used to generate source code for mock versions of interfaces from installed packages.
 createmock is used to generate source code for mock versions of interfaces from installed packages.
generate
Package generate implements code generation for mock classes.
 Package generate implements code generation for mock classes.
generate/test_cases
generate/test_cases/complicated_pkg
Package complicated_pkg contains an interface with lots of interesting cases, for use in integration testing.
 Package complicated_pkg contains an interface with lots of interesting cases, for use in integration testing.
generate/test_cases/renamed_pkg
A package that calls itself something different than its package path would have you believe.
 A package that calls itself something different than its package path would have you believe.
sample/mock_io
Package ogletest provides a framework for writing expressive unit tests.
 Package ogletest provides a framework for writing expressive unit tests.
test_cases
test_cases/mock_image

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.