Oliver Jakoubek
889e78da90
Reorganized test suite with consolidated benchmarks and comprehensive edge case coverage, exceeding 95% minimum coverage requirement. Changes: - Created benchmark_test.go with all 52 benchmarks organized by category (arithmetic, clock, date, diff, format, inspection, parse, snap, unit) - Removed benchmarks from 9 individual test files for better organization - Added 6 edge case tests to improve coverage: * Format() unknown type fallback * formatLong() empty lang default * Format.String() unknown value * isYearPrefix() edge cases * StartOf()/EndOf() unsupported units - Added 3 DST transition tests: * Spring forward (23-hour day) * Fall back (25-hour day) * Multiple timezone preservation Results: - Test coverage: 97.7% → 99.5% (exceeds 95% target) - All 52 benchmarks consolidated and verified - All benchmarks meet performance targets - No test regressions Files modified: - Created: benchmark_test.go (580 lines) - Modified: 9 test files (removed benchmarks, added tests)
755 lines
20 KiB
Go
755 lines
20 KiB
Go
package quando
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestStartOfWeek(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
date Date
|
|
expected string // Expected Monday
|
|
}{
|
|
{
|
|
name: "Monday stays Monday",
|
|
date: From(time.Date(2026, 2, 9, 15, 30, 45, 0, time.UTC)), // Monday
|
|
expected: "2026-02-09 00:00:00",
|
|
},
|
|
{
|
|
name: "Tuesday goes to Monday",
|
|
date: From(time.Date(2026, 2, 10, 15, 30, 45, 0, time.UTC)), // Tuesday
|
|
expected: "2026-02-09 00:00:00",
|
|
},
|
|
{
|
|
name: "Wednesday goes to Monday",
|
|
date: From(time.Date(2026, 2, 11, 15, 30, 45, 0, time.UTC)), // Wednesday
|
|
expected: "2026-02-09 00:00:00",
|
|
},
|
|
{
|
|
name: "Sunday goes to Monday",
|
|
date: From(time.Date(2026, 2, 15, 15, 30, 45, 0, time.UTC)), // Sunday
|
|
expected: "2026-02-09 00:00:00",
|
|
},
|
|
{
|
|
name: "Saturday goes to Monday",
|
|
date: From(time.Date(2026, 2, 14, 15, 30, 45, 0, time.UTC)), // Saturday
|
|
expected: "2026-02-09 00:00:00",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := tt.date.StartOf(Weeks)
|
|
if result.String() != tt.expected {
|
|
t.Errorf("StartOf(Weeks) = %v, want %v", result, tt.expected)
|
|
}
|
|
|
|
// Verify it's Monday
|
|
if result.Time().Weekday() != time.Monday {
|
|
t.Errorf("StartOf(Weeks) weekday = %v, want Monday", result.Time().Weekday())
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEndOfWeek(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
date Date
|
|
expected string // Expected Sunday
|
|
}{
|
|
{
|
|
name: "Monday goes to Sunday",
|
|
date: From(time.Date(2026, 2, 9, 15, 30, 45, 0, time.UTC)), // Monday
|
|
expected: "2026-02-15 23:59:59",
|
|
},
|
|
{
|
|
name: "Sunday stays Sunday",
|
|
date: From(time.Date(2026, 2, 15, 15, 30, 45, 0, time.UTC)), // Sunday
|
|
expected: "2026-02-15 23:59:59",
|
|
},
|
|
{
|
|
name: "Saturday goes to Sunday",
|
|
date: From(time.Date(2026, 2, 14, 15, 30, 45, 0, time.UTC)), // Saturday
|
|
expected: "2026-02-15 23:59:59",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := tt.date.EndOf(Weeks)
|
|
if result.String() != tt.expected {
|
|
t.Errorf("EndOf(Weeks) = %v, want %v", result, tt.expected)
|
|
}
|
|
|
|
// Verify it's Sunday
|
|
if result.Time().Weekday() != time.Sunday {
|
|
t.Errorf("EndOf(Weeks) weekday = %v, want Sunday", result.Time().Weekday())
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestStartOfMonth(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
date Date
|
|
expected string
|
|
}{
|
|
{
|
|
name: "mid-month",
|
|
date: From(time.Date(2026, 2, 15, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-02-01 00:00:00",
|
|
},
|
|
{
|
|
name: "first day",
|
|
date: From(time.Date(2026, 2, 1, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-02-01 00:00:00",
|
|
},
|
|
{
|
|
name: "last day",
|
|
date: From(time.Date(2026, 2, 28, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-02-01 00:00:00",
|
|
},
|
|
{
|
|
name: "31-day month",
|
|
date: From(time.Date(2026, 1, 31, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-01-01 00:00:00",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := tt.date.StartOf(Months)
|
|
if result.String() != tt.expected {
|
|
t.Errorf("StartOf(Months) = %v, want %v", result, tt.expected)
|
|
}
|
|
|
|
// Verify it's day 1
|
|
if result.Time().Day() != 1 {
|
|
t.Errorf("StartOf(Months) day = %d, want 1", result.Time().Day())
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEndOfMonth(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
date Date
|
|
expectedDay int
|
|
}{
|
|
{
|
|
name: "February non-leap",
|
|
date: From(time.Date(2026, 2, 15, 15, 30, 45, 0, time.UTC)),
|
|
expectedDay: 28,
|
|
},
|
|
{
|
|
name: "February leap year",
|
|
date: From(time.Date(2024, 2, 15, 15, 30, 45, 0, time.UTC)),
|
|
expectedDay: 29,
|
|
},
|
|
{
|
|
name: "30-day month (April)",
|
|
date: From(time.Date(2026, 4, 15, 15, 30, 45, 0, time.UTC)),
|
|
expectedDay: 30,
|
|
},
|
|
{
|
|
name: "31-day month (January)",
|
|
date: From(time.Date(2026, 1, 15, 15, 30, 45, 0, time.UTC)),
|
|
expectedDay: 31,
|
|
},
|
|
{
|
|
name: "31-day month (December)",
|
|
date: From(time.Date(2026, 12, 15, 15, 30, 45, 0, time.UTC)),
|
|
expectedDay: 31,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := tt.date.EndOf(Months)
|
|
|
|
// Verify correct day
|
|
if result.Time().Day() != tt.expectedDay {
|
|
t.Errorf("EndOf(Months) day = %d, want %d", result.Time().Day(), tt.expectedDay)
|
|
}
|
|
|
|
// Verify time is 23:59:59
|
|
if result.Time().Hour() != 23 || result.Time().Minute() != 59 || result.Time().Second() != 59 {
|
|
t.Errorf("EndOf(Months) time = %02d:%02d:%02d, want 23:59:59",
|
|
result.Time().Hour(), result.Time().Minute(), result.Time().Second())
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestStartOfQuarter(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
date Date
|
|
expected string
|
|
}{
|
|
{
|
|
name: "Q1 January",
|
|
date: From(time.Date(2026, 1, 15, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-01-01 00:00:00",
|
|
},
|
|
{
|
|
name: "Q1 February",
|
|
date: From(time.Date(2026, 2, 15, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-01-01 00:00:00",
|
|
},
|
|
{
|
|
name: "Q1 March",
|
|
date: From(time.Date(2026, 3, 15, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-01-01 00:00:00",
|
|
},
|
|
{
|
|
name: "Q2 April",
|
|
date: From(time.Date(2026, 4, 15, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-04-01 00:00:00",
|
|
},
|
|
{
|
|
name: "Q2 May",
|
|
date: From(time.Date(2026, 5, 15, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-04-01 00:00:00",
|
|
},
|
|
{
|
|
name: "Q2 June",
|
|
date: From(time.Date(2026, 6, 15, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-04-01 00:00:00",
|
|
},
|
|
{
|
|
name: "Q3 July",
|
|
date: From(time.Date(2026, 7, 15, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-07-01 00:00:00",
|
|
},
|
|
{
|
|
name: "Q3 August",
|
|
date: From(time.Date(2026, 8, 15, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-07-01 00:00:00",
|
|
},
|
|
{
|
|
name: "Q3 September",
|
|
date: From(time.Date(2026, 9, 15, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-07-01 00:00:00",
|
|
},
|
|
{
|
|
name: "Q4 October",
|
|
date: From(time.Date(2026, 10, 15, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-10-01 00:00:00",
|
|
},
|
|
{
|
|
name: "Q4 November",
|
|
date: From(time.Date(2026, 11, 15, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-10-01 00:00:00",
|
|
},
|
|
{
|
|
name: "Q4 December",
|
|
date: From(time.Date(2026, 12, 15, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-10-01 00:00:00",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := tt.date.StartOf(Quarters)
|
|
if result.String() != tt.expected {
|
|
t.Errorf("StartOf(Quarters) = %v, want %v", result, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEndOfQuarter(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
date Date
|
|
expectedMonth time.Month
|
|
expectedDay int
|
|
}{
|
|
{
|
|
name: "Q1 January",
|
|
date: From(time.Date(2026, 1, 15, 15, 30, 45, 0, time.UTC)),
|
|
expectedMonth: time.March,
|
|
expectedDay: 31,
|
|
},
|
|
{
|
|
name: "Q1 February",
|
|
date: From(time.Date(2026, 2, 15, 15, 30, 45, 0, time.UTC)),
|
|
expectedMonth: time.March,
|
|
expectedDay: 31,
|
|
},
|
|
{
|
|
name: "Q1 March",
|
|
date: From(time.Date(2026, 3, 15, 15, 30, 45, 0, time.UTC)),
|
|
expectedMonth: time.March,
|
|
expectedDay: 31,
|
|
},
|
|
{
|
|
name: "Q2 April",
|
|
date: From(time.Date(2026, 4, 15, 15, 30, 45, 0, time.UTC)),
|
|
expectedMonth: time.June,
|
|
expectedDay: 30,
|
|
},
|
|
{
|
|
name: "Q2 June",
|
|
date: From(time.Date(2026, 6, 15, 15, 30, 45, 0, time.UTC)),
|
|
expectedMonth: time.June,
|
|
expectedDay: 30,
|
|
},
|
|
{
|
|
name: "Q3 July",
|
|
date: From(time.Date(2026, 7, 15, 15, 30, 45, 0, time.UTC)),
|
|
expectedMonth: time.September,
|
|
expectedDay: 30,
|
|
},
|
|
{
|
|
name: "Q3 September",
|
|
date: From(time.Date(2026, 9, 15, 15, 30, 45, 0, time.UTC)),
|
|
expectedMonth: time.September,
|
|
expectedDay: 30,
|
|
},
|
|
{
|
|
name: "Q4 October",
|
|
date: From(time.Date(2026, 10, 15, 15, 30, 45, 0, time.UTC)),
|
|
expectedMonth: time.December,
|
|
expectedDay: 31,
|
|
},
|
|
{
|
|
name: "Q4 December",
|
|
date: From(time.Date(2026, 12, 15, 15, 30, 45, 0, time.UTC)),
|
|
expectedMonth: time.December,
|
|
expectedDay: 31,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := tt.date.EndOf(Quarters)
|
|
|
|
// Verify correct month and day
|
|
if result.Time().Month() != tt.expectedMonth {
|
|
t.Errorf("EndOf(Quarters) month = %v, want %v", result.Time().Month(), tt.expectedMonth)
|
|
}
|
|
if result.Time().Day() != tt.expectedDay {
|
|
t.Errorf("EndOf(Quarters) day = %d, want %d", result.Time().Day(), tt.expectedDay)
|
|
}
|
|
|
|
// Verify time is 23:59:59
|
|
if result.Time().Hour() != 23 || result.Time().Minute() != 59 || result.Time().Second() != 59 {
|
|
t.Errorf("EndOf(Quarters) time = %02d:%02d:%02d, want 23:59:59",
|
|
result.Time().Hour(), result.Time().Minute(), result.Time().Second())
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestStartOfYear(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
date Date
|
|
expected string
|
|
}{
|
|
{
|
|
name: "mid-year",
|
|
date: From(time.Date(2026, 6, 15, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-01-01 00:00:00",
|
|
},
|
|
{
|
|
name: "start of year",
|
|
date: From(time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)),
|
|
expected: "2026-01-01 00:00:00",
|
|
},
|
|
{
|
|
name: "end of year",
|
|
date: From(time.Date(2026, 12, 31, 23, 59, 59, 0, time.UTC)),
|
|
expected: "2026-01-01 00:00:00",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := tt.date.StartOf(Years)
|
|
if result.String() != tt.expected {
|
|
t.Errorf("StartOf(Years) = %v, want %v", result, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEndOfYear(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
date Date
|
|
expected string
|
|
}{
|
|
{
|
|
name: "mid-year",
|
|
date: From(time.Date(2026, 6, 15, 15, 30, 45, 0, time.UTC)),
|
|
expected: "2026-12-31 23:59:59",
|
|
},
|
|
{
|
|
name: "start of year",
|
|
date: From(time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)),
|
|
expected: "2026-12-31 23:59:59",
|
|
},
|
|
{
|
|
name: "end of year",
|
|
date: From(time.Date(2026, 12, 31, 23, 59, 59, 0, time.UTC)),
|
|
expected: "2026-12-31 23:59:59",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := tt.date.EndOf(Years)
|
|
if result.String() != tt.expected {
|
|
t.Errorf("EndOf(Years) = %v, want %v", result, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestSnapImmutability verifies that snap operations don't modify the original date
|
|
func TestSnapImmutability(t *testing.T) {
|
|
original := From(time.Date(2026, 2, 15, 15, 30, 45, 0, time.UTC))
|
|
originalTime := original.Time()
|
|
|
|
_ = original.StartOf(Weeks)
|
|
_ = original.EndOf(Weeks)
|
|
_ = original.StartOf(Months)
|
|
_ = original.EndOf(Months)
|
|
_ = original.StartOf(Quarters)
|
|
_ = original.EndOf(Quarters)
|
|
_ = original.StartOf(Years)
|
|
_ = original.EndOf(Years)
|
|
|
|
if !original.Time().Equal(originalTime) {
|
|
t.Error("Snap operations modified the original date")
|
|
}
|
|
}
|
|
|
|
// TestSnapTimezones verifies that snap operations preserve timezone
|
|
func TestSnapTimezones(t *testing.T) {
|
|
loc, err := time.LoadLocation("Europe/Berlin")
|
|
if err != nil {
|
|
t.Skipf("Skipping timezone test: %v", err)
|
|
}
|
|
|
|
berlinTime := time.Date(2026, 2, 15, 15, 30, 45, 0, loc)
|
|
date := From(berlinTime)
|
|
|
|
operations := []struct {
|
|
name string
|
|
result Date
|
|
}{
|
|
{"StartOf(Weeks)", date.StartOf(Weeks)},
|
|
{"EndOf(Weeks)", date.EndOf(Weeks)},
|
|
{"StartOf(Months)", date.StartOf(Months)},
|
|
{"EndOf(Months)", date.EndOf(Months)},
|
|
{"StartOf(Quarters)", date.StartOf(Quarters)},
|
|
{"EndOf(Quarters)", date.EndOf(Quarters)},
|
|
{"StartOf(Years)", date.StartOf(Years)},
|
|
{"EndOf(Years)", date.EndOf(Years)},
|
|
}
|
|
|
|
for _, op := range operations {
|
|
t.Run(op.name, func(t *testing.T) {
|
|
if op.result.Time().Location() != loc {
|
|
t.Errorf("%s location = %v, want %v", op.name, op.result.Time().Location(), loc)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
|
|
// TestNext tests the Next() method for all weekdays
|
|
func TestNext(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
date Date
|
|
targetDay time.Weekday
|
|
expectedDay time.Weekday
|
|
daysLater int
|
|
}{
|
|
// Monday as starting point
|
|
{
|
|
name: "Monday -> next Monday (same day, 7 days later)",
|
|
date: From(time.Date(2026, 2, 9, 15, 30, 0, 0, time.UTC)), // Monday
|
|
targetDay: time.Monday,
|
|
expectedDay: time.Monday,
|
|
daysLater: 7,
|
|
},
|
|
{
|
|
name: "Monday -> next Tuesday",
|
|
date: From(time.Date(2026, 2, 9, 15, 30, 0, 0, time.UTC)), // Monday
|
|
targetDay: time.Tuesday,
|
|
expectedDay: time.Tuesday,
|
|
daysLater: 1,
|
|
},
|
|
{
|
|
name: "Monday -> next Friday",
|
|
date: From(time.Date(2026, 2, 9, 15, 30, 0, 0, time.UTC)), // Monday
|
|
targetDay: time.Friday,
|
|
expectedDay: time.Friday,
|
|
daysLater: 4,
|
|
},
|
|
{
|
|
name: "Monday -> next Sunday",
|
|
date: From(time.Date(2026, 2, 9, 15, 30, 0, 0, time.UTC)), // Monday
|
|
targetDay: time.Sunday,
|
|
expectedDay: time.Sunday,
|
|
daysLater: 6,
|
|
},
|
|
// Friday as starting point
|
|
{
|
|
name: "Friday -> next Friday (same day, 7 days later)",
|
|
date: From(time.Date(2026, 2, 13, 15, 30, 0, 0, time.UTC)), // Friday
|
|
targetDay: time.Friday,
|
|
expectedDay: time.Friday,
|
|
daysLater: 7,
|
|
},
|
|
{
|
|
name: "Friday -> next Monday",
|
|
date: From(time.Date(2026, 2, 13, 15, 30, 0, 0, time.UTC)), // Friday
|
|
targetDay: time.Monday,
|
|
expectedDay: time.Monday,
|
|
daysLater: 3,
|
|
},
|
|
{
|
|
name: "Friday -> next Thursday",
|
|
date: From(time.Date(2026, 2, 13, 15, 30, 0, 0, time.UTC)), // Friday
|
|
targetDay: time.Thursday,
|
|
expectedDay: time.Thursday,
|
|
daysLater: 6,
|
|
},
|
|
// Sunday as starting point
|
|
{
|
|
name: "Sunday -> next Sunday (same day, 7 days later)",
|
|
date: From(time.Date(2026, 2, 15, 15, 30, 0, 0, time.UTC)), // Sunday
|
|
targetDay: time.Sunday,
|
|
expectedDay: time.Sunday,
|
|
daysLater: 7,
|
|
},
|
|
{
|
|
name: "Sunday -> next Monday",
|
|
date: From(time.Date(2026, 2, 15, 15, 30, 0, 0, time.UTC)), // Sunday
|
|
targetDay: time.Monday,
|
|
expectedDay: time.Monday,
|
|
daysLater: 1,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := tt.date.Next(tt.targetDay)
|
|
|
|
// Verify correct weekday
|
|
if result.Time().Weekday() != tt.expectedDay {
|
|
t.Errorf("Next(%v) weekday = %v, want %v", tt.targetDay, result.Time().Weekday(), tt.expectedDay)
|
|
}
|
|
|
|
// Verify it's in the future
|
|
if !result.Time().After(tt.date.Time()) {
|
|
t.Errorf("Next(%v) = %v, should be after %v", tt.targetDay, result, tt.date)
|
|
}
|
|
|
|
// Verify correct number of days
|
|
daysDiff := int(result.Time().Sub(tt.date.Time()).Hours() / 24)
|
|
if daysDiff != tt.daysLater {
|
|
t.Errorf("Next(%v) is %d days later, want %d", tt.targetDay, daysDiff, tt.daysLater)
|
|
}
|
|
|
|
// Verify time of day is preserved
|
|
if result.Time().Hour() != tt.date.Time().Hour() ||
|
|
result.Time().Minute() != tt.date.Time().Minute() {
|
|
t.Errorf("Next(%v) time = %02d:%02d, want %02d:%02d",
|
|
tt.targetDay,
|
|
result.Time().Hour(), result.Time().Minute(),
|
|
tt.date.Time().Hour(), tt.date.Time().Minute())
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestPrev tests the Prev() method for all weekdays
|
|
func TestPrev(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
date Date
|
|
targetDay time.Weekday
|
|
expectedDay time.Weekday
|
|
daysEarlier int
|
|
}{
|
|
// Monday as starting point
|
|
{
|
|
name: "Monday -> prev Monday (same day, 7 days earlier)",
|
|
date: From(time.Date(2026, 2, 9, 15, 30, 0, 0, time.UTC)), // Monday
|
|
targetDay: time.Monday,
|
|
expectedDay: time.Monday,
|
|
daysEarlier: 7,
|
|
},
|
|
{
|
|
name: "Monday -> prev Friday",
|
|
date: From(time.Date(2026, 2, 9, 15, 30, 0, 0, time.UTC)), // Monday
|
|
targetDay: time.Friday,
|
|
expectedDay: time.Friday,
|
|
daysEarlier: 3,
|
|
},
|
|
{
|
|
name: "Monday -> prev Sunday",
|
|
date: From(time.Date(2026, 2, 9, 15, 30, 0, 0, time.UTC)), // Monday
|
|
targetDay: time.Sunday,
|
|
expectedDay: time.Sunday,
|
|
daysEarlier: 1,
|
|
},
|
|
{
|
|
name: "Monday -> prev Tuesday",
|
|
date: From(time.Date(2026, 2, 9, 15, 30, 0, 0, time.UTC)), // Monday
|
|
targetDay: time.Tuesday,
|
|
expectedDay: time.Tuesday,
|
|
daysEarlier: 6,
|
|
},
|
|
// Friday as starting point
|
|
{
|
|
name: "Friday -> prev Friday (same day, 7 days earlier)",
|
|
date: From(time.Date(2026, 2, 13, 15, 30, 0, 0, time.UTC)), // Friday
|
|
targetDay: time.Friday,
|
|
expectedDay: time.Friday,
|
|
daysEarlier: 7,
|
|
},
|
|
{
|
|
name: "Friday -> prev Monday",
|
|
date: From(time.Date(2026, 2, 13, 15, 30, 0, 0, time.UTC)), // Friday
|
|
targetDay: time.Monday,
|
|
expectedDay: time.Monday,
|
|
daysEarlier: 4,
|
|
},
|
|
{
|
|
name: "Friday -> prev Thursday",
|
|
date: From(time.Date(2026, 2, 13, 15, 30, 0, 0, time.UTC)), // Friday
|
|
targetDay: time.Thursday,
|
|
expectedDay: time.Thursday,
|
|
daysEarlier: 1,
|
|
},
|
|
// Sunday as starting point
|
|
{
|
|
name: "Sunday -> prev Sunday (same day, 7 days earlier)",
|
|
date: From(time.Date(2026, 2, 15, 15, 30, 0, 0, time.UTC)), // Sunday
|
|
targetDay: time.Sunday,
|
|
expectedDay: time.Sunday,
|
|
daysEarlier: 7,
|
|
},
|
|
{
|
|
name: "Sunday -> prev Saturday",
|
|
date: From(time.Date(2026, 2, 15, 15, 30, 0, 0, time.UTC)), // Sunday
|
|
targetDay: time.Saturday,
|
|
expectedDay: time.Saturday,
|
|
daysEarlier: 1,
|
|
},
|
|
{
|
|
name: "Sunday -> prev Monday",
|
|
date: From(time.Date(2026, 2, 15, 15, 30, 0, 0, time.UTC)), // Sunday
|
|
targetDay: time.Monday,
|
|
expectedDay: time.Monday,
|
|
daysEarlier: 6,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := tt.date.Prev(tt.targetDay)
|
|
|
|
// Verify correct weekday
|
|
if result.Time().Weekday() != tt.expectedDay {
|
|
t.Errorf("Prev(%v) weekday = %v, want %v", tt.targetDay, result.Time().Weekday(), tt.expectedDay)
|
|
}
|
|
|
|
// Verify it's in the past
|
|
if !result.Time().Before(tt.date.Time()) {
|
|
t.Errorf("Prev(%v) = %v, should be before %v", tt.targetDay, result, tt.date)
|
|
}
|
|
|
|
// Verify correct number of days
|
|
daysDiff := int(tt.date.Time().Sub(result.Time()).Hours() / 24)
|
|
if daysDiff != tt.daysEarlier {
|
|
t.Errorf("Prev(%v) is %d days earlier, want %d", tt.targetDay, daysDiff, tt.daysEarlier)
|
|
}
|
|
|
|
// Verify time of day is preserved
|
|
if result.Time().Hour() != tt.date.Time().Hour() ||
|
|
result.Time().Minute() != tt.date.Time().Minute() {
|
|
t.Errorf("Prev(%v) time = %02d:%02d, want %02d:%02d",
|
|
tt.targetDay,
|
|
result.Time().Hour(), result.Time().Minute(),
|
|
tt.date.Time().Hour(), tt.date.Time().Minute())
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestNextPrevImmutability verifies that Next and Prev don't modify the original date
|
|
func TestNextPrevImmutability(t *testing.T) {
|
|
original := From(time.Date(2026, 2, 9, 15, 30, 0, 0, time.UTC))
|
|
originalTime := original.Time()
|
|
|
|
_ = original.Next(time.Friday)
|
|
_ = original.Prev(time.Friday)
|
|
_ = original.Next(time.Monday)
|
|
_ = original.Prev(time.Monday)
|
|
|
|
if !original.Time().Equal(originalTime) {
|
|
t.Error("Next/Prev operations modified the original date")
|
|
}
|
|
}
|
|
|
|
// TestNextPrevTimezones verifies that Next and Prev preserve timezone
|
|
func TestNextPrevTimezones(t *testing.T) {
|
|
loc, err := time.LoadLocation("Europe/Berlin")
|
|
if err != nil {
|
|
t.Skipf("Skipping timezone test: %v", err)
|
|
}
|
|
|
|
berlinTime := time.Date(2026, 2, 9, 15, 30, 0, 0, loc)
|
|
date := From(berlinTime)
|
|
|
|
nextFriday := date.Next(time.Friday)
|
|
prevFriday := date.Prev(time.Friday)
|
|
|
|
if nextFriday.Time().Location() != loc {
|
|
t.Errorf("Next() location = %v, want %v", nextFriday.Time().Location(), loc)
|
|
}
|
|
if prevFriday.Time().Location() != loc {
|
|
t.Errorf("Prev() location = %v, want %v", prevFriday.Time().Location(), loc)
|
|
}
|
|
}
|
|
|
|
// TestStartOf_UnsupportedUnit tests StartOf() with unsupported unit
|
|
func TestStartOf_UnsupportedUnit(t *testing.T) {
|
|
date := From(time.Date(2026, 2, 15, 14, 30, 45, 0, time.UTC))
|
|
|
|
// Seconds is not supported by StartOf
|
|
result := date.StartOf(Seconds)
|
|
|
|
// Should return unchanged date
|
|
if !result.Time().Equal(date.Time()) {
|
|
t.Errorf("StartOf(Seconds) should return unchanged date")
|
|
}
|
|
}
|
|
|
|
// TestEndOf_UnsupportedUnit tests EndOf() with unsupported unit
|
|
func TestEndOf_UnsupportedUnit(t *testing.T) {
|
|
date := From(time.Date(2026, 2, 15, 14, 30, 45, 0, time.UTC))
|
|
|
|
// Seconds is not supported by EndOf
|
|
result := date.EndOf(Seconds)
|
|
|
|
// Should return unchanged date
|
|
if !result.Time().Equal(date.Time()) {
|
|
t.Errorf("EndOf(Seconds) should return unchanged date")
|
|
}
|
|
}
|
|
|