update dependencies

Signed-off-by: hongming <talonwan@yunify.com>

vendor/github.com/onsi/gomega/matchers/assignable_to_type_of_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_a_directory.go

@@ -1,3 +1,5 @@
+// untested sections: 5
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_a_regular_file.go

@@ -1,3 +1,5 @@
+// untested sections: 5
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_an_existing_file.go

@@ -1,3 +1,5 @@
+// untested sections: 3
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_closed_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_element_of_matcher.go

@@ -0,0 +1,57 @@
+// untested sections: 1
+
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/onsi/gomega/format"
+)
+
+type BeElementOfMatcher struct {
+	Elements []interface{}
+}
+
+func (matcher *BeElementOfMatcher) Match(actual interface{}) (success bool, err error) {
+	if reflect.TypeOf(actual) == nil {
+		return false, fmt.Errorf("BeElement matcher expects actual to be typed")
+	}
+
+	length := len(matcher.Elements)
+	valueAt := func(i int) interface{} {
+		return matcher.Elements[i]
+	}
+	// Special handling of a single element of type Array or Slice
+	if length == 1 && isArrayOrSlice(valueAt(0)) {
+		element := valueAt(0)
+		value := reflect.ValueOf(element)
+		length = value.Len()
+		valueAt = func(i int) interface{} {
+			return value.Index(i).Interface()
+		}
+	}
+
+	var lastError error
+	for i := 0; i < length; i++ {
+		matcher := &EqualMatcher{Expected: valueAt(i)}
+		success, err := matcher.Match(actual)
+		if err != nil {
+			lastError = err
+			continue
+		}
+		if success {
+			return true, nil
+		}
+	}
+
+	return false, lastError
+}
+
+func (matcher *BeElementOfMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to be an element of", matcher.Elements)
+}
+
+func (matcher *BeElementOfMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to be an element of", matcher.Elements)
+}

vendor/github.com/onsi/gomega/matchers/be_empty_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_equivalent_to_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_false_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_identical_to.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_nil_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import "github.com/onsi/gomega/format"

vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 4
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_sent_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 3
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_temporally_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 3
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_true_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/consist_of.go

@@ -1,3 +1,5 @@
+// untested sections: 3
+
 package matchers
 
 import (
@@ -9,7 +11,9 @@ import (
 )
 
 type ConsistOfMatcher struct {
-	Elements []interface{}
+	Elements        []interface{}
+	missingElements []interface{}
+	extraElements   []interface{}
 }
 
 func (matcher *ConsistOfMatcher) Match(actual interface{}) (success bool, err error) {
@@ -17,44 +21,63 @@ func (matcher *ConsistOfMatcher) Match(actual interface{}) (success bool, err er
 		return false, fmt.Errorf("ConsistOf matcher expects an array/slice/map.  Got:\n%s", format.Object(actual, 1))
 	}
 
-	elements := matcher.Elements
-	if len(matcher.Elements) == 1 && isArrayOrSlice(matcher.Elements[0]) {
-		elements = []interface{}{}
-		value := reflect.ValueOf(matcher.Elements[0])
-		for i := 0; i < value.Len(); i++ {
-			elements = append(elements, value.Index(i).Interface())
-		}
-	}
-
-	matchers := []interface{}{}
-	for _, element := range elements {
-		matcher, isMatcher := element.(omegaMatcher)
-		if !isMatcher {
-			matcher = &EqualMatcher{Expected: element}
-		}
-		matchers = append(matchers, matcher)
-	}
-
-	values := matcher.valuesOf(actual)
-
-	if len(values) != len(matchers) {
-		return false, nil
-	}
-
-	neighbours := func(v, m interface{}) (bool, error) {
-		match, err := m.(omegaMatcher).Match(v)
-		return match && err == nil, nil
-	}
+	matchers := matchers(matcher.Elements)
+	values := valuesOf(actual)
 
 	bipartiteGraph, err := bipartitegraph.NewBipartiteGraph(values, matchers, neighbours)
 	if err != nil {
 		return false, err
 	}
 
-	return len(bipartiteGraph.LargestMatching()) == len(values), nil
+	edges := bipartiteGraph.LargestMatching()
+	if len(edges) == len(values) && len(edges) == len(matchers) {
+		return true, nil
+	}
+
+	var missingMatchers []interface{}
+	matcher.extraElements, missingMatchers = bipartiteGraph.FreeLeftRight(edges)
+	matcher.missingElements = equalMatchersToElements(missingMatchers)
+
+	return false, nil
 }
 
-func (matcher *ConsistOfMatcher) valuesOf(actual interface{}) []interface{} {
+func neighbours(value, matcher interface{}) (bool, error) {
+	match, err := matcher.(omegaMatcher).Match(value)
+	return match && err == nil, nil
+}
+
+func equalMatchersToElements(matchers []interface{}) (elements []interface{}) {
+	for _, matcher := range matchers {
+		equalMatcher, ok := matcher.(*EqualMatcher)
+		if ok {
+			matcher = equalMatcher.Expected
+		}
+		elements = append(elements, matcher)
+	}
+	return
+}
+
+func matchers(expectedElems []interface{}) (matchers []interface{}) {
+	elems := expectedElems
+	if len(expectedElems) == 1 && isArrayOrSlice(expectedElems[0]) {
+		elems = []interface{}{}
+		value := reflect.ValueOf(expectedElems[0])
+		for i := 0; i < value.Len(); i++ {
+			elems = append(elems, value.Index(i).Interface())
+		}
+	}
+
+	for _, e := range elems {
+		matcher, isMatcher := e.(omegaMatcher)
+		if !isMatcher {
+			matcher = &EqualMatcher{Expected: e}
+		}
+		matchers = append(matchers, matcher)
+	}
+	return
+}
+
+func valuesOf(actual interface{}) []interface{} {
 	value := reflect.ValueOf(actual)
 	values := []interface{}{}
 	if isMap(actual) {
@@ -72,7 +95,21 @@ func (matcher *ConsistOfMatcher) valuesOf(actual interface{}) []interface{} {
 }
 
 func (matcher *ConsistOfMatcher) FailureMessage(actual interface{}) (message string) {
-	return format.Message(actual, "to consist of", matcher.Elements)
+	message = format.Message(actual, "to consist of", matcher.Elements)
+	message = appendMissingElements(message, matcher.missingElements)
+	if len(matcher.extraElements) > 0 {
+		message = fmt.Sprintf("%s\nthe extra elements were\n%s", message,
+			format.Object(matcher.extraElements, 1))
+	}
+	return
+}
+
+func appendMissingElements(message string, missingElements []interface{}) string {
+	if len(missingElements) == 0 {
+		return message
+	}
+	return fmt.Sprintf("%s\nthe missing elements were\n%s", message,
+		format.Object(missingElements, 1))
 }
 
 func (matcher *ConsistOfMatcher) NegatedFailureMessage(actual interface{}) (message string) {

vendor/github.com/onsi/gomega/matchers/contain_element_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (
@@ -22,19 +24,21 @@ func (matcher *ContainElementMatcher) Match(actual interface{}) (success bool, e
 	}
 
 	value := reflect.ValueOf(actual)
-	var keys []reflect.Value
+	var valueAt func(int) interface{}
 	if isMap(actual) {
-		keys = value.MapKeys()
+		keys := value.MapKeys()
+		valueAt = func(i int) interface{} {
+			return value.MapIndex(keys[i]).Interface()
+		}
+	} else {
+		valueAt = func(i int) interface{} {
+			return value.Index(i).Interface()
+		}
 	}
+
 	var lastError error
 	for i := 0; i < value.Len(); i++ {
-		var success bool
-		var err error
-		if isMap(actual) {
-			success, err = elemMatcher.Match(value.MapIndex(keys[i]).Interface())
-		} else {
-			success, err = elemMatcher.Match(value.Index(i).Interface())
-		}
+		success, err := elemMatcher.Match(valueAt(i))
 		if err != nil {
 			lastError = err
 			continue

vendor/github.com/onsi/gomega/matchers/contain_elements_matcher.go

@@ -0,0 +1,44 @@
+package matchers
+
+import (
+	"fmt"
+
+	"github.com/onsi/gomega/format"
+	"github.com/onsi/gomega/matchers/support/goraph/bipartitegraph"
+)
+
+type ContainElementsMatcher struct {
+	Elements        []interface{}
+	missingElements []interface{}
+}
+
+func (matcher *ContainElementsMatcher) Match(actual interface{}) (success bool, err error) {
+	if !isArrayOrSlice(actual) && !isMap(actual) {
+		return false, fmt.Errorf("ContainElements matcher expects an array/slice/map.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	matchers := matchers(matcher.Elements)
+	bipartiteGraph, err := bipartitegraph.NewBipartiteGraph(valuesOf(actual), matchers, neighbours)
+	if err != nil {
+		return false, err
+	}
+
+	edges := bipartiteGraph.LargestMatching()
+	if len(edges) == len(matchers) {
+		return true, nil
+	}
+
+	_, missingMatchers := bipartiteGraph.FreeLeftRight(edges)
+	matcher.missingElements = equalMatchersToElements(missingMatchers)
+
+	return false, nil
+}
+
+func (matcher *ContainElementsMatcher) FailureMessage(actual interface{}) (message string) {
+	message = format.Message(actual, "to contain elements", matcher.Elements)
+	return appendMissingElements(message, matcher.missingElements)
+}
+
+func (matcher *ContainElementsMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to contain elements", matcher.Elements)
+}

vendor/github.com/onsi/gomega/matchers/contain_substring_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/have_cap_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/have_http_status_matcher.go

@@ -0,0 +1,42 @@
+package matchers
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+
+	"github.com/onsi/gomega/format"
+)
+
+type HaveHTTPStatusMatcher struct {
+	Expected interface{}
+}
+
+func (matcher *HaveHTTPStatusMatcher) Match(actual interface{}) (success bool, err error) {
+	var resp *http.Response
+	switch a := actual.(type) {
+	case *http.Response:
+		resp = a
+	case *httptest.ResponseRecorder:
+		resp = a.Result()
+	default:
+		return false, fmt.Errorf("HaveHTTPStatus matcher expects *http.Response or *httptest.ResponseRecorder. Got:\n%s", format.Object(actual, 1))
+	}
+
+	switch e := matcher.Expected.(type) {
+	case int:
+		return resp.StatusCode == e, nil
+	case string:
+		return resp.Status == e, nil
+	}
+
+	return false, fmt.Errorf("HaveHTTPStatus matcher must be passed an int or a string. Got:\n%s", format.Object(matcher.Expected, 1))
+}
+
+func (matcher *HaveHTTPStatusMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to have HTTP status", matcher.Expected)
+}
+
+func (matcher *HaveHTTPStatusMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to have HTTP status", matcher.Expected)
+}

vendor/github.com/onsi/gomega/matchers/have_key_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 6
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go

@@ -1,3 +1,5 @@
+// untested sections:10
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/have_occurred_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/match_error_matcher.go

@@ -5,6 +5,7 @@ import (
 	"reflect"
 
 	"github.com/onsi/gomega/format"
+	"golang.org/x/xerrors"
 )
 
 type MatchErrorMatcher struct {
@@ -21,25 +22,28 @@ func (matcher *MatchErrorMatcher) Match(actual interface{}) (success bool, err e
 	}
 
 	actualErr := actual.(error)
+	expected := matcher.Expected
 
-	if isError(matcher.Expected) {
-		return reflect.DeepEqual(actualErr, matcher.Expected), nil
+	if isError(expected) {
+		return reflect.DeepEqual(actualErr, expected) || xerrors.Is(actualErr, expected.(error)), nil
 	}
 
-	if isString(matcher.Expected) {
-		return actualErr.Error() == matcher.Expected, nil
+	if isString(expected) {
+		return actualErr.Error() == expected, nil
 	}
 
 	var subMatcher omegaMatcher
 	var hasSubMatcher bool
-	if matcher.Expected != nil {
-		subMatcher, hasSubMatcher = (matcher.Expected).(omegaMatcher)
+	if expected != nil {
+		subMatcher, hasSubMatcher = (expected).(omegaMatcher)
 		if hasSubMatcher {
 			return subMatcher.Match(actualErr.Error())
 		}
 	}
 
-	return false, fmt.Errorf("MatchError must be passed an error, string, or Matcher that can match on strings.  Got:\n%s", format.Object(matcher.Expected, 1))
+	return false, fmt.Errorf(
+		"MatchError must be passed an error, a string, or a Matcher that can match on strings. Got:\n%s",
+		format.Object(expected, 1))
 }
 
 func (matcher *MatchErrorMatcher) FailureMessage(actual interface{}) (message string) {

vendor/github.com/onsi/gomega/matchers/panic_matcher.go

@@ -8,7 +8,8 @@ import (
 )
 
 type PanicMatcher struct {
-	object interface{}
+	Expected interface{}
+	object   interface{}
 }
 
 func (matcher *PanicMatcher) Match(actual interface{}) (success bool, err error) {
@@ -28,7 +29,21 @@ func (matcher *PanicMatcher) Match(actual interface{}) (success bool, err error)
 	defer func() {
 		if e := recover(); e != nil {
 			matcher.object = e
-			success = true
+
+			if matcher.Expected == nil {
+				success = true
+				return
+			}
+
+			valueMatcher, valueIsMatcher := matcher.Expected.(omegaMatcher)
+			if !valueIsMatcher {
+				valueMatcher = &EqualMatcher{Expected: matcher.Expected}
+			}
+
+			success, err = valueMatcher.Match(e)
+			if err != nil {
+				err = fmt.Errorf("PanicMatcher's value matcher failed with:\n%s%s", format.Indent, err.Error())
+			}
 		}
 	}()
 
@@ -38,9 +53,62 @@ func (matcher *PanicMatcher) Match(actual interface{}) (success bool, err error)
 }
 
 func (matcher *PanicMatcher) FailureMessage(actual interface{}) (message string) {
-	return format.Message(actual, "to panic")
+	if matcher.Expected == nil {
+		// We wanted any panic to occur, but none did.
+		return format.Message(actual, "to panic")
+	}
+
+	if matcher.object == nil {
+		// We wanted a panic with a specific value to occur, but none did.
+		switch matcher.Expected.(type) {
+		case omegaMatcher:
+			return format.Message(actual, "to panic with a value matching", matcher.Expected)
+		default:
+			return format.Message(actual, "to panic with", matcher.Expected)
+		}
+	}
+
+	// We got a panic, but the value isn't what we expected.
+	switch matcher.Expected.(type) {
+	case omegaMatcher:
+		return format.Message(
+			actual,
+			fmt.Sprintf(
+				"to panic with a value matching\n%s\nbut panicked with\n%s",
+				format.Object(matcher.Expected, 1),
+				format.Object(matcher.object, 1),
+			),
+		)
+	default:
+		return format.Message(
+			actual,
+			fmt.Sprintf(
+				"to panic with\n%s\nbut panicked with\n%s",
+				format.Object(matcher.Expected, 1),
+				format.Object(matcher.object, 1),
+			),
+		)
+	}
 }
 
 func (matcher *PanicMatcher) NegatedFailureMessage(actual interface{}) (message string) {
-	return format.Message(actual, fmt.Sprintf("not to panic, but panicked with\n%s", format.Object(matcher.object, 1)))
+	if matcher.Expected == nil {
+		// We didn't want any panic to occur, but one did.
+		return format.Message(actual, fmt.Sprintf("not to panic, but panicked with\n%s", format.Object(matcher.object, 1)))
+	}
+
+	// We wanted a to ensure a panic with a specific value did not occur, but it did.
+	switch matcher.Expected.(type) {
+	case omegaMatcher:
+		return format.Message(
+			actual,
+			fmt.Sprintf(
+				"not to panic with a value matching\n%s\nbut panicked with\n%s",
+				format.Object(matcher.Expected, 1),
+				format.Object(matcher.object, 1),
+			),
+		)
+	default:
+		return format.Message(actual, "not to panic with", matcher.Expected)
+	}
 }

vendor/github.com/onsi/gomega/matchers/receive_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 3
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/semi_structured_data_support.go

@@ -1,3 +1,5 @@
+// untested sections: 5
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/support/goraph/bipartitegraph/bipartitegraph.go

@@ -1,6 +1,5 @@
 package bipartitegraph
 
-import "errors"
 import "fmt"
 
 import . "github.com/onsi/gomega/matchers/support/goraph/node"
@@ -14,13 +13,13 @@ type BipartiteGraph struct {
 
 func NewBipartiteGraph(leftValues, rightValues []interface{}, neighbours func(interface{}, interface{}) (bool, error)) (*BipartiteGraph, error) {
 	left := NodeOrderedSet{}
-	for i := range leftValues {
-		left = append(left, Node{Id: i})
+	for i, v := range leftValues {
+		left = append(left, Node{ID: i, Value: v})
 	}
 
 	right := NodeOrderedSet{}
-	for j := range rightValues {
-		right = append(right, Node{Id: j + len(left)})
+	for j, v := range rightValues {
+		right = append(right, Node{ID: j + len(left), Value: v})
 	}
 
 	edges := EdgeSet{}
@@ -28,14 +27,30 @@ func NewBipartiteGraph(leftValues, rightValues []interface{}, neighbours func(in
 		for j, rightValue := range rightValues {
 			neighbours, err := neighbours(leftValue, rightValue)
 			if err != nil {
-				return nil, errors.New(fmt.Sprintf("error determining adjacency for %v and %v: %s", leftValue, rightValue, err.Error()))
+				return nil, fmt.Errorf("error determining adjacency for %v and %v: %s", leftValue, rightValue, err.Error())
 			}
 
 			if neighbours {
-				edges = append(edges, Edge{Node1: left[i], Node2: right[j]})
+				edges = append(edges, Edge{Node1: left[i].ID, Node2: right[j].ID})
 			}
 		}
 	}
 
 	return &BipartiteGraph{left, right, edges}, nil
 }
+
+// FreeLeftRight returns left node values and right node values
+// of the BipartiteGraph's nodes which are not part of the given edges.
+func (bg *BipartiteGraph) FreeLeftRight(edges EdgeSet) (leftValues, rightValues []interface{}) {
+	for _, node := range bg.Left {
+		if edges.Free(node) {
+			leftValues = append(leftValues, node.Value)
+		}
+	}
+	for _, node := range bg.Right {
+		if edges.Free(node) {
+			rightValues = append(rightValues, node.Value)
+		}
+	}
+	return
+}

vendor/github.com/onsi/gomega/matchers/support/goraph/bipartitegraph/bipartitegraphmatching.go

@@ -1,9 +1,14 @@
 package bipartitegraph
 
-import . "github.com/onsi/gomega/matchers/support/goraph/node"
-import . "github.com/onsi/gomega/matchers/support/goraph/edge"
-import "github.com/onsi/gomega/matchers/support/goraph/util"
+import (
+	. "github.com/onsi/gomega/matchers/support/goraph/edge"
+	. "github.com/onsi/gomega/matchers/support/goraph/node"
+	"github.com/onsi/gomega/matchers/support/goraph/util"
+)
 
+// LargestMatching implements the Hopcroft–Karp algorithm taking as input a bipartite graph
+// and outputting a maximum cardinality matching, i.e. a set of as many edges as possible
+// with the property that no two edges share an endpoint.
 func (bg *BipartiteGraph) LargestMatching() (matching EdgeSet) {
 	paths := bg.maximalDisjointSLAPCollection(matching)
 
@@ -23,7 +28,7 @@ func (bg *BipartiteGraph) maximalDisjointSLAPCollection(matching EdgeSet) (resul
 		return
 	}
 
-	used := make(map[Node]bool)
+	used := make(map[int]bool)
 
 	for _, u := range guideLayers[len(guideLayers)-1] {
 		slap, found := bg.findDisjointSLAP(u, matching, guideLayers, used)
@@ -43,7 +48,7 @@ func (bg *BipartiteGraph) findDisjointSLAP(
 	start Node,
 	matching EdgeSet,
 	guideLayers []NodeOrderedSet,
-	used map[Node]bool,
+	used map[int]bool,
 ) ([]Edge, bool) {
 	return bg.findDisjointSLAPHelper(start, EdgeSet{}, len(guideLayers)-1, matching, guideLayers, used)
 }
@@ -54,16 +59,16 @@ func (bg *BipartiteGraph) findDisjointSLAPHelper(
 	currentLevel int,
 	matching EdgeSet,
 	guideLayers []NodeOrderedSet,
-	used map[Node]bool,
+	used map[int]bool,
 ) (EdgeSet, bool) {
-	used[currentNode] = true
+	used[currentNode.ID] = true
 
 	if currentLevel == 0 {
 		return currentSLAP, true
 	}
 
 	for _, nextNode := range guideLayers[currentLevel-1] {
-		if used[nextNode] {
+		if used[nextNode.ID] {
 			continue
 		}
 
@@ -84,17 +89,17 @@ func (bg *BipartiteGraph) findDisjointSLAPHelper(
 		currentSLAP = currentSLAP[:len(currentSLAP)-1]
 	}
 
-	used[currentNode] = false
+	used[currentNode.ID] = false
 	return nil, false
 }
 
 func (bg *BipartiteGraph) createSLAPGuideLayers(matching EdgeSet) (guideLayers []NodeOrderedSet) {
-	used := make(map[Node]bool)
+	used := make(map[int]bool)
 	currentLayer := NodeOrderedSet{}
 
 	for _, node := range bg.Left {
 		if matching.Free(node) {
-			used[node] = true
+			used[node.ID] = true
 			currentLayer = append(currentLayer, node)
 		}
 	}
@@ -113,7 +118,7 @@ func (bg *BipartiteGraph) createSLAPGuideLayers(matching EdgeSet) (guideLayers [
 		if util.Odd(len(guideLayers)) {
 			for _, leftNode := range lastLayer {
 				for _, rightNode := range bg.Right {
-					if used[rightNode] {
+					if used[rightNode.ID] {
 						continue
 					}
 
@@ -123,7 +128,7 @@ func (bg *BipartiteGraph) createSLAPGuideLayers(matching EdgeSet) (guideLayers [
 					}
 
 					currentLayer = append(currentLayer, rightNode)
-					used[rightNode] = true
+					used[rightNode.ID] = true
 
 					if matching.Free(rightNode) {
 						done = true
@@ -133,7 +138,7 @@ func (bg *BipartiteGraph) createSLAPGuideLayers(matching EdgeSet) (guideLayers [
 		} else {
 			for _, rightNode := range lastLayer {
 				for _, leftNode := range bg.Left {
-					if used[leftNode] {
+					if used[leftNode.ID] {
 						continue
 					}
 
@@ -143,7 +148,7 @@ func (bg *BipartiteGraph) createSLAPGuideLayers(matching EdgeSet) (guideLayers [
 					}
 
 					currentLayer = append(currentLayer, leftNode)
-					used[leftNode] = true
+					used[leftNode.ID] = true
 				}
 			}
 

vendor/github.com/onsi/gomega/matchers/support/goraph/edge/edge.go

@@ -3,15 +3,15 @@ package edge
 import . "github.com/onsi/gomega/matchers/support/goraph/node"
 
 type Edge struct {
-	Node1 Node
-	Node2 Node
+	Node1 int
+	Node2 int
 }
 
 type EdgeSet []Edge
 
 func (ec EdgeSet) Free(node Node) bool {
 	for _, e := range ec {
-		if e.Node1 == node || e.Node2 == node {
+		if e.Node1 == node.ID || e.Node2 == node.ID {
 			return false
 		}
 	}
@@ -31,7 +31,7 @@ func (ec EdgeSet) Contains(edge Edge) bool {
 
 func (ec EdgeSet) FindByNodes(node1, node2 Node) (Edge, bool) {
 	for _, e := range ec {
-		if (e.Node1 == node1 && e.Node2 == node2) || (e.Node1 == node2 && e.Node2 == node1) {
+		if (e.Node1 == node1.ID && e.Node2 == node2.ID) || (e.Node1 == node2.ID && e.Node2 == node1.ID) {
 			return e, true
 		}
 	}

vendor/github.com/onsi/gomega/matchers/support/goraph/node/node.go

@@ -1,7 +1,8 @@
 package node
 
 type Node struct {
-	Id int
+	ID    int
+	Value interface{}
 }
 
 type NodeOrderedSet []Node

vendor/github.com/onsi/gomega/matchers/type_support.go

@@ -6,6 +6,9 @@ See the docs for Gomega for documentation on the matchers
 
 http://onsi.github.io/gomega/
 */
+
+// untested sections: 11
+
 package matchers
 
 import (