1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
|
// SPDX-License-Identifier: GPL-3.0-or-later
package journal
import (
"path/filepath"
"strings"
"testing"
"time"
)
// FuzzEscapeRoundTrip: escape never yields a tab or a newline, which would
// split a log line, and unescape returns exactly the bytes escaped - for
// any string, invalid UTF-8 included. Undo reads every path back through
// this pair.
func FuzzEscapeRoundTrip(f *testing.F) {
for _, s := range []string{"plain.pdf", "tab\there", "new\nline", `back\slash`, `\x41`, "\xff\xfe", `\\n`, "zażółć gęślą jaźń", "\x00\x1b[2K"} {
f.Add(s)
}
f.Fuzz(func(t *testing.T, s string) {
e := escape(s)
if strings.ContainsAny(e, "\t\n") {
t.Fatalf("escape(%q) = %q holds a tab or a newline", s, e)
}
if got := unescape(e); got != s {
t.Fatalf("unescape(escape(%q)) = %q", s, got)
}
})
}
// FuzzParseLine: a log line of any content is rejected or parsed, never a
// panic - the log is a file a crash can truncate or a person can edit.
func FuzzParseLine(f *testing.F) {
f.Add("2026-09-11T10:02:03+02:00\tR\tdl\ta.pdf\t1\tmove\tok\tacme\t/a\t/b\t3\t2026-09-11T10:02:03+02:00\t")
f.Add("\t\t\t\t\t\t\t\t\t\t\t\t")
f.Add("")
f.Add("2026-09-11T10:02:03+02:00\tR\tdl\t\\x\t99999999999999999999\tmove")
f.Fuzz(func(t *testing.T, line string) {
parseLine(line)
})
}
// FuzzEntryRoundTrip: a step written with Append comes back from Entries
// field for field, whatever its file name, rule, paths and detail hold.
func FuzzEntryRoundTrip(f *testing.F) {
f.Add("a.pdf", "acme", "/dl/a.pdf", "/w/a.pdf", "")
f.Add("new\nline\t.pdf", "r", `/dl/\x`, "", "bad\xffbyte")
f.Fuzz(func(t *testing.T, file, rule, src, dst, detail string) {
path := filepath.Join(t.TempDir(), "krino.log")
w, err := Open(path)
if err != nil {
t.Fatal(err)
}
at := time.Date(2026, 9, 11, 10, 2, 3, 0, time.FixedZone("CEST", 2*3600))
want := Entry{Time: at, Run: "R", Dir: "dl", File: file, Step: 1, Action: "move", Status: "ok",
Rule: rule, Src: src, Dst: dst, Size: 3, ModTime: at, Detail: detail}
for _, e := range []Entry{
{Time: at, Run: "R", Action: "run-start", Status: "ok"},
want,
{Time: at, Run: "R", Action: "run-end", Status: "ok"},
} {
if err := w.Append(e); err != nil {
t.Fatal(err)
}
}
if err := w.Close(); err != nil {
t.Fatal(err)
}
entries, err := Entries(path, "R")
if err != nil {
t.Fatal(err)
}
var got []Entry
for _, e := range entries {
if e.Action == "move" {
got = append(got, e)
}
}
if len(got) != 1 {
t.Fatalf("read back %d move entries, want 1: %+v", len(got), entries)
}
g := got[0]
if !g.Time.Equal(want.Time) || !g.ModTime.Equal(want.ModTime) {
t.Fatalf("times changed: %v %v", g.Time, g.ModTime)
}
g.Time, g.ModTime = want.Time, want.ModTime
if g != want {
t.Fatalf("read back\n%+v\nwant\n%+v", g, want)
}
})
}
|
