tools/syz-linter: check t.Logf/Errorf/Fatalf messages

Fix checking of Logf, it has string in 0-th arg.
Add checking of t.Errorf/Fatalf.

41 files changed, 100 insertions, 89 deletions

diff --git a/dashboard/app/access_test.go b/dashboard/app/access_test.go
index 8652fca87..208d79a29 100644
--- a/dashboard/app/access_test.go
+++ b/dashboard/app/access_test.go
@@ -373,7 +373,7 @@ func TestAccess(t *testing.T) {
 				continue
 			}
 			if bytes.Contains(reply, []byte(ent.ref)) {
-				t.Errorf("request %v at level %v contains ref %v at level %v:\n%s\n\n",
+				t.Errorf("request %v at level %v contains ref %v at level %v:\n%s",
 					url, requestLevel, ent.ref, ent.level, reply)
 			}
 		}
diff --git a/dashboard/app/api_test.go b/dashboard/app/api_test.go
index 4a872231e..6897848cf 100644
--- a/dashboard/app/api_test.go
+++ b/dashboard/app/api_test.go
@@ -17,7 +17,7 @@ func TestClientSecretOK(t *testing.T) {
 		},
 	}, "user", "secr1t", "")
 	if err != nil || got != "" {
-		t.Errorf("Unexpected error %v %v", got, err)
+		t.Errorf("unexpected error %v %v", got, err)
 	}
 }
 
@@ -28,7 +28,7 @@ func TestClientOauthOK(t *testing.T) {
 		},
 	}, "user", "", "OauthSubject:public")
 	if err != nil || got != "" {
-		t.Errorf("Unexpected error %v %v", got, err)
+		t.Errorf("unexpected error %v %v", got, err)
 	}
 }
 
@@ -39,7 +39,7 @@ func TestClientSecretFail(t *testing.T) {
 		},
 	}, "user", "wrong", "")
 	if err != ErrAccess || got != "" {
-		t.Errorf("Unexpected error %v %v", got, err)
+		t.Errorf("unexpected error %v %v", got, err)
 	}
 }
 
@@ -48,7 +48,7 @@ func TestClientSecretMissing(t *testing.T) {
 		Clients: map[string]string{},
 	}, "user", "ignored", "")
 	if err != ErrAccess || got != "" {
-		t.Errorf("Unexpected error %v %v", got, err)
+		t.Errorf("unexpected error %v %v", got, err)
 	}
 }
 
@@ -63,7 +63,7 @@ func TestClientNamespaceOK(t *testing.T) {
 		},
 	}, "user", "secr1t", "")
 	if err != nil || got != "ns1" {
-		t.Errorf("Unexpected error %v %v", got, err)
+		t.Errorf("unexpected error %v %v", got, err)
 	}
 }
 
diff --git a/dashboard/app/app_test.go b/dashboard/app/app_test.go
index 4e8e4efde..99da350aa 100644
--- a/dashboard/app/app_test.go
+++ b/dashboard/app/app_test.go
@@ -947,7 +947,7 @@ func TestPurgeOldCrashes(t *testing.T) {
 
 	// A sanity check for the test itself.
 	if !firstCrashExists() {
-		t.Fatalf("The first reported crash should be present")
+		t.Fatalf("the first reported crash should be present")
 	}
 
 	// Unreport the first crash.
@@ -970,7 +970,7 @@ func TestPurgeOldCrashes(t *testing.T) {
 	}
 	// Check that the unreported crash was purged.
 	if firstCrashExists() {
-		t.Fatalf("The unreported crash should have been purged.")
+		t.Fatalf("the unreported crash should have been purged")
 	}
 }
 
diff --git a/dashboard/app/reporting_test.go b/dashboard/app/reporting_test.go
index c0d419418..7515cd810 100644
--- a/dashboard/app/reporting_test.go
+++ b/dashboard/app/reporting_test.go
@@ -968,10 +968,10 @@ func TestUpdateBugReporting(t *testing.T) {
 		setIDs(bug, test.After)
 		hasError := bug.updateReportings(c.ctx, cfg, now) != nil
 		if hasError != test.Error {
-			t.Errorf("Before: %#v, Expected error: %v, Got error: %v", test.Before, test.Error, hasError)
+			t.Errorf("before: %#v, expected error: %v, got error: %v", test.Before, test.Error, hasError)
 		}
 		if !test.Error && !reflect.DeepEqual(bug.Reporting, test.After) {
-			t.Errorf("Before: %#v, Expected After: %#v, Got After: %#v", test.Before, test.After, bug.Reporting)
+			t.Errorf("before: %#v, expected after: %#v, got after: %#v", test.Before, test.After, bug.Reporting)
 		}
 	}
 }
diff --git a/dashboard/app/repro_test.go b/dashboard/app/repro_test.go
index 8c587324e..db37046d6 100644
--- a/dashboard/app/repro_test.go
+++ b/dashboard/app/repro_test.go
@@ -337,7 +337,7 @@ func TestNeedReproIsolated(t *testing.T) {
 		}
 		funcResult := needReproForBug(c.ctx, bug)
 		if funcResult != test.needRepro {
-			t.Errorf("For %#v expected needRepro=%v, got needRepro=%v",
+			t.Errorf("for %#v expected needRepro=%v, got needRepro=%v",
 				bug, test.needRepro, funcResult)
 		}
 	}
diff --git a/executor/style_test.go b/executor/style_test.go
index 501b58fea..e41674d1c 100644
--- a/executor/style_test.go
+++ b/executor/style_test.go
@@ -190,7 +190,7 @@ if (foo) {
 				}
 
 				line := bytes.Count(data[:start], []byte{'\n'}) + 1
-				t.Errorf("\nexecutor/%v:%v: %v\n%s\n", file, line, check.message, data[start:end])
+				t.Errorf("\nexecutor/%v:%v: %v\n%s", file, line, check.message, data[start:end])
 			}
 		}
 	}
diff --git a/pkg/asset/storage_test.go b/pkg/asset/storage_test.go
index dcafdacf4..7500e9db3 100644
--- a/pkg/asset/storage_test.go
+++ b/pkg/asset/storage_test.go
@@ -184,14 +184,14 @@ func TestUploadBuildAsset(t *testing.T) {
 	be.objectRemove = func(string) error { return fmt.Errorf("not now") }
 	err = storage.DeprecateAssets()
 	if err == nil {
-		t.Fatalf("DeprecateAssets() should have failed")
+		t.Fatalf("DeprecateAssets should have failed")
 	}
 
 	// Let the deletion be successful.
 	be.objectRemove = nil
 	err = storage.DeprecateAssets()
 	if err != nil {
-		t.Fatalf("DeprecateAssets() was expected to be successful, got %s", err)
+		t.Fatalf("DeprecateAssets was expected to be successful, got %s", err)
 	}
 	path, err := be.getPath(allUrls[2])
 	if err != nil {
@@ -199,14 +199,14 @@ func TestUploadBuildAsset(t *testing.T) {
 	}
 	err = be.hasOnly([]string{path})
 	if err != nil {
-		t.Fatalf("after first DeprecateAssets(): %s", err)
+		t.Fatalf("after first DeprecateAssets: %s", err)
 	}
 
 	// Delete the rest.
 	dashMock.downloadURLs = map[string]bool{}
 	err = storage.DeprecateAssets()
 	if err != nil || len(be.objects) != 0 {
-		t.Fatalf("second DeprecateAssets() failed: %s, len %d",
+		t.Fatalf("second DeprecateAssets failed: %s, len %d",
 			err, len(be.objects))
 	}
 }
@@ -365,7 +365,7 @@ func TestTwoBucketDeprecation(t *testing.T) {
 		url: true,
 	}
 	dummy.objectRemove = func(url string) error {
-		t.Fatalf("Unexpected removal")
+		t.Fatalf("unexpected removal")
 		return nil
 	}
 	err := storage.DeprecateAssets()
@@ -389,7 +389,7 @@ func TestInvalidAssetURLs(t *testing.T) {
 		url: true,
 	}
 	dummy.objectRemove = func(url string) error {
-		t.Fatalf("Unexpected removal")
+		t.Fatalf("unexpected removal")
 		return nil
 	}
 	err := storage.DeprecateAssets()
diff --git a/pkg/ast/parser_test.go b/pkg/ast/parser_test.go
index 5e25157f5..bc66ed4be 100644
--- a/pkg/ast/parser_test.go
+++ b/pkg/ast/parser_test.go
@@ -76,7 +76,7 @@ func TestParseAll(t *testing.T) {
 			desc4 := desc.Filter(func(n Node) bool { return true })
 			desc5 := desc.Filter(func(n Node) bool { return false })
 			if len(desc4.Nodes) != len(desc.Nodes) || len(desc5.Nodes) != 0 {
-				t.Fatalf("Filter is broken: desc=%v desc4=%v desc5=%v",
+				t.Fatalf("filter is broken: desc=%v desc4=%v desc5=%v",
 					len(desc.Nodes), len(desc4.Nodes), len(desc5.Nodes))
 			}
 		})
diff --git a/pkg/auth/auth_test.go b/pkg/auth/auth_test.go
index d343e0f33..1c317fe15 100644
--- a/pkg/auth/auth_test.go
+++ b/pkg/auth/auth_test.go
@@ -21,7 +21,7 @@ func reponseFor(t *testing.T, claims jwtClaims) (*httptest.Server, Endpoint) {
 			Expiration: fmt.Sprint(claims.Expiration.Unix()),
 		})
 		if err != nil {
-			t.Fatalf("Marshal %v", err)
+			t.Fatalf("marshal %v", err)
 		}
 		w.Header()["Content-Type"] = []string{"application/json"}
 		w.Write(bytes)
@@ -41,10 +41,10 @@ func TestBearerValid(t *testing.T) {
 
 	got, err := dut.DetermineAuthSubj(tm, []string{"Bearer x"})
 	if err != nil {
-		t.Errorf("Unexpected error %v", err)
+		t.Errorf("inexpected error %v", err)
 	}
 	if !strings.HasSuffix(got, magic) {
-		t.Errorf("Wrong subj %v not suffix of %v", magic, got)
+		t.Errorf("wrong subj %v not suffix of %v", magic, got)
 	}
 }
 
@@ -59,7 +59,7 @@ func TestBearerWrongAudience(t *testing.T) {
 
 	_, err := dut.DetermineAuthSubj(tm, []string{"Bearer x"})
 	if !strings.HasPrefix(err.Error(), "unexpected audience") {
-		t.Fatalf("Unexpected error %v", err)
+		t.Fatalf("unexpected error %v", err)
 	}
 }
 
@@ -74,7 +74,7 @@ func TestBearerExpired(t *testing.T) {
 
 	_, err := dut.DetermineAuthSubj(tm, []string{"Bearer x"})
 	if !strings.HasPrefix(err.Error(), "token past expiration") {
-		t.Fatalf("Unexpected error %v", err)
+		t.Fatalf("unexpected error %v", err)
 	}
 }
 
@@ -83,7 +83,7 @@ func TestMissingHeader(t *testing.T) {
 	defer ts.Close()
 	got, err := dut.DetermineAuthSubj(time.Now(), []string{})
 	if err != nil || got != "" {
-		t.Errorf("Unexpected error %v %v", got, err)
+		t.Errorf("unexpected error %v %v", got, err)
 	}
 }
 
@@ -92,7 +92,7 @@ func TestBadHeader(t *testing.T) {
 	defer ts.Close()
 	got, err := dut.DetermineAuthSubj(time.Now(), []string{"bad"})
 	if err != nil || got != "" {
-		t.Errorf("Unexpected error %v %v", got, err)
+		t.Errorf("unexpected error %v %v", got, err)
 	}
 }
 
@@ -104,6 +104,6 @@ func TestBadHttpStatus(t *testing.T) {
 	dut := MakeEndpoint(ts.URL)
 	got, err := dut.DetermineAuthSubj(time.Now(), []string{"Bearer x"})
 	if err == nil || !strings.HasSuffix(err.Error(), "400") || got != "" {
-		t.Errorf("Unexpected error %v %v", got, err)
+		t.Errorf("unexpected error %v %v", got, err)
 	}
 }
diff --git a/pkg/build/linux_test.go b/pkg/build/linux_test.go
index 31fbdceaa..91d344531 100644
--- a/pkg/build/linux_test.go
+++ b/pkg/build/linux_test.go
@@ -38,7 +38,7 @@ func TestQueryLinuxCompiler(t *testing.T) {
 	const badDir = "./testingData/non_existing_folder"
 	_, err = queryLinuxCompiler(badDir)
 	if err == nil {
-		t.Fatalf("Expected an error, got none")
+		t.Fatalf("expected an error, got none")
 	}
 }
 
diff --git a/pkg/compiler/compiler_test.go b/pkg/compiler/compiler_test.go
index dbb4d6582..0a2396b5b 100644
--- a/pkg/compiler/compiler_test.go
+++ b/pkg/compiler/compiler_test.go
@@ -281,16 +281,16 @@ func TestCollectUnused(t *testing.T) {
 	for i, input := range inputs {
 		desc := ast.Parse([]byte(input.text), "input", nil)
 		if desc == nil {
-			t.Fatalf("Test %d: failed to parse", i)
+			t.Fatalf("test %d: failed to parse", i)
 		}
 
 		nodes, err := CollectUnused(desc, targets.List[targets.TestOS][targets.TestArch64], nil)
 		if err != nil {
-			t.Fatalf("Test %d: CollectUnused failed: %v", i, err)
+			t.Fatalf("test %d: CollectUnused failed: %v", i, err)
 		}
 
 		if len(input.names) != len(nodes) {
-			t.Errorf("Test %d: want %d nodes, got %d", i, len(input.names), len(nodes))
+			t.Errorf("test %d: want %d nodes, got %d", i, len(input.names), len(nodes))
 		}
 
 		names := make([]string, len(nodes))
@@ -302,7 +302,7 @@ func TestCollectUnused(t *testing.T) {
 		sort.Strings(input.names)
 
 		if !reflect.DeepEqual(names, input.names) {
-			t.Errorf("Test %d: Unused nodes differ. Want %v, Got %v", i, input.names, names)
+			t.Errorf("test %d: Unused nodes differ. Want %v, Got %v", i, input.names, names)
 		}
 	}
 }
diff --git a/pkg/cover/backend/dwarf_test.go b/pkg/cover/backend/dwarf_test.go
index 9d4da8e90..d95c1ec01 100644
--- a/pkg/cover/backend/dwarf_test.go
+++ b/pkg/cover/backend/dwarf_test.go
@@ -27,12 +27,12 @@ func TestIsKcovBrokenInCompiler(t *testing.T) {
 	}
 	for _, ver := range inputDataTrue {
 		if !isKcovBrokenInCompiler(ver) {
-			t.Fatalf("isKcovBrokenInCompiler(%q) unexpectedly returned false\n", ver)
+			t.Fatalf("isKcovBrokenInCompiler(%q) unexpectedly returned false", ver)
 		}
 	}
 	for _, ver := range inputDataFalse {
 		if isKcovBrokenInCompiler(ver) {
-			t.Fatalf("isKcovBrokenInCompiler(%q) unexpectedly returned true\n", ver)
+			t.Fatalf("isKcovBrokenInCompiler(%q) unexpectedly returned true", ver)
 		}
 	}
 }
@@ -94,7 +94,7 @@ func TestCleanPathAndroid(t *testing.T) {
 			path, epath, ename := files[0], files[1], files[2]
 			rpath, rname := cleanPathAndroid(path, test.SrcDir, test.Delimiters, test.FnExists)
 			if (rpath != epath) || (rname != ename) {
-				t.Fatalf("cleanPathAndroid(`%s`, `%s`, %v, ...) unexpectedly returned (`%s`, `%s`) instead of (`%s`, `%s`)\n",
+				t.Fatalf("cleanPathAndroid(`%s`, `%s`, %v, ...) unexpectedly returned (`%s`, `%s`) instead of (`%s`, `%s`)",
 					path, test.SrcDir, test.Delimiters, rpath, rname, epath, ename)
 			}
 		}
@@ -113,7 +113,7 @@ func runNextCallTarget(t *testing.T, arg NextCallTargetTest) {
 	i := 0
 	target, pc := nextCallTarget(arg.Arch, arg.Text, arg.Data, &i)
 	if target != arg.ExpTarget || pc != arg.ExpPC {
-		t.Fatalf("nextCallTarget(`%v`, %x, %v) unexpectedly returned (%x, %x) instead of (%x, %x)\n",
+		t.Fatalf("nextCallTarget(`%v`, %x, %v) unexpectedly returned (%x, %x) instead of (%x, %x)",
 			arg.Arch, arg.Text, arg.Data, target, pc, arg.ExpTarget, arg.ExpPC)
 	}
 }
diff --git a/pkg/cover/cover_test.go b/pkg/cover/cover_test.go
index 2124fb3c8..d5f214ff5 100644
--- a/pkg/cover/cover_test.go
+++ b/pkg/cover/cover_test.go
@@ -51,7 +51,7 @@ func TestMergeDiff(t *testing.T) {
 			cov.Merge(test.init)
 			diff := cov.MergeDiff(test.merge)
 			if res := cmp.Diff(test.diff, diff); res != "" {
-				t.Fatalf("MergeDiff result is wrong: %v", res)
+				t.Fatalf("result is wrong: %v", res)
 			}
 			result := cov.Serialize()
 			sort.Slice(result, func(i, j int) bool {
diff --git a/pkg/csource/csource_test.go b/pkg/csource/csource_test.go
index 957d2ebc9..8b4d83296 100644
--- a/pkg/csource/csource_test.go
+++ b/pkg/csource/csource_test.go
@@ -139,7 +139,7 @@ func testOne(t *testing.T, p *prog.Prog, opts Options) {
 		if atomic.AddUint32(&failedTests, 1) > maxFailures {
 			t.Fatal()
 		}
-		t.Logf("opts: %+v\nprogram:\n%s\n", opts, p.Serialize())
+		t.Logf("opts: %+v\nprogram:\n%s", opts, p.Serialize())
 		t.Fatalf("%v", err)
 	}
 	bin, err := Build(p.Target, src)
@@ -147,7 +147,7 @@ func testOne(t *testing.T, p *prog.Prog, opts Options) {
 		if atomic.AddUint32(&failedTests, 1) > maxFailures {
 			t.Fatal()
 		}
-		t.Logf("opts: %+v\nprogram:\n%s\n", opts, p.Serialize())
+		t.Logf("opts: %+v\nprogram:\n%s", opts, p.Serialize())
 		t.Fatalf("%v", err)
 	}
 	defer os.Remove(bin)
diff --git a/pkg/email/lore/parse_test.go b/pkg/email/lore/parse_test.go
index 13370045c..8349859ec 100644
--- a/pkg/email/lore/parse_test.go
+++ b/pkg/email/lore/parse_test.go
@@ -238,7 +238,7 @@ Bug report`,
 	}
 
 	if len(threads) > len(expected) {
-		t.Fatalf("Expected %d threads, got %d", len(expected), len(threads))
+		t.Fatalf("expected %d threads, got %d", len(expected), len(threads))
 	}
 }
 
diff --git a/pkg/ipc/ipc_priv_test.go b/pkg/ipc/ipc_priv_test.go
index be164911a..054916045 100644
--- a/pkg/ipc/ipc_priv_test.go
+++ b/pkg/ipc/ipc_priv_test.go
@@ -20,6 +20,6 @@ func TestOutputDeadline(t *testing.T) {
 	c.wait()
 	out := <-c.readDone
 	if string(out) != "done\n" {
-		t.Errorf("Unexpected output: '%s'", out)
+		t.Errorf("unexpected output: '%s'", out)
 	}
 }
diff --git a/pkg/ipc/ipc_test.go b/pkg/ipc/ipc_test.go
index 859e14948..ffb28d0a6 100644
--- a/pkg/ipc/ipc_test.go
+++ b/pkg/ipc/ipc_test.go
@@ -94,7 +94,7 @@ func TestExecute(t *testing.T) {
 
 	flags := []ExecFlags{0, FlagThreaded}
 	for _, flag := range flags {
-		t.Logf("testing flags 0x%x\n", flag)
+		t.Logf("testing flags 0x%x", flag)
 		cfg := &Config{
 			Executor:      bin,
 			UseShmem:      useShmem,
diff --git a/pkg/report/decompile_test.go b/pkg/report/decompile_test.go
index c89b88681..7e05561af 100644
--- a/pkg/report/decompile_test.go
+++ b/pkg/report/decompile_test.go
@@ -52,6 +52,6 @@ Disassembly of section .data:
 		},
 	}
 	if !reflect.DeepEqual(opcodes, expected) {
-		t.Errorf("Expected: %#v, got: %#v", expected, opcodes)
+		t.Errorf("expected: %#v, got: %#v", expected, opcodes)
 	}
 }
diff --git a/pkg/report/linux_test.go b/pkg/report/linux_test.go
index 5f27b9e7d..258efb271 100644
--- a/pkg/report/linux_test.go
+++ b/pkg/report/linux_test.go
@@ -248,7 +248,7 @@ func prepareLinuxReporter(t *testing.T, arch string) (*Reporter, *linux) {
 	}
 	reporter, err := NewReporter(cfg)
 	if err != nil {
-		t.Errorf("Failed to create a reporter instance for %#v: %v", arch, err)
+		t.Errorf("failed to create a reporter instance for %#v: %v", arch, err)
 	}
 	return reporter, reporter.impl.(*linux)
 }
@@ -369,11 +369,11 @@ func TestParseLinuxOpcodes(t *testing.T) {
 			_, linuxReporter := prepareLinuxReporter(t, test.arch)
 			ret, err := linuxReporter.parseOpcodes(test.input)
 			if test.output == nil && err == nil {
-				t.Errorf("Expected an error on input %#v", test)
+				t.Errorf("expected an error on input %#v", test)
 			} else if test.output != nil && err != nil {
-				t.Errorf("Unexpected error %v on input %#v", err, test.input)
+				t.Errorf("unexpected error %v on input %#v", err, test.input)
 			} else if test.output != nil && !reflect.DeepEqual(ret, *test.output) {
-				t.Errorf("Expected: %#v, got: %#v", test.output, ret)
+				t.Errorf("expected: %#v, got: %#v", test.output, ret)
 			}
 		})
 	}
@@ -441,6 +441,6 @@ func testDisassembly(t *testing.T, reporter *Reporter, linuxReporter *linux, tes
 	}
 
 	if !bytes.Equal(output, result) {
-		t.Fatalf("Expected:\n%s\nGot:\n%s\n", output, result)
+		t.Fatalf("expected:\n%s\ngot:\n%s", output, result)
 	}
 }
diff --git a/pkg/report/report_test.go b/pkg/report/report_test.go
index 934d4552e..9671607ec 100644
--- a/pkg/report/report_test.go
+++ b/pkg/report/report_test.go
@@ -148,10 +148,10 @@ func testParseImpl(t *testing.T, reporter *Reporter, test *ParseTest) {
 	containsCrash := reporter.ContainsCrash(test.Log)
 	expectCrash := (test.Title != "")
 	if expectCrash && !containsCrash {
-		t.Fatalf("ContainsCrash did not find crash")
+		t.Fatalf("did not find crash")
 	}
 	if !expectCrash && containsCrash {
-		t.Fatalf("ContainsCrash found unexpected crash")
+		t.Fatalf("found unexpected crash")
 	}
 	if rep != nil && rep.Title == "" {
 		t.Fatalf("found crash, but title is empty")
@@ -185,7 +185,7 @@ func testParseImpl(t *testing.T, reporter *Reporter, test *ParseTest) {
 			wantAltTitles += "ALT: " + t + "\n"
 		}
 		t.Fatalf("want:\nTITLE: %s\n%sTYPE: %v\nFRAME: %v\nCORRUPTED: %v\nSUPPRESSED: %v\n"+
-			"got:\nTITLE: %s\n%sTYPE: %v\nFRAME: %v\nCORRUPTED: %v (%v)\nSUPPRESSED: %v\n",
+			"got:\nTITLE: %s\n%sTYPE: %v\nFRAME: %v\nCORRUPTED: %v (%v)\nSUPPRESSED: %v",
 			test.Title, wantAltTitles, test.Type, test.Frame, test.Corrupted, test.Suppressed,
 			title, gotAltTitles, typ, frame, corrupted, corruptedReason, suppressed)
 	}
@@ -206,13 +206,13 @@ func checkReport(t *testing.T, reporter *Reporter, rep *Report, test *ParseTest)
 		t.Fatalf("bad Output:\n%s", rep.Output)
 	}
 	if rep.StartPos != 0 && rep.EndPos != 0 && rep.StartPos >= rep.EndPos {
-		t.Fatalf("StartPos=%v >= EndPos=%v", rep.StartPos, rep.EndPos)
+		t.Fatalf("StartPos %v >= EndPos %v", rep.StartPos, rep.EndPos)
 	}
 	if rep.EndPos > len(rep.Output) {
-		t.Fatalf("EndPos=%v > len(Output)=%v", rep.EndPos, len(rep.Output))
+		t.Fatalf("EndPos %v > len(Output) %v", rep.EndPos, len(rep.Output))
 	}
 	if rep.SkipPos <= rep.StartPos || rep.SkipPos > rep.EndPos {
-		t.Fatalf("bad SkipPos=%v: StartPos=%v EndPos=%v", rep.SkipPos, rep.StartPos, rep.EndPos)
+		t.Fatalf("bad SkipPos %v: StartPos %v EndPos %v", rep.SkipPos, rep.StartPos, rep.EndPos)
 	}
 	if test.StartLine != "" {
 		if test.EndLine == "" {
diff --git a/pkg/symbolizer/symbolizer_test.go b/pkg/symbolizer/symbolizer_test.go
index d7e996bb0..f6445367e 100644
--- a/pkg/symbolizer/symbolizer_test.go
+++ b/pkg/symbolizer/symbolizer_test.go
@@ -159,7 +159,7 @@ func TestParse(t *testing.T) {
 			t.Fatalf("got error: %v", err)
 		}
 		if !reflect.DeepEqual(addr.frames, frames) {
-			t.Fatalf("want frames:\n%+v\ngot:\n%+v\n", addr.frames, frames)
+			t.Fatalf("want frames:\n%+v\ngot:\n%+v", addr.frames, frames)
 		}
 		allPCs = append(allPCs, addr.pc)
 		allFrames = append(allFrames, frames...)
@@ -177,7 +177,7 @@ func TestParse(t *testing.T) {
 		}
 		frames = append(frames, frames2...)
 		if !reflect.DeepEqual(allFrames, frames) {
-			t.Fatalf("want frames:\n%+v\ngot:\n%+v\n", allFrames, frames)
+			t.Fatalf("want frames:\n%+v\ngot:\n%+v", allFrames, frames)
 		}
 	}
 
diff --git a/pkg/vcs/vcs_test.go b/pkg/vcs/vcs_test.go
index aeccb3149..01e1fe7f5 100644
--- a/pkg/vcs/vcs_test.go
+++ b/pkg/vcs/vcs_test.go
@@ -226,7 +226,7 @@ func TestFileLink(t *testing.T) {
 	for _, test := range tests {
 		link := FileLink(test.URL, test.Hash, test.File, test.Line)
 		if link != test.FileLink {
-			t.Errorf("Test: %+v\ngot:  %v", test, link)
+			t.Errorf("test: %+v\ngot:  %v", test, link)
 		}
 	}
 }
diff --git a/prog/alloc_test.go b/prog/alloc_test.go
index c1d0317a5..24fef233d 100644
--- a/prog/alloc_test.go
+++ b/prog/alloc_test.go
@@ -92,6 +92,6 @@ func TestVmaAlloc(t *testing.T) {
 	for i := 0; i < 30; i++ {
 		size := r.rand(4) + 1
 		page := va.alloc(r, size)
-		t.Logf("alloc(%v) = %3v-%3v\n", size, page, page+size)
+		t.Logf("alloc(%v) = %3v-%3v", size, page, page+size)
 	}
 }
diff --git a/prog/collide_test.go b/prog/collide_test.go
index 0e29777a7..54ac156ab 100644
--- a/prog/collide_test.go
+++ b/prog/collide_test.go
@@ -73,7 +73,7 @@ r4 = dup(r3)
 		for i := 0; i < iters; i++ {
 			collided := AssignRandomAsync(p, r)
 			if !test.check(collided) {
-				t.Fatalf("bad async assignment:\n%s\n", collided.Serialize())
+				t.Fatalf("bad async assignment:\n%s", collided.Serialize())
 			}
 			for _, call := range collided.Calls {
 				anyAsync = anyAsync || call.Props.Async
@@ -143,7 +143,7 @@ dup(r3)
 				}
 				serialized := string(woProps.Serialize())
 				if serialized != test.duplicated {
-					t.Fatalf("expected:%s\ngot:%s\n", test.duplicated, serialized)
+					t.Fatalf("expected:%s\ngot:%s", test.duplicated, serialized)
 				}
 			}
 			// TODO: also test the `async` assignment.
diff --git a/prog/encoding_test.go b/prog/encoding_test.go
index bf4f708d1..608f94371 100644
--- a/prog/encoding_test.go
+++ b/prog/encoding_test.go
@@ -432,8 +432,8 @@ func testSerializeDeserialize(t *testing.T, p0 *Prog) ([]byte, []byte, bool) {
 		t.Fatal(err)
 	}
 	if !bytes.Equal(data0, data1) {
-		t.Logf("PROG0:\n%s\n", p0.Serialize())
-		t.Logf("PROG1:\n%s\n", p1.Serialize())
+		t.Logf("PROG0:\n%s", p0.Serialize())
+		t.Logf("PROG1:\n%s", p1.Serialize())
 		return data0, data1, false
 	}
 	return nil, nil, true
diff --git a/prog/expr_test.go b/prog/expr_test.go
index adff50c6a..8188436e1 100644
--- a/prog/expr_test.go
+++ b/prog/expr_test.go
@@ -36,7 +36,7 @@ func TestGenerateConditionalFields(t *testing.T) {
 	for _, first := range []int{0, 1} {
 		for _, second := range []int{0, 1} {
 			if !combinations[first][second] {
-				t.Fatalf("Did not generate a combination f1=%v f2=%v", first, second)
+				t.Fatalf("did not generate a combination f1=%v f2=%v", first, second)
 			}
 		}
 	}
diff --git a/prog/heatmap_test.go b/prog/heatmap_test.go
index 585bc095c..62a0c45e5 100644
--- a/prog/heatmap_test.go
+++ b/prog/heatmap_test.go
@@ -64,7 +64,7 @@ func TestGenericHeatmap(t *testing.T) {
 				index := hm.ChooseLocation()
 				if !checkIndex(index, len(data), test.regions) {
 					hm.debugPrint(t, data, test.regions)
-					t.Fatalf("selected index %d does not fall in a region\n", index)
+					t.Fatalf("selected index %d does not fall in a region", index)
 				}
 			}
 		}
@@ -100,7 +100,7 @@ func (hm *GenericHeatmap) debugPrint(t *testing.T, data []byte, regions []region
 		}
 		t.Logf("%8d: %x", j*granularity, data[j:end])
 	}
-	t.Logf("\n")
+	t.Log("\n")
 
 	// Print selected regions in data.
 	sort.Slice(regions, func(i, j int) bool {
@@ -109,12 +109,12 @@ func (hm *GenericHeatmap) debugPrint(t *testing.T, data []byte, regions []region
 	for j, region := range regions {
 		t.Logf("region  %4d: %8v - %8v", j, region.start, region.end)
 	}
-	t.Logf("\n")
+	t.Log("\n")
 
 	// Print heatmap.
 	t.Logf("generic heatmap (total segment length %d)", hm.length)
 	for j, seg := range hm.segments {
 		t.Logf("segment %4d: %8v - %8v", j, seg.offset, seg.offset+seg.length)
 	}
-	t.Logf("\n\n\n")
+	t.Log("\n\n\n")
 }
diff --git a/prog/minimization_test.go b/prog/minimization_test.go
index f5b4c34d1..9b7652908 100644
--- a/prog/minimization_test.go
+++ b/prog/minimization_test.go
@@ -254,7 +254,7 @@ func TestMinimize(t *testing.T) {
 		p1, ci := Minimize(p, test.callIndex, false, test.pred)
 		res := p1.Serialize()
 		if string(res) != test.result {
-			t.Fatalf("minimization produced wrong result #%v\norig:\n%v\nexpect:\n%v\ngot:\n%v\n",
+			t.Fatalf("minimization produced wrong result #%v\norig:\n%v\nexpect:\n%v\ngot:\n%v",
 				ti, test.orig, test.result, string(res))
 		}
 		if ci != test.resultCallIndex {
diff --git a/prog/mutation_test.go b/prog/mutation_test.go
index 29bf7a34a..14e80a73b 100644
--- a/prog/mutation_test.go
+++ b/prog/mutation_test.go
@@ -191,7 +191,7 @@ func TestSizeMutateArg(t *testing.T) {
 				limit := uint64(1<<bits - 1)
 				val := arg.(*ConstArg).Val
 				if val > limit {
-					t.Fatalf("Invalid argument value: %d. (arg size: %d; max value: %d)", val, arg.Size(), limit)
+					t.Fatalf("invalid argument value: %d. (arg size: %d; max value: %d)", val, arg.Size(), limit)
 				}
 			})
 		}
@@ -207,7 +207,7 @@ func TestClone(t *testing.T) {
 		data := p.Serialize()
 		data1 := p1.Serialize()
 		if !bytes.Equal(data, data1) {
-			t.Fatalf("program changed after clone\noriginal:\n%s\n\nnew:\n%s\n", data, data1)
+			t.Fatalf("program changed after clone\noriginal:\n%s\n\nnew:\n%s", data, data1)
 		}
 	}
 }
@@ -226,7 +226,7 @@ func TestMutateRandom(t *testing.T) {
 				p1.Mutate(rs, 10, ct, nil, nil)
 				data := p.Serialize()
 				if !bytes.Equal(data0, data) {
-					t.Fatalf("program changed after mutate\noriginal:\n%s\n\nnew:\n%s\n",
+					t.Fatalf("program changed after mutate\noriginal:\n%s\n\nnew:\n%s",
 						data0, data)
 				}
 				data1 := p1.Serialize()
@@ -234,7 +234,7 @@ func TestMutateRandom(t *testing.T) {
 					continue
 				}
 				if _, err := target.Deserialize(data1, NonStrict); err != nil {
-					t.Fatalf("Deserialize failed after Mutate: %v\n%s", err, data1)
+					t.Fatalf("deserialize failed after mutate: %v\n%s", err, data1)
 				}
 				continue next
 			}
diff --git a/prog/parse_test.go b/prog/parse_test.go
index eddd03873..c1a6aa6aa 100644
--- a/prog/parse_test.go
+++ b/prog/parse_test.go
@@ -49,7 +49,7 @@ func TestParseMulti(t *testing.T) {
 	entries := target.ParseLog([]byte(execLog))
 	if len(entries) != 5 {
 		for i, ent := range entries {
-			t.Logf("program #%v: %v\n", i, ent.P)
+			t.Logf("program #%v: %v", i, ent.P)
 		}
 		t.Fatalf("got %v programs, want 5", len(entries))
 	}
diff --git a/prog/prio_test.go b/prog/prio_test.go
index 60802657a..93555818e 100644
--- a/prog/prio_test.go
+++ b/prog/prio_test.go
@@ -63,7 +63,7 @@ func TestStaticPriorities(t *testing.T) {
 			}
 			// Checks that prio[callCreatesRes][callUsesRes] > prio[callUsesRes][callCreatesRes]
 			if count >= counter[call] {
-				t.Fatalf("Too high priority for %s -> %s: %d vs %s -> %s: %d",
+				t.Fatalf("too high priority for %s -> %s: %d vs %s -> %s: %d",
 					call, referenceCall, count, referenceCall, call, counter[call])
 			}
 		}
diff --git a/prog/prog_test.go b/prog/prog_test.go
index 8da8d773c..d4301e1e7 100644
--- a/prog/prog_test.go
+++ b/prog/prog_test.go
@@ -87,7 +87,7 @@ func testSerialize(t *testing.T, verbose bool) {
 			t.Fatalf("different number of calls")
 		}
 		if !bytes.Equal(data, data1) {
-			t.Fatalf("program changed after serialize/deserialize\noriginal:\n%s\n\nnew:\n%s\n", data, data1)
+			t.Fatalf("program changed after serialize/deserialize\noriginal:\n%s\n\nnew:\n%s", data, data1)
 		}
 	}
 }
diff --git a/prog/rand_test.go b/prog/rand_test.go
index ef1d03390..00613d42a 100644
--- a/prog/rand_test.go
+++ b/prog/rand_test.go
@@ -110,7 +110,7 @@ func TestEnabledCalls(t *testing.T) {
 		}
 		for _, c := range p.Calls {
 			if _, ok := enabledCalls[c.Meta.Name]; !ok {
-				t.Fatalf("program contains a syscall that is not enabled: %v\n", c.Meta.Name)
+				t.Fatalf("program contains a syscall that is not enabled: %v", c.Meta.Name)
 			}
 		}
 	}
@@ -234,7 +234,7 @@ func TestNoGenerate(t *testing.T) {
 		}
 		for _, c := range p.Calls {
 			if c.Meta.Attrs.NoGenerate {
-				t.Fatalf("program contains a no_generate syscall: %v\n", c.Meta.Name)
+				t.Fatalf("program contains a no_generate syscall: %v", c.Meta.Name)
 			}
 		}
 	}
diff --git a/prog/size_test.go b/prog/size_test.go
index 5b49c437a..62f6237c1 100644
--- a/prog/size_test.go
+++ b/prog/size_test.go
@@ -18,7 +18,7 @@ func TestAssignSizeRandom(t *testing.T) {
 			target.assignSizesCall(call)
 		}
 		if data1 := p.Serialize(); !bytes.Equal(data0, data1) {
-			t.Fatalf("different lens assigned, initial:\n%s\nnew:\n%s\n", data0, data1)
+			t.Fatalf("different lens assigned, initial:\n%s\nnew:\n%s", data0, data1)
 		}
 		p.Mutate(rs, 10, ct, nil, nil)
 		p.Serialize()
diff --git a/prog/test_util.go b/prog/test_util.go
index eb15539ea..fb45a8566 100644
--- a/prog/test_util.go
+++ b/prog/test_util.go
@@ -36,7 +36,7 @@ func TestDeserializeHelper(t *testing.T, OS, arch string, transform func(*Target
 				t.Errorf("both Err and Out are set")
 			}
 			if test.In == test.Out {
-				t.Errorf("In and Out are equal, remove Out in such case\n%v", test.In)
+				t.Errorf("in and out are equal, remove Out in such case\n%v", test.In)
 			}
 			if test.Out == "" {
 				test.Out = test.In
@@ -49,7 +49,7 @@ func TestDeserializeHelper(t *testing.T, OS, arch string, transform func(*Target
 				}
 				if err != nil {
 					if wantErr == "" {
-						t.Fatalf("deserialization failed with\n%s\ndata:\n%s\n",
+						t.Fatalf("deserialization failed with\n%s\ndata:\n%s",
 							err, test.In)
 					}
 					if !strings.Contains(err.Error(), wantErr) {
@@ -58,7 +58,7 @@ func TestDeserializeHelper(t *testing.T, OS, arch string, transform func(*Target
 					}
 				} else {
 					if wantErr != "" {
-						t.Fatalf("deserialization should have failed with:\n%s\ndata:\n%s\n",
+						t.Fatalf("deserialization should have failed with:\n%s\ndata:\n%s",
 							wantErr, test.In)
 					}
 					if transform != nil {
@@ -72,7 +72,7 @@ func TestDeserializeHelper(t *testing.T, OS, arch string, transform func(*Target
 					// the verbose and non-verbose output don't match -- the strict parsing
 					// mode does not accept the non-verbose output as input.
 					if want != output && want != outputVerbose {
-						t.Fatalf("wrong serialized data:\n%s\nexpect:\n%s\n", outputVerbose, want)
+						t.Fatalf("wrong serialized data:\n%s\nexpect:\n%s", outputVerbose, want)
 					}
 					p.SerializeForExec()
 				}
diff --git a/syz-hub/state/state_test.go b/syz-hub/state/state_test.go
index ad90d6aaf..335f02ea0 100644
--- a/syz-hub/state/state_test.go
+++ b/syz-hub/state/state_test.go
@@ -95,7 +95,7 @@ func TestRepro(t *testing.T) {
 		t.Helper()
 		repro := st.PendingRepro(name)
 		if string(repro) != result {
-			t.Fatalf("PendingRepro returned %q, want %q", string(repro), result)
+			t.Fatalf("got %q, want %q", string(repro), result)
 		}
 	}
 	expectPendingRepro("foo", "")
diff --git a/syz-verifier/execresult_test.go b/syz-verifier/execresult_test.go
index 2c024e0b0..1ff25e73d 100644
--- a/syz-verifier/execresult_test.go
+++ b/syz-verifier/execresult_test.go
@@ -171,7 +171,7 @@ func TestCompareResults(t *testing.T) {
 			}
 			got := CompareResults(test.res, prog)
 			if diff := cmp.Diff(test.wantReport, got); diff != "" {
-				t.Errorf("Verify report mismatch (-want +got):\n%s", diff)
+				t.Errorf("verify report mismatch (-want +got):\n%s", diff)
 			}
 		})
 	}
diff --git a/syz-verifier/rpcserver_test.go b/syz-verifier/rpcserver_test.go
index 8d630e8c6..71047fd2f 100644
--- a/syz-verifier/rpcserver_test.go
+++ b/syz-verifier/rpcserver_test.go
@@ -27,6 +27,6 @@ func TestConnect(t *testing.T) {
 	}
 
 	if diff := cmp.Diff(&rpctype.RunnerConnectRes{CheckUnsupportedCalls: true}, r); diff != "" {
-		t.Errorf("Connect result mismatch (-want +got):\n%s", diff)
+		t.Errorf("connect result mismatch (-want +got):\n%s", diff)
 	}
 }
diff --git a/tools/syz-linter/linter.go b/tools/syz-linter/linter.go
index 542d040e6..14549aff4 100644
--- a/tools/syz-linter/linter.go
+++ b/tools/syz-linter/linter.go
@@ -301,14 +301,16 @@ func (pass *Pass) logFormatArg(n *ast.CallExpr) (arg int, newLine, sure bool) {
 			break
 		}
 		return 1, true, true
+	case "t.Errorf", "t.Fatalf":
+		return 0, false, true
 	}
 	if fun.Sel.String() == "Logf" {
-		return 1, false, true
+		return 0, false, true
 	}
 	return -1, false, false
 }
 
-var publicIdentifier = regexp.MustCompile(`^[A-Z][[:alnum:]]+(\.[[:alnum:]]+)+ `)
+var publicIdentifier = regexp.MustCompile(`^[A-Z][[:alnum:]]+?((\.|[A-Z])[[:alnum:]]+)+ `)
 
 func stringLit(n ast.Node) (string, bool) {
 	lit, ok := n.(*ast.BasicLit)
diff --git a/tools/syz-linter/testdata/src/lintertest/lintertest.go b/tools/syz-linter/testdata/src/lintertest/lintertest.go
index 51700726e..c6ba8ba8f 100644
--- a/tools/syz-linter/testdata/src/lintertest/lintertest.go
+++ b/tools/syz-linter/testdata/src/lintertest/lintertest.go
@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"testing"
 )
 
 /* some comment */ // want "Use C-style comments // instead of /* */"
@@ -100,6 +101,14 @@ func logErrorMessages() {
 	fmt.Fprintf(os.Stderr, "%v", err)                                   // want "Add \\\\n at the end of printed messages"
 }
 
+func testMessages(t *testing.T) {
+	t.Logf("good message %v", 1)
+	t.Logf("Bad message %v", 1)     // want "Don't start log/error messages with a Capital letter"
+	t.Errorf("bad message %v\n", 1) // want "Don't use \\\\n at the end of log/error messages"
+	t.Fatalf("Bad message %v", 1)   // want "Don't start log/error messages with a Capital letter"
+	t.Fatalf("PublicFunc is ok %v", 1)
+}
+
 func varDecls() {
 	var a int
 	b := 0
diff --git a/vm/vm_test.go b/vm/vm_test.go
index c147ac049..f927a337a 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -424,10 +424,10 @@ func testMonitorExecution(t *testing.T, test *Test) {
 		t.Fatalf("want title %q, got title %q", test.Report.Title, rep.Title)
 	}
 	if !bytes.Equal(test.Report.Report, rep.Report) {
-		t.Fatalf("want report:\n%s\n\ngot report:\n%s\n", test.Report.Report, rep.Report)
+		t.Fatalf("want report:\n%s\n\ngot report:\n%s", test.Report.Report, rep.Report)
 	}
 	if test.Report.Output != nil && !bytes.Equal(test.Report.Output, rep.Output) {
-		t.Fatalf("want output:\n%s\n\ngot output:\n%s\n", test.Report.Output, rep.Output)
+		t.Fatalf("want output:\n%s\n\ngot output:\n%s", test.Report.Output, rep.Output)
 	}
 }