简单升级依赖

yangyile · yangyile · commit 6365aa9da044 · 2025-02-10T15:13:27.000+07:00
diff --git a/.gitignore b/.gitignore
@@ -1,36 +1,25 @@
-*.a
-*.so
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
 *.exe
-*.pyc
-*.log
+*.exe~
 *.dll
-*.out
-*.key
-_test
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
 *.test
-*.cert
-*.exe~
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
 go.work
-.Trash-*
-.DS_Store
 go.work.sum
-main.out.bin
-*gitignore*secrets*
-*gitignore*outputs*
-ehthumbs.db
-Thumbs.db
-.gitkeep
-.vscode/
-*.dylib
-vendor/
-.idea/
-*.err
-*.swp
-_obj
-tmp/
-bin/
-tags
-*.DB
-*.db
-*.o
-*~
+
+# env file
+.env
diff --git a/go.mod b/go.mod
@@ -5,14 +5,14 @@ go 1.22.6
 require (
 	github.com/pkg/errors v0.9.1
 	github.com/stretchr/testify v1.10.0
-	github.com/yyle88/zaplog v0.0.17
+	github.com/yyle88/zaplog v0.0.19
 	go.uber.org/zap v1.27.0
 )
 
 require (
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
-	github.com/yyle88/mutexmap v1.0.9 // indirect
+	github.com/yyle88/mutexmap v1.0.10 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
 	gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
diff --git a/go.sum b/go.sum
@@ -12,10 +12,10 @@ github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU
 github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
 github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/yyle88/mutexmap v1.0.9 h1:g1nfNmsReU/AgcGkLgPEKrBeMThJJBrJuvU7i3DOVC0=
-github.com/yyle88/mutexmap v1.0.9/go.mod h1:QUYDuARLPlGj414kHewQ5tt8jkDxQXoai8H3C4Gg+yc=
-github.com/yyle88/zaplog v0.0.17 h1:2exjnXROfkNRvcKZDAFUM2KDpca1n2OKrEH73pTvrX0=
-github.com/yyle88/zaplog v0.0.17/go.mod h1:SJvxdHW7zWu1r+K66oBPBWljiGnDjCV8le3SzQnJpBw=
+github.com/yyle88/mutexmap v1.0.10 h1:PIsx9KTdK6h1yH5NzBrPl21RrZ/XsE4IbgulMlhJzZE=
+github.com/yyle88/mutexmap v1.0.10/go.mod h1:QUYDuARLPlGj414kHewQ5tt8jkDxQXoai8H3C4Gg+yc=
+github.com/yyle88/zaplog v0.0.19 h1:O4g7EO+uks7DkXbBXAje0LRvrBbkPuMD4gphuXw9jAo=
+github.com/yyle88/zaplog v0.0.19/go.mod h1:jN9/2IXYlpHOgoIyOTid1EPlUyGBWzFjr0dX9YKLkC0=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
diff --git a/must.go b/must.go
@@ -10,23 +10,23 @@ import (
 // True 期望值为 true。如果值为 false，则触发 panic。
 func True(v bool) {
 	if !v {
-		zaplog.ZAPS.P1.LOG.Panic("expect TRUE while got FALSE", zap.Bool("v", v))
+		zaplog.ZAPS.Skip1.LOG.Panic("expect TRUE while got FALSE", zap.Bool("v", v))
 	}
 }
 
 // Done expects no error. Panics if the provided error is non-nil.
 // Done 期望没有错误。如果提供的错误不为 nil，则触发 panic。
 func Done(err error) {
 	if err != nil {
-		zaplog.ZAPS.P1.LOG.Panic("NO ERROR BUG", zap.Error(err))
+		zaplog.ZAPS.Skip1.LOG.Panic("NO ERROR BUG", zap.Error(err))
 	}
 }
 
 // Must expects no error. Panics if the provided error is non-nil.
 // Must 期望没有错误。如果提供的错误不为 nil，则触发 panic。
 func Must(err error) {
 	if err != nil {
-		zaplog.ZAPS.P1.LOG.Panic("ERROR", zap.Error(err))
+		zaplog.ZAPS.Skip1.LOG.Panic("ERROR", zap.Error(err))
 	}
 }
 
@@ -35,7 +35,7 @@ func Must(err error) {
 func Nice[V comparable](a V) V {
 	var b V // zero value
 	if a == b {
-		zaplog.ZAPS.P1.LOG.Panic("A IS ZERO VALUE", zap.Any("a", a))
+		zaplog.ZAPS.Skip1.LOG.Panic("A IS ZERO VALUE", zap.Any("a", a))
 	}
 	return a
 }
@@ -45,7 +45,7 @@ func Nice[V comparable](a V) V {
 func Zero[V comparable](a V) {
 	var b V // zero value
 	if a != b {
-		zaplog.ZAPS.P1.LOG.Panic("A IS NOT ZERO VALUE", zap.Any("a", a))
+		zaplog.ZAPS.Skip1.LOG.Panic("A IS NOT ZERO VALUE", zap.Any("a", a))
 	}
 }
 
@@ -54,63 +54,63 @@ func Zero[V comparable](a V) {
 func None[V comparable](a V) {
 	var b V // zero value
 	if a != b {
-		zaplog.ZAPS.P1.LOG.Panic("A IS NOT NONE VALUE", zap.Any("a", a))
+		zaplog.ZAPS.Skip1.LOG.Panic("A IS NOT NONE VALUE", zap.Any("a", a))
 	}
 }
 
 // Null expects the value to be nil. Panics if the value is non-nil.
 // Null 期望值为 nil。如果值不为 nil，则触发 panic。
 func Null[T any](v *T) {
 	if v != nil {
-		zaplog.ZAPS.P1.LOG.Panic("SHOULD BE NULL BUT IS FULL")
+		zaplog.ZAPS.Skip1.LOG.Panic("SHOULD BE NULL BUT IS FULL")
 	}
 }
 
 // Full expects the value to be non-nil. Panics if the value is nil.
 // Full 期望值为非 nil。如果值为 nil，则触发 panic。
 func Full[T any](v *T) {
 	if v == nil {
-		zaplog.ZAPS.P1.LOG.Panic("SHOULD BE FULL BUT IS NULL")
+		zaplog.ZAPS.Skip1.LOG.Panic("SHOULD BE FULL BUT IS NULL")
 	}
 }
 
 // Equal expects the values to be equal. Panics if they are not equal.
 // Equal 期望值相等。如果值不相等，则触发 panic。
 func Equal[V comparable](a, b V) {
 	if a != b {
-		zaplog.ZAPS.P1.LOG.Panic("A AND B ARE NOT EQUAL", zap.Any("a", a), zap.Any("b", b))
+		zaplog.ZAPS.Skip1.LOG.Panic("A AND B ARE NOT EQUAL", zap.Any("a", a), zap.Any("b", b))
 	}
 }
 
 // Equals expects the values to be equal. Panics if they are not equal.
 // Equals 期望值相等。如果值不相等，则触发 panic。
 func Equals[V comparable](a, b V) {
 	if a != b {
-		zaplog.ZAPS.P1.LOG.Panic("A AND B ARE NOT EQUALS", zap.Any("a", a), zap.Any("b", b))
+		zaplog.ZAPS.Skip1.LOG.Panic("A AND B ARE NOT EQUALS", zap.Any("a", a), zap.Any("b", b))
 	}
 }
 
 // Same expects the values to be same. Panics if they are not same.
 // Same 期望值相等。如果值不相等，则触发 panic。
 func Same[V comparable](a, b V) {
 	if a != b {
-		zaplog.ZAPS.P1.LOG.Panic("A AND B ARE NOT SAME", zap.Any("a", a), zap.Any("b", b))
+		zaplog.ZAPS.Skip1.LOG.Panic("A AND B ARE NOT SAME", zap.Any("a", a), zap.Any("b", b))
 	}
 }
 
 // Is expects equality, not the logic of errors.Is, but the logic of Equals. Panics if the values are not equal.
 // Is 期望相等，不是 errors.Is 的逻辑，而是 Equals 的逻辑。如果值不相等，则触发 panic。
 func Is[V comparable](a, b V) {
 	if a != b {
-		zaplog.ZAPS.P1.LOG.Panic("A AND B ARE NOT EQUALS", zap.Any("a", a), zap.Any("b", b))
+		zaplog.ZAPS.Skip1.LOG.Panic("A AND B ARE NOT EQUALS", zap.Any("a", a), zap.Any("b", b))
 	}
 }
 
 // Ise expects the errors to be equal, similar to the behavior of errors.Is. Panics if they are not equal.
 // Ise 期望错误相等，类似于 errors.Is 的行为。如果错误不相等，则触发 panic。
 func Ise(err, target error) {
 	if !errors.Is(err, target) {
-		zaplog.ZAPS.P1.LOG.Panic("ERROR IS NOT SAME", zap.Error(err), zap.Error(target))
+		zaplog.ZAPS.Skip1.LOG.Panic("ERROR IS NOT SAME", zap.Error(err), zap.Error(target))
 	}
 }
 
@@ -119,7 +119,7 @@ func Ise(err, target error) {
 func Ok[V comparable](a V) {
 	var b V // zero value
 	if a == b {
-		zaplog.ZAPS.P1.LOG.Panic("A IS ZERO VALUE NOT OK", zap.Any("a", a))
+		zaplog.ZAPS.Skip1.LOG.Panic("A IS ZERO VALUE NOT OK", zap.Any("a", a))
 	}
 }
 
@@ -128,55 +128,55 @@ func Ok[V comparable](a V) {
 func OK[V comparable](a V) {
 	var b V // zero value
 	if a == b {
-		zaplog.ZAPS.P1.LOG.Panic("A IS ZERO VALUE NOT OK", zap.Any("a", a))
+		zaplog.ZAPS.Skip1.LOG.Panic("A IS ZERO VALUE NOT OK", zap.Any("a", a))
 	}
 }
 
 // TRUE expects the value to be true. Panics if the value is false.
 // TRUE 期望值为 true。如果值为 false，则触发 panic。
 func TRUE(v bool) {
 	if !v {
-		zaplog.ZAPS.P1.LOG.Panic("expect TRUE while got FALSE", zap.Bool("v", v))
+		zaplog.ZAPS.Skip1.LOG.Panic("expect TRUE while got FALSE", zap.Bool("v", v))
 	}
 }
 
 // FALSE expects the value to be false. Panics if the value is true.
 // FALSE 期望值为 false。如果值为 true，则触发 panic。
 func FALSE(v bool) {
 	if v {
-		zaplog.ZAPS.P1.LOG.Panic("expect FALSE while got TRUE", zap.Bool("v", v))
+		zaplog.ZAPS.Skip1.LOG.Panic("expect FALSE while got TRUE", zap.Bool("v", v))
 	}
 }
 
 // False expects the value to be false. Panics if the value is true.
 // False 期望值为 false。如果值为 true，则触发 panic。
 func False(v bool) {
 	if v {
-		zaplog.ZAPS.P1.LOG.Panic("expect FALSE while got TRUE", zap.Bool("v", v))
+		zaplog.ZAPS.Skip1.LOG.Panic("expect FALSE while got TRUE", zap.Bool("v", v))
 	}
 }
 
 // Have checks that the slice is not empty/none. Panics if the slice is empty/none.
 // Have 检查切片是否为空。如果切片为空，则触发 panic。
 func Have[T any](a []T) {
 	if len(a) == 0 {
-		zaplog.ZAPS.P1.LOG.Panic("expect LENGTH > 0 while got an empty/none slice")
+		zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH > 0 while got an empty/none slice")
 	}
 }
 
 // Length expects the slice to have length n. Panics if the length is not n.
 // Length 期望切片的长度为 n。如果长度不是 n，则触发 panic。
 func Length[T any](a []T, n int) {
 	if len(a) != n {
-		zaplog.ZAPS.P1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))
+		zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))
 	}
 }
 
 // Len is an abbreviation of Length, serving the same purpose. Panics if the length is not n.
 // Len 是 Length 的缩写，功能相同。如果长度不是 n，则触发 panic。
 func Len[T any](a []T, n int) {
 	if len(a) != n {
-		zaplog.ZAPS.P1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))
+		zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))
 	}
 }
 
@@ -188,7 +188,7 @@ func In[T comparable](v T, a []T) {
 			return
 		}
 	}
-	zaplog.ZAPS.P1.LOG.Panic("expect value in slice while not in", zap.Any("v", v), zap.Int("len", len(a)))
+	zaplog.ZAPS.Skip1.LOG.Panic("expect value in slice while not in", zap.Any("v", v), zap.Int("len", len(a)))
 }
 
 // Contains checks if the slice contains the value. Panics if the value is not found.
@@ -199,5 +199,5 @@ func Contains[T comparable](a []T, v T) {
 			return
 		}
 	}
-	zaplog.ZAPS.P1.LOG.Panic("expect slice contains value while not contains", zap.Int("len", len(a)), zap.Any("v", v))
+	zaplog.ZAPS.Skip1.LOG.Panic("expect slice contains value while not contains", zap.Int("len", len(a)), zap.Any("v", v))
 }
diff --git a/mustmap/must_map.go b/mustmap/must_map.go
@@ -11,23 +11,23 @@ import (
 // Equals 比较两个 map 是否相等，如果不相等，则触发 panic。
 func Equals[K, V comparable](a, b map[K]V) {
 	if !maps.Equal(a, b) {
-		zaplog.ZAPS.P1.LOG.Panic("expect map equals while not equals", zap.Int("len_a", len(a)), zap.Int("len_b", len(b)))
+		zaplog.ZAPS.Skip1.LOG.Panic("expect map equals while not equals", zap.Int("len_a", len(a)), zap.Int("len_b", len(b)))
 	}
 }
 
 // Have checks if a map is non-empty. If it is empty, it panics.
 // Have 检查一个 map 是否非空，如果为空，则触发 panic。
 func Have[K comparable, V any](a map[K]V) {
 	if len(a) == 0 {
-		zaplog.ZAPS.P1.LOG.Panic("expect LENGTH > 0 while got an none map")
+		zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH > 0 while got an none map")
 	}
 }
 
 // Nice checks if a map is non-empty and returns it. If it is empty, it panics.
 // Nice 检查一个 map 是否非空并返回它，如果为空，则触发 panic。
 func Nice[K comparable, V any](a map[K]V) map[K]V {
 	if len(a) == 0 {
-		zaplog.ZAPS.P1.LOG.Panic("expect LENGTH > 0 while got an none map")
+		zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH > 0 while got an none map")
 	}
 	return a
 }
@@ -36,23 +36,23 @@ func Nice[K comparable, V any](a map[K]V) map[K]V {
 // None 确保 map 内容为空，若有元素则 panic。
 func None[K comparable, V any](a map[K]V) {
 	if len(a) != 0 {
-		zaplog.ZAPS.P1.LOG.Panic("expect LENGTH = 0 while contains elements")
+		zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH = 0 while contains elements")
 	}
 }
 
 // Length checks if the length of a map is equal to n. If not, it panics.
 // Length 检查一个 map 的长度是否等于 n，如果不等，则触发 panic。
 func Length[K comparable, V any](a map[K]V, n int) {
 	if len(a) != n {
-		zaplog.ZAPS.P1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))
+		zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))
 	}
 }
 
 // Len checks if the length of a map is equal to n. If not, it panics.
 // Len 是 Length 的简写版本，检查一个 map 的长度是否等于 n，如果不等，则触发 panic。
 func Len[K comparable, V any](a map[K]V, n int) {
 	if len(a) != n {
-		zaplog.ZAPS.P1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))
+		zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))
 	}
 }
 
@@ -61,7 +61,7 @@ func Len[K comparable, V any](a map[K]V, n int) {
 func Get[K, V comparable](a map[K]V, key K) V {
 	value, exists := a[key]
 	if !exists {
-		zaplog.ZAPS.P1.LOG.Panic("expect KEY to EXIST in map", zap.Any("key", key))
+		zaplog.ZAPS.Skip1.LOG.Panic("expect KEY to EXIST in map", zap.Any("key", key))
 	}
 	return value
 }
diff --git a/mustslice/must_slice.go b/mustslice/must_slice.go

Original file line number	Diff line number	Diff line change
`@@ -10,23 +10,23 @@ import (`
`10`	`10`	`// True 期望值为 true。如果值为 false，则触发 panic。`
`11`	`11`	`func True(v bool) {`
`12`	`12`	`if !v {`
`13`		`- zaplog.ZAPS.P1.LOG.Panic("expect TRUE while got FALSE", zap.Bool("v", v))`
	`13`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect TRUE while got FALSE", zap.Bool("v", v))`
`14`	`14`	`}`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`// Done expects no error. Panics if the provided error is non-nil.`
`18`	`18`	`// Done 期望没有错误。如果提供的错误不为 nil，则触发 panic。`
`19`	`19`	`func Done(err error) {`
`20`	`20`	`if err != nil {`
`21`		`- zaplog.ZAPS.P1.LOG.Panic("NO ERROR BUG", zap.Error(err))`
	`21`	`+ zaplog.ZAPS.Skip1.LOG.Panic("NO ERROR BUG", zap.Error(err))`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`// Must expects no error. Panics if the provided error is non-nil.`
`26`	`26`	`// Must 期望没有错误。如果提供的错误不为 nil，则触发 panic。`
`27`	`27`	`func Must(err error) {`
`28`	`28`	`if err != nil {`
`29`		`- zaplog.ZAPS.P1.LOG.Panic("ERROR", zap.Error(err))`
	`29`	`+ zaplog.ZAPS.Skip1.LOG.Panic("ERROR", zap.Error(err))`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`@@ -35,7 +35,7 @@ func Must(err error) {`
`35`	`35`	`func Nice[V comparable](a V) V {`
`36`	`36`	`var b V // zero value`
`37`	`37`	`if a == b {`
`38`		`- zaplog.ZAPS.P1.LOG.Panic("A IS ZERO VALUE", zap.Any("a", a))`
	`38`	`+ zaplog.ZAPS.Skip1.LOG.Panic("A IS ZERO VALUE", zap.Any("a", a))`
`39`	`39`	`}`
`40`	`40`	`return a`
`41`	`41`	`}`
`@@ -45,7 +45,7 @@ func Nice[V comparable](a V) V {`
`45`	`45`	`func Zero[V comparable](a V) {`
`46`	`46`	`var b V // zero value`
`47`	`47`	`if a != b {`
`48`		`- zaplog.ZAPS.P1.LOG.Panic("A IS NOT ZERO VALUE", zap.Any("a", a))`
	`48`	`+ zaplog.ZAPS.Skip1.LOG.Panic("A IS NOT ZERO VALUE", zap.Any("a", a))`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`@@ -54,63 +54,63 @@ func Zero[V comparable](a V) {`
`54`	`54`	`func None[V comparable](a V) {`
`55`	`55`	`var b V // zero value`
`56`	`56`	`if a != b {`
`57`		`- zaplog.ZAPS.P1.LOG.Panic("A IS NOT NONE VALUE", zap.Any("a", a))`
	`57`	`+ zaplog.ZAPS.Skip1.LOG.Panic("A IS NOT NONE VALUE", zap.Any("a", a))`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`// Null expects the value to be nil. Panics if the value is non-nil.`
`62`	`62`	`// Null 期望值为 nil。如果值不为 nil，则触发 panic。`
`63`	`63`	`func Null[T any](v *T) {`
`64`	`64`	`if v != nil {`
`65`		`- zaplog.ZAPS.P1.LOG.Panic("SHOULD BE NULL BUT IS FULL")`
	`65`	`+ zaplog.ZAPS.Skip1.LOG.Panic("SHOULD BE NULL BUT IS FULL")`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`// Full expects the value to be non-nil. Panics if the value is nil.`
`70`	`70`	`// Full 期望值为非 nil。如果值为 nil，则触发 panic。`
`71`	`71`	`func Full[T any](v *T) {`
`72`	`72`	`if v == nil {`
`73`		`- zaplog.ZAPS.P1.LOG.Panic("SHOULD BE FULL BUT IS NULL")`
	`73`	`+ zaplog.ZAPS.Skip1.LOG.Panic("SHOULD BE FULL BUT IS NULL")`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`// Equal expects the values to be equal. Panics if they are not equal.`
`78`	`78`	`// Equal 期望值相等。如果值不相等，则触发 panic。`
`79`	`79`	`func Equal[V comparable](a, b V) {`
`80`	`80`	`if a != b {`
`81`		`- zaplog.ZAPS.P1.LOG.Panic("A AND B ARE NOT EQUAL", zap.Any("a", a), zap.Any("b", b))`
	`81`	`+ zaplog.ZAPS.Skip1.LOG.Panic("A AND B ARE NOT EQUAL", zap.Any("a", a), zap.Any("b", b))`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`// Equals expects the values to be equal. Panics if they are not equal.`
`86`	`86`	`// Equals 期望值相等。如果值不相等，则触发 panic。`
`87`	`87`	`func Equals[V comparable](a, b V) {`
`88`	`88`	`if a != b {`
`89`		`- zaplog.ZAPS.P1.LOG.Panic("A AND B ARE NOT EQUALS", zap.Any("a", a), zap.Any("b", b))`
	`89`	`+ zaplog.ZAPS.Skip1.LOG.Panic("A AND B ARE NOT EQUALS", zap.Any("a", a), zap.Any("b", b))`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`// Same expects the values to be same. Panics if they are not same.`
`94`	`94`	`// Same 期望值相等。如果值不相等，则触发 panic。`
`95`	`95`	`func Same[V comparable](a, b V) {`
`96`	`96`	`if a != b {`
`97`		`- zaplog.ZAPS.P1.LOG.Panic("A AND B ARE NOT SAME", zap.Any("a", a), zap.Any("b", b))`
	`97`	`+ zaplog.ZAPS.Skip1.LOG.Panic("A AND B ARE NOT SAME", zap.Any("a", a), zap.Any("b", b))`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`// Is expects equality, not the logic of errors.Is, but the logic of Equals. Panics if the values are not equal.`
`102`	`102`	`// Is 期望相等，不是 errors.Is 的逻辑，而是 Equals 的逻辑。如果值不相等，则触发 panic。`
`103`	`103`	`func Is[V comparable](a, b V) {`
`104`	`104`	`if a != b {`
`105`		`- zaplog.ZAPS.P1.LOG.Panic("A AND B ARE NOT EQUALS", zap.Any("a", a), zap.Any("b", b))`
	`105`	`+ zaplog.ZAPS.Skip1.LOG.Panic("A AND B ARE NOT EQUALS", zap.Any("a", a), zap.Any("b", b))`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`// Ise expects the errors to be equal, similar to the behavior of errors.Is. Panics if they are not equal.`
`110`	`110`	`// Ise 期望错误相等，类似于 errors.Is 的行为。如果错误不相等，则触发 panic。`
`111`	`111`	`func Ise(err, target error) {`
`112`	`112`	`if !errors.Is(err, target) {`
`113`		`- zaplog.ZAPS.P1.LOG.Panic("ERROR IS NOT SAME", zap.Error(err), zap.Error(target))`
	`113`	`+ zaplog.ZAPS.Skip1.LOG.Panic("ERROR IS NOT SAME", zap.Error(err), zap.Error(target))`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`
`@@ -119,7 +119,7 @@ func Ise(err, target error) {`
`119`	`119`	`func Ok[V comparable](a V) {`
`120`	`120`	`var b V // zero value`
`121`	`121`	`if a == b {`
`122`		`- zaplog.ZAPS.P1.LOG.Panic("A IS ZERO VALUE NOT OK", zap.Any("a", a))`
	`122`	`+ zaplog.ZAPS.Skip1.LOG.Panic("A IS ZERO VALUE NOT OK", zap.Any("a", a))`
`123`	`123`	`}`
`124`	`124`	`}`
`125`	`125`
`@@ -128,55 +128,55 @@ func Ok[V comparable](a V) {`
`128`	`128`	`func OK[V comparable](a V) {`
`129`	`129`	`var b V // zero value`
`130`	`130`	`if a == b {`
`131`		`- zaplog.ZAPS.P1.LOG.Panic("A IS ZERO VALUE NOT OK", zap.Any("a", a))`
	`131`	`+ zaplog.ZAPS.Skip1.LOG.Panic("A IS ZERO VALUE NOT OK", zap.Any("a", a))`
`132`	`132`	`}`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`// TRUE expects the value to be true. Panics if the value is false.`
`136`	`136`	`// TRUE 期望值为 true。如果值为 false，则触发 panic。`
`137`	`137`	`func TRUE(v bool) {`
`138`	`138`	`if !v {`
`139`		`- zaplog.ZAPS.P1.LOG.Panic("expect TRUE while got FALSE", zap.Bool("v", v))`
	`139`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect TRUE while got FALSE", zap.Bool("v", v))`
`140`	`140`	`}`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`// FALSE expects the value to be false. Panics if the value is true.`
`144`	`144`	`// FALSE 期望值为 false。如果值为 true，则触发 panic。`
`145`	`145`	`func FALSE(v bool) {`
`146`	`146`	`if v {`
`147`		`- zaplog.ZAPS.P1.LOG.Panic("expect FALSE while got TRUE", zap.Bool("v", v))`
	`147`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect FALSE while got TRUE", zap.Bool("v", v))`
`148`	`148`	`}`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`// False expects the value to be false. Panics if the value is true.`
`152`	`152`	`// False 期望值为 false。如果值为 true，则触发 panic。`
`153`	`153`	`func False(v bool) {`
`154`	`154`	`if v {`
`155`		`- zaplog.ZAPS.P1.LOG.Panic("expect FALSE while got TRUE", zap.Bool("v", v))`
	`155`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect FALSE while got TRUE", zap.Bool("v", v))`
`156`	`156`	`}`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`// Have checks that the slice is not empty/none. Panics if the slice is empty/none.`
`160`	`160`	`// Have 检查切片是否为空。如果切片为空，则触发 panic。`
`161`	`161`	`func Have[T any](a []T) {`
`162`	`162`	`if len(a) == 0 {`
`163`		`- zaplog.ZAPS.P1.LOG.Panic("expect LENGTH > 0 while got an empty/none slice")`
	`163`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH > 0 while got an empty/none slice")`
`164`	`164`	`}`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`// Length expects the slice to have length n. Panics if the length is not n.`
`168`	`168`	`// Length 期望切片的长度为 n。如果长度不是 n，则触发 panic。`
`169`	`169`	`func Length[T any](a []T, n int) {`
`170`	`170`	`if len(a) != n {`
`171`		`- zaplog.ZAPS.P1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))`
	`171`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))`
`172`	`172`	`}`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`// Len is an abbreviation of Length, serving the same purpose. Panics if the length is not n.`
`176`	`176`	`// Len 是 Length 的缩写，功能相同。如果长度不是 n，则触发 panic。`
`177`	`177`	`func Len[T any](a []T, n int) {`
`178`	`178`	`if len(a) != n {`
`179`		`- zaplog.ZAPS.P1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))`
	`179`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`
`@@ -188,7 +188,7 @@ func In[T comparable](v T, a []T) {`
`188`	`188`	`return`
`189`	`189`	`}`
`190`	`190`	`}`
`191`		`- zaplog.ZAPS.P1.LOG.Panic("expect value in slice while not in", zap.Any("v", v), zap.Int("len", len(a)))`
	`191`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect value in slice while not in", zap.Any("v", v), zap.Int("len", len(a)))`
`192`	`192`	`}`
`193`	`193`
`194`	`194`	`// Contains checks if the slice contains the value. Panics if the value is not found.`
`@@ -199,5 +199,5 @@ func Contains[T comparable](a []T, v T) {`
`199`	`199`	`return`
`200`	`200`	`}`
`201`	`201`	`}`
`202`		`- zaplog.ZAPS.P1.LOG.Panic("expect slice contains value while not contains", zap.Int("len", len(a)), zap.Any("v", v))`
	`202`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect slice contains value while not contains", zap.Int("len", len(a)), zap.Any("v", v))`
`203`	`203`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,23 +11,23 @@ import (`
`11`	`11`	`// Equals 比较两个 map 是否相等，如果不相等，则触发 panic。`
`12`	`12`	`func Equals[K, V comparable](a, b map[K]V) {`
`13`	`13`	`if !maps.Equal(a, b) {`
`14`		`- zaplog.ZAPS.P1.LOG.Panic("expect map equals while not equals", zap.Int("len_a", len(a)), zap.Int("len_b", len(b)))`
	`14`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect map equals while not equals", zap.Int("len_a", len(a)), zap.Int("len_b", len(b)))`
`15`	`15`	`}`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`// Have checks if a map is non-empty. If it is empty, it panics.`
`19`	`19`	`// Have 检查一个 map 是否非空，如果为空，则触发 panic。`
`20`	`20`	`func Have[K comparable, V any](a map[K]V) {`
`21`	`21`	`if len(a) == 0 {`
`22`		`- zaplog.ZAPS.P1.LOG.Panic("expect LENGTH > 0 while got an none map")`
	`22`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH > 0 while got an none map")`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`// Nice checks if a map is non-empty and returns it. If it is empty, it panics.`
`27`	`27`	`// Nice 检查一个 map 是否非空并返回它，如果为空，则触发 panic。`
`28`	`28`	`func Nice[K comparable, V any](a map[K]V) map[K]V {`
`29`	`29`	`if len(a) == 0 {`
`30`		`- zaplog.ZAPS.P1.LOG.Panic("expect LENGTH > 0 while got an none map")`
	`30`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH > 0 while got an none map")`
`31`	`31`	`}`
`32`	`32`	`return a`
`33`	`33`	`}`
`@@ -36,23 +36,23 @@ func Nice[K comparable, V any](a map[K]V) map[K]V {`
`36`	`36`	`// None 确保 map 内容为空，若有元素则 panic。`
`37`	`37`	`func None[K comparable, V any](a map[K]V) {`
`38`	`38`	`if len(a) != 0 {`
`39`		`- zaplog.ZAPS.P1.LOG.Panic("expect LENGTH = 0 while contains elements")`
	`39`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH = 0 while contains elements")`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`// Length checks if the length of a map is equal to n. If not, it panics.`
`44`	`44`	`// Length 检查一个 map 的长度是否等于 n，如果不等，则触发 panic。`
`45`	`45`	`func Length[K comparable, V any](a map[K]V, n int) {`
`46`	`46`	`if len(a) != n {`
`47`		`- zaplog.ZAPS.P1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))`
	`47`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`// Len checks if the length of a map is equal to n. If not, it panics.`
`52`	`52`	`// Len 是 Length 的简写版本，检查一个 map 的长度是否等于 n，如果不等，则触发 panic。`
`53`	`53`	`func Len[K comparable, V any](a map[K]V, n int) {`
`54`	`54`	`if len(a) != n {`
`55`		`- zaplog.ZAPS.P1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))`
	`55`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect LENGTH = n while not equals", zap.Int("len", len(a)), zap.Int("n", n))`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`@@ -61,7 +61,7 @@ func Len[K comparable, V any](a map[K]V, n int) {`
`61`	`61`	`func Get[K, V comparable](a map[K]V, key K) V {`
`62`	`62`	`value, exists := a[key]`
`63`	`63`	`if !exists {`
`64`		`- zaplog.ZAPS.P1.LOG.Panic("expect KEY to EXIST in map", zap.Any("key", key))`
	`64`	`+ zaplog.ZAPS.Skip1.LOG.Panic("expect KEY to EXIST in map", zap.Any("key", key))`
`65`	`65`	`}`
`66`	`66`	`return value`
`67`	`67`	`}`