代码拉取完成，页面将自动刷新
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()")
}
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。