修复缓存

pkg/errorx/atomicerror_test.go

@@ -1,82 +0,0 @@
-package errorx
-
-import (
-	"errors"
-	"sync"
-	"sync/atomic"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-var errDummy = errors.New("hello")
-
-func TestAtomicError(t *testing.T) {
-	var err AtomicError
-	err.Set(errDummy)
-	assert.Equal(t, errDummy, err.Load())
-}
-
-func TestAtomicErrorSetNil(t *testing.T) {
-	var (
-		errNil error
-		err    AtomicError
-	)
-	err.Set(errNil)
-	assert.Equal(t, errNil, err.Load())
-}
-
-func TestAtomicErrorNil(t *testing.T) {
-	var err AtomicError
-	assert.Nil(t, err.Load())
-}
-
-func BenchmarkAtomicError(b *testing.B) {
-	var aerr AtomicError
-	wg := sync.WaitGroup{}
-
-	b.Run("Load", func(b *testing.B) {
-		var done uint32
-		go func() {
-			for {
-				if atomic.LoadUint32(&done) != 0 {
-					break
-				}
-				wg.Add(1)
-				go func() {
-					aerr.Set(errDummy)
-					wg.Done()
-				}()
-			}
-		}()
-		b.ResetTimer()
-		for i := 0; i < b.N; i++ {
-			_ = aerr.Load()
-		}
-		b.StopTimer()
-		atomic.StoreUint32(&done, 1)
-		wg.Wait()
-	})
-	b.Run("Set", func(b *testing.B) {
-		var done uint32
-		go func() {
-			for {
-				if atomic.LoadUint32(&done) != 0 {
-					break
-				}
-				wg.Add(1)
-				go func() {
-					_ = aerr.Load()
-					wg.Done()
-				}()
-			}
-		}()
-		b.ResetTimer()
-		for i := 0; i < b.N; i++ {
-			aerr.Set(errDummy)
-		}
-		b.StopTimer()
-		atomic.StoreUint32(&done, 1)
-		wg.Wait()
-	})
-}

pkg/errorx/batcherror_test.go

@@ -1,147 +0,0 @@
-package errorx
-
-import (
-	"errors"
-	"fmt"
-	"sync"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-const (
-	err1 = "first error"
-	err2 = "second error"
-)
-
-func TestBatchErrorNil(t *testing.T) {
-	var batch BatchError
-	assert.Nil(t, batch.Err())
-	assert.False(t, batch.NotNil())
-	batch.Add(nil)
-	assert.Nil(t, batch.Err())
-	assert.False(t, batch.NotNil())
-}
-
-func TestBatchErrorNilFromFunc(t *testing.T) {
-	err := func() error {
-		var be BatchError
-		return be.Err()
-	}()
-	assert.True(t, err == nil)
-}
-
-func TestBatchErrorOneError(t *testing.T) {
-	var batch BatchError
-	batch.Add(errors.New(err1))
-	assert.NotNil(t, batch.Err())
-	assert.Equal(t, err1, batch.Err().Error())
-	assert.True(t, batch.NotNil())
-}
-
-func TestBatchErrorWithErrors(t *testing.T) {
-	var batch BatchError
-	batch.Add(errors.New(err1))
-	batch.Add(errors.New(err2))
-	assert.NotNil(t, batch.Err())
-	assert.Equal(t, fmt.Sprintf("%s\n%s", err1, err2), batch.Err().Error())
-	assert.True(t, batch.NotNil())
-}
-
-func TestBatchErrorConcurrentAdd(t *testing.T) {
-	const count = 10000
-	var batch BatchError
-	var wg sync.WaitGroup
-
-	wg.Add(count)
-	for i := 0; i < count; i++ {
-		go func() {
-			defer wg.Done()
-			batch.Add(errors.New(err1))
-		}()
-	}
-	wg.Wait()
-
-	assert.NotNil(t, batch.Err())
-	assert.Equal(t, count, len(batch.errs))
-	assert.True(t, batch.NotNil())
-}
-
-func TestBatchError_Unwrap(t *testing.T) {
-	t.Run("nil", func(t *testing.T) {
-		var be BatchError
-		assert.Nil(t, be.Err())
-		assert.True(t, errors.Is(be.Err(), nil))
-	})
-
-	t.Run("one error", func(t *testing.T) {
-		var errFoo = errors.New("foo")
-		var errBar = errors.New("bar")
-		var be BatchError
-		be.Add(errFoo)
-		assert.True(t, errors.Is(be.Err(), errFoo))
-		assert.False(t, errors.Is(be.Err(), errBar))
-	})
-
-	t.Run("two errors", func(t *testing.T) {
-		var errFoo = errors.New("foo")
-		var errBar = errors.New("bar")
-		var errBaz = errors.New("baz")
-		var be BatchError
-		be.Add(errFoo)
-		be.Add(errBar)
-		assert.True(t, errors.Is(be.Err(), errFoo))
-		assert.True(t, errors.Is(be.Err(), errBar))
-		assert.False(t, errors.Is(be.Err(), errBaz))
-	})
-}
-
-func TestBatchError_Add(t *testing.T) {
-	var be BatchError
-
-	// Test adding nil errors
-	be.Add(nil, nil)
-	assert.False(t, be.NotNil(), "Expected BatchError to be empty after adding nil errors")
-
-	// Test adding non-nil errors
-	err1 := errors.New("error 1")
-	err2 := errors.New("error 2")
-	be.Add(err1, err2)
-	assert.True(t, be.NotNil(), "Expected BatchError to be non-empty after adding errors")
-
-	// Test adding a mix of nil and non-nil errors
-	err3 := errors.New("error 3")
-	be.Add(nil, err3, nil)
-	assert.True(t, be.NotNil(), "Expected BatchError to be non-empty after adding a mix of nil and non-nil errors")
-}
-
-func TestBatchError_Err(t *testing.T) {
-	var be BatchError
-
-	// Test Err() on empty BatchError
-	assert.Nil(t, be.Err(), "Expected nil error for empty BatchError")
-
-	// Test Err() with multiple errors
-	err1 := errors.New("error 1")
-	err2 := errors.New("error 2")
-	be.Add(err1, err2)
-
-	combinedErr := be.Err()
-	assert.NotNil(t, combinedErr, "Expected nil error for BatchError with multiple errors")
-
-	// Check if the combined error contains both error messages
-	errString := combinedErr.Error()
-	assert.Truef(t, errors.Is(combinedErr, err1), "Combined error doesn't contain first error: %s", errString)
-	assert.Truef(t, errors.Is(combinedErr, err2), "Combined error doesn't contain second error: %s", errString)
-}
-
-func TestBatchError_NotNil(t *testing.T) {
-	var be BatchError
-
-	// Test NotNil() on empty BatchError
-	assert.Nil(t, be.Err(), "Expected nil error for empty BatchError")
-
-	// Test NotNil() after adding an error
-	be.Add(errors.New("test error"))
-	assert.NotNil(t, be.Err(), "Expected non-nil error after adding an error")
-}

pkg/errorx/callchain_test.go

@@ -1,27 +0,0 @@
-package errorx
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestChain(t *testing.T) {
-	errDummy := errors.New("dummy")
-	assert.Nil(t, Chain(func() error {
-		return nil
-	}, func() error {
-		return nil
-	}))
-	assert.Equal(t, errDummy, Chain(func() error {
-		return errDummy
-	}, func() error {
-		return nil
-	}))
-	assert.Equal(t, errDummy, Chain(func() error {
-		return nil
-	}, func() error {
-		return errDummy
-	}))
-}

pkg/errorx/check_test.go

@@ -1,70 +0,0 @@
-package errorx
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestIn(t *testing.T) {
-	err1 := errors.New("error 1")
-	err2 := errors.New("error 2")
-	err3 := errors.New("error 3")
-
-	tests := []struct {
-		name string
-		err  error
-		errs []error
-		want bool
-	}{
-		{
-			name: "Error matches one of the errors in the list",
-			err:  err1,
-			errs: []error{err1, err2},
-			want: true,
-		},
-		{
-			name: "Error does not match any errors in the list",
-			err:  err3,
-			errs: []error{err1, err2},
-			want: false,
-		},
-		{
-			name: "Empty error list",
-			err:  err1,
-			errs: []error{},
-			want: false,
-		},
-		{
-			name: "Nil error with non-nil list",
-			err:  nil,
-			errs: []error{err1, err2},
-			want: false,
-		},
-		{
-			name: "Non-nil error with nil in list",
-			err:  err1,
-			errs: []error{nil, err2},
-			want: false,
-		},
-		{
-			name: "Error matches nil error in the list",
-			err:  nil,
-			errs: []error{nil, err2},
-			want: true,
-		},
-		{
-			name: "Nil error with empty list",
-			err:  nil,
-			errs: []error{},
-			want: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := In(tt.err, tt.errs...); got != tt.want {
-				t.Errorf("In() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}

pkg/errorx/wrap_test.go

@@ -1,24 +0,0 @@
-package errorx
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestWrap(t *testing.T) {
-	assert.Nil(t, Wrap(nil, "test"))
-	assert.Equal(t, "foo: bar", Wrap(errors.New("bar"), "foo").Error())
-
-	err := errors.New("foo")
-	assert.True(t, errors.Is(Wrap(err, "bar"), err))
-}
-
-func TestWrapf(t *testing.T) {
-	assert.Nil(t, Wrapf(nil, "%s", "test"))
-	assert.Equal(t, "foo bar: quz", Wrapf(errors.New("quz"), "foo %s", "bar").Error())
-
-	err := errors.New("foo")
-	assert.True(t, errors.Is(Wrapf(err, "foo %s", "bar"), err))
-}