fix issue in gres.UnpackContent; fix issue in gtime.NewFromTimeStamp

.example/other/test.go

@@ -1,30 +1,15 @@
 package main
 
 import (
-	"github.com/gogf/gf/frame/g"
-	"github.com/gogf/gf/net/ghttp"
-	"github.com/gogf/gf/os/glog"
+	"fmt"
+	"github.com/gogf/gf/os/gtime"
+	"github.com/gogf/gf/util/gconv"
 )
 
 func main() {
-	s := g.Server()
-	s.Group("/api.v2", func(group *ghttp.RouterGroup) {
-		group.ALL("/user/list", func(r *ghttp.Request) {
-			glog.Debug(r.Method, r.RequestURI)
-
-			paramKey := "X-CSRF-Token"
-
-			// // www-form or query
-			// glog.Debug("go:", r.Request.FormValue(paramKey))
-
-			// // post form-data
-			// glog.Debug("go form:", r.Request.PostFormValue(paramKey))
-
-			glog.Debug("gf GetString:", r.GetString(paramKey))
-			glog.Debug("gf GetFormString:", r.GetFormString(paramKey))
-			r.Response.Writeln("list")
-		})
-	})
-	s.SetPort(8199)
-	s.Run()
+	t1 := gconv.Convert(1989, "Time")
+	t2 := gconv.Time("2033-01-11 04:00:00 +0800 CST")
+	fmt.Println(gtime.Timestamp())
+	fmt.Println(t1)
+	fmt.Println(t2)
 }

os/gfile/gfile_contents.go

@@ -23,7 +23,7 @@ var (
 // GetContents returns the file content of <path> as string.
 // It returns en empty string if it fails reading.
 func GetContents(path string) string {
-	return string(GetBytes(path))
+	return gconv.UnsafeBytesToStr(GetBytes(path))
 }
 
 // GetBytes returns the file content of <path> as []byte.

os/gres/gres_func.go

@@ -91,9 +91,18 @@ func Unpack(path string) ([]*File, error) {
 
 // UnpackContent unpacks the content to []*File.
 func UnpackContent(content string) ([]*File, error) {
-	data, err := gcompress.UnGzip(hexStrToBytes(content))
-	if err != nil {
-		return nil, err
+	var data []byte
+	var err error
+	if isHexStr(content) {
+		data, err = gcompress.UnGzip(hexStrToBytes(content))
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		data, err = gcompress.UnGzip(gconv.UnsafeStrToBytes(content))
+		if err != nil {
+			return nil, err
+		}
 	}
 	reader, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
 	if err != nil {
@@ -106,6 +115,21 @@ func UnpackContent(content string) ([]*File, error) {
 	return array, nil
 }
 
+// isHexStr checks and returns whether given content <s> is hex string.
+// It returns true if <s> is hex string, or false if not.
+func isHexStr(s string) bool {
+	var r bool
+	for i := 0; i < len(s); i++ {
+		r = (s[i] >= '0' && s[i] <= '9') ||
+			(s[i] >= 'a' && s[i] <= 'f') ||
+			(s[i] >= 'A' && s[i] <= 'F')
+		if !r {
+			return false
+		}
+	}
+	return true
+}
+
 // bytesToHexString converts binary content to hex string content.
 func bytesToHexStr(b []byte) string {
 	dst := make([]byte, hex.EncodedLen(len(b)))

os/gres/gres_unit_1_test.go

@@ -7,6 +7,7 @@
 package gres_test
 
 import (
+	"github.com/gogf/gf/os/gtime"
 	"strings"
 	"testing"
 
@@ -17,7 +18,7 @@ import (
 	"github.com/gogf/gf/test/gtest"
 )
 
-func Test_Pack(t *testing.T) {
+func Test_PackToGoFile(t *testing.T) {
 	gtest.Case(t, func() {
 		srcPath := gdebug.CallerDirectory() + "/testdata/files"
 		goFilePath := gdebug.CallerDirectory() + "/testdata/testdata.go"
@@ -27,6 +28,35 @@ func Test_Pack(t *testing.T) {
 	})
 }
 
+func Test_Pack(t *testing.T) {
+	gtest.Case(t, func() {
+		srcPath := gdebug.CallerDirectory() + "/testdata/files"
+		data, err := gres.Pack(srcPath)
+		gtest.Assert(err, nil)
+
+		r := gres.New()
+		err = r.Add(string(data))
+		gtest.Assert(err, nil)
+		gtest.Assert(r.Contains("files"), true)
+	})
+}
+
+func Test_PackToFile(t *testing.T) {
+	gtest.Case(t, func() {
+		srcPath := gdebug.CallerDirectory() + "/testdata/files"
+		dstPath := gfile.Join(gfile.TempDir(), gtime.TimestampNanoStr())
+		err := gres.PackToFile(srcPath, dstPath)
+		gtest.Assert(err, nil)
+
+		defer gfile.Remove(dstPath)
+
+		r := gres.New()
+		err = r.Load(dstPath)
+		gtest.Assert(err, nil)
+		gtest.Assert(r.Contains("files"), true)
+	})
+}
+
 func Test_PackMulti(t *testing.T) {
 	gtest.Case(t, func() {
 		srcPath := gdebug.CallerDirectory() + "/testdata/files"

os/gtime/gtime_time.go

@@ -71,11 +71,18 @@ func NewFromTimeStamp(timestamp int64) *Time {
 	if timestamp == 0 {
 		return &Time{}
 	}
-	for timestamp < 1e18 {
-		timestamp *= 10
+	var sec, nano int64
+	if timestamp > 1e9 {
+		for timestamp < 1e18 {
+			timestamp *= 10
+		}
+		sec = timestamp / 1e9
+		nano = timestamp % 1e9
+	} else {
+		sec = timestamp
 	}
 	return &Time{
-		time.Unix(timestamp/1e9, timestamp%1e9),
+		time.Unix(sec, nano),
 	}
 }
 

util/gconv/gconv_z_all_test.go

@@ -635,9 +635,9 @@ func Test_Convert_All(t *testing.T) {
 		gtest.AssertEQ(gconv.Convert([]string{}, "[]string"), []string{})
 		gtest.AssertEQ(gconv.Convert([2]int{1, 2}, "[]int"), []int{0})
 		gtest.AssertEQ(gconv.Convert("1989-01-02", "Time", "Y-m-d"), gconv.Time("1989-01-02", "Y-m-d"))
-		gtest.AssertEQ(gconv.Convert(1989, "Time"), gconv.Time("2033-01-11 04:00:00 +0800 CST"))
+		gtest.AssertEQ(gconv.Convert(1989, "Time"), gconv.Time("1970-01-01 08:33:09 +0800 CST"))
 		gtest.AssertEQ(gconv.Convert(gtime.Now(), "gtime.Time", 1), nil)
-		gtest.AssertEQ(gconv.Convert(1989, "gtime.Time"), gtime.Time{gconv.Time("2033-01-11 04:00:00 +0800 CST")})
+		gtest.AssertEQ(gconv.Convert(1989, "gtime.Time"), gtime.Time{gconv.Time("1970-01-01 08:33:09 +0800 CST")})
 		gtest.AssertEQ(gconv.Convert(gtime.Now(), "*gtime.Time", 1), nil)
 		gtest.AssertEQ(gconv.Convert(gtime.Now(), "GTime", 1), nil)
 		gtest.AssertEQ(gconv.Convert(1989, "*gtime.Time"), gconv.GTime(1989))