From e69de8b1173a52354dc49cf1808d73a4a27e27b4 Mon Sep 17 00:00:00 2001
From: Aneurin Barker Snook <a@aneur.in>
Date: Thu, 11 Jul 2024 22:21:19 +0100
Subject: [PATCH] add version.List

---
 list.go         | 19 +++++++++++++++++++
 list_test.go    | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
 parse_test.go   |  4 ++--
 version_test.go |  6 +++---
 4 files changed, 73 insertions(+), 5 deletions(-)
 create mode 100644 list.go
 create mode 100644 list_test.go

diff --git a/list.go b/list.go
new file mode 100644
index 0000000..20deb16
--- /dev/null
+++ b/list.go
@@ -0,0 +1,19 @@
+package version
+
+// List is a slice of versions that implements sort.Interface.
+type List []*Version
+
+func (list List) Len() int {
+	return len(list)
+}
+
+func (list List) Less(i, j int) bool {
+	return list[i].Less(list[j])
+}
+
+func (list List) Swap(i, j int) {
+	a := list[i]
+	b := list[j]
+	list[i] = b
+	list[j] = a
+}
diff --git a/list_test.go b/list_test.go
new file mode 100644
index 0000000..f061d1e
--- /dev/null
+++ b/list_test.go
@@ -0,0 +1,49 @@
+package version
+
+import (
+	"sort"
+	"testing"
+)
+
+func TestListSort(t *testing.T) {
+	type TestCase struct {
+		Input    List
+		Expected List
+	}
+
+	testCases := []TestCase{
+		{
+			Input:    List{MustParse("1.1.1"), MustParse("1.0.1"), MustParse("1.1.0"), MustParse("1.0.0")},
+			Expected: List{MustParse("1.0.0"), MustParse("1.0.1"), MustParse("1.1.0"), MustParse("1.1.1")},
+		},
+		{
+			Input:    List{MustParse("4.0.0"), MustParse("3.0.0"), MustParse("2.0.0"), MustParse("1.0.0")},
+			Expected: List{MustParse("1.0.0"), MustParse("2.0.0"), MustParse("3.0.0"), MustParse("4.0.0")},
+		},
+		{
+			Input:    List{MustParse("2.0.4"), MustParse("1.2.4"), MustParse("1.2.3"), MustParse("1.3.1")},
+			Expected: List{MustParse("1.2.3"), MustParse("1.2.4"), MustParse("1.3.1"), MustParse("2.0.4")},
+		},
+	}
+
+	for i, testCase := range testCases {
+		actual := List{}
+		actual = append(actual, testCase.Input...)
+
+		sort.Stable(actual)
+
+		ok := true
+		for j, v := range actual {
+			expected := testCase.Expected[j]
+			cmp := v.Compare(expected)
+			if cmp != 0 {
+				ok = false
+				t.Errorf("test %d failed at position %d (expected %s, got %s)", i, j, expected, actual)
+			}
+		}
+
+		if ok {
+			t.Logf("test %d passed", i)
+		}
+	}
+}
diff --git a/parse_test.go b/parse_test.go
index b9204f8..0d4fb18 100644
--- a/parse_test.go
+++ b/parse_test.go
@@ -39,14 +39,14 @@ func TestVersion_Parse(t *testing.T) {
 			} else if !errors.Is(err, testCase.Err) {
 				t.Errorf("test %d failed (expected error %q, actual error %q)", i, testCase.Err, err)
 			} else {
-				t.Logf("test %d succeeded with error %q for %q\n", i, testCase.Err, testCase.Input)
+				t.Logf("test %d passed with error %q for %q\n", i, testCase.Err, testCase.Input)
 			}
 		} else if err != nil {
 			t.Errorf("test %d failed (expected error nil, actual error %q)", i, err)
 		} else if actual.Major != testCase.Expected.Major || actual.Minor != testCase.Expected.Minor || actual.Patch != testCase.Expected.Patch || actual.Text != testCase.Expected.Text {
 			t.Errorf("test %d failed (expected %v, actual %v)", i, testCase.Expected, actual)
 		} else {
-			t.Logf("test %d succeeded with %v\n", i, actual)
+			t.Logf("test %d passed with %v\n", i, actual)
 		}
 	}
 }
diff --git a/version_test.go b/version_test.go
index b2e1649..b2a7af7 100644
--- a/version_test.go
+++ b/version_test.go
@@ -29,7 +29,7 @@ func TestVersion_String(t *testing.T) {
 		if actual != testCase.Expected {
 			t.Errorf("test %d failed (expected %s, actual %s)", i, testCase.Expected, actual)
 		} else {
-			t.Logf("test %d succeeded with %s\n", i, actual)
+			t.Logf("test %d passed with %s\n", i, actual)
 		}
 	}
 }
@@ -62,7 +62,7 @@ func TestVersion_Compare(t *testing.T) {
 		if actual != testCase.Expected {
 			t.Errorf("test %d failed (expected %d, actual %d)", i, testCase.Expected, actual)
 		} else {
-			t.Logf("test %d succeeded with %d", i, actual)
+			t.Logf("test %d passed with %d", i, actual)
 		}
 	}
 }
@@ -95,7 +95,7 @@ func TestVersion_Less(t *testing.T) {
 		if actual != testCase.Expected {
 			t.Errorf("test %d failed (expected %v, actual %v)", i, testCase.Expected, actual)
 		} else {
-			t.Logf("test %d succeeded with %v", i, actual)
+			t.Logf("test %d passed with %v", i, actual)
 		}
 	}
 }