callset.go

Documentation: github.com/golang/mock/gomock

     1  // Copyright 2011 Google Inc.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package gomock
    16  
    17  import (
    18  	"bytes"
    19  	"errors"
    20  	"fmt"
    21  )
    22  
    23  // callSet represents a set of expected calls, indexed by receiver and method
    24  // name.
    25  type callSet struct {
    26  	// Calls that are still expected.
    27  	expected map[callSetKey][]*Call
    28  	// Calls that have been exhausted.
    29  	exhausted map[callSetKey][]*Call
    30  }
    31  
    32  // callSetKey is the key in the maps in callSet
    33  type callSetKey struct {
    34  	receiver interface{}
    35  	fname    string
    36  }
    37  
    38  func newCallSet() *callSet {
    39  	return &callSet{make(map[callSetKey][]*Call), make(map[callSetKey][]*Call)}
    40  }
    41  
    42  // Add adds a new expected call.
    43  func (cs callSet) Add(call *Call) {
    44  	key := callSetKey{call.receiver, call.method}
    45  	m := cs.expected
    46  	if call.exhausted() {
    47  		m = cs.exhausted
    48  	}
    49  	m[key] = append(m[key], call)
    50  }
    51  
    52  // Remove removes an expected call.
    53  func (cs callSet) Remove(call *Call) {
    54  	key := callSetKey{call.receiver, call.method}
    55  	calls := cs.expected[key]
    56  	for i, c := range calls {
    57  		if c == call {
    58  			// maintain order for remaining calls
    59  			cs.expected[key] = append(calls[:i], calls[i+1:]...)
    60  			cs.exhausted[key] = append(cs.exhausted[key], call)
    61  			break
    62  		}
    63  	}
    64  }
    65  
    66  // FindMatch searches for a matching call. Returns error with explanation message if no call matched.
    67  func (cs callSet) FindMatch(receiver interface{}, method string, args []interface{}) (*Call, error) {
    68  	key := callSetKey{receiver, method}
    69  
    70  	// Search through the expected calls.
    71  	expected := cs.expected[key]
    72  	var callsErrors bytes.Buffer
    73  	for _, call := range expected {
    74  		err := call.matches(args)
    75  		if err != nil {
    76  			_, _ = fmt.Fprintf(&callsErrors, "\n%v", err)
    77  		} else {
    78  			return call, nil
    79  		}
    80  	}
    81  
    82  	// If we haven't found a match then search through the exhausted calls so we
    83  	// get useful error messages.
    84  	exhausted := cs.exhausted[key]
    85  	for _, call := range exhausted {
    86  		if err := call.matches(args); err != nil {
    87  			_, _ = fmt.Fprintf(&callsErrors, "\n%v", err)
    88  			continue
    89  		}
    90  		_, _ = fmt.Fprintf(
    91  			&callsErrors, "all expected calls for method %q have been exhausted", method,
    92  		)
    93  	}
    94  
    95  	if len(expected)+len(exhausted) == 0 {
    96  		_, _ = fmt.Fprintf(&callsErrors, "there are no expected calls of the method %q for that receiver", method)
    97  	}
    98  
    99  	return nil, errors.New(callsErrors.String())
   100  }
   101  
   102  // Failures returns the calls that are not satisfied.
   103  func (cs callSet) Failures() []*Call {
   104  	failures := make([]*Call, 0, len(cs.expected))
   105  	for _, calls := range cs.expected {
   106  		for _, call := range calls {
   107  			if !call.satisfied() {
   108  				failures = append(failures, call)
   109  			}
   110  		}
   111  	}
   112  	return failures
   113  }
   114
View as plain text