clerk @ 232cfaba8685839ee439fec29100e31822de2da4

···
        10
        10
         

      
        11
        11
         var update = flag.Bool("golden.update", false, "update golden files")

      
        12
        12
         

      
        13
        
        -// Load reads testdata/<name>.input. Fails the test if the file is missing.

      
        14
        
        -func Load(t testing.TB, name string) []byte {

      
        
        13
        +// Load reads testdata/<path>.input. Fails the test if file is not found.

      
        
        14
        +func Load(t testing.TB, path string) []byte {

      
        15
        15
         	t.Helper()

      
        16
        
        -	path := filepath.Join("testdata", name+".input")

      
        17
        
        -	data, err := os.ReadFile(path)

      
        
        16
        +	data, err := os.ReadFile(filepath.Join("testdata", path+".input"))

      
        18
        17
         	if err != nil {

      
        19
        
        -		t.Fatalf("reading input file %s: %v", path, err)

      
        
        18
        +		t.Fatalf("loading %s: %v", path, err)

      
        20
        19
         	}

      
        21
        20
         	return data

      
        22
        21
         }

      
        23
        22
         

      
        24
        
        -func AssertInput(t testing.TB, got string, name string) {

      
        
        23
        +// Assert compares got against testdata/<name>.golden.

      
        
        24
        +func Assert(t testing.TB, name, got string) {

      
        25
        25
         	t.Helper()

      
        26
        26
         

      
        27
        
        -	path := filepath.Join("testdata", name+".golden")

      
        
        27
        +	normalized := strings.NewReplacer("/", "__", " ", "_").Replace(name)

      
        
        28
        +	path := filepath.Join("testdata", normalized+".golden")

      
        
        29
        +

      
        28
        30
         	if *update {

      
        29
        31
         		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {

      
        30
        32
         			t.Fatalf("creating testdata dir: %v", err)

      ···
        47
        49
         		t.Fatalf("golden mismatch for %s\nwant:\n%s\ngot:\n%s", path, string(golden), got)

      
        48
        50
         	}

      
        49
        51
         }

      
        50
        
        -

      
        51
        
        -func Assert(t testing.TB, got string) {

      
        52
        
        -	t.Helper()

      
        53
        
        -

      
        54
        
        -	name := strings.NewReplacer("/", "__", " ", "_").Replace(t.Name())

      
        55
        
        -	name = strings.TrimPrefix(name, "Test")

      
        56
        
        -	path := filepath.Join("testdata", "golden", name+".golden")

      
        57
        
        -

      
        58
        
        -	if *update {

      
        59
        
        -		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {

      
        60
        
        -			t.Fatalf("creating golden dir: %v", err)

      
        61
        
        -		}

      
        62
        
        -		t.Logf("updated golden file: %s", path)

      
        63
        
        -		if err := os.WriteFile(path, []byte(got), 0o644); err != nil {

      
        64
        
        -			t.Fatalf("writing golden file: %v", err)

      
        65
        
        -		}

      
        66
        
        -		return

      
        67
        
        -	}

      
        68
        
        -

      
        69
        
        -	golden, err := os.ReadFile(path)

      
        70
        
        -	if os.IsNotExist(err) {

      
        71
        
        -		t.Fatalf("no golden file %s, run with -golden.update:\n%s", path, got)

      
        72
        
        -	}

      
        73
        
        -	if err != nil {

      
        74
        
        -		t.Fatalf("reading golden file: %v", err)

      
        75
        
        -	}

      
        76
        
        -

      
        77
        
        -	if string(golden) != got {

      
        78
        
        -		t.Fatalf("golden mismatch for %s\nwant:\n%s\ngot:\n%s", path, string(golden), got)

      
        79
        
        -	}

      
        80
        
        -}

      

···
        84
        84
         	for _, tt := range tests {

      
        85
        85
         		t.Run(tt.name, func(t *testing.T) {

      
        86
        86
         			l := New("j", []byte(tt.input))

      
        87
        
        -			golden.Assert(t, l.Dump())

      
        
        87
        +			golden.Assert(t, tt.name, l.Dump())

      
        88
        88
         		})

      
        89
        89
         	}

      
        90
        90
         }

      

···
        322
        322
         		t.Run(tt.name, func(t *testing.T) {

      
        323
        323
         			l := lexer.New("j", []byte(tt.inp))

      
        324
        324
         			f := New(l).ParseJournal()

      
        325
        
        -			golden.Assert(t, ast.Dump(f))

      
        
        325
        +			golden.Assert(t, tt.name, ast.Dump(f))

      
        326
        326
         		})

      
        327
        327
         	}

      
        328
        328
         }

      

···
        24
        24
         				t.Fatal(err)

      
        25
        25
         			}

      
        26
        26
         

      
        27
        
        -			golden.AssertInput(t, b.String(), tname)

      
        
        27
        +			golden.Assert(t, tname, b.String())

      
        28
        28
         		})

      
        29
        29
         	}

      
        30
        30
         }

      ···
        71
        71
         				t.Fatal(err)

      
        72
        72
         			}

      
        73
        73
         

      
        74
        
        -			golden.AssertInput(t, b.String(), tname)

      
        
        74
        +			golden.Assert(t, tname, b.String())

      
        75
        75
         		})

      
        76
        76
         	}

      
        77
        77
         }

      

···
        16
        16
         		t.Run(tt, func(t *testing.T) {

      
        17
        17
         			inp := golden.Load(t, tt)

      
        18
        18
         			out := generateTags(t, inp, tt+".journal")

      
        19
        
        -			golden.AssertInput(t, out, tt)

      
        
        19
        +			golden.Assert(t, tt, out)

      
        20
        20
         		})

      
        21
        21
         	}

      
        22
        22
         }

      ···
        41
        41
         		t.Fatal(err)

      
        42
        42
         	}

      
        43
        43
         

      
        44
        
        -	golden.AssertInput(t, buf.String(), "crossfile")

      
        
        44
        +	golden.Assert(t, "crossfile", buf.String())

      
        45
        45
         }

      
        46
        46
         

      
        47
        47
         func generateTags(t *testing.T, src []byte, fname string) string {