src/internal/trace/v2/reader_test.go

   1 // Copyright 2023 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package trace_test
   6
   7 import (
   8         "bytes"
   9         "flag"
  10         "fmt"
  11         "io"
  12         "os"
  13         "path/filepath"
  14         "strings"
  15         "testing"
  16
  17         "internal/trace/v2"
  18         "internal/trace/v2/raw"
  19         "internal/trace/v2/testtrace"
  20         "internal/trace/v2/version"
  21 )
  22
  23 var (
  24         logEvents  = flag.Bool("log-events", false, "whether to log high-level events; significantly slows down tests")
  25         dumpTraces = flag.Bool("dump-traces", false, "dump traces even on success")
  26 )
  27
  28 func TestReaderGolden(t *testing.T) {
  29         matches, err := filepath.Glob("./testdata/tests/*.test")
  30         if err != nil {
  31                 t.Fatalf("failed to glob for tests: %v", err)
  32         }
  33         for _, testPath := range matches {
  34                 testPath := testPath
  35                 testName, err := filepath.Rel("./testdata", testPath)
  36                 if err != nil {
  37                         t.Fatalf("failed to relativize testdata path: %v", err)
  38                 }
  39                 t.Run(testName, func(t *testing.T) {
  40                         tr, exp, err := testtrace.ParseFile(testPath)
  41                         if err != nil {
  42                                 t.Fatalf("failed to parse test file at %s: %v", testPath, err)
  43                         }
  44                         testReader(t, tr, exp)
  45                 })
  46         }
  47 }
  48
  49 func testReader(t *testing.T, tr io.Reader, exp *testtrace.Expectation) {
  50         r, err := trace.NewReader(tr)
  51         if err != nil {
  52                 if err := exp.Check(err); err != nil {
  53                         t.Error(err)
  54                 }
  55                 return
  56         }
  57         v := testtrace.NewValidator()
  58         for {
  59                 ev, err := r.ReadEvent()
  60                 if err == io.EOF {
  61                         break
  62                 }
  63                 if err != nil {
  64                         if err := exp.Check(err); err != nil {
  65                                 t.Error(err)
  66                         }
  67                         return
  68                 }
  69                 if *logEvents {
  70                         t.Log(ev.String())
  71                 }
  72                 if err := v.Event(ev); err != nil {
  73                         t.Error(err)
  74                 }
  75         }
  76         if err := exp.Check(nil); err != nil {
  77                 t.Error(err)
  78         }
  79 }
  80
  81 func dumpTraceToText(t *testing.T, b []byte) string {
  82         t.Helper()
  83
  84         br, err := raw.NewReader(bytes.NewReader(b))
  85         if err != nil {
  86                 t.Fatalf("dumping trace: %v", err)
  87         }
  88         var sb strings.Builder
  89         tw, err := raw.NewTextWriter(&sb, version.Go122)
  90         if err != nil {
  91                 t.Fatalf("dumping trace: %v", err)
  92         }
  93         for {
  94                 ev, err := br.ReadEvent()
  95                 if err == io.EOF {
  96                         break
  97                 }
  98                 if err != nil {
  99                         t.Fatalf("dumping trace: %v", err)
 100                 }
 101                 if err := tw.WriteEvent(ev); err != nil {
 102                         t.Fatalf("dumping trace: %v", err)
 103                 }
 104         }
 105         return sb.String()
 106 }
 107
 108 func dumpTraceToFile(t *testing.T, testName string, stress bool, b []byte) string {
 109         t.Helper()
 110
 111         desc := "default"
 112         if stress {
 113                 desc = "stress"
 114         }
 115         name := fmt.Sprintf("%s.%s.trace.", testName, desc)
 116         f, err := os.CreateTemp("", name)
 117         if err != nil {
 118                 t.Fatalf("creating temp file: %v", err)
 119         }
 120         defer f.Close()
 121         if _, err := io.Copy(f, bytes.NewReader(b)); err != nil {
 122                 t.Fatalf("writing trace dump to %q: %v", f.Name(), err)
 123         }
 124         return f.Name()
 125 }