First commit

1 files changed, 157 insertions, 0 deletions

diff --git a/pkg/gitdiff/format_roundtrip_test.go b/pkg/gitdiff/format_roundtrip_test.go
new file mode 100644
index 0000000..a230e91
--- /dev/null
+++ b/pkg/gitdiff/format_roundtrip_test.go
@@ -0,0 +1,157 @@
+package gitdiff
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"path/filepath"
+	"slices"
+	"testing"
+)
+
+func TestFormatRoundtrip(t *testing.T) {
+	patches := []struct {
+		File            string
+		SkipTextCompare bool
+	}{
+		{File: "copy.patch"},
+		{File: "copy_modify.patch"},
+		{File: "delete.patch"},
+		{File: "mode.patch"},
+		{File: "mode_modify.patch"},
+		{File: "modify.patch"},
+		{File: "new.patch"},
+		{File: "new_empty.patch"},
+		{File: "new_mode.patch"},
+		{File: "rename.patch"},
+		{File: "rename_modify.patch"},
+
+		// Due to differences between Go's 'encoding/zlib' package and the zlib
+		// C library, binary patches cannot be compared directly as the patch
+		// data is slightly different when re-encoded by Go.
+		{File: "binary_modify.patch", SkipTextCompare: true},
+		{File: "binary_new.patch", SkipTextCompare: true},
+		{File: "binary_modify_nodata.patch"},
+	}
+
+	for _, patch := range patches {
+		t.Run(patch.File, func(t *testing.T) {
+			b, err := os.ReadFile(filepath.Join("testdata", "string", patch.File))
+			if err != nil {
+				t.Fatalf("failed to read patch: %v", err)
+			}
+
+			original := assertParseSingleFile(t, b, "patch")
+			str := original.String()
+
+			if !patch.SkipTextCompare {
+				if string(b) != str {
+					t.Errorf("incorrect patch text\nexpected: %q\n  actual: %q\n", string(b), str)
+				}
+			}
+
+			reparsed := assertParseSingleFile(t, []byte(str), "formatted patch")
+			assertFilesEqual(t, original, reparsed)
+		})
+	}
+}
+
+func assertParseSingleFile(t *testing.T, b []byte, kind string) *File {
+	files, _, err := Parse(bytes.NewReader(b))
+	if err != nil {
+		t.Fatalf("failed to parse %s: %v", kind, err)
+	}
+	if len(files) != 1 {
+		t.Fatalf("expected %s to contain a single files, but found %d", kind, len(files))
+	}
+	return files[0]
+}
+
+func assertFilesEqual(t *testing.T, expected, actual *File) {
+	assertEqual(t, expected.OldName, actual.OldName, "OldName")
+	assertEqual(t, expected.NewName, actual.NewName, "NewName")
+
+	assertEqual(t, expected.IsNew, actual.IsNew, "IsNew")
+	assertEqual(t, expected.IsDelete, actual.IsDelete, "IsDelete")
+	assertEqual(t, expected.IsCopy, actual.IsCopy, "IsCopy")
+	assertEqual(t, expected.IsRename, actual.IsRename, "IsRename")
+
+	assertEqual(t, expected.OldMode, actual.OldMode, "OldMode")
+	assertEqual(t, expected.NewMode, actual.NewMode, "NewMode")
+
+	assertEqual(t, expected.OldOIDPrefix, actual.OldOIDPrefix, "OldOIDPrefix")
+	assertEqual(t, expected.NewOIDPrefix, actual.NewOIDPrefix, "NewOIDPrefix")
+	assertEqual(t, expected.Score, actual.Score, "Score")
+
+	if len(expected.TextFragments) == len(actual.TextFragments) {
+		for i := range expected.TextFragments {
+			prefix := fmt.Sprintf("TextFragments[%d].", i)
+			ef := expected.TextFragments[i]
+			af := actual.TextFragments[i]
+
+			assertEqual(t, ef.Comment, af.Comment, prefix+"Comment")
+
+			assertEqual(t, ef.OldPosition, af.OldPosition, prefix+"OldPosition")
+			assertEqual(t, ef.OldLines, af.OldLines, prefix+"OldLines")
+
+			assertEqual(t, ef.NewPosition, af.NewPosition, prefix+"NewPosition")
+			assertEqual(t, ef.NewLines, af.NewLines, prefix+"NewLines")
+
+			assertEqual(t, ef.LinesAdded, af.LinesAdded, prefix+"LinesAdded")
+			assertEqual(t, ef.LinesDeleted, af.LinesDeleted, prefix+"LinesDeleted")
+
+			assertEqual(t, ef.LeadingContext, af.LeadingContext, prefix+"LeadingContext")
+			assertEqual(t, ef.TrailingContext, af.TrailingContext, prefix+"TrailingContext")
+
+			if !slices.Equal(ef.Lines, af.Lines) {
+				t.Errorf("%sLines: expected %#v, actual %#v", prefix, ef.Lines, af.Lines)
+			}
+		}
+	} else {
+		t.Errorf("TextFragments: expected length %d, actual length %d", len(expected.TextFragments), len(actual.TextFragments))
+	}
+
+	assertEqual(t, expected.IsBinary, actual.IsBinary, "IsBinary")
+
+	if expected.BinaryFragment != nil {
+		if actual.BinaryFragment == nil {
+			t.Errorf("BinaryFragment: expected non-nil, actual is nil")
+		} else {
+			ef := expected.BinaryFragment
+			af := expected.BinaryFragment
+
+			assertEqual(t, ef.Method, af.Method, "BinaryFragment.Method")
+			assertEqual(t, ef.Size, af.Size, "BinaryFragment.Size")
+
+			if !slices.Equal(ef.Data, af.Data) {
+				t.Errorf("BinaryFragment.Data: expected %#v, actual %#v", ef.Data, af.Data)
+			}
+		}
+	} else if actual.BinaryFragment != nil {
+		t.Errorf("BinaryFragment: expected nil, actual is non-nil")
+	}
+
+	if expected.ReverseBinaryFragment != nil {
+		if actual.ReverseBinaryFragment == nil {
+			t.Errorf("ReverseBinaryFragment: expected non-nil, actual is nil")
+		} else {
+			ef := expected.ReverseBinaryFragment
+			af := expected.ReverseBinaryFragment
+
+			assertEqual(t, ef.Method, af.Method, "ReverseBinaryFragment.Method")
+			assertEqual(t, ef.Size, af.Size, "ReverseBinaryFragment.Size")
+
+			if !slices.Equal(ef.Data, af.Data) {
+				t.Errorf("ReverseBinaryFragment.Data: expected %#v, actual %#v", ef.Data, af.Data)
+			}
+		}
+	} else if actual.ReverseBinaryFragment != nil {
+		t.Errorf("ReverseBinaryFragment: expected nil, actual is non-nil")
+	}
+}
+
+func assertEqual[T comparable](t *testing.T, expected, actual T, name string) {
+	if expected != actual {
+		t.Errorf("%s: expected %#v, actual %#v", name, expected, actual)
+	}
+}