1
package matchers
2

3
import (
4
	"fmt"
5
	"reflect"
6

7
	"github.com/onsi/gomega/format"
8
	"github.com/onsi/gomega/matchers/internal/miter"
9
)
10

11
type HaveEachMatcher struct {
12
	Element any
13
}
14

15
func (matcher *HaveEachMatcher) Match(actual any) (success bool, err error) {
16
	if !isArrayOrSlice(actual) && !isMap(actual) && !miter.IsIter(actual) {
17
		return false, fmt.Errorf("HaveEach matcher expects an array/slice/map/iter.Seq/iter.Seq2.  Got:\n%s",
18
			format.Object(actual, 1))
19
	}
20

21
	elemMatcher, elementIsMatcher := matcher.Element.(omegaMatcher)
22
	if !elementIsMatcher {
23
		elemMatcher = &EqualMatcher{Expected: matcher.Element}
24
	}
25

26
	if miter.IsIter(actual) {
27
		// rejecting the non-elements case works different for iterators as we
28
		// don't want to fetch all elements into a slice first.
29
		count := 0
30
		var success bool
31
		var err error
32
		if miter.IsSeq2(actual) {
33
			miter.IterateKV(actual, func(k, v reflect.Value) bool {
34
				count++
35
				success, err = elemMatcher.Match(v.Interface())
36
				if err != nil {
37
					return false
38
				}
39
				return success
40
			})
41
		} else {
42
			miter.IterateV(actual, func(v reflect.Value) bool {
43
				count++
44
				success, err = elemMatcher.Match(v.Interface())
45
				if err != nil {
46
					return false
47
				}
48
				return success
49
			})
50
		}
51
		if count == 0 {
52
			return false, fmt.Errorf("HaveEach matcher expects a non-empty iter.Seq/iter.Seq2.  Got:\n%s",
53
				format.Object(actual, 1))
54
		}
55
		return success, err
56
	}
57

58
	value := reflect.ValueOf(actual)
59
	if value.Len() == 0 {
60
		return false, fmt.Errorf("HaveEach matcher expects a non-empty array/slice/map.  Got:\n%s",
61
			format.Object(actual, 1))
62
	}
63

64
	var valueAt func(int) any
65
	if isMap(actual) {
66
		keys := value.MapKeys()
67
		valueAt = func(i int) any {
68
			return value.MapIndex(keys[i]).Interface()
69
		}
70
	} else {
71
		valueAt = func(i int) any {
72
			return value.Index(i).Interface()
73
		}
74
	}
75

76
	// if we never failed then we succeed; the empty/nil cases have already been
77
	// rejected above.
78
	for i := 0; i < value.Len(); i++ {
79
		success, err := elemMatcher.Match(valueAt(i))
80
		if err != nil {
81
			return false, err
82
		}
83
		if !success {
84
			return false, nil
85
		}
86
	}
87

88
	return true, nil
89
}
90

91
// FailureMessage returns a suitable failure message.
92
func (matcher *HaveEachMatcher) FailureMessage(actual any) (message string) {
93
	return format.Message(actual, "to contain element matching", matcher.Element)
94
}
95

96
// NegatedFailureMessage returns a suitable negated failure message.
97
func (matcher *HaveEachMatcher) NegatedFailureMessage(actual any) (message string) {
98
	return format.Message(actual, "not to contain element matching", matcher.Element)
99
}
100

101