| // Copyright 2021 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package test |
| |
| import ( |
| "fmt" |
| "internal/coverage" |
| "internal/coverage/decodecounter" |
| "internal/coverage/encodecounter" |
| "io" |
| "os" |
| "path/filepath" |
| "testing" |
| ) |
| |
| type ctrVis struct { |
| funcs []decodecounter.FuncPayload |
| } |
| |
| func (v *ctrVis) VisitFuncs(f encodecounter.CounterVisitorFn) error { |
| for _, fn := range v.funcs { |
| if err := f(fn.PkgIdx, fn.FuncIdx, fn.Counters); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| |
| func mkfunc(p uint32, f uint32, c []uint32) decodecounter.FuncPayload { |
| return decodecounter.FuncPayload{ |
| PkgIdx: p, |
| FuncIdx: f, |
| Counters: c, |
| } |
| } |
| |
| func TestCounterDataWriterReader(t *testing.T) { |
| flavors := []coverage.CounterFlavor{ |
| coverage.CtrRaw, |
| coverage.CtrULeb128, |
| } |
| |
| isDead := func(fp decodecounter.FuncPayload) bool { |
| for _, v := range fp.Counters { |
| if v != 0 { |
| return false |
| } |
| } |
| return true |
| } |
| |
| funcs := []decodecounter.FuncPayload{ |
| mkfunc(0, 0, []uint32{13, 14, 15}), |
| mkfunc(0, 1, []uint32{16, 17}), |
| mkfunc(1, 0, []uint32{18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 976543, 7}), |
| } |
| writeVisitor := &ctrVis{funcs: funcs} |
| |
| for kf, flav := range flavors { |
| |
| t.Logf("testing flavor %d\n", flav) |
| |
| // Open a counter data file in preparation for emitting data. |
| d := t.TempDir() |
| cfpath := filepath.Join(d, fmt.Sprintf("covcounters.hash.0.%d", kf)) |
| of, err := os.OpenFile(cfpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666) |
| if err != nil { |
| t.Fatalf("opening covcounters: %v", err) |
| } |
| |
| // Perform the encode and write. |
| cdfw := encodecounter.NewCoverageDataWriter(of, flav) |
| if cdfw == nil { |
| t.Fatalf("NewCoverageDataWriter failed") |
| } |
| finalHash := [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0} |
| args := map[string]string{"argc": "3", "argv0": "arg0", "argv1": "arg1", "argv2": "arg_________2"} |
| if err := cdfw.Write(finalHash, args, writeVisitor); err != nil { |
| t.Fatalf("counter file Write failed: %v", err) |
| } |
| if err := of.Close(); err != nil { |
| t.Fatalf("closing covcounters: %v", err) |
| } |
| cdfw = nil |
| |
| // Decode the same file. |
| var cdr *decodecounter.CounterDataReader |
| inf, err := os.Open(cfpath) |
| defer func() { |
| if err := inf.Close(); err != nil { |
| t.Fatalf("close failed with: %v", err) |
| } |
| }() |
| |
| if err != nil { |
| t.Fatalf("reopening covcounters file: %v", err) |
| } |
| if cdr, err = decodecounter.NewCounterDataReader(cfpath, inf); err != nil { |
| t.Fatalf("opening covcounters for read: %v", err) |
| } |
| decodedArgs := cdr.OsArgs() |
| aWant := "[arg0 arg1 arg_________2]" |
| aGot := fmt.Sprintf("%+v", decodedArgs) |
| if aWant != aGot { |
| t.Errorf("reading decoded args, got %s want %s", aGot, aWant) |
| } |
| for i := range funcs { |
| if isDead(funcs[i]) { |
| continue |
| } |
| var fp decodecounter.FuncPayload |
| if ok, err := cdr.NextFunc(&fp); err != nil { |
| t.Fatalf("reading func %d: %v", i, err) |
| } else if !ok { |
| t.Fatalf("reading func %d: bad return", i) |
| } |
| got := fmt.Sprintf("%+v", fp) |
| want := fmt.Sprintf("%+v", funcs[i]) |
| if got != want { |
| t.Errorf("cdr.NextFunc iter %d\ngot %+v\nwant %+v", i, got, want) |
| } |
| } |
| var dummy decodecounter.FuncPayload |
| if ok, err := cdr.NextFunc(&dummy); err != nil { |
| t.Fatalf("reading func after loop: %v", err) |
| } else if ok { |
| t.Fatalf("reading func after loop: expected EOF") |
| } |
| } |
| } |
| |
| func TestCounterDataAppendSegment(t *testing.T) { |
| d := t.TempDir() |
| cfpath := filepath.Join(d, "covcounters.hash2.0") |
| of, err := os.OpenFile(cfpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666) |
| if err != nil { |
| t.Fatalf("opening covcounters: %v", err) |
| } |
| |
| const numSegments = 2 |
| |
| // Write a counter with with multiple segments. |
| args := map[string]string{"argc": "1", "argv0": "prog.exe"} |
| allfuncs := [][]decodecounter.FuncPayload{} |
| ctrs := []uint32{} |
| q := uint32(0) |
| var cdfw *encodecounter.CoverageDataWriter |
| for idx := 0; idx < numSegments; idx++ { |
| args[fmt.Sprintf("seg%d", idx)] = "x" |
| q += 7 |
| ctrs = append(ctrs, q) |
| funcs := []decodecounter.FuncPayload{} |
| for k := 0; k < idx+1; k++ { |
| c := make([]uint32, len(ctrs)) |
| copy(c, ctrs) |
| funcs = append(funcs, mkfunc(uint32(idx), uint32(k), c)) |
| } |
| allfuncs = append(allfuncs, funcs) |
| |
| writeVisitor := &ctrVis{funcs: funcs} |
| |
| if idx == 0 { |
| // Perform the encode and write. |
| cdfw = encodecounter.NewCoverageDataWriter(of, coverage.CtrRaw) |
| if cdfw == nil { |
| t.Fatalf("NewCoverageDataWriter failed") |
| } |
| finalHash := [16]byte{1, 2} |
| if err := cdfw.Write(finalHash, args, writeVisitor); err != nil { |
| t.Fatalf("counter file Write failed: %v", err) |
| } |
| } else { |
| if err := cdfw.AppendSegment(args, writeVisitor); err != nil { |
| t.Fatalf("counter file AppendSegment failed: %v", err) |
| } |
| } |
| } |
| if err := of.Close(); err != nil { |
| t.Fatalf("closing covcounters: %v", err) |
| } |
| |
| // Read the result file. |
| var cdr *decodecounter.CounterDataReader |
| inf, err := os.Open(cfpath) |
| defer func() { |
| if err := inf.Close(); err != nil { |
| t.Fatalf("close failed with: %v", err) |
| } |
| }() |
| |
| if err != nil { |
| t.Fatalf("reopening covcounters file: %v", err) |
| } |
| if cdr, err = decodecounter.NewCounterDataReader(cfpath, inf); err != nil { |
| t.Fatalf("opening covcounters for read: %v", err) |
| } |
| ns := cdr.NumSegments() |
| if ns != numSegments { |
| t.Fatalf("got %d segments want %d", ns, numSegments) |
| } |
| if len(allfuncs) != numSegments { |
| t.Fatalf("expected %d got %d", numSegments, len(allfuncs)) |
| } |
| |
| for sidx := 0; sidx < int(ns); sidx++ { |
| if off, err := inf.Seek(0, io.SeekCurrent); err != nil { |
| t.Fatalf("Seek failed: %v", err) |
| } else { |
| t.Logf("sidx=%d off=%d\n", sidx, off) |
| } |
| |
| if sidx != 0 { |
| if ok, err := cdr.BeginNextSegment(); err != nil { |
| t.Fatalf("BeginNextSegment failed: %v", err) |
| } else if !ok { |
| t.Fatalf("BeginNextSegment return %v on iter %d", |
| ok, sidx) |
| } |
| } |
| funcs := allfuncs[sidx] |
| for i := range funcs { |
| var fp decodecounter.FuncPayload |
| if ok, err := cdr.NextFunc(&fp); err != nil { |
| t.Fatalf("reading func %d: %v", i, err) |
| } else if !ok { |
| t.Fatalf("reading func %d: bad return", i) |
| } |
| got := fmt.Sprintf("%+v", fp) |
| want := fmt.Sprintf("%+v", funcs[i]) |
| if got != want { |
| t.Errorf("cdr.NextFunc iter %d\ngot %+v\nwant %+v", i, got, want) |
| } |
| } |
| } |
| } |
