mirror of
https://gitee.com/dromara/carbon.git
synced 2024-12-03 12:48:22 +08:00
529 lines
15 KiB
Go
Executable File
529 lines
15 KiB
Go
Executable File
package carbon
|
|
|
|
import (
|
|
"github.com/stretchr/testify/assert"
|
|
"strconv"
|
|
"testing"
|
|
)
|
|
|
|
func TestCarbon_SetTimezone(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
timezone string // 输入参数
|
|
expected string // 期望值
|
|
}{
|
|
{"0000-00-00 00:00:00", PRC, ""},
|
|
{"2020-08-05 13:14:15", PRC, "2020-08-05 13:14:15"},
|
|
{"2020-08-05 13:14:15", Tokyo, "2020-08-05 12:14:15"},
|
|
{"2020-08-05 13:14:15", London, "2020-08-05 20:14:15"},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetTimezone(test.timezone).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.ToDateTimeString(PRC), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_SetTimezone(t *testing.T) {
|
|
timezone := "xxx"
|
|
c1 := SetTimezone(timezone)
|
|
assert.NotNil(t, c1.Error, "It should catch an exception in SetTimezone()")
|
|
|
|
c2 := Now(timezone).SetTimezone(timezone)
|
|
assert.NotNil(t, c2.Error, "It should catch an exception in SetTimezone()")
|
|
}
|
|
|
|
func TestCarbon_SetLocale(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
locale string // 输入参数
|
|
expected string // 期望值
|
|
}{
|
|
{"0000-00-00", "en", ""},
|
|
{"2020-08-05", "en", "August"},
|
|
{"2020-08-05", "jp", "はちがつ"},
|
|
{"2020-08-05", "zh-CN", "八月"},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetLocale(test.locale).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.ToMonthString(PRC), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetLocale(test.locale)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.ToMonthString(PRC), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_SetLocale(t *testing.T) {
|
|
locale := "xxx"
|
|
|
|
c1 := SetLocale(locale)
|
|
assert.NotNil(t, c1.Error, "It should catch an exception in SetLocale()")
|
|
|
|
c2 := SetLocale(locale).SetLocale(PRC)
|
|
assert.NotNil(t, c2.Error, "It should catch an exception in SetLocale()")
|
|
}
|
|
|
|
func TestCarbon_SetLanguage(t *testing.T) {
|
|
lang := NewLanguage()
|
|
resources := map[string]string{
|
|
"seasons": "spring|summer|autumn|winter",
|
|
}
|
|
lang.SetLocale("en")
|
|
if lang.Error == nil {
|
|
lang.SetResources(resources)
|
|
}
|
|
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
expected string // 期望值
|
|
}{
|
|
{"", ""},
|
|
{"2020-08-05", "summer"},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetLanguage(lang)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.Season(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := SetLanguage(lang).Parse(test.input)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.Season(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_SetLanguage(t *testing.T) {
|
|
lang, locale := NewLanguage(), "xxx"
|
|
lang.SetLocale(locale)
|
|
|
|
c1 := SetLanguage(lang)
|
|
assert.NotNil(t, c1.Error, "It should catch an exception in SetLanguage()")
|
|
|
|
c2 := SetLocale(locale).SetLanguage(lang)
|
|
assert.NotNil(t, c2.Error, "It should catch an exception in SetLanguage()")
|
|
}
|
|
|
|
func TestCarbon_SetDateTime(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
year, month, day, hour, minute, second int // 输入参数
|
|
expected string // 期望值
|
|
}{
|
|
{"2020-01-01", 2019, 02, 02, 13, 14, 15, "2019-02-02 13:14:15"},
|
|
{"2020-01-01", 2019, 02, 31, 13, 14, 15, "2019-03-03 13:14:15"},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetDateTime(test.year, test.month, test.day, test.hour, test.minute, test.second)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.ToDateTimeString(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_SetDateTime(t *testing.T) {
|
|
input, year, month, day, hour, minute, second := "2020-08-50", 2020, 8, 50, 13, 14, 15
|
|
c := Parse(input).SetDateTime(year, month, day, hour, minute, second)
|
|
assert.NotNil(t, c.Error, "It should catch an exception in SetDateTime()")
|
|
}
|
|
|
|
func TestCarbon_SetDate(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
year, month, day int // 输入参数
|
|
expected string // 期望值
|
|
}{
|
|
{"2020-01-01", 2019, 02, 02, "2019-02-02 00:00:00"},
|
|
{"2020-01-01", 2019, 02, 31, "2019-03-03 00:00:00"},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetDate(test.year, test.month, test.day)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.ToDateTimeString(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_SetDate(t *testing.T) {
|
|
input, year, month, day := "2020-08-50", 2020, 8, 50
|
|
c := Parse(input).SetDate(year, month, day)
|
|
assert.NotNil(t, c.Error, "It should catch an exception in SeDate()")
|
|
}
|
|
|
|
func TestCarbon_SetTime(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
hour, minute, second int // 输入参数
|
|
expected string // 期望值
|
|
}{
|
|
{"2020-08-05", 13, 14, 15, "2020-08-05 13:14:15"},
|
|
{"2020-08-05", 13, 14, 90, "2020-08-05 13:15:30"},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetTime(test.hour, test.minute, test.second)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.ToDateTimeString(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_SetTime(t *testing.T) {
|
|
input, hour, minute, second := "2020-08-50", 13, 14, 15
|
|
c := Parse(input).SetTime(hour, minute, second)
|
|
assert.NotNil(t, c.Error, "It should catch an exception in SetTime()")
|
|
}
|
|
|
|
func TestCarbon_SetYear(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
year int // 输入参数
|
|
expected string // 期望值
|
|
}{
|
|
{"2020-01-01", 2019, "2019-01-01"},
|
|
{"2020-01-31", 2019, "2019-01-31"},
|
|
{"2020-02-01", 2019, "2019-02-01"},
|
|
{"2020-02-28", 2019, "2019-02-28"},
|
|
{"2020-02-29", 2019, "2019-03-01"},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetYear(test.year)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.ToDateString(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_SetYearNoOverflow(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
year int // 输入参数
|
|
expected string // 期望值
|
|
}{
|
|
{"2020-01-01", 2019, "2019-01-01"},
|
|
{"2020-01-31", 2019, "2019-01-31"},
|
|
{"2020-02-01", 2019, "2019-02-01"},
|
|
{"2020-02-28", 2019, "2019-02-28"},
|
|
{"2020-02-29", 2019, "2019-02-28"},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetYearNoOverflow(test.year)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.ToDateString(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_SetYear(t *testing.T) {
|
|
input, year := "2020-08-50", 2020
|
|
c := Parse(input).SetYear(year)
|
|
assert.NotNil(t, c.Error, "It should catch an exception in SetYear()")
|
|
}
|
|
|
|
func TestError_SetYearNoOverflow(t *testing.T) {
|
|
value, year := "2020-08-50", 2020
|
|
c := Parse(value).SetYearNoOverflow(year)
|
|
assert.NotNil(t, c.Error, "It should catch an exception in SetYearNoOverflow()")
|
|
}
|
|
|
|
func TestCarbon_SetMonth(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
month int // 输入参数
|
|
expected string // 期望值
|
|
}{
|
|
{"2020-01-01", 2, "2020-02-01"},
|
|
{"2020-01-30", 2, "2020-03-01"},
|
|
{"2020-01-31", 2, "2020-03-02"},
|
|
{"2020-08-05", 2, "2020-02-05"},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetMonth(test.month)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.ToDateString(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_SetMonthNoOverflow(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
month int // 输入参数
|
|
expected string // 期望值
|
|
}{
|
|
{"2020-01-01", 2, "2020-02-01"},
|
|
{"2020-01-30", 2, "2020-02-29"},
|
|
{"2020-01-31", 2, "2020-02-29"},
|
|
{"2020-08-05", 2, "2020-02-05"},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetMonthNoOverflow(test.month)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.ToDateString(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_SetMonth(t *testing.T) {
|
|
input, month := "2020-08-50", 12
|
|
c := Parse(input).SetMonth(month)
|
|
assert.NotNil(t, c.Error, "It should catch an exception in SetMonth()")
|
|
}
|
|
|
|
func TestError_SetMonthNoOverflow(t *testing.T) {
|
|
input, month := "2020-08-50", 12
|
|
c := Parse(input).SetMonthNoOverflow(month)
|
|
assert.NotNil(t, c.Error, "It should catch an exception in SetMonthNoOverflow()")
|
|
}
|
|
|
|
func TestCarbon_SetWeekStartsAt(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
week string // 输入参数
|
|
expected string // 期望值
|
|
}{
|
|
{"", Sunday, ""},
|
|
{"0000-00-00 00:00:00", Sunday, ""},
|
|
{"", Monday, ""},
|
|
{"0000-00-00 00:00:00", Monday, ""},
|
|
|
|
{"2021-06-13", Sunday, "2021-06-13 00:00:00"},
|
|
{"2021-06-14", Sunday, "2021-06-13 00:00:00"},
|
|
{"2021-06-18", Sunday, "2021-06-13 00:00:00"},
|
|
|
|
{"2021-06-13", Monday, "2021-06-07 00:00:00"},
|
|
{"2021-06-14", Monday, "2021-06-14 00:00:00"},
|
|
{"2021-06-18", Monday, "2021-06-14 00:00:00"},
|
|
|
|
{"2021-06-13", Tuesday, "2021-06-08 00:00:00"},
|
|
{"2021-06-14", Tuesday, "2021-06-08 00:00:00"},
|
|
{"2021-06-18", Tuesday, "2021-06-15 00:00:00"},
|
|
|
|
{"2021-06-13", Wednesday, "2021-06-09 00:00:00"},
|
|
{"2021-06-14", Wednesday, "2021-06-09 00:00:00"},
|
|
{"2021-06-18", Wednesday, "2021-06-16 00:00:00"},
|
|
|
|
{"2021-06-13", Thursday, "2021-06-10 00:00:00"},
|
|
{"2021-06-14", Thursday, "2021-06-10 00:00:00"},
|
|
{"2021-06-18", Thursday, "2021-06-17 00:00:00"},
|
|
|
|
{"2021-06-13", Friday, "2021-06-11 00:00:00"},
|
|
{"2021-06-14", Friday, "2021-06-11 00:00:00"},
|
|
{"2021-06-18", Friday, "2021-06-18 00:00:00"},
|
|
|
|
{"2021-06-13", Saturday, "2021-06-12 00:00:00"},
|
|
{"2021-06-14", Saturday, "2021-06-12 00:00:00"},
|
|
{"2021-06-18", Saturday, "2021-06-12 00:00:00"},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetWeekStartsAt(test.week).StartOfWeek()
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.ToDateTimeString(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestCarbon_SetDay(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
day int // 输入参数
|
|
expected string // 期望值
|
|
}{
|
|
{"2020-01-01", 31, "2020-01-31"},
|
|
{"2020-02-01", 31, "2020-03-02"},
|
|
{"2020-02-28", 31, "2020-03-02"},
|
|
{"2020-02-29", 31, "2020-03-02"},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetDay(test.day)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.ToDateString(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_SetDay(t *testing.T) {
|
|
input, day := "2020-08-50", 30
|
|
c := Parse(input).SetDay(day)
|
|
assert.NotNil(t, c.Error, "It should catch an exception in SetDay()")
|
|
}
|
|
|
|
func TestCarbon_SetHour(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
hour int // 输入参数
|
|
expected string // 期望值
|
|
}{
|
|
{"2020-08-05 13:14:15", 10, "2020-08-05 10:14:15"},
|
|
{"2020-08-05 13:14:15", 24, "2020-08-06 00:14:15"},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetHour(test.hour)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.ToDateTimeString(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_SetHour(t *testing.T) {
|
|
value, hour := "2020-08-50", 12
|
|
c := Parse(value).SetHour(hour)
|
|
assert.NotNil(t, c.Error, "It should catch an exception in SetHour()")
|
|
}
|
|
|
|
func TestCarbon_SetMinute(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
minute int // 输入参数
|
|
expected string // 期望值
|
|
}{
|
|
{"2020-08-05 13:14:15", 10, "2020-08-05 13:10:15"},
|
|
{"2020-08-05 13:14:15", 60, "2020-08-05 14:00:15"},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetMinute(test.minute)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.ToDateTimeString(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_SetMinute(t *testing.T) {
|
|
input, minute := "2020-08-50", 30
|
|
c := Parse(input).SetMinute(minute)
|
|
assert.NotNil(t, c.Error, "It should catch an exception in SetMinute()")
|
|
}
|
|
|
|
func TestCarbon_SetSecond(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
second int // 输入参数
|
|
expected int // 期望值
|
|
}{
|
|
{"2020-08-05 13:14:15", 10, 10},
|
|
{"2020-08-05 13:14:15", 59, 59},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetSecond(test.second)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.Second(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_SetSecond(t *testing.T) {
|
|
input, second := "2020-08-50", 30
|
|
c := Parse(input).SetSecond(second)
|
|
assert.NotNil(t, c.Error, "It should catch an exception in SetSecond()")
|
|
}
|
|
|
|
func TestCarbon_SetMillisecond(t *testing.T) {
|
|
assert := assert.New(t)
|
|
tests := []struct {
|
|
input string // 输入值
|
|
millisecond int // 输入参数
|
|
expected int // 期望值
|
|
}{
|
|
{"2020-08-05 13:14:15", 100, 100},
|
|
{"2020-08-05 13:14:15", 999, 999},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetMillisecond(test.millisecond)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.Millisecond(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_SetMillisecond(t *testing.T) {
|
|
input, millisecond := "2020-08-50", 100
|
|
c := Parse(input).SetMillisecond(millisecond)
|
|
assert.NotNil(t, c.Error, "It should catch an exception in SetMillisecond()")
|
|
}
|
|
|
|
func TestCarbon_SetMicrosecond(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
microsecond int // 输入参数
|
|
expected int // 期望值
|
|
}{
|
|
{"2020-08-05 13:14:15", 100000, 100000},
|
|
{"2020-08-05 13:14:15", 999999, 999999},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetMicrosecond(test.microsecond)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.Microsecond(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_SetMicrosecond(t *testing.T) {
|
|
input, microsecond := "2020-08-50", 100000
|
|
c := Parse(input).SetMicrosecond(microsecond)
|
|
assert.NotNil(t, c.Error, "It should catch an exception in SetMicrosecond()")
|
|
}
|
|
|
|
func TestCarbon_SetNanosecond(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
tests := []struct {
|
|
input string // 输入值
|
|
nanosecond int // 输入参数
|
|
expected int // 期望值
|
|
}{
|
|
{"2020-08-05 13:14:15", 100000000, 100000000},
|
|
{"2020-08-05 13:14:15", 999999999, 999999999},
|
|
}
|
|
|
|
for index, test := range tests {
|
|
c := Parse(test.input).SetNanosecond(test.nanosecond)
|
|
assert.Nil(c.Error)
|
|
assert.Equal(test.expected, c.Nanosecond(), "Current test index is "+strconv.Itoa(index))
|
|
}
|
|
}
|
|
|
|
func TestError_SetNanosecond(t *testing.T) {
|
|
input, nanosecond := "2020-08-50", 100000000
|
|
c := Parse(input).SetNanosecond(nanosecond)
|
|
assert.NotNil(t, c.Error, "It should catch an exception in SetNanosecond()")
|
|
}
|