mirror of
https://gitee.com/dromara/carbon.git
synced 2024-12-02 04:07:36 +08:00
1912 lines
33 KiB
Go
Executable File
1912 lines
33 KiB
Go
Executable File
package carbon
|
|
|
|
import (
|
|
"github.com/stretchr/testify/assert"
|
|
"testing"
|
|
)
|
|
|
|
func TestCarbon_IsDST(t *testing.T) {
|
|
tzWithDST, tzWithoutDST := "Australia/Sydney", "Australia/Brisbane"
|
|
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: NewCarbon(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("0000-01-01 00:00:00 +0000 UTC", tzWithDST),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case4",
|
|
carbon: Parse("0001-01-01 00:00:00 +0000 UTC", tzWithDST),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case5",
|
|
carbon: Parse("2009-01-01", tzWithDST),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case6",
|
|
carbon: Parse("2009-01-01", tzWithoutDST),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsDST(), "IsDST()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsZero(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: NewCarbon(),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("0000-01-01 00:00:00 +0000 UTC"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case4",
|
|
carbon: Parse("0001-01-01 00:00:00 +0000 UTC"),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case5",
|
|
carbon: Parse("2020-08-05 00:00:00"),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsZero(), "IsZero()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsValid(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: NewCarbon(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("0000-01-01 00:00:00 +0000 UTC"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case4",
|
|
carbon: Parse("0001-01-01 00:00:00 +0000 UTC"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case5",
|
|
carbon: Parse("2020-08-05"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsValid(), "IsValid()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsInvalid(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: NewCarbon(),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("0000-01-01 00:00:00 +0000 UTC"),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case4",
|
|
carbon: Parse("0001-01-01 00:00:00 +0000 UTC"),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case5",
|
|
carbon: Parse("2020-08-05"),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsInvalid(), "IsInvalid()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsAM(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-08-05 00:00:00"),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-08-05 08:00:00"),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case4",
|
|
carbon: Parse("2020-08-05 12:00:00"),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsAM(), "IsAM()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsPM(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-08-05 00:00:00"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-08-05 08:00:00"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case4",
|
|
carbon: Parse("2020-08-05 12:00:00"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsPM(), "IsPM()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsNow(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Tomorrow(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Yesterday(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case4",
|
|
carbon: Now(),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsNow(), "IsNow()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsFuture(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Tomorrow(),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Yesterday(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case4",
|
|
carbon: Now(),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsFuture(), "IsFuture()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsPast(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Tomorrow(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Yesterday(),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case4",
|
|
carbon: Now(),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsPast(), "IsPast()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsLeapYear(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2015-01-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2016-01-01"),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case4",
|
|
carbon: Parse("2017-01-01"),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsLeapYear(), "IsLeapYear()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsLongYear(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2015-01-01"),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2016-01-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case4",
|
|
carbon: Parse("2017-01-01"),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsLongYear(), "IsLongYear()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsJanuary(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-01-01"),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-02-01"),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsJanuary(), "IsJanuary()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsFebruary(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-01-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-02-01"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsFebruary(), "IsFebruary()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsMarch(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-01-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-03-01"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsMarch(), "IsMarch()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsApril(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-01-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-04-01"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsApril(), "IsApril()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsMay(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-01-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-05-01"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsMay(), "IsMay()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsJune(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-01-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-06-01"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsJune(), "IsJune()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsJuly(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-01-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-07-01"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsJuly(), "IsJuly()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsAugust(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-01-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-08-01"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsAugust(), "IsAugust()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSeptember(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-01-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-09-01"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsSeptember(), "IsSeptember()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsOctober(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-01-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-10-01"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsOctober(), "IsOctober()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsNovember(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-01-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-11-01"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsNovember(), "IsNovember()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsDecember(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-01-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-12-01"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsDecember(), "IsDecember()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsMonday(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-10-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-10-05"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsMonday(), "IsMonday()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsTuesday(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-10-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-10-06"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsTuesday(), "IsTuesday()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsWednesday(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-10-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-10-07"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsWednesday(), "IsWednesday()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsThursday(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-10-05"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-10-08"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsThursday(), "IsThursday()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsFriday(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-10-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-10-09"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsFriday(), "IsFriday()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSaturday(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-10-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-10-10"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsSaturday(), "IsSaturday()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSunday(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-10-01"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-10-11"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsSunday(), "IsSunday()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsWeekday(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-10-05"),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-10-10"),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsWeekday(), "IsWeekday()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsWeekend(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: Parse("2020-10-05"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Parse("2020-10-10"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsWeekend(), "IsWeekend()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsYesterday(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: NewCarbon(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Yesterday(),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case4",
|
|
carbon: Tomorrow(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case5",
|
|
carbon: Now(),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsYesterday(), "IsYesterday()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsToday(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: NewCarbon(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Yesterday(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case4",
|
|
carbon: Tomorrow(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case5",
|
|
carbon: Now(),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsToday(), "IsToday()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsTomorrow(t *testing.T) {
|
|
|
|
tests := []struct {
|
|
name string
|
|
carbon Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon: NewCarbon(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon: Yesterday(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case4",
|
|
carbon: Tomorrow(),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case5",
|
|
carbon: Now(),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon.IsTomorrow(), "IsTomorrow()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameCentury(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon1 Carbon
|
|
carbon2 Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon1: Parse(""),
|
|
carbon2: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon1: Parse("xxx"),
|
|
carbon2: Parse("xxx"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon1: Parse("2020-08-05"),
|
|
carbon2: Parse("3020-08-05"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon1: Parse("2020-08-05"),
|
|
carbon2: Parse("2099-08-05"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon1.IsSameCentury(tt.carbon2), "IsSameCentury()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameDecade(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon1 Carbon
|
|
carbon2 Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon1: Parse(""),
|
|
carbon2: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon1: Parse("2020-08-05"),
|
|
carbon2: Parse("2030-08-05"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon1: Parse("2020-08-05"),
|
|
carbon2: Parse("2021-08-05"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon1.IsSameDecade(tt.carbon2), "IsSameDecade()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameYear(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon1 Carbon
|
|
carbon2 Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon1: Parse(""),
|
|
carbon2: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon1: Parse("2020-08-05"),
|
|
carbon2: Parse("2021-08-05"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon1: Parse("2020-01-01"),
|
|
carbon2: Parse("2020-12-31"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon1.IsSameYear(tt.carbon2), "IsSameYear()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameQuarter(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon1 Carbon
|
|
carbon2 Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon1: Parse(""),
|
|
carbon2: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon1: Parse("2020-08-05"),
|
|
carbon2: Parse("2020-01-05"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon1: Parse("2020-01-01"),
|
|
carbon2: Parse("2020-01-31"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon1.IsSameQuarter(tt.carbon2), "IsSameQuarter()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameMonth(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon1 Carbon
|
|
carbon2 Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon1: Parse(""),
|
|
carbon2: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon1: Parse("2020-08-05"),
|
|
carbon2: Parse("2021-08-05"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon1: Parse("2020-01-01"),
|
|
carbon2: Parse("2020-01-31"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon1.IsSameMonth(tt.carbon2), "IsSameMonth()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameDay(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon1 Carbon
|
|
carbon2 Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon1: Parse(""),
|
|
carbon2: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon1: Parse("2020-08-05 13:14:15"),
|
|
carbon2: Parse("2021-08-05 13:14:15"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon1: Parse("2020-08-05 00:00:00"),
|
|
carbon2: Parse("2020-08-05 13:14:15"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon1.IsSameDay(tt.carbon2), "IsSameDay()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameHour(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon1 Carbon
|
|
carbon2 Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon1: Parse(""),
|
|
carbon2: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon1: Parse("2020-08-05 13:14:15"),
|
|
carbon2: Parse("2021-08-05 13:14:15"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon1: Parse("2020-08-05 13:00:00"),
|
|
carbon2: Parse("2020-08-05 13:14:15"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon1.IsSameHour(tt.carbon2), "IsSameDay()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameMinute(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon1 Carbon
|
|
carbon2 Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon1: Parse(""),
|
|
carbon2: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon1: Parse("2020-08-05 13:14:15"),
|
|
carbon2: Parse("2021-08-05 13:14:15"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon1: Parse("2020-08-05 13:14:00"),
|
|
carbon2: Parse("2020-08-05 13:14:15"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon1.IsSameMinute(tt.carbon2), "IsSameMinute()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameSecond(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
carbon1 Carbon
|
|
carbon2 Carbon
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
carbon1: Parse(""),
|
|
carbon2: Parse(""),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
carbon1: Parse("2020-08-05 13:14:15"),
|
|
carbon2: Parse("2021-08-05 13:14:15"),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
carbon1: Parse("2020-08-05 13:14:15"),
|
|
carbon2: Parse("2020-08-05 13:14:15"),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.carbon1.IsSameSecond(tt.carbon2), "IsSameSecond()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Compare(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
actual bool
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
actual: Parse("xxx").Compare(">", Parse("2020-08-04")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
actual: Parse("2020-08-05").Compare(">", Parse("2020-08-04")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case3",
|
|
actual: Parse("2020-08-05").Compare("<", Parse("2020-08-04")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case4",
|
|
actual: Parse("2020-08-05").Compare("<", Parse("2020-08-06")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case5",
|
|
actual: Parse("2020-08-05").Compare("=", Parse("2020-08-05")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case6",
|
|
actual: Parse("2020-08-05").Compare(">=", Parse("2020-08-05")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case7",
|
|
actual: Parse("2020-08-05").Compare("<=", Parse("2020-08-05")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case8",
|
|
actual: Parse("2020-08-05").Compare("<>", Parse("2020-08-06")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case9",
|
|
actual: Parse("2020-08-05").Compare("+", Parse("2020-08-06")),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.actual, "Compare()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Gt(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
actual bool
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
actual: Parse("xxx").Gt(Parse("2020-08-04")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
actual: Parse("2020-08-05").Gt(Parse("2020-08-04")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case3",
|
|
actual: Parse("2020-08-05").Gt(Parse("2020-08-04")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case4",
|
|
actual: Parse("2020-08-05").Gt(Parse("2020-08-06")),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.actual, "Gt()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Lt(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
actual bool
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
actual: Parse("xxx").Lt(Parse("2020-08-04")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
actual: Parse("2020-08-05").Lt(Parse("2020-08-04")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
actual: Parse("2020-08-05").Lt(Parse("2020-08-04")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case4",
|
|
actual: Parse("2020-08-05").Lt(Parse("2020-08-06")),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.actual, "Lt()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Eq(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
actual bool
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
actual: Parse("xxx").Eq(Parse("2020-08-05")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
actual: Parse("2020-08-05").Eq(Parse("2020-08-05")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case3",
|
|
actual: Parse("2020-08-05").Eq(Parse("2020-08-04")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case4",
|
|
actual: Parse("2020-08-05").Eq(Parse("2020-08-06")),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.actual, "Eq()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Ne(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
actual bool
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
actual: Parse("xxx").Ne(Parse("2020-08-05")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case2",
|
|
actual: Parse("2020-08-05").Ne(Parse("2020-08-05")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
actual: Parse("2020-08-05").Ne(Parse("2020-08-04")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case4",
|
|
actual: Parse("2020-08-05").Ne(Parse("2020-08-06")),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.actual, "Ne()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Gte(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
actual bool
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
actual: Parse("xxx").Gte(Parse("2020-08-05")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
actual: Parse("2020-08-05").Gte(Parse("2020-08-05")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case3",
|
|
actual: Parse("2020-08-05").Gte(Parse("2020-08-04")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case4",
|
|
actual: Parse("2020-08-05").Gte(Parse("2020-08-06")),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.actual, "Gte()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Lte(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
actual bool
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
actual: Parse("xxx").Lte(Parse("2020-08-05")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
actual: Parse("2020-08-05").Lte(Parse("2020-08-05")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case3",
|
|
actual: Parse("2020-08-05").Lte(Parse("2020-08-04")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case4",
|
|
actual: Parse("2020-08-05").Lte(Parse("2020-08-06")),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.actual, "Lte()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Between(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
actual bool
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
actual: Parse("xxx").Between(Parse("2020-08-05"), Parse("2020-08-05")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
actual: Parse("2020-08-05").Between(Parse("2020-08-05"), Parse("2020-08-05")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
actual: Parse("2020-08-05").Between(Parse("2020-08-05"), Parse("2020-08-06")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case4",
|
|
actual: Parse("2020-08-05").Between(Parse("2020-08-05"), Parse("2020-08-05")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case5",
|
|
actual: Parse("2020-08-05").Between(Parse("2020-08-04"), Parse("2020-08-06")),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.actual, "Between()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_BetweenIncludedStart(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
actual bool
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
actual: Parse("xxx").BetweenIncludedStart(Parse("2020-08-05"), Parse("2020-08-05")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
actual: Parse("2020-08-05").BetweenIncludedStart(Parse("2020-08-05"), Parse("2020-08-05")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
actual: Parse("2020-08-05").BetweenIncludedStart(Parse("2020-08-05"), Parse("2020-08-06")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case4",
|
|
actual: Parse("2020-08-05").BetweenIncludedStart(Parse("2020-08-04"), Parse("2020-08-05")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case5",
|
|
actual: Parse("2020-08-05").BetweenIncludedStart(Parse("2020-08-04"), Parse("2020-08-06")),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.actual, "BetweenIncludedStart()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_BetweenIncludedEnd(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
actual bool
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
actual: Parse("xxx").BetweenIncludedEnd(Parse("2020-08-05"), Parse("2020-08-05")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
actual: Parse("2020-08-05").BetweenIncludedEnd(Parse("2020-08-05"), Parse("2020-08-05")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case3",
|
|
actual: Parse("2020-08-05").BetweenIncludedEnd(Parse("2020-08-05"), Parse("2020-08-06")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case4",
|
|
actual: Parse("2020-08-05").BetweenIncludedEnd(Parse("2020-08-04"), Parse("2020-08-05")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case5",
|
|
actual: Parse("2020-08-05").BetweenIncludedEnd(Parse("2020-08-04"), Parse("2020-08-06")),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.actual, "BetweenIncludedEnd()")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCarbon_BetweenIncludedBoth(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
actual bool
|
|
want bool
|
|
}{
|
|
{
|
|
name: "case1",
|
|
actual: Parse("xxx").BetweenIncludedBoth(Parse("2020-08-05"), Parse("2020-08-05")),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "case2",
|
|
actual: Parse("2020-08-05").BetweenIncludedBoth(Parse("2020-08-05"), Parse("2020-08-05")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case3",
|
|
actual: Parse("2020-08-05").BetweenIncludedBoth(Parse("2020-08-05"), Parse("2020-08-06")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case4",
|
|
actual: Parse("2020-08-05").BetweenIncludedBoth(Parse("2020-08-04"), Parse("2020-08-05")),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "case5",
|
|
actual: Parse("2020-08-05").BetweenIncludedBoth(Parse("2020-08-06"), Parse("2020-08-06")),
|
|
want: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, tt.actual, "BetweenIncludedBoth()")
|
|
})
|
|
}
|
|
}
|