diff --git a/g/os/gtime/gtime_z_bench_test.go b/g/os/gtime/gtime_z_bench_test.go
index 4375df43d..1b6e60c54 100644
--- a/g/os/gtime/gtime_z_bench_test.go
+++ b/g/os/gtime/gtime_z_bench_test.go
@@ -4,50 +4,70 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
-package gtime
+package gtime_test
 
 import (
-    "testing"
+	"testing"
+
+	"github.com/gogf/gf/g/os/gtime"
 )
 
 func Benchmark_Second(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        Second()
-    }
+	for i := 0; i < b.N; i++ {
+		gtime.Second()
+	}
 }
 
 func Benchmark_Millisecond(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        Millisecond()
-    }
+	for i := 0; i < b.N; i++ {
+		gtime.Millisecond()
+	}
 }
 
 func Benchmark_Microsecond(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        Microsecond()
-    }
+	for i := 0; i < b.N; i++ {
+		gtime.Microsecond()
+	}
 }
 
 func Benchmark_Nanosecond(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        Nanosecond()
-    }
+	for i := 0; i < b.N; i++ {
+		gtime.Nanosecond()
+	}
 }
 
 func Benchmark_StrToTime(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        StrToTime("2018-02-09T20:46:17.897Z")
-    }
+	for i := 0; i < b.N; i++ {
+		gtime.StrToTime("2018-02-09T20:46:17.897Z")
+	}
 }
 
 func Benchmark_ParseTimeFromContent(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ParseTimeFromContent("2018-02-09T20:46:17.897Z")
-    }
+	for i := 0; i < b.N; i++ {
+		gtime.ParseTimeFromContent("2018-02-09T20:46:17.897Z")
+	}
 }
 
 func Benchmark_NewFromTimeStamp(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        NewFromTimeStamp(1542674930)
-    }
-}
\ No newline at end of file
+	for i := 0; i < b.N; i++ {
+		gtime.NewFromTimeStamp(1542674930)
+	}
+}
+
+func Benchmark_Date(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		gtime.Date()
+	}
+}
+
+func Benchmark_Datetime(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		gtime.Datetime()
+	}
+}
+
+func Benchmark_SetTimeZone(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		gtime.SetTimeZone("Asia/Shanghai")
+	}
+}
diff --git a/g/os/gtime/gtime_z_unit_basic_test.go b/g/os/gtime/gtime_z_unit_basic_test.go
new file mode 100644
index 000000000..9499b3ac5
--- /dev/null
+++ b/g/os/gtime/gtime_z_unit_basic_test.go
@@ -0,0 +1,238 @@
+package gtime_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/g/os/gtime"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+func Test_SetTimeZone(t *testing.T) {
+	gtest.Case(t, func() {
+		gtime.SetTimeZone("Asia/Shanghai")
+		gtest.Assert(time.Local.String(), "Asia/Shanghai")
+	})
+}
+
+func Test_Nanosecond(t *testing.T) {
+	gtest.Case(t, func() {
+		nanos := gtime.Nanosecond()
+		timeTemp := time.Unix(0, nanos)
+		gtest.Assert(nanos, timeTemp.UnixNano())
+	})
+}
+
+func Test_Microsecond(t *testing.T) {
+	gtest.Case(t, func() {
+		micros := gtime.Microsecond()
+		timeTemp := time.Unix(0, micros*1e3)
+		gtest.Assert(micros, timeTemp.UnixNano()/1e3)
+	})
+}
+
+func Test_Millisecond(t *testing.T) {
+	gtest.Case(t, func() {
+		millis := gtime.Millisecond()
+		timeTemp := time.Unix(0, millis*1e6)
+		gtest.Assert(millis, timeTemp.UnixNano()/1e6)
+	})
+}
+
+func Test_Second(t *testing.T) {
+	gtest.Case(t, func() {
+		s := gtime.Second()
+		timeTemp := time.Unix(s, 0)
+		gtest.Assert(s, timeTemp.Unix())
+	})
+}
+
+func Test_Date(t *testing.T) {
+	gtest.Case(t, func() {
+		gtest.Assert(gtime.Date(), time.Now().Format("2006-01-02"))
+	})
+}
+
+func Test_Datetime(t *testing.T) {
+	gtest.Case(t, func() {
+		datetime := gtime.Datetime()
+		timeTemp, err := gtime.StrToTime(datetime, "Y-m-d H:i:s")
+		if err != nil {
+			t.Error("test fail")
+		}
+		gtest.Assert(datetime, timeTemp.Time.Format("2006-01-02 15:04:05"))
+	})
+}
+
+/*
+func Test_parseDateStr(t *testing.T) {
+	gtest.Case(t, func() {
+		//正常日期列表
+		var testDates = []string{
+			"2006-01-02",
+			"2006/01/02",
+			"2006.01.02",
+			"06.01.02",
+			"02.jan.2006",
+		}
+
+		for _, item := range testDates {
+			year, month, day := parseDateStr(item)
+			gtest.Assert(year, 2006)
+			gtest.Assert(month, 1)
+			gtest.Assert(day, 2)
+		}
+
+		//异常日期列表
+		var testDatesFail = []string{
+			"2006.01",
+			"06..02",
+		}
+
+		for _, item := range testDatesFail {
+			year, month, day := parseDateStr(item)
+			gtest.Assert(year, 0)
+			gtest.Assert(month, 0)
+			gtest.Assert(day, 0)
+		}
+
+	})
+}
+*/
+//
+func Test_ConvertZone(t *testing.T) {
+	gtest.Case(t, func() {
+		//现行时间
+		nowUTC := time.Now().UTC()
+		testZone := "America/Los_Angeles"
+
+		//转换为洛杉矶时间
+		t1, err := gtime.ConvertZone(nowUTC.Format("2006-01-02 15:04:05"), testZone, "")
+		if err != nil {
+			t.Error("test fail")
+		}
+
+		//使用洛杉矶时区解析上面转换后的时间
+		laStr := t1.Time.Format("2006-01-02 15:04:05")
+		loc, err := time.LoadLocation(testZone)
+		t2, err := time.ParseInLocation("2006-01-02 15:04:05", laStr, loc)
+
+		//判断是否与现行时间匹配
+		gtest.Assert(t2.UTC().Unix(), nowUTC.Unix())
+
+	})
+
+	//test err
+	gtest.Case(t, func() {
+		//现行时间
+		nowUTC := time.Now().UTC()
+		//t.Log(nowUTC.Unix())
+		testZone := "errZone"
+
+		//错误时间输入
+		_, err := gtime.ConvertZone(nowUTC.Format("06..02 15:04:05"), testZone, "")
+		if err == nil {
+			t.Error("test fail")
+		}
+		//错误时区输入
+		_, err = gtime.ConvertZone(nowUTC.Format("2006-01-02 15:04:05"), testZone, "")
+		if err == nil {
+			t.Error("test fail")
+		}
+		//错误时区输入
+		_, err = gtime.ConvertZone(nowUTC.Format("2006-01-02 15:04:05"), testZone, testZone)
+		if err == nil {
+			t.Error("test fail")
+		}
+	})
+}
+
+func Test_StrToTime(t *testing.T) {
+	gtest.Case(t, func() {
+		//正常日期列表
+		var testDatetimes = []string{
+			"2006-01-02 15:04:05",
+			"2006/01/02 15:04:05",
+			"2006.01.02 15:04:05.000",
+			"2006.01.02 - 15:04:05",
+			"2006.01.02 15:04:05 +0800 CST",
+			"2006-01-02T20:05:06+05:01:01",
+			"2006-01-02T14:03:04Z01:01:01",
+			"2006-01-02T15:04:05Z",
+			"02-jan-2006 15:04:05",
+			"02/jan/2006 15:04:05",
+			"02.jan.2006 15:04:05",
+			"02.jan.2006:15:04:05",
+		}
+
+		for _, item := range testDatetimes {
+			timeTemp, err := gtime.StrToTime(item)
+			if err != nil {
+				t.Error("test fail")
+			}
+			gtest.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2006-01-02 15:04:05")
+		}
+
+		//正常日期列表，时间00:00:00
+		var testDates = []string{
+			"2006.01.02",
+			"2006.01.02 00:00",
+			"2006.01.02 00:00:00.000",
+		}
+
+		for _, item := range testDates {
+			timeTemp, err := gtime.StrToTime(item)
+			if err != nil {
+				t.Error("test fail")
+			}
+			gtest.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2006-01-02 00:00:00")
+		}
+
+		//异常日期列表
+		var testDatesFail = []string{
+			"2006.01",
+			"06..02",
+			"20060102",
+		}
+
+		for _, item := range testDatesFail {
+			_, err := gtime.StrToTime(item)
+			if err == nil {
+				t.Error("test fail")
+			}
+		}
+
+		//test err
+		_, err := gtime.StrToTime("2006-01-02 15:04:05", "aabbccdd")
+		if err == nil {
+			t.Error("test fail")
+		}
+	})
+}
+
+func Test_ParseTimeFromContent(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.ParseTimeFromContent("我是中文2006-01-02 15:04:05我也是中文", "Y-m-d H:i:s")
+		gtest.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2006-01-02 15:04:05")
+
+		timeTemp1 := gtime.ParseTimeFromContent("我是中文2006-01-02 15:04:05我也是中文")
+		gtest.Assert(timeTemp1.Time.Format("2006-01-02 15:04:05"), "2006-01-02 15:04:05")
+
+		timeTemp2 := gtime.ParseTimeFromContent("我是中文02.jan.2006 15:04:05我也是中文")
+		gtest.Assert(timeTemp2.Time.Format("2006-01-02 15:04:05"), "2006-01-02 15:04:05")
+
+		//test err
+		timeTempErr := gtime.ParseTimeFromContent("我是中文", "Y-m-d H:i:s")
+		if timeTempErr != nil {
+			t.Error("test fail")
+		}
+	})
+}
+
+func Test_FuncCost(t *testing.T) {
+	gtest.Case(t, func() {
+		gtime.FuncCost(func() {
+
+		})
+	})
+}
diff --git a/g/os/gtime/gtime_z_unit_format_test.go b/g/os/gtime/gtime_z_unit_format_test.go
new file mode 100644
index 000000000..09f5e9cb3
--- /dev/null
+++ b/g/os/gtime/gtime_z_unit_format_test.go
@@ -0,0 +1,65 @@
+package gtime_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/g/os/gtime"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+/*
+func Test_formatToStdLayout(t *testing.T) {
+	gtest.Case(t, func() {
+		gtest.Assert(formatToStdLayout("Y-m-d H:i:s"), "2006-01-02 15:04:05")
+		gtest.Assert(formatToStdLayout("\\T\\i\\m\\e Y-m-d H:i:s"), "Time 2006-01-02 15:04:05")
+		gtest.Assert(formatToStdLayout("Y-m-d H:i:s\\"), "2006-01-02 15:04:05")
+		gtest.Assert(formatToStdLayout("Y-m-j G:i:s.u"), "2006-01-02 15:04:05.000")
+		gtest.Assert(formatToStdLayout("Y-m-j G:i:su"), "2006-01-02 15:04:05.000")
+	})
+}
+*/
+func Test_Format(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp, err := gtime.StrToTime("2006-01-11 15:04:05", "Y-m-d H:i:s")
+		timeTemp.ToZone("Asia/Shanghai")
+		if err != nil {
+			t.Error("test fail")
+		}
+		gtest.Assert(timeTemp.Format("\\T\\i\\m\\e中文Y-m-j G:i:s.u\\"), "Time中文2006-01-11 15:04:05.000")
+
+		gtest.Assert(timeTemp.Format("d D j l"), "11 Wed 11 Wednesday")
+
+		gtest.Assert(timeTemp.Format("F m M n"), "January 01 Jan 1")
+
+		gtest.Assert(timeTemp.Format("Y y"), "2006 06")
+
+		gtest.Assert(timeTemp.Format("a A g G h H i s u .u"), "pm PM 3 15 03 15 04 05 000 .000")
+
+		gtest.Assert(timeTemp.Format("O P T"), "+0800 +08:00 CST")
+
+		gtest.Assert(timeTemp.Format("r"), "Wed, 11 Jan 06 15:04 CST")
+
+		gtest.Assert(timeTemp.Format("c"), "2006-01-11T15:04:05+08:00")
+
+		//补零
+		timeTemp1, err := gtime.StrToTime("2006-01-02 03:04:05", "Y-m-d H:i:s")
+		if err != nil {
+			t.Error("test fail")
+		}
+		gtest.Assert(timeTemp1.Format("Y-m-d h:i:s"), "2006-01-02 03:04:05")
+		//不补零
+		timeTemp2, err := gtime.StrToTime("2006-01-02 03:04:05", "Y-m-d H:i:s")
+		if err != nil {
+			t.Error("test fail")
+		}
+		gtest.Assert(timeTemp2.Format("Y-n-j G:i:s"), "2006-1-2 3:04:05")
+
+	})
+}
+
+func Test_Layout(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		gtest.Assert(timeTemp.Layout("2006-01-02 15:04:05"), timeTemp.Time.Format("2006-01-02 15:04:05"))
+	})
+}
diff --git a/g/os/gtime/gtime_z_unit_time_test.go b/g/os/gtime/gtime_z_unit_time_test.go
new file mode 100644
index 000000000..22dbe5e46
--- /dev/null
+++ b/g/os/gtime/gtime_z_unit_time_test.go
@@ -0,0 +1,189 @@
+package gtime_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/g/os/gtime"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+func Test_New(t *testing.T) {
+	gtest.Case(t, func() {
+		timeNow := time.Now()
+		timeTemp := gtime.New(timeNow)
+		gtest.Assert(timeTemp.Time.UnixNano(), timeNow.UnixNano())
+
+		timeTemp1 := gtime.New()
+		gtest.Assert(timeTemp1.Time, time.Time{})
+	})
+}
+
+func Test_NewFromStr(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.NewFromStr("2006-01-02 15:04:05")
+		gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:05")
+
+		timeTemp1 := gtime.NewFromStr("20060102")
+		if timeTemp1 != nil {
+			t.Error("test fail")
+		}
+	})
+}
+
+func Test_NewFromStrFormat(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.NewFromStrFormat("2006-01-02 15:04:05", "Y-m-d H:i:s")
+		gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:05")
+
+		timeTemp1 := gtime.NewFromStrFormat("2006-01-02 15:04:05", "aabbcc")
+		if timeTemp1 != nil {
+			t.Error("test fail")
+		}
+	})
+}
+
+func Test_NewFromStrLayout(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.NewFromStrLayout("2006-01-02 15:04:05", "2006-01-02 15:04:05")
+		gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:05")
+
+		timeTemp1 := gtime.NewFromStrLayout("2006-01-02 15:04:05", "aabbcc")
+		if timeTemp1 != nil {
+			t.Error("test fail")
+		}
+	})
+}
+
+func Test_NewFromTimeStamp(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.NewFromTimeStamp(1554459846000)
+		gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2019-04-05 18:24:06")
+		timeTemp1 := gtime.NewFromTimeStamp(0)
+		gtest.Assert(timeTemp1.Format("Y-m-d H:i:s"), "0001-01-01 00:00:00")
+	})
+}
+
+func Test_tSecond(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		gtest.Assert(timeTemp.Second(), timeTemp.Time.Unix())
+	})
+}
+
+func Test_tNanosecond(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		gtest.Assert(timeTemp.Nanosecond(), timeTemp.Time.UnixNano())
+	})
+}
+
+func Test_tMicrosecond(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		gtest.Assert(timeTemp.Microsecond(), timeTemp.Time.UnixNano()/1e3)
+	})
+}
+
+func Test_tMillisecond(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		gtest.Assert(timeTemp.Millisecond(), timeTemp.Time.UnixNano()/1e6)
+	})
+}
+
+func Test_String(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		gtest.Assert(timeTemp.String(), timeTemp.Time.Format("2006-01-02 15:04:05"))
+	})
+}
+
+func Test_Clone(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		timeTemp1 := timeTemp.Clone()
+		gtest.Assert(timeTemp.Time.Unix(), timeTemp1.Time.Unix())
+	})
+}
+
+func Test_ToTime(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		timeTemp1 := timeTemp.Time
+		gtest.Assert(timeTemp.ToTime().UnixNano(), timeTemp1.UnixNano())
+	})
+}
+
+func Test_Add(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.NewFromStr("2006-01-02 15:04:05")
+		timeTemp.Add(time.Second)
+		gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:06")
+	})
+}
+
+func Test_ToZone(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		//
+		timeTemp.ToZone("America/Los_Angeles")
+		gtest.Assert(timeTemp.Time.Location().String(), "America/Los_Angeles")
+
+		loc, err := time.LoadLocation("Asia/Shanghai")
+		if err != nil {
+			t.Error("test fail")
+		}
+		timeTemp.ToLocation(loc)
+		gtest.Assert(timeTemp.Time.Location().String(), "Asia/Shanghai")
+
+		timeTemp1 := timeTemp.ToZone("errZone")
+		if timeTemp1 != nil {
+			t.Error("test fail")
+		}
+	})
+}
+
+func Test_AddDate(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.NewFromStr("2006-01-02 15:04:05")
+		timeTemp.AddDate(1, 2, 3)
+		gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2007-03-05 15:04:05")
+	})
+}
+
+func Test_UTC(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		timeTemp1 := timeTemp.Time
+		timeTemp.UTC()
+		gtest.Assert(timeTemp.UnixNano(), timeTemp1.UTC().UnixNano())
+	})
+}
+
+func Test_Local(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		timeTemp1 := timeTemp.Time
+		timeTemp.Local()
+		gtest.Assert(timeTemp.UnixNano(), timeTemp1.Local().UnixNano())
+	})
+}
+
+func Test_Round(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		timeTemp1 := timeTemp.Time
+		timeTemp.Round(time.Hour)
+		gtest.Assert(timeTemp.UnixNano(), timeTemp1.Round(time.Hour).UnixNano())
+	})
+}
+
+func Test_Truncate(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		timeTemp1 := timeTemp.Time
+		timeTemp.Truncate(time.Hour)
+		gtest.Assert(timeTemp.UnixNano(), timeTemp1.Truncate(time.Hour).UnixNano())
+	})
+}