|
- // Copyright 2010 Google Inc.
- //
- // Licensed under the Apache License, Version 2.0 (the "License");
- // you may not use this file except in compliance with the License.
- // You may obtain a copy of the License at
- //
- // http://www.apache.org/licenses/LICENSE-2.0
- //
- // Unless required by applicable law or agreed to in writing, software
- // distributed under the License is distributed on an "AS IS" BASIS,
- // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- // See the License for the specific language governing permissions and
- // limitations under the License.
-
- package gomock
-
- import (
- "fmt"
- "reflect"
- )
-
- // A Matcher is a representation of a class of values.
- // It is used to represent the valid or expected arguments to a mocked method.
- type Matcher interface {
- // Matches returns whether x is a match.
- Matches(x interface{}) bool
-
- // String describes what the matcher matches.
- String() string
- }
-
- type anyMatcher struct{}
-
- func (anyMatcher) Matches(x interface{}) bool {
- return true
- }
-
- func (anyMatcher) String() string {
- return "is anything"
- }
-
- type eqMatcher struct {
- x interface{}
- }
-
- func (e eqMatcher) Matches(x interface{}) bool {
- return reflect.DeepEqual(e.x, x)
- }
-
- func (e eqMatcher) String() string {
- return fmt.Sprintf("is equal to %v", e.x)
- }
-
- type nilMatcher struct{}
-
- func (nilMatcher) Matches(x interface{}) bool {
- if x == nil {
- return true
- }
-
- v := reflect.ValueOf(x)
- switch v.Kind() {
- case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map,
- reflect.Ptr, reflect.Slice:
- return v.IsNil()
- }
-
- return false
- }
-
- func (nilMatcher) String() string {
- return "is nil"
- }
-
- type notMatcher struct {
- m Matcher
- }
-
- func (n notMatcher) Matches(x interface{}) bool {
- return !n.m.Matches(x)
- }
-
- func (n notMatcher) String() string {
- // TODO: Improve this if we add a NotString method to the Matcher interface.
- return "not(" + n.m.String() + ")"
- }
-
- type assignableToTypeOfMatcher struct {
- targetType reflect.Type
- }
-
- func (m assignableToTypeOfMatcher) Matches(x interface{}) bool {
- return reflect.TypeOf(x).AssignableTo(m.targetType)
- }
-
- func (m assignableToTypeOfMatcher) String() string {
- return "is assignable to " + m.targetType.Name()
- }
-
- // Constructors
- // Any returns a matcher that always matches.
- func Any() Matcher { return anyMatcher{} }
-
- // Eq returns a matcher that matches on equality.
- //
- // Example usage:
- // Eq(5).Matches(5) // returns true
- // Eq(5).Matches(4) // returns false
- func Eq(x interface{}) Matcher { return eqMatcher{x} }
-
- // Nil returns a matcher that matches if the received value is nil.
- //
- // Example usage:
- // var x *bytes.Buffer
- // Nil().Matches(x) // returns true
- // x = &bytes.Buffer{}
- // Nil().Matches(x) // returns false
- func Nil() Matcher { return nilMatcher{} }
-
- // Not reverses the results of its given child matcher.
- //
- // Example usage:
- // Not(Eq(5)).Matches(4) // returns true
- // Not(Eq(5)).Matches(5) // returns false
- func Not(x interface{}) Matcher {
- if m, ok := x.(Matcher); ok {
- return notMatcher{m}
- }
- return notMatcher{Eq(x)}
- }
-
- // AssignableToTypeOf is a Matcher that matches if the parameter to the mock
- // function is assignable to the type of the parameter to this function.
- //
- // Example usage:
- // var s fmt.Stringer = &bytes.Buffer{}
- // AssignableToTypeOf(s).Matches(time.Second) // returns true
- // AssignableToTypeOf(s).Matches(99) // returns false
- func AssignableToTypeOf(x interface{}) Matcher {
- return assignableToTypeOfMatcher{reflect.TypeOf(x)}
- }
|