func (s *SuiteScanner) TestEmptyReader(c *C) { r := strings.NewReader("") sc := pktline.NewScanner(r) hasPayload := sc.Scan() c.Assert(hasPayload, Equals, false) c.Assert(sc.Err(), Equals, nil) }
func (s *SuiteScanner) TestScanAndPayload(c *C) { for _, test := range [...]string{ "a", "a\n", strings.Repeat("a", 100), strings.Repeat("a", 100) + "\n", strings.Repeat("\x00", 100), strings.Repeat("\x00", 100) + "\n", strings.Repeat("a", pktline.MaxPayloadSize), strings.Repeat("a", pktline.MaxPayloadSize-1) + "\n", } { 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(&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))) } }
func ExampleScanner() { // A reader is needed as input. input := strings.NewReader("000ahello\n" + "000bworld!\n" + "0000", ) // Create the scanner... s := pktline.NewScanner(input) // and scan every pkt-line found in the input. for s.Scan() { payload := s.Bytes() if len(payload) == 0 { // zero sized payloads correspond to flush-pkts. fmt.Println("FLUSH-PKT DETECTED\n") } else { // otherwise, you will be able to access the full payload. fmt.Printf("PAYLOAD = %q\n", string(payload)) } } // this will catch any error when reading from the input, if any. if s.Err() != nil { fmt.Println(s.Err()) } // Output: // PAYLOAD = "hello\n" // PAYLOAD = "world!\n" // FLUSH-PKT DETECTED }
func (s *SuiteScanner) TestPktLineTooShort(c *C) { r := strings.NewReader("010cfoobar") sc := pktline.NewScanner(r) c.Assert(sc.Scan(), Equals, false) c.Assert(sc.Err(), ErrorMatches, "unexpected EOF") }
func discardResponseInfo(r io.Reader) error { s := pktline.NewScanner(r) for s.Scan() { if bytes.Equal(s.Bytes(), []byte{'N', 'A', 'K', '\n'}) { break } } return s.Err() }
func (s *SuiteScanner) TestEOF(c *C) { var buf bytes.Buffer e := pktline.NewEncoder(&buf) err := e.EncodeString("first", "second") c.Assert(err, IsNil) sc := pktline.NewScanner(&buf) for sc.Scan() { } c.Assert(sc.Err(), IsNil) }
func (s *SuiteScanner) TestFlush(c *C) { 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) }
func (s *SuiteScanner) TestInvalid(c *C) { for _, test := range [...]string{ "0001", "0002", "0003", "0004", "0001asdfsadf", "0004foo", "fff1", "fff2", "gorka", "0", "003", " 5a", "5 a", "5 \n", "-001", "-000", } { r := strings.NewReader(test) sc := pktline.NewScanner(r) _ = sc.Scan() c.Assert(sc.Err(), ErrorMatches, pktline.ErrInvalidPktLen.Error(), Commentf("data = %q", test)) } }
// A section are several non flush-pkt lines followed by a flush-pkt, which // how the git protocol sends long messages. func (s *SuiteScanner) TestReadSomeSections(c *C) { nSections := 2 nLines := 4 data := sectionsExample(c, nSections, nLines) sc := pktline.NewScanner(data) sectionCounter := 0 lineCounter := 0 for sc.Scan() { if len(sc.Bytes()) == 0 { sectionCounter++ } lineCounter++ } c.Assert(sc.Err(), IsNil) c.Assert(sectionCounter, Equals, nSections) c.Assert(lineCounter, Equals, (1+nLines)*nSections) }
func (s *SuiteScanner) TestSkip(c *C) { for _, test := range [...]struct { input []string n int expected []byte }{ { input: []string{ "first", "second", "third"}, n: 1, expected: []byte("second"), }, { input: []string{ "first", "second", "third"}, n: 2, expected: []byte("third"), }, } { var buf bytes.Buffer e := pktline.NewEncoder(&buf) err := e.EncodeString(test.input...) c.Assert(err, IsNil) 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", test.input, obtained, test.expected)) } }
// NewDecoder returns a new decoder that reads from r. // // Will not read more data from r than necessary. func NewDecoder(r io.Reader) *Decoder { return &Decoder{ s: pktline.NewScanner(r), } }