aboutsummaryrefslogtreecommitdiffstats
path: root/formats/packp/pktline
diff options
context:
space:
mode:
Diffstat (limited to 'formats/packp/pktline')
-rw-r--r--formats/packp/pktline/encoder.go123
-rw-r--r--formats/packp/pktline/encoder_test.go249
-rw-r--r--formats/packp/pktline/pktlines.go140
-rw-r--r--formats/packp/pktline/pktlines_test.go231
-rw-r--r--formats/packp/pktline/scanner_test.go46
5 files changed, 402 insertions, 387 deletions
diff --git a/formats/packp/pktline/encoder.go b/formats/packp/pktline/encoder.go
new file mode 100644
index 0000000..0a88a9b
--- /dev/null
+++ b/formats/packp/pktline/encoder.go
@@ -0,0 +1,123 @@
+// Package pktline implements reading payloads form pkt-lines and encoding pkt-lines from payloads.
+package pktline
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "io"
+)
+
+// An Encoder writes pkt-lines to an output stream.
+type Encoder struct {
+ w io.Writer
+}
+
+const (
+ // MaxPayloadSize is the maximum payload size of a pkt-line in bytes.
+ MaxPayloadSize = 65516
+)
+
+var (
+ // FlushPkt are the contents of a flush-pkt pkt-line.
+ FlushPkt = []byte{'0', '0', '0', '0'}
+ // Flush is the payload to use with the Encode method to encode a flush-pkt.
+ Flush = []byte{}
+ // FlushString is the payload to use with the EncodeString method to encode a flush-pkt.
+ FlushString = ""
+ // ErrPayloadTooLong is returned by the Encode methods when any of the
+ // provided payloads is bigger than MaxPayloadSize.
+ ErrPayloadTooLong = errors.New("payload is too long")
+)
+
+// NewEncoder returns a new encoder that writes to w.
+func NewEncoder(w io.Writer) *Encoder {
+ return &Encoder{
+ w: w,
+ }
+}
+
+// Flush encodes a flush-pkt to the output stream.
+func (e *Encoder) Flush() error {
+ _, err := e.w.Write(FlushPkt)
+ return err
+}
+
+// Encode encodes a pkt-line with the payload specified and write it to
+// the output stream. If several payloads are specified, each of them
+// will get streamed in their own pkt-lines.
+func (e *Encoder) Encode(payloads ...[]byte) error {
+ for _, p := range payloads {
+ if err := e.encodeLine(p); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+func (e *Encoder) encodeLine(p []byte) error {
+ if len(p) > MaxPayloadSize {
+ return ErrPayloadTooLong
+ }
+
+ if bytes.Equal(p, Flush) {
+ if err := e.Flush(); err != nil {
+ return err
+ }
+ return nil
+ }
+
+ n := len(p) + 4
+ if _, err := e.w.Write(asciiHex16(n)); err != nil {
+ return err
+ }
+ if _, err := e.w.Write(p); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+// Returns the hexadecimal ascii representation of the 16 less
+// significant bits of n. The length of the returned slice will always
+// be 4. Example: if n is 1234 (0x4d2), the return value will be
+// []byte{'0', '4', 'd', '2'}.
+func asciiHex16(n int) []byte {
+ var ret [4]byte
+ ret[0] = byteToASCIIHex(byte(n & 0xf000 >> 12))
+ ret[1] = byteToASCIIHex(byte(n & 0x0f00 >> 8))
+ ret[2] = byteToASCIIHex(byte(n & 0x00f0 >> 4))
+ ret[3] = byteToASCIIHex(byte(n & 0x000f))
+
+ return ret[:]
+}
+
+// turns a byte into its hexadecimal ascii representation. Example:
+// from 11 (0xb) to 'b'.
+func byteToASCIIHex(n byte) byte {
+ if n < 10 {
+ return '0' + n
+ }
+
+ return 'a' - 10 + n
+}
+
+// EncodeString works similarly as Encode but payloads are specified as strings.
+func (e *Encoder) EncodeString(payloads ...string) error {
+ for _, p := range payloads {
+ if err := e.Encode([]byte(p)); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// Encodef encodes a single pkt-line with the payload formatted as
+// the format specifier and the rest of the arguments suggest.
+func (e *Encoder) Encodef(format string, a ...interface{}) error {
+ return e.EncodeString(
+ fmt.Sprintf(format, a...),
+ )
+}
diff --git a/formats/packp/pktline/encoder_test.go b/formats/packp/pktline/encoder_test.go
new file mode 100644
index 0000000..5990ea5
--- /dev/null
+++ b/formats/packp/pktline/encoder_test.go
@@ -0,0 +1,249 @@
+package pktline_test
+
+import (
+ "bytes"
+ "os"
+ "strings"
+ "testing"
+
+ "gopkg.in/src-d/go-git.v4/formats/packp/pktline"
+
+ . "gopkg.in/check.v1"
+)
+
+func Test(t *testing.T) { TestingT(t) }
+
+type SuiteEncoder struct{}
+
+var _ = Suite(&SuiteEncoder{})
+
+func (s *SuiteEncoder) TestFlush(c *C) {
+ var buf bytes.Buffer
+ e := pktline.NewEncoder(&buf)
+
+ err := e.Flush()
+ c.Assert(err, IsNil)
+
+ obtained := buf.Bytes()
+ c.Assert(obtained, DeepEquals, pktline.FlushPkt)
+}
+
+func (s *SuiteEncoder) TestEncode(c *C) {
+ for i, test := range [...]struct {
+ input [][]byte
+ expected []byte
+ }{
+ {
+ input: [][]byte{
+ []byte("hello\n"),
+ },
+ expected: []byte("000ahello\n"),
+ }, {
+ input: [][]byte{
+ []byte("hello\n"),
+ pktline.Flush,
+ },
+ expected: []byte("000ahello\n0000"),
+ }, {
+ input: [][]byte{
+ []byte("hello\n"),
+ []byte("world!\n"),
+ []byte("foo"),
+ },
+ expected: []byte("000ahello\n000bworld!\n0007foo"),
+ }, {
+ input: [][]byte{
+ []byte("hello\n"),
+ pktline.Flush,
+ []byte("world!\n"),
+ []byte("foo"),
+ pktline.Flush,
+ },
+ expected: []byte("000ahello\n0000000bworld!\n0007foo0000"),
+ }, {
+ input: [][]byte{
+ []byte(strings.Repeat("a", pktline.MaxPayloadSize)),
+ },
+ expected: []byte(
+ "fff0" + strings.Repeat("a", pktline.MaxPayloadSize)),
+ }, {
+ input: [][]byte{
+ []byte(strings.Repeat("a", pktline.MaxPayloadSize)),
+ []byte(strings.Repeat("b", pktline.MaxPayloadSize)),
+ },
+ expected: []byte(
+ "fff0" + strings.Repeat("a", pktline.MaxPayloadSize) +
+ "fff0" + strings.Repeat("b", pktline.MaxPayloadSize)),
+ },
+ } {
+ comment := Commentf("input %d = %v\n", i, test.input)
+
+ var buf bytes.Buffer
+ e := pktline.NewEncoder(&buf)
+
+ err := e.Encode(test.input...)
+ c.Assert(err, IsNil, comment)
+
+ c.Assert(buf.Bytes(), DeepEquals, test.expected, comment)
+ }
+}
+
+func (s *SuiteEncoder) TestEncodeErrPayloadTooLong(c *C) {
+ for i, input := range [...][][]byte{
+ [][]byte{
+ []byte(strings.Repeat("a", pktline.MaxPayloadSize+1)),
+ },
+ [][]byte{
+ []byte("hello world!"),
+ []byte(strings.Repeat("a", pktline.MaxPayloadSize+1)),
+ },
+ [][]byte{
+ []byte("hello world!"),
+ []byte(strings.Repeat("a", pktline.MaxPayloadSize+1)),
+ []byte("foo"),
+ },
+ } {
+ comment := Commentf("input %d = %v\n", i, input)
+
+ var buf bytes.Buffer
+ e := pktline.NewEncoder(&buf)
+
+ err := e.Encode(input...)
+ c.Assert(err, Equals, pktline.ErrPayloadTooLong, comment)
+ }
+}
+
+func (s *SuiteEncoder) TestEncodeStrings(c *C) {
+ for i, test := range [...]struct {
+ input []string
+ expected []byte
+ }{
+ {
+ input: []string{
+ "hello\n",
+ },
+ expected: []byte("000ahello\n"),
+ }, {
+ input: []string{
+ "hello\n",
+ pktline.FlushString,
+ },
+ expected: []byte("000ahello\n0000"),
+ }, {
+ input: []string{
+ "hello\n",
+ "world!\n",
+ "foo",
+ },
+ expected: []byte("000ahello\n000bworld!\n0007foo"),
+ }, {
+ input: []string{
+ "hello\n",
+ pktline.FlushString,
+ "world!\n",
+ "foo",
+ pktline.FlushString,
+ },
+ expected: []byte("000ahello\n0000000bworld!\n0007foo0000"),
+ }, {
+ input: []string{
+ strings.Repeat("a", pktline.MaxPayloadSize),
+ },
+ expected: []byte(
+ "fff0" + strings.Repeat("a", pktline.MaxPayloadSize)),
+ }, {
+ input: []string{
+ strings.Repeat("a", pktline.MaxPayloadSize),
+ strings.Repeat("b", pktline.MaxPayloadSize),
+ },
+ expected: []byte(
+ "fff0" + strings.Repeat("a", pktline.MaxPayloadSize) +
+ "fff0" + strings.Repeat("b", pktline.MaxPayloadSize)),
+ },
+ } {
+ comment := Commentf("input %d = %v\n", i, test.input)
+
+ var buf bytes.Buffer
+ e := pktline.NewEncoder(&buf)
+
+ err := e.EncodeString(test.input...)
+ c.Assert(err, IsNil, comment)
+ c.Assert(buf.Bytes(), DeepEquals, test.expected, comment)
+ }
+}
+
+func (s *SuiteEncoder) TestEncodeStringErrPayloadTooLong(c *C) {
+ for i, input := range [...][]string{
+ []string{
+ strings.Repeat("a", pktline.MaxPayloadSize+1),
+ },
+ []string{
+ "hello world!",
+ strings.Repeat("a", pktline.MaxPayloadSize+1),
+ },
+ []string{
+ "hello world!",
+ strings.Repeat("a", pktline.MaxPayloadSize+1),
+ "foo",
+ },
+ } {
+ comment := Commentf("input %d = %v\n", i, input)
+
+ var buf bytes.Buffer
+ e := pktline.NewEncoder(&buf)
+
+ err := e.EncodeString(input...)
+ c.Assert(err, Equals, pktline.ErrPayloadTooLong, comment)
+ }
+}
+
+func (s *SuiteEncoder) TestEncodef(c *C) {
+ format := " %s %d\n"
+ str := "foo"
+ d := 42
+
+ var buf bytes.Buffer
+ e := pktline.NewEncoder(&buf)
+
+ err := e.Encodef(format, str, d)
+ c.Assert(err, IsNil)
+
+ expected := []byte("000c foo 42\n")
+ c.Assert(buf.Bytes(), DeepEquals, expected)
+}
+
+func ExampleEncoder() {
+ // Create an encoder that writes pktlines to stdout.
+ e := pktline.NewEncoder(os.Stdout)
+
+ // Encode some data as a new pkt-line.
+ _ = e.Encode([]byte("data\n")) // error checks removed for brevity
+
+ // Encode a flush-pkt.
+ _ = e.Flush()
+
+ // Encode a couple of byte slices and a flush in one go. Each of
+ // them will end up as payloads of their own pktlines.
+ _ = e.Encode(
+ []byte("hello\n"),
+ []byte("world!\n"),
+ pktline.Flush,
+ )
+
+ // You can also encode strings:
+ _ = e.EncodeString(
+ "foo\n",
+ "bar\n",
+ pktline.FlushString,
+ )
+
+ // You can also format and encode a payload:
+ _ = e.Encodef(" %s %d\n", "foo", 42)
+ // Output:
+ // 0009data
+ // 0000000ahello
+ // 000bworld!
+ // 00000008foo
+ // 0008bar
+ // 0000000c foo 42
+}
diff --git a/formats/packp/pktline/pktlines.go b/formats/packp/pktline/pktlines.go
deleted file mode 100644
index c19aa2e..0000000
--- a/formats/packp/pktline/pktlines.go
+++ /dev/null
@@ -1,140 +0,0 @@
-// Package pktline implements reading payloads form pkt-lines and creating pkt-lines from payloads.
-package pktline
-
-import (
- "bytes"
- "errors"
- "io"
- "strings"
-)
-
-const (
- // MaxPayloadSize is the maximum payload size of a pkt-line in bytes.
- MaxPayloadSize = 65516
-)
-
-var (
- flush = []byte{'0', '0', '0', '0'}
-)
-
-// PktLines values represent a succession of pkt-lines. Values from
-// this type are not zero-value safe, use the New function instead.
-type PktLines struct {
- r io.Reader
-}
-
-var (
- // ErrPayloadTooLong is returned by the Add methods when any of the
- // provided payloads is bigger than MaxPayloadSize.
- ErrPayloadTooLong = errors.New("payload is too long")
- // ErrEmptyPayload is returned by the Add methods when an empty
- // payload is provided.
- ErrEmptyPayload = errors.New("cannot add empty payloads")
-)
-
-// New returns an empty PktLines (with no payloads) ready to be used.
-func New() *PktLines {
- return &PktLines{
- r: bytes.NewReader(nil),
- }
-}
-
-// AddFlush adds a flush-pkt to p.
-func (p *PktLines) AddFlush() {
- p.r = io.MultiReader(p.r, bytes.NewReader(flush))
-}
-
-// Add adds the slices in pp as the payloads of a
-// corresponding number of pktlines.
-func (p *PktLines) Add(pp ...[]byte) error {
- tmp := []io.Reader{p.r}
- for _, p := range pp {
- if err := add(&tmp, p); err != nil {
- return err
- }
- }
- p.r = io.MultiReader(tmp...)
-
- return nil
-}
-
-func add(dst *[]io.Reader, e []byte) error {
- if err := checkPayloadLength(len(e)); err != nil {
- return err
- }
-
- n := len(e) + 4
- *dst = append(*dst, bytes.NewReader(asciiHex16(n)))
- *dst = append(*dst, bytes.NewReader(e))
-
- return nil
-}
-
-func checkPayloadLength(n int) error {
- switch {
- case n < 0:
- panic("unexpected negative payload length")
- case n == 0:
- return ErrEmptyPayload
- case n > MaxPayloadSize:
- return ErrPayloadTooLong
- default:
- return nil
- }
-}
-
-// Returns the hexadecimal ascii representation of the 16 less
-// significant bits of n. The length of the returned slice will always
-// be 4. Example: if n is 1234 (0x4d2), the return value will be
-// []byte{'0', '4', 'd', '2'}.
-func asciiHex16(n int) []byte {
- var ret [4]byte
- ret[0] = byteToASCIIHex(byte(n & 0xf000 >> 12))
- ret[1] = byteToASCIIHex(byte(n & 0x0f00 >> 8))
- ret[2] = byteToASCIIHex(byte(n & 0x00f0 >> 4))
- ret[3] = byteToASCIIHex(byte(n & 0x000f))
-
- return ret[:]
-}
-
-// turns a byte into its hexadecimal ascii representation. Example:
-// from 11 (0xb) to 'b'.
-func byteToASCIIHex(n byte) byte {
- if n < 10 {
- return '0' + n
- }
-
- return 'a' - 10 + n
-}
-
-// AddString adds the strings in pp as payloads of a
-// corresponding number of pktlines.
-func (p *PktLines) AddString(pp ...string) error {
- tmp := []io.Reader{p.r}
- for _, p := range pp {
- if err := addString(&tmp, p); err != nil {
- return err
- }
- }
-
- p.r = io.MultiReader(tmp...)
-
- return nil
-}
-
-func addString(dst *[]io.Reader, s string) error {
- if err := checkPayloadLength(len(s)); err != nil {
- return err
- }
-
- n := len(s) + 4
- *dst = append(*dst, bytes.NewReader(asciiHex16(n)))
- *dst = append(*dst, strings.NewReader(s))
-
- return nil
-}
-
-// Read reads the pktlines for the payloads added so far.
-func (p *PktLines) Read(b []byte) (n int, err error) {
- return p.r.Read(b)
-}
diff --git a/formats/packp/pktline/pktlines_test.go b/formats/packp/pktline/pktlines_test.go
deleted file mode 100644
index e0ba16b..0000000
--- a/formats/packp/pktline/pktlines_test.go
+++ /dev/null
@@ -1,231 +0,0 @@
-package pktline_test
-
-import (
- "io"
- "io/ioutil"
- "os"
- "strings"
- "testing"
-
- "gopkg.in/src-d/go-git.v4/formats/packp/pktline"
-
- . "gopkg.in/check.v1"
-)
-
-func Test(t *testing.T) { TestingT(t) }
-
-type SuitePktLine struct {
-}
-
-var _ = Suite(&SuitePktLine{})
-
-func (s *SuitePktLine) TestNewIsEmpty(c *C) {
- p := pktline.New()
-
- b, err := ioutil.ReadAll(p)
- c.Assert(err, IsNil)
- c.Assert(b, DeepEquals, []byte{})
-}
-
-func (s *SuitePktLine) TestAddFlush(c *C) {
- p := pktline.New()
- p.AddFlush()
-
- b, err := ioutil.ReadAll(p)
- c.Assert(err, IsNil)
- c.Assert(string(b), DeepEquals, "0000")
-}
-
-func (s *SuitePktLine) TestAdd(c *C) {
- for i, test := range [...]struct {
- input [][]byte
- expected []byte
- }{
- {
- input: [][]byte{
- []byte("hello\n"),
- },
- expected: []byte("000ahello\n"),
- }, {
- input: [][]byte{
- []byte("hello\n"),
- []byte("world!\n"),
- []byte("foo"),
- },
- expected: []byte("000ahello\n000bworld!\n0007foo"),
- }, {
- input: [][]byte{
- []byte(strings.Repeat("a", pktline.MaxPayloadSize)),
- },
- expected: []byte(
- "fff0" + strings.Repeat("a", pktline.MaxPayloadSize)),
- }, {
- input: [][]byte{
- []byte(strings.Repeat("a", pktline.MaxPayloadSize)),
- []byte(strings.Repeat("b", pktline.MaxPayloadSize)),
- },
- expected: []byte(
- "fff0" + strings.Repeat("a", pktline.MaxPayloadSize) +
- "fff0" + strings.Repeat("b", pktline.MaxPayloadSize)),
- },
- } {
- p := pktline.New()
- err := p.Add(test.input...)
- c.Assert(err, IsNil, Commentf("input %d = %v", i, test.input))
-
- obtained, err := ioutil.ReadAll(p)
- c.Assert(err, IsNil, Commentf("input %d = %v", i, test.input))
-
- c.Assert(obtained, DeepEquals, test.expected,
- Commentf("input %d = %v", i, test.input))
- }
-}
-
-func (s *SuitePktLine) TestAddErrEmptyPayload(c *C) {
- for _, input := range [...][][]byte{
- [][]byte{
- []byte{},
- },
- [][]byte{
- []byte(nil),
- },
- [][]byte{
- []byte("hello world!"),
- []byte{},
- },
- [][]byte{
- []byte{},
- []byte("hello world!"),
- },
- } {
- p := pktline.New()
- err := p.Add(input...)
- c.Assert(err, Equals, pktline.ErrEmptyPayload)
- }
-}
-
-func (s *SuitePktLine) TestAddErrPayloadTooLong(c *C) {
- for _, input := range [...][][]byte{
- [][]byte{
- []byte(strings.Repeat("a", pktline.MaxPayloadSize+1)),
- },
- [][]byte{
- []byte("hello world!"),
- []byte(strings.Repeat("a", pktline.MaxPayloadSize+1)),
- },
- [][]byte{
- []byte("hello world!"),
- []byte(strings.Repeat("a", pktline.MaxPayloadSize+1)),
- []byte("foo"),
- },
- } {
- p := pktline.New()
- err := p.Add(input...)
- c.Assert(err, Equals, pktline.ErrPayloadTooLong,
- Commentf("%v\n", input))
- }
-}
-
-func (s *SuitePktLine) TestAddString(c *C) {
- for i, test := range [...]struct {
- input []string
- expected []byte
- }{
- {
- input: []string{
- "hello\n",
- },
- expected: []byte("000ahello\n"),
- }, {
- input: []string{
- "hello\n",
- "world!\n",
- "foo",
- },
- expected: []byte("000ahello\n000bworld!\n0007foo"),
- }, {
- input: []string{
- strings.Repeat("a", pktline.MaxPayloadSize),
- },
- expected: []byte(
- "fff0" + strings.Repeat("a", pktline.MaxPayloadSize)),
- }, {
- input: []string{
- strings.Repeat("a", pktline.MaxPayloadSize),
- strings.Repeat("b", pktline.MaxPayloadSize),
- },
- expected: []byte(
- "fff0" + strings.Repeat("a", pktline.MaxPayloadSize) +
- "fff0" + strings.Repeat("b", pktline.MaxPayloadSize)),
- },
- } {
- p := pktline.New()
- err := p.AddString(test.input...)
- c.Assert(err, IsNil, Commentf("input %d = %v", i, test.input))
-
- obtained, err := ioutil.ReadAll(p)
- c.Assert(err, IsNil, Commentf("input %d = %v", i, test.input))
-
- c.Assert(obtained, DeepEquals, test.expected,
- Commentf("input %d = %v", i, test.input))
- }
-}
-
-func (s *SuitePktLine) TestAddStringErrEmptyPayload(c *C) {
- for _, input := range [...][]string{
- []string{""},
- []string{"hello world!", ""},
- []string{"", "hello world!"},
- } {
- p := pktline.New()
- err := p.AddString(input...)
- c.Assert(err, Equals, pktline.ErrEmptyPayload)
- }
-}
-
-func (s *SuitePktLine) TestAddStringErrPayloadTooLong(c *C) {
- for _, input := range [...][]string{
- []string{
- strings.Repeat("a", pktline.MaxPayloadSize+1),
- },
- []string{
- "hello world!",
- strings.Repeat("a", pktline.MaxPayloadSize+1),
- },
- []string{
- "hello world!",
- strings.Repeat("a", pktline.MaxPayloadSize+1),
- "foo",
- },
- } {
- p := pktline.New()
- err := p.AddString(input...)
- c.Assert(err, Equals, pktline.ErrPayloadTooLong,
- Commentf("%v\n", input))
- }
-}
-
-func ExamplePktLines() {
- // Create an empty collection of pktlines.
- p := pktline.New()
-
- // Add two strings as payloads ("foo\n" and "bar\n"), they will
- // end up as two consecutive pktlines.
- p.AddString("foo\n", "bar\n") // error checks removed for brevity
-
- // You can also add byte slices as payloads...
- p.Add([]byte("hello\n"), []byte("world!\n"))
-
- // Add a flush-pkt.
- p.AddFlush()
-
- // PktLines are Readers, so you can directly read the full sequence.
- io.Copy(os.Stdout, p)
-
- // Output:
- // 0008foo
- // 0008bar
- // 000ahello
- // 000bworld!
- // 0000
-}
diff --git a/formats/packp/pktline/scanner_test.go b/formats/packp/pktline/scanner_test.go
index de0f8df..b5a3c7d 100644
--- a/formats/packp/pktline/scanner_test.go
+++ b/formats/packp/pktline/scanner_test.go
@@ -1,6 +1,7 @@
package pktline_test
import (
+ "bytes"
"fmt"
"io"
"strings"
@@ -41,11 +42,14 @@ func (s *SuiteScanner) TestEmptyReader(c *C) {
}
func (s *SuiteScanner) TestFlush(c *C) {
- p := pktline.New()
- p.AddFlush()
- sc := pktline.NewScanner(p)
+ var buf bytes.Buffer
+ e := pktline.NewEncoder(&buf)
+ err := e.Flush()
+ c.Assert(err, IsNil)
+ sc := pktline.NewScanner(&buf)
c.Assert(sc.Scan(), Equals, true)
+
payload := sc.Bytes()
c.Assert(len(payload), Equals, 0)
}
@@ -70,14 +74,16 @@ func (s *SuiteScanner) TestScanAndPayload(c *C) {
strings.Repeat("a", pktline.MaxPayloadSize),
strings.Repeat("a", pktline.MaxPayloadSize-1) + "\n",
} {
- p := pktline.New()
- err := p.AddString(test)
+ var buf bytes.Buffer
+ e := pktline.NewEncoder(&buf)
+ err := e.EncodeString(test)
c.Assert(err, IsNil,
Commentf("input len=%x, contents=%.10q\n", len(test), test))
- sc := pktline.NewScanner(p)
+ sc := pktline.NewScanner(&buf)
c.Assert(sc.Scan(), Equals, true,
Commentf("test = %.20q...", test))
+
obtained := sc.Bytes()
c.Assert(obtained, DeepEquals, []byte(test),
Commentf("in = %.20q out = %.20q", test, string(obtained)))
@@ -107,16 +113,19 @@ func (s *SuiteScanner) TestSkip(c *C) {
expected: []byte("third"),
},
} {
- p := pktline.New()
- err := p.AddString(test.input...)
+ var buf bytes.Buffer
+ e := pktline.NewEncoder(&buf)
+ err := e.EncodeString(test.input...)
c.Assert(err, IsNil)
- sc := pktline.NewScanner(p)
+
+ sc := pktline.NewScanner(&buf)
for i := 0; i < test.n; i++ {
c.Assert(sc.Scan(), Equals, true,
Commentf("scan error = %s", sc.Err()))
}
c.Assert(sc.Scan(), Equals, true,
Commentf("scan error = %s", sc.Err()))
+
obtained := sc.Bytes()
c.Assert(obtained, DeepEquals, test.expected,
Commentf("\nin = %.20q\nout = %.20q\nexp = %.20q",
@@ -125,10 +134,12 @@ func (s *SuiteScanner) TestSkip(c *C) {
}
func (s *SuiteScanner) TestEOF(c *C) {
- p := pktline.New()
- err := p.AddString("first", "second")
+ var buf bytes.Buffer
+ e := pktline.NewEncoder(&buf)
+ err := e.EncodeString("first", "second")
c.Assert(err, IsNil)
- sc := pktline.NewScanner(p)
+
+ sc := pktline.NewScanner(&buf)
for sc.Scan() {
}
c.Assert(sc.Err(), IsNil)
@@ -164,19 +175,22 @@ func (s *SuiteScanner) TestReadSomeSections(c *C) {
// 0000
// and so on
func sectionsExample(c *C, nSections, nLines int) io.Reader {
- p := pktline.New()
+ var buf bytes.Buffer
+ e := pktline.NewEncoder(&buf)
+
for section := 0; section < nSections; section++ {
ss := []string{}
for line := 0; line < nLines; line++ {
line := fmt.Sprintf(" %d.%d\n", section, line)
ss = append(ss, line)
}
- err := p.AddString(ss...)
+ err := e.EncodeString(ss...)
+ c.Assert(err, IsNil)
+ err = e.Flush()
c.Assert(err, IsNil)
- p.AddFlush()
}
- return p
+ return &buf
}
func ExampleScanner() {
generated by cgit (git 2.34.1) at 2024-09-21 11:37:15 +0000