matchers

package

Go to main page

Versions in this module

v1

v1.27.10

Aug 31, 2023

Changes in this version

+ type HaveExactElementsMatcher struct

+ Elements []interface{}

+ func (matcher *HaveExactElementsMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *HaveExactElementsMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *HaveExactElementsMatcher) NegatedFailureMessage(actual interface{}) (message string)

v1.27.7

May 25, 2023

v1.26.0

Jan 27, 2023

Changes in this version

+ type BeKeyOfMatcher struct

+ Map interface{}

+ func (matcher *BeKeyOfMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *BeKeyOfMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *BeKeyOfMatcher) NegatedFailureMessage(actual interface{}) (message string)

v1.20.0

Aug 9, 2022

Changes in this version

type ContainElementMatcher

+ Result []interface{}

+ type HaveEachMatcher struct

+ Element interface{}

+ func (matcher *HaveEachMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *HaveEachMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *HaveEachMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type HaveExistingFieldMatcher struct

+ Field string

+ func (matcher *HaveExistingFieldMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *HaveExistingFieldMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *HaveExistingFieldMatcher) NegatedFailureMessage(actual interface{}) (message string)

v1.18.1

Mar 18, 2022

Changes in this version

+ type HaveValueMatcher struct

+ Matcher types.GomegaMatcher

+ func (m *HaveValueMatcher) FailureMessage(_ interface{}) (message string)

+ func (m *HaveValueMatcher) Match(actual interface{}) (bool, error)

+ func (m *HaveValueMatcher) NegatedFailureMessage(_ interface{}) (message string)

v1.17.0

Nov 26, 2021

Changes in this version

+ type HaveFieldMatcher struct

+ Expected interface{}

+ Field string

+ func (matcher *HaveFieldMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *HaveFieldMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *HaveFieldMatcher) NegatedFailureMessage(actual interface{}) (message string)

v1.16.0

Aug 31, 2021

Changes in this version

+ type HaveHTTPBodyMatcher struct

+ Expected interface{}

+ func (matcher *HaveHTTPBodyMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *HaveHTTPBodyMatcher) Match(actual interface{}) (bool, error)

+ func (matcher *HaveHTTPBodyMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type HaveHTTPHeaderWithValueMatcher struct

+ Header string

+ Value interface{}

+ func (matcher *HaveHTTPHeaderWithValueMatcher) FailureMessage(actual interface{}) string

+ func (matcher *HaveHTTPHeaderWithValueMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *HaveHTTPHeaderWithValueMatcher) NegatedFailureMessage(actual interface{}) (message string)

v1.14.0

Jul 13, 2021

v1.13.0

Jun 4, 2021

Changes in this version

+ type SatisfyMatcher struct

+ Predicate interface{}

+ func NewSatisfyMatcher(predicate interface{}) *SatisfyMatcher

+ func (m *SatisfyMatcher) FailureMessage(actual interface{}) (message string)

+ func (m *SatisfyMatcher) Match(actual interface{}) (success bool, err error)

+ func (m *SatisfyMatcher) NegatedFailureMessage(actual interface{}) (message string)

v1.11.0

Apr 6, 2021

Changes in this version

+ type AndMatcher struct

+ Matchers []types.GomegaMatcher

+ func (m *AndMatcher) FailureMessage(actual interface{}) (message string)

+ func (m *AndMatcher) Match(actual interface{}) (success bool, err error)

+ func (m *AndMatcher) MatchMayChangeInTheFuture(actual interface{}) bool

+ func (m *AndMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type AssignableToTypeOfMatcher struct

+ Expected interface{}

+ func (matcher *AssignableToTypeOfMatcher) FailureMessage(actual interface{}) string

+ func (matcher *AssignableToTypeOfMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *AssignableToTypeOfMatcher) NegatedFailureMessage(actual interface{}) string

+ type BeADirectoryMatcher struct

+ func (matcher *BeADirectoryMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *BeADirectoryMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *BeADirectoryMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type BeARegularFileMatcher struct

+ func (matcher *BeARegularFileMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *BeARegularFileMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *BeARegularFileMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type BeAnExistingFileMatcher struct

+ func (matcher *BeAnExistingFileMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *BeAnExistingFileMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *BeAnExistingFileMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type BeClosedMatcher struct

+ func (matcher *BeClosedMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *BeClosedMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *BeClosedMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type BeElementOfMatcher struct

+ Elements []interface{}

+ func (matcher *BeElementOfMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *BeElementOfMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *BeElementOfMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type BeEmptyMatcher struct

+ func (matcher *BeEmptyMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *BeEmptyMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *BeEmptyMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type BeEquivalentToMatcher struct

+ Expected interface{}

+ func (matcher *BeEquivalentToMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *BeEquivalentToMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *BeEquivalentToMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type BeFalseMatcher struct

+ func (matcher *BeFalseMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *BeFalseMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *BeFalseMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type BeIdenticalToMatcher struct

+ Expected interface{}

+ func (matcher *BeIdenticalToMatcher) FailureMessage(actual interface{}) string

+ func (matcher *BeIdenticalToMatcher) Match(actual interface{}) (success bool, matchErr error)

+ func (matcher *BeIdenticalToMatcher) NegatedFailureMessage(actual interface{}) string

+ type BeNilMatcher struct

+ func (matcher *BeNilMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *BeNilMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *BeNilMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type BeNumericallyMatcher struct

+ Comparator string

+ CompareTo []interface{}

+ func (matcher *BeNumericallyMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *BeNumericallyMatcher) FormatFailureMessage(actual interface{}, negated bool) (message string)

+ func (matcher *BeNumericallyMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *BeNumericallyMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type BeSentMatcher struct

+ Arg interface{}

+ func (matcher *BeSentMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *BeSentMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *BeSentMatcher) MatchMayChangeInTheFuture(actual interface{}) bool

+ func (matcher *BeSentMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type BeTemporallyMatcher struct

+ Comparator string

+ CompareTo time.Time

+ Threshold []time.Duration

+ func (matcher *BeTemporallyMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *BeTemporallyMatcher) Match(actual interface{}) (bool, error)

+ func (matcher *BeTemporallyMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type BeTrueMatcher struct

+ func (matcher *BeTrueMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *BeTrueMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *BeTrueMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type BeZeroMatcher struct

+ func (matcher *BeZeroMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *BeZeroMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *BeZeroMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type ConsistOfMatcher struct

+ Elements []interface{}

+ func (matcher *ConsistOfMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *ConsistOfMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *ConsistOfMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type ContainElementMatcher struct

+ Element interface{}

+ func (matcher *ContainElementMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *ContainElementMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *ContainElementMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type ContainElementsMatcher struct

+ Elements []interface{}

+ func (matcher *ContainElementsMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *ContainElementsMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *ContainElementsMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type ContainSubstringMatcher struct

+ Args []interface{}

+ Substr string

+ func (matcher *ContainSubstringMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *ContainSubstringMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *ContainSubstringMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type EqualMatcher struct

+ Expected interface{}

+ func (matcher *EqualMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *EqualMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *EqualMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type HaveCapMatcher struct

+ Count int

+ func (matcher *HaveCapMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *HaveCapMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *HaveCapMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type HaveHTTPStatusMatcher struct

+ Expected interface{}

+ func (matcher *HaveHTTPStatusMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *HaveHTTPStatusMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *HaveHTTPStatusMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type HaveKeyMatcher struct

+ Key interface{}

+ func (matcher *HaveKeyMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *HaveKeyMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *HaveKeyMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type HaveKeyWithValueMatcher struct

+ Key interface{}

+ Value interface{}

+ func (matcher *HaveKeyWithValueMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *HaveKeyWithValueMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *HaveKeyWithValueMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type HaveLenMatcher struct

+ Count int

+ func (matcher *HaveLenMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *HaveLenMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *HaveLenMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type HaveOccurredMatcher struct

+ func (matcher *HaveOccurredMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *HaveOccurredMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *HaveOccurredMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type HavePrefixMatcher struct

+ Args []interface{}

+ Prefix string

+ func (matcher *HavePrefixMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *HavePrefixMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *HavePrefixMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type HaveSuffixMatcher struct

+ Args []interface{}

+ Suffix string

+ func (matcher *HaveSuffixMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *HaveSuffixMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *HaveSuffixMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type MatchErrorMatcher struct

+ Expected interface{}

+ func (matcher *MatchErrorMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *MatchErrorMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *MatchErrorMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type MatchJSONMatcher struct

+ JSONToMatch interface{}

+ func (matcher *MatchJSONMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *MatchJSONMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *MatchJSONMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type MatchRegexpMatcher struct

+ Args []interface{}

+ Regexp string

+ func (matcher *MatchRegexpMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *MatchRegexpMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *MatchRegexpMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type MatchXMLMatcher struct

+ XMLToMatch interface{}

+ func (matcher *MatchXMLMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *MatchXMLMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *MatchXMLMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type NotMatcher struct

+ Matcher types.GomegaMatcher

+ func (m *NotMatcher) FailureMessage(actual interface{}) (message string)

+ func (m *NotMatcher) Match(actual interface{}) (bool, error)

+ func (m *NotMatcher) MatchMayChangeInTheFuture(actual interface{}) bool

+ func (m *NotMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type OrMatcher struct

+ Matchers []types.GomegaMatcher

+ func (m *OrMatcher) FailureMessage(actual interface{}) (message string)

+ func (m *OrMatcher) Match(actual interface{}) (success bool, err error)

+ func (m *OrMatcher) MatchMayChangeInTheFuture(actual interface{}) bool

+ func (m *OrMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type PanicMatcher struct

+ Expected interface{}

+ func (matcher *PanicMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *PanicMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *PanicMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type ReceiveMatcher struct

+ Arg interface{}

+ func (matcher *ReceiveMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *ReceiveMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *ReceiveMatcher) MatchMayChangeInTheFuture(actual interface{}) bool

+ func (matcher *ReceiveMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type SucceedMatcher struct

+ func (matcher *SucceedMatcher) FailureMessage(actual interface{}) (message string)

+ func (matcher *SucceedMatcher) Match(actual interface{}) (success bool, err error)

+ func (matcher *SucceedMatcher) NegatedFailureMessage(actual interface{}) (message string)

+ type WithTransformMatcher struct

+ Matcher types.GomegaMatcher

+ Transform interface{}

+ func NewWithTransformMatcher(transform interface{}, matcher types.GomegaMatcher) *WithTransformMatcher

+ func (m *WithTransformMatcher) FailureMessage(_ interface{}) (message string)

+ func (m *WithTransformMatcher) Match(actual interface{}) (bool, error)

+ func (m *WithTransformMatcher) MatchMayChangeInTheFuture(_ interface{}) bool

+ func (m *WithTransformMatcher) NegatedFailureMessage(_ interface{}) (message string)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL