plumbing: packfile, Refactor Parser and Scanner logic The changes focus on increasing thread-safety, simplifying the code base, enabling support for sha256 and improving general time and space complexities.

Raw allocations for a packfile parse dropped on average 39%:

│ /tmp/before │ /tmp/after │
│ allocs/op │ allocs/op vs base │
Parse/https://github.com/git-fixtures/root-references.git-16 1.987k ± 0% 1.191k ± 0% -40.06% (p=0.000 n=10)
Parse/https://github.com/git-fixtures/basic.git-16 1034.0 ± 0% 613.0 ± 0% -40.72% (p=0.000 n=10)
Parse/https://github.com/git-fixtures/basic.git#01-16 941.0 ± 0% 576.0 ± 0% -38.79% (p=0.000 n=10)
Parse/https://github.com/git-fixtures/basic.git#02-16 880.0 ± 0% 547.0 ± 0% -37.84% (p=0.000 n=10)
Parse/https://github.com/src-d/go-git.git-16 124.06k ± 0% 67.12k ± 0% -45.90% (p=0.000 n=10)
Parse/https://github.com/git-fixtures/tags.git-16 212.0 ± 0% 155.0 ± 0% -26.89% (p=0.000 n=10)
Parse/https://github.com/spinnaker/spinnaker.git-16 195.6k ± 0% 106.8k ± 0% -45.41% (p=0.000 n=10)
Parse/https://github.com/jamesob/desk.git-16 22.52k ± 0% 12.20k ± 0% -45.82% (p=0.000 n=10)
Parse/https://github.com/cpcs499/Final_Pres_P.git-16 65.00 ± 0% 68.00 ± 0% +4.62% (p=0.000 n=10)
Parse/https://github.com/github/gem-builder.git-16 3.237k ± 0% 1.778k ± 0% -45.07% (p=0.000 n=10)
Parse/https://github.com/githubtraining/example-branches.git-16 871.0 ± 0% 529.0 ± 0% -39.27% (p=0.000 n=10)
Parse/https://github.com/rumpkernel/rumprun-xen.git-16 127.86k ± 0% 70.23k ± 0% -45.07% (p=0.000 n=10)
Parse/https://github.com/mcuadros/skeetr.git-16 9.334k ± 0% 5.317k ± 0% -43.04% (p=0.000 n=10)
Parse/https://github.com/dezfowler/LiteMock.git-16 1.892k ± 0% 1.134k ± 0% -40.06% (p=0.000 n=10)
Parse/https://github.com/tyba/storable.git-16 47.22k ± 0% 25.34k ± 0% -46.32% (p=0.000 n=10)
Parse/https://github.com/toqueteos/ts3.git-16 4.246k ± 0% 2.438k ± 0% -42.58% (p=0.000 n=10)

GetByOffset calls no longer create new allocations for cached operations:

│ /tmp/before │ /tmp/after │
│ B/op │ B/op vs base │
GetByOffset/with_storage-16 6.052µ ± 3% 3.887µ ± 2% -35.78% (p=0.000 n=10)
│ B/op │ B/op vs base │
GetByOffset/with_storage-16 384.0 ± 0% 0.0 ± 0% -100.00% (p=0.000 n=10)
│ allocs/op │ allocs/op vs base │
GetByOffset/with_storage-16 4.000 ± 0% 0.000 ± 0% -100.00% (p=0.000 n=10)

The test files modified as part of this commit started replacing the check.v1
test framework with stretchr/testify. That shall continue as other changes
take place.

Breaking Changes
- Removal of the concept of Large Object Threshold.
- Rename packfile.ObjectHeader from Length to Size.
- Both Parser and Scanner APIs have changed. They now rely on the
Functional Options pattern for increased extensibility.

Signed-off-by: Paulo Gomes <[e-mail]>

common_test.go

···
 // NewRepositoryWithEmptyWorktree returns a new repository using the .git folder
 // from the fixture but without a empty memfs worktree, the index and the
 // modules are deleted from the .git folder.
-func (s *BaseSuite) NewRepositoryWithEmptyWorktree(f *fixtures.Fixture) *Repository {
+func NewRepositoryWithEmptyWorktree(f *fixtures.Fixture) *Repository {
 	dotgit := f.DotGit()
 	err := dotgit.Remove("index")
 	if err != nil {
···
 	}
 
 	return r
-
 }
 
 func (s *BaseSuite) NewRepositoryFromPackfile(f *fixtures.Fixture) *Repository {

plumbing/format/idxfile/writer_test.go

···
 	scanner := packfile.NewScanner(f.Packfile())
 
 	obs := new(idxfile.Writer)
-	parser, err := packfile.NewParser(scanner, obs)
-	c.Assert(err, IsNil)
+	parser := packfile.NewParser(scanner, packfile.WithScannerObservers(obs))
 
-	_, err = parser.Parse()
+	_, err := parser.Parse()
 	c.Assert(err, IsNil)
 
 	idx, err := obs.Index()

plumbing/format/packfile/common.go

···
 
 	"github.com/go-git/go-git/v5/plumbing/storer"
 	"github.com/go-git/go-git/v5/utils/ioutil"
+	"github.com/go-git/go-git/v5/utils/sync"
 	"github.com/go-git/go-git/v5/utils/trace"
 )
 
···
 		return WritePackfileToObjectStorage(pw, packfile)
 	}
 
-	p, err := NewParserWithStorage(NewScanner(packfile), s)
-	if err != nil {
-		return err
-	}
+	p := NewParser(packfile, WithStorage(s))
 
-	_, err = p.Parse()
+	_, err := p.Parse()
 	return err
 }
 
···
 	}
 
 	defer ioutil.CheckClose(w, &err)
+	var n int64
 
-	var n int64
-	n, err = io.Copy(w, packfile)
+	buf := sync.GetByteSlice()
+	n, err = io.CopyBuffer(w, packfile, *buf)
+	sync.PutByteSlice(buf)
+
 	if err == nil && n == 0 {
 		return ErrEmptyPackfile
 	}

plumbing/format/packfile/common_test.go

···
 
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/storage/memory"
-
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/assert"
 )
 
-func Test(t *testing.T) { TestingT(t) }
-
-type CommonSuite struct{}
-
-var _ = Suite(&CommonSuite{})
-
-func (s *CommonSuite) TestEmptyUpdateObjectStorage(c *C) {
+func TestEmptyUpdateObjectStorage(t *testing.T) {
 	var buf bytes.Buffer
 	sto := memory.NewStorage()
 
 	err := UpdateObjectStorage(sto, &buf)
-	c.Assert(err, Equals, ErrEmptyPackfile)
+	assert.ErrorIs(t, err, ErrEmptyPackfile)
 }
 
 func newObject(t plumbing.ObjectType, cont []byte) plumbing.EncodedObject {

plumbing/format/packfile/encoder_advanced_test.go

···
 	c.Assert(err, IsNil)
 
 	w := new(idxfile.Writer)
-	parser, err := NewParser(NewScanner(f), w)
-	c.Assert(err, IsNil)
+	parser := NewParser(NewScanner(f), WithScannerObservers(w))
 
 	_, err = parser.Parse()
 	c.Assert(err, IsNil)
···
 	_, err = f.Seek(0, io.SeekStart)
 	c.Assert(err, IsNil)
 
-	p := NewPackfile(index, fs, f, 0)
+	p := NewPackfile(f, WithIdx(index), WithFs(fs))
 
 	decodeHash, err := p.ID()
 	c.Assert(err, IsNil)

plumbing/format/packfile/encoder_test.go

···
 	scanner := NewScanner(file)
 
 	w := new(idxfile.Writer)
-	p, err := NewParser(scanner, w)
-	c.Assert(err, IsNil)
+	p := NewParser(scanner, WithScannerObservers(w))
 
 	_, err = p.Parse()
 	c.Assert(err, IsNil)
···
 	index, err := w.Index()
 	c.Assert(err, IsNil)
 
-	return NewPackfile(index, fs, file, 0), func() {
+	return NewPackfile(file, WithIdx(index), WithFs(fs)), func() {
 		c.Assert(file.Close(), IsNil)
 	}
 }

plumbing/format/packfile/fsobject.go

···
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/cache"
 	"github.com/go-git/go-git/v5/plumbing/format/idxfile"
-	"github.com/go-git/go-git/v5/utils/ioutil"
+	"github.com/go-git/go-git/v5/utils/sync"
 )
 
 // FSObject is an object from the packfile on the filesystem.
 type FSObject struct {
-	hash                 plumbing.Hash
-	offset               int64
-	size                 int64
-	typ                  plumbing.ObjectType
-	index                idxfile.Index
-	fs                   billy.Filesystem
-	path                 string
-	cache                cache.Object
-	largeObjectThreshold int64
+	hash   plumbing.Hash
+	offset int64
+	size   int64
+	typ    plumbing.ObjectType
+	index  idxfile.Index
+	fs     billy.Filesystem
+	path   string
+	cache  cache.Object
 }
 
 // NewFSObject creates a new filesystem object.
···
 	fs billy.Filesystem,
 	path string,
 	cache cache.Object,
-	largeObjectThreshold int64,
 ) *FSObject {
 	return &FSObject{
-		hash:                 hash,
-		offset:               offset,
-		size:                 contentSize,
-		typ:                  finalType,
-		index:                index,
-		fs:                   fs,
-		path:                 path,
-		cache:                cache,
-		largeObjectThreshold: largeObjectThreshold,
+		hash:   hash,
+		offset: offset,
+		size:   contentSize,
+		typ:    finalType,
+		index:  index,
+		fs:     fs,
+		path:   path,
+		cache:  cache,
 	}
 }
 
···
 		return nil, err
 	}
 
-	p := NewPackfileWithCache(o.index, nil, f, o.cache, o.largeObjectThreshold)
-	if o.largeObjectThreshold > 0 && o.size > o.largeObjectThreshold {
-		// We have a big object
-		h, err := p.objectHeaderAtOffset(o.offset)
-		if err != nil {
-			return nil, err
-		}
-
-		r, err := p.getReaderDirect(h)
-		if err != nil {
-			_ = f.Close()
-			return nil, err
-		}
-		return ioutil.NewReadCloserWithCloser(r, f.Close), nil
-	}
-	r, err := p.getObjectContent(o.offset)
+	_, err = f.Seek(o.offset, io.SeekStart)
 	if err != nil {
-		_ = f.Close()
 		return nil, err
 	}
 
-	if err := f.Close(); err != nil {
+	dict := sync.GetByteSlice()
+	zr := sync.NewZlibReader(dict)
+	err = zr.Reset(f)
+	if err != nil {
 		return nil, err
 	}
+	return &zlibReadCloser{zr, dict}, nil
+}
 
-	return r, nil
+type zlibReadCloser struct {
+	r    sync.ZLibReader
+	dict *[]byte
+}
+
+// Read reads up to len(p) bytes into p from the data.
+func (r *zlibReadCloser) Read(p []byte) (int, error) {
+	return r.r.Reader.Read(p)
+}
+
+func (r *zlibReadCloser) Close() error {
+	sync.PutByteSlice(r.dict)
+	sync.PutZlibReader(r.r)
+	return nil
 }
 
 // SetSize implements the plumbing.EncodedObject interface. This method

plumbing/format/packfile/object_pack.go

···
 // ObjectToPack is a representation of an object that is going to be into a
 // pack file.
 type ObjectToPack struct {
-	// The main object to pack, it could be any object, including deltas
+	// The main object to pack, it could be any object, including deltas.
 	Object plumbing.EncodedObject
-	// Base is the object that a delta is based on (it could be also another delta).
-	// If the main object is not a delta, Base will be null
+	// Base is the object that a delta is based on, which could also be another delta.
+	// Nil when the main object is not a delta.
 	Base *ObjectToPack
 	// Original is the object that we can generate applying the delta to
 	// Base, or the same object as Object in the case of a non-delta

plumbing/format/packfile/packfile.go

···
 package packfile
 
 import (
-	"bytes"
 	"fmt"
 	"io"
 	"os"
+	"sync"
 
 	billy "github.com/go-git/go-billy/v5"
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/cache"
 	"github.com/go-git/go-git/v5/plumbing/format/idxfile"
 	"github.com/go-git/go-git/v5/plumbing/storer"
+	"github.com/go-git/go-git/v5/utils/binary"
 	"github.com/go-git/go-git/v5/utils/ioutil"
-	"github.com/go-git/go-git/v5/utils/sync"
 )
 
 var (
···
 	ErrZLib = NewError("zlib reading error")
 )
 
-// When reading small objects from packfile it is beneficial to do so at
-// once to exploit the buffered I/O. In many cases the objects are so small
-// that they were already loaded to memory when the object header was
-// loaded from the packfile. Wrapping in FSObject would cause this buffered
-// data to be thrown away and then re-read later, with the additional
-// seeking causing reloads from disk. Objects smaller than this threshold
-// are now always read into memory and stored in cache instead of being
-// wrapped in FSObject.
-const smallObjectThreshold = 16 * 1024
-
 // Packfile allows retrieving information from inside a packfile.
 type Packfile struct {
 	idxfile.Index
-	fs                   billy.Filesystem
-	file                 billy.File
-	s                    *Scanner
-	deltaBaseCache       cache.Object
-	offsetToType         map[int64]plumbing.ObjectType
-	largeObjectThreshold int64
+	fs      billy.Filesystem
+	file    billy.File
+	scanner *Scanner
+
+	cache cache.Object
+
+	id plumbing.Hash
+	m  sync.Mutex
+
+	once    sync.Once
+	onceErr error
 }
 
-// NewPackfileWithCache creates a new Packfile with the given object cache.
+// NewPackfile returns a packfile representation for the given packfile file
+// and packfile idx.
 // If the filesystem is provided, the packfile will return FSObjects, otherwise
 // it will return MemoryObjects.
-func NewPackfileWithCache(
-	index idxfile.Index,
-	fs billy.Filesystem,
+func NewPackfile(
 	file billy.File,
-	cache cache.Object,
-	largeObjectThreshold int64,
+	opts ...PackfileOption,
 ) *Packfile {
-	if index == nil {
-		index = idxfile.NewMemoryIndex()
+	p := &Packfile{
+		file: file,
 	}
-
-	s := NewScanner(file)
-	return &Packfile{
-		index,
-		fs,
-		file,
-		s,
-		cache,
-		make(map[int64]plumbing.ObjectType),
-		largeObjectThreshold,
+	for _, opt := range opts {
+		opt(p)
 	}
-}
 
-// NewPackfile returns a packfile representation for the given packfile file
-// and packfile idx.
-// If the filesystem is provided, the packfile will return FSObjects, otherwise
-// it will return MemoryObjects.
-func NewPackfile(index idxfile.Index, fs billy.Filesystem, file billy.File, largeObjectThreshold int64) *Packfile {
-	return NewPackfileWithCache(index, fs, file, cache.NewObjectLRUDefault(), largeObjectThreshold)
+	return p
 }
 
 // Get retrieves the encoded object in the packfile with the given hash.
 func (p *Packfile) Get(h plumbing.Hash) (plumbing.EncodedObject, error) {
-	offset, err := p.FindOffset(h)
-	if err != nil {
+	if err := p.init(); err != nil {
 		return nil, err
 	}
+	p.m.Lock()
+	defer p.m.Unlock()
 
-	return p.objectAtOffset(offset, h)
+	return p.get(h)
 }
 
 // GetByOffset retrieves the encoded object from the packfile at the given
 // offset.
-func (p *Packfile) GetByOffset(o int64) (plumbing.EncodedObject, error) {
-	hash, err := p.FindHash(o)
-	if err != nil {
+func (p *Packfile) GetByOffset(offset int64) (plumbing.EncodedObject, error) {
+	if err := p.init(); err != nil {
 		return nil, err
 	}
+	p.m.Lock()
+	defer p.m.Unlock()
 
-	return p.objectAtOffset(o, hash)
+	return p.getByOffset(offset)
 }
 
 // GetSizeByOffset retrieves the size of the encoded object from the
 // packfile with the given offset.
-func (p *Packfile) GetSizeByOffset(o int64) (size int64, err error) {
-	if _, err := p.s.SeekFromStart(o); err != nil {
-		if err == io.EOF || isInvalid(err) {
-			return 0, plumbing.ErrObjectNotFound
-		}
-
+func (p *Packfile) GetSizeByOffset(offset int64) (size int64, err error) {
+	if err := p.init(); err != nil {
 		return 0, err
 	}
 
-	h, err := p.nextObjectHeader()
+	d, err := p.GetByOffset(offset)
 	if err != nil {
 		return 0, err
 	}
-	return p.getObjectSize(h)
-}
 
-func (p *Packfile) objectHeaderAtOffset(offset int64) (*ObjectHeader, error) {
-	h, err := p.s.SeekObjectHeader(offset)
-	p.s.pendingObject = nil
-	return h, err
+	return d.Size(), nil
 }
 
-func (p *Packfile) nextObjectHeader() (*ObjectHeader, error) {
-	h, err := p.s.NextObjectHeader()
-	p.s.pendingObject = nil
-	return h, err
+// GetAll returns an iterator with all encoded objects in the packfile.
+// The iterator returned is not thread-safe, it should be used in the same
+// thread as the Packfile instance.
+func (p *Packfile) GetAll() (storer.EncodedObjectIter, error) {
+	return p.GetByType(plumbing.AnyObject)
 }
 
-func (p *Packfile) getDeltaObjectSize(buf *bytes.Buffer) int64 {
-	delta := buf.Bytes()
-	_, delta = decodeLEB128(delta) // skip src size
-	sz, _ := decodeLEB128(delta)
-	return int64(sz)
-}
-
-func (p *Packfile) getObjectSize(h *ObjectHeader) (int64, error) {
-	switch h.Type {
-	case plumbing.CommitObject, plumbing.TreeObject, plumbing.BlobObject, plumbing.TagObject:
-		return h.Length, nil
-	case plumbing.REFDeltaObject, plumbing.OFSDeltaObject:
-		buf := sync.GetBytesBuffer()
-		defer sync.PutBytesBuffer(buf)
-
-		if _, _, err := p.s.NextObject(buf); err != nil {
-			return 0, err
-		}
-
-		return p.getDeltaObjectSize(buf), nil
-	default:
-		return 0, ErrInvalidObject.AddDetails("type %q", h.Type)
+// GetByType returns all the objects of the given type.
+func (p *Packfile) GetByType(typ plumbing.ObjectType) (storer.EncodedObjectIter, error) {
+	if err := p.init(); err != nil {
+		return nil, err
 	}
-}
 
-func (p *Packfile) getObjectType(h *ObjectHeader) (typ plumbing.ObjectType, err error) {
-	switch h.Type {
-	case plumbing.CommitObject, plumbing.TreeObject, plumbing.BlobObject, plumbing.TagObject:
-		return h.Type, nil
-	case plumbing.REFDeltaObject, plumbing.OFSDeltaObject:
-		var offset int64
-		if h.Type == plumbing.REFDeltaObject {
-			offset, err = p.FindOffset(h.Reference)
-			if err != nil {
-				return
-			}
-		} else {
-			offset = h.OffsetReference
+	switch typ {
+	case plumbing.AnyObject,
+		plumbing.BlobObject,
+		plumbing.TreeObject,
+		plumbing.CommitObject,
+		plumbing.TagObject:
+		entries, err := p.EntriesByOffset()
+		if err != nil {
+			return nil, err
 		}
 
-		if baseType, ok := p.offsetToType[offset]; ok {
-			typ = baseType
-		} else {
-			h, err = p.objectHeaderAtOffset(offset)
-			if err != nil {
-				return
-			}
-
-			typ, err = p.getObjectType(h)
-			if err != nil {
-				return
-			}
-		}
+		return &objectIter{
+			p:    p,
+			iter: entries,
+			typ:  typ,
+		}, nil
 	default:
-		err = ErrInvalidObject.AddDetails("type %q", h.Type)
+		return nil, plumbing.ErrInvalidType
 	}
-
-	p.offsetToType[h.Offset] = typ
-
-	return
 }
 
-func (p *Packfile) objectAtOffset(offset int64, hash plumbing.Hash) (plumbing.EncodedObject, error) {
-	if obj, ok := p.cacheGet(hash); ok {
-		return obj, nil
-	}
-
-	h, err := p.objectHeaderAtOffset(offset)
-	if err != nil {
-		if err == io.EOF || isInvalid(err) {
-			return nil, plumbing.ErrObjectNotFound
-		}
+// Returns the Packfile's inner scanner.
+//
+// Deprecated: this will be removed in future versions of the packfile package
+// to avoid exposing the package internals and to improve its thread-safety.
+func (p *Packfile) Scanner() (*Scanner, error) {
+	if err := p.init(); err != nil {
 		return nil, err
 	}
 
-	return p.getNextObject(h, hash)
+	return p.scanner, nil
 }
 
-func (p *Packfile) getNextObject(h *ObjectHeader, hash plumbing.Hash) (plumbing.EncodedObject, error) {
-	var err error
-
-	// If we have no filesystem, we will return a MemoryObject instead
-	// of an FSObject.
-	if p.fs == nil {
-		return p.getNextMemoryObject(h)
+// ID returns the ID of the packfile, which is the checksum at the end of it.
+func (p *Packfile) ID() (plumbing.Hash, error) {
+	if err := p.init(); err != nil {
+		return plumbing.ZeroHash, err
 	}
 
-	// If the object is small enough then read it completely into memory now since
-	// it is already read from disk into buffer anyway. For delta objects we want
-	// to perform the optimization too, but we have to be careful about applying
-	// small deltas on big objects.
-	var size int64
-	if h.Length <= smallObjectThreshold {
-		if h.Type != plumbing.OFSDeltaObject && h.Type != plumbing.REFDeltaObject {
-			return p.getNextMemoryObject(h)
-		}
-
-		// For delta objects we read the delta data and apply the small object
-		// optimization only if the expanded version of the object still meets
-		// the small object threshold condition.
-		buf := sync.GetBytesBuffer()
-		defer sync.PutBytesBuffer(buf)
-
-		if _, _, err := p.s.NextObject(buf); err != nil {
-			return nil, err
-		}
-
-		size = p.getDeltaObjectSize(buf)
-		if size <= smallObjectThreshold {
-			var obj = new(plumbing.MemoryObject)
-			obj.SetSize(size)
-			if h.Type == plumbing.REFDeltaObject {
-				err = p.fillREFDeltaObjectContentWithBuffer(obj, h.Reference, buf)
-			} else {
-				err = p.fillOFSDeltaObjectContentWithBuffer(obj, h.OffsetReference, buf)
-			}
-			return obj, err
-		}
-	} else {
-		size, err = p.getObjectSize(h)
-		if err != nil {
-			return nil, err
-		}
-	}
+	return p.id, nil
+}
 
-	typ, err := p.getObjectType(h)
-	if err != nil {
-		return nil, err
+// get is not threat-safe, and should only be called within packfile.go.
+func (p *Packfile) get(h plumbing.Hash) (plumbing.EncodedObject, error) {
+	if obj, ok := p.cache.Get(h); ok {
+		return obj, nil
 	}
 
-	p.offsetToType[h.Offset] = typ
-
-	return NewFSObject(
-		hash,
-		typ,
-		h.Offset,
-		size,
-		p.Index,
-		p.fs,
-		p.file.Name(),
-		p.deltaBaseCache,
-		p.largeObjectThreshold,
-	), nil
-}
-
-func (p *Packfile) getObjectContent(offset int64) (io.ReadCloser, error) {
-	h, err := p.objectHeaderAtOffset(offset)
+	offset, err := p.Index.FindOffset(h)
 	if err != nil {
 		return nil, err
 	}
 
-	// getObjectContent is called from FSObject, so we have to explicitly
-	// get memory object here to avoid recursive cycle
-	obj, err := p.getNextMemoryObject(h)
+	oh, err := p.headerFromOffset(offset)
 	if err != nil {
 		return nil, err
 	}
 
-	return obj.Reader()
+	return p.objectFromHeader(oh)
 }
 
-func asyncReader(p *Packfile) (io.ReadCloser, error) {
-	reader := ioutil.NewReaderUsingReaderAt(p.file, p.s.r.offset)
-	zr, err := sync.GetZlibReader(reader)
+// getByOffset is not threat-safe, and should only be called within packfile.go.
+func (p *Packfile) getByOffset(offset int64) (plumbing.EncodedObject, error) {
+	h, err := p.FindHash(offset)
 	if err != nil {
-		return nil, fmt.Errorf("zlib reset error: %s", err)
+		return nil, err
 	}
 
-	return ioutil.NewReadCloserWithCloser(zr.Reader, func() error {
-		sync.PutZlibReader(zr)
-		return nil
-	}), nil
-
-}
-
-func (p *Packfile) getReaderDirect(h *ObjectHeader) (io.ReadCloser, error) {
-	switch h.Type {
-	case plumbing.CommitObject, plumbing.TreeObject, plumbing.BlobObject, plumbing.TagObject:
-		return asyncReader(p)
-	case plumbing.REFDeltaObject:
-		deltaRc, err := asyncReader(p)
-		if err != nil {
-			return nil, err
-		}
-		r, err := p.readREFDeltaObjectContent(h, deltaRc)
-		if err != nil {
-			return nil, err
-		}
-		return r, nil
-	case plumbing.OFSDeltaObject:
-		deltaRc, err := asyncReader(p)
-		if err != nil {
-			return nil, err
-		}
-		r, err := p.readOFSDeltaObjectContent(h, deltaRc)
-		if err != nil {
-			return nil, err
-		}
-		return r, nil
-	default:
-		return nil, ErrInvalidObject.AddDetails("type %q", h.Type)
+	if obj, ok := p.cache.Get(h); ok {
+		return obj, nil
 	}
-}
 
-func (p *Packfile) getNextMemoryObject(h *ObjectHeader) (plumbing.EncodedObject, error) {
-	var obj = new(plumbing.MemoryObject)
-	obj.SetSize(h.Length)
-	obj.SetType(h.Type)
-
-	var err error
-	switch h.Type {
-	case plumbing.CommitObject, plumbing.TreeObject, plumbing.BlobObject, plumbing.TagObject:
-		err = p.fillRegularObjectContent(obj)
-	case plumbing.REFDeltaObject:
-		err = p.fillREFDeltaObjectContent(obj, h.Reference)
-	case plumbing.OFSDeltaObject:
-		err = p.fillOFSDeltaObjectContent(obj, h.OffsetReference)
-	default:
-		err = ErrInvalidObject.AddDetails("type %q", h.Type)
-	}
-
+	oh, err := p.headerFromOffset(offset)
 	if err != nil {
 		return nil, err
 	}
 
-	p.offsetToType[h.Offset] = obj.Type()
-
-	return obj, nil
+	return p.objectFromHeader(oh)
 }
 
-func (p *Packfile) fillRegularObjectContent(obj plumbing.EncodedObject) (err error) {
-	w, err := obj.Writer()
-	if err != nil {
-		return err
-	}
-
-	defer ioutil.CheckClose(w, &err)
-
-	_, _, err = p.s.NextObject(w)
-	p.cachePut(obj)
-
-	return err
-}
-
-func (p *Packfile) fillREFDeltaObjectContent(obj plumbing.EncodedObject, ref plumbing.Hash) error {
-	buf := sync.GetBytesBuffer()
-	defer sync.PutBytesBuffer(buf)
-
-	_, _, err := p.s.NextObject(buf)
-	if err != nil {
-		return err
-	}
+func (p *Packfile) init() error {
+	p.once.Do(func() {
+		if p.file == nil {
+			p.onceErr = fmt.Errorf("file is not set")
+			return
+		}
 
-	return p.fillREFDeltaObjectContentWithBuffer(obj, ref, buf)
-}
+		if p.Index == nil {
+			p.onceErr = fmt.Errorf("index is not set")
+			return
+		}
 
-func (p *Packfile) readREFDeltaObjectContent(h *ObjectHeader, deltaRC io.Reader) (io.ReadCloser, error) {
-	var err error
+		p.scanner = NewScanner(p.file)
+		// Validate packfile signature.
+		if !p.scanner.Scan() {
+			p.onceErr = p.scanner.Error()
+			return
+		}
 
-	base, ok := p.cacheGet(h.Reference)
-	if !ok {
-		base, err = p.Get(h.Reference)
+		_, err := p.scanner.Seek(-20, io.SeekEnd)
 		if err != nil {
-			return nil, err
+			p.onceErr = err
+			return
 		}
-	}
 
-	return ReaderFromDelta(base, deltaRC)
-}
-
-func (p *Packfile) fillREFDeltaObjectContentWithBuffer(obj plumbing.EncodedObject, ref plumbing.Hash, buf *bytes.Buffer) error {
-	var err error
-
-	base, ok := p.cacheGet(ref)
-	if !ok {
-		base, err = p.Get(ref)
+		id, err := binary.ReadHash(p.scanner)
 		if err != nil {
-			return err
+			p.onceErr = err
 		}
-	}
-
-	obj.SetType(base.Type())
-	err = ApplyDelta(obj, base, buf.Bytes())
-	p.cachePut(obj)
+		p.id = id
 
-	return err
-}
+		if p.cache == nil {
+			p.cache = cache.NewObjectLRUDefault()
+		}
+	})
 
-func (p *Packfile) fillOFSDeltaObjectContent(obj plumbing.EncodedObject, offset int64) error {
-	buf := sync.GetBytesBuffer()
-	defer sync.PutBytesBuffer(buf)
-
-	_, _, err := p.s.NextObject(buf)
-	if err != nil {
-		return err
-	}
-
-	return p.fillOFSDeltaObjectContentWithBuffer(obj, offset, buf)
+	return p.onceErr
 }
 
-func (p *Packfile) readOFSDeltaObjectContent(h *ObjectHeader, deltaRC io.Reader) (io.ReadCloser, error) {
-	hash, err := p.FindHash(h.OffsetReference)
+func (p *Packfile) headerFromOffset(offset int64) (*ObjectHeader, error) {
+	err := p.scanner.SeekFromStart(offset)
 	if err != nil {
 		return nil, err
 	}
 
-	base, err := p.objectAtOffset(h.OffsetReference, hash)
-	if err != nil {
-		return nil, err
+	if !p.scanner.Scan() {
+		return nil, plumbing.ErrObjectNotFound
 	}
 
-	return ReaderFromDelta(base, deltaRC)
+	oh := p.scanner.Data().Value().(ObjectHeader)
+	return &oh, nil
 }
 
-func (p *Packfile) fillOFSDeltaObjectContentWithBuffer(obj plumbing.EncodedObject, offset int64, buf *bytes.Buffer) error {
-	hash, err := p.FindHash(offset)
-	if err != nil {
-		return err
-	}
+// Close the packfile and its resources.
+func (p *Packfile) Close() error {
+	p.m.Lock()
+	defer p.m.Unlock()
 
-	base, err := p.objectAtOffset(offset, hash)
-	if err != nil {
-		return err
+	closer, ok := p.file.(io.Closer)
+	if !ok {
+		return nil
 	}
 
-	obj.SetType(base.Type())
-	err = ApplyDelta(obj, base, buf.Bytes())
-	p.cachePut(obj)
-
-	return err
+	return closer.Close()
 }
 
-func (p *Packfile) cacheGet(h plumbing.Hash) (plumbing.EncodedObject, bool) {
-	if p.deltaBaseCache == nil {
-		return nil, false
+func (p *Packfile) objectFromHeader(oh *ObjectHeader) (plumbing.EncodedObject, error) {
+	if oh == nil {
+		return nil, plumbing.ErrObjectNotFound
 	}
 
-	return p.deltaBaseCache.Get(h)
-}
+	// If we have filesystem, and the object is not a delta type, return a FSObject.
+	// This avoids having to inflate the object more than once.
+	if !oh.Type.IsDelta() && p.fs != nil {
+		fs := NewFSObject(
+			oh.Hash,
+			oh.Type,
+			oh.ContentOffset,
+			oh.Size,
+			p.Index,
+			p.fs,
+			p.file.Name(),
+			p.cache,
+		)
 
-func (p *Packfile) cachePut(obj plumbing.EncodedObject) {
-	if p.deltaBaseCache == nil {
-		return
+		p.cache.Put(fs)
+		return fs, nil
 	}
 
-	p.deltaBaseCache.Put(obj)
+	return p.getMemoryObject(oh)
 }
 
-// GetAll returns an iterator with all encoded objects in the packfile.
-// The iterator returned is not thread-safe, it should be used in the same
-// thread as the Packfile instance.
-func (p *Packfile) GetAll() (storer.EncodedObjectIter, error) {
-	return p.GetByType(plumbing.AnyObject)
-}
+func (p *Packfile) getMemoryObject(oh *ObjectHeader) (plumbing.EncodedObject, error) {
+	var obj = new(plumbing.MemoryObject)
+	obj.SetSize(oh.Size)
+	obj.SetType(oh.Type)
 
-// GetByType returns all the objects of the given type.
-func (p *Packfile) GetByType(typ plumbing.ObjectType) (storer.EncodedObjectIter, error) {
-	switch typ {
-	case plumbing.AnyObject,
-		plumbing.BlobObject,
-		plumbing.TreeObject,
-		plumbing.CommitObject,
-		plumbing.TagObject:
-		entries, err := p.EntriesByOffset()
-		if err != nil {
-			return nil, err
-		}
-
-		return &objectIter{
-			// Easiest way to provide an object decoder is just to pass a Packfile
-			// instance. To not mess with the seeks, it's a new instance with a
-			// different scanner but the same cache and offset to hash map for
-			// reusing as much cache as possible.
-			p:    p,
-			iter: entries,
-			typ:  typ,
-		}, nil
-	default:
-		return nil, plumbing.ErrInvalidType
-	}
-}
-
-// ID returns the ID of the packfile, which is the checksum at the end of it.
-func (p *Packfile) ID() (plumbing.Hash, error) {
-	prev, err := p.file.Seek(-20, io.SeekEnd)
+	w, err := obj.Writer()
 	if err != nil {
-		return plumbing.ZeroHash, err
+		return nil, err
 	}
+	defer ioutil.CheckClose(w, &err)
 
-	var hash plumbing.Hash
-	if _, err := io.ReadFull(p.file, hash[:]); err != nil {
-		return plumbing.ZeroHash, err
-	}
+	switch oh.Type {
+	case plumbing.CommitObject, plumbing.TreeObject, plumbing.BlobObject, plumbing.TagObject:
+		err = p.scanner.inflateContent(oh.ContentOffset, w)
 
-	if _, err := p.file.Seek(prev, io.SeekStart); err != nil {
-		return plumbing.ZeroHash, err
-	}
+	case plumbing.REFDeltaObject, plumbing.OFSDeltaObject:
+		var parent plumbing.EncodedObject
 
-	return hash, nil
-}
-
-// Scanner returns the packfile's Scanner
-func (p *Packfile) Scanner() *Scanner {
-	return p.s
-}
-
-// Close the packfile and its resources.
-func (p *Packfile) Close() error {
-	closer, ok := p.file.(io.Closer)
-	if !ok {
-		return nil
-	}
-
-	return closer.Close()
-}
+		switch oh.Type {
+		case plumbing.REFDeltaObject:
+			var ok bool
+			parent, ok = p.cache.Get(oh.Reference)
+			if !ok {
+				parent, err = p.get(oh.Reference)
+			}
+		case plumbing.OFSDeltaObject:
+			parent, err = p.getByOffset(oh.OffsetReference)
+		}
 
-type objectIter struct {
-	p    *Packfile
-	typ  plumbing.ObjectType
-	iter idxfile.EntryIter
-}
-
-func (i *objectIter) Next() (plumbing.EncodedObject, error) {
-	for {
-		e, err := i.iter.Next()
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("cannot find base object: %w", err)
 		}
 
-		if i.typ != plumbing.AnyObject {
-			if typ, ok := i.p.offsetToType[int64(e.Offset)]; ok {
-				if typ != i.typ {
-					continue
-				}
-			} else if obj, ok := i.p.cacheGet(e.Hash); ok {
-				if obj.Type() != i.typ {
-					i.p.offsetToType[int64(e.Offset)] = obj.Type()
-					continue
-				}
-				return obj, nil
-			} else {
-				h, err := i.p.objectHeaderAtOffset(int64(e.Offset))
-				if err != nil {
-					return nil, err
-				}
-
-				if h.Type == plumbing.REFDeltaObject || h.Type == plumbing.OFSDeltaObject {
-					typ, err := i.p.getObjectType(h)
-					if err != nil {
-						return nil, err
-					}
-					if typ != i.typ {
-						i.p.offsetToType[int64(e.Offset)] = typ
-						continue
-					}
-					// getObjectType will seek in the file so we cannot use getNextObject safely
-					return i.p.objectAtOffset(int64(e.Offset), e.Hash)
-				} else {
-					if h.Type != i.typ {
-						i.p.offsetToType[int64(e.Offset)] = h.Type
-						continue
-					}
-					return i.p.getNextObject(h, e.Hash)
-				}
-			}
+		err = p.scanner.inflateContent(oh.ContentOffset, &oh.content)
+		if err != nil {
+			return nil, fmt.Errorf("test")
 		}
 
-		obj, err := i.p.objectAtOffset(int64(e.Offset), e.Hash)
-		if err != nil {
-			return nil, err
-		}
+		obj.SetType(parent.Type())
+		err = ApplyDelta(obj, parent, oh.content.Bytes()) //nolint:ineffassign
 
-		return obj, nil
+	default:
+		err = ErrInvalidObject.AddDetails("type %q", oh.Type)
 	}
-}
 
-func (i *objectIter) ForEach(f func(plumbing.EncodedObject) error) error {
-	for {
-		o, err := i.Next()
-		if err != nil {
-			if err == io.EOF {
-				return nil
-			}
-			return err
-		}
-
-		if err := f(o); err != nil {
-			return err
-		}
+	if err != nil {
+		return nil, err
 	}
-}
 
-func (i *objectIter) Close() {
-	i.iter.Close()
+	p.cache.Put(obj)
+
+	return obj, nil
 }
 
 // isInvalid checks whether an error is an os.PathError with an os.ErrInvalid

plumbing/format/packfile/packfile_iter.go

···
+package packfile
+
+import (
+	"io"
+
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/go-git/go-git/v5/plumbing/format/idxfile"
+)
+
+type objectIter struct {
+	p    *Packfile
+	typ  plumbing.ObjectType
+	iter idxfile.EntryIter
+}
+
+func (i *objectIter) Next() (plumbing.EncodedObject, error) {
+	if err := i.p.init(); err != nil {
+		return nil, err
+	}
+
+	i.p.m.Lock()
+	defer i.p.m.Unlock()
+
+	return i.next()
+}
+
+func (i *objectIter) next() (plumbing.EncodedObject, error) {
+	for {
+		e, err := i.iter.Next()
+		if err != nil {
+			return nil, err
+		}
+
+		oh, err := i.p.headerFromOffset(int64(e.Offset))
+		if err != nil {
+			return nil, err
+		}
+
+		if i.typ == plumbing.AnyObject {
+			return i.p.objectFromHeader(oh)
+		}
+
+		// Current object header type is a delta, get the actual object to
+		// assess the actual type.
+		if oh.Type.IsDelta() {
+			o, err := i.p.objectFromHeader(oh)
+			if o.Type() == i.typ {
+				return o, err
+			}
+
+			continue
+		}
+
+		if oh.Type == i.typ {
+			return i.p.objectFromHeader(oh)
+		}
+
+		continue
+	}
+}
+
+func (i *objectIter) ForEach(f func(plumbing.EncodedObject) error) error {
+	if err := i.p.init(); err != nil {
+		return err
+	}
+
+	i.p.m.Lock()
+	defer i.p.m.Unlock()
+
+	for {
+		o, err := i.next()
+		if err != nil {
+			if err == io.EOF {
+				return nil
+			}
+			return err
+		}
+
+		if err := f(o); err != nil {
+			return err
+		}
+	}
+}
+
+func (i *objectIter) Close() {
+	i.p.m.Lock()
+	defer i.p.m.Unlock()
+
+	i.iter.Close()
+}

plumbing/format/packfile/packfile_options.go

···
+package packfile
+
+import (
+	billy "github.com/go-git/go-billy/v5"
+	"github.com/go-git/go-git/v5/plumbing/cache"
+	"github.com/go-git/go-git/v5/plumbing/format/idxfile"
+)
+
+type PackfileOption func(*Packfile)
+
+// WithCache sets the cache to be used throughout Packfile operations.
+// Use this to share existing caches with the Packfile. If not used, a
+// new cache instance will be created.
+func WithCache(cache cache.Object) PackfileOption {
+	return func(p *Packfile) {
+		p.cache = cache
+	}
+}
+
+// WithIdx sets the idxfile for the packfile.
+func WithIdx(idx idxfile.Index) PackfileOption {
+	return func(p *Packfile) {
+		p.Index = idx
+	}
+}
+
+// WithFs sets the filesystem to be used.
+func WithFs(fs billy.Filesystem) PackfileOption {
+	return func(p *Packfile) {
+		p.fs = fs
+	}
+}

plumbing/format/packfile/packfile_test.go

···
 import (
 	"io"
 	"math"
+	"testing"
 
-	fixtures "github.com/go-git/go-git-fixtures/v4"
+	fixtures "github.com/go-git/go-git-fixtures/v5"
 	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/go-git/go-git/v5/plumbing/cache"
 	"github.com/go-git/go-git/v5/plumbing/format/idxfile"
 	"github.com/go-git/go-git/v5/plumbing/format/packfile"
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
-type PackfileSuite struct {
-	fixtures.Suite
-	p   *packfile.Packfile
-	idx *idxfile.MemoryIndex
-	f   *fixtures.Fixture
-}
+func TestGet(t *testing.T) {
+	t.Parallel()
+
+	f := fixtures.Basic().One()
+	idx := getIndexFromIdxFile(f.Idx())
 
-var _ = Suite(&PackfileSuite{})
+	p := packfile.NewPackfile(f.Packfile(),
+		packfile.WithIdx(idx), packfile.WithFs(fixtures.Filesystem),
+	)
 
-func (s *PackfileSuite) TestGet(c *C) {
 	for h := range expectedEntries {
-		obj, err := s.p.Get(h)
-		c.Assert(err, IsNil)
-		c.Assert(obj, Not(IsNil))
-		c.Assert(obj.Hash(), Equals, h)
+		obj, err := p.Get(h)
+
+		assert.NoError(t, err)
+		assert.NotNil(t, obj)
+		assert.Equal(t, h.String(), obj.Hash().String())
 	}
 
-	_, err := s.p.Get(plumbing.ZeroHash)
-	c.Assert(err, Equals, plumbing.ErrObjectNotFound)
+	_, err := p.Get(plumbing.ZeroHash)
+	assert.ErrorIs(t, err, plumbing.ErrObjectNotFound)
+
+	id, err := p.ID()
+	assert.NoError(t, err)
+	assert.Equal(t, f.PackfileHash, id.String())
 }
 
-func (s *PackfileSuite) TestGetByOffset(c *C) {
+func TestGetByOffset(t *testing.T) {
+	t.Parallel()
+
+	f := fixtures.Basic().One()
+	idx := getIndexFromIdxFile(f.Idx())
+
+	p := packfile.NewPackfile(f.Packfile(),
+		packfile.WithIdx(idx), packfile.WithFs(fixtures.Filesystem),
+	)
+
 	for h, o := range expectedEntries {
-		obj, err := s.p.GetByOffset(o)
-		c.Assert(err, IsNil)
-		c.Assert(obj, Not(IsNil))
-		c.Assert(obj.Hash(), Equals, h)
+		obj, err := p.GetByOffset(o)
+		assert.NoError(t, err)
+		assert.NotNil(t, obj)
+		assert.Equal(t, h.String(), obj.Hash().String())
 	}
 
-	_, err := s.p.GetByOffset(math.MaxInt64)
-	c.Assert(err, Equals, plumbing.ErrObjectNotFound)
+	_, err := p.GetByOffset(math.MaxInt64)
+	assert.ErrorIs(t, err, plumbing.ErrObjectNotFound)
 }
 
-func (s *PackfileSuite) TestID(c *C) {
-	id, err := s.p.ID()
-	c.Assert(err, IsNil)
-	c.Assert(id.String(), Equals, s.f.PackfileHash)
-}
+func TestGetAll(t *testing.T) {
+	t.Parallel()
+
+	f := fixtures.Basic().One()
+	idx := getIndexFromIdxFile(f.Idx())
 
-func (s *PackfileSuite) TestGetAll(c *C) {
-	iter, err := s.p.GetAll()
-	c.Assert(err, IsNil)
+	p := packfile.NewPackfile(f.Packfile(),
+		packfile.WithIdx(idx),
+		packfile.WithFs(fixtures.Filesystem))
+
+	iter, err := p.GetAll()
+	assert.NoError(t, err)
 
 	var objects int
 	for {
···
 		if err == io.EOF {
 			break
 		}
-		c.Assert(err, IsNil)
+		assert.NoError(t, err)
 
 		objects++
-		_, ok := expectedEntries[o.Hash()]
-		c.Assert(ok, Equals, true)
+		h := o.Hash()
+		_, ok := expectedEntries[h]
+		assert.True(t, ok, "%s not found", h)
 	}
 
-	c.Assert(objects, Equals, len(expectedEntries))
-}
+	assert.Len(t, expectedEntries, objects)
 
-var expectedEntries = map[plumbing.Hash]int64{
-	plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea"): 615,
-	plumbing.NewHash("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88"): 1524,
-	plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"): 1063,
-	plumbing.NewHash("49c6bb89b17060d7b4deacb7b338fcc6ea2352a9"): 78882,
-	plumbing.NewHash("4d081c50e250fa32ea8b1313cf8bb7c2ad7627fd"): 84688,
-	plumbing.NewHash("586af567d0bb5e771e49bdd9434f5e0fb76d25fa"): 84559,
-	plumbing.NewHash("5a877e6a906a2743ad6e45d99c1793642aaf8eda"): 84479,
-	plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"): 186,
-	plumbing.NewHash("7e59600739c96546163833214c36459e324bad0a"): 84653,
-	plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198"): 78050,
-	plumbing.NewHash("8dcef98b1d52143e1e2dbc458ffe38f925786bf2"): 84741,
-	plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"): 286,
-	plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492"): 80998,
-	plumbing.NewHash("9dea2395f5403188298c1dabe8bdafe562c491e3"): 84032,
-	plumbing.NewHash("a39771a7651f97faf5c72e08224d857fc35133db"): 84430,
-	plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"): 838,
-	plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c"): 84375,
-	plumbing.NewHash("aa9b383c260e1d05fbbf6b30a02914555e20c725"): 84760,
-	plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"): 449,
-	plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"): 1392,
-	plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"): 1230,
-	plumbing.NewHash("c192bd6a24ea1ab01d78686e417c8bdc7c3d197f"): 1713,
-	plumbing.NewHash("c2d30fa8ef288618f65f6eed6e168e0d514886f4"): 84725,
-	plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956"): 80725,
-	plumbing.NewHash("cf4aa3b38974fb7d81f367c0830f7d78d65ab86b"): 84608,
-	plumbing.NewHash("d3ff53e0564a9f87d8e84b6e28e5060e517008aa"): 1685,
-	plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d"): 2351,
-	plumbing.NewHash("dbd3641b371024f44d0e469a9c8f5457b0660de1"): 84115,
-	plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"): 12,
-	plumbing.NewHash("eba74343e2f15d62adedfd8c883ee0262b5c8021"): 84708,
-	plumbing.NewHash("fb72698cab7617ac416264415f13224dfd7a165e"): 84671,
+	iter.Close()
+	assert.NoError(t, p.Close())
 }
 
-func (s *PackfileSuite) SetUpTest(c *C) {
-	s.f = fixtures.Basic().One()
-
-	s.idx = idxfile.NewMemoryIndex()
-	c.Assert(idxfile.NewDecoder(s.f.Idx()).Decode(s.idx), IsNil)
-
-	s.p = packfile.NewPackfile(s.idx, fixtures.Filesystem, s.f.Packfile(), 0)
-}
+func TestDecode(t *testing.T) {
+	t.Parallel()
 
-func (s *PackfileSuite) TearDownTest(c *C) {
-	c.Assert(s.p.Close(), IsNil)
-}
+	packfiles := fixtures.Basic().ByTag("packfile")
+	assert.Greater(t, len(packfiles), 0)
 
-func (s *PackfileSuite) TestDecode(c *C) {
-	fixtures.Basic().ByTag("packfile").Test(c, func(f *fixtures.Fixture) {
+	for _, f := range packfiles {
+		f := f
 		index := getIndexFromIdxFile(f.Idx())
 
-		p := packfile.NewPackfile(index, fixtures.Filesystem, f.Packfile(), 0)
-		defer p.Close()
+		p := packfile.NewPackfile(f.Packfile(),
+			packfile.WithIdx(index), packfile.WithFs(fixtures.Filesystem),
+		)
 
 		for _, h := range expectedHashes {
+			h := h
 			obj, err := p.Get(plumbing.NewHash(h))
-			c.Assert(err, IsNil)
-			c.Assert(obj.Hash().String(), Equals, h)
+			assert.NoError(t, err)
+			assert.Equal(t, obj.Hash().String(), h)
 		}
-	})
+
+		err := p.Close()
+		assert.NoError(t, err)
+	}
 }
 
-func (s *PackfileSuite) TestDecodeByTypeRefDelta(c *C) {
+func TestDecodeByTypeRefDelta(t *testing.T) {
+	t.Parallel()
+
 	f := fixtures.Basic().ByTag("ref-delta").One()
 
 	index := getIndexFromIdxFile(f.Idx())
 
-	packfile := packfile.NewPackfile(index, fixtures.Filesystem, f.Packfile(), 0)
-	defer packfile.Close()
+	packfile := packfile.NewPackfile(f.Packfile(),
+		packfile.WithIdx(index), packfile.WithFs(fixtures.Filesystem))
 
 	iter, err := packfile.GetByType(plumbing.CommitObject)
-	c.Assert(err, IsNil)
+	assert.NoError(t, err)
 
 	var count int
 	for {
···
 		}
 
 		count++
-		c.Assert(err, IsNil)
-		c.Assert(obj.Type(), Equals, plumbing.CommitObject)
+		assert.NoError(t, err)
+		assert.Equal(t, obj.Type(), plumbing.CommitObject)
 	}
 
-	c.Assert(count > 0, Equals, true)
+	err = packfile.Close()
+
+	assert.NoError(t, err)
+	assert.Greater(t, count, 0)
 }
 
-func (s *PackfileSuite) TestDecodeByType(c *C) {
-	ts := []plumbing.ObjectType{
+func TestDecodeByType(t *testing.T) {
+	t.Parallel()
+
+	types := []plumbing.ObjectType{
 		plumbing.CommitObject,
 		plumbing.TagObject,
 		plumbing.TreeObject,
 		plumbing.BlobObject,
 	}
 
-	fixtures.Basic().ByTag("packfile").Test(c, func(f *fixtures.Fixture) {
-		for _, t := range ts {
+	for _, f := range fixtures.Basic().ByTag("packfile") {
+		f := f
+		for _, typ := range types {
+			typ := typ
 			index := getIndexFromIdxFile(f.Idx())
 
-			packfile := packfile.NewPackfile(index, fixtures.Filesystem, f.Packfile(), 0)
+			packfile := packfile.NewPackfile(f.Packfile(),
+				packfile.WithIdx(index), packfile.WithFs(fixtures.Filesystem),
+			)
 			defer packfile.Close()
 
-			iter, err := packfile.GetByType(t)
-			c.Assert(err, IsNil)
+			iter, err := packfile.GetByType(typ)
+			assert.NoError(t, err)
 
-			c.Assert(iter.ForEach(func(obj plumbing.EncodedObject) error {
-				c.Assert(obj.Type(), Equals, t)
+			err = iter.ForEach(func(obj plumbing.EncodedObject) error {
+				assert.Equal(t, typ, obj.Type())
 				return nil
-			}), IsNil)
+			})
+			assert.NoError(t, err)
 		}
-	})
+	}
 }
 
-func (s *PackfileSuite) TestDecodeByTypeConstructor(c *C) {
+func TestDecodeByTypeConstructor(t *testing.T) {
+	t.Parallel()
+
 	f := fixtures.Basic().ByTag("packfile").One()
 	index := getIndexFromIdxFile(f.Idx())
 
-	packfile := packfile.NewPackfile(index, fixtures.Filesystem, f.Packfile(), 0)
+	packfile := packfile.NewPackfile(f.Packfile(),
+		packfile.WithIdx(index), packfile.WithFs(fixtures.Filesystem),
+	)
 	defer packfile.Close()
 
 	_, err := packfile.GetByType(plumbing.OFSDeltaObject)
-	c.Assert(err, Equals, plumbing.ErrInvalidType)
+	assert.ErrorIs(t, err, plumbing.ErrInvalidType)
 
 	_, err = packfile.GetByType(plumbing.REFDeltaObject)
-	c.Assert(err, Equals, plumbing.ErrInvalidType)
+	assert.ErrorIs(t, err, plumbing.ErrInvalidType)
 
 	_, err = packfile.GetByType(plumbing.InvalidObject)
-	c.Assert(err, Equals, plumbing.ErrInvalidType)
+	assert.ErrorIs(t, err, plumbing.ErrInvalidType)
+}
+
+func getIndexFromIdxFile(r io.ReadCloser) idxfile.Index {
+	defer r.Close()
+
+	idx := idxfile.NewMemoryIndex()
+	if err := idxfile.NewDecoder(r).Decode(idx); err != nil {
+		panic(err)
+	}
+
+	return idx
+}
+
+func TestSize(t *testing.T) {
+	t.Parallel()
+
+	f := fixtures.Basic().ByTag("ref-delta").One()
+
+	index := getIndexFromIdxFile(f.Idx())
+
+	packfile := packfile.NewPackfile(f.Packfile(),
+		packfile.WithIdx(index),
+		packfile.WithFs(fixtures.Filesystem),
+	)
+	defer packfile.Close()
+
+	// Get the size of binary.jpg, which is not delta-encoded.
+	offset, err := packfile.FindOffset(plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d"))
+	assert.NoError(t, err)
+
+	size, err := packfile.GetSizeByOffset(offset)
+	assert.NoError(t, err)
+	assert.Equal(t, int64(76110), size)
+
+	// Get the size of the root commit, which is delta-encoded.
+	offset, err = packfile.FindOffset(plumbing.NewHash(f.Head))
+	assert.NoError(t, err)
+	size, err = packfile.GetSizeByOffset(offset)
+	assert.NoError(t, err)
+	assert.Equal(t, int64(245), size)
+}
+
+func BenchmarkGetByOffset(b *testing.B) {
+	f := fixtures.Basic().One()
+	idx := idxfile.NewMemoryIndex()
+
+	cache := cache.NewObjectLRUDefault()
+	err := idxfile.NewDecoder(f.Idx()).Decode(idx)
+	require.NoError(b, err)
+
+	b.Run("with storage",
+		benchmarkGetByOffset(packfile.NewPackfile(f.Packfile(),
+			packfile.WithIdx(idx), packfile.WithFs(fixtures.Filesystem),
+			packfile.WithCache(cache),
+		)))
+	b.Run("without storage",
+		benchmarkGetByOffset(packfile.NewPackfile(f.Packfile(),
+			packfile.WithCache(cache), packfile.WithIdx(idx),
+		)))
+}
+
+func benchmarkGetByOffset(p *packfile.Packfile) func(b *testing.B) {
+	return func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			for h, o := range expectedEntries {
+				obj, err := p.GetByOffset(o)
+				if err != nil {
+					b.Fatal()
+				}
+				if h != obj.Hash() {
+					b.Fatal()
+				}
+			}
+		}
+	}
 }
 
 var expectedHashes = []string{
···
 	"7e59600739c96546163833214c36459e324bad0a",
 }
 
-func getIndexFromIdxFile(r io.Reader) idxfile.Index {
-	idx := idxfile.NewMemoryIndex()
-	if err := idxfile.NewDecoder(r).Decode(idx); err != nil {
-		panic(err)
-	}
-
-	return idx
-}
-
-func (s *PackfileSuite) TestSize(c *C) {
-	f := fixtures.Basic().ByTag("ref-delta").One()
-
-	index := getIndexFromIdxFile(f.Idx())
-
-	packfile := packfile.NewPackfile(index, fixtures.Filesystem, f.Packfile(), 0)
-	defer packfile.Close()
-
-	// Get the size of binary.jpg, which is not delta-encoded.
-	offset, err := packfile.FindOffset(plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d"))
-	c.Assert(err, IsNil)
-	size, err := packfile.GetSizeByOffset(offset)
-	c.Assert(err, IsNil)
-	c.Assert(size, Equals, int64(76110))
-
-	// Get the size of the root commit, which is delta-encoded.
-	offset, err = packfile.FindOffset(plumbing.NewHash(f.Head))
-	c.Assert(err, IsNil)
-	size, err = packfile.GetSizeByOffset(offset)
-	c.Assert(err, IsNil)
-	c.Assert(size, Equals, int64(245))
+var expectedEntries = map[plumbing.Hash]int64{
+	plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea"): 615,
+	plumbing.NewHash("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88"): 1524,
+	plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"): 1063,
+	plumbing.NewHash("49c6bb89b17060d7b4deacb7b338fcc6ea2352a9"): 78882,
+	plumbing.NewHash("4d081c50e250fa32ea8b1313cf8bb7c2ad7627fd"): 84688,
+	plumbing.NewHash("586af567d0bb5e771e49bdd9434f5e0fb76d25fa"): 84559,
+	plumbing.NewHash("5a877e6a906a2743ad6e45d99c1793642aaf8eda"): 84479,
+	plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"): 186,
+	plumbing.NewHash("7e59600739c96546163833214c36459e324bad0a"): 84653,
+	plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198"): 78050,
+	plumbing.NewHash("8dcef98b1d52143e1e2dbc458ffe38f925786bf2"): 84741,
+	plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"): 286,
+	plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492"): 80998,
+	plumbing.NewHash("9dea2395f5403188298c1dabe8bdafe562c491e3"): 84032,
+	plumbing.NewHash("a39771a7651f97faf5c72e08224d857fc35133db"): 84430,
+	plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"): 838,
+	plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c"): 84375,
+	plumbing.NewHash("aa9b383c260e1d05fbbf6b30a02914555e20c725"): 84760,
+	plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"): 449,
+	plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"): 1392,
+	plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"): 1230,
+	plumbing.NewHash("c192bd6a24ea1ab01d78686e417c8bdc7c3d197f"): 1713,
+	plumbing.NewHash("c2d30fa8ef288618f65f6eed6e168e0d514886f4"): 84725,
+	plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956"): 80725,
+	plumbing.NewHash("cf4aa3b38974fb7d81f367c0830f7d78d65ab86b"): 84608,
+	plumbing.NewHash("d3ff53e0564a9f87d8e84b6e28e5060e517008aa"): 1685,
+	plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d"): 2351,
+	plumbing.NewHash("dbd3641b371024f44d0e469a9c8f5457b0660de1"): 84115,
+	plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"): 12,
+	plumbing.NewHash("eba74343e2f15d62adedfd8c883ee0262b5c8021"): 84708,
+	plumbing.NewHash("fb72698cab7617ac416264415f13224dfd7a165e"): 84671,
 }

plumbing/format/packfile/parser.go

···
 	"errors"
 	"fmt"
 	"io"
+	stdsync "sync"
 
 	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/go-git/go-git/v5/plumbing/cache"
 	"github.com/go-git/go-git/v5/plumbing/storer"
 	"github.com/go-git/go-git/v5/utils/ioutil"
-	"github.com/go-git/go-git/v5/utils/sync"
 )
 
 var (
···
 	ErrDeltaNotCached = errors.New("delta could not be found in cache")
 )
 
-// Observer interface is implemented by index encoders.
-type Observer interface {
-	// OnHeader is called when a new packfile is opened.
-	OnHeader(count uint32) error
-	// OnInflatedObjectHeader is called for each object header read.
-	OnInflatedObjectHeader(t plumbing.ObjectType, objSize int64, pos int64) error
-	// OnInflatedObjectContent is called for each decoded object.
-	OnInflatedObjectContent(h plumbing.Hash, pos int64, crc uint32, content []byte) error
-	// OnFooter is called when decoding is done.
-	OnFooter(h plumbing.Hash) error
-}
-
 // Parser decodes a packfile and calls any observer associated to it. Is used
 // to generate indexes.
 type Parser struct {
-	storage    storer.EncodedObjectStorer
-	scanner    *Scanner
-	count      uint32
-	oi         []*objectInfo
-	oiByHash   map[plumbing.Hash]*objectInfo
-	oiByOffset map[int64]*objectInfo
-	checksum   plumbing.Hash
+	storage storer.EncodedObjectStorer
+	cache   *parserCache
 
-	cache *cache.BufferLRU
-	// delta content by offset, only used if source is not seekable
-	deltas map[int64][]byte
+	scanner   *Scanner
+	observers []Observer
+	hasher    plumbing.Hasher
 
-	ob []Observer
+	checksum plumbing.Hash
+	m        stdsync.Mutex
 }
 
-// NewParser creates a new Parser. The Scanner source must be seekable.
-// If it's not, NewParserWithStorage should be used instead.
-func NewParser(scanner *Scanner, ob ...Observer) (*Parser, error) {
-	return NewParserWithStorage(scanner, nil, ob...)
-}
-
-// NewParserWithStorage creates a new Parser. The scanner source must either
-// be seekable or a storage must be provided.
-func NewParserWithStorage(
-	scanner *Scanner,
-	storage storer.EncodedObjectStorer,
-	ob ...Observer,
-) (*Parser, error) {
-	if !scanner.IsSeekable && storage == nil {
-		return nil, ErrNotSeekableSource
+// NewParser creates a new Parser.
+// When a storage is set, the objects are written to storage as they
+// are parsed.
+func NewParser(data io.Reader, opts ...ParserOption) *Parser {
+	p := &Parser{
+		hasher: plumbing.NewHasher(plumbing.AnyObject, 0),
 	}
-
-	var deltas map[int64][]byte
-	if !scanner.IsSeekable {
-		deltas = make(map[int64][]byte)
+	for _, opt := range opts {
+		opt(p)
 	}
 
-	return &Parser{
-		storage: storage,
-		scanner: scanner,
-		ob:      ob,
-		count:   0,
-		cache:   cache.NewBufferLRUDefault(),
-		deltas:  deltas,
-	}, nil
-}
+	p.scanner = NewScanner(data)
 
-func (p *Parser) forEachObserver(f func(o Observer) error) error {
-	for _, o := range p.ob {
-		if err := f(o); err != nil {
-			return err
-		}
+	if p.storage != nil {
+		p.scanner.storage = p.storage
 	}
-	return nil
-}
-
-func (p *Parser) onHeader(count uint32) error {
-	return p.forEachObserver(func(o Observer) error {
-		return o.OnHeader(count)
-	})
-}
+	p.cache = newParserCache()
 
-func (p *Parser) onInflatedObjectHeader(
-	t plumbing.ObjectType,
-	objSize int64,
-	pos int64,
-) error {
-	return p.forEachObserver(func(o Observer) error {
-		return o.OnInflatedObjectHeader(t, objSize, pos)
-	})
+	return p
 }
 
-func (p *Parser) onInflatedObjectContent(
-	h plumbing.Hash,
-	pos int64,
-	crc uint32,
-	content []byte,
-) error {
-	return p.forEachObserver(func(o Observer) error {
-		return o.OnInflatedObjectContent(h, pos, crc, content)
-	})
-}
+func (p *Parser) storeOrCache(oh *ObjectHeader) error {
+	// Only need to store deltas, as the scanner already stored non-delta
+	// objects.
+	if p.storage != nil && oh.diskType.IsDelta() {
+		w, err := p.storage.RawObjectWriter(oh.Type, oh.Size)
+		if err != nil {
+			return err
+		}
 
-func (p *Parser) onFooter(h plumbing.Hash) error {
-	return p.forEachObserver(func(o Observer) error {
-		return o.OnFooter(h)
-	})
-}
+		defer w.Close()
 
-// Parse start decoding phase of the packfile.
-func (p *Parser) Parse() (plumbing.Hash, error) {
-	if err := p.init(); err != nil {
-		return plumbing.ZeroHash, err
+		_, err = io.Copy(w, bytes.NewReader(oh.content.Bytes()))
+		if err != nil {
+			return err
+		}
 	}
 
-	if err := p.indexObjects(); err != nil {
-		return plumbing.ZeroHash, err
+	if p.cache != nil {
+		p.cache.Add(oh)
 	}
 
-	var err error
-	p.checksum, err = p.scanner.Checksum()
-	if err != nil && err != io.EOF {
-		return plumbing.ZeroHash, err
-	}
+	p.onInflatedObjectHeader(oh.Type, oh.Size, oh.Offset)
+	p.onInflatedObjectContent(oh.Hash, oh.Offset, oh.Crc32, nil)
 
-	if err := p.resolveDeltas(); err != nil {
-		return plumbing.ZeroHash, err
-	}
-
-	if err := p.onFooter(p.checksum); err != nil {
-		return plumbing.ZeroHash, err
-	}
-
-	return p.checksum, nil
+	return nil
 }
 
-func (p *Parser) init() error {
-	_, c, err := p.scanner.Header()
-	if err != nil {
-		return err
-	}
-
-	if err := p.onHeader(c); err != nil {
-		return err
+func (p *Parser) resetCache(qty int) {
+	if p.cache != nil {
+		p.cache.Reset(qty)
 	}
-
-	p.count = c
-	p.oiByHash = make(map[plumbing.Hash]*objectInfo, p.count)
-	p.oiByOffset = make(map[int64]*objectInfo, p.count)
-	p.oi = make([]*objectInfo, p.count)
-
-	return nil
 }
 
-type objectHeaderWriter func(typ plumbing.ObjectType, sz int64) error
+// Parse start decoding phase of the packfile.
+func (p *Parser) Parse() (plumbing.Hash, error) {
+	p.m.Lock()
+	defer p.m.Unlock()
 
-type lazyObjectWriter interface {
-	// LazyWriter enables an object to be lazily written.
-	// It returns:
-	// - w: a writer to receive the object's content.
-	// - lwh: a func to write the object header.
-	// - err: any error from the initial writer creation process.
-	//
-	// Note that if the object header is not written BEFORE the writer
-	// is used, this will result in an invalid object.
-	LazyWriter() (w io.WriteCloser, lwh objectHeaderWriter, err error)
-}
+	var pendingDeltas []*ObjectHeader
+	var pendingDeltaREFs []*ObjectHeader
 
-func (p *Parser) indexObjects() error {
-	buf := sync.GetBytesBuffer()
-	defer sync.PutBytesBuffer(buf)
+	for p.scanner.Scan() {
+		data := p.scanner.Data()
+		switch data.Section {
+		case HeaderSection:
+			header := data.Value().(Header)
 
-	for i := uint32(0); i < p.count; i++ {
-		oh, err := p.scanner.NextObjectHeader()
-		if err != nil {
-			return err
-		}
+			p.resetCache(int(header.ObjectsQty))
+			p.onHeader(header.ObjectsQty)
 
-		delta := false
-		var ota *objectInfo
-		switch t := oh.Type; t {
-		case plumbing.OFSDeltaObject:
-			delta = true
+		case ObjectSection:
+			oh := data.Value().(ObjectHeader)
 
-			parent, ok := p.oiByOffset[oh.OffsetReference]
-			if !ok {
-				return plumbing.ErrObjectNotFound
-			}
-
-			ota = newDeltaObject(oh.Offset, oh.Length, t, parent)
-			parent.Children = append(parent.Children, ota)
-		case plumbing.REFDeltaObject:
-			delta = true
-			parent, ok := p.oiByHash[oh.Reference]
-			if !ok {
-				// can't find referenced object in this pack file
-				// this must be a "thin" pack.
-				parent = &objectInfo{ //Placeholder parent
-					SHA1:        oh.Reference,
-					ExternalRef: true, // mark as an external reference that must be resolved
-					Type:        plumbing.AnyObject,
-					DiskType:    plumbing.AnyObject,
+			if oh.Type.IsDelta() {
+				if oh.Type == plumbing.OFSDeltaObject {
+					pendingDeltas = append(pendingDeltas, &oh)
+				} else if oh.Type == plumbing.REFDeltaObject {
+					pendingDeltaREFs = append(pendingDeltaREFs, &oh)
 				}
-				p.oiByHash[oh.Reference] = parent
+				continue
+			} else {
+				p.storeOrCache(&oh)
 			}
-			ota = newDeltaObject(oh.Offset, oh.Length, t, parent)
-			parent.Children = append(parent.Children, ota)
 
-		default:
-			ota = newBaseObject(oh.Offset, oh.Length, t)
+		case FooterSection:
+			p.checksum = data.Value().(plumbing.Hash)
 		}
+	}
 
-		hasher := plumbing.NewHasher(oh.Type, oh.Length)
-		writers := []io.Writer{hasher}
-		var obj *plumbing.MemoryObject
+	if p.scanner.objects == 0 {
+		return plumbing.ZeroHash, ErrEmptyPackfile
+	}
 
-		// Lazy writing is only available for non-delta objects.
-		if p.storage != nil && !delta {
-			// When a storage is set and supports lazy writing,
-			// use that instead of creating a memory object.
-			if low, ok := p.storage.(lazyObjectWriter); ok {
-				ow, lwh, err := low.LazyWriter()
-				if err != nil {
-					return err
-				}
-
-				if err = lwh(oh.Type, oh.Length); err != nil {
-					return err
-				}
-
-				defer ow.Close()
-				writers = append(writers, ow)
-			} else {
-				obj = new(plumbing.MemoryObject)
-				obj.SetSize(oh.Length)
-				obj.SetType(oh.Type)
-
-				writers = append(writers, obj)
-			}
+	for _, oh := range pendingDeltas {
+		err := p.processDelta(oh)
+		if err != nil {
+			return plumbing.ZeroHash, err
 		}
-		if delta && !p.scanner.IsSeekable {
-			buf.Reset()
-			buf.Grow(int(oh.Length))
-			writers = append(writers, buf)
-		}
-
-		mw := io.MultiWriter(writers...)
+	}
 
-		_, crc, err := p.scanner.NextObject(mw)
+	for _, oh := range pendingDeltaREFs {
+		err := p.processDelta(oh)
 		if err != nil {
-			return err
-		}
-
-		// Non delta objects needs to be added into the storage. This
-		// is only required when lazy writing is not supported.
-		if obj != nil {
-			if _, err := p.storage.SetEncodedObject(obj); err != nil {
-				return err
-			}
+			return plumbing.ZeroHash, err
 		}
-
-		ota.Crc32 = crc
-		ota.Length = oh.Length
-
-		if !delta {
-			sha1 := hasher.Sum()
-
-			// Move children of placeholder parent into actual parent, in case this
-			// was a non-external delta reference.
-			if placeholder, ok := p.oiByHash[sha1]; ok {
-				ota.Children = placeholder.Children
-				for _, c := range ota.Children {
-					c.Parent = ota
-				}
-			}
-
-			ota.SHA1 = sha1
-			p.oiByHash[ota.SHA1] = ota
-		}
-
-		if delta && !p.scanner.IsSeekable {
-			data := buf.Bytes()
-			p.deltas[oh.Offset] = make([]byte, len(data))
-			copy(p.deltas[oh.Offset], data)
-		}
-
-		p.oiByOffset[oh.Offset] = ota
-		p.oi[i] = ota
 	}
 
-	return nil
+	return p.checksum, p.onFooter(p.checksum)
 }
 
-func (p *Parser) resolveDeltas() error {
-	buf := sync.GetBytesBuffer()
-	defer sync.PutBytesBuffer(buf)
-
-	for _, obj := range p.oi {
-		buf.Reset()
-		buf.Grow(int(obj.Length))
-		err := p.get(obj, buf)
-		if err != nil {
-			return err
+func (p *Parser) processDelta(oh *ObjectHeader) error {
+	switch oh.Type {
+	case plumbing.OFSDeltaObject:
+		pa, ok := p.cache.oiByOffset[oh.OffsetReference]
+		if !ok {
+			return plumbing.ErrObjectNotFound
 		}
+		oh.parent = pa
 
-		if err := p.onInflatedObjectHeader(obj.Type, obj.Length, obj.Offset); err != nil {
-			return err
-		}
-
-		if err := p.onInflatedObjectContent(obj.SHA1, obj.Offset, obj.Crc32, nil); err != nil {
-			return err
-		}
-
-		if !obj.IsDelta() && len(obj.Children) > 0 {
-			// Dealing with an io.ReaderAt object, means we can
-			// create it once and reuse across all children.
-			r := bytes.NewReader(buf.Bytes())
-			for _, child := range obj.Children {
-				// Even though we are discarding the output, we still need to read it to
-				// so that the scanner can advance to the next object, and the SHA1 can be
-				// calculated.
-				if err := p.resolveObject(io.Discard, child, r); err != nil {
-					return err
-				}
-				p.resolveExternalRef(child)
+	case plumbing.REFDeltaObject:
+		pa, ok := p.cache.oiByHash[oh.Reference]
+		if !ok {
+			// can't find referenced object in this pack file
+			// this must be a "thin" pack.
+			oh.parent = &ObjectHeader{ //Placeholder parent
+				Hash:        oh.Reference,
+				externalRef: true, // mark as an external reference that must be resolved
+				Type:        plumbing.AnyObject,
+				diskType:    plumbing.AnyObject,
 			}
-
-			// Remove the delta from the cache.
-			if obj.DiskType.IsDelta() && !p.scanner.IsSeekable {
-				delete(p.deltas, obj.Offset)
-			}
+		} else {
+			oh.parent = pa
 		}
-	}
+		p.cache.oiByHash[oh.Reference] = oh.parent
 
-	return nil
-}
-
-func (p *Parser) resolveExternalRef(o *objectInfo) {
-	if ref, ok := p.oiByHash[o.SHA1]; ok && ref.ExternalRef {
-		p.oiByHash[o.SHA1] = o
-		o.Children = ref.Children
-		for _, c := range o.Children {
-			c.Parent = o
-		}
+	default:
+		return fmt.Errorf("unsupported delta type: %v", oh.Type)
 	}
-}
 
-func (p *Parser) get(o *objectInfo, buf *bytes.Buffer) (err error) {
-	if !o.ExternalRef { // skip cache check for placeholder parents
-		b, ok := p.cache.Get(o.Offset)
-		if ok {
-			_, err := buf.Write(b)
-			return err
-		}
-	}
-
-	// If it's not on the cache and is not a delta we can try to find it in the
-	// storage, if there's one. External refs must enter here.
-	if p.storage != nil && !o.Type.IsDelta() {
-		var e plumbing.EncodedObject
-		e, err = p.storage.EncodedObject(plumbing.AnyObject, o.SHA1)
-		if err != nil {
-			return err
-		}
-		o.Type = e.Type()
-
-		var r io.ReadCloser
-		r, err = e.Reader()
-		if err != nil {
-			return err
-		}
-
-		defer ioutil.CheckClose(r, &err)
-
-		_, err = buf.ReadFrom(io.LimitReader(r, e.Size()))
+	parentContents, err := p.parentReader(oh.parent)
+	if err != nil {
 		return err
 	}
 
-	if o.ExternalRef {
-		// we were not able to resolve a ref in a thin pack
-		return ErrReferenceDeltaNotFound
-	}
-
-	if o.DiskType.IsDelta() {
-		b := sync.GetBytesBuffer()
-		defer sync.PutBytesBuffer(b)
-		buf.Grow(int(o.Length))
-		err := p.get(o.Parent, b)
-		if err != nil {
-			return err
-		}
-
-		err = p.resolveObject(buf, o, bytes.NewReader(b.Bytes()))
-		if err != nil {
-			return err
-		}
+	var deltaData bytes.Buffer
+	if oh.content.Len() > 0 {
+		oh.content.WriteTo(&deltaData)
 	} else {
-		err := p.readData(buf, o)
+		deltaData = *bytes.NewBuffer(make([]byte, 0, oh.Size))
+		err = p.scanner.inflateContent(oh.ContentOffset, &deltaData)
 		if err != nil {
 			return err
 		}
 	}
 
-	// If the scanner is seekable, caching this data into
-	// memory by offset seems wasteful.
-	// There is a trade-off to be considered here in terms
-	// of execution time vs memory consumption.
-	//
-	// TODO: improve seekable execution time, so that we can
-	// skip this cache.
-	if len(o.Children) > 0 {
-		data := make([]byte, buf.Len())
-		copy(data, buf.Bytes())
-		p.cache.Put(o.Offset, data)
+	w, err := p.cacheWriter(oh)
+	if err != nil {
+		return err
 	}
-	return nil
-}
+
+	defer w.Close()
 
-// resolveObject resolves an object from base, using information
-// provided by o.
-//
-// This call has the side-effect of changing field values
-// from the object info o:
-//   - Type: OFSDeltaObject may become the target type (e.g. Blob).
-//   - Size: The size may be update with the target size.
-//   - Hash: Zero hashes will be calculated as part of the object
-//     resolution. Hence why this process can't be avoided even when w
-//     is an io.Discard.
-//
-// base must be an io.ReaderAt, which is a requirement from
-// patchDeltaStream. The main reason being that reversing an
-// delta object may lead to going backs and forths within base,
-// which is not supported by io.Reader.
-func (p *Parser) resolveObject(
-	w io.Writer,
-	o *objectInfo,
-	base io.ReaderAt,
-) error {
-	if !o.DiskType.IsDelta() {
-		return nil
-	}
-	buf := sync.GetBytesBuffer()
-	defer sync.PutBytesBuffer(buf)
-	err := p.readData(buf, o)
+	err = applyPatchBaseHeader(oh, parentContents, &deltaData, w, nil)
 	if err != nil {
 		return err
 	}
 
-	writers := []io.Writer{w}
-	var obj *plumbing.MemoryObject
-	var lwh objectHeaderWriter
+	p.storeOrCache(oh)
 
-	if p.storage != nil {
-		if low, ok := p.storage.(lazyObjectWriter); ok {
-			ow, wh, err := low.LazyWriter()
-			if err != nil {
-				return err
-			}
-			lwh = wh
+	return nil
+}
 
-			defer ow.Close()
-			writers = append(writers, ow)
-		} else {
-			obj = new(plumbing.MemoryObject)
-			ow, err := obj.Writer()
-			if err != nil {
-				return err
-			}
+func (p *Parser) parentReader(parent *ObjectHeader) (io.ReaderAt, error) {
+	// If parent is a Delta object, the inflated object must come
+	// from either cache or storage, else we would need to inflate
+	// it to then inflate the current object, which could go on
+	// indefinitely.
 
-			writers = append(writers, ow)
+	if p.storage != nil && parent.Hash != plumbing.ZeroHash {
+		obj, err := p.storage.EncodedObject(parent.Type, parent.Hash)
+		if err == nil {
+			r, err := obj.Reader()
+			if err == nil {
+				parentData := bytes.NewBuffer(make([]byte, 0, parent.Size))
+
+				_, err = io.Copy(parentData, r)
+				if err == nil {
+					return bytes.NewReader(parentData.Bytes()), nil
+				}
+			}
 		}
 	}
 
-	mw := io.MultiWriter(writers...)
-
-	err = applyPatchBase(o, base, buf, mw, lwh)
-	if err != nil {
-		return err
+	if p.cache != nil && parent.content.Len() > 0 {
+		return bytes.NewReader(parent.content.Bytes()), nil
 	}
 
-	if obj != nil {
-		obj.SetType(o.Type)
-		obj.SetSize(o.Size()) // Size here is correct as it was populated by applyPatchBase.
-		if _, err := p.storage.SetEncodedObject(obj); err != nil {
-			return err
-		}
+	// If the parent is not an external ref and we don't have the
+	// content offset, we won't be able to inflate via seeking through
+	// the packfile.
+	if parent.externalRef && parent.ContentOffset == 0 {
+		return nil, plumbing.ErrObjectNotFound
 	}
-	return err
-}
 
-func (p *Parser) readData(w io.Writer, o *objectInfo) error {
-	if !p.scanner.IsSeekable && o.DiskType.IsDelta() {
-		data, ok := p.deltas[o.Offset]
-		if !ok {
-			return ErrDeltaNotCached
-		}
-		_, err := w.Write(data)
-		return err
+	// Not a seeker data source, so avoid seeking the content.
+	if p.scanner.seeker == nil {
+		return nil, plumbing.ErrObjectNotFound
 	}
 
-	if _, err := p.scanner.SeekObjectHeader(o.Offset); err != nil {
-		return err
+	parentData := bytes.NewBuffer(make([]byte, 0, parent.Size))
+	err := p.scanner.inflateContent(parent.ContentOffset, parentData)
+	if err != nil {
+		return nil, ErrReferenceDeltaNotFound
 	}
+	return bytes.NewReader(parentData.Bytes()), nil
+}
 
-	if _, _, err := p.scanner.NextObject(w); err != nil {
-		return err
-	}
-	return nil
+func (p *Parser) cacheWriter(oh *ObjectHeader) (io.WriteCloser, error) {
+	return ioutil.NewWriteCloser(&oh.content, nil), nil
 }
 
-// applyPatchBase applies the patch to target.
-//
-// Note that ota will be updated based on the description in resolveObject.
-func applyPatchBase(ota *objectInfo, base io.ReaderAt, delta io.Reader, target io.Writer, wh objectHeaderWriter) error {
+func applyPatchBaseHeader(ota *ObjectHeader, base io.ReaderAt, delta io.Reader, target io.Writer, wh objectHeaderWriter) error {
 	if target == nil {
 		return fmt.Errorf("cannot apply patch against nil target")
 	}
 
 	typ := ota.Type
-	if ota.SHA1 == plumbing.ZeroHash {
-		typ = ota.Parent.Type
+	if ota.Hash == plumbing.ZeroHash {
+		typ = ota.parent.Type
 	}
 
 	sz, h, err := patchDeltaWriter(target, base, delta, typ, wh)
···
 		return err
 	}
 
-	if ota.SHA1 == plumbing.ZeroHash {
+	if ota.Hash == plumbing.ZeroHash {
 		ota.Type = typ
-		ota.Length = int64(sz)
-		ota.SHA1 = h
+		ota.Size = int64(sz)
+		ota.Hash = h
 	}
 
 	return nil
 }
 
-func getSHA1(t plumbing.ObjectType, data []byte) (plumbing.Hash, error) {
-	hasher := plumbing.NewHasher(t, int64(len(data)))
-	if _, err := hasher.Write(data); err != nil {
-		return plumbing.ZeroHash, err
+func (p *Parser) forEachObserver(f func(o Observer) error) error {
+	for _, o := range p.observers {
+		if err := f(o); err != nil {
+			return err
+		}
 	}
-
-	return hasher.Sum(), nil
-}
-
-type objectInfo struct {
-	Offset      int64
-	Length      int64
-	Type        plumbing.ObjectType
-	DiskType    plumbing.ObjectType
-	ExternalRef bool // indicates this is an external reference in a thin pack file
-
-	Crc32 uint32
-
-	Parent   *objectInfo
-	Children []*objectInfo
-	SHA1     plumbing.Hash
+	return nil
 }
 
-func newBaseObject(offset, length int64, t plumbing.ObjectType) *objectInfo {
-	return newDeltaObject(offset, length, t, nil)
+func (p *Parser) onHeader(count uint32) error {
+	return p.forEachObserver(func(o Observer) error {
+		return o.OnHeader(count)
+	})
 }
 
-func newDeltaObject(
-	offset, length int64,
+func (p *Parser) onInflatedObjectHeader(
 	t plumbing.ObjectType,
-	parent *objectInfo,
-) *objectInfo {
-	obj := &objectInfo{
-		Offset:   offset,
-		Length:   length,
-		Type:     t,
-		DiskType: t,
-		Crc32:    0,
-		Parent:   parent,
-	}
-
-	return obj
+	objSize int64,
+	pos int64,
+) error {
+	return p.forEachObserver(func(o Observer) error {
+		return o.OnInflatedObjectHeader(t, objSize, pos)
+	})
 }
 
-func (o *objectInfo) IsDelta() bool {
-	return o.Type.IsDelta()
+func (p *Parser) onInflatedObjectContent(
+	h plumbing.Hash,
+	pos int64,
+	crc uint32,
+	content []byte,
+) error {
+	return p.forEachObserver(func(o Observer) error {
+		return o.OnInflatedObjectContent(h, pos, crc, content)
+	})
 }
 
-func (o *objectInfo) Size() int64 {
-	return o.Length
+func (p *Parser) onFooter(h plumbing.Hash) error {
+	return p.forEachObserver(func(o Observer) error {
+		return o.OnFooter(h)
+	})
 }

plumbing/format/packfile/parser_cache.go

···
+package packfile
+
+import (
+	"slices"
+
+	"github.com/go-git/go-git/v5/plumbing"
+	"golang.org/x/exp/maps"
+)
+
+func newParserCache() *parserCache {
+	c := &parserCache{}
+	return c
+}
+
+// parserCache defines the cache used within the parser.
+// This is not thread safe by itself, and relies on the parser to
+// enforce thread-safety.
+type parserCache struct {
+	oi         []*ObjectHeader
+	oiByHash   map[plumbing.Hash]*ObjectHeader
+	oiByOffset map[int64]*ObjectHeader
+}
+
+func (c *parserCache) Add(oh *ObjectHeader) {
+	c.oiByHash[oh.Hash] = oh
+	c.oiByOffset[oh.Offset] = oh
+	c.oi = append(c.oi, oh)
+}
+
+func (c *parserCache) Reset(n int) {
+	if c.oi == nil {
+		c.oi = make([]*ObjectHeader, 0, n)
+		c.oiByHash = make(map[plumbing.Hash]*ObjectHeader, n)
+		c.oiByOffset = make(map[int64]*ObjectHeader, n)
+	} else {
+		c.oi = c.oi[:0]
+		c.oi = slices.Grow(c.oi, n)
+
+		maps.Clear(c.oiByHash)
+		maps.Clear(c.oiByOffset)
+	}
+}

plumbing/format/packfile/parser_options.go

···
+package packfile
+
+import (
+	"github.com/go-git/go-git/v5/plumbing/storer"
+)
+
+type ParserOption func(*Parser)
+
+// WithStorage sets the storage to be used while parsing a pack file.
+func WithStorage(storage storer.EncodedObjectStorer) ParserOption {
+	return func(p *Parser) {
+		p.storage = storage
+	}
+}
+
+// WithScannerObservers sets the observers to be notified during the
+// scanning or parsing of a pack file. The scanner is responsible for
+// notifying observers around general pack file information, such as
+// header and footer. The scanner also notifies object headers for
+// non-delta objects.
+//
+// Delta objects are notified as part of the parser logic.
+func WithScannerObservers(ob ...Observer) ParserOption {
+	return func(p *Parser) {
+		p.observers = ob
+	}
+}

plumbing/format/packfile/parser_test.go

···
 
 import (
 	"io"
-	"os"
 	"testing"
 
+	billy "github.com/go-git/go-billy/v5"
 	"github.com/go-git/go-billy/v5/osfs"
-	"github.com/go-git/go-billy/v5/util"
-	fixtures "github.com/go-git/go-git-fixtures/v4"
+	fixtures "github.com/go-git/go-git-fixtures/v5"
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/cache"
 	"github.com/go-git/go-git/v5/plumbing/format/packfile"
 	"github.com/go-git/go-git/v5/plumbing/storer"
 	"github.com/go-git/go-git/v5/storage/filesystem"
-	. "gopkg.in/check.v1"
+	"github.com/go-git/go-git/v5/storage/memory"
+	"github.com/stretchr/testify/assert"
 )
 
-type ParserSuite struct {
-	fixtures.Suite
-}
+func TestParserHashes(t *testing.T) {
+	tests := []struct {
+		name    string
+		storage storer.Storer
+	}{
+		{
+			name: "without storage",
+		},
+		{
+			name:    "with storage",
+			storage: filesystem.NewStorage(osfs.New(t.TempDir()), cache.NewObjectLRUDefault()),
+		},
+	}
 
-var _ = Suite(&ParserSuite{})
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			f := fixtures.Basic().One()
 
-func (s *ParserSuite) TestParserHashes(c *C) {
-	f := fixtures.Basic().One()
-	scanner := packfile.NewScanner(f.Packfile())
+			obs := new(testObserver)
+			parser := packfile.NewParser(f.Packfile(), packfile.WithScannerObservers(obs),
+				packfile.WithStorage(tc.storage))
 
-	obs := new(testObserver)
-	parser, err := packfile.NewParser(scanner, obs)
-	c.Assert(err, IsNil)
+			commit := plumbing.CommitObject
+			blob := plumbing.BlobObject
+			tree := plumbing.TreeObject
 
-	ch, err := parser.Parse()
-	c.Assert(err, IsNil)
+			objs := []observerObject{
+				{hash: "e8d3ffab552895c19b9fcf7aa264d277cde33881", otype: commit, size: 254, offset: 12, crc: 0xaa07ba4b},
+				{hash: "918c48b83bd081e863dbe1b80f8998f058cd8294", otype: commit, size: 242, offset: 286, crc: 0x12438846},
+				{hash: "af2d6a6954d532f8ffb47615169c8fdf9d383a1a", otype: commit, size: 242, offset: 449, crc: 0x2905a38c},
+				{hash: "1669dce138d9b841a518c64b10914d88f5e488ea", otype: commit, size: 333, offset: 615, crc: 0xd9429436},
+				{hash: "a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69", otype: commit, size: 332, offset: 838, crc: 0xbecfde4e},
+				{hash: "35e85108805c84807bc66a02d91535e1e24b38b9", otype: commit, size: 244, offset: 1063, crc: 0x780e4b3e},
+				{hash: "b8e471f58bcbca63b07bda20e428190409c2db47", otype: commit, size: 243, offset: 1230, crc: 0xdc18344f},
+				{hash: "b029517f6300c2da0f4b651b8642506cd6aaf45d", otype: commit, size: 187, offset: 1392, crc: 0xcf4e4280},
+				{hash: "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88", otype: blob, size: 189, offset: 1524, crc: 0x1f08118a},
+				{hash: "d3ff53e0564a9f87d8e84b6e28e5060e517008aa", otype: blob, size: 18, offset: 1685, crc: 0xafded7b8},
+				{hash: "c192bd6a24ea1ab01d78686e417c8bdc7c3d197f", otype: blob, size: 1072, offset: 1713, crc: 0xcc1428ed},
+				{hash: "d5c0f4ab811897cadf03aec358ae60d21f91c50d", otype: blob, size: 76110, offset: 2351, crc: 0x1631d22f},
+				{hash: "880cd14280f4b9b6ed3986d6671f907d7cc2a198", otype: blob, size: 2780, offset: 78050, crc: 0xbfff5850},
+				{hash: "49c6bb89b17060d7b4deacb7b338fcc6ea2352a9", otype: blob, size: 217848, offset: 78882, crc: 0xd108e1d8},
+				{hash: "c8f1d8c61f9da76f4cb49fd86322b6e685dba956", otype: blob, size: 706, offset: 80725, crc: 0x8e97ba25},
+				{hash: "9a48f23120e880dfbe41f7c9b7b708e9ee62a492", otype: blob, size: 11488, offset: 80998, crc: 0x7316ff70},
+				{hash: "9dea2395f5403188298c1dabe8bdafe562c491e3", otype: blob, size: 78, offset: 84032, crc: 0xdb4fce56},
+				{hash: "dbd3641b371024f44d0e469a9c8f5457b0660de1", otype: tree, size: 272, offset: 84115, crc: 0x901cce2c},
+				{hash: "a39771a7651f97faf5c72e08224d857fc35133db", otype: tree, size: 38, offset: 84430, crc: 0x847905bf},
+				{hash: "5a877e6a906a2743ad6e45d99c1793642aaf8eda", otype: tree, size: 75, offset: 84479, crc: 0x3689459a},
+				{hash: "586af567d0bb5e771e49bdd9434f5e0fb76d25fa", otype: tree, size: 38, offset: 84559, crc: 0xe67af94a},
+				{hash: "cf4aa3b38974fb7d81f367c0830f7d78d65ab86b", otype: tree, size: 34, offset: 84608, crc: 0xc2314a2e},
+				{hash: "7e59600739c96546163833214c36459e324bad0a", otype: blob, size: 9, offset: 84653, crc: 0xcd987848},
+				{hash: "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", otype: commit, size: 245, offset: 186, crc: 0xf706df58},
+				{hash: "a8d315b2b1c615d43042c3a62402b8a54288cf5c", otype: tree, size: 271, offset: 84375, crc: 0xec4552b0},
+				{hash: "fb72698cab7617ac416264415f13224dfd7a165e", otype: tree, size: 238, offset: 84671, crc: 0x8a853a6d},
+				{hash: "4d081c50e250fa32ea8b1313cf8bb7c2ad7627fd", otype: tree, size: 179, offset: 84688, crc: 0x70c6518},
+				{hash: "eba74343e2f15d62adedfd8c883ee0262b5c8021", otype: tree, size: 148, offset: 84708, crc: 0x4f4108e2},
+				{hash: "c2d30fa8ef288618f65f6eed6e168e0d514886f4", otype: tree, size: 110, offset: 84725, crc: 0xd6fe09e9},
+				{hash: "8dcef98b1d52143e1e2dbc458ffe38f925786bf2", otype: tree, size: 111, offset: 84741, crc: 0xf07a2804},
+				{hash: "aa9b383c260e1d05fbbf6b30a02914555e20c725", otype: tree, size: 73, offset: 84760, crc: 0x1d75d6be},
+			}
 
-	checksum := "a3fed42da1e8189a077c0e6846c040dcf73fc9dd"
-	c.Assert(ch.String(), Equals, checksum)
+			_, err := parser.Parse()
+			assert.NoError(t, err)
 
-	c.Assert(obs.checksum, Equals, checksum)
-	c.Assert(int(obs.count), Equals, int(31))
-
-	commit := plumbing.CommitObject
-	blob := plumbing.BlobObject
-	tree := plumbing.TreeObject
-
-	objs := []observerObject{
-		{"e8d3ffab552895c19b9fcf7aa264d277cde33881", commit, 254, 12, 0xaa07ba4b},
-		{"6ecf0ef2c2dffb796033e5a02219af86ec6584e5", commit, 245, 186, 0xf706df58},
-		{"918c48b83bd081e863dbe1b80f8998f058cd8294", commit, 242, 286, 0x12438846},
-		{"af2d6a6954d532f8ffb47615169c8fdf9d383a1a", commit, 242, 449, 0x2905a38c},
-		{"1669dce138d9b841a518c64b10914d88f5e488ea", commit, 333, 615, 0xd9429436},
-		{"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69", commit, 332, 838, 0xbecfde4e},
-		{"35e85108805c84807bc66a02d91535e1e24b38b9", commit, 244, 1063, 0x780e4b3e},
-		{"b8e471f58bcbca63b07bda20e428190409c2db47", commit, 243, 1230, 0xdc18344f},
-		{"b029517f6300c2da0f4b651b8642506cd6aaf45d", commit, 187, 1392, 0xcf4e4280},
-		{"32858aad3c383ed1ff0a0f9bdf231d54a00c9e88", blob, 189, 1524, 0x1f08118a},
-		{"d3ff53e0564a9f87d8e84b6e28e5060e517008aa", blob, 18, 1685, 0xafded7b8},
-		{"c192bd6a24ea1ab01d78686e417c8bdc7c3d197f", blob, 1072, 1713, 0xcc1428ed},
-		{"d5c0f4ab811897cadf03aec358ae60d21f91c50d", blob, 76110, 2351, 0x1631d22f},
-		{"880cd14280f4b9b6ed3986d6671f907d7cc2a198", blob, 2780, 78050, 0xbfff5850},
-		{"49c6bb89b17060d7b4deacb7b338fcc6ea2352a9", blob, 217848, 78882, 0xd108e1d8},
-		{"c8f1d8c61f9da76f4cb49fd86322b6e685dba956", blob, 706, 80725, 0x8e97ba25},
-		{"9a48f23120e880dfbe41f7c9b7b708e9ee62a492", blob, 11488, 80998, 0x7316ff70},
-		{"9dea2395f5403188298c1dabe8bdafe562c491e3", blob, 78, 84032, 0xdb4fce56},
-		{"dbd3641b371024f44d0e469a9c8f5457b0660de1", tree, 272, 84115, 0x901cce2c},
-		{"a8d315b2b1c615d43042c3a62402b8a54288cf5c", tree, 271, 84375, 0xec4552b0},
-		{"a39771a7651f97faf5c72e08224d857fc35133db", tree, 38, 84430, 0x847905bf},
-		{"5a877e6a906a2743ad6e45d99c1793642aaf8eda", tree, 75, 84479, 0x3689459a},
-		{"586af567d0bb5e771e49bdd9434f5e0fb76d25fa", tree, 38, 84559, 0xe67af94a},
-		{"cf4aa3b38974fb7d81f367c0830f7d78d65ab86b", tree, 34, 84608, 0xc2314a2e},
-		{"7e59600739c96546163833214c36459e324bad0a", blob, 9, 84653, 0xcd987848},
-		{"fb72698cab7617ac416264415f13224dfd7a165e", tree, 238, 84671, 0x8a853a6d},
-		{"4d081c50e250fa32ea8b1313cf8bb7c2ad7627fd", tree, 179, 84688, 0x70c6518},
-		{"eba74343e2f15d62adedfd8c883ee0262b5c8021", tree, 148, 84708, 0x4f4108e2},
-		{"c2d30fa8ef288618f65f6eed6e168e0d514886f4", tree, 110, 84725, 0xd6fe09e9},
-		{"8dcef98b1d52143e1e2dbc458ffe38f925786bf2", tree, 111, 84741, 0xf07a2804},
-		{"aa9b383c260e1d05fbbf6b30a02914555e20c725", tree, 73, 84760, 0x1d75d6be},
+			assert.Equal(t, "a3fed42da1e8189a077c0e6846c040dcf73fc9dd", obs.checksum)
+			assert.Equal(t, objs, obs.objects)
+		})
 	}
-
-	c.Assert(obs.objects, DeepEquals, objs)
 }
 
-func (s *ParserSuite) TestThinPack(c *C) {
-	fs := osfs.New(os.TempDir())
-	path, err := util.TempDir(fs, "", "")
-	c.Assert(err, IsNil)
-
+func TestThinPack(t *testing.T) {
 	// Initialize an empty repository
-	r, err := git.PlainInit(path, true)
-	c.Assert(err, IsNil)
+	r, err := git.PlainInit(t.TempDir(), true)
+	assert.NoError(t, err)
 
 	// Try to parse a thin pack without having the required objects in the repo to
 	// see if the correct errors are returned
 	thinpack := fixtures.ByTag("thinpack").One()
-	scanner := packfile.NewScanner(thinpack.Packfile())
-	parser, err := packfile.NewParserWithStorage(scanner, r.Storer) // ParserWithStorage writes to the storer all parsed objects!
-	c.Assert(err, IsNil)
+	parser := packfile.NewParser(thinpack.Packfile(), packfile.WithStorage(r.Storer)) // ParserWithStorage writes to the storer all parsed objects!
+	assert.NoError(t, err)
 
 	_, err = parser.Parse()
-	c.Assert(err, Equals, plumbing.ErrObjectNotFound)
-
-	path, err = util.TempDir(fs, "", "")
-	c.Assert(err, IsNil)
+	assert.Equal(t, err, plumbing.ErrObjectNotFound)
 
 	// start over with a clean repo
-	r, err = git.PlainInit(path, true)
-	c.Assert(err, IsNil)
+	r, err = git.PlainInit(t.TempDir(), true)
+	assert.NoError(t, err)
 
 	// Now unpack a base packfile into our empty repo:
 	f := fixtures.ByURL("https://github.com/spinnaker/spinnaker.git").One()
 	w, err := r.Storer.(storer.PackfileWriter).PackfileWriter()
-	c.Assert(err, IsNil)
+	assert.NoError(t, err)
 	_, err = io.Copy(w, f.Packfile())
-	c.Assert(err, IsNil)
+	assert.NoError(t, err)
 	w.Close()
 
 	// Check that the test object that will come with our thin pack is *not* in the repo
 	_, err = r.Storer.EncodedObject(plumbing.CommitObject, plumbing.NewHash(thinpack.Head))
-	c.Assert(err, Equals, plumbing.ErrObjectNotFound)
+	assert.ErrorIs(t, err, plumbing.ErrObjectNotFound)
 
 	// Now unpack the thin pack:
-	scanner = packfile.NewScanner(thinpack.Packfile())
-	parser, err = packfile.NewParserWithStorage(scanner, r.Storer) // ParserWithStorage writes to the storer all parsed objects!
-	c.Assert(err, IsNil)
+	parser = packfile.NewParser(thinpack.Packfile(), packfile.WithStorage(r.Storer)) // ParserWithStorage writes to the storer all parsed objects!
 
 	h, err := parser.Parse()
-	c.Assert(err, IsNil)
-	c.Assert(h, Equals, plumbing.NewHash("1288734cbe0b95892e663221d94b95de1f5d7be8"))
+	assert.NoError(t, err)
+	assert.Equal(t, plumbing.NewHash("1288734cbe0b95892e663221d94b95de1f5d7be8"), h)
 
 	// Check that our test object is now accessible
 	_, err = r.Storer.EncodedObject(plumbing.CommitObject, plumbing.NewHash(thinpack.Head))
-	c.Assert(err, IsNil)
+	assert.NoError(t, err)
+}
+
+func TestResolveExternalRefsInThinPack(t *testing.T) {
+	extRefsThinPack := fixtures.ByTag("codecommit").One().Packfile()
+
+	parser := packfile.NewParser(extRefsThinPack)
+
+	checksum, err := parser.Parse()
+	assert.NoError(t, err)
+	assert.NotEqual(t, plumbing.ZeroHash, checksum)
+}
+
+func TestResolveExternalRefs(t *testing.T) {
+	extRefsThinPack := fixtures.ByTag("delta-before-base").One().Packfile()
 
+	parser := packfile.NewParser(extRefsThinPack)
+
+	checksum, err := parser.Parse()
+	assert.NoError(t, err)
+	assert.NotEqual(t, plumbing.ZeroHash, checksum)
 }
 
-func (s *ParserSuite) TestResolveExternalRefsInThinPack(c *C) {
-	extRefsThinPack := fixtures.ByTag("codecommit").One()
+func TestMemoryResolveExternalRefs(t *testing.T) {
+	extRefsThinPack := fixtures.ByTag("delta-before-base").One().Packfile()
+
+	parser := packfile.NewParser(extRefsThinPack, packfile.WithStorage(memory.NewStorage()))
 
-	scanner := packfile.NewScanner(extRefsThinPack.Packfile())
+	checksum, err := parser.Parse()
+	assert.NoError(t, err)
+	assert.NotEqual(t, plumbing.ZeroHash, checksum)
+}
 
-	obs := new(testObserver)
-	parser, err := packfile.NewParser(scanner, obs)
-	c.Assert(err, IsNil)
+func BenchmarkParseBasic(b *testing.B) {
+	f := fixtures.Basic().One().Packfile()
+	scanner := packfile.NewScanner(f)
+	storage := filesystem.NewStorage(osfs.New(b.TempDir()), cache.NewObjectLRUDefault())
 
-	_, err = parser.Parse()
-	c.Assert(err, IsNil)
+	b.Run("with storage", func(b *testing.B) {
+		benchmarkParseBasic(b, f, scanner, packfile.WithStorage(storage))
+	})
+	b.Run("with memory storage", func(b *testing.B) {
+		benchmarkParseBasic(b, f, scanner, packfile.WithStorage(memory.NewStorage()))
+	})
+	b.Run("without storage", func(b *testing.B) {
+		benchmarkParseBasic(b, f, scanner)
+	})
 }
 
-func (s *ParserSuite) TestResolveExternalRefs(c *C) {
-	extRefsThinPack := fixtures.ByTag("delta-before-base").One()
+func benchmarkParseBasic(b *testing.B,
+	f billy.File, scanner *packfile.Scanner,
+	opts ...packfile.ParserOption) {
+	for i := 0; i < b.N; i++ {
+		f.Seek(0, io.SeekStart)
+		scanner.Reset()
+		parser := packfile.NewParser(scanner, opts...)
+
+		checksum, err := parser.Parse()
+		if err != nil {
+			b.Fatal(err)
+		}
 
-	scanner := packfile.NewScanner(extRefsThinPack.Packfile())
+		if checksum == plumbing.ZeroHash {
+			b.Fatal("failed to parse")
+		}
+	}
+}
 
-	obs := new(testObserver)
-	parser, err := packfile.NewParser(scanner, obs)
-	c.Assert(err, IsNil)
+func BenchmarkParse(b *testing.B) {
+	for _, f := range fixtures.ByTag("packfile") {
+		scanner := packfile.NewScanner(f.Packfile())
 
-	_, err = parser.Parse()
-	c.Assert(err, IsNil)
+		b.Run(f.URL, func(b *testing.B) {
+			benchmarkParseBasic(b, f.Packfile(), scanner)
+		})
+	}
 }
 
 type observerObject struct {
···
 	t.pos[pos] = len(t.objects)
 	t.objects = append(t.objects, o)
 }
-
-func BenchmarkParse(b *testing.B) {
-	defer fixtures.Clean()
-
-	for _, f := range fixtures.ByTag("packfile") {
-		b.Run(f.URL, func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
-				parser, err := packfile.NewParser(packfile.NewScanner(f.Packfile()))
-				if err != nil {
-					b.Fatal(err)
-				}
-
-				_, err = parser.Parse()
-				if err != nil {
-					b.Fatal(err)
-				}
-			}
-		})
-	}
-}
-
-func BenchmarkParseBasic(b *testing.B) {
-	defer fixtures.Clean()
-
-	f := fixtures.Basic().One()
-	for i := 0; i < b.N; i++ {
-		parser, err := packfile.NewParser(packfile.NewScanner(f.Packfile()))
-		if err != nil {
-			b.Fatal(err)
-		}
-
-		_, err = parser.Parse()
-		if err != nil {
-			b.Fatal(err)
-		}
-	}
-}
-
-func BenchmarkParser(b *testing.B) {
-	f := fixtures.Basic().One()
-	defer fixtures.Clean()
-
-	b.ResetTimer()
-	for n := 0; n < b.N; n++ {
-		b.StopTimer()
-		scanner := packfile.NewScanner(f.Packfile())
-		fs := osfs.New(os.TempDir())
-		storage := filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
-
-		parser, err := packfile.NewParserWithStorage(scanner, storage)
-		if err != nil {
-			b.Error(err)
-		}
-
-		b.StartTimer()
-		_, err = parser.Parse()
-
-		b.StopTimer()
-		if err != nil {
-			b.Error(err)
-		}
-	}
-}

plumbing/format/packfile/parser_types.go

···
+package packfile
+
+import (
+	"github.com/go-git/go-git/v5/plumbing"
+)
+
+// Observer interface is implemented by index encoders.
+type Observer interface {
+	// OnHeader is called when a new packfile is opened.
+	OnHeader(count uint32) error
+	// OnInflatedObjectHeader is called for each object header read.
+	OnInflatedObjectHeader(t plumbing.ObjectType, objSize int64, pos int64) error
+	// OnInflatedObjectContent is called for each decoded object.
+	OnInflatedObjectContent(h plumbing.Hash, pos int64, crc uint32, content []byte) error
+	// OnFooter is called when decoding is done.
+	OnFooter(h plumbing.Hash) error
+}
+
+type objectHeaderWriter func(typ plumbing.ObjectType, sz int64) error

plumbing/format/packfile/scanner.go

···
 package packfile
 
 import (
-	"bufio"
 	"bytes"
+	"encoding/hex"
 	"fmt"
 	"hash"
 	"hash/crc32"
 	"io"
+	"sync"
 
 	"github.com/go-git/go-git/v5/plumbing"
+	gogithash "github.com/go-git/go-git/v5/plumbing/hash"
+	"github.com/go-git/go-git/v5/plumbing/storer"
 	"github.com/go-git/go-git/v5/utils/binary"
-	"github.com/go-git/go-git/v5/utils/ioutil"
-	"github.com/go-git/go-git/v5/utils/sync"
+	gogitsync "github.com/go-git/go-git/v5/utils/sync"
 )
 
 var (
-	// ErrEmptyPackfile is returned by ReadHeader when no data is found in the packfile
+	// ErrEmptyPackfile is returned by ReadHeader when no data is found in the packfile.
 	ErrEmptyPackfile = NewError("empty packfile")
 	// ErrBadSignature is returned by ReadHeader when the signature in the packfile is incorrect.
 	ErrBadSignature = NewError("malformed pack file signature")
+	// ErrMalformedPackfile is returned when the packfile format is incorrect.
+	ErrMalformedPackfile = NewError("malformed pack file")
 	// ErrUnsupportedVersion is returned by ReadHeader when the packfile version is
 	// different than VersionSupported.
 	ErrUnsupportedVersion = NewError("unsupported packfile version")
-	// ErrSeekNotSupported returned if seek is not support
+	// ErrSeekNotSupported returned if seek is not support.
 	ErrSeekNotSupported = NewError("not seek support")
 )
 
-// ObjectHeader contains the information related to the object, this information
-// is collected from the previous bytes to the content of the object.
-type ObjectHeader struct {
-	Type            plumbing.ObjectType
-	Offset          int64
-	Length          int64
-	Reference       plumbing.Hash
-	OffsetReference int64
-}
-
+// Scanner provides sequential access to the data stored in a Git packfile.
+//
+// A Git packfile is a compressed binary format that stores multiple Git objects,
+// such as commits, trees, delta objects and blobs. These packfiles are used to
+// reduce the size of data when transferring or storing Git repositories.
+//
+// A Git packfile is structured as follows:
+//
+//	+----------------------------------------------------+
+//	|                 PACK File Header                   |
+//	+----------------------------------------------------+
+//	| "PACK"  | Version Number | Number of Objects       |
+//	| (4 bytes)  |  (4 bytes)   |    (4 bytes)           |
+//	+----------------------------------------------------+
+//	|                  Object Entry #1                   |
+//	+----------------------------------------------------+
+//	|  Object Header  |  Compressed Object Data / Delta  |
+//	| (type + size)   |  (var-length, zlib compressed)   |
+//	+----------------------------------------------------+
+//	|                         ...                        |
+//	+----------------------------------------------------+
+//	|                  PACK File Footer                  |
+//	+----------------------------------------------------+
+//	|                SHA-1 Checksum (20 bytes)           |
+//	+----------------------------------------------------+
+//
+// For upstream docs, refer to https://git-scm.com/docs/gitformat-pack.
 type Scanner struct {
-	r   *scannerReader
+	// version holds the packfile version.
+	version Version
+	// objects holds the quantiy of objects within the packfile.
+	objects uint32
+	// objIndex is the current index when going through the packfile objects.
+	objIndex int
+	// hasher is used to hash non-delta objects.
+	hasher plumbing.Hasher
+	// hasher256 is optional and used to hash the non-delta objects using SHA256.
+	hasher256 *plumbing.Hasher256
+	// crc is used to generate the CRC-32 checksum of each object's content.
 	crc hash.Hash32
+	// packhash hashes the pack contents so that at the end it is able to
+	// validate the packfile's footer checksum against the calculated hash.
+	packhash gogithash.Hash
 
-	// pendingObject is used to detect if an object has been read, or still
-	// is waiting to be read
-	pendingObject    *ObjectHeader
-	version, objects uint32
+	// next holds what state function should be executed on the next
+	// call to Scan().
+	nextFn stateFn
+	// packData holds the data for the last successful call to Scan().
+	packData PackData
+	// err holds the first error that occurred.
+	err error
 
-	// lsSeekable says if this scanner can do Seek or not, to have a Scanner
-	// seekable a r implementing io.Seeker is required
-	IsSeekable bool
-}
+	m sync.Mutex
 
-// NewScanner returns a new Scanner based on a reader, if the given reader
-// implements io.ReadSeeker the Scanner will be also Seekable
-func NewScanner(r io.Reader) *Scanner {
-	_, ok := r.(io.ReadSeeker)
+	// storage is optional, and when set is used to store full objects found.
+	// Note that delta objects are not stored.
+	storage storer.EncodedObjectStorer
 
-	crc := crc32.NewIEEE()
-	return &Scanner{
-		r:          newScannerReader(r, crc),
-		crc:        crc,
-		IsSeekable: ok,
-	}
+	*scannerReader
+	zr  gogitsync.ZLibReader
+	buf bytes.Buffer
 }
 
-func (s *Scanner) Reset(r io.Reader) {
-	_, ok := r.(io.ReadSeeker)
+// NewScanner creates a new instance of Scanner.
+func NewScanner(rs io.Reader, opts ...ScannerOption) *Scanner {
+	dict := make([]byte, 16*1024)
+	crc := crc32.NewIEEE()
+	packhash := gogithash.New(gogithash.CryptoType)
 
-	s.r.Reset(r)
-	s.crc.Reset()
-	s.IsSeekable = ok
-	s.pendingObject = nil
-	s.version = 0
-	s.objects = 0
-}
+	r := &Scanner{
+		scannerReader: newScannerReader(rs, io.MultiWriter(crc, packhash)),
+		zr:            gogitsync.NewZlibReader(&dict),
+		objIndex:      -1,
+		hasher:        plumbing.NewHasher(plumbing.AnyObject, 0),
+		crc:           crc,
+		packhash:      packhash,
+		nextFn:        packHeaderSignature,
+	}
 
-// Header reads the whole packfile header (signature, version and object count).
-// It returns the version and the object count and performs checks on the
-// validity of the signature and the version fields.
-func (s *Scanner) Header() (version, objects uint32, err error) {
-	if s.version != 0 {
-		return s.version, s.objects, nil
+	for _, opt := range opts {
+		opt(r)
 	}
 
-	sig, err := s.readSignature()
-	if err != nil {
-		if err == io.EOF {
-			err = ErrEmptyPackfile
-		}
+	return r
+}
 
-		return
-	}
+// Scan scans a Packfile sequently. Each call will navigate from a section
+// to the next, until the entire file is read.
+//
+// The section data can be accessed via calls to Data(). Example:
+//
+//	for scanner.Scan() {
+//	    v := scanner.Data().Value()
+//
+//		switch scanner.Data().Section {
+//		case HeaderSection:
+//			header := v.(Header)
+//			fmt.Println("[Header] Objects Qty:", header.ObjectsQty)
+//		case ObjectSection:
+//			oh := v.(ObjectHeader)
+//			fmt.Println("[Object] Object Type:", oh.Type)
+//		case FooterSection:
+//			checksum := v.(plumbing.Hash)
+//			fmt.Println("[Footer] Checksum:", checksum)
+//		}
+//	}
+func (r *Scanner) Scan() bool {
+	r.m.Lock()
+	defer r.m.Unlock()
 
-	if !s.isValidSignature(sig) {
-		err = ErrBadSignature
-		return
+	if r.err != nil || r.nextFn == nil {
+		return false
 	}
 
-	version, err = s.readVersion()
-	s.version = version
-	if err != nil {
-		return
+	if err := scan(r); err != nil {
+		r.err = err
+		return false
 	}
 
-	if !s.isSupportedVersion(version) {
-		err = ErrUnsupportedVersion.AddDetails("%d", version)
-		return
-	}
-
-	objects, err = s.readCount()
-	s.objects = objects
-	return
+	return true
 }
 
-// readSignature reads a returns the signature field in the packfile.
-func (s *Scanner) readSignature() ([]byte, error) {
-	var sig = make([]byte, 4)
-	if _, err := io.ReadFull(s.r, sig); err != nil {
-		return []byte{}, err
-	}
+// Reset resets the current scanner, enabling it to be used to scan the
+// same Packfile again.
+func (r *Scanner) Reset() {
+	r.scannerReader.Flush()
+	r.scannerReader.Seek(0, io.SeekStart)
+	r.packhash.Reset()
 
-	return sig, nil
+	r.objIndex = -1
+	r.version = 0
+	r.objects = 0
+	r.packData = PackData{}
+	r.err = nil
+	r.nextFn = packHeaderSignature
 }
 
-// isValidSignature returns if sig is a valid packfile signature.
-func (s *Scanner) isValidSignature(sig []byte) bool {
-	return bytes.Equal(sig, signature)
+// Data returns the pack data based on the last call to Scan().
+func (r *Scanner) Data() PackData {
+	return r.packData
 }
 
-// readVersion reads and returns the version field of a packfile.
-func (s *Scanner) readVersion() (uint32, error) {
-	return binary.ReadUint32(s.r)
+// Data returns the first error that occurred on the last call to Scan().
+// Once an error occurs, calls to Scan() becomes a no-op.
+func (r *Scanner) Error() error {
+	return r.err
 }
 
-// isSupportedVersion returns whether version v is supported by the parser.
-// The current supported version is VersionSupported, defined above.
-func (s *Scanner) isSupportedVersion(v uint32) bool {
-	return v == VersionSupported
-}
+func (r *Scanner) SeekFromStart(offset int64) error {
+	r.Reset()
 
-// readCount reads and returns the count of objects field of a packfile.
-func (s *Scanner) readCount() (uint32, error) {
-	return binary.ReadUint32(s.r)
-}
-
-// SeekObjectHeader seeks to specified offset and returns the ObjectHeader
-// for the next object in the reader
-func (s *Scanner) SeekObjectHeader(offset int64) (*ObjectHeader, error) {
-	// if seeking we assume that you are not interested in the header
-	if s.version == 0 {
-		s.version = VersionSupported
+	if !r.Scan() {
+		return fmt.Errorf("failed to reset and read header")
 	}
 
-	if _, err := s.r.Seek(offset, io.SeekStart); err != nil {
-		return nil, err
-	}
+	_, err := r.scannerReader.Seek(offset, io.SeekStart)
+	return err
+}
 
-	h, err := s.nextObjectHeader()
-	if err != nil {
-		return nil, err
+func (s *Scanner) WriteObject(oh *ObjectHeader, writer io.Writer) error {
+	if oh.content.Len() > 0 {
+		_, err := io.Copy(writer, bytes.NewReader(oh.content.Bytes()))
+		return err
 	}
 
-	h.Offset = offset
-	return h, nil
-}
-
-// NextObjectHeader returns the ObjectHeader for the next object in the reader
-func (s *Scanner) NextObjectHeader() (*ObjectHeader, error) {
-	if err := s.doPending(); err != nil {
-		return nil, err
+	// If the oh is not an external ref and we don't have the
+	// content offset, we won't be able to inflate via seeking through
+	// the packfile.
+	if oh.externalRef && oh.ContentOffset == 0 {
+		return plumbing.ErrObjectNotFound
 	}
 
-	offset, err := s.r.Seek(0, io.SeekCurrent)
-	if err != nil {
-		return nil, err
+	// Not a seeker data source.
+	if s.seeker == nil {
+		return plumbing.ErrObjectNotFound
 	}
 
-	h, err := s.nextObjectHeader()
+	err := s.inflateContent(oh.ContentOffset, writer)
 	if err != nil {
-		return nil, err
+		return ErrReferenceDeltaNotFound
 	}
 
-	h.Offset = offset
-	return h, nil
+	return nil
 }
 
-// nextObjectHeader returns the ObjectHeader for the next object in the reader
-// without the Offset field
-func (s *Scanner) nextObjectHeader() (*ObjectHeader, error) {
-	s.r.Flush()
-	s.crc.Reset()
-
-	h := &ObjectHeader{}
-	s.pendingObject = h
-
-	var err error
-	h.Offset, err = s.r.Seek(0, io.SeekCurrent)
+func (s *Scanner) inflateContent(contentOffset int64, writer io.Writer) error {
+	_, err := s.scannerReader.Seek(contentOffset, io.SeekStart)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	h.Type, h.Length, err = s.readObjectTypeAndLength()
+	err = s.zr.Reset(s.scannerReader)
 	if err != nil {
-		return nil, err
+		return fmt.Errorf("zlib reset error: %s", err)
 	}
 
-	switch h.Type {
-	case plumbing.OFSDeltaObject:
-		no, err := binary.ReadVariableWidthInt(s.r)
-		if err != nil {
-			return nil, err
-		}
-
-		h.OffsetReference = h.Offset - no
-	case plumbing.REFDeltaObject:
-		var err error
-		h.Reference, err = binary.ReadHash(s.r)
-		if err != nil {
-			return nil, err
-		}
+	_, err = io.Copy(writer, s.zr.Reader)
+	if err != nil {
+		return err
 	}
 
-	return h, nil
+	return nil
 }
 
-func (s *Scanner) doPending() error {
-	if s.version == 0 {
-		var err error
-		s.version, s.objects, err = s.Header()
+// scan goes through the next stateFn.
+//
+// State functions are chained by returning a non-nil value for stateFn.
+// In such cases, the returned stateFn will be called immediately after
+// the current func.
+func scan(r *Scanner) error {
+	var err error
+	for state := r.nextFn; state != nil; {
+		state, err = state(r)
 		if err != nil {
 			return err
 		}
 	}
-
-	return s.discardObjectIfNeeded()
+	return nil
 }
 
-func (s *Scanner) discardObjectIfNeeded() error {
-	if s.pendingObject == nil {
-		return nil
-	}
+// stateFn defines each individual state within the state machine that
+// represents a packfile.
+type stateFn func(*Scanner) (stateFn, error)
 
-	h := s.pendingObject
-	n, _, err := s.NextObject(io.Discard)
+// packHeaderSignature validates the packfile's header signature and
+// returns [ErrBadSignature] if the value provided is invalid.
+//
+// This is always the first state of a packfile and starts the chain
+// that handles the entire packfile header.
+func packHeaderSignature(r *Scanner) (stateFn, error) {
+	start := make([]byte, 4)
+	_, err := r.Read(start)
 	if err != nil {
-		return err
+		return nil, fmt.Errorf("%w: %w", ErrBadSignature, err)
 	}
 
-	if n != h.Length {
-		return fmt.Errorf(
-			"error discarding object, discarded %d, expected %d",
-			n, h.Length,
-		)
+	if bytes.Equal(start, signature) {
+		return packVersion, nil
 	}
 
-	return nil
+	return nil, ErrBadSignature
 }
 
-// ReadObjectTypeAndLength reads and returns the object type and the
-// length field from an object entry in a packfile.
-func (s *Scanner) readObjectTypeAndLength() (plumbing.ObjectType, int64, error) {
-	t, c, err := s.readType()
+// packVersion parses the packfile version. It returns [ErrMalformedPackfile]
+// when the version cannot be parsed. If a valid version is parsed, but it is
+// not currently supported, it returns [ErrUnsupportedVersion] instead.
+func packVersion(r *Scanner) (stateFn, error) {
+	version, err := binary.ReadUint32(r.scannerReader)
 	if err != nil {
-		return t, 0, err
+		return nil, fmt.Errorf("%w: cannot read version", ErrMalformedPackfile)
 	}
 
-	l, err := s.readLength(c)
+	v := Version(version)
+	if !v.Supported() {
+		return nil, ErrUnsupportedVersion
+	}
 
-	return t, l, err
+	r.version = v
+	return packObjectsQty, nil
 }
 
-func (s *Scanner) readType() (plumbing.ObjectType, byte, error) {
-	var c byte
-	var err error
-	if c, err = s.r.ReadByte(); err != nil {
-		return plumbing.ObjectType(0), 0, err
+// packObjectsQty parses the quantity of objects that the packfile contains.
+// If the value cannot be parsed, [ErrMalformedPackfile] is returned.
+//
+// This state ends the packfile header chain.
+func packObjectsQty(r *Scanner) (stateFn, error) {
+	qty, err := binary.ReadUint32(r.scannerReader)
+	if err != nil {
+		return nil, fmt.Errorf("%w: cannot read number of objects", ErrMalformedPackfile)
+	}
+	if qty == 0 {
+		return packFooter, nil
 	}
 
-	typ := parseType(c)
+	r.objects = qty
+	r.packData = PackData{
+		Section: HeaderSection,
+		header:  Header{Version: r.version, ObjectsQty: r.objects},
+	}
+	r.nextFn = objectEntry
 
-	return typ, c, nil
-}
-
-func parseType(b byte) plumbing.ObjectType {
-	return plumbing.ObjectType((b & maskType) >> firstLengthBits)
+	return nil, nil
 }
 
-// the length is codified in the last 4 bits of the first byte and in
-// the last 7 bits of subsequent bytes.  Last byte has a 0 MSB.
-func (s *Scanner) readLength(first byte) (int64, error) {
-	length := int64(first & maskFirstLength)
-
-	c := first
-	shift := firstLengthBits
-	var err error
-	for c&maskContinue > 0 {
-		if c, err = s.r.ReadByte(); err != nil {
-			return 0, err
-		}
-
-		length += int64(c&maskLength) << shift
-		shift += lengthBits
+// objectEntry handles the object entries within a packfile. This is generally
+// split between object headers and their contents.
+//
+// The object header contains the object type and size. If the type cannot be parsed,
+// [ErrMalformedPackfile] is returned.
+//
+// When SHA256 is enabled, the scanner will also calculate the SHA256 for each object.
+func objectEntry(r *Scanner) (stateFn, error) {
+	if r.objIndex+1 >= int(r.objects) {
+		return packFooter, nil
 	}
+	r.objIndex++
 
-	return length, nil
-}
+	offset := r.scannerReader.offset
 
-// NextObject writes the content of the next object into the reader, returns
-// the number of bytes written, the CRC32 of the content and an error, if any
-func (s *Scanner) NextObject(w io.Writer) (written int64, crc32 uint32, err error) {
-	s.pendingObject = nil
-	written, err = s.copyObject(w)
+	r.scannerReader.Flush()
+	r.crc.Reset()
 
-	s.r.Flush()
-	crc32 = s.crc.Sum32()
-	s.crc.Reset()
-
-	return
-}
-
-// ReadObject returns a reader for the object content and an error
-func (s *Scanner) ReadObject() (io.ReadCloser, error) {
-	s.pendingObject = nil
-	zr, err := sync.GetZlibReader(s.r)
-
+	b := []byte{0}
+	_, err := r.Read(b)
 	if err != nil {
-		return nil, fmt.Errorf("zlib reset error: %s", err)
+		return nil, err
 	}
 
-	return ioutil.NewReadCloserWithCloser(zr.Reader, func() error {
-		sync.PutZlibReader(zr)
-		return nil
-	}), nil
-}
+	typ := parseType(b[0])
+	if !typ.Valid() {
+		return nil, fmt.Errorf("%w: invalid object type: %v", ErrMalformedPackfile, b[0])
+	}
 
-// ReadRegularObject reads and write a non-deltified object
-// from it zlib stream in an object entry in the packfile.
-func (s *Scanner) copyObject(w io.Writer) (n int64, err error) {
-	zr, err := sync.GetZlibReader(s.r)
-	defer sync.PutZlibReader(zr)
-
+	size, err := readVariableLengthSize(b[0], r)
 	if err != nil {
-		return 0, fmt.Errorf("zlib reset error: %s", err)
+		return nil, err
 	}
 
-	defer ioutil.CheckClose(zr.Reader, &err)
-	buf := sync.GetByteSlice()
-	n, err = io.CopyBuffer(w, zr.Reader, *buf)
-	sync.PutByteSlice(buf)
-	return
-}
-
-// SeekFromStart sets a new offset from start, returns the old position before
-// the change.
-func (s *Scanner) SeekFromStart(offset int64) (previous int64, err error) {
-	// if seeking we assume that you are not interested in the header
-	if s.version == 0 {
-		s.version = VersionSupported
+	oh := ObjectHeader{
+		Offset:   offset,
+		Type:     typ,
+		diskType: typ,
+		Size:     int64(size),
 	}
 
-	previous, err = s.r.Seek(0, io.SeekCurrent)
-	if err != nil {
-		return -1, err
+	switch oh.Type {
+	case plumbing.OFSDeltaObject, plumbing.REFDeltaObject:
+		// For delta objects, we need to skip the base reference
+		if oh.Type == plumbing.OFSDeltaObject {
+			no, err := binary.ReadVariableWidthInt(r.scannerReader)
+			if err != nil {
+				return nil, err
+			}
+			oh.OffsetReference = oh.Offset - no
+		} else {
+			ref, err := binary.ReadHash(r.scannerReader)
+			if err != nil {
+				return nil, err
+			}
+			oh.Reference = ref
+		}
 	}
 
-	_, err = s.r.Seek(offset, io.SeekStart)
-	return previous, err
-}
-
-// Checksum returns the checksum of the packfile
-func (s *Scanner) Checksum() (plumbing.Hash, error) {
-	err := s.discardObjectIfNeeded()
+	oh.ContentOffset = r.scannerReader.offset
+	err = r.zr.Reset(r.scannerReader)
 	if err != nil {
-		return plumbing.ZeroHash, err
+		return nil, fmt.Errorf("zlib reset error: %s", err)
 	}
 
-	return binary.ReadHash(s.r)
-}
+	if !oh.Type.IsDelta() {
+		r.hasher.Reset(oh.Type, oh.Size)
 
-// Close reads the reader until io.EOF
-func (s *Scanner) Close() error {
-	buf := sync.GetByteSlice()
-	_, err := io.CopyBuffer(io.Discard, s.r, *buf)
-	sync.PutByteSlice(buf)
+		var mw io.Writer = r.hasher
+		if r.storage != nil {
+			w, err := r.storage.RawObjectWriter(oh.Type, oh.Size)
+			if err != nil {
+				return nil, err
+			}
 
-	return err
-}
+			defer w.Close()
+			mw = io.MultiWriter(r.hasher, w)
+		}
 
-// Flush is a no-op (deprecated)
-func (s *Scanner) Flush() error {
-	return nil
-}
+		if r.hasher256 != nil {
+			r.hasher256.Reset(oh.Type, oh.Size)
+			mw = io.MultiWriter(mw, r.hasher256)
+		}
 
-// scannerReader has the following characteristics:
-//   - Provides an io.SeekReader impl for bufio.Reader, when the underlying
-//     reader supports it.
-//   - Keeps track of the current read position, for when the underlying reader
-//     isn't an io.SeekReader, but we still want to know the current offset.
-//   - Writes to the hash writer what it reads, with the aid of a smaller buffer.
-//     The buffer helps avoid a performance penalty for performing small writes
-//     to the crc32 hash writer.
-type scannerReader struct {
-	reader io.Reader
-	crc    io.Writer
-	rbuf   *bufio.Reader
-	wbuf   *bufio.Writer
-	offset int64
-}
+		// For non delta objects, simply calculate the hash of each object.
+		_, err = io.CopyBuffer(mw, r.zr.Reader, r.buf.Bytes())
+		if err != nil {
+			return nil, err
+		}
 
-func newScannerReader(r io.Reader, h io.Writer) *scannerReader {
-	sr := &scannerReader{
-		rbuf: bufio.NewReader(nil),
-		wbuf: bufio.NewWriterSize(nil, 64),
-		crc:  h,
+		oh.Hash = r.hasher.Sum()
+		if r.hasher256 != nil {
+			h := r.hasher256.Sum()
+			oh.Hash256 = &h
+		}
+	} else {
+		// If data source is not io.Seeker, keep the content
+		// in the cache, so that it can be accessed by the Parser.
+		if r.scannerReader.seeker == nil {
+			_, err = oh.content.ReadFrom(r.zr.Reader)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			// We don't know the compressed length, so we can't seek to
+			// the next object, we must discard the data instead.
+			_, err = io.Copy(io.Discard, r.zr.Reader)
+			if err != nil {
+				return nil, err
+			}
+		}
 	}
-	sr.Reset(r)
+	r.scannerReader.Flush()
+	oh.Crc32 = r.crc.Sum32()
+
+	r.packData.Section = ObjectSection
+	r.packData.objectHeader = oh
 
-	return sr
+	return nil, nil
 }
 
-func (r *scannerReader) Reset(reader io.Reader) {
-	r.reader = reader
-	r.rbuf.Reset(r.reader)
-	r.wbuf.Reset(r.crc)
+// packFooter parses the packfile checksum.
+// If the checksum cannot be parsed, or it does not match the checksum
+// calculated during the scanning process, an [ErrMalformedPackfile] is
+// returned.
+func packFooter(r *Scanner) (stateFn, error) {
+	r.scannerReader.Flush()
+	actual := r.packhash.Sum(nil)
 
-	r.offset = 0
-	if seeker, ok := r.reader.(io.ReadSeeker); ok {
-		r.offset, _ = seeker.Seek(0, io.SeekCurrent)
+	checksum, err := binary.ReadHash(r.scannerReader)
+	if err != nil {
+		return nil, fmt.Errorf("cannot read PACK checksum: %w", ErrMalformedPackfile)
 	}
-}
 
-func (r *scannerReader) Read(p []byte) (n int, err error) {
-	n, err = r.rbuf.Read(p)
-
-	r.offset += int64(n)
-	if _, err := r.wbuf.Write(p[:n]); err != nil {
-		return n, err
+	if !bytes.Equal(actual, checksum[:]) {
+		return nil, fmt.Errorf("checksum mismatch expected %q but found %q: %w",
+			hex.EncodeToString(actual), checksum, ErrMalformedPackfile)
 	}
-	return
-}
 
-func (r *scannerReader) ReadByte() (b byte, err error) {
-	b, err = r.rbuf.ReadByte()
-	if err == nil {
-		r.offset++
-		return b, r.wbuf.WriteByte(b)
-	}
-	return
-}
+	r.packData.Section = FooterSection
+	r.packData.checksum = checksum
+	r.nextFn = nil
 
-func (r *scannerReader) Flush() error {
-	return r.wbuf.Flush()
+	return nil, nil
 }
 
-// Seek seeks to a location. If the underlying reader is not an io.ReadSeeker,
-// then only whence=io.SeekCurrent is supported, any other operation fails.
-func (r *scannerReader) Seek(offset int64, whence int) (int64, error) {
-	var err error
+func readVariableLengthSize(first byte, reader io.ByteReader) (uint64, error) {
+	// Extract the first part of the size (last 3 bits of the first byte).
+	size := uint64(first & 0x0F)
 
-	if seeker, ok := r.reader.(io.ReadSeeker); !ok {
-		if whence != io.SeekCurrent || offset != 0 {
-			return -1, ErrSeekNotSupported
+	// |  001xxxx | xxxxxxxx | xxxxxxxx | ...
+	//
+	//	 ^^^       ^^^^^^^^   ^^^^^^^^
+	//	Type      Size Part 1   Size Part 2
+	//
+	// Check if more bytes are needed to fully determine the size.
+	if first&maskContinue != 0 {
+		shift := uint(4)
+
+		for {
+			b, err := reader.ReadByte()
+			if err != nil {
+				return 0, err
+			}
+
+			// Add the next 7 bits to the size.
+			size |= uint64(b&0x7F) << shift
+
+			// Check if the continuation bit is set.
+			if b&maskContinue == 0 {
+				break
+			}
+
+			// Prepare for the next byte.
+			shift += 7
 		}
-	} else {
-		if whence == io.SeekCurrent && offset == 0 {
-			return r.offset, nil
-		}
-
-		r.offset, err = seeker.Seek(offset, whence)
-		r.rbuf.Reset(r.reader)
 	}
+	return size, nil
+}
 
-	return r.offset, err
+func parseType(b byte) plumbing.ObjectType {
+	return plumbing.ObjectType((b & maskType) >> firstLengthBits)
 }

plumbing/format/packfile/scanner_options.go

···
+package packfile
+
+import "github.com/go-git/go-git/v5/plumbing"
+
+type ScannerOption func(*Scanner)
+
+// WithSHA256 enables the SHA256 hashing while scanning a pack file.
+func WithSHA256() ScannerOption {
+	return func(s *Scanner) {
+		h := plumbing.NewHasher256(plumbing.AnyObject, 0)
+		s.hasher256 = &h
+	}
+}

plumbing/format/packfile/scanner_reader.go

···
+package packfile
+
+import (
+	"bufio"
+	"io"
+)
+
+// scannerReader has the following characteristics:
+//   - Provides an io.SeekReader impl for bufio.Reader, when the underlying
+//     reader supports it.
+//   - Keeps track of the current read position, for when the underlying reader
+//     isn't an io.SeekReader, but we still want to know the current offset.
+//   - Writes to the hash writer what it reads, with the aid of a smaller buffer.
+//     The buffer helps avoid a performance penalty for performing small writes
+//     to the crc32 hash writer.
+//
+// Note that this is passed on to zlib, and it mmust support io.BytesReader, else
+// it won't be able to just read the content of the current object, but rather it
+// will read the entire packfile.
+//
+// scannerReader is not thread-safe.
+type scannerReader struct {
+	reader io.Reader
+	crc    io.Writer
+	rbuf   *bufio.Reader
+	wbuf   *bufio.Writer
+	offset int64
+	seeker io.Seeker
+}
+
+func newScannerReader(r io.Reader, h io.Writer) *scannerReader {
+	sr := &scannerReader{
+		rbuf: bufio.NewReader(nil),
+		wbuf: bufio.NewWriterSize(nil, 64),
+		crc:  h,
+	}
+	sr.Reset(r)
+
+	return sr
+}
+
+func (r *scannerReader) Reset(reader io.Reader) {
+	r.reader = reader
+	r.rbuf.Reset(r.reader)
+	r.wbuf.Reset(r.crc)
+
+	r.offset = 0
+
+	seeker, ok := r.reader.(io.ReadSeeker)
+	r.seeker = seeker
+
+	if ok {
+		r.offset, _ = seeker.Seek(0, io.SeekCurrent)
+	}
+}
+
+func (r *scannerReader) Read(p []byte) (n int, err error) {
+	n, err = r.rbuf.Read(p)
+
+	r.offset += int64(n)
+	if _, err := r.wbuf.Write(p[:n]); err != nil {
+		return n, err
+	}
+	return
+}
+
+func (r *scannerReader) ReadByte() (b byte, err error) {
+	b, err = r.rbuf.ReadByte()
+	if err == nil {
+		r.offset++
+		return b, r.wbuf.WriteByte(b)
+	}
+	return
+}
+
+func (r *scannerReader) Flush() error {
+	return r.wbuf.Flush()
+}
+
+// Seek seeks to a location. If the underlying reader is not an io.ReadSeeker,
+// then only whence=io.SeekCurrent is supported, any other operation fails.
+func (r *scannerReader) Seek(offset int64, whence int) (int64, error) {
+	var err error
+
+	if r.seeker == nil {
+		if whence != io.SeekCurrent || offset != 0 {
+			return -1, ErrSeekNotSupported
+		}
+	}
+
+	if whence == io.SeekCurrent && offset == 0 {
+		return r.offset, nil
+	}
+
+	r.offset, err = r.seeker.Seek(offset, whence)
+	r.rbuf.Reset(r.reader)
+
+	return r.offset, err
+}

plumbing/format/packfile/scanner_test.go

···
 
 import (
 	"bytes"
+	"encoding/binary"
 	"io"
+	"reflect"
+	"runtime"
+	"testing"
 
-	fixtures "github.com/go-git/go-git-fixtures/v4"
+	"github.com/go-git/go-billy/v5"
+	fixtures "github.com/go-git/go-git-fixtures/v5"
 	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/go-git/go-git/v5/plumbing/hash"
-
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/assert"
 )
 
-type ScannerSuite struct {
-	fixtures.Suite
-}
+func TestScan(t *testing.T) {
+	tests := []struct {
+		name         string
+		packfile     billy.File
+		sha256       bool
+		want         []ObjectHeader
+		wantCrc      []uint32
+		wantChecksum string
+	}{
+		{
+			name:         "ofs",
+			packfile:     fixtures.Basic().One().Packfile(),
+			want:         expectedHeadersOFS256,
+			wantCrc:      expectedCRCOFS,
+			wantChecksum: "a3fed42da1e8189a077c0e6846c040dcf73fc9dd",
+		},
+		{
+			name:         "ofs sha256",
+			packfile:     fixtures.Basic().One().Packfile(),
+			sha256:       true,
+			want:         expectedHeadersOFS256,
+			wantCrc:      expectedCRCOFS,
+			wantChecksum: "a3fed42da1e8189a077c0e6846c040dcf73fc9dd",
+		},
+		{
+			name:         "refs",
+			packfile:     fixtures.Basic().ByTag("ref-delta").One().Packfile(),
+			want:         expectedHeadersREF,
+			wantCrc:      expectedCRCREF,
+			wantChecksum: "c544593473465e6315ad4182d04d366c4592b829",
+		},
+	}
 
-var _ = Suite(&ScannerSuite{})
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			var opts []ScannerOption
 
-func (s *ScannerSuite) TestHeader(c *C) {
-	r := fixtures.Basic().One().Packfile()
-	p := NewScanner(r)
+			if tc.sha256 {
+				opts = append(opts, WithSHA256())
+			}
 
-	version, objects, err := p.Header()
-	c.Assert(err, IsNil)
-	c.Assert(version, Equals, VersionSupported)
-	c.Assert(objects, Equals, uint32(31))
-}
+			s := NewScanner(tc.packfile, opts...)
+			i := 0
 
-func (s *ScannerSuite) TestNextObjectHeaderWithoutHeader(c *C) {
-	r := fixtures.Basic().One().Packfile()
-	p := NewScanner(r)
+			for s.Scan() {
+				data := s.Data()
+				v := data.Value()
 
-	h, err := p.NextObjectHeader()
-	c.Assert(err, IsNil)
-	c.Assert(h, DeepEquals, &expectedHeadersOFS[0])
+				switch data.Section {
+				case HeaderSection:
+					gotHeader := v.(Header)
+					assert.Equal(t, 0, i, "wrong index")
+					assert.Equal(t, Version(2), gotHeader.Version)
+					assert.Equal(t, uint32(len(tc.want)), gotHeader.ObjectsQty)
+				case ObjectSection:
+					index := i - 1
 
-	version, objects, err := p.Header()
-	c.Assert(err, IsNil)
-	c.Assert(version, Equals, VersionSupported)
-	c.Assert(objects, Equals, uint32(31))
-}
+					oh := v.(ObjectHeader)
+					oo := tc.want[index]
+					assert.Equal(t, oo.Type, oh.Type, "type mismatch index: %d", index)
+					assert.Equal(t, oo.Offset, oh.Offset, "offset mismatch index: %d", index)
+					assert.Equal(t, oo.Size, oh.Size, "size mismatch index: %d", index)
+					assert.Equal(t, oo.Reference, oh.Reference, "reference mismatch index: %d", index)
+					assert.Equal(t, oo.OffsetReference, oh.OffsetReference, "offset reference mismatch index: %d", index)
+					assert.Equal(t, oo.Hash.String(), oh.Hash.String(), "hash mismatch index: %d", index)
+					if tc.sha256 && !oo.Type.IsDelta() {
+						assert.Equal(t, oo.Hash256.String(), oh.Hash256.String(), "hash mismatch index: %d", index)
+					}
+					assert.Equal(t, tc.wantCrc[index], oh.Crc32, "crc mismatch index: %d", index)
+				case FooterSection:
+					checksum := v.(plumbing.Hash)
+					assert.Equal(t, tc.wantChecksum, checksum.String())
+				}
+				i++
+			}
 
-func (s *ScannerSuite) TestNextObjectHeaderREFDelta(c *C) {
-	s.testNextObjectHeader(c, "ref-delta", expectedHeadersREF, expectedCRCREF)
-}
+			err := s.Error()
+			assert.NoError(t, err)
 
-func (s *ScannerSuite) TestNextObjectHeaderOFSDelta(c *C) {
-	s.testNextObjectHeader(c, "ofs-delta", expectedHeadersOFS, expectedCRCOFS)
+			// wanted objects + header + footer
+			assert.Equal(t, len(tc.want)+2, i)
+		})
+	}
 }
 
-func (s *ScannerSuite) testNextObjectHeader(c *C, tag string,
-	expected []ObjectHeader, expectedCRC []uint32) {
+func BenchmarkScannerBasic(b *testing.B) {
+	f := fixtures.Basic().One().Packfile()
+	scanner := NewScanner(f)
+	for i := 0; i < b.N; i++ {
+		scanner.Reset()
 
-	r := fixtures.Basic().ByTag(tag).One().Packfile()
-	p := NewScanner(r)
+		for scanner.Scan() {
+		}
 
-	_, objects, err := p.Header()
-	c.Assert(err, IsNil)
-
-	for i := 0; i < int(objects); i++ {
-		h, err := p.NextObjectHeader()
-		c.Assert(err, IsNil)
-		c.Assert(*h, DeepEquals, expected[i])
-
-		buf := bytes.NewBuffer(nil)
-		n, crcFromScanner, err := p.NextObject(buf)
-		c.Assert(err, IsNil)
-		c.Assert(n, Equals, h.Length)
-		c.Assert(crcFromScanner, Equals, expectedCRC[i])
+		err := scanner.Error()
+		if err != nil {
+			b.Fatal(err)
+		}
 	}
-
-	n, err := p.Checksum()
-	c.Assert(err, IsNil)
-	c.Assert(n, HasLen, hash.Size)
 }
 
-func (s *ScannerSuite) TestNextObjectHeaderWithOutReadObject(c *C) {
-	f := fixtures.Basic().ByTag("ref-delta").One()
-	r := f.Packfile()
-	p := NewScanner(r)
-
-	_, objects, err := p.Header()
-	c.Assert(err, IsNil)
-
-	for i := 0; i < int(objects); i++ {
-		h, _ := p.NextObjectHeader()
-		c.Assert(err, IsNil)
-		c.Assert(*h, DeepEquals, expectedHeadersREF[i])
+func TestPackHeaderSignature(t *testing.T) {
+	tests := []struct {
+		name      string
+		scanner   *Scanner
+		nextState stateFn
+		wantErr   error
+	}{
+		{
+			name: "valid signature",
+			scanner: &Scanner{
+				scannerReader: newScannerReader(bytes.NewReader([]byte("PACK")), nil),
+			},
+			nextState: packVersion,
+		},
+		{
+			name: "invalid signature",
+			scanner: &Scanner{
+				scannerReader: newScannerReader(bytes.NewReader([]byte("FOOBAR")), nil),
+			},
+			wantErr: ErrBadSignature,
+		},
+		{
+			name: "invalid signature - too small",
+			scanner: &Scanner{
+				scannerReader: newScannerReader(bytes.NewReader([]byte("FOO")), nil),
+			},
+			wantErr: ErrBadSignature,
+		},
+		{
+			name: "empty packfile: io.EOF",
+			scanner: &Scanner{
+				scannerReader: newScannerReader(bytes.NewReader(nil), nil),
+			},
+			wantErr: io.EOF,
+		},
+		{
+			name: "empty packfile: ErrBadSignature",
+			scanner: &Scanner{
+				scannerReader: newScannerReader(bytes.NewReader(nil), nil),
+			},
+			wantErr: ErrBadSignature,
+		},
 	}
 
-	err = p.discardObjectIfNeeded()
-	c.Assert(err, IsNil)
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			next, err := packHeaderSignature(tc.scanner)
 
-	n, err := p.Checksum()
-	c.Assert(err, IsNil)
-	c.Assert(n.String(), Equals, f.PackfileHash)
-}
-
-func (s *ScannerSuite) TestNextObjectHeaderWithOutReadObjectNonSeekable(c *C) {
-	f := fixtures.Basic().ByTag("ref-delta").One()
-	r := io.MultiReader(f.Packfile())
-	p := NewScanner(r)
+			if tc.wantErr == nil {
+				assert.Equal(t,
+					runtime.FuncForPC(reflect.ValueOf(tc.nextState).Pointer()).Name(),
+					runtime.FuncForPC(reflect.ValueOf(next).Pointer()).Name())
 
-	_, objects, err := p.Header()
-	c.Assert(err, IsNil)
-
-	for i := 0; i < int(objects); i++ {
-		h, _ := p.NextObjectHeader()
-		c.Assert(err, IsNil)
-		c.Assert(*h, DeepEquals, expectedHeadersREF[i])
+				assert.NoError(t, err)
+			} else {
+				assert.Nil(t, next)
+				assert.ErrorIs(t, err, tc.wantErr)
+			}
+		})
 	}
-
-	err = p.discardObjectIfNeeded()
-	c.Assert(err, IsNil)
-
-	n, err := p.Checksum()
-	c.Assert(err, IsNil)
-	c.Assert(n.String(), Equals, f.PackfileHash)
 }
 
-func (s *ScannerSuite) TestSeekObjectHeader(c *C) {
-	r := fixtures.Basic().One().Packfile()
-	p := NewScanner(r)
+func TestPackVersion(t *testing.T) {
+	tests := []struct {
+		name      string
+		scanner   *Scanner
+		version   Version
+		nextState stateFn
+		wantErr   error
+	}{
+		{
+			name:    "Version 2",
+			version: Version(2),
+			scanner: &Scanner{
+				scannerReader: func() *scannerReader {
+					buf := bytes.NewBuffer(make([]byte, 0, 4))
+					binary.Write(buf, binary.BigEndian, uint32(2))
+					return newScannerReader(buf, nil)
+				}(),
+			},
+			nextState: packObjectsQty,
+		},
+		{
+			name: "Version -1",
+			scanner: &Scanner{
+				scannerReader: func() *scannerReader {
+					buf := bytes.NewBuffer(make([]byte, 0, 4))
+					binary.Write(buf, binary.BigEndian, -1)
+					return newScannerReader(buf, nil)
+				}(),
+			},
+			wantErr: ErrMalformedPackfile,
+		},
+		{
+			name: "Unsupported version",
+			scanner: &Scanner{
+				scannerReader: func() *scannerReader {
+					buf := bytes.NewBuffer(make([]byte, 0, 4))
+					binary.Write(buf, binary.BigEndian, uint32(3))
+					return newScannerReader(buf, nil)
+				}(),
+			},
+			wantErr: ErrUnsupportedVersion,
+		},
+		{
+			name: "empty packfile: ErrMalformedPackfile",
+			scanner: &Scanner{
+				scannerReader: newScannerReader(bytes.NewReader(nil), nil),
+			},
+			wantErr: ErrMalformedPackfile,
+		},
+	}
 
-	h, err := p.SeekObjectHeader(expectedHeadersOFS[4].Offset)
-	c.Assert(err, IsNil)
-	c.Assert(h, DeepEquals, &expectedHeadersOFS[4])
-}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			next, err := packVersion(tc.scanner)
 
-func (s *ScannerSuite) TestSeekObjectHeaderNonSeekable(c *C) {
-	r := io.MultiReader(fixtures.Basic().One().Packfile())
-	p := NewScanner(r)
+			if tc.wantErr == nil {
+				assert.Equal(t,
+					runtime.FuncForPC(reflect.ValueOf(tc.nextState).Pointer()).Name(),
+					runtime.FuncForPC(reflect.ValueOf(next).Pointer()).Name())
 
-	_, err := p.SeekObjectHeader(expectedHeadersOFS[4].Offset)
-	c.Assert(err, Equals, ErrSeekNotSupported)
+				assert.Equal(t, tc.version, tc.scanner.version)
+				assert.NoError(t, err)
+			} else {
+				assert.Nil(t, next)
+				assert.ErrorIs(t, err, tc.wantErr)
+			}
+		})
+	}
 }
 
-func (s *ScannerSuite) TestReaderReset(c *C) {
-	r := fixtures.Basic().One().Packfile()
-	p := NewScanner(r)
+func TestPackObjectQty(t *testing.T) {
+	tests := []struct {
+		name      string
+		scanner   *Scanner
+		objects   uint32
+		nextState stateFn
+		wantErr   error
+	}{
+		{
+			name: "Zero",
+			scanner: &Scanner{
+				scannerReader: func() *scannerReader {
+					buf := bytes.NewBuffer(make([]byte, 0, 4))
+					binary.Write(buf, binary.BigEndian, uint32(0))
+					return newScannerReader(buf, nil)
+				}(),
+			},
+			nextState: packFooter, // if there are no objects, skip to footer.
+		},
+		{
+			name: "Valid number",
+			scanner: &Scanner{
+				scannerReader: func() *scannerReader {
+					buf := bytes.NewBuffer(make([]byte, 0, 4))
+					binary.Write(buf, binary.BigEndian, uint32(7))
+					return newScannerReader(buf, nil)
+				}(),
+			},
+			objects:   7,
+			nextState: nil,
+		},
+		{
+			name: "less than 2 bytes on source",
+			scanner: &Scanner{
+				scannerReader: func() *scannerReader {
+					buf := bytes.NewBuffer(make([]byte, 0, 2))
+					return newScannerReader(buf, nil)
+				}(),
+			},
+			wantErr: ErrMalformedPackfile,
+		},
+		{
+			name: "empty packfile: ErrMalformedPackfile",
+			scanner: &Scanner{
+				scannerReader: newScannerReader(bytes.NewReader(nil), nil),
+			},
+			wantErr: ErrMalformedPackfile,
+		},
+	}
 
-	version, objects, err := p.Header()
-	c.Assert(err, IsNil)
-	c.Assert(version, Equals, VersionSupported)
-	c.Assert(objects, Equals, uint32(31))
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			next, err := packObjectsQty(tc.scanner)
 
-	h, err := p.SeekObjectHeader(expectedHeadersOFS[0].Offset)
-	c.Assert(err, IsNil)
-	c.Assert(h, DeepEquals, &expectedHeadersOFS[0])
+			if tc.wantErr == nil {
+				assert.Equal(t,
+					runtime.FuncForPC(reflect.ValueOf(tc.nextState).Pointer()).Name(),
+					runtime.FuncForPC(reflect.ValueOf(next).Pointer()).Name())
 
-	p.Reset(r)
-	c.Assert(p.pendingObject, IsNil)
-	c.Assert(p.version, Equals, uint32(0))
-	c.Assert(p.objects, Equals, uint32(0))
-	c.Assert(p.r.reader, Equals, r)
-	c.Assert(p.r.offset > expectedHeadersOFS[0].Offset, Equals, true)
-
-	p.Reset(bytes.NewReader(nil))
-	c.Assert(p.r.offset, Equals, int64(0))
+				assert.Equal(t, tc.objects, tc.scanner.objects)
+				assert.NoError(t, err)
+			} else {
+				assert.Nil(t, next)
+				assert.ErrorIs(t, err, tc.wantErr)
+			}
+		})
+	}
 }
 
-func (s *ScannerSuite) TestReaderResetSeeks(c *C) {
-	r := fixtures.Basic().One().Packfile()
-
-	// seekable
-	p := NewScanner(r)
-	c.Assert(p.IsSeekable, Equals, true)
-	h, err := p.SeekObjectHeader(expectedHeadersOFS[0].Offset)
-	c.Assert(err, IsNil)
-	c.Assert(h, DeepEquals, &expectedHeadersOFS[0])
-
-	// reset with seekable
-	p.Reset(r)
-	c.Assert(p.IsSeekable, Equals, true)
-	h, err = p.SeekObjectHeader(expectedHeadersOFS[1].Offset)
-	c.Assert(err, IsNil)
-	c.Assert(h, DeepEquals, &expectedHeadersOFS[1])
-
-	// reset with non-seekable
-	f := fixtures.Basic().ByTag("ref-delta").One()
-	p.Reset(io.MultiReader(f.Packfile()))
-	c.Assert(p.IsSeekable, Equals, false)
-
-	_, err = p.SeekObjectHeader(expectedHeadersOFS[4].Offset)
-	c.Assert(err, Equals, ErrSeekNotSupported)
+func ptr[T any](value T) *T {
+	return &value
 }
 
-var expectedHeadersOFS = []ObjectHeader{
-	{Type: plumbing.CommitObject, Offset: 12, Length: 254},
-	{Type: plumbing.OFSDeltaObject, Offset: 186, Length: 93, OffsetReference: 12},
-	{Type: plumbing.CommitObject, Offset: 286, Length: 242},
-	{Type: plumbing.CommitObject, Offset: 449, Length: 242},
-	{Type: plumbing.CommitObject, Offset: 615, Length: 333},
-	{Type: plumbing.CommitObject, Offset: 838, Length: 332},
-	{Type: plumbing.CommitObject, Offset: 1063, Length: 244},
-	{Type: plumbing.CommitObject, Offset: 1230, Length: 243},
-	{Type: plumbing.CommitObject, Offset: 1392, Length: 187},
-	{Type: plumbing.BlobObject, Offset: 1524, Length: 189},
-	{Type: plumbing.BlobObject, Offset: 1685, Length: 18},
-	{Type: plumbing.BlobObject, Offset: 1713, Length: 1072},
-	{Type: plumbing.BlobObject, Offset: 2351, Length: 76110},
-	{Type: plumbing.BlobObject, Offset: 78050, Length: 2780},
-	{Type: plumbing.BlobObject, Offset: 78882, Length: 217848},
-	{Type: plumbing.BlobObject, Offset: 80725, Length: 706},
-	{Type: plumbing.BlobObject, Offset: 80998, Length: 11488},
-	{Type: plumbing.BlobObject, Offset: 84032, Length: 78},
-	{Type: plumbing.TreeObject, Offset: 84115, Length: 272},
-	{Type: plumbing.OFSDeltaObject, Offset: 84375, Length: 43, OffsetReference: 84115},
-	{Type: plumbing.TreeObject, Offset: 84430, Length: 38},
-	{Type: plumbing.TreeObject, Offset: 84479, Length: 75},
-	{Type: plumbing.TreeObject, Offset: 84559, Length: 38},
-	{Type: plumbing.TreeObject, Offset: 84608, Length: 34},
-	{Type: plumbing.BlobObject, Offset: 84653, Length: 9},
-	{Type: plumbing.OFSDeltaObject, Offset: 84671, Length: 6, OffsetReference: 84375},
-	{Type: plumbing.OFSDeltaObject, Offset: 84688, Length: 9, OffsetReference: 84375},
-	{Type: plumbing.OFSDeltaObject, Offset: 84708, Length: 6, OffsetReference: 84375},
-	{Type: plumbing.OFSDeltaObject, Offset: 84725, Length: 5, OffsetReference: 84115},
-	{Type: plumbing.OFSDeltaObject, Offset: 84741, Length: 8, OffsetReference: 84375},
-	{Type: plumbing.OFSDeltaObject, Offset: 84760, Length: 4, OffsetReference: 84741},
+var expectedHeadersOFS256 = []ObjectHeader{
+	{Type: plumbing.CommitObject, Offset: 12, Size: 254,
+		Hash:    plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"),
+		Hash256: ptr(plumbing.NewHash256("751ee7d8e2736460ea9b6f1b88aeb050dad7d7641b0313d27f0bb9bedd1b3726"))},
+	{Type: plumbing.OFSDeltaObject, Offset: 186, Size: 93, OffsetReference: 12},
+	{Type: plumbing.CommitObject, Offset: 286, Size: 242,
+		Hash:    plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"),
+		Hash256: ptr(plumbing.NewHash256("a279e860c7074462629fefb6a96e77eecb240eba291791c163581f6afeaa7f12"))},
+	{Type: plumbing.CommitObject, Offset: 449, Size: 242,
+		Hash:    plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"),
+		Hash256: ptr(plumbing.NewHash256("aa68eba21ad1796f88c16e470e0374bf6ed1376495ab3a367cd85698c3df766f"))},
+	{Type: plumbing.CommitObject, Offset: 615, Size: 333,
+		Hash:    plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea"),
+		Hash256: ptr(plumbing.NewHash256("4d00acb62a3ecb5f3f6871aa29c8ea670fc3d27042842277280c6b3e48a206f1"))},
+	{Type: plumbing.CommitObject, Offset: 838, Size: 332,
+		Hash:    plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"),
+		Hash256: ptr(plumbing.NewHash256("627852504dc677ba7ac2ec7717d69b42f787c8d79bac9fe1370b8775d2312e94"))},
+	{Type: plumbing.CommitObject, Offset: 1063, Size: 244,
+		Hash:    plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"),
+		Hash256: ptr(plumbing.NewHash256("00f0a27f127cffbb2a1089b772edd3ba7c82a6b69d666048b75d4bdcee24515d"))},
+	{Type: plumbing.CommitObject, Offset: 1230, Size: 243,
+		Hash:    plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"),
+		Hash256: ptr(plumbing.NewHash256("ef5441299e83e8707722706fefd89e77290a2a6e84be5202b980128eaa6decc2"))},
+	{Type: plumbing.CommitObject, Offset: 1392, Size: 187,
+		Hash:    plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"),
+		Hash256: ptr(plumbing.NewHash256("809c0681b603794597ef162c71184b38dda79364a423c6c61d2e514a1d46efff"))},
+	{Type: plumbing.BlobObject, Offset: 1524, Size: 189,
+		Hash:    plumbing.NewHash("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88"),
+		Hash256: ptr(plumbing.NewHash256("40b7c05726c9da78c3d5a705c2a48a120261b36f521302ce06bad41916d000f7"))},
+	{Type: plumbing.BlobObject, Offset: 1685, Size: 18,
+		Hash:    plumbing.NewHash("d3ff53e0564a9f87d8e84b6e28e5060e517008aa"),
+		Hash256: ptr(plumbing.NewHash256("e6ee53c7eb0e33417ee04110b84b304ff2da5c1b856f320b61ad9f2ef56c6e4e"))},
+	{Type: plumbing.BlobObject, Offset: 1713, Size: 1072,
+		Hash:    plumbing.NewHash("c192bd6a24ea1ab01d78686e417c8bdc7c3d197f"),
+		Hash256: ptr(plumbing.NewHash256("789c9f4220d167b66020b46bacddcad0ab5bb12f0f469576aa60bb59d98293dc"))},
+	{Type: plumbing.BlobObject, Offset: 2351, Size: 76110,
+		Hash:    plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d"),
+		Hash256: ptr(plumbing.NewHash256("665e33431d9b88280d7c1837680fdb66664c4cb4b394c9057cdbd07f3b4acff8"))},
+	{Type: plumbing.BlobObject, Offset: 78050, Size: 2780,
+		Hash:    plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198"),
+		Hash256: ptr(plumbing.NewHash256("33a5013ed4af64b6e54076c986a4733c2c11ce8ab27ede79f21366e8722ac5ed"))},
+	{Type: plumbing.BlobObject, Offset: 78882, Size: 217848,
+		Hash:    plumbing.NewHash("49c6bb89b17060d7b4deacb7b338fcc6ea2352a9"),
+		Hash256: ptr(plumbing.NewHash256("4c61794e77ff8c7ab7f07404cdb1bc0e989b27530e37a6be6d2ef73639aaff6d"))},
+	{Type: plumbing.BlobObject, Offset: 80725, Size: 706,
+		Hash:    plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956"),
+		Hash256: ptr(plumbing.NewHash256("2a246d3eaea67b7c4ac36d96d1dc9dad2a4dc24486c4d67eb7cb73963f522481"))},
+	{Type: plumbing.BlobObject, Offset: 80998, Size: 11488,
+		Hash:    plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492"),
+		Hash256: ptr(plumbing.NewHash256("73660d98a4c6c8951f86bb8c4744a0b4837a6dd5f796c314064c1615781c400c"))},
+	{Type: plumbing.BlobObject, Offset: 84032, Size: 78,
+		Hash:    plumbing.NewHash("9dea2395f5403188298c1dabe8bdafe562c491e3"),
+		Hash256: ptr(plumbing.NewHash256("2a7543a59f760f7ca41784bc898057799ae960323733cab1175c21960a750f72"))},
+	{Type: plumbing.TreeObject, Offset: 84115, Size: 272,
+		Hash:    plumbing.NewHash("dbd3641b371024f44d0e469a9c8f5457b0660de1"),
+		Hash256: ptr(plumbing.NewHash256("773b6c73238a74067c97f193c06c1bf38a982e39ded04fdf9c833ebc34cedd3d"))},
+	{Type: plumbing.OFSDeltaObject, Offset: 84375, Size: 43, OffsetReference: 84115},
+	{Type: plumbing.TreeObject, Offset: 84430, Size: 38,
+		Hash:    plumbing.NewHash("a39771a7651f97faf5c72e08224d857fc35133db"),
+		Hash256: ptr(plumbing.NewHash256("166e4d7c5b5771422259dda0819ea54e06a6e4f07cf927d9fc95f5c370fff28a"))},
+	{Type: plumbing.TreeObject, Offset: 84479, Size: 75,
+		Hash:    plumbing.NewHash("5a877e6a906a2743ad6e45d99c1793642aaf8eda"),
+		Hash256: ptr(plumbing.NewHash256("393e771684c98451b904457acffac4ca5bd5a736a1b9127cedf7b8fa1b6a9901"))},
+	{Type: plumbing.TreeObject, Offset: 84559, Size: 38,
+		Hash:    plumbing.NewHash("586af567d0bb5e771e49bdd9434f5e0fb76d25fa"),
+		Hash256: ptr(plumbing.NewHash256("3db5b7f8353ebe6e4d4bff0bd2953952e08d73e72040abe4a46d08e7c3593dcc"))},
+	{Type: plumbing.TreeObject, Offset: 84608, Size: 34,
+		Hash:    plumbing.NewHash("cf4aa3b38974fb7d81f367c0830f7d78d65ab86b"),
+		Hash256: ptr(plumbing.NewHash256("e39c8c3d47aa310861634c6cf44e54e847c02f99c34c8cb25246e16f40502a7e"))},
+	{Type: plumbing.BlobObject, Offset: 84653, Size: 9,
+		Hash:    plumbing.NewHash("7e59600739c96546163833214c36459e324bad0a"),
+		Hash256: ptr(plumbing.NewHash256("1f307724f91af43be1570b77aeef69c5010e8136e50bef83c28de2918a08f494"))},
+	{Type: plumbing.OFSDeltaObject, Offset: 84671, Size: 6, OffsetReference: 84375},
+	{Type: plumbing.OFSDeltaObject, Offset: 84688, Size: 9, OffsetReference: 84375},
+	{Type: plumbing.OFSDeltaObject, Offset: 84708, Size: 6, OffsetReference: 84375},
+	{Type: plumbing.OFSDeltaObject, Offset: 84725, Size: 5, OffsetReference: 84115},
+	{Type: plumbing.OFSDeltaObject, Offset: 84741, Size: 8, OffsetReference: 84375},
+	{Type: plumbing.OFSDeltaObject, Offset: 84760, Size: 4, OffsetReference: 84741},
 }
 
 var expectedCRCOFS = []uint32{
···
 }
 
 var expectedHeadersREF = []ObjectHeader{
-	{Type: plumbing.CommitObject, Offset: 12, Length: 254},
-	{Type: plumbing.REFDeltaObject, Offset: 186, Length: 93,
+	{Type: plumbing.CommitObject, Offset: 12, Size: 254, Hash: plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881")},
+	{Type: plumbing.REFDeltaObject, Offset: 186, Size: 93,
 		Reference: plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881")},
-	{Type: plumbing.CommitObject, Offset: 304, Length: 242},
-	{Type: plumbing.CommitObject, Offset: 467, Length: 242},
-	{Type: plumbing.CommitObject, Offset: 633, Length: 333},
-	{Type: plumbing.CommitObject, Offset: 856, Length: 332},
-	{Type: plumbing.CommitObject, Offset: 1081, Length: 243},
-	{Type: plumbing.CommitObject, Offset: 1243, Length: 244},
-	{Type: plumbing.CommitObject, Offset: 1410, Length: 187},
-	{Type: plumbing.BlobObject, Offset: 1542, Length: 189},
-	{Type: plumbing.BlobObject, Offset: 1703, Length: 18},
-	{Type: plumbing.BlobObject, Offset: 1731, Length: 1072},
-	{Type: plumbing.BlobObject, Offset: 2369, Length: 76110},
-	{Type: plumbing.TreeObject, Offset: 78068, Length: 38},
-	{Type: plumbing.BlobObject, Offset: 78117, Length: 2780},
-	{Type: plumbing.TreeObject, Offset: 79049, Length: 75},
-	{Type: plumbing.BlobObject, Offset: 79129, Length: 217848},
-	{Type: plumbing.BlobObject, Offset: 80972, Length: 706},
-	{Type: plumbing.TreeObject, Offset: 81265, Length: 38},
-	{Type: plumbing.BlobObject, Offset: 81314, Length: 11488},
-	{Type: plumbing.TreeObject, Offset: 84752, Length: 34},
-	{Type: plumbing.BlobObject, Offset: 84797, Length: 78},
-	{Type: plumbing.TreeObject, Offset: 84880, Length: 271},
-	{Type: plumbing.REFDeltaObject, Offset: 85141, Length: 6,
+	{Type: plumbing.CommitObject, Offset: 304, Size: 242, Hash: plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294")},
+	{Type: plumbing.CommitObject, Offset: 467, Size: 242, Hash: plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a")},
+	{Type: plumbing.CommitObject, Offset: 633, Size: 333, Hash: plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea")},
+	{Type: plumbing.CommitObject, Offset: 856, Size: 332, Hash: plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69")},
+	{Type: plumbing.CommitObject, Offset: 1081, Size: 243, Hash: plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47")},
+	{Type: plumbing.CommitObject, Offset: 1243, Size: 244, Hash: plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9")},
+	{Type: plumbing.CommitObject, Offset: 1410, Size: 187, Hash: plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d")},
+	{Type: plumbing.BlobObject, Offset: 1542, Size: 189, Hash: plumbing.NewHash("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88")},
+	{Type: plumbing.BlobObject, Offset: 1703, Size: 18, Hash: plumbing.NewHash("d3ff53e0564a9f87d8e84b6e28e5060e517008aa")},
+	{Type: plumbing.BlobObject, Offset: 1731, Size: 1072, Hash: plumbing.NewHash("c192bd6a24ea1ab01d78686e417c8bdc7c3d197f")},
+	{Type: plumbing.BlobObject, Offset: 2369, Size: 76110, Hash: plumbing.NewHash("d5c0f4ab811897cadf03aec358ae60d21f91c50d")},
+	{Type: plumbing.TreeObject, Offset: 78068, Size: 38, Hash: plumbing.NewHash("a39771a7651f97faf5c72e08224d857fc35133db")},
+	{Type: plumbing.BlobObject, Offset: 78117, Size: 2780, Hash: plumbing.NewHash("880cd14280f4b9b6ed3986d6671f907d7cc2a198")},
+	{Type: plumbing.TreeObject, Offset: 79049, Size: 75, Hash: plumbing.NewHash("5a877e6a906a2743ad6e45d99c1793642aaf8eda")},
+	{Type: plumbing.BlobObject, Offset: 79129, Size: 217848, Hash: plumbing.NewHash("49c6bb89b17060d7b4deacb7b338fcc6ea2352a9")},
+	{Type: plumbing.BlobObject, Offset: 80972, Size: 706, Hash: plumbing.NewHash("c8f1d8c61f9da76f4cb49fd86322b6e685dba956")},
+	{Type: plumbing.TreeObject, Offset: 81265, Size: 38, Hash: plumbing.NewHash("586af567d0bb5e771e49bdd9434f5e0fb76d25fa")},
+	{Type: plumbing.BlobObject, Offset: 81314, Size: 11488, Hash: plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492")},
+	{Type: plumbing.TreeObject, Offset: 84752, Size: 34, Hash: plumbing.NewHash("cf4aa3b38974fb7d81f367c0830f7d78d65ab86b")},
+	{Type: plumbing.BlobObject, Offset: 84797, Size: 78, Hash: plumbing.NewHash("9dea2395f5403188298c1dabe8bdafe562c491e3")},
+	{Type: plumbing.TreeObject, Offset: 84880, Size: 271, Hash: plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")},
+	{Type: plumbing.REFDeltaObject, Offset: 85141, Size: 6,
 		Reference: plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")},
-	{Type: plumbing.REFDeltaObject, Offset: 85176, Length: 37,
+	{Type: plumbing.REFDeltaObject, Offset: 85176, Size: 37,
 		Reference: plumbing.NewHash("fb72698cab7617ac416264415f13224dfd7a165e")},
-	{Type: plumbing.BlobObject, Offset: 85244, Length: 9},
-	{Type: plumbing.REFDeltaObject, Offset: 85262, Length: 9,
+	{Type: plumbing.BlobObject, Offset: 85244, Size: 9, Hash: plumbing.NewHash("7e59600739c96546163833214c36459e324bad0a")},
+	{Type: plumbing.REFDeltaObject, Offset: 85262, Size: 9,
 		Reference: plumbing.NewHash("fb72698cab7617ac416264415f13224dfd7a165e")},
-	{Type: plumbing.REFDeltaObject, Offset: 85300, Length: 6,
+	{Type: plumbing.REFDeltaObject, Offset: 85300, Size: 6,
 		Reference: plumbing.NewHash("fb72698cab7617ac416264415f13224dfd7a165e")},
-	{Type: plumbing.TreeObject, Offset: 85335, Length: 110},
-	{Type: plumbing.REFDeltaObject, Offset: 85448, Length: 8,
+	{Type: plumbing.TreeObject, Offset: 85335, Size: 110, Hash: plumbing.NewHash("c2d30fa8ef288618f65f6eed6e168e0d514886f4")},
+	{Type: plumbing.REFDeltaObject, Offset: 85448, Size: 8,
 		Reference: plumbing.NewHash("eba74343e2f15d62adedfd8c883ee0262b5c8021")},
-	{Type: plumbing.TreeObject, Offset: 85485, Length: 73},
+	{Type: plumbing.TreeObject, Offset: 85485, Size: 73, Hash: plumbing.NewHash("aa9b383c260e1d05fbbf6b30a02914555e20c725")},
 }
 
 var expectedCRCREF = []uint32{

plumbing/format/packfile/types.go

···
+package packfile
+
+import (
+	"bytes"
+
+	"github.com/go-git/go-git/v5/plumbing"
+)
+
+type Version uint32
+
+const (
+	V2 Version = 2
+)
+
+func (v Version) Supported() bool {
+	switch v {
+	case V2:
+		return true
+	default:
+		return false
+	}
+}
+
+// ObjectHeader contains the information related to the object, this information
+// is collected from the previous bytes to the content of the object.
+type ObjectHeader struct {
+	Type            plumbing.ObjectType
+	Offset          int64
+	ContentOffset   int64
+	Size            int64
+	Reference       plumbing.Hash
+	OffsetReference int64
+	Crc32           uint32
+	Hash            plumbing.Hash
+	Hash256         *plumbing.Hash256
+
+	content     bytes.Buffer
+	parent      *ObjectHeader
+	diskType    plumbing.ObjectType
+	externalRef bool
+}
+
+type SectionType int
+
+const (
+	HeaderSection SectionType = iota
+	ObjectSection
+	FooterSection
+)
+
+type Header struct {
+	Version    Version
+	ObjectsQty uint32
+}
+
+type PackData struct {
+	Section      SectionType
+	header       Header
+	objectHeader ObjectHeader
+	checksum     plumbing.Hash
+}
+
+func (p PackData) Value() interface{} {
+	switch p.Section {
+	case HeaderSection:
+		return p.header
+	case ObjectSection:
+		return p.objectHeader
+	case FooterSection:
+		return p.checksum
+	default:
+		return nil
+	}
+}

plumbing/hash.go

···
 
 func NewHasher(t ObjectType, size int64) Hasher {
 	h := Hasher{hash.New(hash.CryptoType)}
+	h.Reset(t, size)
+	return h
+}
+
+func (h Hasher) Reset(t ObjectType, size int64) {
+	h.Hash.Reset()
 	h.Write(t.Bytes())
 	h.Write([]byte(" "))
 	h.Write([]byte(strconv.FormatInt(size, 10)))
 	h.Write([]byte{0})
-	return h
 }
 
 func (h Hasher) Sum() (hash Hash) {

plumbing/hash256.go

···
+package plumbing
+
+import (
+	"crypto"
+	"encoding/hex"
+	"strconv"
+
+	"github.com/go-git/go-git/v5/plumbing/hash"
+)
+
+// NewHash return a new Hash256 from a hexadecimal hash representation.
+func NewHash256(s string) Hash256 {
+	b, _ := hex.DecodeString(s)
+
+	var h Hash256
+	copy(h[:], b)
+
+	return h
+}
+
+// Hash256 represents SHA256 hashed content.
+type Hash256 [32]byte
+
+// ZeroHash is Hash256 with value zero.
+var ZeroHash256 Hash256
+
+func (h Hash256) IsZero() bool {
+	var empty Hash256
+	return h == empty
+}
+
+func (h Hash256) String() string {
+	return hex.EncodeToString(h[:])
+}
+
+// ComputeHash compute the hash for a given ObjectType and content.
+func ComputeHash256(t ObjectType, content []byte) Hash256 {
+	h := NewHasher256(t, int64(len(content)))
+	h.Write(content)
+	return h.Sum()
+}
+
+type Hasher256 struct {
+	hash.Hash
+}
+
+func NewHasher256(t ObjectType, size int64) Hasher256 {
+	h := Hasher256{hash.New(crypto.SHA256)}
+	h.Reset(t, size)
+	return h
+}
+
+func (h Hasher256) Reset(t ObjectType, size int64) {
+	h.Hash.Reset()
+	h.Write(t.Bytes())
+	h.Write([]byte(" "))
+	h.Write([]byte(strconv.FormatInt(size, 10)))
+	h.Write([]byte{0})
+}
+
+func (h Hasher256) Sum() (hash Hash256) {
+	copy(hash[:], h.Hash.Sum(nil))
+	return
+}

plumbing/memory.go

···
 import (
 	"bytes"
 	"io"
+	"slices"
 )
 
 // MemoryObject on memory Object implementation
···
 
 // SetSize set the object size, a content of the given size should be written
 // afterwards
-func (o *MemoryObject) SetSize(s int64) { o.sz = s }
+func (o *MemoryObject) SetSize(s int64) {
+	o.cont = slices.Grow(o.cont, int(s))
+	o.sz = s
+}
 
 // Reader returns an io.ReadCloser used to read the object's content.
 //

plumbing/object/commitgraph/commitnode_walker_test.go

···
 
 import (
 	"strings"
+	"testing"
 
 	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/go-git/go-git/v5/plumbing/cache"
 	commitgraph "github.com/go-git/go-git/v5/plumbing/format/commitgraph/v2"
+	"github.com/go-git/go-git/v5/plumbing/format/packfile"
+	"github.com/go-git/go-git/v5/storage/filesystem"
+	"github.com/stretchr/testify/assert"
 
-	fixtures "github.com/go-git/go-git-fixtures/v4"
-	. "gopkg.in/check.v1"
+	fixtures "github.com/go-git/go-git-fixtures/v5"
 )
 
-func (s *CommitNodeSuite) TestCommitNodeIter(c *C) {
+func TestCommitNodeIter(t *testing.T) {
+	t.Parallel()
+
 	f := fixtures.ByTag("commit-graph-chain-2").One()
 
-	storer := unpackRepository(f)
+	storer := newUnpackRepository(f)
 
 	index, err := commitgraph.OpenChainOrFileIndex(storer.Filesystem())
-	c.Assert(err, IsNil)
+	assert.NoError(t, err)
 
 	nodeIndex := NewGraphCommitNodeIndex(index, storer)
 
 	head, err := nodeIndex.Get(plumbing.NewHash("ec6f456c0e8c7058a29611429965aa05c190b54b"))
-	c.Assert(err, IsNil)
+	assert.NoError(t, err)
+
+	testTopoOrder(t, head)
+	testDateOrder(t, head)
+	testAuthorDateOrder(t, head)
+}
 
-	testTopoOrder(c, head)
-	testDateOrder(c, head)
-	testAuthorDateOrder(c, head)
+func newUnpackRepository(f *fixtures.Fixture) *filesystem.Storage {
+	storer := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
+	p := f.Packfile()
+	defer p.Close()
+	packfile.UpdateObjectStorage(storer, p)
+	return storer
 }
 
-func testTopoOrder(c *C, head CommitNode) {
+func testTopoOrder(t *testing.T, head CommitNode) {
 	iter := NewCommitNodeIterTopoOrder(
 		head,
 		nil,
···
 		commits = append(commits, c.ID().String())
 		return nil
 	})
-	c.Assert(commits, DeepEquals, strings.Split(`ec6f456c0e8c7058a29611429965aa05c190b54b
+
+	assert.Equal(t, commits, strings.Split(`ec6f456c0e8c7058a29611429965aa05c190b54b
 d82f291cde9987322c8a0c81a325e1ba6159684c
 3048d280d2d5b258d9e582a226ff4bbed34fd5c9
 27aa8cdd2431068606741a589383c02c149ea625
···
 5d7303c49ac984a9fec60523f2d5297682e16646`, "\n"))
 }
 
-func testDateOrder(c *C, head CommitNode) {
+func testDateOrder(t *testing.T, head CommitNode) {
 	iter := NewCommitNodeIterDateOrder(
 		head,
 		nil,
···
 		return nil
 	})
 
-	c.Assert(commits, DeepEquals, strings.Split(`ec6f456c0e8c7058a29611429965aa05c190b54b
+	assert.Equal(t, commits, strings.Split(`ec6f456c0e8c7058a29611429965aa05c190b54b
 3048d280d2d5b258d9e582a226ff4bbed34fd5c9
 d82f291cde9987322c8a0c81a325e1ba6159684c
 27aa8cdd2431068606741a589383c02c149ea625
···
 5d7303c49ac984a9fec60523f2d5297682e16646`, "\n"))
 }
 
-func testAuthorDateOrder(c *C, head CommitNode) {
+func testAuthorDateOrder(t *testing.T, head CommitNode) {
 	iter := NewCommitNodeIterAuthorDateOrder(
 		head,
 		nil,
···
 		return nil
 	})
 
-	c.Assert(commits, DeepEquals, strings.Split(`ec6f456c0e8c7058a29611429965aa05c190b54b
+	assert.Equal(t, commits, strings.Split(`ec6f456c0e8c7058a29611429965aa05c190b54b
 3048d280d2d5b258d9e582a226ff4bbed34fd5c9
 d82f291cde9987322c8a0c81a325e1ba6159684c
 27aa8cdd2431068606741a589383c02c149ea625

plumbing/storer/object.go

···
 
 // EncodedObjectStorer generic storage of objects
 type EncodedObjectStorer interface {
+	// RawObjectWriter returns a io.WriterCloser to write the object without the
+	// need of providing a plumbing.EncodedObject.
+	RawObjectWriter(typ plumbing.ObjectType, sz int64) (w io.WriteCloser, err error)
 	// NewEncodedObject returns a new plumbing.EncodedObject, the real type
 	// of the object can be a custom implementation or the default one,
 	// plumbing.MemoryObject.
 	NewEncodedObject() plumbing.EncodedObject
 	// SetEncodedObject saves an object into the storage, the object should
-	// be create with the NewEncodedObject, method, and file if the type is
+	// be created with the NewEncodedObject, method, and file if the type is
 	// not supported.
 	SetEncodedObject(plumbing.EncodedObject) (plumbing.Hash, error)
 	// EncodedObject gets an object by hash with the given

plumbing/storer/object_test.go

···
 
 import (
 	"fmt"
+	"io"
 	"testing"
 
 	"github.com/go-git/go-git/v5/plumbing"
···
 
 type MockObjectStorage struct {
 	db []plumbing.EncodedObject
+}
+
+func (o *MockObjectStorage) RawObjectWriter(typ plumbing.ObjectType, sz int64) (w io.WriteCloser, err error) {
+	return nil, nil
 }
 
 func (o *MockObjectStorage) NewEncodedObject() plumbing.EncodedObject {

storage/filesystem/dotgit/writers.go

···
 // this operation is synchronized with the write operations.
 // The packfile is written in a temp file, when Close is called this file
 // is renamed/moved (depends on the Filesystem implementation) to the final
-// location, if the PackWriter is not used, nothing is written
+// location, if the PackWriter is not used, nothing is written.
 type PackWriter struct {
 	Notify func(plumbing.Hash, *idxfile.Writer)
 
···
 }
 
 func (w *PackWriter) buildIndex() {
-	s := packfile.NewScanner(w.synced)
 	w.writer = new(idxfile.Writer)
 	var err error
-	w.parser, err = packfile.NewParser(s, w.writer)
-	if err != nil {
-		w.result <- err
-		return
-	}
 
-	checksum, err := w.parser.Parse()
+	w.parser = packfile.NewParser(w.synced, packfile.WithScannerObservers(w.writer))
+
+	h, err := w.parser.Parse()
 	if err != nil {
 		w.result <- err
 		return
 	}
 
-	w.checksum = checksum
-	w.result <- err
+	w.checksum = h
+	w.result <- nil
 }
 
 // waitBuildIndex waits until buildIndex function finishes, this can terminate

storage/filesystem/dotgit/writers_test.go

···
 	"io"
 	"os"
 	"strconv"
+	"testing"
 
 	"github.com/go-git/go-billy/v5/osfs"
 	"github.com/go-git/go-billy/v5/util"
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/format/idxfile"
 	"github.com/go-git/go-git/v5/plumbing/format/packfile"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
-	fixtures "github.com/go-git/go-git-fixtures/v4"
-	. "gopkg.in/check.v1"
+	fixtures "github.com/go-git/go-git-fixtures/v5"
 )
 
-func (s *SuiteDotGit) TestNewObjectPack(c *C) {
+func TestNewObjectPack(t *testing.T) {
+	t.Parallel()
+
 	f := fixtures.Basic().One()
 
-	fs, clean := s.TemporalFilesystem()
-	defer clean()
-
+	fs := osfs.New(t.TempDir())
 	dot := New(fs)
 
 	w, err := dot.NewObjectPack()
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	_, err = io.Copy(w, f.Packfile())
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
-	c.Assert(w.Close(), IsNil)
+	require.NoError(t, w.Close())
 
 	pfPath := fmt.Sprintf("objects/pack/pack-%s.pack", f.PackfileHash)
 	idxPath := fmt.Sprintf("objects/pack/pack-%s.idx", f.PackfileHash)
 
 	stat, err := fs.Stat(pfPath)
-	c.Assert(err, IsNil)
-	c.Assert(stat.Size(), Equals, int64(84794))
+	require.NoError(t, err)
+	assert.Equal(t, int64(84794), stat.Size())
 
 	stat, err = fs.Stat(idxPath)
-	c.Assert(err, IsNil)
-	c.Assert(stat.Size(), Equals, int64(1940))
+	require.NoError(t, err)
+	assert.Equal(t, int64(1940), stat.Size())
 
 	pf, err := fs.Open(pfPath)
-	c.Assert(err, IsNil)
+	assert.NoError(t, err)
+
+	objFound := false
 	pfs := packfile.NewScanner(pf)
-	_, objects, err := pfs.Header()
-	c.Assert(err, IsNil)
-	for i := uint32(0); i < objects; i++ {
-		_, err := pfs.NextObjectHeader()
-		if err != nil {
-			c.Assert(err, IsNil)
-			break
+	for pfs.Scan() {
+		data := pfs.Data()
+		if data.Section != packfile.ObjectSection {
+			continue
 		}
+
+		objFound = true
+		assert.NotNil(t, data.Value())
 	}
-	c.Assert(pfs.Close(), IsNil)
+
+	assert.NoError(t, pf.Close())
+	assert.True(t, objFound)
 }
 
-func (s *SuiteDotGit) TestNewObjectPackUnused(c *C) {
-	fs, clean := s.TemporalFilesystem()
-	defer clean()
+func TestNewObjectPackUnused(t *testing.T) {
+	t.Parallel()
 
+	fs := osfs.New(t.TempDir())
 	dot := New(fs)
 
 	w, err := dot.NewObjectPack()
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
-	c.Assert(w.Close(), IsNil)
+	assert.NoError(t, w.Close())
 
 	info, err := fs.ReadDir("objects/pack")
-	c.Assert(err, IsNil)
-	c.Assert(info, HasLen, 0)
+	require.NoError(t, err)
+	assert.Len(t, info, 0)
 
 	// check clean up of temporary files
 	info, err = fs.ReadDir("")
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	for _, fi := range info {
-		c.Assert(fi.IsDir(), Equals, true)
+		assert.True(t, fi.IsDir())
 	}
 }
 
-func (s *SuiteDotGit) TestSyncedReader(c *C) {
+func TestSyncedReader(t *testing.T) {
+	t.Parallel()
+
 	tmpw, err := util.TempFile(osfs.Default, "", "example")
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	tmpr, err := osfs.Default.Open(tmpw.Name())
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	defer func() {
 		tmpw.Close()
···
 	go func() {
 		for i := 0; i < 281; i++ {
 			_, err := synced.Write([]byte(strconv.Itoa(i) + "\n"))
-			c.Assert(err, IsNil)
+			require.NoError(t, err)
 		}
 
 		synced.Close()
 	}()
 
 	o, err := synced.Seek(1002, io.SeekStart)
-	c.Assert(err, IsNil)
-	c.Assert(o, Equals, int64(1002))
+	require.NoError(t, err)
+	assert.Equal(t, int64(1002), o)
 
 	head := make([]byte, 3)
 	n, err := io.ReadFull(synced, head)
-	c.Assert(err, IsNil)
-	c.Assert(n, Equals, 3)
-	c.Assert(string(head), Equals, "278")
+	require.NoError(t, err)
+	assert.Equal(t, 3, n)
+	assert.Equal(t, "278", string(head))
 
 	o, err = synced.Seek(1010, io.SeekStart)
-	c.Assert(err, IsNil)
-	c.Assert(o, Equals, int64(1010))
+	require.NoError(t, err)
+	assert.Equal(t, int64(1010), o)
 
 	n, err = io.ReadFull(synced, head)
-	c.Assert(err, IsNil)
-	c.Assert(n, Equals, 3)
-	c.Assert(string(head), Equals, "280")
+	require.NoError(t, err)
+	assert.Equal(t, 3, n)
+	assert.Equal(t, "280", string(head))
 }
 
-func (s *SuiteDotGit) TestPackWriterUnusedNotify(c *C) {
-	fs, clean := s.TemporalFilesystem()
-	defer clean()
-
+func TestPackWriterUnusedNotify(t *testing.T) {
+	fs := osfs.New(t.TempDir())
 	w, err := newPackWrite(fs)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	w.Notify = func(h plumbing.Hash, idx *idxfile.Writer) {
-		c.Fatal("unexpected call to PackWriter.Notify")
+		t.Fatal("unexpected call to PackWriter.Notify")
 	}
 
-	c.Assert(w.Close(), IsNil)
+	assert.NoError(t, w.Close())
 }

storage/filesystem/object.go

···
 
 import (
 	"bytes"
+	"fmt"
 	"io"
 	"os"
 	"sync"
···
 	"github.com/go-git/go-git/v5/plumbing/storer"
 	"github.com/go-git/go-git/v5/storage/filesystem/dotgit"
 	"github.com/go-git/go-git/v5/utils/ioutil"
-
-	"github.com/go-git/go-billy/v5"
 )
 
 type ObjectStorage struct {
 	options Options
 
-	// objectCache is an object cache uses to cache delta's bases and also recently
-	// loaded loose objects
+	// objectCache is an object cache used to cache delta's bases and also recently
+	// loaded loose objects.
 	objectCache cache.Object
 
 	dir   *dotgit.DotGit
···
 	return err
 }
 
+func (s *ObjectStorage) RawObjectWriter(typ plumbing.ObjectType, sz int64) (w io.WriteCloser, err error) {
+	ow, err := s.dir.NewObject()
+	if err != nil {
+		return nil, err
+	}
+
+	err = ow.WriteHeader(typ, sz)
+	if err != nil {
+		return nil, err
+	}
+
+	return ow, nil
+}
+
 func (s *ObjectStorage) NewEncodedObject() plumbing.EncodedObject {
 	return &plumbing.MemoryObject{}
 }
···
 		return nil, err
 	}
 
-	var p *packfile.Packfile
-	if s.objectCache != nil {
-		p = packfile.NewPackfileWithCache(idx, s.dir.Fs(), f, s.objectCache, s.options.LargeObjectThreshold)
-	} else {
-		p = packfile.NewPackfile(idx, s.dir.Fs(), f, s.options.LargeObjectThreshold)
-	}
-
+	p := packfile.NewPackfile(f,
+		packfile.WithIdx(idx),
+		packfile.WithFs(s.dir.Fs()),
+		packfile.WithCache(s.objectCache),
+	)
 	return p, s.storePackfileInCache(pack, p)
 }
 
···
 		return nil, err
 	}
 
-	if plumbing.AnyObject != t && obj.Type() != t {
+	if obj == nil || (plumbing.AnyObject != t && obj.Type() != t) {
 		return nil, plumbing.ErrObjectNotFound
 	}
 
···
 		return s.decodeDeltaObjectAt(p, offset, hash)
 	}
 
-	return s.decodeObjectAt(p, offset)
-}
-
-func (s *ObjectStorage) decodeObjectAt(
-	p *packfile.Packfile,
-	offset int64,
-) (plumbing.EncodedObject, error) {
-	hash, err := p.FindHash(offset)
-	if err == nil {
-		obj, ok := s.objectCache.Get(hash)
-		if ok {
-			return obj, nil
-		}
-	}
-
-	if err != nil && err != plumbing.ErrObjectNotFound {
-		return nil, err
-	}
-
 	return p.GetByOffset(offset)
 }
 
+// TODO: refactor this logic into packfile package.
 func (s *ObjectStorage) decodeDeltaObjectAt(
 	p *packfile.Packfile,
 	offset int64,
 	hash plumbing.Hash,
 ) (plumbing.EncodedObject, error) {
-	scan := p.Scanner()
-	header, err := scan.SeekObjectHeader(offset)
+	scan, err := p.Scanner()
 	if err != nil {
 		return nil, err
 	}
+	err = scan.SeekFromStart(offset)
+	if err != nil {
+		return nil, err
+	}
+
+	if !scan.Scan() {
+		return nil, fmt.Errorf("failed to decode delta object")
+	}
+
+	header := scan.Data().Value().(packfile.ObjectHeader)
 
 	var (
 		base plumbing.Hash
···
 			return nil, err
 		}
 	default:
-		return s.decodeObjectAt(p, offset)
+		return p.GetByOffset(offset)
 	}
 
 	obj := &plumbing.MemoryObject{}
···
 		return nil, err
 	}
 
-	if _, _, err := scan.NextObject(w); err != nil {
+	if err := scan.WriteObject(&header, w); err != nil {
 		return nil, err
 	}
 
-	return newDeltaObject(obj, hash, base, header.Length), nil
+	return newDeltaObject(obj, hash, base, header.Size), nil
 }
 
 func (s *ObjectStorage) findObjectInPackfile(h plumbing.Hash) (plumbing.Hash, plumbing.Hash, int64) {
···
 			return newPackfileIter(
 				s.dir.Fs(), pack, t, seen, s.index[h],
 				s.objectCache, s.options.KeepDescriptors,
-				s.options.LargeObjectThreshold,
 			)
 		},
 	}, nil
···
 	s.dir.Close()
 
 	return firstError
-}
-
-type lazyPackfilesIter struct {
-	hashes []plumbing.Hash
-	open   func(h plumbing.Hash) (storer.EncodedObjectIter, error)
-	cur    storer.EncodedObjectIter
-}
-
-func (it *lazyPackfilesIter) Next() (plumbing.EncodedObject, error) {
-	for {
-		if it.cur == nil {
-			if len(it.hashes) == 0 {
-				return nil, io.EOF
-			}
-			h := it.hashes[0]
-			it.hashes = it.hashes[1:]
-
-			sub, err := it.open(h)
-			if err == io.EOF {
-				continue
-			} else if err != nil {
-				return nil, err
-			}
-			it.cur = sub
-		}
-		ob, err := it.cur.Next()
-		if err == io.EOF {
-			it.cur.Close()
-			it.cur = nil
-			continue
-		} else if err != nil {
-			return nil, err
-		}
-		return ob, nil
-	}
-}
-
-func (it *lazyPackfilesIter) ForEach(cb func(plumbing.EncodedObject) error) error {
-	return storer.ForEachIterator(it, cb)
-}
-
-func (it *lazyPackfilesIter) Close() {
-	if it.cur != nil {
-		it.cur.Close()
-		it.cur = nil
-	}
-	it.hashes = nil
-}
-
-type packfileIter struct {
-	pack billy.File
-	iter storer.EncodedObjectIter
-	seen map[plumbing.Hash]struct{}
-
-	// tells whether the pack file should be left open after iteration or not
-	keepPack bool
-}
-
-// NewPackfileIter returns a new EncodedObjectIter for the provided packfile
-// and object type. Packfile and index file will be closed after they're
-// used. If keepPack is true the packfile won't be closed after the iteration
-// finished.
-func NewPackfileIter(
-	fs billy.Filesystem,
-	f billy.File,
-	idxFile billy.File,
-	t plumbing.ObjectType,
-	keepPack bool,
-	largeObjectThreshold int64,
-) (storer.EncodedObjectIter, error) {
-	idx := idxfile.NewMemoryIndex()
-	if err := idxfile.NewDecoder(idxFile).Decode(idx); err != nil {
-		return nil, err
-	}
-
-	if err := idxFile.Close(); err != nil {
-		return nil, err
-	}
-
-	seen := make(map[plumbing.Hash]struct{})
-	return newPackfileIter(fs, f, t, seen, idx, nil, keepPack, largeObjectThreshold)
-}
-
-func newPackfileIter(
-	fs billy.Filesystem,
-	f billy.File,
-	t plumbing.ObjectType,
-	seen map[plumbing.Hash]struct{},
-	index idxfile.Index,
-	cache cache.Object,
-	keepPack bool,
-	largeObjectThreshold int64,
-) (storer.EncodedObjectIter, error) {
-	var p *packfile.Packfile
-	if cache != nil {
-		p = packfile.NewPackfileWithCache(index, fs, f, cache, largeObjectThreshold)
-	} else {
-		p = packfile.NewPackfile(index, fs, f, largeObjectThreshold)
-	}
-
-	iter, err := p.GetByType(t)
-	if err != nil {
-		return nil, err
-	}
-
-	return &packfileIter{
-		pack:     f,
-		iter:     iter,
-		seen:     seen,
-		keepPack: keepPack,
-	}, nil
-}
-
-func (iter *packfileIter) Next() (plumbing.EncodedObject, error) {
-	for {
-		obj, err := iter.iter.Next()
-		if err != nil {
-			return nil, err
-		}
-
-		if _, ok := iter.seen[obj.Hash()]; ok {
-			continue
-		}
-
-		return obj, nil
-	}
-}
-
-func (iter *packfileIter) ForEach(cb func(plumbing.EncodedObject) error) error {
-	for {
-		o, err := iter.Next()
-		if err != nil {
-			if err == io.EOF {
-				iter.Close()
-				return nil
-			}
-			return err
-		}
-
-		if err := cb(o); err != nil {
-			return err
-		}
-	}
-}
-
-func (iter *packfileIter) Close() {
-	iter.iter.Close()
-	if !iter.keepPack {
-		_ = iter.pack.Close()
-	}
-}
-
-type objectsIter struct {
-	s *ObjectStorage
-	t plumbing.ObjectType
-	h []plumbing.Hash
-}
-
-func (iter *objectsIter) Next() (plumbing.EncodedObject, error) {
-	if len(iter.h) == 0 {
-		return nil, io.EOF
-	}
-
-	obj, err := iter.s.getFromUnpacked(iter.h[0])
-	iter.h = iter.h[1:]
-
-	if err != nil {
-		return nil, err
-	}
-
-	if iter.t != plumbing.AnyObject && iter.t != obj.Type() {
-		return iter.Next()
-	}
-
-	return obj, err
-}
-
-func (iter *objectsIter) ForEach(cb func(plumbing.EncodedObject) error) error {
-	for {
-		o, err := iter.Next()
-		if err != nil {
-			if err == io.EOF {
-				return nil
-			}
-			return err
-		}
-
-		if err := cb(o); err != nil {
-			return err
-		}
-	}
-}
-
-func (iter *objectsIter) Close() {
-	iter.h = []plumbing.Hash{}
 }
 
 func hashListAsMap(l []plumbing.Hash) map[plumbing.Hash]struct{} {

storage/filesystem/object_iter.go

···
+package filesystem
+
+import (
+	"io"
+
+	"github.com/go-git/go-billy/v5"
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/go-git/go-git/v5/plumbing/cache"
+	"github.com/go-git/go-git/v5/plumbing/format/idxfile"
+	"github.com/go-git/go-git/v5/plumbing/format/packfile"
+	"github.com/go-git/go-git/v5/plumbing/storer"
+)
+
+type lazyPackfilesIter struct {
+	hashes []plumbing.Hash
+	open   func(h plumbing.Hash) (storer.EncodedObjectIter, error)
+	cur    storer.EncodedObjectIter
+}
+
+func (it *lazyPackfilesIter) Next() (plumbing.EncodedObject, error) {
+	for {
+		if it.cur == nil {
+			if len(it.hashes) == 0 {
+				return nil, io.EOF
+			}
+			h := it.hashes[0]
+			it.hashes = it.hashes[1:]
+
+			sub, err := it.open(h)
+			if err == io.EOF {
+				continue
+			} else if err != nil {
+				return nil, err
+			}
+			it.cur = sub
+		}
+		ob, err := it.cur.Next()
+		if err == io.EOF {
+			it.cur.Close()
+			it.cur = nil
+			continue
+		} else if err != nil {
+			return nil, err
+		}
+		return ob, nil
+	}
+}
+
+func (it *lazyPackfilesIter) ForEach(cb func(plumbing.EncodedObject) error) error {
+	return storer.ForEachIterator(it, cb)
+}
+
+func (it *lazyPackfilesIter) Close() {
+	if it.cur != nil {
+		it.cur.Close()
+		it.cur = nil
+	}
+	it.hashes = nil
+}
+
+type packfileIter struct {
+	pack billy.File
+	iter storer.EncodedObjectIter
+	seen map[plumbing.Hash]struct{}
+
+	// tells whether the pack file should be left open after iteration or not
+	keepPack bool
+}
+
+// NewPackfileIter returns a new EncodedObjectIter for the provided packfile
+// and object type. Packfile and index file will be closed after they're
+// used. If keepPack is true the packfile won't be closed after the iteration
+// finished.
+func NewPackfileIter(
+	fs billy.Filesystem,
+	f billy.File,
+	idxFile billy.File,
+	t plumbing.ObjectType,
+	keepPack bool,
+	largeObjectThreshold int64,
+) (storer.EncodedObjectIter, error) {
+	idx := idxfile.NewMemoryIndex()
+	if err := idxfile.NewDecoder(idxFile).Decode(idx); err != nil {
+		return nil, err
+	}
+
+	if err := idxFile.Close(); err != nil {
+		return nil, err
+	}
+
+	seen := make(map[plumbing.Hash]struct{})
+	return newPackfileIter(fs, f, t, seen, idx, nil, keepPack)
+}
+
+func newPackfileIter(
+	fs billy.Filesystem,
+	f billy.File,
+	t plumbing.ObjectType,
+	seen map[plumbing.Hash]struct{},
+	index idxfile.Index,
+	cache cache.Object,
+	keepPack bool,
+) (storer.EncodedObjectIter, error) {
+	p := packfile.NewPackfile(f,
+		packfile.WithFs(fs),
+		packfile.WithCache(cache),
+		packfile.WithIdx(index),
+	)
+
+	iter, err := p.GetByType(t)
+	if err != nil {
+		return nil, err
+	}
+
+	return &packfileIter{
+		pack:     f,
+		iter:     iter,
+		seen:     seen,
+		keepPack: keepPack,
+	}, nil
+}
+
+func (iter *packfileIter) Next() (plumbing.EncodedObject, error) {
+	for {
+		obj, err := iter.iter.Next()
+		if err != nil {
+			return nil, err
+		}
+
+		if _, ok := iter.seen[obj.Hash()]; ok {
+			continue
+		}
+
+		return obj, nil
+	}
+}
+
+func (iter *packfileIter) ForEach(cb func(plumbing.EncodedObject) error) error {
+	for {
+		o, err := iter.Next()
+		if err != nil {
+			if err == io.EOF {
+				iter.Close()
+				return nil
+			}
+			return err
+		}
+
+		if err := cb(o); err != nil {
+			return err
+		}
+	}
+}
+
+func (iter *packfileIter) Close() {
+	iter.iter.Close()
+	if !iter.keepPack {
+		_ = iter.pack.Close()
+	}
+}
+
+type objectsIter struct {
+	s *ObjectStorage
+	t plumbing.ObjectType
+	h []plumbing.Hash
+}
+
+func (iter *objectsIter) Next() (plumbing.EncodedObject, error) {
+	if len(iter.h) == 0 {
+		return nil, io.EOF
+	}
+
+	obj, err := iter.s.getFromUnpacked(iter.h[0])
+	iter.h = iter.h[1:]
+
+	if err != nil {
+		return nil, err
+	}
+
+	if iter.t != plumbing.AnyObject && iter.t != obj.Type() {
+		return iter.Next()
+	}
+
+	return obj, err
+}
+
+func (iter *objectsIter) ForEach(cb func(plumbing.EncodedObject) error) error {
+	for {
+		o, err := iter.Next()
+		if err != nil {
+			if err == io.EOF {
+				return nil
+			}
+			return err
+		}
+
+		if err := cb(o); err != nil {
+			return err
+		}
+	}
+}
+
+func (iter *objectsIter) Close() {
+	iter.h = []plumbing.Hash{}
+}

storage/filesystem/storage_test.go

···
-package filesystem
+package filesystem_test
 
 import (
 	"testing"
 
 	"github.com/go-git/go-git/v5/plumbing/cache"
 	"github.com/go-git/go-git/v5/plumbing/storer"
-	"github.com/go-git/go-git/v5/storage/test"
+	"github.com/go-git/go-git/v5/storage/filesystem"
+	"github.com/stretchr/testify/assert"
 
-	"github.com/go-git/go-billy/v5"
 	"github.com/go-git/go-billy/v5/memfs"
 	"github.com/go-git/go-billy/v5/osfs"
-	"github.com/go-git/go-billy/v5/util"
-	. "gopkg.in/check.v1"
 )
 
-func Test(t *testing.T) { TestingT(t) }
-
-type StorageSuite struct {
-	test.BaseStorageSuite
-	dir string
-	fs  billy.Filesystem
-}
-
-var _ = Suite(&StorageSuite{})
-
-func (s *StorageSuite) SetUpTest(c *C) {
-	tmp, err := util.TempDir(osfs.Default, "", "go-git-filestystem-config")
-	c.Assert(err, IsNil)
-
-	s.dir = tmp
-	s.fs = osfs.New(s.dir)
-	storage := NewStorage(s.fs, cache.NewObjectLRUDefault())
-
-	setUpTest(s, c, storage)
-}
-
-func setUpTest(s *StorageSuite, c *C, storage *Storage) {
-	// ensure that right interfaces are implemented
-	var _ storer.EncodedObjectStorer = storage
-	var _ storer.IndexStorer = storage
-	var _ storer.ReferenceStorer = storage
-	var _ storer.ShallowStorer = storage
-	var _ storer.DeltaObjectStorer = storage
-	var _ storer.PackfileWriter = storage
-
-	s.BaseStorageSuite = test.NewBaseStorageSuite(storage)
-}
-
-func (s *StorageSuite) TestFilesystem(c *C) {
-	fs := memfs.New()
-	storage := NewStorage(fs, cache.NewObjectLRUDefault())
-
-	c.Assert(storage.Filesystem(), Equals, fs)
-}
+var (
+	fs  = memfs.New()
+	sto = filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
 
-func (s *StorageSuite) TestNewStorageShouldNotAddAnyContentsToDir(c *C) {
-	fis, err := s.fs.ReadDir("/")
-	c.Assert(err, IsNil)
-	c.Assert(fis, HasLen, 0)
-}
+	// Ensure interfaces are implemented.
+	_ storer.EncodedObjectStorer = sto
+	_ storer.IndexStorer         = sto
+	_ storer.ReferenceStorer     = sto
+	_ storer.ShallowStorer       = sto
+	_ storer.DeltaObjectStorer   = sto
+	_ storer.PackfileWriter      = sto
+)
 
-type StorageExclusiveSuite struct {
-	StorageSuite
+func TestFilesystem(t *testing.T) {
+	assert.Same(t, fs, sto.Filesystem())
 }
 
-var _ = Suite(&StorageExclusiveSuite{})
-
-func (s *StorageExclusiveSuite) SetUpTest(c *C) {
-	tmp, err := util.TempDir(osfs.Default, "", "go-git-filestystem-config")
-	c.Assert(err, IsNil)
-
-	s.dir = tmp
-	s.fs = osfs.New(s.dir)
+func TestNewStorageShouldNotAddAnyContentsToDir(t *testing.T) {
+	fs := osfs.New(t.TempDir())
 
-	storage := NewStorageWithOptions(
-		s.fs,
+	sto := filesystem.NewStorageWithOptions(
+		fs,
 		cache.NewObjectLRUDefault(),
-		Options{ExclusiveAccess: true})
+		filesystem.Options{ExclusiveAccess: true})
+	assert.NotNil(t, sto)
 
-	setUpTest(&s.StorageSuite, c, storage)
+	fis, err := fs.ReadDir("/")
+	assert.NoError(t, err)
+	assert.Len(t, fis, 0)
 }

storage/memory/storage.go

···
 
 import (
 	"fmt"
+	"io"
 	"time"
 
 	"github.com/go-git/go-git/v5/config"
···
 	"github.com/go-git/go-git/v5/plumbing/format/index"
 	"github.com/go-git/go-git/v5/plumbing/storer"
 	"github.com/go-git/go-git/v5/storage"
+	"github.com/go-git/go-git/v5/utils/ioutil"
 )
 
 var ErrUnsupportedObjectType = fmt.Errorf("unsupported object type")
···
 	Trees   map[plumbing.Hash]plumbing.EncodedObject
 	Blobs   map[plumbing.Hash]plumbing.EncodedObject
 	Tags    map[plumbing.Hash]plumbing.EncodedObject
+}
+
+type lazyCloser struct {
+	storage *ObjectStorage
+	obj     plumbing.EncodedObject
+	closer  io.Closer
+}
+
+func (c *lazyCloser) Close() error {
+	err := c.closer.Close()
+	if err != nil {
+		return fmt.Errorf("failed to close memory encoded object: %w", err)
+	}
+
+	_, err = c.storage.SetEncodedObject(c.obj)
+	return err
+}
+
+func (o *ObjectStorage) RawObjectWriter(typ plumbing.ObjectType, sz int64) (w io.WriteCloser, err error) {
+	obj := o.NewEncodedObject()
+	obj.SetType(typ)
+	obj.SetSize(sz)
+
+	w, err = obj.Writer()
+	if err != nil {
+		return nil, err
+	}
+
+	wc := ioutil.NewWriteCloser(w,
+		&lazyCloser{storage: o, obj: obj, closer: w},
+	)
+
+	return wc, nil
 }
 
 func (o *ObjectStorage) NewEncodedObject() plumbing.EncodedObject {

storage/memory/storage_test.go

···
-package memory
-
-import (
-	"testing"
-
-	"github.com/go-git/go-git/v5/storage/test"
-	. "gopkg.in/check.v1"
-)
-
-func Test(t *testing.T) { TestingT(t) }
-
-type StorageSuite struct {
-	test.BaseStorageSuite
-}
-
-var _ = Suite(&StorageSuite{})
-
-func (s *StorageSuite) SetUpTest(c *C) {
-	s.BaseStorageSuite = test.NewBaseStorageSuite(NewStorage())
-}

storage/test/storage_suite.go

···
-package test
-
-import (
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"io"
-
-	"github.com/go-git/go-git/v5/config"
-	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/go-git/go-git/v5/plumbing/format/index"
-	"github.com/go-git/go-git/v5/plumbing/storer"
-	"github.com/go-git/go-git/v5/storage"
-
-	fixtures "github.com/go-git/go-git-fixtures/v4"
-	. "gopkg.in/check.v1"
-)
-
-type Storer interface {
-	storer.EncodedObjectStorer
-	storer.ReferenceStorer
-	storer.ShallowStorer
-	storer.IndexStorer
-	config.ConfigStorer
-	storage.ModuleStorer
-}
-
-type TestObject struct {
-	Object plumbing.EncodedObject
-	Hash   string
-	Type   plumbing.ObjectType
-}
-
-type BaseStorageSuite struct {
-	Storer Storer
-
-	validTypes  []plumbing.ObjectType
-	testObjects map[plumbing.ObjectType]TestObject
-}
-
-func NewBaseStorageSuite(s Storer) BaseStorageSuite {
-	commit := &plumbing.MemoryObject{}
-	commit.SetType(plumbing.CommitObject)
-	tree := &plumbing.MemoryObject{}
-	tree.SetType(plumbing.TreeObject)
-	blob := &plumbing.MemoryObject{}
-	blob.SetType(plumbing.BlobObject)
-	tag := &plumbing.MemoryObject{}
-	tag.SetType(plumbing.TagObject)
-
-	return BaseStorageSuite{
-		Storer: s,
-		validTypes: []plumbing.ObjectType{
-			plumbing.CommitObject,
-			plumbing.BlobObject,
-			plumbing.TagObject,
-			plumbing.TreeObject,
-		},
-		testObjects: map[plumbing.ObjectType]TestObject{
-			plumbing.CommitObject: {commit, "dcf5b16e76cce7425d0beaef62d79a7d10fce1f5", plumbing.CommitObject},
-			plumbing.TreeObject:   {tree, "4b825dc642cb6eb9a060e54bf8d69288fbee4904", plumbing.TreeObject},
-			plumbing.BlobObject:   {blob, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", plumbing.BlobObject},
-			plumbing.TagObject:    {tag, "d994c6bb648123a17e8f70a966857c546b2a6f94", plumbing.TagObject},
-		}}
-}
-
-func (s *BaseStorageSuite) TearDownTest(c *C) {
-	fixtures.Clean()
-}
-
-func (s *BaseStorageSuite) TestSetEncodedObjectAndEncodedObject(c *C) {
-	for _, to := range s.testObjects {
-		comment := Commentf("failed for type %s", to.Type.String())
-
-		h, err := s.Storer.SetEncodedObject(to.Object)
-		c.Assert(err, IsNil)
-		c.Assert(h.String(), Equals, to.Hash, comment)
-
-		o, err := s.Storer.EncodedObject(to.Type, h)
-		c.Assert(err, IsNil)
-		c.Assert(objectEquals(o, to.Object), IsNil)
-
-		o, err = s.Storer.EncodedObject(plumbing.AnyObject, h)
-		c.Assert(err, IsNil)
-		c.Assert(objectEquals(o, to.Object), IsNil)
-
-		for _, t := range s.validTypes {
-			if t == to.Type {
-				continue
-			}
-
-			o, err = s.Storer.EncodedObject(t, h)
-			c.Assert(o, IsNil)
-			c.Assert(err, Equals, plumbing.ErrObjectNotFound)
-		}
-	}
-}
-
-func (s *BaseStorageSuite) TestSetEncodedObjectInvalid(c *C) {
-	o := s.Storer.NewEncodedObject()
-	o.SetType(plumbing.REFDeltaObject)
-
-	_, err := s.Storer.SetEncodedObject(o)
-	c.Assert(err, NotNil)
-}
-
-func (s *BaseStorageSuite) TestIterEncodedObjects(c *C) {
-	for _, o := range s.testObjects {
-		h, err := s.Storer.SetEncodedObject(o.Object)
-		c.Assert(err, IsNil)
-		c.Assert(h, Equals, o.Object.Hash())
-	}
-
-	for _, t := range s.validTypes {
-		comment := Commentf("failed for type %s)", t.String())
-		i, err := s.Storer.IterEncodedObjects(t)
-		c.Assert(err, IsNil, comment)
-
-		o, err := i.Next()
-		c.Assert(err, IsNil)
-		c.Assert(objectEquals(o, s.testObjects[t].Object), IsNil)
-
-		o, err = i.Next()
-		c.Assert(o, IsNil)
-		c.Assert(err, Equals, io.EOF, comment)
-	}
-
-	i, err := s.Storer.IterEncodedObjects(plumbing.AnyObject)
-	c.Assert(err, IsNil)
-
-	foundObjects := []plumbing.EncodedObject{}
-	i.ForEach(func(o plumbing.EncodedObject) error {
-		foundObjects = append(foundObjects, o)
-		return nil
-	})
-
-	c.Assert(foundObjects, HasLen, len(s.testObjects))
-	for _, to := range s.testObjects {
-		found := false
-		for _, o := range foundObjects {
-			if to.Object.Hash() == o.Hash() {
-				found = true
-				break
-			}
-		}
-		c.Assert(found, Equals, true, Commentf("Object of type %s not found", to.Type.String()))
-	}
-}
-
-func (s *BaseStorageSuite) TestPackfileWriter(c *C) {
-	pwr, ok := s.Storer.(storer.PackfileWriter)
-	if !ok {
-		c.Skip("not a storer.PackWriter")
-	}
-
-	pw, err := pwr.PackfileWriter()
-	c.Assert(err, IsNil)
-
-	f := fixtures.Basic().One()
-	_, err = io.Copy(pw, f.Packfile())
-	c.Assert(err, IsNil)
-
-	err = pw.Close()
-	c.Assert(err, IsNil)
-
-	iter, err := s.Storer.IterEncodedObjects(plumbing.AnyObject)
-	c.Assert(err, IsNil)
-	objects := 0
-	err = iter.ForEach(func(plumbing.EncodedObject) error {
-		objects++
-		return nil
-	})
-	c.Assert(err, IsNil)
-	c.Assert(objects, Equals, 31)
-}
-
-func (s *BaseStorageSuite) TestObjectStorerTxSetEncodedObjectAndCommit(c *C) {
-	storer, ok := s.Storer.(storer.Transactioner)
-	if !ok {
-		c.Skip("not a plumbing.ObjectStorerTx")
-	}
-
-	tx := storer.Begin()
-	for _, o := range s.testObjects {
-		h, err := tx.SetEncodedObject(o.Object)
-		c.Assert(err, IsNil)
-		c.Assert(h.String(), Equals, o.Hash)
-	}
-
-	iter, err := s.Storer.IterEncodedObjects(plumbing.AnyObject)
-	c.Assert(err, IsNil)
-	_, err = iter.Next()
-	c.Assert(err, Equals, io.EOF)
-
-	err = tx.Commit()
-	c.Assert(err, IsNil)
-
-	iter, err = s.Storer.IterEncodedObjects(plumbing.AnyObject)
-	c.Assert(err, IsNil)
-
-	var count int
-	iter.ForEach(func(o plumbing.EncodedObject) error {
-		count++
-		return nil
-	})
-
-	c.Assert(count, Equals, 4)
-}
-
-func (s *BaseStorageSuite) TestObjectStorerTxSetObjectAndGetObject(c *C) {
-	storer, ok := s.Storer.(storer.Transactioner)
-	if !ok {
-		c.Skip("not a plumbing.ObjectStorerTx")
-	}
-
-	tx := storer.Begin()
-	for _, expected := range s.testObjects {
-		h, err := tx.SetEncodedObject(expected.Object)
-		c.Assert(err, IsNil)
-		c.Assert(h.String(), Equals, expected.Hash)
-
-		o, err := tx.EncodedObject(expected.Type, plumbing.NewHash(expected.Hash))
-		c.Assert(err, IsNil)
-		c.Assert(o.Hash().String(), DeepEquals, expected.Hash)
-	}
-}
-
-func (s *BaseStorageSuite) TestObjectStorerTxGetObjectNotFound(c *C) {
-	storer, ok := s.Storer.(storer.Transactioner)
-	if !ok {
-		c.Skip("not a plumbing.ObjectStorerTx")
-	}
-
-	tx := storer.Begin()
-	o, err := tx.EncodedObject(plumbing.AnyObject, plumbing.ZeroHash)
-	c.Assert(o, IsNil)
-	c.Assert(err, Equals, plumbing.ErrObjectNotFound)
-}
-
-func (s *BaseStorageSuite) TestObjectStorerTxSetObjectAndRollback(c *C) {
-	storer, ok := s.Storer.(storer.Transactioner)
-	if !ok {
-		c.Skip("not a plumbing.ObjectStorerTx")
-	}
-
-	tx := storer.Begin()
-	for _, o := range s.testObjects {
-		h, err := tx.SetEncodedObject(o.Object)
-		c.Assert(err, IsNil)
-		c.Assert(h.String(), Equals, o.Hash)
-	}
-
-	err := tx.Rollback()
-	c.Assert(err, IsNil)
-
-	iter, err := s.Storer.IterEncodedObjects(plumbing.AnyObject)
-	c.Assert(err, IsNil)
-	_, err = iter.Next()
-	c.Assert(err, Equals, io.EOF)
-}
-
-func (s *BaseStorageSuite) TestSetReferenceAndGetReference(c *C) {
-	err := s.Storer.SetReference(
-		plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
-	)
-	c.Assert(err, IsNil)
-
-	err = s.Storer.SetReference(
-		plumbing.NewReferenceFromStrings("bar", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
-	)
-	c.Assert(err, IsNil)
-
-	e, err := s.Storer.Reference(plumbing.ReferenceName("foo"))
-	c.Assert(err, IsNil)
-	c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
-}
-
-func (s *BaseStorageSuite) TestCheckAndSetReference(c *C) {
-	err := s.Storer.SetReference(
-		plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
-	)
-	c.Assert(err, IsNil)
-
-	err = s.Storer.CheckAndSetReference(
-		plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
-		plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
-	)
-	c.Assert(err, IsNil)
-
-	e, err := s.Storer.Reference(plumbing.ReferenceName("foo"))
-	c.Assert(err, IsNil)
-	c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
-}
-
-func (s *BaseStorageSuite) TestCheckAndSetReferenceNil(c *C) {
-	err := s.Storer.SetReference(
-		plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
-	)
-	c.Assert(err, IsNil)
-
-	err = s.Storer.CheckAndSetReference(
-		plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
-		nil,
-	)
-	c.Assert(err, IsNil)
-
-	e, err := s.Storer.Reference(plumbing.ReferenceName("foo"))
-	c.Assert(err, IsNil)
-	c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
-}
-
-func (s *BaseStorageSuite) TestCheckAndSetReferenceError(c *C) {
-	err := s.Storer.SetReference(
-		plumbing.NewReferenceFromStrings("foo", "c3f4688a08fd86f1bf8e055724c84b7a40a09733"),
-	)
-	c.Assert(err, IsNil)
-
-	err = s.Storer.CheckAndSetReference(
-		plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
-		plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
-	)
-	c.Assert(err, Equals, storage.ErrReferenceHasChanged)
-
-	e, err := s.Storer.Reference(plumbing.ReferenceName("foo"))
-	c.Assert(err, IsNil)
-	c.Assert(e.Hash().String(), Equals, "c3f4688a08fd86f1bf8e055724c84b7a40a09733")
-}
-
-func (s *BaseStorageSuite) TestRemoveReference(c *C) {
-	err := s.Storer.SetReference(
-		plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
-	)
-	c.Assert(err, IsNil)
-
-	err = s.Storer.RemoveReference(plumbing.ReferenceName("foo"))
-	c.Assert(err, IsNil)
-
-	_, err = s.Storer.Reference(plumbing.ReferenceName("foo"))
-	c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
-}
-
-func (s *BaseStorageSuite) TestRemoveReferenceNonExistent(c *C) {
-	err := s.Storer.SetReference(
-		plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
-	)
-	c.Assert(err, IsNil)
-
-	err = s.Storer.RemoveReference(plumbing.ReferenceName("nonexistent"))
-	c.Assert(err, IsNil)
-
-	e, err := s.Storer.Reference(plumbing.ReferenceName("foo"))
-	c.Assert(err, IsNil)
-	c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
-}
-
-func (s *BaseStorageSuite) TestGetReferenceNotFound(c *C) {
-	r, err := s.Storer.Reference(plumbing.ReferenceName("bar"))
-	c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
-	c.Assert(r, IsNil)
-}
-
-func (s *BaseStorageSuite) TestIterReferences(c *C) {
-	err := s.Storer.SetReference(
-		plumbing.NewReferenceFromStrings("refs/foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
-	)
-	c.Assert(err, IsNil)
-
-	i, err := s.Storer.IterReferences()
-	c.Assert(err, IsNil)
-
-	e, err := i.Next()
-	c.Assert(err, IsNil)
-	c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
-
-	e, err = i.Next()
-	c.Assert(e, IsNil)
-	c.Assert(err, Equals, io.EOF)
-}
-
-func (s *BaseStorageSuite) TestSetShallowAndShallow(c *C) {
-	expected := []plumbing.Hash{
-		plumbing.NewHash("b66c08ba28aa1f81eb06a1127aa3936ff77e5e2c"),
-		plumbing.NewHash("c3f4688a08fd86f1bf8e055724c84b7a40a09733"),
-		plumbing.NewHash("c78874f116be67ecf54df225a613162b84cc6ebf"),
-	}
-
-	err := s.Storer.SetShallow(expected)
-	c.Assert(err, IsNil)
-
-	result, err := s.Storer.Shallow()
-	c.Assert(err, IsNil)
-	c.Assert(result, DeepEquals, expected)
-}
-
-func (s *BaseStorageSuite) TestSetConfigAndConfig(c *C) {
-	expected := config.NewConfig()
-	expected.Core.IsBare = true
-	expected.Remotes["foo"] = &config.RemoteConfig{
-		Name: "foo",
-		URLs: []string{"http://foo/bar.git"},
-	}
-
-	err := s.Storer.SetConfig(expected)
-	c.Assert(err, IsNil)
-
-	cfg, err := s.Storer.Config()
-	c.Assert(err, IsNil)
-
-	c.Assert(cfg.Core.IsBare, DeepEquals, expected.Core.IsBare)
-	c.Assert(cfg.Remotes, DeepEquals, expected.Remotes)
-}
-
-func (s *BaseStorageSuite) TestIndex(c *C) {
-	expected := &index.Index{}
-	expected.Version = 2
-
-	idx, err := s.Storer.Index()
-	c.Assert(err, IsNil)
-	c.Assert(idx, DeepEquals, expected)
-}
-
-func (s *BaseStorageSuite) TestSetIndexAndIndex(c *C) {
-	expected := &index.Index{}
-	expected.Version = 2
-
-	err := s.Storer.SetIndex(expected)
-	c.Assert(err, IsNil)
-
-	idx, err := s.Storer.Index()
-	c.Assert(err, IsNil)
-	c.Assert(idx, DeepEquals, expected)
-}
-
-func (s *BaseStorageSuite) TestSetConfigInvalid(c *C) {
-	cfg := config.NewConfig()
-	cfg.Remotes["foo"] = &config.RemoteConfig{}
-
-	err := s.Storer.SetConfig(cfg)
-	c.Assert(err, NotNil)
-}
-
-func (s *BaseStorageSuite) TestModule(c *C) {
-	storer, err := s.Storer.Module("foo")
-	c.Assert(err, IsNil)
-	c.Assert(storer, NotNil)
-
-	storer, err = s.Storer.Module("foo")
-	c.Assert(err, IsNil)
-	c.Assert(storer, NotNil)
-}
-
-func (s *BaseStorageSuite) TestDeltaObjectStorer(c *C) {
-	dos, ok := s.Storer.(storer.DeltaObjectStorer)
-	if !ok {
-		c.Skip("not an DeltaObjectStorer")
-	}
-
-	pwr, ok := s.Storer.(storer.PackfileWriter)
-	if !ok {
-		c.Skip("not a storer.PackWriter")
-	}
-
-	pw, err := pwr.PackfileWriter()
-	c.Assert(err, IsNil)
-
-	f := fixtures.Basic().One()
-	_, err = io.Copy(pw, f.Packfile())
-	c.Assert(err, IsNil)
-
-	err = pw.Close()
-	c.Assert(err, IsNil)
-
-	h := plumbing.NewHash("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88")
-	obj, err := dos.DeltaObject(plumbing.AnyObject, h)
-	c.Assert(err, IsNil)
-	c.Assert(obj.Type(), Equals, plumbing.BlobObject)
-
-	h = plumbing.NewHash("aa9b383c260e1d05fbbf6b30a02914555e20c725")
-	obj, err = dos.DeltaObject(plumbing.AnyObject, h)
-	c.Assert(err, IsNil)
-	c.Assert(obj.Type(), Equals, plumbing.OFSDeltaObject)
-	_, ok = obj.(plumbing.DeltaObject)
-	c.Assert(ok, Equals, true)
-}
-
-func objectEquals(a plumbing.EncodedObject, b plumbing.EncodedObject) error {
-	ha := a.Hash()
-	hb := b.Hash()
-	if ha != hb {
-		return fmt.Errorf("hashes do not match: %s != %s",
-			ha.String(), hb.String())
-	}
-
-	ra, err := a.Reader()
-	if err != nil {
-		return fmt.Errorf("can't get reader on a: %q", err)
-	}
-
-	rb, err := b.Reader()
-	if err != nil {
-		return fmt.Errorf("can't get reader on b: %q", err)
-	}
-
-	ca, err := io.ReadAll(ra)
-	if err != nil {
-		return fmt.Errorf("error reading a: %q", err)
-	}
-
-	cb, err := io.ReadAll(rb)
-	if err != nil {
-		return fmt.Errorf("error reading b: %q", err)
-	}
-
-	if hex.EncodeToString(ca) != hex.EncodeToString(cb) {
-		return errors.New("content does not match")
-	}
-
-	err = rb.Close()
-	if err != nil {
-		return fmt.Errorf("can't close reader on b: %q", err)
-	}
-
-	err = ra.Close()
-	if err != nil {
-		return fmt.Errorf("can't close reader on a: %q", err)
-	}
-
-	return nil
-}

storage/tests/storage_test.go

···
+package tests
+
+import (
+	"fmt"
+	"io"
+	"testing"
+
+	"github.com/go-git/go-billy/v5/memfs"
+	"github.com/go-git/go-billy/v5/osfs"
+	fixtures "github.com/go-git/go-git-fixtures/v5"
+	"github.com/go-git/go-git/v5/config"
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/go-git/go-git/v5/plumbing/cache"
+	"github.com/go-git/go-git/v5/plumbing/format/index"
+	"github.com/go-git/go-git/v5/plumbing/storer"
+	"github.com/go-git/go-git/v5/storage"
+	"github.com/go-git/go-git/v5/storage/filesystem"
+	"github.com/go-git/go-git/v5/storage/memory"
+	"github.com/go-git/go-git/v5/storage/transactional"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type Storer interface {
+	storer.EncodedObjectStorer
+	storer.ReferenceStorer
+	storer.ShallowStorer
+	storer.IndexStorer
+	config.ConfigStorer
+	storage.ModuleStorer
+}
+
+type TestObject struct {
+	Object plumbing.EncodedObject
+	Hash   string
+	Type   plumbing.ObjectType
+}
+
+func testObjects() map[plumbing.ObjectType]TestObject {
+	commit := &plumbing.MemoryObject{}
+	commit.SetType(plumbing.CommitObject)
+	tree := &plumbing.MemoryObject{}
+	tree.SetType(plumbing.TreeObject)
+	blob := &plumbing.MemoryObject{}
+	blob.SetType(plumbing.BlobObject)
+	tag := &plumbing.MemoryObject{}
+	tag.SetType(plumbing.TagObject)
+
+	return map[plumbing.ObjectType]TestObject{
+		plumbing.CommitObject: {commit, "dcf5b16e76cce7425d0beaef62d79a7d10fce1f5", plumbing.CommitObject},
+		plumbing.TreeObject:   {tree, "4b825dc642cb6eb9a060e54bf8d69288fbee4904", plumbing.TreeObject},
+		plumbing.BlobObject:   {blob, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", plumbing.BlobObject},
+		plumbing.TagObject:    {tag, "d994c6bb648123a17e8f70a966857c546b2a6f94", plumbing.TagObject},
+	}
+}
+
+func validTypes() []plumbing.ObjectType {
+	return []plumbing.ObjectType{
+		plumbing.CommitObject,
+		plumbing.BlobObject,
+		plumbing.TagObject,
+		plumbing.TreeObject,
+	}
+}
+
+var storageFactories = []func(t *testing.T) (Storer, string){
+	func(_ *testing.T) (Storer, string) { return memory.NewStorage(), "memory" },
+	func(t *testing.T) (Storer, string) {
+		return filesystem.NewStorage(osfs.New(t.TempDir()), nil), "filesystem"
+	},
+	func(t *testing.T) (Storer, string) {
+		temporal := filesystem.NewStorage(memfs.New(), cache.NewObjectLRUDefault())
+		base := memory.NewStorage()
+
+		return transactional.NewStorage(base, temporal), "transactional"
+	},
+}
+
+func forEachStorage(t *testing.T, tc func(sto Storer, t *testing.T)) {
+	for _, factory := range storageFactories {
+		sto, name := factory(t)
+
+		t.Run(name, func(t *testing.T) {
+			tc(sto, t)
+		})
+	}
+}
+
+func TestPackfileWriter(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		pwr, ok := sto.(storer.PackfileWriter)
+		if !ok {
+			t.Skip("not a PackfileWriter")
+		}
+
+		pw, err := pwr.PackfileWriter()
+		assert.NoError(t, err)
+
+		f := fixtures.Basic().One()
+		_, err = io.Copy(pw, f.Packfile())
+		assert.NoError(t, err)
+
+		err = pw.Close()
+		assert.NoError(t, err)
+
+		iter, err := sto.IterEncodedObjects(plumbing.AnyObject)
+		assert.NoError(t, err)
+		objects := 0
+
+		err = iter.ForEach(func(plumbing.EncodedObject) error {
+			objects++
+			return nil
+		})
+
+		assert.NoError(t, err)
+		assert.Equal(t, 31, objects)
+	})
+}
+
+func TestDeltaObjectStorer(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		dos, ok := sto.(storer.DeltaObjectStorer)
+		if !ok {
+			t.Skip("not an DeltaObjectStorer")
+		}
+
+		pwr, ok := sto.(storer.PackfileWriter)
+		if !ok {
+			t.Skip("not a storer.PackWriter")
+		}
+
+		pw, err := pwr.PackfileWriter()
+		require.NoError(t, err)
+
+		f := fixtures.Basic().One()
+		_, err = io.Copy(pw, f.Packfile())
+		require.NoError(t, err)
+
+		err = pw.Close()
+		require.NoError(t, err)
+
+		h := plumbing.NewHash("32858aad3c383ed1ff0a0f9bdf231d54a00c9e88")
+		obj, err := dos.DeltaObject(plumbing.AnyObject, h)
+		require.NoError(t, err)
+		assert.Equal(t, plumbing.BlobObject, obj.Type())
+
+		h = plumbing.NewHash("aa9b383c260e1d05fbbf6b30a02914555e20c725")
+		obj, err = dos.DeltaObject(plumbing.AnyObject, h)
+		require.NoError(t, err)
+		assert.Equal(t, plumbing.OFSDeltaObject.String(), obj.Type().String())
+
+		_, ok = obj.(plumbing.DeltaObject)
+		assert.True(t, ok)
+	})
+}
+
+func TestSetEncodedObjectAndEncodedObject(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		for _, to := range testObjects() {
+			comment := fmt.Sprintf("failed for type %s", to.Type.String())
+
+			h, err := sto.SetEncodedObject(to.Object)
+			require.NoError(t, err)
+			require.Equal(t, to.Hash, h.String(), comment)
+
+			o, err := sto.EncodedObject(to.Type, h)
+			require.NoError(t, err)
+			assert.Equal(t, to.Object, o)
+
+			o, err = sto.EncodedObject(plumbing.AnyObject, h)
+			require.NoError(t, err)
+			assert.Equal(t, to.Object, o)
+
+			for _, typ := range validTypes() {
+				if typ == to.Type {
+					continue
+				}
+
+				o, err = sto.EncodedObject(typ, h)
+				assert.Nil(t, o)
+				assert.ErrorIs(t, err, plumbing.ErrObjectNotFound)
+			}
+		}
+	})
+}
+
+func TestSetEncodedObjectInvalid(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		o := sto.NewEncodedObject()
+		o.SetType(plumbing.REFDeltaObject)
+
+		_, err := sto.SetEncodedObject(o)
+		assert.Error(t, err)
+	})
+}
+
+func TestIterEncodedObjects(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		objs := testObjects()
+		for _, o := range objs {
+			h, err := sto.SetEncodedObject(o.Object)
+			require.NoError(t, err)
+			assert.Equal(t, o.Object.Hash(), h)
+		}
+
+		for _, typ := range validTypes() {
+			comment := fmt.Sprintf("failed for type %s)", typ.String())
+			i, err := sto.IterEncodedObjects(typ)
+			require.NoError(t, err, comment)
+
+			o, err := i.Next()
+			require.NoError(t, err)
+			assert.Equal(t, objs[typ].Object, o)
+
+			o, err = i.Next()
+			assert.Nil(t, o)
+			assert.ErrorIs(t, err, io.EOF, comment)
+		}
+
+		i, err := sto.IterEncodedObjects(plumbing.AnyObject)
+		require.NoError(t, err)
+
+		foundObjects := []plumbing.EncodedObject{}
+		i.ForEach(func(o plumbing.EncodedObject) error {
+			foundObjects = append(foundObjects, o)
+			return nil
+		})
+
+		assert.Len(t, foundObjects, len(testObjects()))
+		for _, to := range testObjects() {
+			found := false
+			for _, o := range foundObjects {
+				if to.Object.Hash() == o.Hash() {
+					found = true
+					break
+				}
+			}
+			assert.True(t, found, "Object of type %s not found", to.Type.String())
+		}
+	})
+}
+
+func TestObjectStorerTxSetEncodedObjectAndCommit(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		storer, ok := sto.(storer.Transactioner)
+		if !ok {
+			t.Skip("not a plumbing.ObjectStorerTx")
+		}
+
+		tx := storer.Begin()
+		for _, o := range testObjects() {
+			h, err := tx.SetEncodedObject(o.Object)
+			require.NoError(t, err)
+			assert.Equal(t, o.Hash, h.String())
+		}
+
+		iter, err := sto.IterEncodedObjects(plumbing.AnyObject)
+		require.NoError(t, err)
+		_, err = iter.Next()
+		assert.ErrorIs(t, err, io.EOF)
+
+		err = tx.Commit()
+		require.NoError(t, err)
+
+		iter, err = sto.IterEncodedObjects(plumbing.AnyObject)
+		require.NoError(t, err)
+
+		var count int
+		iter.ForEach(func(o plumbing.EncodedObject) error {
+			count++
+			return nil
+		})
+
+		assert.Equal(t, 4, count)
+	})
+}
+
+func TestObjectStorerTxSetObjectAndGetObject(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		storer, ok := sto.(storer.Transactioner)
+		if !ok {
+			t.Skip("not a plumbing.ObjectStorerTx")
+		}
+
+		tx := storer.Begin()
+		for _, expected := range testObjects() {
+			h, err := tx.SetEncodedObject(expected.Object)
+			require.NoError(t, err)
+			assert.Equal(t, expected.Hash, h.String())
+
+			o, err := tx.EncodedObject(expected.Type, plumbing.NewHash(expected.Hash))
+			require.NoError(t, err)
+			assert.Equal(t, expected.Hash, o.Hash().String())
+		}
+	})
+}
+
+func TestObjectStorerTxGetObjectNotFound(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		storer, ok := sto.(storer.Transactioner)
+		if !ok {
+			t.Skip("not a plumbing.ObjectStorerTx")
+		}
+
+		tx := storer.Begin()
+		o, err := tx.EncodedObject(plumbing.AnyObject, plumbing.ZeroHash)
+		assert.Nil(t, o)
+		assert.ErrorIs(t, err, plumbing.ErrObjectNotFound)
+	})
+}
+
+func TestObjectStorerTxSetObjectAndRollback(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		storer, ok := sto.(storer.Transactioner)
+		if !ok {
+			t.Skip("not a plumbing.ObjectStorerTx")
+		}
+
+		tx := storer.Begin()
+		for _, o := range testObjects() {
+			h, err := tx.SetEncodedObject(o.Object)
+			require.NoError(t, err)
+			assert.Equal(t, o.Hash, h.String())
+		}
+
+		err := tx.Rollback()
+		require.NoError(t, err)
+
+		iter, err := sto.IterEncodedObjects(plumbing.AnyObject)
+		require.NoError(t, err)
+		_, err = iter.Next()
+		assert.ErrorIs(t, err, io.EOF)
+	})
+}
+
+func TestSetReferenceAndGetReference(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		err := sto.SetReference(
+			plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
+		)
+		require.NoError(t, err)
+
+		err = sto.SetReference(
+			plumbing.NewReferenceFromStrings("bar", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
+		)
+		require.NoError(t, err)
+
+		e, err := sto.Reference(plumbing.ReferenceName("foo"))
+		require.NoError(t, err)
+		assert.Equal(t, e.Hash().String(), "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
+	})
+}
+
+func TestCheckAndSetReference(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		err := sto.SetReference(
+			plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
+		)
+		require.NoError(t, err)
+
+		err = sto.CheckAndSetReference(
+			plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
+			plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
+		)
+		require.NoError(t, err)
+
+		e, err := sto.Reference(plumbing.ReferenceName("foo"))
+		require.NoError(t, err)
+		assert.Equal(t, e.Hash().String(), "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
+	})
+}
+
+func TestCheckAndSetReferenceNil(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		err := sto.SetReference(
+			plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
+		)
+		require.NoError(t, err)
+
+		err = sto.CheckAndSetReference(
+			plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
+			nil,
+		)
+		require.NoError(t, err)
+
+		e, err := sto.Reference(plumbing.ReferenceName("foo"))
+		require.NoError(t, err)
+		assert.Equal(t, e.Hash().String(), "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
+	})
+}
+
+func TestCheckAndSetReferenceError(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		err := sto.SetReference(
+			plumbing.NewReferenceFromStrings("foo", "c3f4688a08fd86f1bf8e055724c84b7a40a09733"),
+		)
+		require.NoError(t, err)
+
+		err = sto.CheckAndSetReference(
+			plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
+			plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
+		)
+		assert.ErrorIs(t, err, storage.ErrReferenceHasChanged)
+
+		e, err := sto.Reference(plumbing.ReferenceName("foo"))
+		require.NoError(t, err)
+		assert.Equal(t, e.Hash().String(), "c3f4688a08fd86f1bf8e055724c84b7a40a09733")
+	})
+}
+
+func TestRemoveReference(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		err := sto.SetReference(
+			plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
+		)
+		require.NoError(t, err)
+
+		err = sto.RemoveReference(plumbing.ReferenceName("foo"))
+		require.NoError(t, err)
+
+		_, err = sto.Reference(plumbing.ReferenceName("foo"))
+		assert.ErrorIs(t, err, plumbing.ErrReferenceNotFound)
+	})
+}
+
+func TestRemoveReferenceNonExistent(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		err := sto.SetReference(
+			plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
+		)
+		require.NoError(t, err)
+
+		err = sto.RemoveReference(plumbing.ReferenceName("nonexistent"))
+		require.NoError(t, err)
+
+		e, err := sto.Reference(plumbing.ReferenceName("foo"))
+		require.NoError(t, err)
+		assert.Equal(t, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52", e.Hash().String())
+	})
+}
+
+func TestGetReferenceNotFound(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		r, err := sto.Reference(plumbing.ReferenceName("bar"))
+		assert.ErrorIs(t, err, plumbing.ErrReferenceNotFound)
+		assert.Nil(t, r)
+	})
+}
+
+func TestIterReferences(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		err := sto.SetReference(
+			plumbing.NewReferenceFromStrings("refs/foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
+		)
+		require.NoError(t, err)
+
+		i, err := sto.IterReferences()
+		require.NoError(t, err)
+
+		e, err := i.Next()
+		require.NoError(t, err)
+		assert.Equal(t, e.Hash().String(), "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
+
+		e, err = i.Next()
+		assert.Nil(t, e)
+		assert.ErrorIs(t, err, io.EOF)
+	})
+}
+
+func TestSetShallowAndShallow(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		expected := []plumbing.Hash{
+			plumbing.NewHash("b66c08ba28aa1f81eb06a1127aa3936ff77e5e2c"),
+			plumbing.NewHash("c3f4688a08fd86f1bf8e055724c84b7a40a09733"),
+			plumbing.NewHash("c78874f116be67ecf54df225a613162b84cc6ebf"),
+		}
+
+		err := sto.SetShallow(expected)
+		require.NoError(t, err)
+
+		result, err := sto.Shallow()
+		require.NoError(t, err)
+		assert.Equal(t, expected, result)
+	})
+}
+
+func TestSetConfigAndConfig(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		expected := config.NewConfig()
+		expected.Core.IsBare = true
+		expected.Remotes["foo"] = &config.RemoteConfig{
+			Name: "foo",
+			URLs: []string{"http://foo/bar.git"},
+		}
+
+		err := sto.SetConfig(expected)
+		require.NoError(t, err)
+
+		cfg, err := sto.Config()
+		require.NoError(t, err)
+
+		assert.Equal(t, expected.Core.IsBare, cfg.Core.IsBare)
+		assert.Equal(t, expected.Remotes, cfg.Remotes)
+	})
+}
+
+func TestIndex(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		expected := &index.Index{}
+		expected.Version = 2
+
+		idx, err := sto.Index()
+		assert.NoError(t, err)
+		assert.Equal(t, expected, idx)
+	})
+}
+
+func TestSetIndexAndIndex(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		expected := &index.Index{}
+		expected.Version = 2
+
+		err := sto.SetIndex(expected)
+		require.NoError(t, err)
+
+		idx, err := sto.Index()
+		require.NoError(t, err)
+		assert.Equal(t, expected, idx)
+	})
+}
+
+func TestSetConfigInvalid(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		cfg := config.NewConfig()
+		cfg.Remotes["foo"] = &config.RemoteConfig{}
+
+		err := sto.SetConfig(cfg)
+		assert.Error(t, err)
+	})
+}
+
+func TestModule(t *testing.T) {
+	t.Parallel()
+
+	forEachStorage(t, func(sto Storer, t *testing.T) {
+		storer, err := sto.Module("foo")
+		require.NoError(t, err)
+		assert.NotNil(t, storer)
+
+		storer, err = sto.Module("foo")
+		require.NoError(t, err)
+		assert.NotNil(t, storer)
+	})
+}

storage/transactional/storage_test.go

···
 	"github.com/go-git/go-git/v5/storage"
 	"github.com/go-git/go-git/v5/storage/filesystem"
 	"github.com/go-git/go-git/v5/storage/memory"
-	"github.com/go-git/go-git/v5/storage/test"
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
-func Test(t *testing.T) { TestingT(t) }
-
-type StorageSuite struct {
-	test.BaseStorageSuite
-	temporal func() storage.Storer
-}
-
-var _ = Suite(&StorageSuite{
-	temporal: func() storage.Storer {
-		return memory.NewStorage()
-	},
-})
-
-var _ = Suite(&StorageSuite{
-	temporal: func() storage.Storer {
-		fs := memfs.New()
-		return filesystem.NewStorage(fs, cache.NewObjectLRUDefault())
-	},
-})
-
-func (s *StorageSuite) SetUpTest(c *C) {
-	base := memory.NewStorage()
-	temporal := s.temporal()
-
-	s.BaseStorageSuite = test.NewBaseStorageSuite(NewStorage(base, temporal))
-}
-
-func (s *StorageSuite) TestCommit(c *C) {
+func TestCommit(t *testing.T) {
 	base := memory.NewStorage()
-	temporal := s.temporal()
+	temporal := filesystem.NewStorage(memfs.New(), cache.NewObjectLRUDefault())
 	st := NewStorage(base, temporal)
 
 	commit := base.NewEncodedObject()
 	commit.SetType(plumbing.CommitObject)
 
 	_, err := st.SetEncodedObject(commit)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	ref := plumbing.NewHashReference("refs/a", commit.Hash())
-	c.Assert(st.SetReference(ref), IsNil)
+	require.NoError(t, st.SetReference(ref))
 
 	err = st.Commit()
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	ref, err = base.Reference(ref.Name())
-	c.Assert(err, IsNil)
-	c.Assert(ref.Hash(), Equals, commit.Hash())
+	require.NoError(t, err)
+	assert.Equal(t, commit.Hash(), ref.Hash())
 
 	obj, err := base.EncodedObject(plumbing.AnyObject, commit.Hash())
-	c.Assert(err, IsNil)
-	c.Assert(obj.Hash(), Equals, commit.Hash())
+	require.NoError(t, err)
+	assert.Equal(t, commit.Hash(), obj.Hash())
 }
 
-func (s *StorageSuite) TestTransactionalPackfileWriter(c *C) {
+func TestTransactionalPackfileWriter(t *testing.T) {
 	base := memory.NewStorage()
-	temporal := s.temporal()
+	var temporal storage.Storer
+
+	temporal = filesystem.NewStorage(memfs.New(), cache.NewObjectLRUDefault())
+
 	st := NewStorage(base, temporal)
 
 	_, tmpOK := temporal.(storer.PackfileWriter)
 	_, ok := st.(storer.PackfileWriter)
-	c.Assert(ok, Equals, tmpOK)
+	assert.Equal(t, tmpOK, ok)
 }

utils/ioutil/common.go

···
 }
 
 func (r *writeCloser) Close() error {
+	if r.closer == nil {
+		return nil
+	}
 	return r.closer.Close()
 }
 

utils/sync/zlib.go

···
 	zlibInitBytes = []byte{0x78, 0x9c, 0x01, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01}
 	zlibReader    = sync.Pool{
 		New: func() interface{} {
-			r, _ := zlib.NewReader(bytes.NewReader(zlibInitBytes))
-			return ZLibReader{
-				Reader: r.(zlibReadCloser),
-			}
+			return NewZlibReader(nil)
 		},
 	}
 	zlibWriter = sync.Pool{
···
 	zlib.Resetter
 }
 
+func NewZlibReader(dict *[]byte) ZLibReader {
+	r, _ := zlib.NewReader(bytes.NewReader(zlibInitBytes))
+	return ZLibReader{
+		Reader: r.(zlibReadCloser),
+		dict:   dict,
+	}
+}
+
 type ZLibReader struct {
 	dict   *[]byte
 	Reader zlibReadCloser
+}
+
+func (z ZLibReader) Reset(r io.Reader) error {
+	var dict []byte
+	if z.dict != nil {
+		dict = *z.dict
+	}
+	return z.Reader.Reset(r, dict)
 }
 
 // GetZlibReader returns a ZLibReader that is managed by a sync.Pool.

worktree_commit_test.go

···
 	"path/filepath"
 	"runtime"
 	"strings"
+	"testing"
 	"time"
 
+	fixtures "github.com/go-git/go-git-fixtures/v4"
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/cache"
 	"github.com/go-git/go-git/v5/plumbing/object"
 	"github.com/go-git/go-git/v5/plumbing/storer"
 	"github.com/go-git/go-git/v5/storage/filesystem"
 	"github.com/go-git/go-git/v5/storage/memory"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"github.com/ProtonMail/go-crypto/openpgp"
 	"github.com/ProtonMail/go-crypto/openpgp/armor"
···
 	c.Assert(amendedHash, Equals, plumbing.ZeroHash)
 }
 
-func (s *WorktreeSuite) TestAddAndCommitWithSkipStatus(c *C) {
+func TestCount(t *testing.T) {
+	f := fixtures.Basic().One()
+	r := NewRepositoryWithEmptyWorktree(f)
+
+	iter, err := r.CommitObjects()
+	require.NoError(t, err)
+
+	count := 0
+	iter.ForEach(func(c *object.Commit) error {
+		count++
+		return nil
+	})
+	assert.Equal(t, 9, count, "commits mismatch")
+
+	trees, err := r.TreeObjects()
+	require.NoError(t, err)
+
+	count = 0
+	trees.ForEach(func(c *object.Tree) error {
+		count++
+		return nil
+	})
+	assert.Equal(t, 12, count, "trees mismatch")
+
+	blobs, err := r.BlobObjects()
+	require.NoError(t, err)
+
+	count = 0
+	blobs.ForEach(func(c *object.Blob) error {
+		count++
+		return nil
+	})
+	assert.Equal(t, 10, count, "blobs mismatch")
+
+	objects, err := r.Objects()
+	require.NoError(t, err)
+
+	count = 0
+	objects.ForEach(func(c object.Object) error {
+		count++
+		return nil
+	})
+	assert.Equal(t, 31, count, "objects mismatch")
+}
+
+func TestAddAndCommitWithSkipStatus(t *testing.T) {
 	expected := plumbing.NewHash("375a3808ffde7f129cdd3c8c252fd0fe37cfd13b")
 
+	f := fixtures.Basic().One()
 	fs := memfs.New()
+	r := NewRepositoryWithEmptyWorktree(f)
 	w := &Worktree{
-		r:          s.Repository,
+		r:          r,
 		Filesystem: fs,
 	}
 
 	err := w.Checkout(&CheckoutOptions{})
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	util.WriteFile(fs, "LICENSE", []byte("foo"), 0644)
 	util.WriteFile(fs, "foo", []byte("foo"), 0644)
···
 		Path:       "foo",
 		SkipStatus: true,
 	})
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	hash, err := w.Commit("commit foo only\n", &CommitOptions{
 		Author: defaultSignature(),
 	})
 
-	c.Assert(hash, Equals, expected)
-	c.Assert(err, IsNil)
+	assert.Equal(t, expected.String(), hash.String())
+	require.NoError(t, err)
 
-	assertStorageStatus(c, s.Repository, 13, 11, 10, expected)
+	assertStorage(t, r, 13, 11, 10, expected)
+}
+
+func assertStorage(
+	t *testing.T, r *Repository,
+	treesCount, blobCount, commitCount int, head plumbing.Hash,
+) {
+	trees, err := r.Storer.IterEncodedObjects(plumbing.TreeObject)
+	require.NoError(t, err)
+	blobs, err := r.Storer.IterEncodedObjects(plumbing.BlobObject)
+	require.NoError(t, err)
+	commits, err := r.Storer.IterEncodedObjects(plumbing.CommitObject)
+	require.NoError(t, err)
+
+	assert.Equal(t, treesCount, lenIterEncodedObjects(trees), "trees count mismatch")
+	assert.Equal(t, blobCount, lenIterEncodedObjects(blobs), "blobs count mismatch")
+	assert.Equal(t, commitCount, lenIterEncodedObjects(commits), "commits count mismatch")
+
+	ref, err := r.Head()
+	require.NoError(t, err)
+	assert.Equal(t, head.String(), ref.Hash().String())
 }
 
 func (s *WorktreeSuite) TestAddAndCommitWithSkipStatusPathNotModified(c *C) {

worktree_test.go

···
 
 func (s *WorktreeSuite) SetUpTest(c *C) {
 	f := fixtures.Basic().One()
-	s.Repository = s.NewRepositoryWithEmptyWorktree(f)
+	s.Repository = NewRepositoryWithEmptyWorktree(f)
 }
 
 func (s *WorktreeSuite) TestPullCheckout(c *C) {
···
 
 func (s *WorktreeSuite) TestCheckoutSubmodule(c *C) {
 	url := "https://github.com/git-fixtures/submodule.git"
-	r := s.NewRepositoryWithEmptyWorktree(fixtures.ByURL(url).One())
+	r := NewRepositoryWithEmptyWorktree(fixtures.ByURL(url).One())
 
 	w, err := r.Worktree()
 	c.Assert(err, IsNil)
···
 
 func (s *WorktreeSuite) TestCheckoutTag(c *C) {
 	f := fixtures.ByTag("tags").One()
-	r := s.NewRepositoryWithEmptyWorktree(f)
+	r := NewRepositoryWithEmptyWorktree(f)
 	w, err := r.Worktree()
 	c.Assert(err, IsNil)
 
···
 
 func (s *WorktreeSuite) TestCheckoutTagHash(c *C) {
 	f := fixtures.ByTag("tags").One()
-	r := s.NewRepositoryWithEmptyWorktree(f)
+	r := NewRepositoryWithEmptyWorktree(f)
 	w, err := r.Worktree()
 	c.Assert(err, IsNil)
 
···
 // checking every commit over the previous commit
 func (s *WorktreeSuite) testCheckoutBisect(c *C, url string) {
 	f := fixtures.ByURL(url).One()
-	r := s.NewRepositoryWithEmptyWorktree(f)
+	r := NewRepositoryWithEmptyWorktree(f)
 
 	w, err := r.Worktree()
 	c.Assert(err, IsNil)