g.Map updates

g/os/gtimer/gtimer_z_unit_1_test.go

@@ -235,7 +235,7 @@ func TestTimer_AddLeveledEntry1(t *testing.T) {
         })
         time.Sleep(1500*time.Millisecond)
         gtest.Assert(array.Len(), 0)
-        time.Sleep(1200*time.Millisecond)
+        time.Sleep(1300*time.Millisecond)
         //glog.Println("check")
         gtest.Assert(array.Len(), 1)
     })

g/test/gtest/gtest.go

@@ -23,6 +23,7 @@ import (
 func Case(t *testing.T, f func()) {
     defer func() {
         if err := recover(); err != nil {
+            panic(err)
             fmt.Fprintf(os.Stderr, "%v\n%s", err, getBacktrace())
             t.Fail()
         }
@@ -253,14 +254,21 @@ func compareMap(value, expect interface{}) error {
     if rvExpect.Kind() == reflect.Map {
         if rvValue.Kind() == reflect.Map {
             if rvExpect.Len() == rvValue.Len() {
+                // 将两个map类型转换为同一个map类型, 才能执行比较,
+                // 直接使用 rvValue.MapIndex(key).Interface() 当key类型不一致时会报错。
+                mValue   := make(map[string]string)
+                mExpect  := make(map[string]string)
+                ksValue  := rvValue.MapKeys()
                 ksExpect := rvExpect.MapKeys()
+                for _, key := range ksValue {
+                    mValue[gconv.String(key.Interface())] = gconv.String(rvValue.MapIndex(key).Interface())
+                }
                 for _, key := range ksExpect {
-                    if fmt.Sprintf("%v", rvValue.MapIndex(key).Interface()) != fmt.Sprintf("%v", rvExpect.MapIndex(key).Interface()) {
-                        return fmt.Errorf(`[ASSERT] EXPECT VALUE map["%v"]:%v == %v`,
-                            key,
-                            rvValue.MapIndex(key).Interface(),
-                            rvExpect.MapIndex(key).Interface(),
-                        )
+                    mExpect[gconv.String(key.Interface())] = gconv.String(rvExpect.MapIndex(key).Interface())
+                }
+                for k, v := range mExpect {
+                    if v != mValue[k] {
+                        return fmt.Errorf(`[ASSERT] EXPECT VALUE map["%v"]:%v == %v`, k, mValue[k], v)
                     }
                 }
             } else {

g/util/gvalid/gvalid_check.go

@@ -105,16 +105,20 @@ var (
 )
 
 // 检测单条数据的规则:
-// value为需要校验的数据，可以为任意基本数据类型；
-// msgs为自定义错误信息，由于同一条数据的校验规则可能存在多条，为方便调用，参数类型支持 string/map[string]string ，允许传递多个自定义的错误信息，如果类型为string，那么中间使用"|"符号分隔多个自定义错误；
-// params参数为联合校验参数，对于需要联合校验的规则有效，如：required-*、same、different；
-func Check(value interface{}, rules string, msgs interface{}, params...map[string]interface{}) *Error {
+//
+// 1. value为需要校验的数据，可以为任意基本数据类型；
+//
+// 2. msgs为自定义错误信息，由于同一条数据的校验规则可能存在多条，为方便调用，参数类型支持 string/map/struct/*struct,
+// 允许传递多个自定义的错误信息，如果类型为string，那么中间使用"|"符号分隔多个自定义错误；
+//
+// 3. params参数为联合校验参数，支持任意的map/struct/*struct类型，对于需要联合校验的规则有效，如：required-*、same、different；
+func Check(value interface{}, rules string, msgs interface{}, params...interface{}) *Error {
     // 内部会将参数全部转换为字符串类型进行校验
     val       := strings.TrimSpace(gconv.String(value))
     data      := make(map[string]string)
     errorMsgs := make(map[string]string)
     if len(params) > 0 {
-        for k, v := range params[0] {
+        for k, v := range gconv.Map(params[0]) {
             data[k] = gconv.String(v)
         }
     }
@@ -122,11 +126,12 @@ func Check(value interface{}, rules string, msgs interface{}, params...map[strin
     msgArray     := make([]string, 0)
     customMsgMap := make(map[string]string)
     switch v := msgs.(type) {
-        case map[string]string:
-            customMsgMap = v
-
         case string:
             msgArray = strings.Split(v, "|")
+        default:
+            for k, v := range gconv.Map(msgs) {
+                data[k] = gconv.String(v)
+            }
     }
     ruleItems := strings.Split(strings.TrimSpace(rules), "|")
     // 规则项预处理, 主要解决规则中存在的"|"关键字符号