Add missing Compare funcs (go-chrono#25)

* Refactor test names.

* Rename variable.

* Rename test variable.

* Implement Duration.Compare.

* Rename variable.

* Remove unused function.

* Fix typos.

* Rename test variables.

* Implement Instant.Compare.

* Revert "Remove unused function."

This reverts commit bd31c7a.

* Add tests for Instant.Compare.

Author: joe-mann

duration.go

@@ -23,9 +23,21 @@ func DurationOf(v Extent) Duration {
 	}
 }
 
-// Equal reports whether d and d2 represent the same duration of time.
-func (d Duration) Equal(d2 Duration) bool {
-	return d2.secs == d.secs && d2.nsec == d.nsec
+// Compare compares d with d2. If d is less than d2, it returns -1;
+// if d is greater than d2, it returns 1; if they're equal, it returns 0.
+func (d Duration) Compare(d2 Duration) int {
+	switch {
+	case d.secs < d2.secs:
+		return -1
+	case d.secs > d2.secs:
+		return 1
+	case d.nsec < d2.nsec:
+		return -1
+	case d.nsec > d2.nsec:
+		return 1
+	default:
+		return 0
+	}
 }
 
 // Add returns the duration d+d2.

duration_test.go

@@ -175,6 +175,27 @@ func TestDuration_units(t *testing.T) {
 	}
 }
 
+func TestDuration_Compare(t *testing.T) {
+	for _, tt := range []struct {
+		name     string
+		d        chrono.Duration
+		d2       chrono.Duration
+		expected int
+	}{
+		{"seconds less", chrono.DurationOf(1 * chrono.Hour), chrono.DurationOf(2 * chrono.Hour), -1},
+		{"seconds more", chrono.DurationOf(2 * chrono.Hour), chrono.DurationOf(1 * chrono.Hour), 1},
+		{"nanos less", chrono.DurationOf(1 * chrono.Nanosecond), chrono.DurationOf(2 * chrono.Nanosecond), -1},
+		{"nanos more", chrono.DurationOf(2 * chrono.Nanosecond), chrono.DurationOf(1 * chrono.Nanosecond), 1},
+		{"equal", chrono.DurationOf(chrono.Minute), chrono.DurationOf(chrono.Minute), 0},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			if v := tt.d.Compare(tt.d2); v != tt.expected {
+				t.Errorf("d.Compare(d2) = %d, want %d", v, tt.expected)
+			}
+		})
+	}
+}
+
 func TestDuration_Add(t *testing.T) {
 	for _, tt := range []struct {
 		name     string
@@ -226,7 +247,7 @@ func TestDuration_Add(t *testing.T) {
 				}
 
 				d := tt.d1.Add(tt.d2)
-				if !d.Equal(tt.expected) {
+				if d.Compare(tt.expected) != 0 {
 					t.Fatalf("d1.Add(d2) = %v, want %v", d, tt.expected)
 				}
 			})
@@ -237,7 +258,7 @@ func TestDuration_Add(t *testing.T) {
 				}
 
 				d := tt.d2.Add(tt.d1)
-				if !d.Equal(tt.expected) {
+				if d.Compare(tt.expected) != 0 {
 					t.Fatalf("d2.Add(d1) = %v, want %v", d, tt.expected)
 				}
 			})
@@ -536,7 +557,7 @@ func TestDuration_Parse(t *testing.T) {
 			var d chrono.Duration
 			if err := d.Parse(tt.input); err != nil {
 				t.Fatalf("failed to parse duation: %v", err)
-			} else if !d.Equal(tt.expected) {
+			} else if d.Compare(tt.expected) != 0 {
 				t.Fatalf("parsed duration = %v, want %v", d, tt.expected)
 			}
 		})

instant.go

@@ -15,6 +15,23 @@ func Now() Instant {
 	}
 }
 
+// Compare compares i with i2. If i is before i2, it returns -1;
+// if i is after i2, it returns 1; if they're the same, it returns 0.
+func (i Instant) Compare(i2 Instant) int {
+	switch {
+	case i.v == nil:
+		panic("i is not initialized")
+	case i2.v == nil:
+		panic("i2 is not initialized")
+	case *i.v < *i2.v:
+		return -1
+	case *i.v > *i2.v:
+		return 1
+	default:
+		return 0
+	}
+}
+
 // Elapsed is shorthand for i.Until(chrono.Now()).
 func (i Instant) Elapsed() Duration {
 	return i.Until(Now())
@@ -25,15 +42,15 @@ func (i Instant) String() string {
 }
 
 // Until returns the Duration that represents the elapsed time from i to v.
-func (i Instant) Until(v Instant) Duration {
+func (i Instant) Until(i2 Instant) Duration {
 	switch {
 	case i.v == nil:
 		panic("i is not initialized")
-	case v.v == nil:
-		panic("v is not initialized")
+	case i2.v == nil:
+		panic("i2 is not initialized")
 	}
 
-	iv, vv := *i.v, *v.v
+	iv, vv := *i.v, *i2.v
 	if vv < iv {
 		panic("v is smaller than i")
 	}
@@ -45,6 +62,7 @@ func (i Instant) Until(v Instant) Duration {
 	}
 }
 
+// instant is used by the chronotest package.
 func instant(t int64) Instant {
 	return Instant{
 		v: &t,

instant_test.go

@@ -3,6 +3,7 @@ package chrono_test
 import (
 	"testing"
 
+	"github.com/go-chrono/chrono"
 	chronotest "github.com/go-chrono/chrono/test"
 )
 
@@ -13,6 +14,25 @@ func TestInstant_String(t *testing.T) {
 	}
 }
 
+func TestInstant_Compare(t *testing.T) {
+	for _, tt := range []struct {
+		name     string
+		i        chrono.Instant
+		i2       chrono.Instant
+		expected int
+	}{
+		{"earlier", chronotest.InstantOf(11e14), chronotest.InstantOf(12e14), -1},
+		{"later", chronotest.InstantOf(12e14), chronotest.InstantOf(11e14), 1},
+		{"equal", chronotest.InstantOf(11e14), chronotest.InstantOf(11e14), 0},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			if v := tt.i.Compare(tt.i2); v != tt.expected {
+				t.Errorf("i.Compare(i2) = %d, want %d", v, tt.expected)
+			}
+		})
+	}
+}
+
 func TestInstant_Until(t *testing.T) {
 	i := chronotest.InstantOf(11e14)
 	d := i.Until(chronotest.InstantOf(12e14))

local_time.go

@@ -73,13 +73,13 @@ func (t LocalTime) Add(v Extent) LocalTime {
 	return LocalTime{v: out}
 }
 
-// Compare compares t with u. If t is before u, it returns -1;
-// if t is after u, it returns 1; if they're the same, it returns 0.
-func (t LocalTime) Compare(u LocalTime) int {
+// Compare compares t with t2. If t is before t2, it returns -1;
+// if t is after t2, it returns 1; if they're the same, it returns 0.
+func (t LocalTime) Compare(t2 LocalTime) int {
 	switch {
-	case t.v < u.v:
+	case t.v < t2.v:
 		return -1
-	case t.v > u.v:
+	case t.v > t2.v:
 		return 1
 	default:
 		return 0

local_time_test.go

@@ -79,16 +79,16 @@ func TestLocalTime_Compare(t *testing.T) {
 	for _, tt := range []struct {
 		name     string
 		t        chrono.LocalTime
-		u        chrono.LocalTime
+		t2       chrono.LocalTime
 		expected int
 	}{
 		{"earlier", chrono.LocalTimeOf(11, 0, 0, 0), chrono.LocalTimeOf(12, 0, 0, 0), -1},
 		{"later", chrono.LocalTimeOf(13, 30, 0, 0), chrono.LocalTimeOf(13, 29, 55, 0), 1},
 		{"equal", chrono.LocalTimeOf(15, 0, 0, 1000), chrono.LocalTimeOf(15, 0, 0, 1000), 0},
 	} {
 		t.Run(tt.name, func(t *testing.T) {
-			if v := tt.t.Compare(tt.u); v != tt.expected {
-				t.Errorf("t.Compare(u) = %d, want %d", v, tt.expected)
+			if v := tt.t.Compare(tt.t2); v != tt.expected {
+				t.Errorf("t.Compare(t2) = %d, want %d", v, tt.expected)
 			}
 		})
 	}

period_test.go

@@ -204,7 +204,7 @@ func TestParseDuration(t *testing.T) {
 				t.Fatalf("failed to parse period & duration: %v", err)
 			} else if !p.Equal(tt.period) {
 				t.Fatalf("parsed period = %v, want %v", p, tt.period)
-			} else if !d.Equal(tt.duration) {
+			} else if d.Compare(tt.duration) != 0 {
 				t.Fatalf("parsed duration = %v, want %v", d, tt.duration)
 			}
 		})