// Ge checks if the value is greater or equal the expected value
964834
func Ge(expectedValue interface{}) *geMatcher {
	matcher := new(geMatcher)
	matcher.expectedValue = expectedValue
	return matcher
}
52690
func (o *QueryOption) Equal(o2 *QueryOption) bool {
	if o2 == nil {
		return o.value == ""
	}
	return o.value == o2.value
}
283204
func (lc Lifecycle) EqualValue(u convert.Equaler) bool {
	return lc.Equal(u)
}
854641
func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
	if h, ok := t.(tHelper); ok {
		h.Helper()
	}

	if !ObjectsAreEqualValues(expected, actual) {
		diff := diff(expected, actual)
		expected, actual = formatUnequalValues(expected, actual)
		return Fail(t, fmt.Sprintf("Not equal: \n"+
			"expected: %s\n"+
			"actual  : %s%s", expected, actual, diff), msgAndArgs...)
	}

	return true

}
1036101
func (a *AggFuncDesc) Equal(ctx sessionctx.Context, other *AggFuncDesc) bool {
	if a.HasDistinct != other.HasDistinct {
		return false
	}
	return a.baseFuncDesc.equal(ctx, &other.baseFuncDesc)
}
233710
func (expr *Expr) IsEquality() bool {
	terms, ok := expr.Terms.([]*Term)
	if !ok {
		return false
	}
	return terms[0].Value.Compare(Equality.Ref()) == 0
}
1062233
func AssertEqual(expected interface{}, result interface{}) {
	AssertType(expected, result)
	if expected == nil && result == nil {
		return
	}
	switch result.(type) {
	case string, int, error, bool:
		if expected != result {
			panic(fmt.Sprintf("Error: [] Mismatched Values\nExpected value: %v\nResult: %v", expected, result))
		}
	default:
		panic("Error: AssertEqual doesn't handles this type yet.")
	}

}
493869
func (p *SampleQueryProperty) GreaterThanOrEqual(value interface{}) *SampleQueryBuilder {
	p.bldr.q = p.bldr.q.Filter(p.name+" >=", value)
	if p.bldr.plugin != nil {
		p.bldr.plugin.Filter(p.name, ">=", value)
	}
	return p.bldr
}
309511
func (s *DescribeBatchPredictionsInput) SetGE(v string) *DescribeBatchPredictionsInput {
	s.GE = &v
	return s
}
104534
func (s *DescribeEvaluationsInput) SetGE(v string) *DescribeEvaluationsInput {
	s.GE = &v
	return s
}
796735
func (b ValExprBuilder) Gte(val interface{}) BoolExprBuilder {
	return b.makeComparisonExpr(astGE, makeValExpr(val))
}
59015
func (f Float) Equal(e Equaler) bool {
	ef := e.(Float)
	if f != f && ef != ef { // For our purposes NaN == NaN.
		return true
	}
	return f == ef
}
234095
func (n Name) Equal(other Name) (equal bool, err error) {
	var min C.OM_uint32
	var isEqual C.int

	maj := C.wrap_gss_compare_name(n.Fp_gss_compare_name, &min,
		n.C_gss_name_t, other.C_gss_name_t, &isEqual)
	err = n.stashLastStatus(maj, min)
	if err != nil {
		return false, err
	}

	return isEqual != 0, nil
}
1075970
func (a *assertion) Equal(obtained, expected interface{}, msgs ...string) bool {
	if !a.IsEqual(obtained, expected) {
		return a.failer.Fail(Equal, obtained, expected, msgs...)
	}
	return true
}
1040647
func Equal(x, y Value) (bool, error) {
	if x, ok := x.(String); ok {
		return x == y, nil // fast path for an important special case
	}
	return EqualDepth(x, y, maxdepth)
}
918823
func (s *OutputState) Equal(other *OutputState) bool {
	if s == nil && other == nil {
		return true
	}

	if s == nil || other == nil {
		return false
	}
	s.Lock()
	defer s.Unlock()

	if s.Type != other.Type {
		return false
	}

	if s.Sensitive != other.Sensitive {
		return false
	}

	if !reflect.DeepEqual(s.Value, other.Value) {
		return false
	}

	return true
}
1068103
func (b *Boolean) NotEqual(value bool) *Boolean {
	if !(b.value != value) {
		b.chain.fail("expected boolean != %v, but got %v", value, b.value)
	}
	return b
}