From 43a123c1ae6613b3efeed291fa552ecd909d3acf Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Tue, 16 Apr 2024 21:23:18 +0200 Subject: Adding upstream version 1.20.14. Signed-off-by: Daniel Baumann --- src/internal/coverage/slicewriter/slicewriter.go | 80 ++++++++++++++ src/internal/coverage/slicewriter/slw_test.go | 131 +++++++++++++++++++++++ 2 files changed, 211 insertions(+) create mode 100644 src/internal/coverage/slicewriter/slicewriter.go create mode 100644 src/internal/coverage/slicewriter/slw_test.go (limited to 'src/internal/coverage/slicewriter') diff --git a/src/internal/coverage/slicewriter/slicewriter.go b/src/internal/coverage/slicewriter/slicewriter.go new file mode 100644 index 0000000..3522bf5 --- /dev/null +++ b/src/internal/coverage/slicewriter/slicewriter.go @@ -0,0 +1,80 @@ +// Copyright 2022 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 slicewriter + +import ( + "fmt" + "io" +) + +// WriteSeeker is a helper object that implements the io.WriteSeeker +// interface. Clients can create a WriteSeeker, make a series of Write +// calls to add data to it (and possibly Seek calls to update +// previously written portions), then finally invoke BytesWritten() to +// get a pointer to the constructed byte slice. +type WriteSeeker struct { + payload []byte + off int64 +} + +func (sws *WriteSeeker) Write(p []byte) (n int, err error) { + amt := len(p) + towrite := sws.payload[sws.off:] + if len(towrite) < amt { + sws.payload = append(sws.payload, make([]byte, amt-len(towrite))...) + towrite = sws.payload[sws.off:] + } + copy(towrite, p) + sws.off += int64(amt) + return amt, nil +} + +// Seek repositions the read/write position of the WriteSeeker within +// its internally maintained slice. Note that it is not possible to +// expand the size of the slice using SEEK_SET; trying to seek outside +// the slice will result in an error. +func (sws *WriteSeeker) Seek(offset int64, whence int) (int64, error) { + switch whence { + case io.SeekStart: + if sws.off != offset && (offset < 0 || offset >= int64(len(sws.payload))) { + return 0, fmt.Errorf("invalid seek: new offset %d (out of range [0 %d]", offset, len(sws.payload)) + } + sws.off = offset + return offset, nil + case io.SeekCurrent: + newoff := sws.off + offset + if newoff != sws.off && (newoff < 0 || newoff >= int64(len(sws.payload))) { + return 0, fmt.Errorf("invalid seek: new offset %d (out of range [0 %d]", newoff, len(sws.payload)) + } + sws.off += offset + return sws.off, nil + case io.SeekEnd: + newoff := int64(len(sws.payload)) + offset + if newoff != sws.off && (newoff < 0 || newoff >= int64(len(sws.payload))) { + return 0, fmt.Errorf("invalid seek: new offset %d (out of range [0 %d]", newoff, len(sws.payload)) + } + sws.off = newoff + return sws.off, nil + } + // other modes not supported + return 0, fmt.Errorf("unsupported seek mode %d", whence) +} + +// BytesWritten returns the underlying byte slice for the WriteSeeker, +// containing the data written to it via Write/Seek calls. +func (sws *WriteSeeker) BytesWritten() []byte { + return sws.payload +} + +func (sws *WriteSeeker) Read(p []byte) (n int, err error) { + amt := len(p) + toread := sws.payload[sws.off:] + if len(toread) < amt { + amt = len(toread) + } + copy(p, toread) + sws.off += int64(amt) + return amt, nil +} diff --git a/src/internal/coverage/slicewriter/slw_test.go b/src/internal/coverage/slicewriter/slw_test.go new file mode 100644 index 0000000..f4e75f4 --- /dev/null +++ b/src/internal/coverage/slicewriter/slw_test.go @@ -0,0 +1,131 @@ +// Copyright 2022 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 slicewriter + +import ( + "io" + "testing" +) + +func TestSliceWriter(t *testing.T) { + + sleq := func(t *testing.T, got []byte, want []byte) { + t.Helper() + if len(got) != len(want) { + t.Fatalf("bad length got %d want %d", len(got), len(want)) + } + for i := range got { + if got[i] != want[i] { + t.Fatalf("bad read at %d got %d want %d", i, got[i], want[i]) + } + } + } + + wf := func(t *testing.T, ws *WriteSeeker, p []byte) { + t.Helper() + nw, werr := ws.Write(p) + if werr != nil { + t.Fatalf("unexpected write error: %v", werr) + } + if nw != len(p) { + t.Fatalf("wrong amount written want %d got %d", len(p), nw) + } + } + + rf := func(t *testing.T, ws *WriteSeeker, p []byte) { + t.Helper() + b := make([]byte, len(p)) + nr, rerr := ws.Read(b) + if rerr != nil { + t.Fatalf("unexpected read error: %v", rerr) + } + if nr != len(p) { + t.Fatalf("wrong amount read want %d got %d", len(p), nr) + } + sleq(t, b, p) + } + + sk := func(t *testing.T, ws *WriteSeeker, offset int64, whence int) { + t.Helper() + _, err := ws.Seek(offset, whence) + if err != nil { + t.Fatalf("unexpected seek error: %v", err) + } + } + + wp1 := []byte{1, 2} + ws := &WriteSeeker{} + + // write some stuff + wf(t, ws, wp1) + // check that BytesWritten returns what we wrote. + sleq(t, ws.BytesWritten(), wp1) + // offset is at end of slice, so reading should return zero bytes. + rf(t, ws, []byte{}) + + // write some more stuff + wp2 := []byte{7, 8, 9} + wf(t, ws, wp2) + // check that BytesWritten returns what we expect. + wpex := []byte{1, 2, 7, 8, 9} + sleq(t, ws.BytesWritten(), wpex) + rf(t, ws, []byte{}) + + // seeks and reads. + sk(t, ws, 1, io.SeekStart) + rf(t, ws, []byte{2, 7}) + sk(t, ws, -2, io.SeekCurrent) + rf(t, ws, []byte{2, 7}) + sk(t, ws, -4, io.SeekEnd) + rf(t, ws, []byte{2, 7}) + + // seek back and overwrite + sk(t, ws, 1, io.SeekStart) + wf(t, ws, []byte{9, 11}) + wpex = []byte{1, 9, 11, 8, 9} + sleq(t, ws.BytesWritten(), wpex) + + // seeks on empty writer. + ws2 := &WriteSeeker{} + sk(t, ws2, 0, io.SeekStart) + sk(t, ws2, 0, io.SeekCurrent) + sk(t, ws2, 0, io.SeekEnd) + + // check for seek errors. + _, err := ws.Seek(-1, io.SeekStart) + if err == nil { + t.Fatalf("expected error on invalid -1 seek") + } + _, err = ws.Seek(int64(len(ws.BytesWritten())), io.SeekStart) + if err == nil { + t.Fatalf("expected error on invalid %d seek", len(ws.BytesWritten())) + } + + ws.Seek(0, io.SeekStart) + _, err = ws.Seek(-1, io.SeekCurrent) + if err == nil { + t.Fatalf("expected error on invalid -1 seek") + } + _, err = ws.Seek(int64(len(ws.BytesWritten())), io.SeekCurrent) + if err == nil { + t.Fatalf("expected error on invalid %d seek", len(ws.BytesWritten())) + } + + _, err = ws.Seek(1, io.SeekEnd) + if err == nil { + t.Fatalf("expected error on invalid 1 seek") + } + bsamt := int64(-1*len(ws.BytesWritten()) - 1) + _, err = ws.Seek(bsamt, io.SeekEnd) + if err == nil { + t.Fatalf("expected error on invalid %d seek", bsamt) + } + + // bad seek mode + _, err = ws.Seek(-1, io.SeekStart+9) + if err == nil { + t.Fatalf("expected error on invalid seek mode") + } +} -- cgit v1.2.3