initial commit

[govpp.git] / vendor / github.com / onsi / gomega / matchers / or.go

diff --git a/vendor/github.com/onsi/gomega/matchers/or.go b/vendor/github.com/onsi/gomega/matchers/or.go
new file mode 100644 (file)
index 0000000..3bf7998
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/or.go
@@ -0,0 +1,67 @@
+package matchers
+
+import (
+       "fmt"
+
+       "github.com/onsi/gomega/format"
+       "github.com/onsi/gomega/internal/oraclematcher"
+       "github.com/onsi/gomega/types"
+)
+
+type OrMatcher struct {
+       Matchers []types.GomegaMatcher
+
+       // state
+       firstSuccessfulMatcher types.GomegaMatcher
+}
+
+func (m *OrMatcher) Match(actual interface{}) (success bool, err error) {
+       m.firstSuccessfulMatcher = nil
+       for _, matcher := range m.Matchers {
+               success, err := matcher.Match(actual)
+               if err != nil {
+                       return false, err
+               }
+               if success {
+                       m.firstSuccessfulMatcher = matcher
+                       return true, nil
+               }
+       }
+       return false, nil
+}
+
+func (m *OrMatcher) FailureMessage(actual interface{}) (message string) {
+       // not the most beautiful list of matchers, but not bad either...
+       return format.Message(actual, fmt.Sprintf("To satisfy at least one of these matchers: %s", m.Matchers))
+}
+
+func (m *OrMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+       return m.firstSuccessfulMatcher.NegatedFailureMessage(actual)
+}
+
+func (m *OrMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
+       /*
+               Example with 3 matchers: A, B, C
+
+               Match evaluates them: F, T, <?>  => T
+               So match is currently T, what should MatchMayChangeInTheFuture() return?
+               Seems like it only depends on B, since currently B MUST change to allow the result to become F
+
+               Match eval: F, F, F  => F
+               So match is currently F, what should MatchMayChangeInTheFuture() return?
+               Seems to depend on ANY of them being able to change to T.
+       */
+
+       if m.firstSuccessfulMatcher != nil {
+               // one of the matchers succeeded.. it must be able to change in order to affect the result
+               return oraclematcher.MatchMayChangeInTheFuture(m.firstSuccessfulMatcher, actual)
+       } else {
+               // so all matchers failed.. Any one of them changing would change the result.
+               for _, matcher := range m.Matchers {
+                       if oraclematcher.MatchMayChangeInTheFuture(matcher, actual) {
+                               return true
+                       }
+               }
+               return false // none of were going to change
+       }
+}