Merge branch 'bench-tests' of ssh://g.yxqyang.asia-lainio/lainio/err2 into bench-tests

Author: lainio

.golangci.yml

@@ -33,12 +33,7 @@ linters-settings:
     # Default: 5
     min-complexity: 8
   gomnd:
-    settings:
-      mnd:
-        # don't include the "operation" and "assign"
-        checks: argument,case,condition,return
   govet:
-    check-shadowing: true
   lll:
     line-length: 140
   maligned:

Makefile

@@ -11,6 +11,7 @@ PKGS := $(PKG_ERR2) $(PKG_ASSERT) $(PKG_TRY) $(PKG_DEBUG) $(PKG_HANDLER) $(PKG_S
 
 SRCDIRS := $(shell go list -f '{{.Dir}}' $(PKGS))
 
+MAX_LINE ?= 80
 GO ?= go
 TEST_ARGS ?= -benchmem
 # -"gcflags '-N -l'" both optimization & inlining disabled
@@ -106,6 +107,12 @@ bench_x:
 vet: | test
 	$(GO) vet $(PKGS)
 
+fmt:
+	@golines -t 5 -w -m $(MAX_LINE) --ignore-generated .
+
+dry-fmt:
+	@golines -t 5 --dry-run -m $(MAX_LINE) --ignore-generated .
+
 gofmt:
 	@echo Checking code is gofmted
 	@test -z "$(shell gofmt -s -l -d -e $(SRCDIRS) | tee /dev/stderr)"

err2_test.go

@@ -1,31 +1,31 @@
 package err2_test
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"os"
 	"runtime"
 	"testing"
 
 	"github.com/lainio/err2"
-	"github.com/lainio/err2/internal/test"
+	"github.com/lainio/err2/internal/require"
 	"github.com/lainio/err2/try"
 )
 
 const errStringInThrow = "this is an ERROR"
 
-func throw() (string, error) {
-	return "", fmt.Errorf(errStringInThrow)
-}
+var (
+	errToTest = errors.New(errStringInThrow)
+)
+
+func throw() (string, error)   { return "", errToTest }
+func noThrow() (string, error) { return "test", nil }
+func noErr() error             { return nil }
 
 func twoStrNoThrow() (string, string, error)        { return "test", "test", nil }
 func intStrNoThrow() (int, string, error)           { return 1, "test", nil }
 func boolIntStrNoThrow() (bool, int, string, error) { return true, 1, "test", nil }
-func noThrow() (string, error)                      { return "test", nil }
-
-func noErr() error {
-	return nil
-}
 
 func TestTry_noError(t *testing.T) {
 	t.Parallel()
@@ -62,9 +62,9 @@ func TestHandle_noerrHandler(t *testing.T) {
 		var err error
 		var handlerCalled bool
 		defer func() {
-			test.Require(t, handlerCalled)
+			require.That(t, handlerCalled)
 		}()
-		// This is the handler we are thesting!
+		// This is the handler we are testing!
 		defer err2.Handle(&err, func(noerr bool) {
 			handlerCalled = noerr
 		})
@@ -77,16 +77,16 @@ func TestHandle_noerrHandler(t *testing.T) {
 		var err error
 		var handlerCalled bool
 		defer func() {
-			test.Require(t, handlerCalled)
+			require.That(t, handlerCalled)
 		}()
 		defer err2.Handle(&err, func(err error) error {
 			// this should not be called, so lets try to fuckup things...
 			handlerCalled = false
-			test.Require(t, false)
+			require.That(t, false)
 			return err
 		})
 
-		// This is the handler we are thesting!
+		// This is the handler we are testing!
 		defer err2.Handle(&err, func(noerr bool) {
 			handlerCalled = noerr
 		})
@@ -99,18 +99,20 @@ func TestHandle_noerrHandler(t *testing.T) {
 		var err error
 		var handlerCalled bool
 		defer func() {
-			test.Require(t, !handlerCalled)
+			require.ThatNot(t, handlerCalled)
 		}()
+
+		// This is the handler we are testing!
 		defer err2.Handle(&err, func(err error) error {
+			require.ThatNot(t, handlerCalled)
 			handlerCalled = false
-			test.Require(t, true, "error should be handled")
+			require.That(t, true, "error should be handled")
 			return err
 		})
 
-		// This is the handler we are thesting!
-		defer err2.Handle(&err, func(noerr bool) {
-			test.Require(t, noerr)
-			handlerCalled = noerr
+		// This is the handler we are testing! AND it's not called in error.
+		defer err2.Handle(&err, func(bool) {
+			require.That(t, false, "when error this is not called")
 		})
 
 		try.To1(throw())
@@ -122,29 +124,35 @@ func TestHandle_noerrHandler(t *testing.T) {
 			err               error
 			finalAnnotatedErr = fmt.Errorf("err: %v", errStringInThrow)
 			handlerCalled     bool
+			callCount         int
 		)
 		defer func() {
-			test.Require(t, !handlerCalled)
-			test.RequireEqual(t, err.Error(), finalAnnotatedErr.Error())
+			require.ThatNot(t, handlerCalled)
+			require.Equal(t, callCount, 2)
+			require.Equal(t, err.Error(), finalAnnotatedErr.Error())
 		}()
 
-		// This is the handler we are thesting!
+		// This is the handler we are testing! AND it's not called in error.
 		defer err2.Handle(&err, func(noerr bool) {
-			test.Require(t, false, "if error occurs/reset, this cannot happen")
+			require.That(t, false, "if error occurs/reset, this cannot happen")
 			handlerCalled = noerr
 		})
 
 		// important! test that our handler doesn't change the current error
 		// and it's not nil
 		defer err2.Handle(&err, func(er error) error {
-			test.Require(t, er != nil, "er val: ", er, err)
+			require.That(t, er != nil, "er val: ", er, err)
+			require.Equal(t, callCount, 1, "this is called in sencond")
+			callCount++
 			return er
 		})
 
 		defer err2.Handle(&err, func(err error) error {
 			// this should not be called, so lets try to fuckup things...
+			require.Equal(t, callCount, 0, "this is called in first")
+			callCount++
 			handlerCalled = false
-			test.Require(t, err != nil)
+			require.That(t, err != nil)
 			return finalAnnotatedErr
 		})
 		try.To1(throw())
@@ -155,17 +163,17 @@ func TestHandle_noerrHandler(t *testing.T) {
 		var err error
 		var handlerCalled bool
 		defer func() {
-			test.Require(t, handlerCalled)
+			require.That(t, handlerCalled)
 		}()
 
-		// This is the handler we are thesting!
+		// This is the handler we are testing!
 		defer err2.Handle(&err, func(noerr bool) {
-			test.Require(t, noerr)
+			require.That(t, noerr)
 			handlerCalled = noerr
 		})
 
 		defer err2.Handle(&err, func(err error) error {
-			test.Require(t, false, "no error to handle!")
+			require.That(t, false, "no error to handle!")
 			// this should not be called, so lets try to fuckup things...
 			handlerCalled = false // see first deferred function
 			return err
@@ -178,26 +186,27 @@ func TestHandle_noerrHandler(t *testing.T) {
 		var err error
 		var handlerCalled bool
 		defer func() {
-			test.Require(t, handlerCalled)
+			require.That(t, handlerCalled)
 		}()
 
-		// This is the handler we are thesting!
+		// This is the handler we are testing!
 		defer err2.Handle(&err, func(noerr bool) {
-			test.Require(t, noerr)
+			require.That(t, true)
+			require.That(t, noerr)
 			handlerCalled = noerr
 		})
 
 		defer err2.Handle(&err)
 
 		defer err2.Handle(&err, func(err error) error {
-			test.Require(t, false, "no error to handle!")
+			require.That(t, false, "no error to handle!")
 			// this should not be called, so lets try to fuckup things...
 			handlerCalled = false // see first deferred function
 			return err
 		})
 
 		defer err2.Handle(&err, func(err error) error {
-			test.Require(t, false, "no error to handle!")
+			require.That(t, false, "no error to handle!")
 			// this should not be called, so lets try to fuckup things...
 			handlerCalled = false // see first deferred function
 			return err
@@ -210,20 +219,20 @@ func TestHandle_noerrHandler(t *testing.T) {
 		var err error
 		var noerrHandlerCalled, errHandlerCalled bool
 		defer func() {
-			test.Require(t, noerrHandlerCalled)
-			test.Require(t, errHandlerCalled)
+			require.That(t, noerrHandlerCalled)
+			require.That(t, errHandlerCalled)
 		}()
 
-		// This is the handler we are thesting!
+		// This is the handler we are testing!
 		defer err2.Handle(&err, func(noerr bool) {
-			test.Require(t, true) // we are here, for debugging
-			test.Require(t, noerr)
+			require.That(t, true) // we are here, for debugging
+			require.That(t, noerr)
 			noerrHandlerCalled = noerr
 		})
 
 		// this is the err handler that -- RESETS -- the error to nil
 		defer err2.Handle(&err, func(err error) error {
-			test.Require(t, err != nil) // helps fast debugging
+			require.That(t, err != nil) // helps fast debugging
 
 			// this should not be called, so lets try to fuckup things...
 			noerrHandlerCalled = false // see first deferred function
@@ -233,7 +242,7 @@ func TestHandle_noerrHandler(t *testing.T) {
 		})
 
 		defer err2.Handle(&err, func(err error) error {
-			test.Require(t, err != nil) // helps fast debugging
+			require.That(t, err != nil) // helps fast debugging
 			// this should not be called, so lets try to fuckup things...
 			noerrHandlerCalled = false // see first deferred function
 
@@ -248,27 +257,28 @@ func TestHandle_noerrHandler(t *testing.T) {
 		var err error
 		var handlerCalled bool
 		defer func() {
-			test.Require(t, handlerCalled)
+			require.That(t, handlerCalled)
 		}()
 
 		defer err2.Handle(&err)
 		defer err2.Handle(&err)
 
 		defer err2.Handle(&err, func(err error) error {
-			test.Require(t, false, "no error to handle!")
+			require.That(t, false, "no error to handle!")
 			// this should not be called, so lets try to fuckup things...
 			handlerCalled = false // see first deferred function
 			return err
 		})
 
-		// This is the handler we are thesting!
+		// This is the handler we are testing!
 		defer err2.Handle(&err, func(noerr bool) {
-			test.Require(t, noerr)
+			require.That(t, true, "this must be called")
+			require.That(t, noerr)
 			handlerCalled = noerr
 		})
 
 		defer err2.Handle(&err, func(err error) error {
-			test.Require(t, false, "no error to handle!")
+			require.That(t, false, "no error to handle!")
 			// this should not be called, so lets try to fuckup things...
 			handlerCalled = false // see first deferred function
 			return err
@@ -338,7 +348,7 @@ func TestPanickingCatchAll(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			defer func() {
-				test.Require(t, recover() == nil, "panics should NOT carry on")
+				require.That(t, recover() == nil, "panics should NOT carry on")
 			}()
 			tt.args.f()
 		})
@@ -382,7 +392,7 @@ func TestPanickingCarryOn_Handle(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			defer func() {
-				test.Require(t, recover() != nil, "panics should went thru when not our errors")
+				require.That(t, recover() != nil, "panics should went thru when not our errors")
 			}()
 			tt.args.f()
 		})
@@ -508,12 +518,12 @@ func TestPanicking_Handle(t *testing.T) {
 			defer func() {
 				r := recover()
 				if tt.wants == nil {
-					test.Require(t, r != nil, "wants err, then panic")
+					require.That(t, r != nil, "wants err, then panic")
 				}
 			}()
 			err := tt.args.f()
 			if err != nil {
-				test.RequireEqual(t, err.Error(), tt.wants.Error())
+				require.Equal(t, err.Error(), tt.wants.Error())
 			}
 		})
 	}
@@ -554,7 +564,7 @@ func TestPanicking_Catch(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			defer func() {
-				test.Require(t, recover() == nil, "panics should NOT carry on")
+				require.That(t, recover() == nil, "panics should NOT carry on")
 			}()
 			tt.args.f()
 		})
@@ -573,7 +583,7 @@ func TestCatch_Error(t *testing.T) {
 func Test_TryOutError(t *testing.T) {
 	t.Parallel()
 	defer err2.Catch(func(err error) error {
-		test.RequireEqual(t, err.Error(), "fails: test: this is an ERROR",
+		require.Equal(t, err.Error(), "fails: test: this is an ERROR",
 			"=> we should catch right error str here")
 		return err
 	})
@@ -583,7 +593,7 @@ func Test_TryOutError(t *testing.T) {
 	// let's test try.Out1() and it's throw capabilities here, even try.To1()
 	// is the preferred way.
 	retVal = try.Out1(noThrow()).Handle().Val1
-	test.Require(t, retVal == "test", "if no error happens, we get value")
+	require.Equal(t, retVal, "test", "if no error happens, we get value")
 
 	_ = try.Out1(throw()).Handle("fails: %v", retVal).Val1
 	t.Fail() // If everything works in Handle we are never here.
@@ -615,11 +625,11 @@ func TestCatch_Panic(t *testing.T) {
 func TestSetErrorTracer(t *testing.T) {
 	t.Parallel()
 	w := err2.ErrorTracer()
-	test.Require(t, w == nil, "error tracer should be nil")
+	require.That(t, w == nil, "error tracer should be nil")
 	var w1 io.Writer
 	err2.SetErrorTracer(w1)
 	w = err2.ErrorTracer()
-	test.Require(t, w == nil, "error tracer should be nil")
+	require.That(t, w == nil, "error tracer should be nil")
 }
 
 func ExampleCatch_withFmt() {