Exemplo n.º 1
0
func Test_Or(t *testing.T) {
	numbers := applyInt(numbers, FilterOr(evenNumbers, oddNumbers))
	for i := 0; i < 10; i++ {
		util.Assert(t, numbers[i] == i+1)
	}
	util.Assert(t, len(numbers) == 10)
}
Exemplo n.º 2
0
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)
}
Exemplo n.º 3
0
func Test_Sorting(t *testing.T) {
	refs := make([]objects.Ref, 3)
	refs[0] = objects.NewRef("zoo", "", nil, nil)
	refs[1] = objects.NewRef("yogurt", "", nil, nil)
	refs[2] = objects.NewRef("xavier", "", nil, nil)
	sort.Sort(refByName(refs))
	util.Assert(t, refs[0].Name() == "xavier")
	util.Assert(t, refs[1].Name() == "yogurt")
	util.Assert(t, refs[2].Name() == "zoo")
}
Exemplo n.º 4
0
func Test_parseInvalidBlobHeader(t *testing.T) {
	test := func(badBlob string) {
		p := ObjectParserForString(badBlob)
		hdr, e := p.ParseHeader()
		util.Assert(t, e != nil)
		util.Assert(t, hdr == nil)
	}
	test("bad 100\000dsfsdfsdfsdf")
	test("bl0b 10\000est")
	test("100\000hehe")
	test("bad \000hoho")
	test("no header at all")
}
Exemplo n.º 5
0
func Test_revParse__zeros(t *testing.T) {
	testCase := test.Linear
	repo := Open(testCase.Repo())
	info := testCase.Info().(*test.InfoLinear)

	util.Assert(t, info.N > 0)
	util.Assert(t, len(info.Commits) == info.N)

	// test the first, parentless commit
	for _, c := range info.Commits {
		oid := objects.OidNow(c.CommitOid)
		testZeros(t, repo, oid)
	}
}
Exemplo n.º 6
0
func Test_revParse__secondAncestor(t *testing.T) {
	testCase := test.Linear
	repo := Open(testCase.Repo())
	info := testCase.Info().(*test.InfoLinear)

	util.Assert(t, info.N > 2)
	util.Assert(t, len(info.Commits) == info.N)

	// test the first, parentless commit
	for i, c := range info.Commits[2:] {
		oid, expOid := objects.OidNow(c.CommitOid), objects.OidNow(info.Commits[i].CommitOid)
		testSecondAncestor(t, repo, oid, expOid)
		testSecondAncestorVariations(t, repo, oid, expOid)
	}
}
Exemplo n.º 7
0
func Test_ParseObjectId(t *testing.T) {
	var oid *objects.ObjectId
	oidStr := "ff6ccb68859fd52216ec8dadf98d2a00859f5369"
	t1 := ObjectParserForString(oidStr)
	oid = t1.ParseOid()
	util.Assert(t, oid.String() == oidStr)
}
Exemplo n.º 8
0
func Test_revParse__firstParent(t *testing.T) {
	testCase := test.Linear
	repo := Open(testCase.Repo())
	info := testCase.Info().(*test.InfoLinear)

	util.Assert(t, info.N > 1)
	util.Assert(t, len(info.Commits) == info.N)

	// test the first, parentless commit
	testParentlessCommit(t, repo, objects.OidNow(info.Commits[0].CommitOid))
	for _, c := range info.Commits[1:] {
		oid, expOid := objects.OidNow(c.CommitOid), objects.OidNow(c.ParentOid)
		testShortOid(t, repo, oid)
		testFirstParent(t, repo, oid, expOid)
		testFirstParentVariations(t, repo, oid, expOid)
	}
}
Exemplo n.º 9
0
// Test_readCommits will compare the commit output of
// git and ggit for a string of commits.
func Test_readTree(t *testing.T) {
	testCase := test.Tree
	repo := Open(testCase.Repo())
	info := testCase.Info().(*test.InfoTree)
	f := format.NewStrFormat()

	var (
		oid = objects.OidNow(info.TreeOid)
	)
	o, err := repo.ObjectFromOid(oid)
	util.AssertNoErr(t, err)

	// check the id
	util.Assert(t, o.ObjectId().String() == info.TreeOid)

	// check the header
	util.Assert(t, o.Header().Type() == objects.ObjectTree)
	util.AssertEqualInt(t, int(o.Header().Size()), info.TreeSize)

	// get the tree
	// now convert to a tag and check the fields
	var tree *objects.Tree
	util.AssertPanicFree(t, func() {
		tree = o.(*objects.Tree)
	})

	// check entries
	entries := tree.Entries()
	util.AssertEqualInt(t, info.N, len(entries))
	util.Assert(t, info.N > 2)

	// check a file
	file := entries[0]
	util.AssertEqualString(t, info.File1Oid, file.ObjectId().String())
	util.Assert(t, file.Mode() == objects.ModeBlob)
	// TODO: add checks for type, etc.

	// check the output
	// check the whole representation, which will catch
	// most of the other stuff
	f.Reset()
	f.Object(o)
	util.AssertEqualString(t, info.TreeRepr, f.String())
}
Exemplo n.º 10
0
func Test_parseBlobBadSize(t *testing.T) {
	test := func(contents string) {
		l := len(contents)
		size := rand.Intn(l+1) - 1 + 2*rand.Intn(2)*l // never equal to l
		tb := makeTestBlobWithSize(size, contents)
		p := ObjectParserForString(tb)
		hdr, e := p.ParseHeader()
		util.AssertNoErr(t, e)
		util.Assert(t, hdr.Type() == objects.ObjectBlob)
		util.Assert(t, hdr.Size() == int64(size))

		// should not be able to parse
		_, e = p.ParsePayload()
		util.Assert(t, e != nil)
	}
	for _, v := range testCasesBlobs {
		test(v)
	}
}
Exemplo n.º 11
0
func Test_assertFileMode(t *testing.T) {
	m1 := uint16(0000000)
	m2 := uint16(0040000)
	m3 := uint16(0100644)
	m4 := uint16(0100755)
	m5 := uint16(0120000)
	m6 := uint16(0160000)

	test := func(m uint16, exp objects.FileMode) {
		mode, ok := assertFileMode(m)
		util.Assert(t, ok, "could not convert to file mode")
		util.Assert(t, mode == exp)
	}

	test(m1, objects.ModeNew)
	test(m2, objects.ModeTree)
	test(m3, objects.ModeBlob)
	test(m4, objects.ModeBlobExec)
	test(m5, objects.ModeLink)
	test(m6, objects.ModeCommit)
}
Exemplo n.º 12
0
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())
}
Exemplo n.º 13
0
// Test_readCommits will compare the commit output of
// git and ggit for a string of commits.
func Test_readTree(t *testing.T) {
	testCase := test.TreeDiff
	repo := api.Open(testCase.Repo())
	info, _ := testCase.Info().(*test.InfoTreeDiff)

	oid := objects.OidNow(info.TreeOid1)
	o, err := repo.ObjectFromOid(oid)
	util.AssertNoErr(t, err)
	// get the tree
	tree1, _ := o.(*objects.Tree)

	oid = objects.OidNow(info.TreeOid2)
	o, err = repo.ObjectFromOid(oid)
	util.AssertNoErr(t, err)
	// get the tree
	tree2, _ := o.(*objects.Tree)

	diff, err := NewTreeDiffer(repo, NewBlobComparator()).Diff(tree1, tree2)
	modified := diff.Modified()

	if len(modified) != 1 {
		t.Errorf("expected 1 modification in the tree diff. got %d", len(modified))
	}

	edit := modified[0]
	before, after := edit.Before, edit.After
	beforeOid, afterOid := before.ObjectId(), after.ObjectId()
	beforeName := before.Name()

	if beforeName != info.ModifiedFileName {
		t.Errorf("expected modified file name to be [%s], but got [%s]", info.ModifiedFileName, beforeName)
	}

	if beforeOid.String() != info.ModifiedFileBeforeOid {
		t.Errorf("expected modified file's initial id to be [%s], but got [%s]", info.ModifiedFileBeforeOid, beforeOid)
	}

	if afterOid.String() != info.ModifiedFileAfterOid {
		t.Errorf("expected modified file's initial id to be [%s], but got [%s]", info.ModifiedFileAfterOid, afterOid)
	}

	deleted := diff.Deleted()

	util.Assert(t, len(deleted) == 1, fmt.Sprintf("expected 1 file to be deleted, got [%d]", len(deleted)))
	entry := deleted[0]
	deletedName, deletedOid := entry.Name(), entry.ObjectId().String()
	if deletedName != info.RemovedFileName {
		t.Errorf("expected deleted file's name to be [%s], but got [%s]", info.RemovedFileName, deletedName)
	}
	if deletedOid != info.RemovedFileOid {
		t.Errorf("expected deleted file's id to be [%s], but got [%s]", info.RemovedFileOid, deletedOid)
	}
}
Exemplo n.º 14
0
func Test_parseValidFileMode(t *testing.T) {
	p := ObjectParserForString("0000000\n0040000\n0100644\n0100755\n0120000\n0160000\n")
	util.Assert(t, p.ParseFileMode(token.LF) == objects.ModeNew)
	util.Assert(t, p.ParseFileMode(token.LF) == objects.ModeTree)
	util.Assert(t, p.ParseFileMode(token.LF) == objects.ModeBlob)
	util.Assert(t, p.ParseFileMode(token.LF) == objects.ModeBlobExec)
	util.Assert(t, p.ParseFileMode(token.LF) == objects.ModeLink)
	util.Assert(t, p.ParseFileMode(token.LF) == objects.ModeCommit)
	util.Assert(t, p.EOF())
}
Exemplo n.º 15
0
// parseAndCompareTree will take a string tree representation and compare
// it with that tree from the provided repository. A tree representation
// has the following format:
//
//     <oid_of_this_tree><LF>
//     <size><LF>
//     <output_of_cat_file_p>
//
// Example:
//
// `dc5c0113b3d246da13b9d4b54861d2894da45e5a
// 348
// 100644 blob 022f0ad6583f99c3c01d0245db452e58bbb8fc8a	.gitignore
// 100644 blob 4760db634060e0f5c76eddb18031d53bff882a23	README
// 040000 tree 888fd8c9a6612c01d8f7c4e71fef114c3d3386d5	api
// 040000 tree 7ba590c4aa02ba2268f732f70b6143cd60457782	builtin
// 040000 tree bd52eecc257922f4c9008d080ad7dd5f9ac3444e	dotfiles
// 040000 tree 9ee2de084ec91660183740dacd8988c8170537e3	ggcase
// 100644 blob 82a1896a6d17e56220681fb66f94ac8a7e1d9bdc	ggit.go
// 100644 blob 3b20433fdf8544b2cff26989c5fc63327137e809	templates.go
// 040000 tree d42d8e7cf260b951e17687404031b1975ffa0b38	test
// 100644 blob 0c01aeb4856324d8487a252e32e04961bf603fad	version.go
// `
func parseAndCompareTree(t *testing.T, repo Repository, treeRepr string) {
	p := parse.ObjectParserForString(treeRepr)

	oid := p.ParseOid()
	p.ConsumeByte(token.LF)
	size := p.ParseInt(token.LF, 10, 32)

	o, err := repo.ObjectFromOid(oid)
	util.AssertNoErr(t, err)

	hdr := o.Header()
	util.Assert(t, hdr.Type() == objects.ObjectTree)
	util.Assert(t, hdr.Size() == size)

	tree := o.(*objects.Tree)
	entries := tree.Entries()

	for !p.EOF() {
		mode := p.ParseFileMode(token.SP)
		otype := objects.ObjectType(p.ConsumeStrings(token.ObjectTypes))
		p.ConsumeByte(token.SP)
		oidStr := p.ParseOid().String()
		p.ConsumeByte(token.TAB)
		name := p.ReadString(token.LF)
		util.Assert(t, len(entries) > 0)
		entry := entries[0]
		util.Assert(t, mode == entry.Mode())
		util.Assertf(t, name == entry.Name(), "expecting: `%s` got: `%s", name, entry.Name())
		util.Assert(t, otype == entry.ObjectType())
		util.Assertf(t, oidStr == entry.ObjectId().String(), "expecting: `%s` got: `%s", oidStr, entry.ObjectId())
		entries = entries[1:]
	}
	util.Assert(t, len(entries) == 0)
}
Exemplo n.º 16
0
func Test_parseValidBlob(t *testing.T) {
	for _, v := range testCasesBlobs {
		tb := makeTestBlob(v)
		p := ObjectParserForString(tb)
		hdr, err := p.ParseHeader()
		util.AssertNoErr(t, err)
		util.Assert(t, hdr.Type() == objects.ObjectBlob)
		util.Assert(t, hdr.Size() == int64(len(v)))

		o, err := p.ParsePayload()
		util.AssertNoErr(t, err)
		util.Assert(t, o.Header().Type() == objects.ObjectBlob)
		util.Assert(t, o.Header().Size() == int64(len(v)))
		util.Assert(t, o.ObjectId() == nil) // wasn't set in the test scenario

		var b *objects.Blob
		util.AssertPanicFree(t, func() {
			b = o.(*objects.Blob)
		})
		util.AssertEqualString(t, string(b.Data()), v)
	}
}
Exemplo n.º 17
0
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
	})
}
Exemplo n.º 18
0
func Test_NotEven(t *testing.T) {
	numbers := applyInt(numbers, FilterNot(evenNumbers))
	util.Assert(t, numbers[0] == 1)
	util.Assert(t, numbers[1] == 3)
	util.Assert(t, numbers[2] == 5)
	util.Assert(t, numbers[3] == 7)
	util.Assert(t, numbers[4] == 9)
	util.Assert(t, len(numbers) == 5)
}
Exemplo n.º 19
0
func Test_NotOdd(t *testing.T) {
	numbers := applyInt(numbers, FilterNot(oddNumbers))
	util.Assert(t, numbers[0] == 2)
	util.Assert(t, numbers[1] == 4)
	util.Assert(t, numbers[2] == 6)
	util.Assert(t, numbers[3] == 8)
	util.Assert(t, numbers[4] == 10)
	util.Assert(t, len(numbers) == 5)
}
Exemplo n.º 20
0
func Test_EvenNumbers(t *testing.T) {
	numbers := applyInt(numbers, evenNumbers)
	util.Assert(t, numbers[0] == 2)
	util.Assert(t, numbers[1] == 4)
	util.Assert(t, numbers[2] == 6)
	util.Assert(t, numbers[3] == 8)
	util.Assert(t, numbers[4] == 10)
	util.Assert(t, len(numbers) == 5)
}
Exemplo n.º 21
0
func Test_OddNumbers(t *testing.T) {
	numbers := applyInt(numbers, oddNumbers)
	util.Assert(t, numbers[0] == 1)
	util.Assert(t, numbers[1] == 3)
	util.Assert(t, numbers[2] == 5)
	util.Assert(t, numbers[3] == 7)
	util.Assert(t, numbers[4] == 9)
	util.Assert(t, len(numbers) == 5)
}
Exemplo n.º 22
0
func Test_makeHash(t *testing.T) {
	testRepo := test.DerefsPacked
	repo := Open(testRepo.Repo())
	info := testRepo.Info().(*test.InfoDerefsPacked)
	tagOid := objects.OidNow(info.TagOid)
	o, err := repo.ObjectFromOid(tagOid)
	if err != nil {
		panic(err)
	}
	if h, err := MakeHash(o); err != nil {
		panic(err)
	} else {
		oid := objects.OidFromHash(h)
		util.Assert(t, oid.String() == tagOid.String())
	}
}
Exemplo n.º 23
0
func assertSymbolicRef(t *testing.T, symbolicRef objects.Ref, tget string) {
	symbolic, target := symbolicRef.Target()
	util.Assert(t, symbolic)
	if target == nil {
		t.Fatalf("nil target")
	}
	util.AssertEqualString(t, target.(string), tget)
	util.AssertPanic(t, func() {
		oid := target.(*objects.ObjectId)
		oid.String() // for compilation
	})
	util.AssertPanic(t, func() {
		oid := symbolicRef.ObjectId()
		oid.String() // for compilation
	})
}
Exemplo n.º 24
0
func assertBadRef(t *testing.T, repo Repository, spec string) {
	_, err := repo.Ref(spec)
	util.Assert(t, err != nil)
	util.Assert(t, IsNoSuchRef(err))
	_, err = RefFromSpec(repo, spec)
	util.Assert(t, err != nil)
	util.Assert(t, IsNoSuchRef(err))
	_, err = PeeledRefFromSpec(repo, spec)
	util.Assert(t, err != nil)
	util.Assert(t, IsNoSuchRef(err))
}
Exemplo n.º 25
0
// this test implements basic blob reading from
// a git repository.
func Test_readBlobs(t *testing.T) {
	testRepo := test.Blobs

	repo := Open(testRepo.Repo())
	info := testRepo.Info().(*test.InfoBlobs)

	if len(info.Blobs) < 1 {
		fmt.Println("warning: no blobs to test")
	}

	for _, detail := range info.Blobs {
		// read the blob
		oid := objects.OidNow(detail.Oid)
		o, err := repo.ObjectFromOid(oid)
		util.AssertNoErr(t, err)
		util.Assert(t, o.Header().Type() == objects.ObjectBlob)
		b := o.(*objects.Blob)
		util.AssertEqualString(t, string(b.Data()), detail.Contents)
		util.AssertEqualInt(t, int(b.Header().Size()), len(detail.Contents))
	}

}
Exemplo n.º 26
0
func Test_NewStrFormat(t *testing.T) {
	f := NewStrFormat()
	f.Printf("hello %d", 10)
	f.Lf()
	util.Assert(t, f.String() == "hello 10\n")
}
Exemplo n.º 27
0
// 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())
}