1// untested sections: 3 2 3package matchers 4 5import ( 6 "fmt" 7 "reflect" 8 9 "github.com/onsi/gomega/format" 10 "github.com/onsi/gomega/matchers/support/goraph/bipartitegraph" 11) 12 13type ConsistOfMatcher struct { 14 Elements []interface{} 15 missingElements []interface{} 16 extraElements []interface{} 17} 18 19func (matcher *ConsistOfMatcher) Match(actual interface{}) (success bool, err error) { 20 if !isArrayOrSlice(actual) && !isMap(actual) { 21 return false, fmt.Errorf("ConsistOf matcher expects an array/slice/map. Got:\n%s", format.Object(actual, 1)) 22 } 23 24 matchers := matchers(matcher.Elements) 25 values := valuesOf(actual) 26 27 bipartiteGraph, err := bipartitegraph.NewBipartiteGraph(values, matchers, neighbours) 28 if err != nil { 29 return false, err 30 } 31 32 edges := bipartiteGraph.LargestMatching() 33 if len(edges) == len(values) && len(edges) == len(matchers) { 34 return true, nil 35 } 36 37 var missingMatchers []interface{} 38 matcher.extraElements, missingMatchers = bipartiteGraph.FreeLeftRight(edges) 39 matcher.missingElements = equalMatchersToElements(missingMatchers) 40 41 return false, nil 42} 43 44func neighbours(value, matcher interface{}) (bool, error) { 45 match, err := matcher.(omegaMatcher).Match(value) 46 return match && err == nil, nil 47} 48 49func equalMatchersToElements(matchers []interface{}) (elements []interface{}) { 50 for _, matcher := range matchers { 51 equalMatcher, ok := matcher.(*EqualMatcher) 52 if ok { 53 matcher = equalMatcher.Expected 54 } 55 elements = append(elements, matcher) 56 } 57 return 58} 59 60func flatten(elems []interface{}) []interface{} { 61 if len(elems) != 1 || !isArrayOrSlice(elems[0]) { 62 return elems 63 } 64 65 value := reflect.ValueOf(elems[0]) 66 flattened := make([]interface{}, value.Len()) 67 for i := 0; i < value.Len(); i++ { 68 flattened[i] = value.Index(i).Interface() 69 } 70 return flattened 71} 72 73func matchers(expectedElems []interface{}) (matchers []interface{}) { 74 for _, e := range flatten(expectedElems) { 75 matcher, isMatcher := e.(omegaMatcher) 76 if !isMatcher { 77 matcher = &EqualMatcher{Expected: e} 78 } 79 matchers = append(matchers, matcher) 80 } 81 return 82} 83 84func presentable(elems []interface{}) interface{} { 85 elems = flatten(elems) 86 87 if len(elems) == 0 { 88 return []interface{}{} 89 } 90 91 sv := reflect.ValueOf(elems) 92 tt := sv.Index(0).Elem().Type() 93 for i := 1; i < sv.Len(); i++ { 94 if sv.Index(i).Elem().Type() != tt { 95 return elems 96 } 97 } 98 99 ss := reflect.MakeSlice(reflect.SliceOf(tt), sv.Len(), sv.Len()) 100 for i := 0; i < sv.Len(); i++ { 101 ss.Index(i).Set(sv.Index(i).Elem()) 102 } 103 104 return ss.Interface() 105} 106 107func valuesOf(actual interface{}) []interface{} { 108 value := reflect.ValueOf(actual) 109 values := []interface{}{} 110 if isMap(actual) { 111 keys := value.MapKeys() 112 for i := 0; i < value.Len(); i++ { 113 values = append(values, value.MapIndex(keys[i]).Interface()) 114 } 115 } else { 116 for i := 0; i < value.Len(); i++ { 117 values = append(values, value.Index(i).Interface()) 118 } 119 } 120 121 return values 122} 123 124func (matcher *ConsistOfMatcher) FailureMessage(actual interface{}) (message string) { 125 message = format.Message(actual, "to consist of", presentable(matcher.Elements)) 126 message = appendMissingElements(message, matcher.missingElements) 127 if len(matcher.extraElements) > 0 { 128 message = fmt.Sprintf("%s\nthe extra elements were\n%s", message, 129 format.Object(presentable(matcher.extraElements), 1)) 130 } 131 return 132} 133 134func appendMissingElements(message string, missingElements []interface{}) string { 135 if len(missingElements) == 0 { 136 return message 137 } 138 return fmt.Sprintf("%s\nthe missing elements were\n%s", message, 139 format.Object(presentable(missingElements), 1)) 140} 141 142func (matcher *ConsistOfMatcher) NegatedFailureMessage(actual interface{}) (message string) { 143 return format.Message(actual, "not to consist of", presentable(matcher.Elements)) 144} 145