// ExpectLt(x, y) is equivalent to ExpectThat(x, oglematchers.LessThan(y)).
345508
func ExpectLt(x, y interface{}, errorParts ...interface{}) {
	expectThat(x, oglematchers.LessThan(y), 1, errorParts)
}
957365
func AssertGt(x, y interface{}, errorParts ...interface{}) {
	assertThat(x, oglematchers.GreaterThan(y), 1, errorParts)
}
670209
func (expectation *Expectation) To(matcher Matcher, expected ...interface{}) {
	if !expectation.Example.HasFailure {
		values := append([]interface{}{expectation.Actual}, expected...)
		if failureMessage := matcher(values...); failureMessage != "" {
			expectation.Example.Failed(failureMessage)
		}
	}
}
708223
func (s *Condition) SetLt(v int64) *Condition {
	s.Lt = &v
	return s
}
423468
func (t *T) ExpectErrorMessagef(err error, msg string, spec string, args ...interface{}) {
	prefix := fmt.Sprintf(spec, args...) + ": "
	if err == nil {
		t.Fatalf("%sExpected error was not returned.", prefix)
	} else if !strings.Contains(err.Error(), msg) {
		t.Fatalf("%sError message didn't contain the expected message:\n"+
			"Error message=%s\nExpected string=%s", prefix, err.Error(), msg)
	}
}
42539
func (t *tree) expectOneOf(expected1, expected2 lex.TokenType, context string) lex.Token {
	token := t.Cur()
	if token.T != expected1 && token.T != expected2 {
		t.unexpected(token, context)
	}
	return token
}
418074
func (s *DescribeMLModelsInput) SetLT(v string) *DescribeMLModelsInput {
	s.LT = &v
	return s
}
1121575
func (d *Decoder) expect(t tokenType) {
	if tok := d.next(); tok.t != t {
		d.error(d.pos(tok), "expected %v found %v", t, tok)
	}
}
308123
func FloatAtLeast(min float64) schema.SchemaValidateFunc {
	return func(i interface{}, k string) (_ []string, errors []error) {
		v, ok := i.(float64)
		if !ok {
			errors = append(errors, fmt.Errorf("expected type of %s to be float64", k))
			return nil, errors
		}

		if v < min {
			errors = append(errors, fmt.Errorf("expected %s to be at least (%f), got %f", k, min, v))
			return nil, errors
		}

		return nil, errors
	}
}
107204
func (c *Conn) ExpectationsWereMet() error {
	errMsg := ""
	for _, err := range c.Errors {
		errMsg = fmt.Sprintf("%s%s\n", errMsg, err.Error())
	}

	for _, cmd := range c.commands {
		if !cmd.Called {
			errMsg = fmt.Sprintf("%sCommand %s with arguments %#v expected but never called.\n", errMsg, cmd.Name, cmd.Args)
		}
	}

	if errMsg != "" {
		return fmt.Errorf("%s", errMsg)
	}

	return nil
}
1290819
func (err BadParameterError) Expected(expected interface{}) BadParameterError {
	err.expectedValue = expected
	err.hasExpectedValue = true
	return err
}
429800
func (r *ReadContext) ExpectMagic(magic int32) error {
	var readMagic int32
	err := binary.Read(r.countingReader, Endianness, &readMagic)
	if err != nil {
		return errors.WithStack(err)
	}

	if magic != readMagic {
		return errors.WithStack(ErrFormat)
	}

	return nil
}
1240719
func (s *DescribeDataSourcesInput) SetLT(v string) *DescribeDataSourcesInput {
	s.LT = &v
	return s
}
1190791
func Le(expectedValue interface{}) *leMatcher {
	matcher := new(leMatcher)
	matcher.expectedValue = expectedValue
	return matcher
}
101166
func (s *DescribeEvaluationsInput) SetLT(v string) *DescribeEvaluationsInput {
	s.LT = &v
	return s
}
166244
func (s *DescribeBatchPredictionsInput) SetLT(v string) *DescribeBatchPredictionsInput {
	s.LT = &v
	return s
}
988515
func ExpectLe(x, y interface{}, errorParts ...interface{}) {
	expectThat(x, oglematchers.LessOrEqual(y), 1, errorParts)
}