must

must.BeTrue(ReturnTrue())

defer func() {
	fmt.Println(recover())
}()
must.BeTrue(ReturnFalse())

Output:

must be true

fmt.Println(must.BeTrueV(ReturnIntTrue()))

defer func() {
	fmt.Println(recover())
}()
_ = must.BeTrueV(ReturnIntFalse())

Output:

100
must be true

must.BeTrueWrap(ReturnTrue(), "any")

defer func() {
	fmt.Println(recover())
}()
must.BeTrueWrap(ReturnFalse(), "required exists")

Output:

must be true: required exists

must.NoError(ReturnNoError())

defer func() {
	fmt.Println(recover())
}()
must.NoError(ReturnError())

Output:

some error

fmt.Println(must.NoErrorV(ReturnIntNoError()))

defer func() {
	fmt.Println(recover())
}()
must.NoErrorV(ReturnIntError())

Output:

100
some error

must.NoErrorWrap(ReturnNoError(), "any")

defer func() {
	fmt.Println(recover())
}()
must.NoErrorWrap(ReturnError(), "some message: %d", 10)

Output:

some message: 10: some error

rv := reflect.ValueOf(struct {
	V0 any
	V7 error
	V8 reflect.Type
	V1 chan error
	V2 func()
	V3 *int
	V4 unsafe.Pointer
	V5 []int
	V6 map[string]int
}{})
for i := range rv.NumField() {
	func(v any) {
		defer func() {
			if err := recover(); err != nil {
				fmt.Println(err)
			}
		}()
		must.NotNilV(v)
	}(rv.Field(i).Interface())
}
fmt.Println(must.NotNilV(1))
fmt.Println(*must.NotNilV(new(int)))

defer func() {
	if err := recover(); err != nil {
		fmt.Println(err)
	}
}()
must.NotNilWrap((*int)(nil), "business message %v", 100)

Output:

must not nil, but got invalid value
must not nil, but got invalid value
must not nil, but got invalid value
must not nil for type `chan error`
must not nil for type `func()`
must not nil for type `*int`
must not nil for type `unsafe.Pointer`
must not nil for type `[]int`
must not nil for type `map[string]int`
1
0
must not nil for type `*int` business message 100