Merge pull request #1382 from BeChris/plumbing-format-packfile-gocheck-to-testify-migration

plumbing: format/packfile, gocheck to testify migration. Fixes #1294

plumbing/format/packfile/delta_selector_test.go

···
 package packfile
 
 import (
+	"testing"
+
 	"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/suite"
 )
 
 type DeltaSelectorSuite struct {
+	suite.Suite
 	ds     *deltaSelector
 	store  *memory.Storage
 	hashes map[string]plumbing.Hash
 }
 
-var _ = Suite(&DeltaSelectorSuite{})
+func TestDeltaSelectorSuite(t *testing.T) {
+	suite.Run(t, new(DeltaSelectorSuite))
+}
 
-func (s *DeltaSelectorSuite) SetUpTest(c *C) {
+func (s *DeltaSelectorSuite) SetupTest() {
 	s.store = memory.NewStorage()
 	s.createTestObjects()
 	s.ds = newDeltaSelector(s.store)
 }
 
-func (s *DeltaSelectorSuite) TestSort(c *C) {
+func (s *DeltaSelectorSuite) TestSort() {
 	var o1 = newObjectToPack(newObject(plumbing.BlobObject, []byte("00000")))
 	var o4 = newObjectToPack(newObject(plumbing.BlobObject, []byte("0000")))
 	var o6 = newObjectToPack(newObject(plumbing.BlobObject, []byte("00")))
···
 	toSort := []*ObjectToPack{o1, o2, o3, o4, o5, o6, o7, o8, o9}
 	s.ds.sort(toSort)
 	expected := []*ObjectToPack{o1, o4, o6, o9, o8, o2, o3, o5, o7}
-	c.Assert(toSort, DeepEquals, expected)
+	s.Equal(expected, toSort)
 }
 
 type testObject struct {
···
 	}
 }
 
-func (s *DeltaSelectorSuite) TestObjectsToPack(c *C) {
+func (s *DeltaSelectorSuite) TestObjectsToPack() {
 	// Different type
 	hashes := []plumbing.Hash{s.hashes["base"], s.hashes["treeType"]}
 	deltaWindowSize := uint(10)
 	otp, err := s.ds.ObjectsToPack(hashes, deltaWindowSize)
-	c.Assert(err, IsNil)
-	c.Assert(len(otp), Equals, 2)
-	c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["base"]])
-	c.Assert(otp[1].Object, Equals, s.store.Objects[s.hashes["treeType"]])
+	s.NoError(err)
+	s.Len(otp, 2)
+	s.Equal(s.store.Objects[s.hashes["base"]], otp[0].Object)
+	s.Equal(s.store.Objects[s.hashes["treeType"]], otp[1].Object)
 
 	// Size radically different
 	hashes = []plumbing.Hash{s.hashes["bigBase"], s.hashes["target"]}
 	otp, err = s.ds.ObjectsToPack(hashes, deltaWindowSize)
-	c.Assert(err, IsNil)
-	c.Assert(len(otp), Equals, 2)
-	c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["bigBase"]])
-	c.Assert(otp[1].Object, Equals, s.store.Objects[s.hashes["target"]])
+	s.NoError(err)
+	s.Len(otp, 2)
+	s.Equal(s.store.Objects[s.hashes["bigBase"]], otp[0].Object)
+	s.Equal(s.store.Objects[s.hashes["target"]], otp[1].Object)
 
 	// Delta Size Limit with no best delta yet
 	hashes = []plumbing.Hash{s.hashes["smallBase"], s.hashes["smallTarget"]}
 	otp, err = s.ds.ObjectsToPack(hashes, deltaWindowSize)
-	c.Assert(err, IsNil)
-	c.Assert(len(otp), Equals, 2)
-	c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["smallBase"]])
-	c.Assert(otp[1].Object, Equals, s.store.Objects[s.hashes["smallTarget"]])
+	s.NoError(err)
+	s.Len(otp, 2)
+	s.Equal(s.store.Objects[s.hashes["smallBase"]], otp[0].Object)
+	s.Equal(s.store.Objects[s.hashes["smallTarget"]], otp[1].Object)
 
 	// It will create the delta
 	hashes = []plumbing.Hash{s.hashes["base"], s.hashes["target"]}
 	otp, err = s.ds.ObjectsToPack(hashes, deltaWindowSize)
-	c.Assert(err, IsNil)
-	c.Assert(len(otp), Equals, 2)
-	c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["target"]])
-	c.Assert(otp[0].IsDelta(), Equals, false)
-	c.Assert(otp[1].Original, Equals, s.store.Objects[s.hashes["base"]])
-	c.Assert(otp[1].IsDelta(), Equals, true)
-	c.Assert(otp[1].Depth, Equals, 1)
+	s.NoError(err)
+	s.Len(otp, 2)
+	s.Equal(s.store.Objects[s.hashes["target"]], otp[0].Object)
+	s.False(otp[0].IsDelta())
+	s.Equal(s.store.Objects[s.hashes["base"]], otp[1].Original)
+	s.True(otp[1].IsDelta())
+	s.Equal(1, otp[1].Depth)
 
 	// If our base is another delta, the depth will increase by one
 	hashes = []plumbing.Hash{
···
 		s.hashes["o3"],
 	}
 	otp, err = s.ds.ObjectsToPack(hashes, deltaWindowSize)
-	c.Assert(err, IsNil)
-	c.Assert(len(otp), Equals, 3)
-	c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["o1"]])
-	c.Assert(otp[0].IsDelta(), Equals, false)
-	c.Assert(otp[1].Original, Equals, s.store.Objects[s.hashes["o2"]])
-	c.Assert(otp[1].IsDelta(), Equals, true)
-	c.Assert(otp[1].Depth, Equals, 1)
-	c.Assert(otp[2].Original, Equals, s.store.Objects[s.hashes["o3"]])
-	c.Assert(otp[2].IsDelta(), Equals, true)
-	c.Assert(otp[2].Depth, Equals, 2)
+	s.NoError(err)
+	s.Len(otp, 3)
+	s.Equal(s.store.Objects[s.hashes["o1"]], otp[0].Object)
+	s.False(otp[0].IsDelta())
+	s.Equal(s.store.Objects[s.hashes["o2"]], otp[1].Original)
+	s.True(otp[1].IsDelta())
+	s.Equal(1, otp[1].Depth)
+	s.Equal(s.store.Objects[s.hashes["o3"]], otp[2].Original)
+	s.True(otp[2].IsDelta())
+	s.Equal(2, otp[2].Depth)
 
 	// Check that objects outside of the sliding window don't produce
 	// a delta.
···
 	// Don't sort so we can easily check the sliding window without
 	// creating a bunch of new objects.
 	otp, err = s.ds.objectsToPack(hashes, deltaWindowSize)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 	err = s.ds.walk(otp, deltaWindowSize)
-	c.Assert(err, IsNil)
-	c.Assert(len(otp), Equals, int(deltaWindowSize)+2)
+	s.NoError(err)
+	s.Len(otp, int(deltaWindowSize)+2)
 	targetIdx := len(otp) - 1
-	c.Assert(otp[targetIdx].IsDelta(), Equals, false)
+	s.False(otp[targetIdx].IsDelta())
 
 	// Check that no deltas are created, and the objects are unsorted,
 	// if compression is off.
 	hashes = []plumbing.Hash{s.hashes["base"], s.hashes["target"]}
 	otp, err = s.ds.ObjectsToPack(hashes, 0)
-	c.Assert(err, IsNil)
-	c.Assert(len(otp), Equals, 2)
-	c.Assert(otp[0].Object, Equals, s.store.Objects[s.hashes["base"]])
-	c.Assert(otp[0].IsDelta(), Equals, false)
-	c.Assert(otp[1].Original, Equals, s.store.Objects[s.hashes["target"]])
-	c.Assert(otp[1].IsDelta(), Equals, false)
-	c.Assert(otp[1].Depth, Equals, 0)
+	s.NoError(err)
+	s.Len(otp, 2)
+	s.Equal(s.store.Objects[s.hashes["base"]], otp[0].Object)
+	s.False(otp[0].IsDelta())
+	s.Equal(s.store.Objects[s.hashes["target"]], otp[1].Original)
+	s.False(otp[1].IsDelta())
+	s.Equal(0, otp[1].Depth)
 }
 
-func (s *DeltaSelectorSuite) TestMaxDepth(c *C) {
+func (s *DeltaSelectorSuite) TestMaxDepth() {
 	dsl := s.ds.deltaSizeLimit(0, 0, int(maxDepth), true)
-	c.Assert(dsl, Equals, int64(0))
+	s.Equal(int64(0), dsl)
 }

plumbing/format/packfile/delta_test.go

···
 	"testing"
 
 	"github.com/go-git/go-git/v5/plumbing"
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/suite"
 )
 
 type DeltaSuite struct {
+	suite.Suite
 	testCases []deltaTest
 }
 
-var _ = Suite(&DeltaSuite{})
+func TestDeltaSuite(t *testing.T) {
+	suite.Run(t, new(DeltaSuite))
+}
 
 type deltaTest struct {
 	description string
···
 	target      []piece
 }
 
-func (s *DeltaSuite) SetUpSuite(c *C) {
+func (s *DeltaSuite) SetupSuite() {
 	s.testCases = []deltaTest{{
 		description: "distinct file",
 		base:        []piece{{"0", 300}},
···
 	return string(randBytes(n))
 }
 
-func (s *DeltaSuite) TestAddDelta(c *C) {
+func (s *DeltaSuite) TestAddDelta() {
 	for _, t := range s.testCases {
 		baseBuf := genBytes(t.base)
 		targetBuf := genBytes(t.target)
 		delta := DiffDelta(baseBuf, targetBuf)
 		result, err := PatchDelta(baseBuf, delta)
 
-		c.Log("Executing test case:", t.description)
-		c.Assert(err, IsNil)
-		c.Assert(result, DeepEquals, targetBuf)
+		s.T().Log("Executing test case:", t.description)
+		s.NoError(err)
+		s.Equal(targetBuf, result)
 	}
 }
 
-func (s *DeltaSuite) TestAddDeltaReader(c *C) {
+func (s *DeltaSuite) TestAddDeltaReader() {
 	for _, t := range s.testCases {
 		baseBuf := genBytes(t.base)
 		baseObj := &plumbing.MemoryObject{}
···
 		delta := DiffDelta(baseBuf, targetBuf)
 		deltaRC := io.NopCloser(bytes.NewReader(delta))
 
-		c.Log("Executing test case:", t.description)
+		s.T().Log("Executing test case:", t.description)
 
 		resultRC, err := ReaderFromDelta(baseObj, deltaRC)
-		c.Assert(err, IsNil)
+		s.NoError(err)
 
 		result, err := io.ReadAll(resultRC)
-		c.Assert(err, IsNil)
+		s.NoError(err)
 
 		err = resultRC.Close()
-		c.Assert(err, IsNil)
+		s.NoError(err)
 
-		c.Assert(result, DeepEquals, targetBuf)
+		s.Equal(targetBuf, result)
 	}
 }
 
-func (s *DeltaSuite) TestIncompleteDelta(c *C) {
+func (s *DeltaSuite) TestIncompleteDelta() {
 	for _, t := range s.testCases {
-		c.Log("Incomplete delta on:", t.description)
+		s.T().Log("Incomplete delta on:", t.description)
 		baseBuf := genBytes(t.base)
 		targetBuf := genBytes(t.target)
 		delta := DiffDelta(baseBuf, targetBuf)
 		delta = delta[:len(delta)-2]
 		result, err := PatchDelta(baseBuf, delta)
-		c.Assert(err, NotNil)
-		c.Assert(result, IsNil)
+		s.NotNil(err)
+		s.Nil(result)
 	}
 
 	// check nil input too
 	result, err := PatchDelta(nil, nil)
-	c.Assert(err, NotNil)
-	c.Assert(result, IsNil)
+	s.NotNil(err)
+	s.Nil(result)
 }
 
-func (s *DeltaSuite) TestMaxCopySizeDelta(c *C) {
+func (s *DeltaSuite) TestMaxCopySizeDelta() {
 	baseBuf := randBytes(maxCopySize)
 	targetBuf := baseBuf[0:]
 	targetBuf = append(targetBuf, byte(1))
 
 	delta := DiffDelta(baseBuf, targetBuf)
 	result, err := PatchDelta(baseBuf, delta)
-	c.Assert(err, IsNil)
-	c.Assert(result, DeepEquals, targetBuf)
+	s.NoError(err)
+	s.Equal(targetBuf, result)
 }
 
-func (s *DeltaSuite) TestMaxCopySizeDeltaReader(c *C) {
+func (s *DeltaSuite) TestMaxCopySizeDeltaReader() {
 	baseBuf := randBytes(maxCopySize)
 	baseObj := &plumbing.MemoryObject{}
 	baseObj.Write(baseBuf)
···
 	deltaRC := io.NopCloser(bytes.NewReader(delta))
 
 	resultRC, err := ReaderFromDelta(baseObj, deltaRC)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	result, err := io.ReadAll(resultRC)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	err = resultRC.Close()
-	c.Assert(err, IsNil)
-	c.Assert(result, DeepEquals, targetBuf)
+	s.NoError(err)
+	s.Equal(targetBuf, result)
 }
 
 func FuzzPatchDelta(f *testing.F) {

plumbing/format/packfile/encoder_advanced_test.go

···
 	. "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"
+	"github.com/stretchr/testify/suite"
 
 	"github.com/go-git/go-billy/v5/memfs"
 	fixtures "github.com/go-git/go-git-fixtures/v4"
-	. "gopkg.in/check.v1"
 )
 
+type EncoderAdvancedFixtureSuite struct {
+	fixtures.Suite
+}
+
 type EncoderAdvancedSuite struct {
-	fixtures.Suite
+	suite.Suite
+	EncoderAdvancedFixtureSuite
 }
 
-var _ = Suite(&EncoderAdvancedSuite{})
+func TestEncoderAdvancedSuite(t *testing.T) {
+	suite.Run(t, new(EncoderAdvancedSuite))
+}
 
-func (s *EncoderAdvancedSuite) TestEncodeDecode(c *C) {
+func (s *EncoderAdvancedSuite) TestEncodeDecode() {
 	if testing.Short() {
-		c.Skip("skipping test in short mode.")
+		s.T().Skip("skipping test in short mode.")
 	}
 
 	fixs := fixtures.Basic().ByTag("packfile").ByTag(".git")
 	fixs = append(fixs, fixtures.ByURL("https://github.com/src-d/go-git.git").
 		ByTag("packfile").ByTag(".git").One())
-	fixs.Test(c, func(f *fixtures.Fixture) {
+
+	for _, f := range fixs {
 		storage := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
-		s.testEncodeDecode(c, storage, 10)
-	})
+		s.testEncodeDecode(storage, 10)
+	}
 }
 
-func (s *EncoderAdvancedSuite) TestEncodeDecodeNoDeltaCompression(c *C) {
+func (s *EncoderAdvancedSuite) TestEncodeDecodeNoDeltaCompression() {
 	if testing.Short() {
-		c.Skip("skipping test in short mode.")
+		s.T().Skip("skipping test in short mode.")
 	}
 
 	fixs := fixtures.Basic().ByTag("packfile").ByTag(".git")
 	fixs = append(fixs, fixtures.ByURL("https://github.com/src-d/go-git.git").
 		ByTag("packfile").ByTag(".git").One())
-	fixs.Test(c, func(f *fixtures.Fixture) {
+
+	for _, f := range fixs {
 		storage := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
-		s.testEncodeDecode(c, storage, 0)
-	})
+		s.testEncodeDecode(storage, 0)
+	}
 }
 
 func (s *EncoderAdvancedSuite) testEncodeDecode(
-	c *C,
 	storage storer.Storer,
 	packWindow uint,
 ) {
 	objIter, err := storage.IterEncodedObjects(plumbing.AnyObject)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	expectedObjects := map[plumbing.Hash]bool{}
 	var hashes []plumbing.Hash
···
 		return err
 
 	})
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	// Shuffle hashes to avoid delta selector getting order right just because
 	// the initial order is correct.
···
 	buf := bytes.NewBuffer(nil)
 	enc := NewEncoder(buf, storage, false)
 	encodeHash, err := enc.Encode(hashes, packWindow)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	fs := memfs.New()
 	f, err := fs.Create("packfile")
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	_, err = f.Write(buf.Bytes())
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	_, err = f.Seek(0, io.SeekStart)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	w := new(idxfile.Writer)
 	parser := NewParser(NewScanner(f), WithScannerObservers(w))
 
 	_, err = parser.Parse()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 	index, err := w.Index()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	_, err = f.Seek(0, io.SeekStart)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	p := NewPackfile(f, WithIdx(index), WithFs(fs))
 
 	decodeHash, err := p.ID()
-	c.Assert(err, IsNil)
-	c.Assert(encodeHash, Equals, decodeHash)
+	s.NoError(err)
+	s.Equal(decodeHash, encodeHash)
 
 	objIter, err = p.GetAll()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 	obtainedObjects := map[plumbing.Hash]bool{}
 	err = objIter.ForEach(func(o plumbing.EncodedObject) error {
 		obtainedObjects[o.Hash()] = true
 		return nil
 	})
-	c.Assert(err, IsNil)
-	c.Assert(obtainedObjects, DeepEquals, expectedObjects)
+	s.NoError(err)
+	s.Equal(expectedObjects, obtainedObjects)
 
 	for h := range obtainedObjects {
 		if !expectedObjects[h] {
-			c.Errorf("obtained unexpected object: %s", h)
+			s.T().Errorf("obtained unexpected object: %s", h)
 		}
 	}
 
 	for h := range expectedObjects {
 		if !obtainedObjects[h] {
-			c.Errorf("missing object: %s", h)
+			s.T().Errorf("missing object: %s", h)
 		}
 	}
 }

plumbing/format/packfile/encoder_test.go

···
 import (
 	"bytes"
 	"io"
+	"testing"
 
 	"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/hash"
 	"github.com/go-git/go-git/v5/storage/memory"
+	"github.com/stretchr/testify/suite"
 
 	"github.com/go-git/go-billy/v5/memfs"
 	fixtures "github.com/go-git/go-git-fixtures/v4"
-	. "gopkg.in/check.v1"
 )
+
+type EncoderFixtureSuite struct {
+	fixtures.Suite
+}
 
 type EncoderSuite struct {
-	fixtures.Suite
+	suite.Suite
+	EncoderFixtureSuite
 	buf   *bytes.Buffer
 	store *memory.Storage
 	enc   *Encoder
 }
 
-var _ = Suite(&EncoderSuite{})
+func TestEncoderSuite(t *testing.T) {
+	suite.Run(t, new(EncoderSuite))
+}
 
-func (s *EncoderSuite) SetUpTest(c *C) {
+func (s *EncoderSuite) SetupTest() {
 	s.buf = bytes.NewBuffer(nil)
 	s.store = memory.NewStorage()
 	s.enc = NewEncoder(s.buf, s.store, false)
 }
 
-func (s *EncoderSuite) TestCorrectPackHeader(c *C) {
+func (s *EncoderSuite) TestCorrectPackHeader() {
 	h, err := s.enc.Encode([]plumbing.Hash{}, 10)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	hb := [hash.Size]byte(h)
 
···
 
 	result := s.buf.Bytes()
 
-	c.Assert(result, DeepEquals, expectedResult)
+	s.Equal(expectedResult, result)
 }
 
-func (s *EncoderSuite) TestCorrectPackWithOneEmptyObject(c *C) {
+func (s *EncoderSuite) TestCorrectPackWithOneEmptyObject() {
 	o := &plumbing.MemoryObject{}
 	o.SetType(plumbing.CommitObject)
 	o.SetSize(0)
 	_, err := s.store.SetEncodedObject(o)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	h, err := s.enc.Encode([]plumbing.Hash{o.Hash()}, 10)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	// PACK + VERSION(2) + OBJECT NUMBER(1)
 	expectedResult := []byte{'P', 'A', 'C', 'K', 0, 0, 0, 2, 0, 0, 0, 1}
···
 
 	result := s.buf.Bytes()
 
-	c.Assert(result, DeepEquals, expectedResult)
+	s.Equal(expectedResult, result)
 }
 
-func (s *EncoderSuite) TestMaxObjectSize(c *C) {
+func (s *EncoderSuite) TestMaxObjectSize() {
 	o := s.store.NewEncodedObject()
 	o.SetSize(9223372036854775807)
 	o.SetType(plumbing.CommitObject)
 	_, err := s.store.SetEncodedObject(o)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 	hash, err := s.enc.Encode([]plumbing.Hash{o.Hash()}, 10)
-	c.Assert(err, IsNil)
-	c.Assert(hash.IsZero(), Not(Equals), true)
+	s.NoError(err)
+	s.NotEqual(true, hash.IsZero())
 }
 
-func (s *EncoderSuite) TestHashNotFound(c *C) {
+func (s *EncoderSuite) TestHashNotFound() {
 	h, err := s.enc.Encode([]plumbing.Hash{plumbing.NewHash("BAD")}, 10)
-	c.Assert(h, Equals, plumbing.ZeroHash)
-	c.Assert(err, NotNil)
-	c.Assert(err, Equals, plumbing.ErrObjectNotFound)
+	s.Equal(plumbing.ZeroHash, h)
+	s.NotNil(err)
+	s.ErrorIs(err, plumbing.ErrObjectNotFound)
 }
 
-func (s *EncoderSuite) TestDecodeEncodeWithDeltaDecodeREF(c *C) {
+func (s *EncoderSuite) TestDecodeEncodeWithDeltaDecodeREF() {
 	s.enc = NewEncoder(s.buf, s.store, true)
-	s.simpleDeltaTest(c)
+	s.simpleDeltaTest()
 }
 
-func (s *EncoderSuite) TestDecodeEncodeWithDeltaDecodeOFS(c *C) {
+func (s *EncoderSuite) TestDecodeEncodeWithDeltaDecodeOFS() {
 	s.enc = NewEncoder(s.buf, s.store, false)
-	s.simpleDeltaTest(c)
+	s.simpleDeltaTest()
 }
 
-func (s *EncoderSuite) TestDecodeEncodeWithDeltasDecodeREF(c *C) {
+func (s *EncoderSuite) TestDecodeEncodeWithDeltasDecodeREF() {
 	s.enc = NewEncoder(s.buf, s.store, true)
-	s.deltaOverDeltaTest(c)
+	s.deltaOverDeltaTest()
 }
 
-func (s *EncoderSuite) TestDecodeEncodeWithDeltasDecodeOFS(c *C) {
+func (s *EncoderSuite) TestDecodeEncodeWithDeltasDecodeOFS() {
 	s.enc = NewEncoder(s.buf, s.store, false)
-	s.deltaOverDeltaTest(c)
+	s.deltaOverDeltaTest()
 }
 
-func (s *EncoderSuite) TestDecodeEncodeWithCycleREF(c *C) {
+func (s *EncoderSuite) TestDecodeEncodeWithCycleREF() {
 	s.enc = NewEncoder(s.buf, s.store, true)
-	s.deltaOverDeltaCyclicTest(c)
+	s.deltaOverDeltaCyclicTest()
 }
 
-func (s *EncoderSuite) TestDecodeEncodeWithCycleOFS(c *C) {
+func (s *EncoderSuite) TestDecodeEncodeWithCycleOFS() {
 	s.enc = NewEncoder(s.buf, s.store, false)
-	s.deltaOverDeltaCyclicTest(c)
+	s.deltaOverDeltaCyclicTest()
 }
 
-func (s *EncoderSuite) simpleDeltaTest(c *C) {
+func (s *EncoderSuite) simpleDeltaTest() {
 	srcObject := newObject(plumbing.BlobObject, []byte("0"))
 	targetObject := newObject(plumbing.BlobObject, []byte("01"))
 
 	deltaObject, err := GetDelta(srcObject, targetObject)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	srcToPack := newObjectToPack(srcObject)
 	encHash, err := s.enc.encode([]*ObjectToPack{
 		srcToPack,
 		newDeltaObjectToPack(srcToPack, targetObject, deltaObject),
 	})
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
-	p, cleanup := packfileFromReader(c, s.buf)
+	p, cleanup := packfileFromReader(s, s.buf)
 	defer cleanup()
 	decHash, err := p.ID()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
-	c.Assert(encHash, Equals, decHash)
+	s.Equal(decHash, encHash)
 
 	decSrc, err := p.Get(srcObject.Hash())
-	c.Assert(err, IsNil)
-	objectsEqual(c, decSrc, srcObject)
+	s.NoError(err)
+	objectsEqual(s, decSrc, srcObject)
 
 	decTarget, err := p.Get(targetObject.Hash())
-	c.Assert(err, IsNil)
-	objectsEqual(c, decTarget, targetObject)
+	s.NoError(err)
+	objectsEqual(s, decTarget, targetObject)
 }
 
-func (s *EncoderSuite) deltaOverDeltaTest(c *C) {
+func (s *EncoderSuite) deltaOverDeltaTest() {
 	srcObject := newObject(plumbing.BlobObject, []byte("0"))
 	targetObject := newObject(plumbing.BlobObject, []byte("01"))
 	otherTargetObject := newObject(plumbing.BlobObject, []byte("011111"))
 
 	deltaObject, err := GetDelta(srcObject, targetObject)
-	c.Assert(err, IsNil)
-	c.Assert(deltaObject.Hash(), Not(Equals), plumbing.ZeroHash)
+	s.NoError(err)
+	s.NotEqual(plumbing.ZeroHash, deltaObject.Hash())
 
 	otherDeltaObject, err := GetDelta(targetObject, otherTargetObject)
-	c.Assert(err, IsNil)
-	c.Assert(otherDeltaObject.Hash(), Not(Equals), plumbing.ZeroHash)
+	s.NoError(err)
+	s.NotEqual(plumbing.ZeroHash, otherDeltaObject.Hash())
 
 	srcToPack := newObjectToPack(srcObject)
 	targetToPack := newObjectToPack(targetObject)
···
 		newDeltaObjectToPack(srcToPack, targetObject, deltaObject),
 		newDeltaObjectToPack(targetToPack, otherTargetObject, otherDeltaObject),
 	})
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
-	p, cleanup := packfileFromReader(c, s.buf)
+	p, cleanup := packfileFromReader(s, s.buf)
 	defer cleanup()
 	decHash, err := p.ID()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
-	c.Assert(encHash, Equals, decHash)
+	s.Equal(decHash, encHash)
 
 	decSrc, err := p.Get(srcObject.Hash())
-	c.Assert(err, IsNil)
-	objectsEqual(c, decSrc, srcObject)
+	s.NoError(err)
+	objectsEqual(s, decSrc, srcObject)
 
 	decTarget, err := p.Get(targetObject.Hash())
-	c.Assert(err, IsNil)
-	objectsEqual(c, decTarget, targetObject)
+	s.NoError(err)
+	objectsEqual(s, decTarget, targetObject)
 
 	decOtherTarget, err := p.Get(otherTargetObject.Hash())
-	c.Assert(err, IsNil)
-	objectsEqual(c, decOtherTarget, otherTargetObject)
+	s.NoError(err)
+	objectsEqual(s, decOtherTarget, otherTargetObject)
 }
 
-func (s *EncoderSuite) deltaOverDeltaCyclicTest(c *C) {
+func (s *EncoderSuite) deltaOverDeltaCyclicTest() {
 	o1 := newObject(plumbing.BlobObject, []byte("0"))
 	o2 := newObject(plumbing.BlobObject, []byte("01"))
 	o3 := newObject(plumbing.BlobObject, []byte("011111"))
 	o4 := newObject(plumbing.BlobObject, []byte("01111100000"))
 
 	_, err := s.store.SetEncodedObject(o1)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 	_, err = s.store.SetEncodedObject(o2)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 	_, err = s.store.SetEncodedObject(o3)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 	_, err = s.store.SetEncodedObject(o4)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	d2, err := GetDelta(o1, o2)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	d3, err := GetDelta(o4, o3)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	d4, err := GetDelta(o3, o4)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	po1 := newObjectToPack(o1)
 	pd2 := newDeltaObjectToPack(po1, o2, d2)
···
 		pd3,
 		pd4,
 	})
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
-	p, cleanup := packfileFromReader(c, s.buf)
+	p, cleanup := packfileFromReader(s, s.buf)
 	defer cleanup()
 	decHash, err := p.ID()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
-	c.Assert(encHash, Equals, decHash)
+	s.Equal(decHash, encHash)
 
 	decSrc, err := p.Get(o1.Hash())
-	c.Assert(err, IsNil)
-	objectsEqual(c, decSrc, o1)
+	s.NoError(err)
+	objectsEqual(s, decSrc, o1)
 
 	decTarget, err := p.Get(o2.Hash())
-	c.Assert(err, IsNil)
-	objectsEqual(c, decTarget, o2)
+	s.NoError(err)
+	objectsEqual(s, decTarget, o2)
 
 	decOtherTarget, err := p.Get(o3.Hash())
-	c.Assert(err, IsNil)
-	objectsEqual(c, decOtherTarget, o3)
+	s.NoError(err)
+	objectsEqual(s, decOtherTarget, o3)
 
 	decAnotherTarget, err := p.Get(o4.Hash())
-	c.Assert(err, IsNil)
-	objectsEqual(c, decAnotherTarget, o4)
+	s.NoError(err)
+	objectsEqual(s, decAnotherTarget, o4)
 }
 
-func objectsEqual(c *C, o1, o2 plumbing.EncodedObject) {
-	c.Assert(o1.Type(), Equals, o2.Type())
-	c.Assert(o1.Hash(), Equals, o2.Hash())
-	c.Assert(o1.Size(), Equals, o2.Size())
+func objectsEqual(s *EncoderSuite, o1, o2 plumbing.EncodedObject) {
+	s.Equal(o2.Type(), o1.Type())
+	s.Equal(o2.Hash(), o1.Hash())
+	s.Equal(o2.Size(), o1.Size())
 
 	r1, err := o1.Reader()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	b1, err := io.ReadAll(r1)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	r2, err := o2.Reader()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	b2, err := io.ReadAll(r2)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
-	c.Assert(bytes.Compare(b1, b2), Equals, 0)
+	s.Equal(0, bytes.Compare(b1, b2))
 
 	err = r2.Close()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	err = r1.Close()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 }
 
-func packfileFromReader(c *C, buf *bytes.Buffer) (*Packfile, func()) {
+func packfileFromReader(s *EncoderSuite, buf *bytes.Buffer) (*Packfile, func()) {
 	fs := memfs.New()
 	file, err := fs.Create("packfile")
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	_, err = file.Write(buf.Bytes())
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	_, err = file.Seek(0, io.SeekStart)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	scanner := NewScanner(file)
 
···
 	p := NewParser(scanner, WithScannerObservers(w))
 
 	_, err = p.Parse()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	index, err := w.Index()
-	c.Assert(err, IsNil)
+	s.NoError(err)
+
+	_, err = file.Seek(0, io.SeekStart)
+	s.NoError(err)
 
 	return NewPackfile(file, WithIdx(index), WithFs(fs)), func() {
-		c.Assert(file.Close(), IsNil)
+		s.NoError(file.Close())
 	}
 }

plumbing/format/packfile/object_pack_test.go

···
 
 import (
 	"io"
+	"testing"
 
 	"github.com/go-git/go-git/v5/plumbing"
-
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/suite"
 )
 
-type ObjectToPackSuite struct{}
+type ObjectToPackSuite struct {
+	suite.Suite
+}
 
-var _ = Suite(&ObjectToPackSuite{})
+func TestObjectToPackSuite(t *testing.T) {
+	suite.Run(t, new(ObjectToPackSuite))
+}
 
-func (s *ObjectToPackSuite) TestObjectToPack(c *C) {
+func (s *ObjectToPackSuite) TestObjectToPack() {
 	obj := &dummyObject{}
 	otp := newObjectToPack(obj)
-	c.Assert(obj, Equals, otp.Object)
-	c.Assert(obj, Equals, otp.Original)
-	c.Assert(otp.Base, IsNil)
-	c.Assert(otp.IsDelta(), Equals, false)
+	s.Equal(otp.Object, obj)
+	s.Equal(otp.Original, obj)
+	s.Nil(otp.Base)
+	s.False(otp.IsDelta())
 
 	original := &dummyObject{}
 	delta := &dummyObject{}
 	deltaToPack := newDeltaObjectToPack(otp, original, delta)
-	c.Assert(obj, Equals, deltaToPack.Object)
-	c.Assert(original, Equals, deltaToPack.Original)
-	c.Assert(otp, Equals, deltaToPack.Base)
-	c.Assert(deltaToPack.IsDelta(), Equals, true)
+	s.Equal(deltaToPack.Object, obj)
+	s.Equal(deltaToPack.Original, original)
+	s.Equal(deltaToPack.Base, otp)
+	s.True(deltaToPack.IsDelta())
 }
 
 type dummyObject struct{}

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.cont = slices.Grow(o.cont, int(s))
 	o.sz = s
 }