diff --git a/err2_test.go b/err2_test.go
index e3c1550..09dc69a 100644
--- a/err2_test.go
+++ b/err2_test.go
@@ -9,7 +9,7 @@ import (
 	"testing"
 
 	"github.com/lainio/err2"
-	"github.com/lainio/err2/internal/require"
+	"github.com/lainio/err2/internal/except"
 	"github.com/lainio/err2/try"
 )
 
@@ -70,7 +70,7 @@ func TestHandle_noerrHandler(t *testing.T) {
 			var err error
 			var handlerCalled bool
 			defer func() {
-				require.That(t, handlerCalled)
+				except.That(t, handlerCalled)
 			}()
 			// This is the handler we are testing!
 			defer err2.Handle(&err, func(noerr bool) {
@@ -88,12 +88,12 @@ func TestHandle_noerrHandler(t *testing.T) {
 			var err error
 			var handlerCalled bool
 			defer func() {
-				require.That(t, handlerCalled)
+				except.That(t, handlerCalled)
 			}()
 			defer err2.Handle(&err, func(err error) error {
 				// this should not be called, so lets try to fuckup things...
 				handlerCalled = false
-				require.That(t, false)
+				except.That(t, false)
 				return err
 			})
 
@@ -111,20 +111,20 @@ func TestHandle_noerrHandler(t *testing.T) {
 		var err error
 		var handlerCalled bool
 		defer func() {
-			require.ThatNot(t, handlerCalled)
+			except.ThatNot(t, handlerCalled)
 		}()
 
 		// This is the handler we are testing!
 		defer err2.Handle(&err, func(err error) error {
-			require.ThatNot(t, handlerCalled)
+			except.ThatNot(t, handlerCalled)
 			handlerCalled = false
-			require.That(t, true, "error should be handled")
+			except.That(t, true, "error should be handled")
 			return err
 		})
 
 		// 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")
+			except.That(t, false, "when error this is not called")
 		})
 
 		try.To1(throw())
@@ -141,14 +141,14 @@ func TestHandle_noerrHandler(t *testing.T) {
 				callCount         int
 			)
 			defer func() {
-				require.ThatNot(t, handlerCalled)
-				require.Equal(t, callCount, 2)
-				require.Equal(t, err.Error(), finalAnnotatedErr.Error())
+				except.ThatNot(t, handlerCalled)
+				except.Equal(t, callCount, 2)
+				except.Equal(t, err.Error(), finalAnnotatedErr.Error())
 			}()
 
 			// This is the handler we are testing! AND it's not called in error.
 			defer err2.Handle(&err, func(noerr bool) {
-				require.That(
+				except.That(
 					t,
 					false,
 					"if error occurs/reset, this cannot happen",
@@ -159,18 +159,18 @@ func TestHandle_noerrHandler(t *testing.T) {
 			// important! test that our handler doesn't change the current error
 			// and it's not nil
 			defer err2.Handle(&err, func(er error) error {
-				require.That(t, er != nil, "er val: ", er, err)
-				require.Equal(t, callCount, 1, "this is called in sencond")
+				except.That(t, er != nil, "er val: ", er, err)
+				except.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")
+				except.Equal(t, callCount, 0, "this is called in first")
 				callCount++
 				handlerCalled = false
-				require.That(t, err != nil)
+				except.That(t, err != nil)
 				return finalAnnotatedErr
 			})
 			try.To1(throw())
@@ -182,17 +182,17 @@ func TestHandle_noerrHandler(t *testing.T) {
 		var err error
 		var handlerCalled bool
 		defer func() {
-			require.That(t, handlerCalled)
+			except.That(t, handlerCalled)
 		}()
 
 		// This is the handler we are testing!
 		defer err2.Handle(&err, func(noerr bool) {
-			require.That(t, noerr)
+			except.That(t, noerr)
 			handlerCalled = noerr
 		})
 
 		defer err2.Handle(&err, func(err error) error {
-			require.That(t, false, "no error to handle!")
+			except.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
@@ -207,27 +207,27 @@ func TestHandle_noerrHandler(t *testing.T) {
 			var err error
 			var handlerCalled bool
 			defer func() {
-				require.That(t, handlerCalled)
+				except.That(t, handlerCalled)
 			}()
 
 			// This is the handler we are testing!
 			defer err2.Handle(&err, func(noerr bool) {
-				require.That(t, true)
-				require.That(t, noerr)
+				except.That(t, true)
+				except.That(t, noerr)
 				handlerCalled = noerr
 			})
 
 			defer err2.Handle(&err)
 
 			defer err2.Handle(&err, func(err error) error {
-				require.That(t, false, "no error to handle!")
+				except.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 {
-				require.That(t, false, "no error to handle!")
+				except.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
@@ -243,20 +243,20 @@ func TestHandle_noerrHandler(t *testing.T) {
 			var err error
 			var noerrHandlerCalled, errHandlerCalled bool
 			defer func() {
-				require.That(t, noerrHandlerCalled)
-				require.That(t, errHandlerCalled)
+				except.That(t, noerrHandlerCalled)
+				except.That(t, errHandlerCalled)
 			}()
 
 			// This is the handler we are testing!
 			defer err2.Handle(&err, func(noerr bool) {
-				require.That(t, true) // we are here, for debugging
-				require.That(t, noerr)
+				except.That(t, true) // we are here, for debugging
+				except.That(t, noerr)
 				noerrHandlerCalled = noerr
 			})
 
 			// this is the err handler that -- RESETS -- the error to nil
 			defer err2.Handle(&err, func(err error) error {
-				require.That(t, err != nil) // helps fast debugging
+				except.That(t, err != nil) // helps fast debugging
 
 				// this should not be called, so lets try to fuckup things...
 				noerrHandlerCalled = false // see first deferred function
@@ -266,7 +266,7 @@ func TestHandle_noerrHandler(t *testing.T) {
 			})
 
 			defer err2.Handle(&err, func(err error) error {
-				require.That(t, err != nil) // helps fast debugging
+				except.That(t, err != nil) // helps fast debugging
 				// this should not be called, so lets try to fuckup things...
 				noerrHandlerCalled = false // see first deferred function
 
@@ -284,14 +284,14 @@ func TestHandle_noerrHandler(t *testing.T) {
 			var err error
 			var handlerCalled bool
 			defer func() {
-				require.That(t, handlerCalled)
+				except.That(t, handlerCalled)
 			}()
 
 			defer err2.Handle(&err)
 			defer err2.Handle(&err)
 
 			defer err2.Handle(&err, func(err error) error {
-				require.That(t, false, "no error to handle!")
+				except.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
@@ -299,13 +299,13 @@ func TestHandle_noerrHandler(t *testing.T) {
 
 			// This is the handler we are testing!
 			defer err2.Handle(&err, func(noerr bool) {
-				require.That(t, true, "this must be called")
-				require.That(t, noerr)
+				except.That(t, true, "this must be called")
+				except.That(t, noerr)
 				handlerCalled = noerr
 			})
 
 			defer err2.Handle(&err, func(err error) error {
-				require.That(t, false, "no error to handle!")
+				except.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
@@ -376,7 +376,7 @@ func TestPanickingCatchAll(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			defer func() {
-				require.That(
+				except.That(
 					t,
 					recover() == nil,
 					"panics should NOT carry on",
@@ -424,7 +424,7 @@ func TestPanickingCarryOn_Handle(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			defer func() {
-				require.That(
+				except.That(
 					t,
 					recover() != nil,
 					"panics should went thru when not our errors",
@@ -554,12 +554,12 @@ func TestPanicking_Handle(t *testing.T) {
 			defer func() {
 				r := recover()
 				if tt.wants == nil {
-					require.That(t, r != nil, "wants err, then panic")
+					except.That(t, r != nil, "wants err, then panic")
 				}
 			}()
 			err := tt.args.f()
 			if err != nil {
-				require.Equal(t, err.Error(), tt.wants.Error())
+				except.Equal(t, err.Error(), tt.wants.Error())
 			}
 		})
 	}
@@ -600,7 +600,7 @@ func TestPanicking_Catch(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			defer func() {
-				require.That(
+				except.That(
 					t,
 					recover() == nil,
 					"panics should NOT carry on",
@@ -623,7 +623,7 @@ func TestCatch_Error(t *testing.T) {
 func Test_TryOutError(t *testing.T) {
 	t.Parallel()
 	defer err2.Catch(func(err error) error {
-		require.Equal(t, err.Error(), "fails: test: this is an ERROR",
+		except.Equal(t, err.Error(), "fails: test: this is an ERROR",
 			"=> we should catch right error str here")
 		return err
 	})
@@ -633,7 +633,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
-	require.Equal(t, retVal, "test", "if no error happens, we get value")
+	except.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.
@@ -665,21 +665,21 @@ func TestCatch_Panic(t *testing.T) {
 func TestSetErrorTracer(t *testing.T) {
 	t.Parallel()
 	w := err2.ErrorTracer()
-	require.That(t, w == nil, "error tracer should be nil")
+	except.That(t, w == nil, "error tracer should be nil")
 	var w1 io.Writer
 	err2.SetErrorTracer(w1)
 	w = err2.ErrorTracer()
-	require.That(t, w == nil, "error tracer should be nil")
+	except.That(t, w == nil, "error tracer should be nil")
 }
 
 func TestSetErrRetTracer(t *testing.T) {
 	t.Parallel()
 	w := err2.ErrRetTracer()
-	require.That(t, w == nil, "error return tracer should be nil")
+	except.That(t, w == nil, "error return tracer should be nil")
 	var w1 io.Writer
 	err2.SetErrRetTracer(w1)
 	w = err2.ErrRetTracer()
-	require.That(t, w == nil, "error return tracer should be nil")
+	except.That(t, w == nil, "error return tracer should be nil")
 }
 
 func ExampleCatch_withFmt() {
diff --git a/internal/debug/debug_test.go b/internal/debug/debug_test.go
index e0a70b4..501458e 100644
--- a/internal/debug/debug_test.go
+++ b/internal/debug/debug_test.go
@@ -6,7 +6,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/lainio/err2/internal/require"
+	"github.com/lainio/err2/internal/except"
 )
 
 func TestFullName(t *testing.T) {
@@ -42,7 +42,7 @@ func TestFullName(t *testing.T) {
 		tt := ttv
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			require.Equal(t, tt.retval, tt.fullName())
+			except.Equal(t, tt.retval, tt.fullName())
 		})
 	}
 }
@@ -94,7 +94,7 @@ func TestIsAnchor(t *testing.T) {
 		tt := ttv
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			require.Equal(t, tt.retval, tt.isAnchor(tt.input))
+			except.Equal(t, tt.retval, tt.isAnchor(tt.input))
 		})
 	}
 }
@@ -140,7 +140,7 @@ func TestIsFuncAnchor(t *testing.T) {
 		tt := ttv
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			require.Equal(t, tt.retval, tt.isFuncAnchor(tt.input))
+			except.Equal(t, tt.retval, tt.isFuncAnchor(tt.input))
 		})
 	}
 }
@@ -161,7 +161,7 @@ func TestFnLNro(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			output := fnLNro(tt.input)
-			require.Equal(t, output, tt.output)
+			except.Equal(t, output, tt.output)
 		})
 	}
 }
@@ -212,7 +212,7 @@ func TestFnName(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			output := fnName(tt.input)
-			require.Equal(t, output, tt.output)
+			except.Equal(t, output, tt.output)
 		})
 	}
 }
@@ -239,7 +239,7 @@ func TestStackPrint_noLimits(t *testing.T) {
 				FuncName:    "",
 				Level:       0,
 			})
-			require.Equal(t, tt.input, w.String())
+			except.Equal(t, tt.input, w.String())
 		})
 	}
 }
@@ -267,8 +267,8 @@ func TestStackPrintForTest(t *testing.T) {
 			// print(tt.output)
 			// println("------")
 			// print(w.String())
-			require.Equal(t, a, b)
-			require.Equal(t, tt.output, w.String())
+			except.Equal(t, a, b)
+			except.Equal(t, tt.output, w.String())
 		})
 	}
 }
@@ -346,7 +346,7 @@ func TestCalcAnchor(t *testing.T) {
 			t.Parallel()
 			r := strings.NewReader(tt.input)
 			anchor := calcAnchor(r, tt.StackInfo)
-			require.Equal(t, tt.anchor, anchor)
+			except.Equal(t, tt.anchor, anchor)
 		})
 	}
 }
@@ -385,10 +385,10 @@ func TestStackPrint_limit(t *testing.T) {
 			stackPrint(readStack, writeStack, tt.StackInfo)
 			ins := strings.Split(tt.input, "\n")
 			outs := strings.Split(writeStack.String(), "\n")
-			require.Thatf(t, len(ins) > len(outs),
+			except.Thatf(t, len(ins) > len(outs),
 				"input length:%d should be greater:%d", len(ins), len(outs))
 			wantResult, gotResult := tt.output, writeStack.String()
-			require.Equal(t, gotResult, wantResult)
+			except.Equal(t, gotResult, wantResult)
 		})
 	}
 }
@@ -460,10 +460,10 @@ func TestStackPrint_OneFunction(t *testing.T) {
 			stackPrint(r, w, tt.StackInfo)
 			ins := strings.Split(tt.input, "\n")
 			outs := strings.Split(w.String(), "\n")
-			require.Thatf(t, len(ins) > len(outs),
+			except.Thatf(t, len(ins) > len(outs),
 				"input length:%d should be greater:%d", len(ins), len(outs))
 			b, a := tt.output, w.String()
-			require.Equal(t, a, b)
+			except.Equal(t, a, b)
 		})
 	}
 }
@@ -528,10 +528,10 @@ func TestFuncName(t *testing.T) {
 				FuncName:    tt.FuncName,
 				Level:       tt.Level,
 			})
-			require.That(t, found)
-			require.Equal(t, tt.output, name)
-			require.Equal(t, ln, tt.outln)
-			require.Equal(t, fr, tt.outFrame)
+			except.That(t, found)
+			except.Equal(t, tt.output, name)
+			except.Equal(t, ln, tt.outln)
+			except.Equal(t, fr, tt.outFrame)
 		})
 	}
 }
diff --git a/internal/require/test.go b/internal/except/except.go
similarity index 98%
rename from internal/require/test.go
rename to internal/except/except.go
index c1a87fa..932099f 100644
--- a/internal/require/test.go
+++ b/internal/except/except.go
@@ -1,4 +1,4 @@
-package require
+package except
 
 import (
 	"fmt"
diff --git a/internal/handler/handler_test.go b/internal/handler/handler_test.go
index dd72499..0e8476b 100644
--- a/internal/handler/handler_test.go
+++ b/internal/handler/handler_test.go
@@ -6,8 +6,8 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/lainio/err2/internal/except"
 	"github.com/lainio/err2/internal/handler"
-	"github.com/lainio/err2/internal/require"
 	"github.com/lainio/err2/internal/x"
 )
 
@@ -121,11 +121,11 @@ func TestProcess(t *testing.T) {
 			if handler.WorkToDo(tt.args.Any, tt.args.Err) {
 				handler.Process(&tt.args.Info)
 
-				require.Equal(t, panicHandlerCalled, tt.want.panicCalled)
-				require.Equal(t, errorHandlerCalled, tt.want.errorCalled)
-				require.Equal(t, nilHandlerCalled, tt.want.nilCalled)
+				except.Equal(t, panicHandlerCalled, tt.want.panicCalled)
+				except.Equal(t, errorHandlerCalled, tt.want.errorCalled)
+				except.Equal(t, nilHandlerCalled, tt.want.nilCalled)
 
-				require.Equal(t, myErrVal.Error(), tt.want.errStr)
+				except.Equal(t, myErrVal.Error(), tt.want.errStr)
 			}
 			resetCalled()
 		})
@@ -152,13 +152,13 @@ func TestPreProcess_debug(t *testing.T) {
 	// and that's what error stack tracing is all about
 	Handle()
 
-	require.ThatNot(t, panicHandlerCalled)
-	require.ThatNot(t, errorHandlerCalled)
-	require.ThatNot(t, nilHandlerCalled)
+	except.ThatNot(t, panicHandlerCalled)
+	except.ThatNot(t, errorHandlerCalled)
+	except.ThatNot(t, nilHandlerCalled)
 
 	// See the name of this test function. Decamel it + error
 	const want = "testing: t runner: error"
-	require.Equal(t, myErrVal.Error(), want)
+	except.Equal(t, myErrVal.Error(), want)
 
 	resetCalled()
 }
@@ -243,11 +243,11 @@ func TestPreProcess(t *testing.T) {
 
 				err = handler.PreProcess(&err, &tt.args.Info, tt.args.a)
 
-				require.Equal(t, panicHandlerCalled, tt.want.panicCalled)
-				require.Equal(t, errorHandlerCalled, tt.want.errorCalled)
-				require.Equal(t, nilHandlerCalled, tt.want.nilCalled)
+				except.Equal(t, panicHandlerCalled, tt.want.panicCalled)
+				except.Equal(t, errorHandlerCalled, tt.want.errorCalled)
+				except.Equal(t, nilHandlerCalled, tt.want.nilCalled)
 
-				require.Equal(t, err.Error(), tt.want.errStr)
+				except.Equal(t, err.Error(), tt.want.errStr)
 			}
 			resetCalled()
 		})
diff --git a/internal/handler/handlers_test.go b/internal/handler/handlers_test.go
index cd76762..a98586c 100644
--- a/internal/handler/handlers_test.go
+++ b/internal/handler/handlers_test.go
@@ -4,8 +4,8 @@ import (
 	"testing"
 
 	"github.com/lainio/err2"
+	"github.com/lainio/err2/internal/except"
 	"github.com/lainio/err2/internal/handler"
-	"github.com/lainio/err2/internal/require"
 )
 
 func TestHandlers(t *testing.T) {
@@ -93,17 +93,17 @@ func TestHandlers(t *testing.T) {
 			t.Parallel()
 			anys := tt.args.f
 
-			require.That(t, anys != nil, "cannot be nil")
+			except.That(t, anys != nil, "cannot be nil")
 			fns, dis := handler.ToErrorFns(anys)
-			require.That(t, fns != nil, "cannot be nil")
-			require.Equal(t, dis, tt.dis, "disabled wanted")
+			except.That(t, fns != nil, "cannot be nil")
+			except.Equal(t, dis, tt.dis, "disabled wanted")
 
 			errHandler := handler.Pipeline(fns)
 			err := errHandler(err2.ErrNotFound)
 			if err == nil {
-				require.That(t, tt.want == nil)
+				except.That(t, tt.want == nil)
 			} else {
-				require.Equal(t, err.Error(), tt.want.Error())
+				except.Equal(t, err.Error(), tt.want.Error())
 			}
 		})
 	}
diff --git a/internal/str/str_test.go b/internal/str/str_test.go
index 56da177..c013d0b 100644
--- a/internal/str/str_test.go
+++ b/internal/str/str_test.go
@@ -3,7 +3,7 @@ package str_test
 import (
 	"testing"
 
-	"github.com/lainio/err2/internal/require"
+	"github.com/lainio/err2/internal/except"
 	"github.com/lainio/err2/internal/str"
 )
 
@@ -49,7 +49,7 @@ func TestCamel(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			got := str.DecamelRegexp(tt.args.s)
-			require.Equal(t, got, tt.want)
+			except.Equal(t, got, tt.want)
 		})
 	}
 }
@@ -106,7 +106,7 @@ func TestDecamel(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			got := str.Decamel(tt.args.s)
-			require.Equal(t, got, tt.want)
+			except.Equal(t, got, tt.want)
 		})
 	}
 }
@@ -182,7 +182,7 @@ func TestDecamelRmTryPrefix(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			got := str.DecamelRmTryPrefix(tt.args.s)
-			require.Equal(t, got, tt.want)
+			except.Equal(t, got, tt.want)
 		})
 	}
 }
diff --git a/internal/x/x_test.go b/internal/x/x_test.go
index 1140013..b18fc78 100644
--- a/internal/x/x_test.go
+++ b/internal/x/x_test.go
@@ -4,7 +4,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/lainio/err2/internal/require"
+	"github.com/lainio/err2/internal/except"
 )
 
 var (
@@ -52,30 +52,30 @@ func TestSwap(t *testing.T) {
 		var (
 			lhs, rhs = 1, 2 // these are ints as default
 		)
-		require.Equal(t, lhs, 1)
-		require.Equal(t, rhs, 2)
+		except.Equal(t, lhs, 1)
+		except.Equal(t, rhs, 2)
 		Swap(&lhs, &rhs)
-		require.Equal(t, lhs, 2)
-		require.Equal(t, rhs, 1)
+		except.Equal(t, lhs, 2)
+		except.Equal(t, rhs, 1)
 	}
 	{
 		var (
 			lhs, rhs float64 = 1, 2
 		)
-		require.Equal(t, lhs, 1)
-		require.Equal(t, rhs, 2)
+		except.Equal(t, lhs, 1)
+		except.Equal(t, rhs, 2)
 		Swap(&lhs, &rhs)
-		require.Equal(t, lhs, 2)
-		require.Equal(t, rhs, 1)
+		except.Equal(t, lhs, 2)
+		except.Equal(t, rhs, 1)
 	}
 }
 
 func TestSReverse(t *testing.T) {
 	t.Parallel()
 	SReverse(lengths)
-	require.That(t, reflect.DeepEqual(lengths, reverseLengths))
+	except.That(t, reflect.DeepEqual(lengths, reverseLengths))
 	SReverse(lengths) // it's reverse now turn it to original
-	require.That(t, reflect.DeepEqual(lengths, original))
+	except.That(t, reflect.DeepEqual(lengths, original))
 }
 
 func BenchmarkSSReverse(b *testing.B) {
diff --git a/try/copy_test.go b/try/copy_test.go
index 7e50099..1498538 100644
--- a/try/copy_test.go
+++ b/try/copy_test.go
@@ -8,7 +8,7 @@ import (
 	"os"
 	"testing"
 
-	"github.com/lainio/err2/internal/require"
+	"github.com/lainio/err2/internal/except"
 	"github.com/lainio/err2/try"
 )
 
@@ -16,8 +16,8 @@ const dataFile = "./try.go"
 
 func Benchmark_CopyBufferMy(b *testing.B) {
 	all, err := os.ReadFile(dataFile)
-	require.Thatf(b, err == nil, "error: %v", err)
-	require.That(b, all != nil)
+	except.Thatf(b, err == nil, "error: %v", err)
+	except.That(b, all != nil)
 
 	buf := make([]byte, 4)
 	dst := bufio.NewWriter(bytes.NewBuffer(make([]byte, 0, len(all))))
@@ -29,8 +29,8 @@ func Benchmark_CopyBufferMy(b *testing.B) {
 
 func Benchmark_CopyBufferStd(b *testing.B) {
 	all, err := os.ReadFile(dataFile)
-	require.Thatf(b, err == nil, "error: %v", err)
-	require.That(b, all != nil)
+	except.Thatf(b, err == nil, "error: %v", err)
+	except.That(b, all != nil)
 
 	buf := make([]byte, 4)
 	dst := bufio.NewWriter(bytes.NewBuffer(make([]byte, 0, len(all))))
@@ -42,8 +42,8 @@ func Benchmark_CopyBufferStd(b *testing.B) {
 
 func Benchmark_CopyBufferOur(b *testing.B) {
 	all, err := os.ReadFile(dataFile)
-	require.Thatf(b, err == nil, "error: %v", err)
-	require.That(b, all != nil)
+	except.Thatf(b, err == nil, "error: %v", err)
+	except.That(b, all != nil)
 
 	tmp := make([]byte, 4)
 	dst := bufio.NewWriter(bytes.NewBuffer(make([]byte, 0, len(all))))
diff --git a/try/out_test.go b/try/out_test.go
index 60ea173..1ce0946 100644
--- a/try/out_test.go
+++ b/try/out_test.go
@@ -11,7 +11,7 @@ import (
 	"testing"
 
 	"github.com/lainio/err2"
-	"github.com/lainio/err2/internal/require"
+	"github.com/lainio/err2/internal/except"
 	"github.com/lainio/err2/try"
 )
 
@@ -102,8 +102,8 @@ func TestResult2_Logf(t *testing.T) {
 		return v1 + v2, v2
 	}
 	num1, num2 := countSomething("1", "bad")
-	require.Equal(t, num2, 2)
-	require.Equal(t, num1, 3)
+	except.Equal(t, num2, 2)
+	except.Equal(t, num1, 3)
 }
 
 func TestResult_Handle(t *testing.T) {
@@ -121,10 +121,10 @@ func TestResult_Handle(t *testing.T) {
 		return nil
 	}
 	err := callFn(1)
-	require.That(t, err == nil, "no error when Out.Handle sets it nil")
+	except.That(t, err == nil, "no error when Out.Handle sets it nil")
 
 	err = callFn(0)
-	require.That(t, err != nil, "want error when Out.Handle sets it the same")
+	except.That(t, err != nil, "want error when Out.Handle sets it the same")
 }
 
 func ExampleResult1_Handle() {