Documentation

Overview

    Package cmp provides Comparisons for Assert and Check

    Index

    Constants

    This section is empty.

    Variables

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

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

      Functions

      This section is empty.

      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 google/go-cmp (https://godoc.org/github.com/google/go-cmp/cmp) and succeeds if the values are equal.

            The comparison can be customized using comparison Options. Package http://pkg.go.dev/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 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 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

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