mirror of
https://gitee.com/dromara/carbon.git
synced 2024-11-29 18:57:37 +08:00
1477 lines
36 KiB
Go
Executable File
1477 lines
36 KiB
Go
Executable File
package carbon
|
|
|
|
import (
|
|
"strconv"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestCarbon_IsDST(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tzWithDST, tzWithoutDST := "Australia/Sydney", "Australia/Brisbane"
|
|
|
|
tests := []struct {
|
|
input string
|
|
timezone string
|
|
expected bool
|
|
}{
|
|
0: {"", tzWithDST, false},
|
|
1: {"", tzWithoutDST, false},
|
|
2: {"0", tzWithDST, false},
|
|
3: {"0", tzWithoutDST, false},
|
|
4: {"0000-00-00", tzWithDST, false},
|
|
5: {"0000-00-00", tzWithoutDST, false},
|
|
6: {"00:00:00", tzWithDST, false},
|
|
7: {"00:00:00", tzWithoutDST, false},
|
|
8: {"0000-00-00 00:00:00", tzWithDST, false},
|
|
9: {"0000-00-00 00:00:00", tzWithoutDST, false},
|
|
|
|
10: {"2009-01-01", tzWithDST, true},
|
|
11: {"2009-01-01", tzWithoutDST, false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input, test.timezone)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsDST(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsZero(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", true},
|
|
1: {"0", true},
|
|
2: {"0000-00-00", true},
|
|
3: {"00:00:00", true},
|
|
4: {"0000-00-00 00:00:00", true},
|
|
|
|
5: {"2020-08-05", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsZero(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsValid(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-08-05", true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsValid(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsInvalid(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", true},
|
|
1: {"0", true},
|
|
2: {"0000-00-00", true},
|
|
3: {"00:00:00", true},
|
|
4: {"0000-00-00 00:00:00", true},
|
|
|
|
5: {"2020-08-05", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsInvalid(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsAM(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-08-05 00:00:00", true},
|
|
6: {"2020-08-05 08:00:00", true},
|
|
7: {"2020-08-05 12:00:00", false},
|
|
8: {"2020-08-05 13:00:00", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsAM(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsPM(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-08-05 00:00:00", false},
|
|
6: {"2020-08-05 08:00:00", false},
|
|
7: {"2020-08-05 12:00:00", true},
|
|
8: {"2020-08-05 13:00:00", true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsPM(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsNow(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input Carbon
|
|
expected bool
|
|
}{
|
|
0: {Parse(""), false},
|
|
1: {Parse("0"), false},
|
|
2: {Parse("0000-00-00"), false},
|
|
3: {Parse("00:00:00"), false},
|
|
4: {Parse("0000-00-00 00:00:00"), false},
|
|
|
|
5: {Tomorrow(), false},
|
|
6: {Now(), true},
|
|
7: {Yesterday(), false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := test.input
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsNow(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsFuture(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input Carbon
|
|
expected bool
|
|
}{
|
|
0: {Parse(""), false},
|
|
1: {Parse("0"), false},
|
|
2: {Parse("0000-00-00"), false},
|
|
3: {Parse("00:00:00"), false},
|
|
4: {Parse("0000-00-00 00:00:00"), false},
|
|
|
|
5: {Tomorrow(), true},
|
|
6: {Now(), false},
|
|
7: {Yesterday(), false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := test.input
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsFuture(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsPast(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input Carbon
|
|
expected bool
|
|
}{
|
|
0: {Parse(""), false},
|
|
1: {Parse("0"), false},
|
|
2: {Parse("0000-00-00"), false},
|
|
3: {Parse("00:00:00"), false},
|
|
4: {Parse("0000-00-00 00:00:00"), false},
|
|
|
|
5: {Tomorrow(), false},
|
|
6: {Now(), false},
|
|
7: {Yesterday(), true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := test.input
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsPast(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsLeapYear(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2015-01-01", false},
|
|
6: {"2016-01-01", true},
|
|
7: {"2017-01-01", false},
|
|
8: {"2018-01-01", false},
|
|
9: {"2019-01-01", false},
|
|
10: {"2020-01-01", true},
|
|
11: {"2021-01-01", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsLeapYear(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsLongYear(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2015-01-01", true},
|
|
6: {"2016-01-01", false},
|
|
7: {"2017-01-01", false},
|
|
8: {"2018-01-01", false},
|
|
9: {"2019-01-01", false},
|
|
10: {"2020-01-01", true},
|
|
11: {"2021-01-01", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsLongYear(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsJanuary(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-01-01", true},
|
|
6: {"2020-02-01", false},
|
|
7: {"2020-03-01", false},
|
|
8: {"2020-04-01", false},
|
|
9: {"2020-05-01", false},
|
|
10: {"2020-06-01", false},
|
|
11: {"2020-07-01", false},
|
|
12: {"2020-08-01", false},
|
|
13: {"2020-09-01", false},
|
|
14: {"2020-10-01", false},
|
|
15: {"2020-11-01", false},
|
|
16: {"2020-12-01", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsJanuary(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsFebruary(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-01-01", false},
|
|
6: {"2020-02-01", true},
|
|
7: {"2020-03-01", false},
|
|
8: {"2020-04-01", false},
|
|
9: {"2020-05-01", false},
|
|
10: {"2020-06-01", false},
|
|
11: {"2020-07-01", false},
|
|
12: {"2020-08-01", false},
|
|
13: {"2020-09-01", false},
|
|
14: {"2020-10-01", false},
|
|
15: {"2020-11-01", false},
|
|
16: {"2020-12-01", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsFebruary(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsMarch(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-01-01", false},
|
|
6: {"2020-02-01", false},
|
|
7: {"2020-03-01", true},
|
|
8: {"2020-04-01", false},
|
|
9: {"2020-05-01", false},
|
|
10: {"2020-06-01", false},
|
|
11: {"2020-07-01", false},
|
|
12: {"2020-08-01", false},
|
|
13: {"2020-09-01", false},
|
|
14: {"2020-10-01", false},
|
|
15: {"2020-11-01", false},
|
|
16: {"2020-12-01", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsMarch(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsApril(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-01-01", false},
|
|
6: {"2020-02-01", false},
|
|
7: {"2020-03-01", false},
|
|
8: {"2020-04-01", true},
|
|
9: {"2020-05-01", false},
|
|
10: {"2020-06-01", false},
|
|
11: {"2020-07-01", false},
|
|
12: {"2020-08-01", false},
|
|
13: {"2020-09-01", false},
|
|
14: {"2020-10-01", false},
|
|
15: {"2020-11-01", false},
|
|
16: {"2020-12-01", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsApril(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsMay(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-01-01", false},
|
|
6: {"2020-02-01", false},
|
|
7: {"2020-03-01", false},
|
|
8: {"2020-04-01", false},
|
|
9: {"2020-05-01", true},
|
|
10: {"2020-06-01", false},
|
|
11: {"2020-07-01", false},
|
|
12: {"2020-08-01", false},
|
|
13: {"2020-09-01", false},
|
|
14: {"2020-10-01", false},
|
|
15: {"2020-11-01", false},
|
|
16: {"2020-12-01", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsMay(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsJune(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-01-01", false},
|
|
6: {"2020-02-01", false},
|
|
7: {"2020-03-01", false},
|
|
8: {"2020-04-01", false},
|
|
9: {"2020-05-01", false},
|
|
10: {"2020-06-01", true},
|
|
11: {"2020-07-01", false},
|
|
12: {"2020-08-01", false},
|
|
13: {"2020-09-01", false},
|
|
14: {"2020-10-01", false},
|
|
15: {"2020-11-01", false},
|
|
16: {"2020-12-01", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsJune(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsJuly(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-01-01", false},
|
|
6: {"2020-02-01", false},
|
|
7: {"2020-03-01", false},
|
|
8: {"2020-04-01", false},
|
|
9: {"2020-05-01", false},
|
|
10: {"2020-06-01", false},
|
|
11: {"2020-07-01", true},
|
|
12: {"2020-08-01", false},
|
|
13: {"2020-09-01", false},
|
|
14: {"2020-10-01", false},
|
|
15: {"2020-11-01", false},
|
|
16: {"2020-12-01", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsJuly(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsAugust(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-01-01", false},
|
|
6: {"2020-02-01", false},
|
|
7: {"2020-03-01", false},
|
|
8: {"2020-04-01", false},
|
|
9: {"2020-05-01", false},
|
|
10: {"2020-06-01", false},
|
|
11: {"2020-07-01", false},
|
|
12: {"2020-08-01", true},
|
|
13: {"2020-09-01", false},
|
|
14: {"2020-10-01", false},
|
|
15: {"2020-11-01", false},
|
|
16: {"2020-12-01", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsAugust(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSeptember(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-01-01", false},
|
|
6: {"2020-02-01", false},
|
|
7: {"2020-03-01", false},
|
|
8: {"2020-04-01", false},
|
|
9: {"2020-05-01", false},
|
|
10: {"2020-06-01", false},
|
|
11: {"2020-07-01", false},
|
|
12: {"2020-08-01", false},
|
|
13: {"2020-09-01", true},
|
|
14: {"2020-10-01", false},
|
|
15: {"2020-11-01", false},
|
|
16: {"2020-12-01", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsSeptember(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsOctober(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-01-01", false},
|
|
6: {"2020-02-01", false},
|
|
7: {"2020-03-01", false},
|
|
8: {"2020-04-01", false},
|
|
9: {"2020-05-01", false},
|
|
10: {"2020-06-01", false},
|
|
11: {"2020-07-01", false},
|
|
12: {"2020-08-01", false},
|
|
13: {"2020-09-01", false},
|
|
14: {"2020-10-01", true},
|
|
15: {"2020-11-01", false},
|
|
16: {"2020-12-01", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsOctober(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsNovember(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-01-01", false},
|
|
6: {"2020-02-01", false},
|
|
7: {"2020-03-01", false},
|
|
8: {"2020-04-01", false},
|
|
9: {"2020-05-01", false},
|
|
10: {"2020-06-01", false},
|
|
11: {"2020-07-01", false},
|
|
12: {"2020-08-01", false},
|
|
13: {"2020-09-01", false},
|
|
14: {"2020-10-01", false},
|
|
15: {"2020-11-01", true},
|
|
16: {"2020-12-01", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsNovember(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsDecember(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-01-01", false},
|
|
6: {"2020-02-01", false},
|
|
7: {"2020-03-01", false},
|
|
8: {"2020-04-01", false},
|
|
9: {"2020-05-01", false},
|
|
10: {"2020-06-01", false},
|
|
11: {"2020-07-01", false},
|
|
12: {"2020-08-01", false},
|
|
13: {"2020-09-01", false},
|
|
14: {"2020-10-01", false},
|
|
15: {"2020-11-01", false},
|
|
16: {"2020-12-01", true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsDecember(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsMonday(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-10-05", true},
|
|
6: {"2020-10-06", false},
|
|
7: {"2020-10-07", false},
|
|
8: {"2020-10-08", false},
|
|
9: {"2020-10-09", false},
|
|
10: {"2020-10-10", false},
|
|
11: {"2020-10-11", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsMonday(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsTuesday(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-10-05", false},
|
|
6: {"2020-10-06", true},
|
|
7: {"2020-10-07", false},
|
|
8: {"2020-10-08", false},
|
|
9: {"2020-10-09", false},
|
|
10: {"2020-10-10", false},
|
|
11: {"2020-10-11", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsTuesday(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsWednesday(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-10-05", false},
|
|
6: {"2020-10-06", false},
|
|
7: {"2020-10-07", true},
|
|
8: {"2020-10-08", false},
|
|
9: {"2020-10-09", false},
|
|
10: {"2020-10-10", false},
|
|
11: {"2020-10-11", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsWednesday(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsThursday(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-10-05", false},
|
|
6: {"2020-10-06", false},
|
|
7: {"2020-10-07", false},
|
|
8: {"2020-10-08", true},
|
|
9: {"2020-10-09", false},
|
|
10: {"2020-10-10", false},
|
|
11: {"2020-10-11", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsThursday(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsFriday(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-10-05", false},
|
|
6: {"2020-10-06", false},
|
|
7: {"2020-10-07", false},
|
|
8: {"2020-10-08", false},
|
|
9: {"2020-10-09", true},
|
|
10: {"2020-10-10", false},
|
|
11: {"2020-10-11", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsFriday(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSaturday(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-10-05", false},
|
|
6: {"2020-10-06", false},
|
|
7: {"2020-10-07", false},
|
|
8: {"2020-10-08", false},
|
|
9: {"2020-10-09", false},
|
|
10: {"2020-10-10", true},
|
|
11: {"2020-10-11", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsSaturday(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSunday(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-10-05", false},
|
|
6: {"2020-10-06", false},
|
|
7: {"2020-10-07", false},
|
|
8: {"2020-10-08", false},
|
|
9: {"2020-10-09", false},
|
|
10: {"2020-10-10", false},
|
|
11: {"2020-10-11", true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsSunday(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsWeekday(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-10-05", true},
|
|
6: {"2020-10-06", true},
|
|
7: {"2020-10-07", true},
|
|
8: {"2020-10-08", true},
|
|
9: {"2020-10-09", true},
|
|
10: {"2020-10-10", false},
|
|
11: {"2020-10-11", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsWeekday(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsWeekend(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
expected bool
|
|
}{
|
|
0: {"", false},
|
|
1: {"0", false},
|
|
2: {"0000-00-00", false},
|
|
3: {"00:00:00", false},
|
|
4: {"0000-00-00 00:00:00", false},
|
|
|
|
5: {"2020-10-05", false},
|
|
6: {"2020-10-06", false},
|
|
7: {"2020-10-07", false},
|
|
8: {"2020-10-08", false},
|
|
9: {"2020-10-09", false},
|
|
10: {"2020-10-10", true},
|
|
11: {"2020-10-11", true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(PRC).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsWeekend(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsYesterday(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input Carbon
|
|
expected bool
|
|
}{
|
|
0: {NewCarbon(), false},
|
|
1: {Now(), false},
|
|
2: {Yesterday(), true},
|
|
3: {Tomorrow(), false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := test.input
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsYesterday(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsToday(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input Carbon
|
|
expected bool
|
|
}{
|
|
0: {NewCarbon(), false},
|
|
1: {Now(), true},
|
|
2: {Yesterday(), false},
|
|
3: {Tomorrow(), false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := test.input
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsToday(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsTomorrow(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input Carbon
|
|
expected bool
|
|
}{
|
|
0: {NewCarbon(), false},
|
|
1: {Now(), false},
|
|
2: {Yesterday(), false},
|
|
3: {Tomorrow(), true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := test.input
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.IsTomorrow(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameCentury(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input1 Carbon
|
|
input2 Carbon
|
|
expected bool
|
|
}{
|
|
0: {Parse(""), Parse(""), false},
|
|
1: {Parse("2020-08-05"), Parse("3020-08-05"), false},
|
|
2: {Parse("2020-08-05"), Parse("2099-08-05"), true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
assert.Nil(test.input1.Error)
|
|
assert.Nil(test.input2.Error)
|
|
assert.Equal(test.expected, test.input1.IsSameCentury(test.input2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameDecade(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input1 Carbon
|
|
input2 Carbon
|
|
expected bool
|
|
}{
|
|
0: {Parse(""), Parse(""), false},
|
|
1: {Parse("2020-08-05"), Parse("2030-08-05"), false},
|
|
2: {Parse("2020-08-05"), Parse("2021-08-05"), true},
|
|
3: {Parse("2020-01-01"), Parse("2120-01-31"), true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
assert.Nil(test.input1.Error)
|
|
assert.Nil(test.input2.Error)
|
|
assert.Equal(test.expected, test.input1.IsSameDecade(test.input2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameYear(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input1 Carbon
|
|
input2 Carbon
|
|
expected bool
|
|
}{
|
|
0: {Parse(""), Parse(""), false},
|
|
1: {Parse("2020-08-05"), Parse("2021-08-05"), false},
|
|
2: {Parse("2020-01-01"), Parse("2020-12-31"), true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
assert.Nil(test.input1.Error)
|
|
assert.Nil(test.input2.Error)
|
|
assert.Equal(test.expected, test.input1.IsSameYear(test.input2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameQuarter(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input1 Carbon
|
|
input2 Carbon
|
|
expected bool
|
|
}{
|
|
0: {Parse(""), Parse(""), false},
|
|
1: {Parse("2020-08-05"), Parse("2020-01-05"), false},
|
|
2: {Parse("2020-01-01"), Parse("2020-01-31"), true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
assert.Nil(test.input1.Error)
|
|
assert.Nil(test.input2.Error)
|
|
assert.Equal(test.expected, test.input1.IsSameQuarter(test.input2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameMonth(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input1 Carbon
|
|
input2 Carbon
|
|
expected bool
|
|
}{
|
|
0: {Parse(""), Parse(""), false},
|
|
1: {Parse("2020-08-05"), Parse("2021-08-05"), false},
|
|
2: {Parse("2020-01-01"), Parse("2020-01-31"), true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
assert.Nil(test.input1.Error)
|
|
assert.Nil(test.input2.Error)
|
|
assert.Equal(test.expected, test.input1.IsSameMonth(test.input2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameDay(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input1 Carbon
|
|
input2 Carbon
|
|
expected bool
|
|
}{
|
|
0: {Parse(""), Parse(""), false},
|
|
1: {Parse("2020-08-05 13:14:15"), Parse("2021-08-05 13:14:15"), false},
|
|
2: {Parse("2020-08-05 00:00:00"), Parse("2020-08-05 13:14:15"), true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
assert.Nil(test.input1.Error)
|
|
assert.Nil(test.input2.Error)
|
|
assert.Equal(test.expected, test.input1.IsSameDay(test.input2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameHour(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input1 Carbon
|
|
input2 Carbon
|
|
expected bool
|
|
}{
|
|
0: {Parse(""), Parse(""), false},
|
|
1: {Parse("2020-08-05 13:14:15"), Parse("2021-08-05 13:14:15"), false},
|
|
2: {Parse("2020-08-05 13:00:00"), Parse("2020-08-05 13:14:15"), true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
assert.Nil(test.input1.Error)
|
|
assert.Nil(test.input2.Error)
|
|
assert.Equal(test.expected, test.input1.IsSameHour(test.input2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameMinute(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input1 Carbon
|
|
input2 Carbon
|
|
expected bool
|
|
}{
|
|
0: {Parse(""), Parse(""), false},
|
|
1: {Parse("2020-08-05 13:14:15"), Parse("2021-08-05 13:14:15"), false},
|
|
2: {Parse("2020-08-05 13:14:00"), Parse("2020-08-05 13:14:15"), true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
assert.Nil(test.input1.Error)
|
|
assert.Nil(test.input2.Error)
|
|
assert.Equal(test.expected, test.input1.IsSameMinute(test.input2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_IsSameSecond(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input1 Carbon
|
|
input2 Carbon
|
|
expected bool
|
|
}{
|
|
0: {Parse(""), Parse(""), false},
|
|
1: {Parse("2020-08-05 13:14:15"), Parse("2021-08-05 13:14:15"), false},
|
|
2: {Parse("2020-08-05 13:14:15"), Parse("2020-08-05 13:14:15"), true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
assert.Nil(test.input1.Error)
|
|
assert.Nil(test.input2.Error)
|
|
assert.Equal(test.expected, test.input1.IsSameSecond(test.input2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Compare(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
param1 string
|
|
param2 string
|
|
expected bool
|
|
}{
|
|
0: {"2020-08-05", ">", "2020-08-04", true},
|
|
1: {"2020-08-05", "<", "2020-08-04", false},
|
|
2: {"2020-08-05", "<", "2020-08-06", true},
|
|
3: {"2020-08-05", ">", "2020-08-06", false},
|
|
4: {"2020-08-05", "=", "2020-08-05", true},
|
|
5: {"2020-08-05", ">=", "2020-08-05", true},
|
|
6: {"2020-08-05", "<=", "2020-08-05", true},
|
|
7: {"2020-08-05", "!=", "2020-08-05", false},
|
|
8: {"2020-08-05", "<>", "2020-08-05", false},
|
|
9: {"2020-08-05", "!=", "2020-08-04", true},
|
|
10: {"2020-08-05", "<>", "2020-08-04", true},
|
|
11: {"2020-08-05", "+", "2020-08-04", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c1, c2 := Parse(test.input), Parse(test.param2)
|
|
assert.Nil(c1.Error)
|
|
assert.Nil(c2.Error)
|
|
assert.Equal(test.expected, c1.Compare(test.param1, c2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Gt(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
param string
|
|
expected bool
|
|
}{
|
|
0: {"2020-08-05", "2020-08-05", false},
|
|
1: {"2020-08-05", "2020-08-04", true},
|
|
2: {"2020-08-05", "2020-08-06", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c1, c2 := Parse(test.input), Parse(test.param)
|
|
assert.Nil(c1.Error)
|
|
assert.Nil(c2.Error)
|
|
assert.Equal(test.expected, c1.Gt(c2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Lt(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
param string
|
|
expected bool
|
|
}{
|
|
0: {"2020-08-05", "2020-08-05", false},
|
|
1: {"2020-08-05", "2020-08-04", false},
|
|
2: {"2020-08-05", "2020-08-06", true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c1, c2 := Parse(test.input), Parse(test.param)
|
|
assert.Nil(c1.Error)
|
|
assert.Nil(c2.Error)
|
|
assert.Equal(test.expected, c1.Lt(c2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Eq(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
param string
|
|
expected bool
|
|
}{
|
|
0: {"2020-08-05", "2020-08-05", true},
|
|
1: {"2020-08-05", "2020-08-04", false},
|
|
2: {"2020-08-05", "2020-08-06", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c1, c2 := Parse(test.input), Parse(test.param)
|
|
assert.Nil(c1.Error)
|
|
assert.Nil(c2.Error)
|
|
assert.Equal(test.expected, c1.Eq(c2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Ne(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
param string
|
|
expected bool
|
|
}{
|
|
0: {"2020-08-05", "2020-08-05", false},
|
|
1: {"2020-08-05", "2020-08-04", true},
|
|
2: {"2020-08-05", "2020-08-06", true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c1, c2 := Parse(test.input), Parse(test.param)
|
|
assert.Nil(c1.Error)
|
|
assert.Nil(c2.Error)
|
|
assert.Equal(test.expected, c1.Ne(c2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Gte(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
param string
|
|
expected bool
|
|
}{
|
|
0: {"2020-08-05", "2020-08-05", true},
|
|
1: {"2020-08-05", "2020-08-04", true},
|
|
2: {"2020-08-05", "2020-08-06", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c1, c2 := Parse(test.input), Parse(test.param)
|
|
assert.Nil(c1.Error)
|
|
assert.Nil(c2.Error)
|
|
assert.Equal(test.expected, c1.Gte(c2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Lte(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
param string
|
|
expected bool
|
|
}{
|
|
0: {"2020-08-05", "2020-08-05", true},
|
|
1: {"2020-08-05", "2020-08-04", false},
|
|
2: {"2020-08-05", "2020-08-06", true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c1, c2 := Parse(test.input), Parse(test.param)
|
|
assert.Nil(c1.Error)
|
|
assert.Nil(c2.Error)
|
|
assert.Equal(test.expected, c1.Lte(c2), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_Between(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
param1 string
|
|
param2 string
|
|
expected bool
|
|
}{
|
|
{"2020-08-05 13:14:15", "2020-08-05 13:14:15", "2020-08-05 13:14:15", false},
|
|
{"2020-08-05 13:14:15", "2020-08-05 13:14:15", "2020-08-06 13:14:15", false},
|
|
{"2020-08-05 13:14:15", "2020-08-04 13:14:15", "2020-08-05 13:14:15", false},
|
|
{"2020-08-05 13:14:15", "2020-08-04 13:14:15", "2020-08-06 13:14:15", true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c1, c2, c3 := Parse(test.input), Parse(test.param1), Parse(test.param2)
|
|
assert.Nil(c1.Error)
|
|
assert.Nil(c2.Error)
|
|
assert.Nil(c3.Error)
|
|
assert.Equal(test.expected, c1.Between(c2, c3), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_BetweenIncludedStart(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
param1 string
|
|
param2 string
|
|
expected bool
|
|
}{
|
|
{"2020-08-05 13:14:15", "2020-08-05 13:14:15", "2020-08-05 13:14:15", false},
|
|
{"2020-08-05 13:14:15", "2020-08-05 13:14:15", "2020-08-06 13:14:15", true},
|
|
{"2020-08-05 13:14:15", "2020-08-04 13:14:15", "2020-08-05 13:14:15", false},
|
|
{"2020-08-05 13:14:15", "2020-08-04 13:14:15", "2020-08-06 13:14:15", true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c1, c2, c3 := Parse(test.input), Parse(test.param1), Parse(test.param2)
|
|
assert.Nil(c1.Error)
|
|
assert.Nil(c2.Error)
|
|
assert.Nil(c3.Error)
|
|
assert.Equal(test.expected, c1.BetweenIncludedStart(c2, c3), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_BetweenIncludedEnd(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
param1 string
|
|
param2 string
|
|
expected bool
|
|
}{
|
|
0: {"2020-08-05 13:14:15", "2020-08-05 13:14:15", "2020-08-05 13:14:15", false},
|
|
1: {"2020-08-05 13:14:15", "2020-08-05 13:14:15", "2020-08-06 13:14:15", false},
|
|
2: {"2020-08-05 13:14:15", "2020-08-04 13:14:15", "2020-08-05 13:14:15", true},
|
|
3: {"2020-08-05 13:14:15", "2020-08-04 13:14:15", "2020-08-06 13:14:15", true},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c1, c2, c3 := Parse(test.input), Parse(test.param1), Parse(test.param2)
|
|
assert.Nil(c1.Error)
|
|
assert.Nil(c2.Error)
|
|
assert.Nil(c3.Error)
|
|
assert.Equal(test.expected, c1.BetweenIncludedEnd(c2, c3), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_BetweenIncludedBoth(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string
|
|
param1 string
|
|
param2 string
|
|
expected bool
|
|
}{
|
|
0: {"2020-08-05 13:14:15", "2020-08-05 13:14:15", "2020-08-05 13:14:15", true},
|
|
1: {"2020-08-05 13:14:15", "2020-08-05 13:14:15", "2020-08-06 13:14:15", true},
|
|
2: {"2020-08-05 13:14:15", "2020-08-04 13:14:15", "2020-08-05 13:14:15", true},
|
|
3: {"2020-08-05 13:14:15", "2020-08-04 13:14:15", "2020-08-06 13:14:15", true},
|
|
4: {"2020-08-05 13:14:15", "2020-08-06 13:14:15", "2020-08-06 13:14:15", false},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c1, c2, c3 := Parse(test.input), Parse(test.param1), Parse(test.param2)
|
|
assert.Nil(c1.Error)
|
|
assert.Nil(c2.Error)
|
|
assert.Nil(c3.Error)
|
|
assert.Equal(test.expected, c1.BetweenIncludedBoth(c2, c3), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_Comparer(t *testing.T) {
|
|
time1, time2, time3, operator := "2020-13-50", "xxx", "xxx", ">"
|
|
assert.True(t, Parse(time1).IsZero(), "It should catch an exception in IsZero()")
|
|
assert.True(t, Parse(time1).IsInvalid(), "It should catch an exception in IsInvalid()")
|
|
assert.True(t, Parse(time1).IsInvalid(), "It should catch an exception in IsInvalid()")
|
|
assert.True(t, Parse(time1).Ne(Parse(time2)), "It should catch an exception in Ne()")
|
|
assert.False(t, Parse(time1).Compare(operator, Parse(time2)), "It should catch an exception in Compare()")
|
|
assert.False(t, Parse(time1).Gt(Parse(time2)), "It should catch an exception in Gt()")
|
|
assert.False(t, Parse(time1).Lt(Parse(time2)), "It should catch an exception in Lt()")
|
|
assert.False(t, Parse(time1).Eq(Parse(time2)), "It should catch an exception in Eq()")
|
|
assert.False(t, Parse(time1).Gte(Parse(time2)), "It should catch an exception in Gte()")
|
|
assert.False(t, Parse(time1).Lte(Parse(time2)), "It should catch an exception in Lte()")
|
|
assert.False(t, Parse(time1).Between(Parse(time2), Parse(time3)), "It should catch an exception in Between()")
|
|
assert.False(t, Parse(time1).BetweenIncludedStart(Parse(time2), Parse(time3)), "It should catch an exception in BetweenIncludedStart()")
|
|
assert.False(t, Parse(time1).BetweenIncludedEnd(Parse(time2), Parse(time3)), "It should catch an exception in BetweenIncludedEnd()")
|
|
assert.False(t, Parse(time1).BetweenIncludedBoth(Parse(time2), Parse(time3)), "It should catch an exception in BetweenIncludedBoth()")
|
|
}
|