diff --git a/calendar/julian/julian_test.go b/calendar/julian/julian_test.go
index 09339114..22daff96 100644
--- a/calendar/julian/julian_test.go
+++ b/calendar/julian/julian_test.go
@@ -1,7 +1,6 @@
 package julian
 
 import (
-	"strconv"
 	"testing"
 	"time"
 
@@ -16,28 +15,33 @@ func TestGregorian_ToJulian(t *testing.T) {
 		j Julian
 	}
 	tests := []struct {
+		name string
 		args args
 		want want
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: want{FromJulian(0)},
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(1800, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: want{FromJulian(2378496.5)},
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2024, 1, 23, 0, 0, 0, 0, time.Local))},
 			want: want{FromJulian(2460332.5)},
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2024, 1, 23, 0, 0, 0, 0, time.Local))},
 			want: want{FromJulian(60332)},
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want.j, (tt.args.g).ToJulian(), "args{%v}", tt.args.g)
 		})
 	}
@@ -48,45 +52,53 @@ func TestJulian_ToGregorian(t *testing.T) {
 		j Julian
 	}
 	tests := []struct {
+		name string
 		args args
 		want string
 	}{
 		{
+			name: "case1",
 			args: args{FromJulian(0)},
 			want: "",
 		},
 		{
+			name: "case2",
 			args: args{FromJulian(2460332.5)},
 			want: "2024-01-23 00:00:00",
 		},
 		{
+			name: "case3",
 			args: args{FromJulian(60332)},
 			want: "2024-01-23 00:00:00",
 		},
 		{
+			name: "case4",
 			args: args{FromJulian(2460333)},
 			want: "2024-01-23 12:00:00",
 		},
 		{
+			name: "case5",
 			args: args{FromJulian(60332.5)},
 			want: "2024-01-23 12:00:00",
 		},
-
 		{
+			name: "case6",
 			args: args{FromJulian(2460333.051563)},
 			want: "2024-01-23 13:14:15",
 		},
 		{
+			name: "case7",
 			args: args{FromJulian(60332.551563)},
 			want: "2024-01-23 13:14:15",
 		},
 		{
+			name: "case8",
 			args: args{FromJulian(60232.5)},
 			want: "2023-10-15 12:00:00",
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.j).ToGregorian().String(), "args{%v}", tt.args.j)
 		})
 	}
@@ -97,28 +109,33 @@ func TestGregorian_JD(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want float64
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(1800, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: 2378496.5,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2024, 1, 23, 0, 0, 0, 0, time.Local))},
 			want: 2460332.5,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2024, 1, 23, 12, 0, 0, 0, time.Local))},
 			want: 2460333,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2024, 1, 23, 13, 14, 15, 0, time.Local))},
 			want: 2460333.051563,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToJulian().JD(6), "args{%v}", tt.args.g)
 		})
 	}
@@ -129,24 +146,28 @@ func TestGregorian_MJD(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want float64
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(2024, 1, 23, 0, 0, 0, 0, time.Local))},
 			want: 60332,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2024, 1, 23, 12, 0, 0, 0, time.Local))},
 			want: 60332.5,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2024, 1, 23, 13, 14, 15, 0, time.Local))},
 			want: 60332.551563,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToJulian().MJD(6), "args{%v}", tt.args.g)
 		})
 	}
diff --git a/calendar/lunar/lunar_test.go b/calendar/lunar/lunar_test.go
index d2c4f0f7..fecd24b4 100644
--- a/calendar/lunar/lunar_test.go
+++ b/calendar/lunar/lunar_test.go
@@ -1,7 +1,6 @@
 package lunar
 
 import (
-	"strconv"
 	"testing"
 	"time"
 
@@ -13,24 +12,28 @@ func TestGregorian_ToLunar(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want string
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(2024, 1, 21, 0, 0, 0, 0, time.Local))},
 			want: "2023-12-11 00:00:00",
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2023, 3, 2, 0, 0, 0, 0, time.Local))},
 			want: "2023-02-11 00:00:00",
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2023, 4, 1, 0, 0, 0, 0, time.Local))},
 			want: "2023-02-11 00:00:00",
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().String(), "args{%v}", tt.args.g)
 		})
 	}
@@ -41,40 +44,48 @@ func TestLunar_ToGregorian(t *testing.T) {
 		l Lunar
 	}
 	tests := []struct {
+		name string
 		args args
 		want string
 	}{
 		{
+			name: "case1",
 			args: args{Lunar{}},
 			want: "",
 		},
 		{
+			name: "case2",
 			args: args{FromLunar(0, 0, 0, 0, 0, 0, false)},
 			want: "",
 		},
 		{
+			name: "case3",
 			args: args{FromLunar(2023, 12, 11, 0, 0, 0, false)},
 			want: "2024-01-21 00:00:00",
 		},
 		{
+			name: "case4",
 			args: args{FromLunar(2023, 2, 11, 0, 0, 0, false)},
 			want: "2023-03-02 00:00:00",
 		},
 		{
+			name: "case5",
 			args: args{FromLunar(2023, 2, 11, 0, 0, 0, true)},
 			want: "2023-04-01 00:00:00",
 		},
 		{
+			name: "case6",
 			args: args{FromLunar(1800, 2, 11, 0, 0, 0, false)},
 			want: "",
 		},
 		{
+			name: "case7",
 			args: args{FromLunar(2500, 2, 11, 0, 0, 0, false)},
 			want: "",
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.l).ToGregorian().String(), "args{%v}", tt.args.l)
 		})
 	}
@@ -85,88 +96,108 @@ func TestLunar_Animal(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want string
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: "",
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: "",
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: "鼠",
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: "鼠",
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 7, 7, 0, 0, 0, 0, time.Local))},
 			want: "牛",
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2010, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: "虎",
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2011, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: "兔",
 		},
 		{
+			name: "case8",
 			args: args{FromGregorian(time.Date(2012, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: "龙",
 		},
 		{
+			name: "case9",
 			args: args{FromGregorian(time.Date(2013, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: "蛇",
 		},
 		{
+			name: "case10",
 			args: args{FromGregorian(time.Date(2014, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: "马",
 		},
 		{
+			name: "case11",
 			args: args{FromGregorian(time.Date(2015, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: "羊",
 		},
 		{
+			name: "case12",
 			args: args{FromGregorian(time.Date(2016, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: "猴",
 		},
 		{
+			name: "case13",
 			args: args{FromGregorian(time.Date(2017, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: "鸡",
 		},
 		{
+			name: "case14",
 			args: args{FromGregorian(time.Date(2018, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: "狗",
 		},
 		{
+			name: "case15",
 			args: args{FromGregorian(time.Date(2019, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: "猪",
 		},
 		{
+			name: "case16",
 			args: args{FromGregorian(time.Date(2020, 5, 23, 0, 0, 0, 0, time.Local))},
 			want: "鼠",
 		},
 		{
+			name: "case17",
 			args: args{FromGregorian(time.Date(2020, 6, 21, 0, 0, 0, 0, time.Local))},
 			want: "鼠",
 		},
 		{
+			name: "case18",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: "鼠",
 		},
 		{
+			name: "case19",
 			args: args{FromGregorian(time.Date(2021, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: "牛",
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().Animal(), "args{%v}", tt.args.g)
 		})
 	}
@@ -177,64 +208,78 @@ func TestLunar_Festival(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want string
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: "",
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: "",
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: "",
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2021, 2, 12, 0, 0, 0, 0, time.Local))},
 			want: "春节",
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 2, 26, 0, 0, 0, 0, time.Local))},
 			want: "元宵节",
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2021, 6, 14, 0, 0, 0, 0, time.Local))},
 			want: "端午节",
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2021, 8, 14, 0, 0, 0, 0, time.Local))},
 			want: "七夕节",
 		},
 		{
+			name: "case8",
 			args: args{FromGregorian(time.Date(2021, 8, 22, 0, 0, 0, 0, time.Local))},
 			want: "中元节",
 		},
 		{
+			name: "case9",
 			args: args{FromGregorian(time.Date(2021, 9, 21, 0, 0, 0, 0, time.Local))},
 			want: "中秋节",
 		},
 		{
+			name: "case10",
 			args: args{FromGregorian(time.Date(2021, 10, 14, 0, 0, 0, 0, time.Local))},
 			want: "重阳节",
 		},
 		{
+			name: "case11",
 			args: args{FromGregorian(time.Date(2021, 11, 5, 0, 0, 0, 0, time.Local))},
 			want: "寒衣节",
 		},
 		{
+			name: "case12",
 			args: args{FromGregorian(time.Date(2021, 11, 19, 0, 0, 0, 0, time.Local))},
 			want: "下元节",
 		},
 		{
+			name: "case13",
 			args: args{FromGregorian(time.Date(2022, 1, 10, 0, 0, 0, 0, time.Local))},
 			want: "腊八节",
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().Festival(), "args{%v}", tt.args.g)
 		})
 	}
@@ -245,28 +290,33 @@ func TestLunar_Year(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want int
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: 0,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: 0,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: 2020,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2021, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: 2021,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().Year(), "args{%v}", tt.args.g)
 		})
 	}
@@ -277,14 +327,17 @@ func TestLunar_Month(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want int
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: 0,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: 0,
 		},
@@ -293,52 +346,63 @@ func TestLunar_Month(t *testing.T) {
 			want: 1,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2021, 4, 5, 0, 0, 0, 0, time.Local))},
 			want: 2,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2021, 5, 5, 0, 0, 0, 0, time.Local))},
 			want: 3,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 6, 5, 0, 0, 0, 0, time.Local))},
 			want: 4,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2021, 7, 5, 0, 0, 0, 0, time.Local))},
 			want: 5,
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2021, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: 6,
 		},
 		{
+			name: "case8",
 			args: args{FromGregorian(time.Date(2021, 9, 5, 0, 0, 0, 0, time.Local))},
 			want: 7,
 		},
 		{
+			name: "case9",
 			args: args{FromGregorian(time.Date(2021, 10, 5, 0, 0, 0, 0, time.Local))},
 			want: 8,
 		},
 		{
+			name: "case10",
 			args: args{FromGregorian(time.Date(2021, 10, 20, 0, 0, 0, 0, time.Local))},
 			want: 9,
 		},
 		{
+			name: "case11",
 			args: args{FromGregorian(time.Date(2021, 11, 5, 0, 0, 0, 0, time.Local))},
 			want: 10,
 		},
 		{
+			name: "case12",
 			args: args{FromGregorian(time.Date(2022, 12, 5, 0, 0, 0, 0, time.Local))},
 			want: 11,
 		},
 		{
+			name: "case13",
 			args: args{FromGregorian(time.Date(2022, 1, 5, 0, 0, 0, 0, time.Local))},
 			want: 12,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().Month(), "args{%v}", tt.args.g)
 		})
 	}
@@ -349,36 +413,43 @@ func TestLunar_Day(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want int
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: 0,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: 0,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 8, 19, 0, 0, 0, 0, time.Local))},
 			want: 1,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 8, 20, 0, 0, 0, 0, time.Local))},
 			want: 2,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2020, 8, 21, 0, 0, 0, 0, time.Local))},
 			want: 3,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2020, 8, 22, 0, 0, 0, 0, time.Local))},
 			want: 4,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().Day(), "args{%v}", tt.args.g)
 		})
 	}
@@ -389,24 +460,28 @@ func TestLunar_Hour(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want int
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: 0,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: 0,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 8, 19, 13, 14, 15, 0, time.Local))},
 			want: 13,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().Hour(), "args{%v}", tt.args.g)
 		})
 	}
@@ -417,24 +492,28 @@ func TestLunar_Minute(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want int
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: 0,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: 0,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 8, 19, 13, 14, 15, 0, time.Local))},
 			want: 14,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().Minute(), "args{%v}", tt.args.g)
 		})
 	}
@@ -445,24 +524,28 @@ func TestLunar_Second(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want int
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: 0,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: 0,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 8, 19, 13, 14, 15, 0, time.Local))},
 			want: 15,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().Second(), "args{%v}", tt.args.g)
 		})
 	}
@@ -473,28 +556,33 @@ func TestLunar_LeapMonth(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want int
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: 0,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: 0,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: 4,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2021, 7, 1, 0, 0, 0, 0, time.Local))},
 			want: 0,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().LeapMonth(), "args{%v}", tt.args.g)
 		})
 	}
@@ -505,28 +593,33 @@ func TestLunar_ToYearString(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want string
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: "",
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: "",
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: "二零二零",
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2021, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: "二零二一",
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().ToYearString(), "args{%v}", tt.args.g)
 		})
 	}
@@ -537,76 +630,93 @@ func TestLunar_ToMonthString(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want string
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: "",
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: "",
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: "腊月",
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 2, 1, 0, 0, 0, 0, time.Local))},
 			want: "正月",
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2020, 3, 1, 0, 0, 0, 0, time.Local))},
 			want: "二月",
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2020, 4, 1, 0, 0, 0, 0, time.Local))},
 			want: "三月",
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: "闰四月",
 		},
 		{
+			name: "case8",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: "闰四月",
 		},
 		{
+			name: "case9",
 			args: args{FromGregorian(time.Date(2020, 6, 1, 0, 0, 0, 0, time.Local))},
 			want: "闰四月",
 		},
 		{
+			name: "case10",
 			args: args{FromGregorian(time.Date(2020, 7, 1, 0, 0, 0, 0, time.Local))},
 			want: "五月",
 		},
 		{
+			name: "case11",
 			args: args{FromGregorian(time.Date(2020, 8, 1, 0, 0, 0, 0, time.Local))},
 			want: "六月",
 		},
 		{
+			name: "case12",
 			args: args{FromGregorian(time.Date(2020, 9, 1, 0, 0, 0, 0, time.Local))},
 			want: "七月",
 		},
 		{
+			name: "case13",
 			args: args{FromGregorian(time.Date(2020, 10, 1, 0, 0, 0, 0, time.Local))},
 			want: "八月",
 		},
 		{
+			name: "case14",
 			args: args{FromGregorian(time.Date(2020, 11, 1, 0, 0, 0, 0, time.Local))},
 			want: "九月",
 		},
 		{
+			name: "case15",
 			args: args{FromGregorian(time.Date(2020, 12, 1, 0, 0, 0, 0, time.Local))},
 			want: "十月",
 		},
 		{
+			name: "case16",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: "十一月",
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().ToMonthString(), "args{%v}", tt.args.g)
 		})
 	}
@@ -617,44 +727,53 @@ func TestLunar_ToWeekString(t *testing.T) {
 		l Lunar
 	}
 	tests := []struct {
+		name string
 		args args
 		want string
 	}{
 		{
+			name: "case1",
 			args: args{Lunar{}},
 			want: "",
 		},
 		{
+			name: "case2",
 			args: args{FromLunar(0, 0, 0, 0, 0, 0, false)},
 			want: "",
 		},
 		{
+			name: "case3",
 			args: args{FromLunar(2023, 12, 20, 0, 0, 0, false)},
 			want: "周二",
 		},
 		{
+			name: "case4",
 			args: args{FromLunar(2023, 12, 21, 0, 0, 0, false)},
 			want: "周三",
 		},
 		{
+			name: "case5",
 			args: args{FromLunar(2023, 12, 22, 0, 0, 0, false)},
 			want: "周四",
 		},
 		{
+			name: "case6",
 			args: args{FromLunar(2023, 12, 23, 0, 0, 0, false)},
 			want: "周五",
 		},
 		{
+			name: "case7",
 			args: args{FromLunar(2023, 12, 24, 0, 0, 0, false)},
 			want: "周六",
 		},
 		{
+			name: "case8",
 			args: args{FromLunar(2023, 12, 25, 0, 0, 0, false)},
 			want: "周日",
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.l).ToWeekString(), "args{%v}", tt.args.l)
 		})
 	}
@@ -665,80 +784,98 @@ func TestLunar_ToDayString(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want string
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: "",
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: "",
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: "初七",
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 2, 1, 0, 0, 0, 0, time.Local))},
 			want: "初八",
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2020, 3, 1, 0, 0, 0, 0, time.Local))},
 			want: "初八",
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2020, 4, 1, 0, 0, 0, 0, time.Local))},
 			want: "初九",
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: "初九",
 		},
 		{
+			name: "case8",
 			args: args{FromGregorian(time.Date(2020, 6, 1, 0, 0, 0, 0, time.Local))},
 			want: "初十",
 		},
 		{
+			name: "case9",
 			args: args{FromGregorian(time.Date(2020, 7, 1, 0, 0, 0, 0, time.Local))},
 			want: "十一",
 		},
 		{
+			name: "case10",
 			args: args{FromGregorian(time.Date(2020, 8, 1, 0, 0, 0, 0, time.Local))},
 			want: "十二",
 		},
 		{
+			name: "case11",
 			args: args{FromGregorian(time.Date(2020, 9, 1, 0, 0, 0, 0, time.Local))},
 			want: "十四",
 		},
 		{
+			name: "case12",
 			args: args{FromGregorian(time.Date(2020, 10, 1, 0, 0, 0, 0, time.Local))},
 			want: "十五",
 		},
 		{
+			name: "case13",
 			args: args{FromGregorian(time.Date(2020, 11, 1, 0, 0, 0, 0, time.Local))},
 			want: "十六",
 		},
 		{
+			name: "case14",
 			args: args{FromGregorian(time.Date(2020, 12, 1, 0, 0, 0, 0, time.Local))},
 			want: "十七",
 		},
 		{
+			name: "case15",
 			args: args{FromGregorian(time.Date(2021, 1, 3, 0, 0, 0, 0, time.Local))},
 			want: "二十",
 		},
 		{
+			name: "case16",
 			args: args{FromGregorian(time.Date(2021, 1, 5, 0, 0, 0, 0, time.Local))},
 			want: "廿二",
 		},
 		{
+			name: "case17",
 			args: args{FromGregorian(time.Date(2021, 4, 11, 0, 0, 0, 0, time.Local))},
 			want: "三十",
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().ToDayString(), "args{%v}", tt.args.g)
 		})
 	}
@@ -749,52 +886,63 @@ func TestLunar_String(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want string
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: "",
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: "",
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: "2019-12-07 00:00:00",
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 2, 1, 0, 0, 0, 0, time.Local))},
 			want: "2020-01-08 00:00:00",
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2020, 3, 1, 0, 0, 0, 0, time.Local))},
 			want: "2020-02-08 00:00:00",
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2020, 4, 1, 0, 0, 0, 0, time.Local))},
 			want: "2020-03-09 00:00:00",
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: "2020-04-09 00:00:00",
 		},
 		{
+			name: "case8",
 			args: args{FromGregorian(time.Date(2020, 6, 1, 0, 0, 0, 0, time.Local))},
 			want: "2020-04-10 00:00:00",
 		},
 		{
+			name: "case9",
 			args: args{FromGregorian(time.Date(2020, 7, 1, 0, 0, 0, 0, time.Local))},
 			want: "2020-05-11 00:00:00",
 		},
 		{
+			name: "case10",
 			args: args{FromGregorian(time.Date(2020, 8, 1, 0, 0, 0, 0, time.Local))},
 			want: "2020-06-12 00:00:00",
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().String(), "args{%v}", tt.args.g)
 		})
 	}
@@ -805,68 +953,83 @@ func TestLunar_ToDateString(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want string
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: "",
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: "",
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: "二零一九年腊月初七",
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 2, 1, 0, 0, 0, 0, time.Local))},
 			want: "二零二零年正月初八",
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2020, 3, 1, 0, 0, 0, 0, time.Local))},
 			want: "二零二零年二月初八",
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2020, 4, 1, 0, 0, 0, 0, time.Local))},
 			want: "二零二零年三月初九",
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: "二零二零年闰四月初九",
 		},
 		{
+			name: "case8",
 			args: args{FromGregorian(time.Date(2020, 6, 1, 0, 0, 0, 0, time.Local))},
 			want: "二零二零年闰四月初十",
 		},
 		{
+			name: "case9",
 			args: args{FromGregorian(time.Date(2020, 7, 1, 0, 0, 0, 0, time.Local))},
 			want: "二零二零年五月十一",
 		},
 		{
+			name: "case10",
 			args: args{FromGregorian(time.Date(2020, 8, 1, 0, 0, 0, 0, time.Local))},
 			want: "二零二零年六月十二",
 		},
 		{
+			name: "case11",
 			args: args{FromGregorian(time.Date(2020, 9, 1, 0, 0, 0, 0, time.Local))},
 			want: "二零二零年七月十四",
 		},
 		{
+			name: "case12",
 			args: args{FromGregorian(time.Date(2020, 10, 1, 0, 0, 0, 0, time.Local))},
 			want: "二零二零年八月十五",
 		},
 		{
+			name: "case13",
 			args: args{FromGregorian(time.Date(2020, 11, 1, 0, 0, 0, 0, time.Local))},
 			want: "二零二零年九月十六",
 		},
 		{
+			name: "case14",
 			args: args{FromGregorian(time.Date(2020, 12, 1, 0, 0, 0, 0, time.Local))},
 			want: "二零二零年十月十七",
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().ToDateString(), "args{%v}", tt.args.g)
 		})
 	}
@@ -877,48 +1040,58 @@ func TestLunar_IsLeapYear(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want bool
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: false,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 		{
+			name: "case8",
 			args: args{FromGregorian(time.Date(2021, 7, 7, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case9",
 			args: args{FromGregorian(time.Date(2022, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().IsLeapYear(), "args{%v}", tt.args.g)
 		})
 	}
@@ -929,40 +1102,48 @@ func TestLunar_IsLeapMonth(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want bool
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2021, 7, 7, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2022, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().IsLeapMonth(), "args{%v}", tt.args.g)
 		})
 	}
@@ -973,40 +1154,48 @@ func TestLunar_IsRatYear(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want bool
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2021, 7, 7, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2022, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().IsRatYear(), "args{%v}", tt.args.g)
 		})
 	}
@@ -1017,40 +1206,48 @@ func TestLunar_IsOxYear(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want bool
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2021, 7, 7, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2022, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().IsOxYear(), "args{%v}", tt.args.g)
 		})
 	}
@@ -1061,40 +1258,48 @@ func TestLunar_IsTigerYear(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want bool
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2021, 7, 7, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2022, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().IsTigerYear(), "args{%v}", tt.args.g)
 		})
 	}
@@ -1105,40 +1310,48 @@ func TestLunar_IsRabbitYear(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want bool
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2021, 7, 7, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2023, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().IsRabbitYear(), "args{%v}", tt.args.g)
 		})
 	}
@@ -1149,40 +1362,48 @@ func TestLunar_IsDragonYear(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want bool
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2021, 7, 7, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2024, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().IsDragonYear(), "args{%v}", tt.args.g)
 		})
 	}
@@ -1193,40 +1414,48 @@ func TestLunar_IsSnakeYear(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want bool
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2021, 7, 7, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2025, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().IsSnakeYear(), "args{%v}", tt.args.g)
 		})
 	}
@@ -1237,40 +1466,48 @@ func TestLunar_IsHorseYear(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want bool
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2021, 7, 7, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2026, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().IsHorseYear(), "args{%v}", tt.args.g)
 		})
 	}
@@ -1281,40 +1518,48 @@ func TestLunar_IsGoatYear(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want bool
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2021, 7, 7, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2027, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().IsGoatYear(), "args{%v}", tt.args.g)
 		})
 	}
@@ -1325,40 +1570,48 @@ func TestLunar_IsMonkeyYear(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want bool
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2021, 7, 7, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2028, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().IsMonkeyYear(), "args{%v}", tt.args.g)
 		})
 	}
@@ -1369,40 +1622,48 @@ func TestLunar_IsRoosterYear(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want bool
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2021, 7, 7, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2029, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().IsRoosterYear(), "args{%v}", tt.args.g)
 		})
 	}
@@ -1413,40 +1674,48 @@ func TestLunar_IsDogYear(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want bool
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 7, 7, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2030, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().IsDogYear(), "args{%v}", tt.args.g)
 		})
 	}
@@ -1457,40 +1726,48 @@ func TestLunar_IsPigYear(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want bool
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(2020, 4, 23, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2021, 7, 7, 0, 0, 0, 0, time.Local))},
 			want: false,
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2031, 8, 5, 0, 0, 0, 0, time.Local))},
 			want: true,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToLunar().IsPigYear(), "args{%v}", tt.args.g)
 		})
 	}
diff --git a/calendar/persian/persian_test.go b/calendar/persian/persian_test.go
index d4300a2e..1e0c81c1 100755
--- a/calendar/persian/persian_test.go
+++ b/calendar/persian/persian_test.go
@@ -1,7 +1,6 @@
 package persian
 
 import (
-	"strconv"
 	"testing"
 	"time"
 
@@ -13,40 +12,48 @@ func TestGregorian_ToPersian(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want string
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: "",
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: "",
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(1800, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: "1178-10-11 00:00:00",
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2024, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: "1402-10-11 00:00:00",
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2024, 8, 5, 12, 0, 0, 0, time.Local))},
 			want: "1403-05-15 12:00:00",
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2024, 12, 31, 23, 59, 59, 0, time.Local))},
 			want: "1403-10-11 23:59:59",
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2645, 3, 21, 0, 0, 0, 0, time.Local))},
 			want: "2024-01-01 00:00:00",
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToPersian().String(), "args{%v}", tt.args.g)
 		})
 	}
@@ -57,45 +64,54 @@ func TestPersian_ToGregorian(t *testing.T) {
 		p Persian
 	}
 	tests := []struct {
+		name string
 		args args
 		want string
 	}{
 		{
+			name: "case1",
 			args: args{Persian{}},
 			want: "",
 		},
 		{
+			name: "case2",
 			args: args{FromPersian(0, 0, 0, 0, 0, 0)},
 			want: "",
 		},
 		{
+			name: "case3",
 			args: args{FromPersian(1395, 1, 1, 0, 0, 0)},
 			want: "2016-03-20 00:00:00",
 		},
 		{
+			name: "case4",
 			args: args{FromPersian(1402, 10, 11, 0, 0, 0)},
 			want: "2024-01-01 00:00:00",
 		},
 		{
+			name: "case5",
 			args: args{FromPersian(1403, 5, 15, 12, 0, 0)},
 			want: "2024-08-05 12:00:00",
 		},
 		{
+			name: "case6",
 			args: args{FromPersian(1403, 10, 11, 23, 59, 59)},
 			want: "2024-12-31 23:59:59",
 		},
 
 		{
+			name: "case7",
 			args: args{FromPersian(2024, 1, 1, 0, 0, 0)},
 			want: "2645-03-21 00:00:00",
 		},
 		{
+			name: "case8",
 			args: args{FromPersian(2100, 12, 31, 23, 59, 59)},
 			want: "2722-03-22 23:59:59",
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.p).ToGregorian().String(), "args{%v}", tt.args.p)
 		})
 	}
@@ -106,32 +122,38 @@ func TestPersian_Year(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want int
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: 0,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: 0,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2024, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: 1402,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2024, 8, 5, 12, 0, 0, 0, time.Local))},
 			want: 1403,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2024, 12, 31, 23, 59, 59, 0, time.Local))},
 			want: 1403,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToPersian().Year(), "args{%v}", tt.args.g)
 		})
 	}
@@ -142,32 +164,38 @@ func TestPersian_Month(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want int
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: 0,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: 0,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2024, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: 10,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2024, 8, 5, 12, 0, 0, 0, time.Local))},
 			want: 5,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2024, 12, 31, 23, 59, 59, 0, time.Local))},
 			want: 10,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToPersian().Month(), "args{%v}", tt.args.g)
 		})
 	}
@@ -178,32 +206,38 @@ func TestPersian_Day(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want int
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: 0,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: 0,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2024, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: 11,
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2024, 8, 5, 12, 0, 0, 0, time.Local))},
 			want: 15,
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2024, 12, 31, 23, 59, 59, 0, time.Local))},
 			want: 11,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToPersian().Day(), "args{%v}", tt.args.g)
 		})
 	}
@@ -214,24 +248,28 @@ func TestPersian_Hour(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want int
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: 0,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: 0,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 8, 19, 13, 14, 15, 0, time.Local))},
 			want: 13,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToPersian().Hour(), "args{%v}", tt.args.g)
 		})
 	}
@@ -242,24 +280,28 @@ func TestPersian_Minute(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want int
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: 0,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: 0,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 8, 19, 13, 14, 15, 0, time.Local))},
 			want: 14,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToPersian().Minute(), "args{%v}", tt.args.g)
 		})
 	}
@@ -270,24 +312,28 @@ func TestPersian_Second(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want int
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: 0,
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: 0,
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 8, 19, 13, 14, 15, 0, time.Local))},
 			want: 15,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToPersian().Second(), "args{%v}", tt.args.g)
 		})
 	}
@@ -298,72 +344,88 @@ func TestPersian_ToMonthString(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want string
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: "",
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: "",
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: "دی",
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 2, 1, 0, 0, 0, 0, time.Local))},
 			want: "بهمن",
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2020, 3, 1, 0, 0, 0, 0, time.Local))},
 			want: "اسفند",
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2020, 4, 1, 0, 0, 0, 0, time.Local))},
 			want: "فروردین",
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: "اردیبهشت",
 		},
 		{
+			name: "case8",
 			args: args{FromGregorian(time.Date(2020, 6, 1, 0, 0, 0, 0, time.Local))},
 			want: "خرداد",
 		},
 		{
+			name: "case9",
 			args: args{FromGregorian(time.Date(2020, 7, 1, 0, 0, 0, 0, time.Local))},
 			want: "تیر",
 		},
 		{
+			name: "case10",
 			args: args{FromGregorian(time.Date(2020, 8, 1, 0, 0, 0, 0, time.Local))},
 			want: "مرداد",
 		},
 		{
+			name: "case11",
 			args: args{FromGregorian(time.Date(2020, 9, 1, 0, 0, 0, 0, time.Local))},
 			want: "شهریور",
 		},
 		{
+			name: "case12",
 			args: args{FromGregorian(time.Date(2020, 10, 1, 0, 0, 0, 0, time.Local))},
 			want: "مهر",
 		},
 		{
+			name: "case13",
 			args: args{FromGregorian(time.Date(2020, 11, 1, 0, 0, 0, 0, time.Local))},
 			want: "آبان",
 		},
 		{
+			name: "case14",
 			args: args{FromGregorian(time.Date(2020, 12, 1, 0, 0, 0, 0, time.Local))},
 			want: "آذر",
 		},
 		{
+			name: "case15",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: "دی",
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToPersian().ToMonthString(), "args{%v}", tt.args.g)
 		})
 	}
@@ -374,72 +436,88 @@ func TestPersian_ToWeekString(t *testing.T) {
 		g Gregorian
 	}
 	tests := []struct {
+		name string
 		args args
 		want string
 	}{
 		{
+			name: "case1",
 			args: args{FromGregorian(time.Time{})},
 			want: "",
 		},
 		{
+			name: "case2",
 			args: args{FromGregorian(time.Date(0, 0, 0, 0, 0, 0, 0, time.Local))},
 			want: "",
 		},
 		{
+			name: "case3",
 			args: args{FromGregorian(time.Date(2020, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: "چهارشنبه",
 		},
 		{
+			name: "case4",
 			args: args{FromGregorian(time.Date(2020, 2, 1, 0, 0, 0, 0, time.Local))},
 			want: "شنبه",
 		},
 		{
+			name: "case5",
 			args: args{FromGregorian(time.Date(2020, 3, 1, 0, 0, 0, 0, time.Local))},
 			want: "یکشنبه",
 		},
 		{
+			name: "case6",
 			args: args{FromGregorian(time.Date(2020, 4, 1, 0, 0, 0, 0, time.Local))},
 			want: "چهارشنبه",
 		},
 		{
+			name: "case7",
 			args: args{FromGregorian(time.Date(2020, 5, 1, 0, 0, 0, 0, time.Local))},
 			want: "جمعه",
 		},
 		{
+			name: "case8",
 			args: args{FromGregorian(time.Date(2020, 6, 1, 0, 0, 0, 0, time.Local))},
 			want: "دوشنبه",
 		},
 		{
+			name: "case9",
 			args: args{FromGregorian(time.Date(2020, 7, 1, 0, 0, 0, 0, time.Local))},
 			want: "چهارشنبه",
 		},
 		{
+			name: "case10",
 			args: args{FromGregorian(time.Date(2020, 8, 1, 0, 0, 0, 0, time.Local))},
 			want: "شنبه",
 		},
 		{
+			name: "case11",
 			args: args{FromGregorian(time.Date(2020, 9, 1, 0, 0, 0, 0, time.Local))},
 			want: "سه شنبه",
 		},
 		{
+			name: "case12",
 			args: args{FromGregorian(time.Date(2020, 10, 1, 0, 0, 0, 0, time.Local))},
 			want: "پنجشنبه",
 		},
 		{
+			name: "case13",
 			args: args{FromGregorian(time.Date(2020, 11, 1, 0, 0, 0, 0, time.Local))},
 			want: "یکشنبه",
 		},
 		{
+			name: "case14",
 			args: args{FromGregorian(time.Date(2020, 12, 1, 0, 0, 0, 0, time.Local))},
 			want: "سه شنبه",
 		},
 		{
+			name: "case15",
 			args: args{FromGregorian(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local))},
 			want: "جمعه",
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.g).ToPersian().ToWeekString(), "args{%v}", tt.args.g)
 		})
 	}
@@ -450,28 +528,33 @@ func TestPersian_IsLeapYear(t *testing.T) {
 		p Persian
 	}
 	tests := []struct {
+		name string
 		args args
 		want bool
 	}{
 		{
+			name: "case1",
 			args: args{Persian{}},
 			want: false,
 		},
 		{
+			name: "cas2",
 			args: args{FromPersian(0, 0, 0, 0, 0, 0)},
 			want: false,
 		},
 		{
+			name: "case3",
 			args: args{FromPersian(1394, 1, 1, 0, 0, 0)},
 			want: false,
 		},
 		{
+			name: "case4",
 			args: args{FromPersian(1395, 1, 1, 0, 0, 0)},
 			want: true,
 		},
 	}
-	for index, tt := range tests {
-		t.Run(strconv.Itoa(index), func(t *testing.T) {
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
 			assert.Equalf(t, tt.want, (tt.args.p).IsLeapYear(), "args{%v}", tt.args.p)
 		})
 	}