fix some code block intentions

Author: lainio

assert/assert.go

@@ -159,17 +159,17 @@ const (
 // be called at the beginning of every test. There is two way of doing it:
 //
 //	for _, tt := range tests {
-//		t.Run(tt.name, func(t *testing.T) { // Shorter way, litle magic
-//			defer assert.PushTester(t)() // <- IMPORTANT! NOTE! (t)()
-//			...
-//			assert.That(something, "test won't work")
-//		})
-//		t.Run(tt.name, func(t *testing.T) { // Longer, explicit way, 2 lines
-//			assert.PushTester(t) // <- IMPORTANT!
-//			defer assert.PopTester()
-//			...
-//			assert.That(something, "test won't work")
-//		})
+//	     t.Run(tt.name, func(t *testing.T) { // Shorter way, litle magic
+//	          defer assert.PushTester(t)() // <- IMPORTANT! NOTE! (t)()
+//	          ...
+//	          assert.That(something, "test won't work")
+//	     })
+//	     t.Run(tt.name, func(t *testing.T) { // Longer, explicit way, 2 lines
+//	          assert.PushTester(t) // <- IMPORTANT!
+//	          defer assert.PopTester()
+//	          ...
+//	          assert.That(something, "test won't work")
+//	     })
 //	}
 //
 // Because PushTester returns [PopTester] it allows us to merge these two calls
@@ -184,8 +184,8 @@ const (
 //	defer assert.PushTester(t)() // does the cleanup
 //	...
 //	go func() {
-//	   assert.PushTester(t) // left cleanup out! Leave it for the test, see ^
-//	   ...
+//	     assert.PushTester(t) // left cleanup out! Leave it for the test, see ^
+//	     ...
 //
 // Note that the second argument, if given, changes the default asserter for
 // whole package. The argument is mainly for temporary development use and isn't
@@ -209,12 +209,12 @@ func PushTester(t testing.TB, a ...defInd) function {
 // You have two ways to call [PopTester]. With defer right after [PushTester]:
 //
 //	for _, tt := range tests {
-//		t.Run(tt.name, func(t *testing.T) {
-//			assert.PushTester(t) // <- important!
-//			defer assert.PopTester() // <- for good girls and not so bad boys
-//			...
-//			assert.That(something, "test won't work")
-//		})
+//	     t.Run(tt.name, func(t *testing.T) {
+//	          assert.PushTester(t) // <- important!
+//	          defer assert.PopTester() // <- for good girls and not so bad boys
+//	          ...
+//	          assert.That(something, "test won't work")
+//	     })
 //	}
 //
 // If you want, you can combine [PushTester] and PopTester to one-liner:
@@ -853,7 +853,7 @@ func current() asserter {
 // and set asserter only one in TestMain, or in init.
 //
 //	func TestMain(m *testing.M) {
-//		SetDefault(assert.TestFull)
+//	     SetDefault(assert.TestFull)
 func SetDefault(i defInd) (old defInd) {
 	// pkg lvl lock to allow only one pkg client call this at one of the time
 	// together with the indexing, i.e we don't need to switch asserter

assert/doc.go

@@ -22,7 +22,7 @@ assertion line is written more from a runtime detection point of view, it catche
 all assert violations in the unit tests as well:
 
 	func (c Chain) Invite(...) {
-		assert.That(c.isLeaf(invitersKey), "only leaf can invite")
+	     assert.That(c.isLeaf(invitersKey), "only leaf can invite")
 
 If some assertion violation occurs in the deep call stack, they are still
 reported as a test failure. See the above code blocks. If assertion failure

err2.go

@@ -91,9 +91,9 @@ var Stdnull = &nullDev{}
 // a panic handler. See the second handler below:
 //
 //	defer err2.Handle(&err,
-//	   err2.Err( func(error) { os.Remove(dst) }), // err2.Err() keeps it short
-//	   // below handler catches panics, but you can re-throw if needed
-//	   func(p any) {}
+//	     err2.Err( func(error) { os.Remove(dst) }), // err2.Err() keeps it short
+//	     // below handler catches panics, but you can re-throw if needed
+//	     func(p any) {}
 //	)
 func Handle(err *error, a ...any) {
 	// This and others are similar but we need to call `recover` here because

handlers.go

@@ -14,7 +14,7 @@ import (
 // You can use it like this:
 //
 //	func main() {
-//		defer err2.Catch(err2.Stderr)
+//	     defer err2.Catch(err2.Stderr)
 func Stderr(err error) error {
 	if err == nil {
 		return nil
@@ -30,7 +30,7 @@ func Stderr(err error) error {
 // You can use it like this:
 //
 //	func main() {
-//		defer err2.Catch(err2.Stdout)
+//	     defer err2.Catch(err2.Stdout)
 func Stdout(err error) error {
 	if err == nil {
 		return nil
@@ -57,7 +57,7 @@ func Reset(error) error { return nil }
 // and don't want to use [SetLogTracer] and keep it to write to your logs.
 //
 //	defer err2.Catch(err2.Err(func(err error) {
-//		fmt.Println("ERROR:", err)
+//	     fmt.Println("ERROR:", err)
 //	}))
 //
 // Note that since Err helper we have other helpers like [Stdout] that allows
@@ -89,7 +89,7 @@ func Log(err error) error {
 // You can use it like this:
 //
 //	func myFunction() {
-//		defer err2.Handle(err2.Noop, err2.StderrNoReset)
+//	     defer err2.Handle(err2.Noop, err2.StderrNoReset)
 func StderrNoReset(err error) error {
 	if err == nil {
 		return nil
@@ -104,7 +104,7 @@ func StderrNoReset(err error) error {
 // You can use it like this:
 //
 //	func main() {
-//		defer err2.Catch(err2.StdoutNoReset)
+//	     defer err2.Catch(err2.StdoutNoReset)
 func StdoutNoReset(err error) error {
 	if err == nil {
 		return nil