// nonil gives first non-nil error from the given arguments.
428789
func nonil(err ...error) error {
	for _, err := range err {
		if err != nil {
			return err
		}
	}
	return nil
}
489132
func (c C) Ceil() Input {
	return C(float32(math.Ceil(float64(c))))
}
576787
func NotNilFilter(_ string, v reflect.Value) bool {
	switch v.Kind() {
	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
		return !v.IsNil()
	}
	return true
}
452884
func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
	if h, ok := t.(tHelper); ok {
		h.Helper()
	}
	if isNil(object) {
		return true
	}
	return Fail(t, fmt.Sprintf("Expected nil, but got: %#v", object), msgAndArgs...)
}
182972
func (as *Assertion) ToBeNil() {
	if !as.isNil(as.Value) {
		as.Test.PrintError(fmt.Sprintf("Expected `%v` to not exist", as.Value))
	}
}
497178
func FirstNonNil(errs ...error) error {
	for _, err := range errs {
		if err != nil {
			return err
		}
	}
	return nil
}
173332
func (a *Assertion) NotPanic(fn func(), msg ...interface{}) *Assertion {
	NotPanic(a.t, fn, msg...)
	return a
}
692791
func (s *Selection) NextUntil(selector string) *Selection {
	return pushStack(s, getSiblingNodes(s.Nodes, siblingNextUntil,
		compileMatcher(selector), nil))
}
407190
func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
	if !isNil(object) {
		return true
	}
	return Fail(t, "Expected value not to be nil.", msgAndArgs...)
}
1085282
func (a *auther) nonce() string {
	if a.noncer != nil {
		return a.noncer.Nonce()
	}
	b := make([]byte, 32)
	rand.Read(b)
	return base64.StdEncoding.EncodeToString(b)
}
671648
func NotNil(field, contents string) []ValidationMsg {
	if contents == "" {
		return []ValidationMsg{ValidationMsg{Field: field, Msg: NilMsg}}
	}

	return []ValidationMsg{}
}
534012
func (s *StructStruct) CallUntil(m string, args []interface{}, until func([]interface{}) bool) ([]interface{}, bool) {
	res, ok := s.Call(m, args)
	if ok && until(res) {
		return res, true
	}
	for _, item := range s.data {
		if item.embedded == nil {
			continue
		}
		res, ok := item.embedded.CallUntil(m, args, until)
		if ok && until(res) {
			return res, true
		}
	}
	return nil, false
}
996118
func Ceil(inReal []float64) []float64 {
	outReal := make([]float64, len(inReal))
	for i := 0; i < len(inReal); i++ {
		outReal[i] = math.Ceil(inReal[i])
	}
	return outReal
}
164204
func (session *Session) NotIn(column string, args ...interface{}) *Session {
	session.Statement.NotIn(column, args...)
	return session
}
933729
func IsNil(err error) bool {
	switch v := err.(type) {
	case *ErrorCollection:
		if len(v.Errors) == 0 {
			return true
		} else {
			return false
		}
	default:
		if err == nil {
			return true
		} else {
			return false
		}
	}
}
274552
func (s *Selection) Not(selector string) *Selection {
	return s.NotMatcher(compileMatcher(selector))
}
645674
func AssertNoError(err error) {
	if err == nil {
		return
	}
	if enableAssert {
		panic(err)
	}
	writeWithSync(2, "[ASSERT] "+err.Error())
}