// Is checks if the value eq with the expected value
194433
func Is(expectedValue interface{}) *isMatcher {
	matcher := new(isMatcher)
	matcher.expectedValue = expectedValue
	return matcher
}
191733
func ShouldDeepEqual(actual interface{}, expected ...interface{}) string {
	res := convey.ShouldResemble(actual, expected...)
	if res == "" {
		return ""
	}

	const msg0 = "Expected: '%v'\nActual:   '%v'\n(Should deep equal)!"
	const msg1 = "Expected: '%v'\nActual:   '%v'\n(Should deep equal: %v)!"

	diff := deep.Equal(expected[0], actual)
	format := "Not match %d items: %v"
	if len(diff) == 0 {
		return fmt.Sprintf(msg0, spew.Sdump(expected[0]), spew.Sdump(actual)) + "\n" + res
	}
	if len(diff) == 1 {
		format = "Not match %d item: %v"
	}
	return fmt.Sprintf(msg1, spew.Sdump(expected[0]), spew.Sdump(actual),
		fmt.Sprintf(format, len(diff), spew.Sdump(diff)),
	)
}
904463
func (i Interval) Eq(o Interval) bool {
	return i.Semitones() == o.Semitones()
}
853238
func Is(err error, errType ErrorType) bool {
	bErr, ok := err.(*BoulderError)
	if !ok {
		return false
	}
	return bErr.Type == errType
}
466720
func (self *Commands) IsString(value interface{}) error {
	if typeutil.IsKindOfString(value) {
		return nil
	} else {
		return fmt.Errorf("Expected string value")
	}
}
1136235
func (b *Boolean) Equal(value bool) *Boolean {
	if !(b.value == value) {
		b.chain.fail("expected boolean == %v, but got %v", value, b.value)
	}
	return b
}
1058213
func AreEqual(first, second api.Toleration) bool {
	if first.Key == second.Key &&
		first.Operator == second.Operator &&
		first.Value == second.Value &&
		first.Effect == second.Effect &&
		AreTolerationSecondsEqual(first.TolerationSeconds, second.TolerationSeconds) {
		return true
	}
	return false
}
30346
func (s Slice) IsEqualString(value string) (bool, error) {
	k, err := s.GetStringUTF8()
	if err != nil {
		return false, WithStack(err)
	}
	rc := bytes.Compare(k, []byte(value))
	return rc == 0, nil
}
425631
func (s *set) IsEqual(t Interface) bool {
	// Force locking only if given set is threadsafe.
	if conv, ok := t.(*Set); ok {
		conv.l.RLock()
		defer conv.l.RUnlock()
	}

	// return false if they are no the same size
	if sameSize := len(s.m) == t.Size(); !sameSize {
		return false
	}

	equal := true
	t.Each(func(item interface{}) bool {
		_, equal = s.m[item]
		return equal // if false, Each() will end
	})

	return equal
}
319900
func (l *LabelSelector) Eq(key, val string) {
	if !validLabelValue(key) || !validLabelValue(val) {
		return
	}
	l.stmts = append(l.stmts, key+"="+val)
}
393083
func (bol Boolean) Equal(other Value) bool {
	switch other := other.(type) {
	case Boolean:
		return bol == other
	default:
		return false
	}
}
924032
func (e *ComplexExplanation) IsMatch() bool {
	return e.match != nil && e.match.(bool) || e.match == nil && e.ExplanationImpl.IsMatch()
}
543329
func (schema *Schema) IsEqual(schema2 *Schema) bool {
	return schema.String() == schema2.String()
}
1193812
func areEqual(a, b interface{}) bool {
	if isNil(a) || isNil(b) {
		if isNil(a) && !isNil(b) {
			return false
		}
		if !isNil(a) && isNil(b) {
			return false
		}
		return a == b
	}
	if reflect.DeepEqual(a, b) {
		return true
	}
	aValue := reflect.ValueOf(a)
	bValue := reflect.ValueOf(b)
	if aValue == bValue {
		return true
	}

	// Attempt comparison after type conversion
	if bValue.Type().ConvertibleTo(aValue.Type()) {
		return reflect.DeepEqual(a, bValue.Convert(aValue.Type()).Interface())
	}
	// Last ditch effort
	if fmt.Sprintf("%#v", a) == fmt.Sprintf("%#v", b) {
		return true
	}

	return false
}
772236
func (s *Selection) Is(selector string) bool {
	return s.IsMatcher(compileMatcher(selector))
}
26146
func (is *Is) EqualType(expected, actual interface{}) {
	is.TB.Helper()
	if reflect.TypeOf(expected) != reflect.TypeOf(actual) {
		fail(is, "expected objects '%s' to be of the same type as object '%s'", objectTypeName(expected), objectTypeName(actual))
	}
}
1241299
func (s SessionID) Eq(s2 SessionID) bool {
	return hmac.Equal(s[:], s2[:])
}