Update deps

vendor/github.com/powerman/check/.gitignore

@@ -5,6 +5,5 @@
 # **/name   - exclude path (* doesn't match /) to file/dir "name"  in any dir including project root
 # na/**/me  - exclude path (* doesn't match /) to file/dir "na/me", "na/*/me", "na/*/*/me", …
 # !name     - include previously excluded path …
-/.circleci/config-local.yml
-/.gobincache/
+/.buildcache/
 /cover.out

vendor/github.com/powerman/check/check.go

@@ -3,6 +3,7 @@ package check
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"math"
 	"reflect"
@@ -134,7 +135,7 @@ func (t *C) fail() {
 	stats[t.T].failed.value++
 }
 
-func (t *C) report(ok bool, msg []interface{}, checker string, name []string, args []interface{}) bool { //nolint:revive // False positive.
+func (t *C) report(ok bool, msg []any, checker string, name []string, args []any) bool { //nolint:revive // False positive.
 	t.Helper()
 
 	if ok != t.todo {
@@ -194,39 +195,39 @@ func (t *C) report(ok bool, msg []interface{}, checker string, name []string, ar
 	return ok
 }
 
-func (t *C) reportShould1(funcName string, actual interface{}, msg []interface{}, ok bool) bool {
+func (t *C) reportShould1(funcName string, actual any, msg []any, ok bool) bool {
 	t.Helper()
 	return t.report(ok, msg,
 		"Should "+funcName,
 		[]string{nameActual},
-		[]interface{}{actual})
+		[]any{actual})
 }
 
-func (t *C) reportShould2(funcName string, actual, expected interface{}, msg []interface{}, ok bool) bool {
+func (t *C) reportShould2(funcName string, actual, expected any, msg []any, ok bool) bool {
 	t.Helper()
 	return t.report(ok, msg,
 		"Should "+funcName,
 		[]string{nameActual, nameExpected},
-		[]interface{}{actual, expected})
+		[]any{actual, expected})
 }
 
-func (t *C) report0(msg []interface{}, ok bool) bool {
+func (t *C) report0(msg []any, ok bool) bool {
 	t.Helper()
 	return t.report(ok, msg,
 		callerFuncName(1),
 		[]string{},
-		[]interface{}{})
+		[]any{})
 }
 
-func (t *C) report1(actual interface{}, msg []interface{}, ok bool) bool {
+func (t *C) report1(actual any, msg []any, ok bool) bool {
 	t.Helper()
 	return t.report(ok, msg,
 		callerFuncName(1),
 		[]string{nameActual},
-		[]interface{}{actual})
+		[]any{actual})
 }
 
-func (t *C) report2(actual, expected interface{}, msg []interface{}, ok bool) bool {
+func (t *C) report2(actual, expected any, msg []any, ok bool) bool {
 	t.Helper()
 	checker, arg2Name := callerFuncName(1), nameExpected
 	if strings.Contains(checker, "Match") {
@@ -235,10 +236,10 @@ func (t *C) report2(actual, expected interface{}, msg []interface{}, ok bool) bo
 	return t.report(ok, msg,
 		checker,
 		[]string{nameActual, arg2Name},
-		[]interface{}{actual, expected})
+		[]any{actual, expected})
 }
 
-func (t *C) report3(actual, expected1, expected2 interface{}, msg []interface{}, ok bool) bool {
+func (t *C) report3(actual, expected1, expected2 any, msg []any, ok bool) bool {
 	t.Helper()
 	checker, arg2Name, arg3Name := callerFuncName(1), "arg1", "arg2"
 	switch {
@@ -252,15 +253,15 @@ func (t *C) report3(actual, expected1, expected2 interface{}, msg []interface{},
 	return t.report(ok, msg,
 		checker,
 		[]string{nameActual, arg2Name, arg3Name},
-		[]interface{}{actual, expected1, expected2})
+		[]any{actual, expected1, expected2})
 }
 
 // Must interrupt test using t.FailNow if called with false value.
 //
 // This provides an easy way to turn any check into assertion:
 //
-//   t.Must(t.Nil(err))
-func (t *C) Must(continueTest bool, msg ...interface{}) { //nolint:revive // False positive.
+//	t.Must(t.Nil(err))
+func (t *C) Must(continueTest bool, msg ...any) { //nolint:revive // False positive.
 	t.Helper()
 	t.report0(msg, continueTest)
 	if !continueTest {
@@ -270,9 +271,9 @@ func (t *C) Must(continueTest bool, msg ...interface{}) { //nolint:revive // Fal
 
 type (
 	// ShouldFunc1 is like Nil or Zero.
-	ShouldFunc1 func(t *C, actual interface{}) bool
+	ShouldFunc1 func(t *C, actual any) bool
 	// ShouldFunc2 is like Equal or Match.
-	ShouldFunc2 func(t *C, actual, expected interface{}) bool
+	ShouldFunc2 func(t *C, actual, expected any) bool
 )
 
 // Should use user-provided check function to do actual check.
@@ -294,19 +295,19 @@ type (
 //		t := check.T(tt)
 //		t.Should(bePositive, 42, "custom check!!!")
 //	}
-func (t *C) Should(anyShouldFunc interface{}, args ...interface{}) bool {
+func (t *C) Should(anyShouldFunc any, args ...any) bool {
 	t.Helper()
 	switch f := anyShouldFunc.(type) {
-	case func(t *C, actual interface{}) bool:
+	case func(t *C, actual any) bool:
 		return t.should1(f, args...)
-	case func(t *C, actual, expected interface{}) bool:
+	case func(t *C, actual, expected any) bool:
 		return t.should2(f, args...)
 	default:
 		panic("anyShouldFunc is not a ShouldFunc1 or ShouldFunc2")
 	}
 }
 
-func (t *C) should1(f ShouldFunc1, args ...interface{}) bool {
+func (t *C) should1(f ShouldFunc1, args ...any) bool {
 	t.Helper()
 	if len(args) < 1 {
 		panic("not enough params for " + funcName(f))
@@ -316,7 +317,7 @@ func (t *C) should1(f ShouldFunc1, args ...interface{}) bool {
 		f(t, actual))
 }
 
-func (t *C) should2(f ShouldFunc2, args ...interface{}) bool {
+func (t *C) should2(f ShouldFunc2, args ...any) bool {
 	t.Helper()
 	const minArgs = 2
 	if len(args) < minArgs {
@@ -361,13 +362,13 @@ func (t *C) should2(f ShouldFunc2, args ...interface{}) bool {
 // really, so Nil(uintptr(0)) will fail. Nil(unsafe.Pointer(nil)) will
 // also fail, for the same reason. Please do not use this and consider
 // this behaviour undefined, because it may change in the future.
-func (t *C) Nil(actual interface{}, msg ...interface{}) bool {
+func (t *C) Nil(actual any, msg ...any) bool {
 	t.Helper()
 	return t.report1(actual, msg,
 		isNil(actual))
 }
 
-func isNil(actual interface{}) bool {
+func isNil(actual any) bool {
 	switch val := reflect.ValueOf(actual); val.Kind() {
 	case reflect.Invalid:
 		return actual == nil
@@ -387,7 +388,7 @@ func isNil(actual interface{}) bool {
 // NotNil checks for actual != nil.
 //
 // See Nil about subtle case in check logic.
-func (t *C) NotNil(actual interface{}, msg ...interface{}) bool {
+func (t *C) NotNil(actual any, msg ...any) bool {
 	t.Helper()
 	return t.report0(msg,
 		!isNil(actual))
@@ -396,7 +397,7 @@ func (t *C) NotNil(actual interface{}, msg ...interface{}) bool {
 // Error is equivalent to Log followed by Fail.
 //
 // It is like t.Errorf with TODO() and statistics support.
-func (t *C) Error(msg ...interface{}) {
+func (t *C) Error(msg ...any) {
 	t.Helper()
 	t.report0(msg, false)
 }
@@ -410,14 +411,14 @@ func (t *C) Error(msg ...interface{}) {
 //	if !cond {
 //		t.Errorf(msg...)
 //	}
-func (t *C) True(cond bool, msg ...interface{}) bool {
+func (t *C) True(cond bool, msg ...any) bool {
 	t.Helper()
 	return t.report0(msg,
 		cond)
 }
 
 // False checks for cond == false.
-func (t *C) False(cond bool, msg ...interface{}) bool {
+func (t *C) False(cond bool, msg ...any) bool {
 	t.Helper()
 	return t.report0(msg,
 		!cond)
@@ -426,13 +427,13 @@ func (t *C) False(cond bool, msg ...interface{}) bool {
 // Equal checks for actual == expected.
 //
 // Note: For time.Time it uses actual.Equal(expected) instead.
-func (t *C) Equal(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) Equal(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.report2(actual, expected, msg,
 		isEqual(actual, expected))
 }
 
-func isEqual(actual, expected interface{}) bool {
+func isEqual(actual, expected any) bool {
 	switch actual := actual.(type) {
 	case time.Time:
 		return actual.Equal(expected.(time.Time))
@@ -442,20 +443,20 @@ func isEqual(actual, expected interface{}) bool {
 }
 
 // EQ is a synonym for Equal.
-func (t *C) EQ(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) EQ(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.Equal(actual, expected, msg...)
 }
 
 // NotEqual checks for actual != expected.
-func (t *C) NotEqual(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) NotEqual(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.report2(actual, expected, msg,
 		!isEqual(actual, expected))
 }
 
 // NE is a synonym for NotEqual.
-func (t *C) NE(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) NE(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.NotEqual(actual, expected, msg...)
 }
@@ -463,7 +464,7 @@ func (t *C) NE(actual, expected interface{}, msg ...interface{}) bool {
 // BytesEqual checks for bytes.Equal(actual, expected).
 //
 // Hint: BytesEqual([]byte{}, []byte(nil)) is true (unlike DeepEqual).
-func (t *C) BytesEqual(actual, expected []byte, msg ...interface{}) bool {
+func (t *C) BytesEqual(actual, expected []byte, msg ...any) bool {
 	t.Helper()
 	return t.report2(actual, expected, msg,
 		bytes.Equal(actual, expected))
@@ -472,7 +473,7 @@ func (t *C) BytesEqual(actual, expected []byte, msg ...interface{}) bool {
 // NotBytesEqual checks for !bytes.Equal(actual, expected).
 //
 // Hint: NotBytesEqual([]byte{}, []byte(nil)) is false (unlike NotDeepEqual).
-func (t *C) NotBytesEqual(actual, expected []byte, msg ...interface{}) bool {
+func (t *C) NotBytesEqual(actual, expected []byte, msg ...any) bool {
 	t.Helper()
 	return t.report1(actual, msg,
 		!bytes.Equal(actual, expected))
@@ -482,7 +483,7 @@ func (t *C) NotBytesEqual(actual, expected []byte, msg ...interface{}) bool {
 // It will also use Equal method for types which implements it
 // (e.g. time.Time, decimal.Decimal, etc.).
 // It will use proto.Equal for protobuf messages.
-func (t *C) DeepEqual(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) DeepEqual(actual, expected any, msg ...any) bool {
 	t.Helper()
 	protoActual, proto1 := actual.(protoreflect.ProtoMessage)
 	protoExpected, proto2 := expected.(protoreflect.ProtoMessage)
@@ -498,7 +499,7 @@ func (t *C) DeepEqual(actual, expected interface{}, msg ...interface{}) bool {
 // It will also use Equal method for types which implements it
 // (e.g. time.Time, decimal.Decimal, etc.).
 // It will use proto.Equal for protobuf messages.
-func (t *C) NotDeepEqual(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) NotDeepEqual(actual, expected any, msg ...any) bool {
 	t.Helper()
 	protoActual, proto1 := actual.(protoreflect.ProtoMessage)
 	protoExpected, proto2 := expected.(protoreflect.ProtoMessage)
@@ -521,7 +522,7 @@ func (t *C) NotDeepEqual(actual, expected interface{}, msg ...interface{}) bool
 //   - fmt.Stringer - will match with actual.String()
 //   - error        - will match with actual.Error()
 //   - nil          - will not match (even with empty regex)
-func (t *C) Match(actual, regex interface{}, msg ...interface{}) bool {
+func (t *C) Match(actual, regex any, msg ...any) bool {
 	t.Helper()
 	ok := isMatch(&actual, regex)
 	return t.report2(actual, regex, msg,
@@ -530,7 +531,7 @@ func (t *C) Match(actual, regex interface{}, msg ...interface{}) bool {
 
 // isMatch updates actual to be a real string used for matching, to make
 // dump easier to understand, but this result in losing type information.
-func isMatch(actual *interface{}, regex interface{}) bool { //nolint:gocritic // False positive.
+func isMatch(actual *any, regex any) bool { //nolint:gocritic // False positive.
 	if *actual == nil {
 		return false
 	}
@@ -548,7 +549,7 @@ func isMatch(actual *interface{}, regex interface{}) bool { //nolint:gocritic //
 	panic("regex is not a *regexp.Regexp or string")
 }
 
-func stringify(arg *interface{}) bool { //nolint:gocritic // False positive.
+func stringify(arg *any) bool { //nolint:gocritic // False positive.
 	switch v := (*arg).(type) {
 	case nil:
 		return false
@@ -577,7 +578,7 @@ func stringify(arg *interface{}) bool { //nolint:gocritic // False positive.
 // NotMatch checks for !regex.MatchString(actual).
 //
 // See Match about supported actual/regex types and check logic.
-func (t *C) NotMatch(actual, regex interface{}, msg ...interface{}) bool {
+func (t *C) NotMatch(actual, regex any, msg ...any) bool {
 	t.Helper()
 	ok := !isMatch(&actual, regex)
 	return t.report2(actual, regex, msg,
@@ -596,13 +597,13 @@ func (t *C) NotMatch(actual, regex interface{}, msg ...interface{}) bool {
 //
 // Hint: In a map it looks for a value, if you need to look for a key -
 // use HasKey instead.
-func (t *C) Contains(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) Contains(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.report2(actual, expected, msg,
 		isContains(actual, expected))
 }
 
-func isContains(actual, expected interface{}) (found bool) {
+func isContains(actual, expected any) (found bool) {
 	switch valActual := reflect.ValueOf(actual); valActual.Kind() { //nolint:exhaustive // Covered by default case.
 	case reflect.String:
 		strActual := valActual.Convert(typString).Interface().(string) //nolint:forcetypeassert // False positive.
@@ -639,38 +640,38 @@ func isContains(actual, expected interface{}) (found bool) {
 // NotContains checks is actual not contains substring/element expected.
 //
 // See Contains about supported actual/expected types and check logic.
-func (t *C) NotContains(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) NotContains(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.report2(actual, expected, msg,
 		!isContains(actual, expected))
 }
 
 // HasKey checks is actual has key expected.
-func (t *C) HasKey(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) HasKey(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.report2(actual, expected, msg,
 		hasKey(actual, expected))
 }
 
-func hasKey(actual, expected interface{}) bool {
+func hasKey(actual, expected any) bool {
 	return reflect.ValueOf(actual).MapIndex(reflect.ValueOf(expected)).IsValid()
 }
 
 // NotHasKey checks is actual has no key expected.
-func (t *C) NotHasKey(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) NotHasKey(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.report2(actual, expected, msg,
 		!hasKey(actual, expected))
 }
 
 // Zero checks is actual is zero value of it's type.
-func (t *C) Zero(actual interface{}, msg ...interface{}) bool {
+func (t *C) Zero(actual any, msg ...any) bool {
 	t.Helper()
 	return t.report1(actual, msg,
 		isZero(actual))
 }
 
-func isZero(actual interface{}) bool {
+func isZero(actual any) bool {
 	if isNil(actual) {
 		return true
 	} else if typ := reflect.TypeOf(actual); typ.Comparable() {
@@ -691,14 +692,14 @@ func isZero(actual interface{}) bool {
 }
 
 // NotZero checks is actual is not zero value of it's type.
-func (t *C) NotZero(actual interface{}, msg ...interface{}) bool {
+func (t *C) NotZero(actual any, msg ...any) bool {
 	t.Helper()
 	return t.report1(actual, msg,
 		!isZero(actual))
 }
 
 // Len checks is len(actual) == expected.
-func (t *C) Len(actual interface{}, expected int, msg ...interface{}) bool {
+func (t *C) Len(actual any, expected int, msg ...any) bool {
 	t.Helper()
 	l := reflect.ValueOf(actual).Len()
 	return t.report2(l, expected, msg,
@@ -706,7 +707,7 @@ func (t *C) Len(actual interface{}, expected int, msg ...interface{}) bool {
 }
 
 // NotLen checks is len(actual) != expected.
-func (t *C) NotLen(actual interface{}, expected int, msg ...interface{}) bool {
+func (t *C) NotLen(actual any, expected int, msg ...any) bool {
 	t.Helper()
 	l := reflect.ValueOf(actual).Len()
 	return t.report2(l, expected, msg,
@@ -715,15 +716,18 @@ func (t *C) NotLen(actual interface{}, expected int, msg ...interface{}) bool {
 
 // Err checks is actual error is the same as expected error.
 //
+// If errors.Is() fails then it'll use more sofiscated logic:
+//
 // It tries to recursively unwrap actual before checking using
 // errors.Unwrap() and github.com/pkg/errors.Cause().
+// In case of multi-error (Unwrap() []error) it use only first error.
 //
 // It will use proto.Equal for gRPC status errors.
 //
 // They may be a different instances, but must have same type and value.
 //
 // Checking for nil is okay, but using Nil(actual) instead is more clean.
-func (t *C) Err(actual, expected error, msg ...interface{}) bool {
+func (t *C) Err(actual, expected error, msg ...any) bool {
 	t.Helper()
 	actual2 := unwrapErr(actual)
 	equal := fmt.Sprintf("%#v", actual2) == fmt.Sprintf("%#v", expected)
@@ -732,6 +736,9 @@ func (t *C) Err(actual, expected error, msg ...interface{}) bool {
 	if proto1 || proto2 {
 		equal = proto.Equal(status.Convert(actual2).Proto(), status.Convert(expected).Proto())
 	}
+	if !equal {
+		equal = errors.Is(actual, expected)
+	}
 	return t.report2(actual, expected, msg, equal)
 }
 
@@ -740,11 +747,16 @@ func unwrapErr(err error) (actual error) {
 	actual = err
 	for {
 		actual = pkgerrors.Cause(actual)
-		wrapped, ok := actual.(interface{ Unwrap() error }) //nolint:errorlint // False positive.
-		if !ok {
-			break
+		var unwrapped error
+		switch wrapped := actual.(type) { //nolint:errorlint // False positive.
+		case interface{ Unwrap() error }:
+			unwrapped = wrapped.Unwrap()
+		case interface{ Unwrap() []error }:
+			unwrappeds := wrapped.Unwrap()
+			if len(unwrappeds) > 0 {
+				unwrapped = unwrappeds[0]
+			}
 		}
-		unwrapped := wrapped.Unwrap()
 		if unwrapped == nil {
 			break
 		}
@@ -757,13 +769,16 @@ func unwrapErr(err error) (actual error) {
 //
 // It tries to recursively unwrap actual before checking using
 // errors.Unwrap() and github.com/pkg/errors.Cause().
+// In case of multi-error (Unwrap() []error) it use only first error.
 //
 // It will use !proto.Equal for gRPC status errors.
 //
 // They must have either different types or values (or one should be nil).
 // Different instances with same type and value will be considered the
 // same error, and so is both nil.
-func (t *C) NotErr(actual, expected error, msg ...interface{}) bool {
+//
+// Finally it'll use !errors.Is().
+func (t *C) NotErr(actual, expected error, msg ...any) bool {
 	t.Helper()
 	actual2 := unwrapErr(actual)
 	notEqual := fmt.Sprintf("%#v", actual2) != fmt.Sprintf("%#v", expected)
@@ -772,13 +787,16 @@ func (t *C) NotErr(actual, expected error, msg ...interface{}) bool {
 	if proto1 || proto2 {
 		notEqual = !proto.Equal(status.Convert(actual2).Proto(), status.Convert(expected).Proto())
 	}
+	if notEqual {
+		notEqual = !errors.Is(actual, expected)
+	}
 	return t.report1(actual, msg, notEqual)
 }
 
 // Panic checks is actual() panics.
 //
 // It is able to detect panic(nil)… but you should try to avoid using this.
-func (t *C) Panic(actual func(), msg ...interface{}) bool {
+func (t *C) Panic(actual func(), msg ...any) bool {
 	t.Helper()
 	didPanic := true
 	func() {
@@ -793,7 +811,7 @@ func (t *C) Panic(actual func(), msg ...interface{}) bool {
 // NotPanic checks is actual() don't panics.
 //
 // It is able to detect panic(nil)… but you should try to avoid using this.
-func (t *C) NotPanic(actual func(), msg ...interface{}) bool {
+func (t *C) NotPanic(actual func(), msg ...any) bool {
 	t.Helper()
 	didPanic := true
 	func() {
@@ -810,9 +828,9 @@ func (t *C) NotPanic(actual func(), msg ...interface{}) bool {
 // Regex type can be either *regexp.Regexp or string.
 //
 // In case of panic(nil) it will match like panic("<nil>").
-func (t *C) PanicMatch(actual func(), regex interface{}, msg ...interface{}) bool {
+func (t *C) PanicMatch(actual func(), regex any, msg ...any) bool {
 	t.Helper()
-	var panicVal interface{}
+	var panicVal any
 	didPanic := true
 	func() {
 		defer func() { panicVal = recover() }()
@@ -840,9 +858,9 @@ func (t *C) PanicMatch(actual func(), regex interface{}, msg ...interface{}) boo
 // Regex type can be either *regexp.Regexp or string.
 //
 // In case of panic(nil) it will match like panic("<nil>").
-func (t *C) PanicNotMatch(actual func(), regex interface{}, msg ...interface{}) bool {
+func (t *C) PanicNotMatch(actual func(), regex any, msg ...any) bool {
 	t.Helper()
-	var panicVal interface{}
+	var panicVal any
 	didPanic := true
 	func() {
 		defer func() { panicVal = recover() }()
@@ -873,13 +891,13 @@ func (t *C) PanicNotMatch(actual func(), regex interface{}, msg ...interface{})
 //   - floats
 //   - strings
 //   - time.Time
-func (t *C) Less(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) Less(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.report2(actual, expected, msg,
 		isLess(actual, expected))
 }
 
-func isLess(actual, expected interface{}) bool {
+func isLess(actual, expected any) bool {
 	switch v1, v2 := reflect.ValueOf(actual), reflect.ValueOf(expected); v1.Kind() { //nolint:exhaustive // Covered by default case.
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		return v1.Int() < v2.Int()
@@ -898,7 +916,7 @@ func isLess(actual, expected interface{}) bool {
 }
 
 // LT is a synonym for Less.
-func (t *C) LT(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) LT(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.Less(actual, expected, msg...)
 }
@@ -911,13 +929,13 @@ func (t *C) LT(actual, expected interface{}, msg ...interface{}) bool {
 //   - floats
 //   - strings
 //   - time.Time
-func (t *C) LessOrEqual(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) LessOrEqual(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.report2(actual, expected, msg,
 		!isGreater(actual, expected))
 }
 
-func isGreater(actual, expected interface{}) bool {
+func isGreater(actual, expected any) bool {
 	switch v1, v2 := reflect.ValueOf(actual), reflect.ValueOf(expected); v1.Kind() { //nolint:exhaustive // Covered by default case.
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		return v1.Int() > v2.Int()
@@ -936,7 +954,7 @@ func isGreater(actual, expected interface{}) bool {
 }
 
 // LE is a synonym for LessOrEqual.
-func (t *C) LE(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) LE(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.LessOrEqual(actual, expected, msg...)
 }
@@ -949,14 +967,14 @@ func (t *C) LE(actual, expected interface{}, msg ...interface{}) bool {
 //   - floats
 //   - strings
 //   - time.Time
-func (t *C) Greater(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) Greater(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.report2(actual, expected, msg,
 		isGreater(actual, expected))
 }
 
 // GT is a synonym for Greater.
-func (t *C) GT(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) GT(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.Greater(actual, expected, msg...)
 }
@@ -969,14 +987,14 @@ func (t *C) GT(actual, expected interface{}, msg ...interface{}) bool {
 //   - floats
 //   - strings
 //   - time.Time
-func (t *C) GreaterOrEqual(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) GreaterOrEqual(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.report2(actual, expected, msg,
 		!isLess(actual, expected))
 }
 
 // GE is a synonym for GreaterOrEqual.
-func (t *C) GE(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) GE(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.GreaterOrEqual(actual, expected, msg...)
 }
@@ -989,13 +1007,13 @@ func (t *C) GE(actual, expected interface{}, msg ...interface{}) bool {
 //   - floats
 //   - strings
 //   - time.Time
-func (t *C) Between(actual, min, max interface{}, msg ...interface{}) bool {
+func (t *C) Between(actual, min, max any, msg ...any) bool {
 	t.Helper()
 	return t.report3(actual, min, max, msg,
 		isBetween(actual, min, max))
 }
 
-func isBetween(actual, min, max interface{}) bool {
+func isBetween(actual, min, max any) bool {
 	switch v, vmin, vmax := reflect.ValueOf(actual), reflect.ValueOf(min), reflect.ValueOf(max); v.Kind() { //nolint:exhaustive // Covered by default case.
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		return vmin.Int() < v.Int() && v.Int() < vmax.Int()
@@ -1023,7 +1041,7 @@ func isBetween(actual, min, max interface{}) bool {
 //   - floats
 //   - strings
 //   - time.Time
-func (t *C) NotBetween(actual, min, max interface{}, msg ...interface{}) bool {
+func (t *C) NotBetween(actual, min, max any, msg ...any) bool {
 	t.Helper()
 	return t.report3(actual, min, max, msg,
 		!isBetween(actual, min, max))
@@ -1037,7 +1055,7 @@ func (t *C) NotBetween(actual, min, max interface{}, msg ...interface{}) bool {
 //   - floats
 //   - strings
 //   - time.Time
-func (t *C) BetweenOrEqual(actual, min, max interface{}, msg ...interface{}) bool {
+func (t *C) BetweenOrEqual(actual, min, max any, msg ...any) bool {
 	t.Helper()
 	return t.report3(actual, min, max, msg,
 		isBetween(actual, min, max) || isEqual(actual, min) || isEqual(actual, max))
@@ -1051,7 +1069,7 @@ func (t *C) BetweenOrEqual(actual, min, max interface{}, msg ...interface{}) boo
 //   - floats
 //   - strings
 //   - time.Time
-func (t *C) NotBetweenOrEqual(actual, min, max interface{}, msg ...interface{}) bool {
+func (t *C) NotBetweenOrEqual(actual, min, max any, msg ...any) bool {
 	t.Helper()
 	return t.report3(actual, min, max, msg,
 		!(isBetween(actual, min, max) || isEqual(actual, min) || isEqual(actual, max)))
@@ -1064,13 +1082,13 @@ func (t *C) NotBetweenOrEqual(actual, min, max interface{}, msg ...interface{})
 //   - unsigned integers
 //   - floats
 //   - time.Time (in this case delta must be time.Duration)
-func (t *C) InDelta(actual, expected, delta interface{}, msg ...interface{}) bool {
+func (t *C) InDelta(actual, expected, delta any, msg ...any) bool {
 	t.Helper()
 	return t.report3(actual, expected, delta, msg,
 		isInDelta(actual, expected, delta))
 }
 
-func isInDelta(actual, expected, delta interface{}) bool {
+func isInDelta(actual, expected, delta any) bool {
 	switch v, e, d := reflect.ValueOf(actual), reflect.ValueOf(expected), reflect.ValueOf(delta); v.Kind() { //nolint:exhaustive // Covered by default case.
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		min, max := e.Int()-d.Int(), e.Int()+d.Int()
@@ -1101,7 +1119,7 @@ func isInDelta(actual, expected, delta interface{}) bool {
 //   - unsigned integers
 //   - floats
 //   - time.Time (in this case delta must be time.Duration)
-func (t *C) NotInDelta(actual, expected, delta interface{}, msg ...interface{}) bool {
+func (t *C) NotInDelta(actual, expected, delta any, msg ...any) bool {
 	t.Helper()
 	return t.report3(actual, expected, delta, msg,
 		!isInDelta(actual, expected, delta))
@@ -1127,14 +1145,14 @@ func (t *C) NotInDelta(actual, expected, delta interface{}, msg ...interface{})
 //   - ~82   when they differs in 10 times
 //   - 99.0+ when actual and expected differs in 200+ times
 //   - 100.0 when only one of actual or expected is 0 or one of them is
-//           positive while another is negative
-func (t *C) InSMAPE(actual, expected interface{}, smape float64, msg ...interface{}) bool {
+//     positive while another is negative
+func (t *C) InSMAPE(actual, expected any, smape float64, msg ...any) bool {
 	t.Helper()
 	return t.report3(actual, expected, smape, msg,
 		isInSMAPE(actual, expected, smape))
 }
 
-func isInSMAPE(actual, expected interface{}, smape float64) bool {
+func isInSMAPE(actual, expected any, smape float64) bool {
 	if !(0 < smape && smape < 100) {
 		panic("smape is not in allowed range: 0 < smape < 100")
 	}
@@ -1151,7 +1169,7 @@ func isInSMAPE(actual, expected interface{}, smape float64) bool {
 // smape.
 //
 // See InSMAPE about supported actual/expected types and check logic.
-func (t *C) NotInSMAPE(actual, expected interface{}, smape float64, msg ...interface{}) bool {
+func (t *C) NotInSMAPE(actual, expected any, smape float64, msg ...any) bool {
 	t.Helper()
 	return t.report3(actual, expected, smape, msg,
 		!isInSMAPE(actual, expected, smape))
@@ -1166,7 +1184,7 @@ func (t *C) NotInSMAPE(actual, expected interface{}, smape float64, msg ...inter
 //   - fmt.Stringer - will convert with actual.String()
 //   - error        - will convert with actual.Error()
 //   - nil          - check will always fail
-func (t *C) HasPrefix(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) HasPrefix(actual, expected any, msg ...any) bool {
 	t.Helper()
 	ok := isHasPrefix(&actual, &expected)
 	return t.report2(actual, expected, msg,
@@ -1175,7 +1193,7 @@ func (t *C) HasPrefix(actual, expected interface{}, msg ...interface{}) bool {
 
 // isHasPrefix updates actual and expected to be a real string used for check,
 // to make dump easier to understand, but this result in losing type information.
-func isHasPrefix(actual, expected *interface{}) bool { //nolint:gocritic // False positive.
+func isHasPrefix(actual, expected *any) bool { //nolint:gocritic // False positive.
 	if *actual == nil || *expected == nil {
 		return false
 	}
@@ -1191,7 +1209,7 @@ func isHasPrefix(actual, expected *interface{}) bool { //nolint:gocritic // Fals
 // NotHasPrefix checks for !strings.HasPrefix(actual, expected).
 //
 // See HasPrefix about supported actual/expected types and check logic.
-func (t *C) NotHasPrefix(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) NotHasPrefix(actual, expected any, msg ...any) bool {
 	t.Helper()
 	ok := !isHasPrefix(&actual, &expected)
 	return t.report2(actual, expected, msg,
@@ -1207,7 +1225,7 @@ func (t *C) NotHasPrefix(actual, expected interface{}, msg ...interface{}) bool
 //   - fmt.Stringer - will convert with actual.String()
 //   - error        - will convert with actual.Error()
 //   - nil          - check will always fail
-func (t *C) HasSuffix(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) HasSuffix(actual, expected any, msg ...any) bool {
 	t.Helper()
 	ok := isHasSuffix(&actual, &expected)
 	return t.report2(actual, expected, msg,
@@ -1216,7 +1234,7 @@ func (t *C) HasSuffix(actual, expected interface{}, msg ...interface{}) bool {
 
 // isHasSuffix updates actual and expected to be a real string used for check,
 // to make dump easier to understand, but this result in losing type information.
-func isHasSuffix(actual, expected *interface{}) bool { //nolint:gocritic // False positive.
+func isHasSuffix(actual, expected *any) bool { //nolint:gocritic // False positive.
 	if *actual == nil || *expected == nil {
 		return false
 	}
@@ -1232,7 +1250,7 @@ func isHasSuffix(actual, expected *interface{}) bool { //nolint:gocritic // Fals
 // NotHasSuffix checks for !strings.HasSuffix(actual, expected).
 //
 // See HasSuffix about supported actual/expected types and check logic.
-func (t *C) NotHasSuffix(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) NotHasSuffix(actual, expected any, msg ...any) bool {
 	t.Helper()
 	ok := !isHasSuffix(&actual, &expected)
 	return t.report2(actual, expected, msg,
@@ -1251,7 +1269,7 @@ func (t *C) NotHasSuffix(actual, expected interface{}, msg ...interface{}) bool
 //
 // In case any of actual or expected is nil or empty or (for string or
 // []byte) is invalid JSON - check will fail.
-func (t *C) JSONEqual(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) JSONEqual(actual, expected any, msg ...any) bool {
 	t.Helper()
 	ok := isJSONEqual(actual, expected)
 	if !ok {
@@ -1266,13 +1284,13 @@ func (t *C) JSONEqual(actual, expected interface{}, msg ...interface{}) bool {
 		ok)
 }
 
-func isJSONEqual(actual, expected interface{}) bool {
+func isJSONEqual(actual, expected any) bool {
 	jsonActual, jsonExpected := jsonify(actual), jsonify(expected)
 	return len(jsonActual) != 0 && len(jsonExpected) != 0 &&
 		bytes.Equal(jsonActual, jsonExpected)
 }
 
-func jsonify(arg interface{}) json.RawMessage {
+func jsonify(arg any) json.RawMessage {
 	switch v := (arg).(type) {
 	case nil:
 		return nil
@@ -1286,7 +1304,7 @@ func jsonify(arg interface{}) json.RawMessage {
 	}
 	buf := reflect.ValueOf(arg).Convert(typBytes).Interface().([]byte) //nolint:forcetypeassert // Want panic.
 
-	var v interface{}
+	var v any
 	err := json.Unmarshal(buf, &v)
 	if err != nil {
 		return nil
@@ -1299,14 +1317,14 @@ func jsonify(arg interface{}) json.RawMessage {
 }
 
 // HasType checks is actual has same type as expected.
-func (t *C) HasType(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) HasType(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.report2(actual, expected, msg,
 		reflect.TypeOf(actual) == reflect.TypeOf(expected))
 }
 
 // NotHasType checks is actual has not same type as expected.
-func (t *C) NotHasType(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) NotHasType(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.report2(actual, expected, msg,
 		reflect.TypeOf(actual) != reflect.TypeOf(expected))
@@ -1317,13 +1335,13 @@ func (t *C) NotHasType(actual, expected interface{}, msg ...interface{}) bool {
 // You must use pointer to interface type in expected:
 //
 //	t.Implements(os.Stdin, (*io.Reader)(nil))
-func (t *C) Implements(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) Implements(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.report2(actual, expected, msg,
 		isImplements(actual, expected))
 }
 
-func isImplements(actual, expected interface{}) bool {
+func isImplements(actual, expected any) bool {
 	typActual := reflect.TypeOf(actual)
 	if typActual.Kind() != reflect.Ptr {
 		typActual = reflect.PtrTo(typActual)
@@ -1336,7 +1354,7 @@ func isImplements(actual, expected interface{}) bool {
 // You must use pointer to interface type in expected:
 //
 //	t.NotImplements(os.Stdin, (*fmt.Stringer)(nil))
-func (t *C) NotImplements(actual, expected interface{}, msg ...interface{}) bool {
+func (t *C) NotImplements(actual, expected any, msg ...any) bool {
 	t.Helper()
 	return t.report2(actual, expected, msg,
 		!isImplements(actual, expected))

vendor/github.com/powerman/check/color_bsd.go

@@ -1,3 +1,4 @@
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
 // +build darwin dragonfly freebsd netbsd openbsd
 
 package check

vendor/github.com/powerman/check/color_linux.go

@@ -1,3 +1,4 @@
+//go:build linux
 // +build linux
 
 package check

vendor/github.com/powerman/check/color_other.go

@@ -1,3 +1,4 @@
+//go:build !linux && !darwin && !dragonfly && !freebsd && !netbsd && !openbsd && !windows
 // +build !linux,!darwin,!dragonfly,!freebsd,!netbsd,!openbsd,!windows
 
 package check

vendor/github.com/powerman/check/color_windows.go

@@ -1,3 +1,4 @@
+//go:build windows
 // +build windows
 
 package check

vendor/github.com/powerman/check/doc.go

@@ -1,13 +1,13 @@
 // Package check provide helpers to complement Go testing package.
 //
-// Features
+// # Features
 //
 // This package is like testify/assert on steroids. :)
 //
 //   - Compelling output from failed tests:
-//     - Very easy-to-read dumps for expected and actual values.
-//     - Same text diff you loved in testify/assert.
-//     - Also visual diff in GoConvey web UI, if you use it (recommended).
+//   - Very easy-to-read dumps for expected and actual values.
+//   - Same text diff you loved in testify/assert.
+//   - Also visual diff in GoConvey web UI, if you use it (recommended).
 //   - Statistics with amount of passed/failed checks.
 //   - Colored output in terminal.
 //   - 100% compatible with testing package - check package just provide
@@ -17,7 +17,7 @@
 //   - Very easy to add your own check functions.
 //   - Concise, handy and consistent API, without dot-import!
 //
-// Quickstart
+// # Quickstart
 //
 // Just wrap each (including subtests) *testing.T using check.T() and write
 // tests as usually with testing package. Call new methods provided by
@@ -48,7 +48,7 @@
 //
 //	import _ "github.com/smartystreets/goconvey/convey"
 //
-// Hints
+// # Hints
 //
 // ★ How to check for errors:
 //
@@ -111,7 +111,7 @@
 //
 //	export GO_TEST_COLOR=1
 //
-// Contents
+// # Contents
 //
 // There are few special functions (assertion, custom checkers, etc.).
 //

vendor/github.com/powerman/check/dump.go

@@ -64,10 +64,11 @@ func (v dump) diff(expected dump) string {
 // - string: use this instead of quoted single-line:
 //   - valid utf8: don't quote ", show multiline strings on separate lines
 //   - invalid utf8: use hexdump like for []byte
+//
 // - []byte: same as string instead of hexdump for valid utf8
 // - []rune: use quoted char instead of number for valid runes in list
 // - json.RawMessage: indent, then same as string.
-func newDump(i interface{}) (d dump) { //nolint:gocyclo,gocognit,funlen,cyclop // By design.
+func newDump(i any) (d dump) { //nolint:gocyclo,gocognit,funlen,cyclop // By design.
 	d.dump = spewCfg.Sdump(i)
 
 	if i == nil {

vendor/github.com/powerman/check/tools.go

@@ -1,10 +1,9 @@
-// +build tools generate
+//go:build generate
 
-//go:generate sh -c "GOBIN=$PWD/.gobincache go install $(sed -n 's/.*_ \"\\(.*\\)\".*/\\1/p' <$GOFILE)"
+//go:generate mkdir -p .buildcache/bin
+//go:generate -command GOINSTALL env "GOBIN=$PWD/.buildcache/bin" go install
 
 package tools
 
-import (
-	_ "github.com/golangci/golangci-lint/cmd/golangci-lint"
-	_ "github.com/mattn/goveralls"
-)
+//go:generate GOINSTALL github.com/golangci/golangci-lint/cmd/golangci-lint@v1.52.0
+//go:generate GOINSTALL github.com/mattn/goveralls@v0.0.11

vendor/github.com/powerman/check/util.go

@@ -30,7 +30,7 @@ func callerFuncName(stack int) string {
 	return strings.TrimPrefix(funcNameAt(pc), "(*C).")
 }
 
-func funcName(f interface{}) string {
+func funcName(f any) string {
 	return funcNameAt(reflect.ValueOf(f).Pointer())
 }
 
@@ -48,7 +48,7 @@ func funcNameAt(pc uintptr) string {
 	return name
 }
 
-func format(msg ...interface{}) string {
+func format(msg ...any) string {
 	if len(msg) > 1 {
 		return fmt.Sprintf(msg[0].(string), msg[1:]...)
 	}