cmp

Documentation

Overview

Package cmp provides Comparisons for Assert and Check

Index

• Variables
• type Comparison
  • func Contains(collection interface{}, item interface{}) Comparison
  • func DeepEqual(x, y interface{}, opts ...cmp.Option) Comparison
  • func Equal(x, y interface{}) Comparison
  • func Error(err error, message string) Comparison
  • func ErrorContains(err error, substring string) Comparison
  • func ErrorIs(actual error, expected error) Comparison
  • func ErrorType(err error, expected interface{}) Comparison
  • func Len(seq interface{}, expected int) Comparison
  • func Nil(obj interface{}) Comparison
  • func Panics(f func()) Comparison
  • func Regexp(re RegexOrPattern, v string) Comparison
• type RegexOrPattern
• type Result
  • func ResultFailureTemplate(template string, data map[string]interface{}) Result
  • func ResultFromError(err error) Result
• type StringResult
  • func ResultFailure(message string) StringResult
  • func (r StringResult) FailureMessage() string
  • func (r StringResult) Success() bool

Variables

var ResultSuccess = StringResult{/* contains filtered or unexported fields */}

ResultSuccess is a constant which is returned by a Comparison to indicate success.

Types

type Comparison

type Comparison func() Result

Comparison is a function which compares values and returns ResultSuccess if the actual value matches the expected value. If the values do not match the Result will contain a message about why it failed.

func Contains

func Contains(collection interface{}, item interface{}) Comparison

Contains succeeds if item is in collection. Collection may be a string, map, slice, or array.

If collection is a string, item must also be a string, and is compared using strings.Contains. If collection is a Map, contains will succeed if item is a key in the map. If collection is a slice or array, item is compared to each item in the sequence using reflect.DeepEqual.

func DeepEqual

func DeepEqual(x, y interface{}, opts ...cmp.Option) Comparison

DeepEqual compares two values using github.com/google/go-cmp/cmp and succeeds if the values are equal.

The comparison can be customized using comparison Options. Package gotest.tools/v3/assert/opt provides some additional commonly used Options.

func Equal

func Equal(x, y interface{}) Comparison

Equal succeeds if x == y. See gotest.tools/v3/assert.Equal for full documentation.

func Error

func Error(err error, message string) Comparison

Error succeeds if err is a non-nil error, and the error message equals the expected message.

func ErrorContains

func ErrorContains(err error, substring string) Comparison

ErrorContains succeeds if err is a non-nil error, and the error message contains the expected substring.

func ErrorIs

func ErrorIs(actual error, expected error) Comparison

ErrorIs succeeds if errors.Is(actual, expected) returns true. See errors.Is for accepted argument values.

func ErrorType

func ErrorType(err error, expected interface{}) Comparison

ErrorType succeeds if err is not nil and is of the expected type.

Expected can be one of:

func(error) bool

Function should return true if the error is the expected type.

type struct{}, type &struct{}

A struct or a pointer to a struct. Fails if the error is not of the same type as expected.

type &interface{}

A pointer to an interface type. Fails if err does not implement the interface.

reflect.Type

Fails if err does not implement the reflect.Type.

Deprecated: Use ErrorIs

func Len

func Len(seq interface{}, expected int) Comparison

Len succeeds if the sequence has the expected length.

func Nil

func Nil(obj interface{}) Comparison

Nil succeeds if obj is a nil interface, pointer, or function.

Use gotest.tools/v3/assert.NilError for comparing errors. Use Len(obj, 0) for comparing slices, maps, and channels.

func Panics

func Panics(f func()) Comparison

Panics succeeds if f() panics.

func Regexp

func Regexp(re RegexOrPattern, v string) Comparison

Regexp succeeds if value v matches regular expression re.

Example:

assert.Assert(t, cmp.Regexp("^[0-9a-f]{32}$", str))
r := regexp.MustCompile("^[0-9a-f]{32}$")
assert.Assert(t, cmp.Regexp(r, str))

type RegexOrPattern

type RegexOrPattern interface{}

RegexOrPattern may be either a *regexp.Regexp or a string that is a valid regexp pattern.

type Result

type Result interface {
	Success() bool
}

A Result of a Comparison.

func ResultFailureTemplate

func ResultFailureTemplate(template string, data map[string]interface{}) Result

ResultFailureTemplate returns a Result with a template string and data which can be used to format a failure message. The template may access data from .Data, the comparison args with the callArg function, and the formatNode function may be used to format the call args.

func ResultFromError

func ResultFromError(err error) Result

ResultFromError returns ResultSuccess if err is nil. Otherwise ResultFailure is returned with the error message as the failure message.

type StringResult

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

StringResult is an implementation of Result that reports the error message string verbatim and does not provide any templating or formatting of the message.

func ResultFailure

func ResultFailure(message string) StringResult

ResultFailure returns a failed Result with a failure message.

func (StringResult) FailureMessage

func (r StringResult) FailureMessage() string

FailureMessage returns the message used to provide additional information about the failure.

func (StringResult) Success

func (r StringResult) Success() bool

Success returns true if the comparison was successful.