assert

README

assert

assert for go

func a1() error {
	return KTry(func() {
		SWrap(errors.New("sbhbhbh"), func(m *M) {
			m.Msg("test shhh")
			m.M["ss"] = 1
			m.M["input"] = 1
		})

		TT(true, func(m *M) {
			m.Msg("好东西%d", 1)
		})
	})
}

func TestName(t *testing.T) {
	P(IfEquals(1, 2, 34))
	P(IfEquals(nil, nil))
	P(IfEquals(0, ""))
	P(IfEquals("", ""))

	fmt.Println(IsNil(a1()))

	P(KTry(func() {
		Throw(KTry(func() {
			SWrap(KTry(func() {
				SWrap(a1(), func(m *M) {
					m.Msg("ok111")
					m.Tag("test tag")
				})
			}), func(m *M) {
				m.Msg("test 123")
			})
		}))
	}))
}

func TestType(t *testing.T) {
	var ss map[string]interface{}
	var s interface{}
	for _, i := range ObjOf("1", 0, errors.New(""), nil, []string{}, ss, s) {
		fmt.Println(IsNil(i))
	}
}

func TestTry(t *testing.T) {
	P(Try(func() {
		T(true, "sss")
	}))

	P(KTry(func() {
		T(true, "sss")
	}))
}

func TestIf(t *testing.T) {
	fmt.Println(If(true, 1, "ss").(int))
	fmt.Println(If(true, FnOf(ToInt, "2"), "ss").(int))
	fmt.Println(If(true, FnOf(ToInt, "2"), "ss").(int))
	fmt.Println(reflect.TypeOf(FnOf(ToInt, "2")).Name())
}

Documentation

Index

• func AssertFn(fn interface{})
• func ErrWrap(err interface{}, msg string, args ...interface{})
• func FnCost(f func()) time.Duration
• func If(b bool, t, f interface{}) interface{}
• func IfEquals(args ...interface{}) bool
• func IfIn(a interface{}, args ...interface{}) bool
• func IfNotIn(a interface{}, args ...interface{}) bool
• func IsAllNil(args ...interface{}) bool
• func IsAllNotNil(args ...interface{}) bool
• func IsErr(p interface{}) bool
• func IsNil(p interface{}) (b bool)
• func IsPtr(p interface{}) bool
• func KTry(fn interface{}, args ...interface{}) (err error)
• func ObjOf(args ...interface{}) []interface{}
• func P(d ...interface{})
• func SWrap(err interface{}, fn func(m *M))
• func StrOf(args ...string) []string
• func T(b bool, msg string, args ...interface{})
• func TT(b bool, fn func(m *M))
• func Throw(err interface{})
• func ToInt(p string) int
• func Try(fn interface{}, args ...interface{}) (r interface{})
• func Wrap(err error, msg string, args ...interface{}) error
• type FnT
  • func FnOf(fn interface{}, args ...interface{}) FnT
• type KErr
  • func (t *KErr) Error() string
  • func (t *KErr) P()
  • func (t *KErr) Panic()
  • func (t *KErr) StackTrace() string
• type M
  • func (t *M) Msg(format string, args ...interface{})
  • func (t *M) Tag(tag string)

Functions

func AssertFn

func AssertFn(fn interface{})

func ErrWrap

func ErrWrap(err interface{}, msg string, args ...interface{})

func FnCost

func FnCost(f func()) time.Duration

func If

func If(b bool, t, f interface{}) interface{}

func IfEquals

func IfEquals(args ...interface{}) bool

func IfIn

func IfIn(a interface{}, args ...interface{}) bool

func IfNotIn

func IfNotIn(a interface{}, args ...interface{}) bool

func IsAllNil

func IsAllNil(args ...interface{}) bool

func IsAllNotNil

func IsAllNotNil(args ...interface{}) bool

func IsErr

func IsErr(p interface{}) bool

func IsNil

func IsNil(p interface{}) (b bool)

func IsPtr

func IsPtr(p interface{}) bool

func KTry

func KTry(fn interface{}, args ...interface{}) (err error)

func ObjOf

func ObjOf(args ...interface{}) []interface{}

func P

func P(d ...interface{})

func SWrap

func SWrap(err interface{}, fn func(m *M))

func StrOf

func StrOf(args ...string) []string

func T

func T(b bool, msg string, args ...interface{})

func TT

func TT(b bool, fn func(m *M))

func Throw

func Throw(err interface{})

func ToInt

func ToInt(p string) int

func Try

func Try(fn interface{}, args ...interface{}) (r interface{})

func Wrap

func Wrap(err error, msg string, args ...interface{}) error

Types

type FnT

type FnT func() []reflect.Value

func FnOf

func FnOf(fn interface{}, args ...interface{}) FnT

type KErr

type KErr struct {
	Tag    string                 `json:"tag,omitempty"`
	M      map[string]interface{} `json:"m,omitempty"`
	Err    error                  `json:"err,omitempty"`
	Msg    string                 `json:"msg,omitempty"`
	Caller string                 `json:"caller,omitempty"`
	Sub    *KErr                  `json:"sub,omitempty"`
}

func (*KErr) Error

func (t *KErr) Error() string

func (*KErr) P

func (t *KErr) P()

func (*KErr) Panic

func (t *KErr) Panic()

func (*KErr) StackTrace

func (t *KErr) StackTrace() string

type M

type M struct {
	M map[string]interface{}
	// contains filtered or unexported fields
}

func (*M) Msg

func (t *M) Msg(format string, args ...interface{})

func (*M) Tag

func (t *M) Tag(tag string)