From 5fc4604aa8b593d8d9e93c98a1380114633b7c6a Mon Sep 17 00:00:00 2001 From: Tim Cooper Date: Fri, 26 Oct 2018 16:34:27 -0500 Subject: [PATCH] bytes, strings: fix Reader.UnreadRune returning without error on a zero Reader Fixes #28269 Change-Id: I878dff43c0b6bdb98702d8e73f2ecd984fb2350f Reviewed-on: https://go-review.googlesource.com/c/145098 Reviewed-by: Brad Fitzpatrick Run-TryBot: Brad Fitzpatrick TryBot-Result: Gobot Gobot --- src/bytes/reader.go | 6 +++++- src/bytes/reader_test.go | 42 ++++++++++++++++++++++++++++++++++++++ src/strings/reader.go | 6 +++++- src/strings/reader_test.go | 42 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 94 insertions(+), 2 deletions(-) diff --git a/src/bytes/reader.go b/src/bytes/reader.go index 08464c2402..5946cf9780 100644 --- a/src/bytes/reader.go +++ b/src/bytes/reader.go @@ -14,6 +14,7 @@ import ( // io.ByteScanner, and io.RuneScanner interfaces by reading from // a byte slice. // Unlike a Buffer, a Reader is read-only and supports seeking. +// The zero value for Reader operates like a Reader of an empty slice. type Reader struct { s []byte i int64 // current reading index @@ -75,10 +76,10 @@ func (r *Reader) ReadByte() (byte, error) { // UnreadByte complements ReadByte in implementing the io.ByteScanner interface. func (r *Reader) UnreadByte() error { - r.prevRune = -1 if r.i <= 0 { return errors.New("bytes.Reader.UnreadByte: at beginning of slice") } + r.prevRune = -1 r.i-- return nil } @@ -101,6 +102,9 @@ func (r *Reader) ReadRune() (ch rune, size int, err error) { // UnreadRune complements ReadRune in implementing the io.RuneScanner interface. func (r *Reader) UnreadRune() error { + if r.i <= 0 { + return errors.New("bytes.Reader.UnreadRune: at beginning of slice") + } if r.prevRune < 0 { return errors.New("bytes.Reader.UnreadRune: previous operation was not ReadRune") } diff --git a/src/bytes/reader_test.go b/src/bytes/reader_test.go index 8806876ff1..d799e036f0 100644 --- a/src/bytes/reader_test.go +++ b/src/bytes/reader_test.go @@ -276,3 +276,45 @@ func TestReaderReset(t *testing.T) { t.Errorf("ReadAll: got %q, want %q", got, want) } } + +func TestReaderZero(t *testing.T) { + if l := (&Reader{}).Len(); l != 0 { + t.Errorf("Len: got %d, want 0", l) + } + + if n, err := (&Reader{}).Read(nil); n != 0 || err != io.EOF { + t.Errorf("Read: got %d, %v; want 0, io.EOF", n, err) + } + + if n, err := (&Reader{}).ReadAt(nil, 11); n != 0 || err != io.EOF { + t.Errorf("ReadAt: got %d, %v; want 0, io.EOF", n, err) + } + + if b, err := (&Reader{}).ReadByte(); b != 0 || err != io.EOF { + t.Errorf("ReadByte: got %d, %v; want 0, io.EOF", b, err) + } + + if ch, size, err := (&Reader{}).ReadRune(); ch != 0 || size != 0 || err != io.EOF { + t.Errorf("ReadRune: got %d, %d, %v; want 0, 0, io.EOF", ch, size, err) + } + + if offset, err := (&Reader{}).Seek(11, io.SeekStart); offset != 11 || err != nil { + t.Errorf("Seek: got %d, %v; want 11, nil", offset, err) + } + + if s := (&Reader{}).Size(); s != 0 { + t.Errorf("Size: got %d, want 0", s) + } + + if (&Reader{}).UnreadByte() == nil { + t.Errorf("UnreadByte: got nil, want error") + } + + if (&Reader{}).UnreadRune() == nil { + t.Errorf("UnreadRune: got nil, want error") + } + + if n, err := (&Reader{}).WriteTo(ioutil.Discard); n != 0 || err != nil { + t.Errorf("WriteTo: got %d, %v; want 0, nil", n, err) + } +} diff --git a/src/strings/reader.go b/src/strings/reader.go index 6c1a5064c0..eb2fa1164c 100644 --- a/src/strings/reader.go +++ b/src/strings/reader.go @@ -13,6 +13,7 @@ import ( // A Reader implements the io.Reader, io.ReaderAt, io.Seeker, io.WriterTo, // io.ByteScanner, and io.RuneScanner interfaces by reading // from a string. +// The zero value for Reader operates like a Reader of an empty string. type Reader struct { s string i int64 // current reading index @@ -70,10 +71,10 @@ func (r *Reader) ReadByte() (byte, error) { } func (r *Reader) UnreadByte() error { - r.prevRune = -1 if r.i <= 0 { return errors.New("strings.Reader.UnreadByte: at beginning of string") } + r.prevRune = -1 r.i-- return nil } @@ -94,6 +95,9 @@ func (r *Reader) ReadRune() (ch rune, size int, err error) { } func (r *Reader) UnreadRune() error { + if r.i <= 0 { + return errors.New("strings.Reader.UnreadRune: at beginning of string") + } if r.prevRune < 0 { return errors.New("strings.Reader.UnreadRune: previous operation was not ReadRune") } diff --git a/src/strings/reader_test.go b/src/strings/reader_test.go index bf40eb1a31..a4c211d699 100644 --- a/src/strings/reader_test.go +++ b/src/strings/reader_test.go @@ -190,3 +190,45 @@ func TestReaderReset(t *testing.T) { t.Errorf("ReadAll: got %q, want %q", got, want) } } + +func TestReaderZero(t *testing.T) { + if l := (&strings.Reader{}).Len(); l != 0 { + t.Errorf("Len: got %d, want 0", l) + } + + if n, err := (&strings.Reader{}).Read(nil); n != 0 || err != io.EOF { + t.Errorf("Read: got %d, %v; want 0, io.EOF", n, err) + } + + if n, err := (&strings.Reader{}).ReadAt(nil, 11); n != 0 || err != io.EOF { + t.Errorf("ReadAt: got %d, %v; want 0, io.EOF", n, err) + } + + if b, err := (&strings.Reader{}).ReadByte(); b != 0 || err != io.EOF { + t.Errorf("ReadByte: got %d, %v; want 0, io.EOF", b, err) + } + + if ch, size, err := (&strings.Reader{}).ReadRune(); ch != 0 || size != 0 || err != io.EOF { + t.Errorf("ReadRune: got %d, %d, %v; want 0, 0, io.EOF", ch, size, err) + } + + if offset, err := (&strings.Reader{}).Seek(11, io.SeekStart); offset != 11 || err != nil { + t.Errorf("Seek: got %d, %v; want 11, nil", offset, err) + } + + if s := (&strings.Reader{}).Size(); s != 0 { + t.Errorf("Size: got %d, want 0", s) + } + + if (&strings.Reader{}).UnreadByte() == nil { + t.Errorf("UnreadByte: got nil, want error") + } + + if (&strings.Reader{}).UnreadRune() == nil { + t.Errorf("UnreadRune: got nil, want error") + } + + if n, err := (&strings.Reader{}).WriteTo(ioutil.Discard); n != 0 || err != nil { + t.Errorf("WriteTo: got %d, %v; want 0, nil", n, err) + } +} -- 2.48.1