aboutsummaryrefslogblamecommitdiffstats
path: root/plumbing/protocol/packp/advrefs_decode_test.go
blob: 2b3da72e5be75ebec26da536146533e636d57b33 (plain) (tree)
1
2
3
4
5
6
7
8
9
             





                 
                                           
                                                          



                             
                                
 
                                    
 

                                              
                            
                                    

                           
                                              

 

                                                   



                                     
                                    

                           
                                              

 

                                                         





                                                   
                                    

                           
                                              

 
                                                     




                                    
                                                      

 

                                                                                             
                                     




                                            
                                                         




                                                                                         
                                                           

 
                                               



                                                                                                    
                                         


                                
                                                                             




                                          
                          
                                    






                            
                                                        




                                                                                          
                                                                

 
                                                    




                                                                  
                                                                

 
                                             



                                                                    
                                         
                                  
                                                                             

 
                                                       



                                                                                 
                                         

                                                            
                                                                             

 
                                                 




                                                             
                                                        

 
                                               




                                                                                   
                                                             

 
                                                         




                                                                    
                                                                  

 
                                               



                                                                    
                                         


                                                         
                                             

                                          
                                         





                                                                                    
                                                     





                                                                                      
                                                     





                                                                                             
                                                   










                                                                                                       
                                                   








                                                                                                         
                                                   








                                                                                                                                 
                                                   








                                                                                                                                                 
                                                   




                                                                                             
                                                   








                                                                                                    
                                                   




                                                                         
                                         



                                                                        
                                                           





                                                                         
                                         




                                                                        
                                                  

                                          

                                                   





                                                                                                                              

                                                                   





                                                                                                                              

                                                                                                        
                          
                                                               





                                                                                                                              

                                                                                                        
                          
                                                               






                                                                                                                              


                                                                                                        
                          
                                                               





                                                                                                                              


                                                                                                        







                                                                                                                              

                                                                                                        
                          

                                                                                                        














                                                                                                                              







                                                                                                                       
                          


                                                                                                                       


                          
                                                   





                                                                             
                                                                  





                                                                                         
                                                                 

 
                                                                         





                                                                                         
                                                                 

 
                                                

                                          
                                        








                                                                                                                              
                                                    








                                                                                                                              
                                                                                                                









                                                                                                                              


                                                                                             


                          
                                                   




                                                                         
                                                           









                                                                                                              
                                                                

 
                                                            










                                                                                                              
                                                                       

 
                                                             









                                                                                                              
                                                                     

 
                                                




                                                                                                                   
                                                                  

 
                                                    






                                                                                                                   
                                                                 
 
package packp

import (
	"bytes"
	"io"
	"strings"

	"gopkg.in/src-d/go-git.v4/plumbing"
	"gopkg.in/src-d/go-git.v4/plumbing/format/pktline"

	. "gopkg.in/check.v1"
)

type AdvRefsDecodeSuite struct{}

var _ = Suite(&AdvRefsDecodeSuite{})

func (s *AdvRefsDecodeSuite) TestEmpty(c *C) {
	ar := NewAdvRefs()
	var buf bytes.Buffer
	d := newAdvRefsDecoder(&buf)

	err := d.Decode(ar)
	c.Assert(err, Equals, ErrEmptyAdvRefs)
}

func (s *AdvRefsDecodeSuite) TestEmptyFlush(c *C) {
	ar := NewAdvRefs()
	var buf bytes.Buffer
	e := pktline.NewEncoder(&buf)
	e.Flush()

	d := newAdvRefsDecoder(&buf)

	err := d.Decode(ar)
	c.Assert(err, Equals, ErrEmptyAdvRefs)
}

func (s *AdvRefsDecodeSuite) TestEmptyPrefixFlush(c *C) {
	ar := NewAdvRefs()
	var buf bytes.Buffer
	e := pktline.NewEncoder(&buf)
	e.EncodeString("# service=git-upload-pack")
	e.Flush()
	e.Flush()

	d := newAdvRefsDecoder(&buf)

	err := d.Decode(ar)
	c.Assert(err, Equals, ErrEmptyAdvRefs)
}

func (s *AdvRefsDecodeSuite) TestShortForHash(c *C) {
	payloads := []string{
		"6ecf0ef2c2dffb796",
		pktline.FlushString,
	}
	r := toPktLines(c, payloads)
	s.testDecoderErrorMatches(c, r, ".*too short")
}

func (s *AdvRefsDecodeSuite) testDecoderErrorMatches(c *C, input io.Reader, pattern string) {
	ar := NewAdvRefs()
	d := newAdvRefsDecoder(input)

	err := d.Decode(ar)
	c.Assert(err, ErrorMatches, pattern)
}

func (s *AdvRefsDecodeSuite) TestInvalidFirstHash(c *C) {
	payloads := []string{
		"6ecf0ef2c2dffb796alberto2219af86ec6584e5 HEAD\x00multi_ack thin-pack\n",
		pktline.FlushString,
	}
	r := toPktLines(c, payloads)
	s.testDecoderErrorMatches(c, r, ".*invalid hash.*")
}

func (s *AdvRefsDecodeSuite) TestZeroId(c *C) {
	payloads := []string{
		"0000000000000000000000000000000000000000 capabilities^{}\x00multi_ack thin-pack\n",
		pktline.FlushString,
	}
	ar := s.testDecodeOK(c, payloads)
	c.Assert(ar.Head, IsNil)
}

func (s *AdvRefsDecodeSuite) testDecodeOK(c *C, payloads []string) *AdvRefs {
	var buf bytes.Buffer
	e := pktline.NewEncoder(&buf)
	err := e.EncodeString(payloads...)
	c.Assert(err, IsNil)

	ar := NewAdvRefs()
	d := newAdvRefsDecoder(&buf)

	err = d.Decode(ar)
	c.Assert(err, IsNil)

	return ar
}

func (s *AdvRefsDecodeSuite) TestMalformedZeroId(c *C) {
	payloads := []string{
		"0000000000000000000000000000000000000000 wrong\x00multi_ack thin-pack\n",
		pktline.FlushString,
	}
	r := toPktLines(c, payloads)
	s.testDecoderErrorMatches(c, r, ".*malformed zero-id.*")
}

func (s *AdvRefsDecodeSuite) TestShortZeroId(c *C) {
	payloads := []string{
		"0000000000000000000000000000000000000000 capabi",
		pktline.FlushString,
	}
	r := toPktLines(c, payloads)
	s.testDecoderErrorMatches(c, r, ".*too short zero-id.*")
}

func (s *AdvRefsDecodeSuite) TestHead(c *C) {
	payloads := []string{
		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00",
		pktline.FlushString,
	}
	ar := s.testDecodeOK(c, payloads)
	c.Assert(*ar.Head, Equals,
		plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
}

func (s *AdvRefsDecodeSuite) TestFirstIsNotHead(c *C) {
	payloads := []string{
		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/heads/master\x00",
		pktline.FlushString,
	}
	ar := s.testDecodeOK(c, payloads)
	c.Assert(ar.Head, IsNil)
	c.Assert(ar.References["refs/heads/master"], Equals,
		plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
}

func (s *AdvRefsDecodeSuite) TestShortRef(c *C) {
	payloads := []string{
		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 H",
		pktline.FlushString,
	}
	r := toPktLines(c, payloads)
	s.testDecoderErrorMatches(c, r, ".*too short.*")
}

func (s *AdvRefsDecodeSuite) TestNoNULL(c *C) {
	payloads := []string{
		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEADofs-delta multi_ack",
		pktline.FlushString,
	}
	r := toPktLines(c, payloads)
	s.testDecoderErrorMatches(c, r, ".*NULL not found.*")
}

func (s *AdvRefsDecodeSuite) TestNoSpaceAfterHash(c *C) {
	payloads := []string{
		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5-HEAD\x00",
		pktline.FlushString,
	}
	r := toPktLines(c, payloads)
	s.testDecoderErrorMatches(c, r, ".*no space after hash.*")
}

func (s *AdvRefsDecodeSuite) TestNoCaps(c *C) {
	payloads := []string{
		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00",
		pktline.FlushString,
	}
	ar := s.testDecodeOK(c, payloads)
	c.Assert(ar.Capabilities.IsEmpty(), Equals, true)
}

func (s *AdvRefsDecodeSuite) TestCaps(c *C) {
	for _, test := range [...]struct {
		input        []string
		capabilities []Capability
	}{
		{
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00",
				pktline.FlushString,
			},
			capabilities: []Capability{},
		},
		{
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00\n",
				pktline.FlushString,
			},
			capabilities: []Capability{},
		},
		{
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta",
				pktline.FlushString,
			},
			capabilities: []Capability{
				{
					Name:   "ofs-delta",
					Values: []string(nil),
				},
			},
		},
		{
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta multi_ack",
				pktline.FlushString,
			},
			capabilities: []Capability{
				{Name: "ofs-delta", Values: []string(nil)},
				{Name: "multi_ack", Values: []string(nil)},
			},
		},
		{
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta multi_ack\n",
				pktline.FlushString,
			},
			capabilities: []Capability{
				{Name: "ofs-delta", Values: []string(nil)},
				{Name: "multi_ack", Values: []string(nil)},
			},
		},
		{
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:refs/heads/master agent=foo=bar\n",
				pktline.FlushString,
			},
			capabilities: []Capability{
				{Name: "symref", Values: []string{"HEAD:refs/heads/master"}},
				{Name: "agent", Values: []string{"foo=bar"}},
			},
		},
		{
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:refs/heads/master agent=foo=bar agent=new-agent\n",
				pktline.FlushString,
			},
			capabilities: []Capability{
				{Name: "symref", Values: []string{"HEAD:refs/heads/master"}},
				{Name: "agent", Values: []string{"foo=bar", "new-agent"}},
			},
		},
	} {
		ar := s.testDecodeOK(c, test.input)
		for _, fixCap := range test.capabilities {
			c.Assert(ar.Capabilities.Supports(fixCap.Name), Equals, true,
				Commentf("input = %q, capability = %q", test.input, fixCap.Name))
			c.Assert(ar.Capabilities.Get(fixCap.Name).Values, DeepEquals, fixCap.Values,
				Commentf("input = %q, capability = %q", test.input, fixCap.Name))
		}
	}
}

func (s *AdvRefsDecodeSuite) TestWithPrefix(c *C) {
	payloads := []string{
		"# this is a prefix\n",
		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00foo\n",
		pktline.FlushString,
	}
	ar := s.testDecodeOK(c, payloads)
	c.Assert(len(ar.Prefix), Equals, 1)
	c.Assert(ar.Prefix[0], DeepEquals, []byte("# this is a prefix"))
}

func (s *AdvRefsDecodeSuite) TestWithPrefixAndFlush(c *C) {
	payloads := []string{
		"# this is a prefix\n",
		pktline.FlushString,
		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00foo\n",
		pktline.FlushString,
	}
	ar := s.testDecodeOK(c, payloads)
	c.Assert(len(ar.Prefix), Equals, 2)
	c.Assert(ar.Prefix[0], DeepEquals, []byte("# this is a prefix"))
	c.Assert(ar.Prefix[1], DeepEquals, []byte(pktline.FlushString))
}

func (s *AdvRefsDecodeSuite) TestOtherRefs(c *C) {
	for _, test := range [...]struct {
		input      []string
		references map[string]plumbing.Hash
		peeled     map[string]plumbing.Hash
	}{
		{
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
				pktline.FlushString,
			},
			references: make(map[string]plumbing.Hash),
			peeled:     make(map[string]plumbing.Hash),
		}, {
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
				"1111111111111111111111111111111111111111 ref/foo",
				pktline.FlushString,
			},
			references: map[string]plumbing.Hash{
				"ref/foo": plumbing.NewHash("1111111111111111111111111111111111111111"),
			},
			peeled: make(map[string]plumbing.Hash),
		}, {
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
				"1111111111111111111111111111111111111111 ref/foo\n",
				pktline.FlushString,
			},
			references: map[string]plumbing.Hash{
				"ref/foo": plumbing.NewHash("1111111111111111111111111111111111111111"),
			},
			peeled: make(map[string]plumbing.Hash),
		}, {
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
				"1111111111111111111111111111111111111111 ref/foo\n",
				"2222222222222222222222222222222222222222 ref/bar",
				pktline.FlushString,
			},
			references: map[string]plumbing.Hash{
				"ref/foo": plumbing.NewHash("1111111111111111111111111111111111111111"),
				"ref/bar": plumbing.NewHash("2222222222222222222222222222222222222222"),
			},
			peeled: make(map[string]plumbing.Hash),
		}, {
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
				"1111111111111111111111111111111111111111 ref/foo^{}\n",
				pktline.FlushString,
			},
			references: make(map[string]plumbing.Hash),
			peeled: map[string]plumbing.Hash{
				"ref/foo": plumbing.NewHash("1111111111111111111111111111111111111111"),
			},
		}, {
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
				"1111111111111111111111111111111111111111 ref/foo\n",
				"2222222222222222222222222222222222222222 ref/bar^{}",
				pktline.FlushString,
			},
			references: map[string]plumbing.Hash{
				"ref/foo": plumbing.NewHash("1111111111111111111111111111111111111111"),
			},
			peeled: map[string]plumbing.Hash{
				"ref/bar": plumbing.NewHash("2222222222222222222222222222222222222222"),
			},
		}, {
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
				"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
				"51b8b4fb32271d39fbdd760397406177b2b0fd36 refs/pull/10/head\n",
				"02b5a6031ba7a8cbfde5d65ff9e13ecdbc4a92ca refs/pull/100/head\n",
				"c284c212704c43659bf5913656b8b28e32da1621 refs/pull/100/merge\n",
				"3d6537dce68c8b7874333a1720958bd8db3ae8ca refs/pull/101/merge\n",
				"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11\n",
				"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}\n",
				"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
				"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
				pktline.FlushString,
			},
			references: map[string]plumbing.Hash{
				"refs/heads/master":      plumbing.NewHash("a6930aaee06755d1bdcfd943fbf614e4d92bb0c7"),
				"refs/pull/10/head":      plumbing.NewHash("51b8b4fb32271d39fbdd760397406177b2b0fd36"),
				"refs/pull/100/head":     plumbing.NewHash("02b5a6031ba7a8cbfde5d65ff9e13ecdbc4a92ca"),
				"refs/pull/100/merge":    plumbing.NewHash("c284c212704c43659bf5913656b8b28e32da1621"),
				"refs/pull/101/merge":    plumbing.NewHash("3d6537dce68c8b7874333a1720958bd8db3ae8ca"),
				"refs/tags/v2.6.11":      plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c"),
				"refs/tags/v2.6.11-tree": plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c"),
			},
			peeled: map[string]plumbing.Hash{
				"refs/tags/v2.6.11":      plumbing.NewHash("c39ae07f393806ccf406ef966e9a15afc43cc36a"),
				"refs/tags/v2.6.11-tree": plumbing.NewHash("c39ae07f393806ccf406ef966e9a15afc43cc36a"),
			},
		},
	} {
		ar := s.testDecodeOK(c, test.input)
		comment := Commentf("input = %v\n", test.input)
		c.Assert(ar.References, DeepEquals, test.references, comment)
		c.Assert(ar.Peeled, DeepEquals, test.peeled, comment)
	}
}

func (s *AdvRefsDecodeSuite) TestMalformedOtherRefsNoSpace(c *C) {
	payloads := []string{
		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00multi_ack thin-pack\n",
		"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8crefs/tags/v2.6.11\n",
		pktline.FlushString,
	}
	r := toPktLines(c, payloads)
	s.testDecoderErrorMatches(c, r, ".*malformed ref data.*")
}

func (s *AdvRefsDecodeSuite) TestMalformedOtherRefsMultipleSpaces(c *C) {
	payloads := []string{
		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00multi_ack thin-pack\n",
		"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags v2.6.11\n",
		pktline.FlushString,
	}
	r := toPktLines(c, payloads)
	s.testDecoderErrorMatches(c, r, ".*malformed ref data.*")
}

func (s *AdvRefsDecodeSuite) TestShallow(c *C) {
	for _, test := range [...]struct {
		input    []string
		shallows []plumbing.Hash
	}{
		{
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
				"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
				"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
				"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
				pktline.FlushString,
			},
			shallows: []plumbing.Hash{},
		}, {
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
				"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
				"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
				"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
				"shallow 1111111111111111111111111111111111111111\n",
				pktline.FlushString,
			},
			shallows: []plumbing.Hash{plumbing.NewHash("1111111111111111111111111111111111111111")},
		}, {
			input: []string{
				"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
				"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
				"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
				"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
				"shallow 1111111111111111111111111111111111111111\n",
				"shallow 2222222222222222222222222222222222222222\n",
				pktline.FlushString,
			},
			shallows: []plumbing.Hash{
				plumbing.NewHash("1111111111111111111111111111111111111111"),
				plumbing.NewHash("2222222222222222222222222222222222222222"),
			},
		},
	} {
		ar := s.testDecodeOK(c, test.input)
		comment := Commentf("input = %v\n", test.input)
		c.Assert(ar.Shallows, DeepEquals, test.shallows, comment)
	}
}

func (s *AdvRefsDecodeSuite) TestInvalidShallowHash(c *C) {
	payloads := []string{
		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
		"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
		"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
		"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
		"shallow 11111111alcortes111111111111111111111111\n",
		"shallow 2222222222222222222222222222222222222222\n",
		pktline.FlushString,
	}
	r := toPktLines(c, payloads)
	s.testDecoderErrorMatches(c, r, ".*invalid hash text.*")
}

func (s *AdvRefsDecodeSuite) TestGarbageAfterShallow(c *C) {
	payloads := []string{
		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
		"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
		"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
		"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
		"shallow 1111111111111111111111111111111111111111\n",
		"shallow 2222222222222222222222222222222222222222\n",
		"b5be40b90dbaa6bd337f3b77de361bfc0723468b refs/tags/v4.4",
		pktline.FlushString,
	}
	r := toPktLines(c, payloads)
	s.testDecoderErrorMatches(c, r, ".*malformed shallow prefix.*")
}

func (s *AdvRefsDecodeSuite) TestMalformedShallowHash(c *C) {
	payloads := []string{
		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n",
		"a6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n",
		"5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n",
		"c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n",
		"shallow 1111111111111111111111111111111111111111\n",
		"shallow 2222222222222222222222222222222222222222 malformed\n",
		pktline.FlushString,
	}
	r := toPktLines(c, payloads)
	s.testDecoderErrorMatches(c, r, ".*malformed shallow hash.*")
}

func (s *AdvRefsDecodeSuite) TestEOFRefs(c *C) {
	input := strings.NewReader("" +
		"005b6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n" +
		"003fa6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n" +
		"00355dc01c595e6c6ec9ccda4f6ffbf614e4d92bb0c7 refs/foo\n",
	)
	s.testDecoderErrorMatches(c, input, ".*invalid pkt-len.*")
}

func (s *AdvRefsDecodeSuite) TestEOFShallows(c *C) {
	input := strings.NewReader("" +
		"005b6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00ofs-delta symref=HEAD:/refs/heads/master\n" +
		"003fa6930aaee06755d1bdcfd943fbf614e4d92bb0c7 refs/heads/master\n" +
		"00445dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11-tree\n" +
		"0047c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11-tree^{}\n" +
		"0035shallow 1111111111111111111111111111111111111111\n" +
		"0034shallow 222222222222222222222222")
	s.testDecoderErrorMatches(c, input, ".*unexpected EOF.*")
}