func (p *Pack) parseDeltaEntry(bytes []byte, pot PackedObjectType, oid *objects.ObjectId, i int) *PackedObject {
	var (
		deltaDeflated packedDelta
		baseOffset    int64
		dp            *packedObjectParser
		err           error
	)
	e := p.idx.entries[i]
	switch pot {
	case ObjectRefDelta:
		var oid *objects.ObjectId
		deltaDeflated, oid = readPackedRefDelta(bytes)
		e := p.idx.entryById(oid)
		if e == nil {
			util.PanicErrf("nil entry for base object with id %s", oid.String())
		}
		baseOffset = e.offset
	case ObjectOffsetDelta:
		if deltaDeflated, baseOffset, err = readPackedOffsetDelta(bytes); err != nil {
			util.PanicErrf("Err parsing size: %v. Could not determine size for %s", err, e.String())
		}
		baseOffset = e.offset - baseOffset
	}
	base := p.findObjectByOffset(baseOffset)
	bytes = []byte(deltaDeflated)
	if dp, err = newPackedObjectParser(bytes, oid); err != nil {
		util.PanicErr(err.Error())
	}
	return dp.applyDelta(base, oid)
}

func testFirstParent(t *testing.T, repo Repository, oid *objects.ObjectId, parentOid *objects.ObjectId) {
	rev := oid.String() // rev == oid here
	testObjectExpected(t, repo, rev, oid, objects.ObjectCommit)
	for i := 4; i <= 40; i++ {
		testObjectExpected(t, repo, rev[:i]+"^", parentOid, objects.ObjectCommit)
	}
}

func testFirstParentVariations(t *testing.T, repo Repository, oid *objects.ObjectId, parentOid *objects.ObjectId) {
	rev := oid.String()
	testObjectExpected(t, repo, rev+"^", parentOid, objects.ObjectCommit)
	testObjectExpected(t, repo, rev+"^1", parentOid, objects.ObjectCommit)
	testObjectExpected(t, repo, rev+"~", parentOid, objects.ObjectCommit)
	testObjectExpected(t, repo, rev+"~1", parentOid, objects.ObjectCommit)
}

func Test_ParseObjectId(t *testing.T) {
	var oid *objects.ObjectId
	oidStr := "ff6ccb68859fd52216ec8dadf98d2a00859f5369"
	t1 := ObjectParserForString(oidStr)
	oid = t1.ParseOid()
	util.Assert(t, oid.String() == oidStr)
}

// testShortOid retrives the object by all possible combinations of
// shortening its id.
func testShortOid(t *testing.T, repo Repository, oid *objects.ObjectId) {
	rev := oid.String()
	for i := 4; i <= 40; i++ {
		o, err := ObjectFromRevision(repo, rev[:i])
		util.AssertNoErr(t, err)
		util.AssertEqualString(t, o.ObjectId().String(), oid.String())
	}
}

func testParentlessCommit(t *testing.T, repo Repository, oid *objects.ObjectId) {
	rev := oid.String()
	testObjectExpected(t, repo, rev, oid, objects.ObjectCommit)
	_, err := ObjectFromRevision(repo, rev+"~1")
	util.Assert(t, err != nil)
	_, err = ObjectFromRevision(repo, rev+"^")
	util.Assert(t, err != nil)
}

func testSecondAncestorVariations(t *testing.T, repo Repository, oid *objects.ObjectId, parentOid *objects.ObjectId) {
	rev := oid.String()
	testObjectExpected(t, repo, rev+"^^", parentOid, objects.ObjectCommit)
	testObjectExpected(t, repo, rev+"^1^1", parentOid, objects.ObjectCommit)
	testObjectExpected(t, repo, rev+"^^1", parentOid, objects.ObjectCommit)
	testObjectExpected(t, repo, rev+"^1^", parentOid, objects.ObjectCommit)
	testObjectExpected(t, repo, rev+"~~", parentOid, objects.ObjectCommit)
	testObjectExpected(t, repo, rev+"~1~", parentOid, objects.ObjectCommit)
	testObjectExpected(t, repo, rev+"~1~1", parentOid, objects.ObjectCommit)
	testObjectExpected(t, repo, rev+"~~1", parentOid, objects.ObjectCommit)
}

func testPackedTagDerefInfo(t *testing.T, repo Repository, spec string, oid *objects.ObjectId) {
	ref, err := repo.Ref(spec)
	util.AssertNoErr(t, err)
	util.AssertEqualString(t, ref.Name(), spec)
	// make sure target is symbolic and matches
	symbolic, target := ref.Target()
	util.Assert(t, !symbolic)
	if target == nil || ref.Commit() == nil {
		t.Fatalf("nil target or commit")
	}
	util.AssertEqualString(t, ref.Commit().String(), oid.String())
}

func assertPeeledRef(t *testing.T, peeledRef objects.Ref, oid *objects.ObjectId) {
	symbolic, target := peeledRef.Target()
	util.Assert(t, !symbolic)
	if target == nil {
		t.Fatalf("nil target")
	}
	util.AssertEqualString(t, target.(*objects.ObjectId).String(), oid.String())
	util.AssertEqualString(t, peeledRef.ObjectId().String(), oid.String())
	util.AssertPanic(t, func() {
		s := target.(string)
		s += "" // for compilation
	})
}

func (idx *Idx) entryById(oid *objects.ObjectId) *PackedObjectId {
	trimmed := idx.entriesWithPrefix(oid.Bytes()[0])
	if trimmed == nil {
		return nil
	}
	id := oid.String()
	if idx.idToEntry[id] != nil {
		return idx.idToEntry[id]
	}
	gte := func(i int) bool {
		var oid *objects.ObjectId
		oid = trimmed[i].ObjectId
		return oid.String() >= id
	}
	i := sort.Search(len(trimmed), gte)
	if i >= len(trimmed) {
		return nil
	}
	result := trimmed[i]
	if result.ObjectId.String() != id {
		return nil
	}
	idx.idToEntry[id] = result
	return result
}

func (f *formatter) ObjectId(oid *objects.ObjectId) (int, error) {
	return fmt.Fprint(f.Writer, oid.String())
}

// testObjectExpected retrieves the commit with the given revision specification
// from the given repository and ensures that this operation went well and the
// returned object in fact has the expected oid.
func testObjectExpected(t *testing.T, repo Repository, rev string, expOid *objects.ObjectId, expType objects.ObjectType) {
	parent, err := ObjectFromRevision(repo, rev)
	util.AssertNoErr(t, err)
	util.Assert(t, parent.Header().Type() == expType)
	util.AssertEqualString(t, parent.ObjectId().String(), expOid.String())
}

func testZeros(t *testing.T, repo Repository, oid *objects.ObjectId) {
	rev := oid.String()
	testObjectExpected(t, repo, rev+"^0", oid, objects.ObjectCommit)
	testObjectExpected(t, repo, rev+"~0", oid, objects.ObjectCommit)
}

// objectFile turns an oid into a path relative to the
// git directory of a repository where that object should
// be located (if it is a loose object).
func objectFile(repo *DiskRepository, oid *objects.ObjectId) (file *os.File, err error) {
	hex := oid.String()
	path := path.Join(repo.path, DefaultObjectsDir, hex[0:2], hex[2:])
	return os.Open(path)
}