1 files changed, 101 insertions, 5 deletions

diff --git a/diff_test.go b/diff_test.go
index b688294..fc6fed9 100644
--- a/diff_test.go
+++ b/diff_test.go
@@ -3,30 +3,81 @@ package git
 import (
 	"errors"
 	"os"
+	"strings"
 	"testing"
 )
 
-func TestDiffTreeToTree(t *testing.T) {
+func TestFindSimilar(t *testing.T) {
 	repo := createTestRepo(t)
 	defer repo.Free()
 	defer os.RemoveAll(repo.Workdir())
 
-	_, originalTreeId := seedTestRepo(t, repo)
-	originalTree, err := repo.LookupTree(originalTreeId)
+	originalTree, newTree := createTestTrees(t, repo)
 
+	diffOpt, _ := DefaultDiffOptions()
+
+	diff, err := repo.DiffTreeToTree(originalTree, newTree, &diffOpt)
 	checkFatal(t, err)
+	if diff == nil {
+		t.Fatal("no diff returned")
+	}
 
-	_, newTreeId := updateReadme(t, repo, "file changed\n")
+	findOpts, err := DefaultDiffFindOptions()
+	checkFatal(t, err)
+	findOpts.Flags = DiffFindBreakRewrites
 
-	newTree, err := repo.LookupTree(newTreeId)
+	err = diff.FindSimilar(&findOpts)
 	checkFatal(t, err)
 
+	numDiffs := 0
+	numAdded := 0
+	numDeleted := 0
+
+	err = diff.ForEach(func(file DiffDelta, progress float64) (DiffForEachHunkCallback, error) {
+		numDiffs++
+
+		switch file.Status {
+		case DeltaAdded:
+			numAdded++
+		case DeltaDeleted:
+			numDeleted++
+		}
+
+		return func(hunk DiffHunk) (DiffForEachLineCallback, error) {
+			return func(line DiffLine) error {
+				return nil
+			}, nil
+		}, nil
+	}, DiffDetailLines)
+
+	if numDiffs != 2 {
+		t.Fatal("Incorrect number of files in diff")
+	}
+	if numAdded != 1 {
+		t.Fatal("Incorrect number of new files in diff")
+	}
+	if numDeleted != 1 {
+		t.Fatal("Incorrect number of deleted files in diff")
+	}
+
+}
+
+func TestDiffTreeToTree(t *testing.T) {
+
+	repo := createTestRepo(t)
+	defer repo.Free()
+	defer os.RemoveAll(repo.Workdir())
+
+	originalTree, newTree := createTestTrees(t, repo)
+
 	callbackInvoked := false
 	opts := DiffOptions{
 		NotifyCallback: func(diffSoFar *Diff, delta DiffDelta, matchedPathSpec string) error {
 			callbackInvoked = true
 			return nil
 		},
+		OldPrefix: "x1/",
+		NewPrefix: "y1/",
 	}
 
 	diff, err := repo.DiffTreeToTree(originalTree, newTree, &opts)
@@ -42,7 +93,19 @@ func TestDiffTreeToTree(t *testing.T) {
 	files := make([]string, 0)
 	hunks := make([]DiffHunk, 0)
 	lines := make([]DiffLine, 0)
+	patches := make([]string, 0)
 	err = diff.ForEach(func(file DiffDelta, progress float64) (DiffForEachHunkCallback, error) {
+		patch, err := diff.Patch(len(patches))
+		if err != nil {
+			return nil, err
+		}
+		defer patch.Free()
+		patchStr, err := patch.String()
+		if err != nil {
+			return nil, err
+		}
+		patches = append(patches, patchStr)
+
 		files = append(files, file.OldFile.Path)
 		return func(hunk DiffHunk) (DiffForEachLineCallback, error) {
 			hunks = append(hunks, hunk)
@@ -83,6 +146,24 @@ func TestDiffTreeToTree(t *testing.T) {
 		t.Fatal("Incorrect lines in diff")
 	}
 
+	if want1, want2 := "x1/README", "y1/README"; !strings.Contains(patches[0], want1) || !strings.Contains(patches[0], want2) {
+		t.Errorf("Diff patch doesn't contain %q or %q\n\n%s", want1, want2, patches[0])
+
+	}
+
+	stats, err := diff.Stats()
+	checkFatal(t, err)
+
+	if stats.Insertions() != 1 {
+		t.Fatal("Incorrect number of insertions in diff")
+	}
+	if stats.Deletions() != 1 {
+		t.Fatal("Incorrect number of deletions in diff")
+	}
+	if stats.FilesChanged() != 1 {
+		t.Fatal("Incorrect number of changed files in diff")
+	}
+
 	errTest := errors.New("test error")
 
 	err = diff.ForEach(func(file DiffDelta, progress float64) (DiffForEachHunkCallback, error) {
@@ -94,3 +175,18 @@ func TestDiffTreeToTree(t *testing.T) {
 	}
 
 }
+
+func createTestTrees(t *testing.T, repo *Repository) (originalTree *Tree, newTree *Tree) {
+	var err error
+	_, originalTreeId := seedTestRepo(t, repo)
+	originalTree, err = repo.LookupTree(originalTreeId)
+
+	checkFatal(t, err)
+
+	_, newTreeId := updateReadme(t, repo, "file changed\n")
+
+	newTree, err = repo.LookupTree(newTreeId)
+	checkFatal(t, err)
+
+	return originalTree, newTree
+}