test: cover ErrorFormatter direct path and single-char inverse flag

Brings codecov patch coverage to 100% for the changed lines:

- TestHandleExitCoder_ErrorFormatterDirect exercises the Fprintf
  branch in HandleExitCoder when an ExitCoder also implements
  ErrorFormatter and is passed in directly (the existing
  TestHandleExitCoder_ErrorFormatter routes through a multiError
  which goes down a different branch).
- TestBoolWithInverseFlagStringNoPanicWithNoTabStringer is split into
  multi-character and single-character sub-tests so the `-` vs `--`
  prefix branch is covered.

Signed-off-by: alliasgher <alliasgher123@gmail.com>

Author: alliasgher

errors_test.go

@@ -257,3 +257,23 @@ func TestHandleExitCoder_EmptyMessage(t *testing.T) {
 	assert.True(t, called)
 	assert.Empty(t, ErrWriter.(*bytes.Buffer).String(), "expected no output for empty-message exit")
 }
+
+// TestHandleExitCoder_ErrorFormatterDirect verifies the ErrorFormatter branch
+// (Fprintf path) is exercised when the ExitCoder is passed to HandleExitCoder
+// directly with a non-empty message. Distinct from
+// TestHandleExitCoder_ErrorFormatter above which routes through a multiError.
+func TestHandleExitCoder_ErrorFormatterDirect(t *testing.T) {
+	called := false
+	OsExiter = func(rc int) { called = true }
+	ErrWriter = &bytes.Buffer{}
+
+	defer func() {
+		OsExiter = fakeOsExiter
+		ErrWriter = fakeErrWriter
+	}()
+
+	HandleExitCoder(&exitFormatter{code: 7})
+
+	assert.True(t, called)
+	assert.Contains(t, ErrWriter.(*bytes.Buffer).String(), "some other special")
+}

flag_bool_with_inverse_test.go

@@ -533,13 +533,19 @@ func TestBoolWithInverseFlagStringNoPanicWithNoTabStringer(t *testing.T) {
 		return "no tab here"
 	}
 
-	flag := &BoolWithInverseFlag{
-		Name: "verbose",
-	}
+	t.Run("multi-character name uses -- prefix", func(t *testing.T) {
+		flag := &BoolWithInverseFlag{Name: "verbose"}
+		got := flag.String() // must not panic
+		if !strings.Contains(got, "--[no-]verbose") {
+			t.Errorf("expected String() to contain --[no-]verbose, got %q", got)
+		}
+	})
 
-	// Must not panic.
-	got := flag.String()
-	if !strings.Contains(got, "verbose") {
-		t.Errorf("expected String() to contain the flag name, got %q", got)
-	}
+	t.Run("single-character name uses - prefix", func(t *testing.T) {
+		flag := &BoolWithInverseFlag{Name: "v"}
+		got := flag.String() // must not panic
+		if !strings.Contains(got, "-[no-]v") {
+			t.Errorf("expected String() to contain -[no-]v, got %q", got)
+		}
+	})
 }