diff --git a/container/garray/garray_z_unit_normal_any_array_test.go b/container/garray/garray_z_unit_normal_any_array_test.go
index b656ad4fb..8984a8670 100644
--- a/container/garray/garray_z_unit_normal_any_array_test.go
+++ b/container/garray/garray_z_unit_normal_any_array_test.go
@@ -541,31 +541,31 @@ func TestArray_RemoveValue(t *testing.T) {
}
func TestArray_UnmarshalValue(t *testing.T) {
- type T struct {
+ type Var struct {
Name string
Array *garray.Array
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(g.Map{
"name": "john",
"array": []byte(`[1,2,3]`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Array.Slice(), g.Slice{1, 2, 3})
+ t.Assert(v.Name, "john")
+ t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(g.Map{
"name": "john",
"array": g.Slice{1, 2, 3},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Array.Slice(), g.Slice{1, 2, 3})
+ t.Assert(v.Name, "john")
+ t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
})
}
diff --git a/container/garray/garray_z_unit_normal_int_array_test.go b/container/garray/garray_z_unit_normal_int_array_test.go
index db9bff224..6895ed433 100644
--- a/container/garray/garray_z_unit_normal_int_array_test.go
+++ b/container/garray/garray_z_unit_normal_int_array_test.go
@@ -576,31 +576,31 @@ func TestIntArray_RemoveValue(t *testing.T) {
}
func TestIntArray_UnmarshalValue(t *testing.T) {
- type T struct {
+ type Var struct {
Name string
Array *garray.IntArray
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(g.Map{
"name": "john",
"array": []byte(`[1,2,3]`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Array.Slice(), g.Slice{1, 2, 3})
+ t.Assert(v.Name, "john")
+ t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(g.Map{
"name": "john",
"array": g.Slice{1, 2, 3},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Array.Slice(), g.Slice{1, 2, 3})
+ t.Assert(v.Name, "john")
+ t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
})
}
diff --git a/container/garray/garray_z_unit_normal_str_array_test.go b/container/garray/garray_z_unit_normal_str_array_test.go
index f1e1b8a6d..0791d0a6a 100644
--- a/container/garray/garray_z_unit_normal_str_array_test.go
+++ b/container/garray/garray_z_unit_normal_str_array_test.go
@@ -579,31 +579,31 @@ func TestStrArray_RemoveValue(t *testing.T) {
}
func TestStrArray_UnmarshalValue(t *testing.T) {
- type T struct {
+ type Var struct {
Name string
Array *garray.StrArray
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(g.Map{
"name": "john",
"array": []byte(`["1","2","3"]`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Array.Slice(), g.SliceStr{"1", "2", "3"})
+ t.Assert(v.Name, "john")
+ t.Assert(v.Array.Slice(), g.SliceStr{"1", "2", "3"})
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(g.Map{
"name": "john",
"array": g.SliceStr{"1", "2", "3"},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Array.Slice(), g.SliceStr{"1", "2", "3"})
+ t.Assert(v.Name, "john")
+ t.Assert(v.Array.Slice(), g.SliceStr{"1", "2", "3"})
})
}
diff --git a/container/glist/glist_z_unit_test.go b/container/glist/glist_z_unit_test.go
index 49a249b2a..9d145d796 100644
--- a/container/glist/glist_z_unit_test.go
+++ b/container/glist/glist_z_unit_test.go
@@ -16,7 +16,7 @@ import (
)
// 检查链表长度
-func checkListLen(t *testing.T, l *List, len int) bool {
+func checkListLen(t *gtest.T, l *List, len int) bool {
if n := l.Len(); n != len {
t.Errorf("l.Len() = %d, want %d", n, len)
return false
@@ -25,7 +25,7 @@ func checkListLen(t *testing.T, l *List, len int) bool {
}
// 检查指针地址
-func checkListPointers(t *testing.T, l *List, es []*Element) {
+func checkListPointers(t *gtest.T, l *List, es []*Element) {
if !checkListLen(t, l, len(es)) {
return
}
@@ -80,87 +80,89 @@ func TestBasic(t *testing.T) {
}
func TestList(t *testing.T) {
- l := New()
- checkListPointers(t, l, []*Element{})
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ checkListPointers(t, l, []*Element{})
- // Single element list
- e := l.PushFront("a")
- checkListPointers(t, l, []*Element{e})
- l.MoveToFront(e)
- checkListPointers(t, l, []*Element{e})
- l.MoveToBack(e)
- checkListPointers(t, l, []*Element{e})
- l.Remove(e)
- checkListPointers(t, l, []*Element{})
-
- // Bigger list
- e2 := l.PushFront(2)
- e1 := l.PushFront(1)
- e3 := l.PushBack(3)
- e4 := l.PushBack("banana")
- checkListPointers(t, l, []*Element{e1, e2, e3, e4})
-
- l.Remove(e2)
- checkListPointers(t, l, []*Element{e1, e3, e4})
-
- l.MoveToFront(e3) // move from middle
- checkListPointers(t, l, []*Element{e3, e1, e4})
-
- l.MoveToFront(e1)
- l.MoveToBack(e3) // move from middle
- checkListPointers(t, l, []*Element{e1, e4, e3})
-
- l.MoveToFront(e3) // move from back
- checkListPointers(t, l, []*Element{e3, e1, e4})
- l.MoveToFront(e3) // should be no-op
- checkListPointers(t, l, []*Element{e3, e1, e4})
-
- l.MoveToBack(e3) // move from front
- checkListPointers(t, l, []*Element{e1, e4, e3})
- l.MoveToBack(e3) // should be no-op
- checkListPointers(t, l, []*Element{e1, e4, e3})
-
- e2 = l.InsertBefore(e1, 2) // insert before front
- checkListPointers(t, l, []*Element{e2, e1, e4, e3})
- l.Remove(e2)
- e2 = l.InsertBefore(e4, 2) // insert before middle
- checkListPointers(t, l, []*Element{e1, e2, e4, e3})
- l.Remove(e2)
- e2 = l.InsertBefore(e3, 2) // insert before back
- checkListPointers(t, l, []*Element{e1, e4, e2, e3})
- l.Remove(e2)
-
- e2 = l.InsertAfter(e1, 2) // insert after front
- checkListPointers(t, l, []*Element{e1, e2, e4, e3})
- l.Remove(e2)
- e2 = l.InsertAfter(e4, 2) // insert after middle
- checkListPointers(t, l, []*Element{e1, e4, e2, e3})
- l.Remove(e2)
- e2 = l.InsertAfter(e3, 2) // insert after back
- checkListPointers(t, l, []*Element{e1, e4, e3, e2})
- l.Remove(e2)
-
- // Check standard iteration.
- sum := 0
- for e := l.Front(); e != nil; e = e.Next() {
- if i, ok := e.Value.(int); ok {
- sum += i
- }
- }
- if sum != 4 {
- t.Errorf("sum over l = %d, want 4", sum)
- }
-
- // Clear all elements by iterating
- var next *Element
- for e := l.Front(); e != nil; e = next {
- next = e.Next()
+ // Single element list
+ e := l.PushFront("a")
+ checkListPointers(t, l, []*Element{e})
+ l.MoveToFront(e)
+ checkListPointers(t, l, []*Element{e})
+ l.MoveToBack(e)
+ checkListPointers(t, l, []*Element{e})
l.Remove(e)
- }
- checkListPointers(t, l, []*Element{})
+ checkListPointers(t, l, []*Element{})
+
+ // Bigger list
+ e2 := l.PushFront(2)
+ e1 := l.PushFront(1)
+ e3 := l.PushBack(3)
+ e4 := l.PushBack("banana")
+ checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+
+ l.Remove(e2)
+ checkListPointers(t, l, []*Element{e1, e3, e4})
+
+ l.MoveToFront(e3) // move from middle
+ checkListPointers(t, l, []*Element{e3, e1, e4})
+
+ l.MoveToFront(e1)
+ l.MoveToBack(e3) // move from middle
+ checkListPointers(t, l, []*Element{e1, e4, e3})
+
+ l.MoveToFront(e3) // move from back
+ checkListPointers(t, l, []*Element{e3, e1, e4})
+ l.MoveToFront(e3) // should be no-op
+ checkListPointers(t, l, []*Element{e3, e1, e4})
+
+ l.MoveToBack(e3) // move from front
+ checkListPointers(t, l, []*Element{e1, e4, e3})
+ l.MoveToBack(e3) // should be no-op
+ checkListPointers(t, l, []*Element{e1, e4, e3})
+
+ e2 = l.InsertBefore(e1, 2) // insert before front
+ checkListPointers(t, l, []*Element{e2, e1, e4, e3})
+ l.Remove(e2)
+ e2 = l.InsertBefore(e4, 2) // insert before middle
+ checkListPointers(t, l, []*Element{e1, e2, e4, e3})
+ l.Remove(e2)
+ e2 = l.InsertBefore(e3, 2) // insert before back
+ checkListPointers(t, l, []*Element{e1, e4, e2, e3})
+ l.Remove(e2)
+
+ e2 = l.InsertAfter(e1, 2) // insert after front
+ checkListPointers(t, l, []*Element{e1, e2, e4, e3})
+ l.Remove(e2)
+ e2 = l.InsertAfter(e4, 2) // insert after middle
+ checkListPointers(t, l, []*Element{e1, e4, e2, e3})
+ l.Remove(e2)
+ e2 = l.InsertAfter(e3, 2) // insert after back
+ checkListPointers(t, l, []*Element{e1, e4, e3, e2})
+ l.Remove(e2)
+
+ // Check standard iteration.
+ sum := 0
+ for e := l.Front(); e != nil; e = e.Next() {
+ if i, ok := e.Value.(int); ok {
+ sum += i
+ }
+ }
+ if sum != 4 {
+ t.Errorf("sum over l = %d, want 4", sum)
+ }
+
+ // Clear all elements by iterating
+ var next *Element
+ for e := l.Front(); e != nil; e = next {
+ next = e.Next()
+ l.Remove(e)
+ }
+ checkListPointers(t, l, []*Element{})
+ })
}
-func checkList(t *testing.T, l *List, es []interface{}) {
+func checkList(t *gtest.T, l *List, es []interface{}) {
if !checkListLen(t, l, len(es)) {
return
}
@@ -193,60 +195,64 @@ func checkList(t *testing.T, l *List, es []interface{}) {
}
func TestExtending(t *testing.T) {
- l1 := New()
- l2 := New()
+ gtest.C(t, func(t *gtest.T) {
+ l1 := New()
+ l2 := New()
- l1.PushBack(1)
- l1.PushBack(2)
- l1.PushBack(3)
+ l1.PushBack(1)
+ l1.PushBack(2)
+ l1.PushBack(3)
- l2.PushBack(4)
- l2.PushBack(5)
+ l2.PushBack(4)
+ l2.PushBack(5)
- l3 := New()
- l3.PushBackList(l1)
- checkList(t, l3, []interface{}{1, 2, 3})
- l3.PushBackList(l2)
- checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
+ l3 := New()
+ l3.PushBackList(l1)
+ checkList(t, l3, []interface{}{1, 2, 3})
+ l3.PushBackList(l2)
+ checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
- l3 = New()
- l3.PushFrontList(l2)
- checkList(t, l3, []interface{}{4, 5})
- l3.PushFrontList(l1)
- checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
+ l3 = New()
+ l3.PushFrontList(l2)
+ checkList(t, l3, []interface{}{4, 5})
+ l3.PushFrontList(l1)
+ checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
- checkList(t, l1, []interface{}{1, 2, 3})
- checkList(t, l2, []interface{}{4, 5})
+ checkList(t, l1, []interface{}{1, 2, 3})
+ checkList(t, l2, []interface{}{4, 5})
- l3 = New()
- l3.PushBackList(l1)
- checkList(t, l3, []interface{}{1, 2, 3})
- l3.PushBackList(l3)
- checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
+ l3 = New()
+ l3.PushBackList(l1)
+ checkList(t, l3, []interface{}{1, 2, 3})
+ l3.PushBackList(l3)
+ checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
- l3 = New()
- l3.PushFrontList(l1)
- checkList(t, l3, []interface{}{1, 2, 3})
- l3.PushFrontList(l3)
- checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
+ l3 = New()
+ l3.PushFrontList(l1)
+ checkList(t, l3, []interface{}{1, 2, 3})
+ l3.PushFrontList(l3)
+ checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
- l3 = New()
- l1.PushBackList(l3)
- checkList(t, l1, []interface{}{1, 2, 3})
- l1.PushFrontList(l3)
- checkList(t, l1, []interface{}{1, 2, 3})
+ l3 = New()
+ l1.PushBackList(l3)
+ checkList(t, l1, []interface{}{1, 2, 3})
+ l1.PushFrontList(l3)
+ checkList(t, l1, []interface{}{1, 2, 3})
+ })
}
func TestRemove(t *testing.T) {
- l := New()
- e1 := l.PushBack(1)
- e2 := l.PushBack(2)
- checkListPointers(t, l, []*Element{e1, e2})
- //e := l.Front()
- //l.Remove(e)
- //checkListPointers(t, l, []*Element{e2})
- //l.Remove(e)
- //checkListPointers(t, l, []*Element{e2})
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ e1 := l.PushBack(1)
+ e2 := l.PushBack(2)
+ checkListPointers(t, l, []*Element{e1, e2})
+ //e := l.Front()
+ //l.Remove(e)
+ //checkListPointers(t, l, []*Element{e2})
+ //l.Remove(e)
+ //checkListPointers(t, l, []*Element{e2})
+ })
}
func TestIssue4103(t *testing.T) {
@@ -289,122 +295,138 @@ func TestIssue6349(t *testing.T) {
}
func TestMove(t *testing.T) {
- l := New()
- e1 := l.PushBack(1)
- e2 := l.PushBack(2)
- e3 := l.PushBack(3)
- e4 := l.PushBack(4)
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ e1 := l.PushBack(1)
+ e2 := l.PushBack(2)
+ e3 := l.PushBack(3)
+ e4 := l.PushBack(4)
- l.MoveAfter(e3, e3)
- checkListPointers(t, l, []*Element{e1, e2, e3, e4})
- l.MoveBefore(e2, e2)
- checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+ l.MoveAfter(e3, e3)
+ checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+ l.MoveBefore(e2, e2)
+ checkListPointers(t, l, []*Element{e1, e2, e3, e4})
- l.MoveAfter(e3, e2)
- checkListPointers(t, l, []*Element{e1, e2, e3, e4})
- l.MoveBefore(e2, e3)
- checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+ l.MoveAfter(e3, e2)
+ checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+ l.MoveBefore(e2, e3)
+ checkListPointers(t, l, []*Element{e1, e2, e3, e4})
- l.MoveBefore(e2, e4)
- checkListPointers(t, l, []*Element{e1, e3, e2, e4})
- e2, e3 = e3, e2
+ l.MoveBefore(e2, e4)
+ checkListPointers(t, l, []*Element{e1, e3, e2, e4})
+ e2, e3 = e3, e2
- l.MoveBefore(e4, e1)
- checkListPointers(t, l, []*Element{e4, e1, e2, e3})
- e1, e2, e3, e4 = e4, e1, e2, e3
+ l.MoveBefore(e4, e1)
+ checkListPointers(t, l, []*Element{e4, e1, e2, e3})
+ e1, e2, e3, e4 = e4, e1, e2, e3
- l.MoveAfter(e4, e1)
- checkListPointers(t, l, []*Element{e1, e4, e2, e3})
- e2, e3, e4 = e4, e2, e3
+ l.MoveAfter(e4, e1)
+ checkListPointers(t, l, []*Element{e1, e4, e2, e3})
+ e2, e3, e4 = e4, e2, e3
- l.MoveAfter(e2, e3)
- checkListPointers(t, l, []*Element{e1, e3, e2, e4})
- e2, e3 = e3, e2
+ l.MoveAfter(e2, e3)
+ checkListPointers(t, l, []*Element{e1, e3, e2, e4})
+ e2, e3 = e3, e2
+ })
}
// Test PushFront, PushBack, PushFrontList, PushBackList with uninitialized List
func TestZeroList(t *testing.T) {
- var l1 = New()
- l1.PushFront(1)
- checkList(t, l1, []interface{}{1})
+ gtest.C(t, func(t *gtest.T) {
+ var l1 = New()
+ l1.PushFront(1)
+ checkList(t, l1, []interface{}{1})
- var l2 = New()
- l2.PushBack(1)
- checkList(t, l2, []interface{}{1})
+ var l2 = New()
+ l2.PushBack(1)
+ checkList(t, l2, []interface{}{1})
- var l3 = New()
- l3.PushFrontList(l1)
- checkList(t, l3, []interface{}{1})
+ var l3 = New()
+ l3.PushFrontList(l1)
+ checkList(t, l3, []interface{}{1})
- var l4 = New()
- l4.PushBackList(l2)
- checkList(t, l4, []interface{}{1})
+ var l4 = New()
+ l4.PushBackList(l2)
+ checkList(t, l4, []interface{}{1})
+ })
}
// Test that a list l is not modified when calling InsertBefore with a mark that is not an element of l.
func TestInsertBeforeUnknownMark(t *testing.T) {
- l := New()
- l.PushBack(1)
- l.PushBack(2)
- l.PushBack(3)
- l.InsertBefore(new(Element), 1)
- checkList(t, l, []interface{}{1, 2, 3})
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ l.PushBack(1)
+ l.PushBack(2)
+ l.PushBack(3)
+ l.InsertBefore(new(Element), 1)
+ checkList(t, l, []interface{}{1, 2, 3})
+ })
}
// Test that a list l is not modified when calling InsertAfter with a mark that is not an element of l.
func TestInsertAfterUnknownMark(t *testing.T) {
- l := New()
- l.PushBack(1)
- l.PushBack(2)
- l.PushBack(3)
- l.InsertAfter(new(Element), 1)
- checkList(t, l, []interface{}{1, 2, 3})
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ l.PushBack(1)
+ l.PushBack(2)
+ l.PushBack(3)
+ l.InsertAfter(new(Element), 1)
+ checkList(t, l, []interface{}{1, 2, 3})
+ })
}
// Test that a list l is not modified when calling MoveAfter or MoveBefore with a mark that is not an element of l.
func TestMoveUnknownMark(t *testing.T) {
- l1 := New()
- e1 := l1.PushBack(1)
+ gtest.C(t, func(t *gtest.T) {
+ l1 := New()
+ e1 := l1.PushBack(1)
- l2 := New()
- e2 := l2.PushBack(2)
+ l2 := New()
+ e2 := l2.PushBack(2)
- l1.MoveAfter(e1, e2)
- checkList(t, l1, []interface{}{1})
- checkList(t, l2, []interface{}{2})
+ l1.MoveAfter(e1, e2)
+ checkList(t, l1, []interface{}{1})
+ checkList(t, l2, []interface{}{2})
- l1.MoveBefore(e1, e2)
- checkList(t, l1, []interface{}{1})
- checkList(t, l2, []interface{}{2})
+ l1.MoveBefore(e1, e2)
+ checkList(t, l1, []interface{}{1})
+ checkList(t, l2, []interface{}{2})
+ })
}
func TestList_RemoveAll(t *testing.T) {
- l := New()
- l.PushBack(1)
- l.RemoveAll()
- checkList(t, l, []interface{}{})
- l.PushBack(2)
- checkList(t, l, []interface{}{2})
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ l.PushBack(1)
+ l.RemoveAll()
+ checkList(t, l, []interface{}{})
+ l.PushBack(2)
+ checkList(t, l, []interface{}{2})
+ })
}
func TestList_PushFronts(t *testing.T) {
- l := New()
- a1 := []interface{}{1, 2}
- l.PushFronts(a1)
- checkList(t, l, []interface{}{2, 1})
- a1 = []interface{}{3, 4, 5}
- l.PushFronts(a1)
- checkList(t, l, []interface{}{5, 4, 3, 2, 1})
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ a1 := []interface{}{1, 2}
+ l.PushFronts(a1)
+ checkList(t, l, []interface{}{2, 1})
+ a1 = []interface{}{3, 4, 5}
+ l.PushFronts(a1)
+ checkList(t, l, []interface{}{5, 4, 3, 2, 1})
+ })
}
func TestList_PushBacks(t *testing.T) {
- l := New()
- a1 := []interface{}{1, 2}
- l.PushBacks(a1)
- checkList(t, l, []interface{}{1, 2})
- a1 = []interface{}{3, 4, 5}
- l.PushBacks(a1)
- checkList(t, l, []interface{}{1, 2, 3, 4, 5})
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ a1 := []interface{}{1, 2}
+ l.PushBacks(a1)
+ checkList(t, l, []interface{}{1, 2})
+ a1 = []interface{}{3, 4, 5}
+ l.PushBacks(a1)
+ checkList(t, l, []interface{}{1, 2, 3, 4, 5})
+ })
}
func TestList_PopBacks(t *testing.T) {
@@ -423,165 +445,190 @@ func TestList_PopBacks(t *testing.T) {
}
func TestList_PopFronts(t *testing.T) {
- l := New()
- a1 := []interface{}{1, 2, 3, 4}
- l.PushFronts(a1)
- i1 := l.PopFronts(2)
- t.Assert(i1, []interface{}{4, 3})
- t.Assert(l.Len(), 2)
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ a1 := []interface{}{1, 2, 3, 4}
+ l.PushFronts(a1)
+ i1 := l.PopFronts(2)
+ t.Assert(i1, []interface{}{4, 3})
+ t.Assert(l.Len(), 2)
+ })
}
func TestList_PopBackAll(t *testing.T) {
- l := New()
- a1 := []interface{}{1, 2, 3, 4}
- l.PushFronts(a1)
- i1 := l.PopBackAll()
- t.Assert(i1, []interface{}{1, 2, 3, 4})
- t.Assert(l.Len(), 0)
-
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ a1 := []interface{}{1, 2, 3, 4}
+ l.PushFronts(a1)
+ i1 := l.PopBackAll()
+ t.Assert(i1, []interface{}{1, 2, 3, 4})
+ t.Assert(l.Len(), 0)
+ })
}
func TestList_PopFrontAll(t *testing.T) {
- l := New()
- a1 := []interface{}{1, 2, 3, 4}
- l.PushFronts(a1)
- i1 := l.PopFrontAll()
- t.Assert(i1, []interface{}{4, 3, 2, 1})
- t.Assert(l.Len(), 0)
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ a1 := []interface{}{1, 2, 3, 4}
+ l.PushFronts(a1)
+ i1 := l.PopFrontAll()
+ t.Assert(i1, []interface{}{4, 3, 2, 1})
+ t.Assert(l.Len(), 0)
+ })
}
func TestList_FrontAll(t *testing.T) {
- l := New()
- a1 := []interface{}{1, 2, 3, 4}
- l.PushFronts(a1)
- i1 := l.FrontAll()
- t.Assert(i1, []interface{}{4, 3, 2, 1})
- t.Assert(l.Len(), 4)
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ a1 := []interface{}{1, 2, 3, 4}
+ l.PushFronts(a1)
+ i1 := l.FrontAll()
+ t.Assert(i1, []interface{}{4, 3, 2, 1})
+ t.Assert(l.Len(), 4)
+ })
}
func TestList_BackAll(t *testing.T) {
- l := New()
- a1 := []interface{}{1, 2, 3, 4}
- l.PushFronts(a1)
- i1 := l.BackAll()
- t.Assert(i1, []interface{}{1, 2, 3, 4})
- t.Assert(l.Len(), 4)
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ a1 := []interface{}{1, 2, 3, 4}
+ l.PushFronts(a1)
+ i1 := l.BackAll()
+ t.Assert(i1, []interface{}{1, 2, 3, 4})
+ t.Assert(l.Len(), 4)
+ })
}
func TestList_FrontValue(t *testing.T) {
- l := New()
- l2 := New()
- a1 := []interface{}{1, 2, 3, 4}
- l.PushFronts(a1)
- i1 := l.FrontValue()
- t.Assert(gconv.Int(i1), 4)
- t.Assert(l.Len(), 4)
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ l2 := New()
+ a1 := []interface{}{1, 2, 3, 4}
+ l.PushFronts(a1)
+ i1 := l.FrontValue()
+ t.Assert(gconv.Int(i1), 4)
+ t.Assert(l.Len(), 4)
- i1 = l2.FrontValue()
- t.Assert(i1, nil)
+ i1 = l2.FrontValue()
+ t.Assert(i1, nil)
+ })
}
func TestList_BackValue(t *testing.T) {
- l := New()
- l2 := New()
- a1 := []interface{}{1, 2, 3, 4}
- l.PushFronts(a1)
- i1 := l.BackValue()
- t.Assert(gconv.Int(i1), 1)
- t.Assert(l.Len(), 4)
-
- i1 = l2.FrontValue()
- t.Assert(i1, nil)
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ l2 := New()
+ a1 := []interface{}{1, 2, 3, 4}
+ l.PushFronts(a1)
+ i1 := l.BackValue()
+ t.Assert(gconv.Int(i1), 1)
+ t.Assert(l.Len(), 4)
+ i1 = l2.FrontValue()
+ t.Assert(i1, nil)
+ })
}
func TestList_Back(t *testing.T) {
- l := New()
- a1 := []interface{}{1, 2, 3, 4}
- l.PushFronts(a1)
- e1 := l.Back()
- t.Assert(e1.Value, 1)
- t.Assert(l.Len(), 4)
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ a1 := []interface{}{1, 2, 3, 4}
+ l.PushFronts(a1)
+ e1 := l.Back()
+ t.Assert(e1.Value, 1)
+ t.Assert(l.Len(), 4)
+ })
}
func TestList_Size(t *testing.T) {
- l := New()
- a1 := []interface{}{1, 2, 3, 4}
- l.PushFronts(a1)
- t.Assert(l.Size(), 4)
- l.PopFront()
- t.Assert(l.Size(), 3)
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ a1 := []interface{}{1, 2, 3, 4}
+ l.PushFronts(a1)
+ t.Assert(l.Size(), 4)
+ l.PopFront()
+ t.Assert(l.Size(), 3)
+ })
}
func TestList_Removes(t *testing.T) {
- l := New()
- a1 := []interface{}{1, 2, 3, 4}
- l.PushFronts(a1)
- e1 := l.Back()
- l.Removes([]*Element{e1})
- t.Assert(l.Len(), 3)
-
- e2 := l.Back()
- l.Removes([]*Element{e2})
- t.Assert(l.Len(), 2)
- checkList(t, l, []interface{}{4, 3})
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ a1 := []interface{}{1, 2, 3, 4}
+ l.PushFronts(a1)
+ e1 := l.Back()
+ l.Removes([]*Element{e1})
+ t.Assert(l.Len(), 3)
+ e2 := l.Back()
+ l.Removes([]*Element{e2})
+ t.Assert(l.Len(), 2)
+ checkList(t, l, []interface{}{4, 3})
+ })
}
func TestList_Clear(t *testing.T) {
- l := New()
- a1 := []interface{}{1, 2, 3, 4}
- l.PushFronts(a1)
- l.Clear()
- t.Assert(l.Len(), 0)
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ a1 := []interface{}{1, 2, 3, 4}
+ l.PushFronts(a1)
+ l.Clear()
+ t.Assert(l.Len(), 0)
+ })
}
func TestList_IteratorAsc(t *testing.T) {
- l := New()
- a1 := []interface{}{1, 2, 5, 6, 3, 4}
- l.PushFronts(a1)
- e1 := l.Back()
- fun1 := func(e *Element) bool {
- if gconv.Int(e1.Value) > 2 {
- return true
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ a1 := []interface{}{1, 2, 5, 6, 3, 4}
+ l.PushFronts(a1)
+ e1 := l.Back()
+ fun1 := func(e *Element) bool {
+ if gconv.Int(e1.Value) > 2 {
+ return true
+ }
+ return false
}
- return false
- }
- checkList(t, l, []interface{}{4, 3, 6, 5, 2, 1})
- l.IteratorAsc(fun1)
- checkList(t, l, []interface{}{4, 3, 6, 5, 2, 1})
+ checkList(t, l, []interface{}{4, 3, 6, 5, 2, 1})
+ l.IteratorAsc(fun1)
+ checkList(t, l, []interface{}{4, 3, 6, 5, 2, 1})
+ })
}
func TestList_IteratorDesc(t *testing.T) {
- l := New()
- a1 := []interface{}{1, 2, 3, 4}
- l.PushFronts(a1)
- e1 := l.Back()
- fun1 := func(e *Element) bool {
- if gconv.Int(e1.Value) > 6 {
- return true
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ a1 := []interface{}{1, 2, 3, 4}
+ l.PushFronts(a1)
+ e1 := l.Back()
+ fun1 := func(e *Element) bool {
+ if gconv.Int(e1.Value) > 6 {
+ return true
+ }
+ return false
}
- return false
- }
- l.IteratorDesc(fun1)
- t.Assert(l.Len(), 4)
- checkList(t, l, []interface{}{4, 3, 2, 1})
+ l.IteratorDesc(fun1)
+ t.Assert(l.Len(), 4)
+ checkList(t, l, []interface{}{4, 3, 2, 1})
+ })
}
func TestList_Iterator(t *testing.T) {
- l := New()
- a1 := []interface{}{"a", "b", "c", "d", "e"}
- l.PushFronts(a1)
- e1 := l.Back()
- fun1 := func(e *Element) bool {
- if gconv.String(e1.Value) > "c" {
- return true
+ gtest.C(t, func(t *gtest.T) {
+ l := New()
+ a1 := []interface{}{"a", "b", "c", "d", "e"}
+ l.PushFronts(a1)
+ e1 := l.Back()
+ fun1 := func(e *Element) bool {
+ if gconv.String(e1.Value) > "c" {
+ return true
+ }
+ return false
}
- return false
- }
- checkList(t, l, []interface{}{"e", "d", "c", "b", "a"})
- l.Iterator(fun1)
- checkList(t, l, []interface{}{"e", "d", "c", "b", "a"})
+ checkList(t, l, []interface{}{"e", "d", "c", "b", "a"})
+ l.Iterator(fun1)
+ checkList(t, l, []interface{}{"e", "d", "c", "b", "a"})
+ })
}
func TestList_Join(t *testing.T) {
@@ -634,30 +681,30 @@ func TestList_Json(t *testing.T) {
}
func TestList_UnmarshalValue(t *testing.T) {
- type T struct {
+ type TList struct {
Name string
List *List
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var tlist *TList
err := gconv.Struct(map[string]interface{}{
"name": "john",
"list": []byte(`[1,2,3]`),
- }, &t)
+ }, &tlist)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.List.FrontAll(), []interface{}{1, 2, 3})
+ t.Assert(tlist.Name, "john")
+ t.Assert(tlist.List.FrontAll(), []interface{}{1, 2, 3})
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var tlist *TList
err := gconv.Struct(map[string]interface{}{
"name": "john",
"list": []interface{}{1, 2, 3},
- }, &t)
+ }, &tlist)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.List.FrontAll(), []interface{}{1, 2, 3})
+ t.Assert(tlist.Name, "john")
+ t.Assert(tlist.List.FrontAll(), []interface{}{1, 2, 3})
})
}
diff --git a/container/gmap/gmap_z_unit_any_any_test.go b/container/gmap/gmap_z_unit_any_any_test.go
index ba6e2bf58..37520c728 100644
--- a/container/gmap/gmap_z_unit_any_any_test.go
+++ b/container/gmap/gmap_z_unit_any_any_test.go
@@ -55,61 +55,68 @@ func Test_AnyAnyMap_Basic(t *testing.T) {
}
func Test_AnyAnyMap_Set_Fun(t *testing.T) {
- m := gmap.NewAnyAnyMap()
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewAnyAnyMap()
- m.GetOrSetFunc(1, getAny)
- m.GetOrSetFuncLock(2, getAny)
- t.Assert(m.Get(1), 123)
- t.Assert(m.Get(2), 123)
+ m.GetOrSetFunc(1, getAny)
+ m.GetOrSetFuncLock(2, getAny)
+ t.Assert(m.Get(1), 123)
+ t.Assert(m.Get(2), 123)
- t.Assert(m.SetIfNotExistFunc(1, getAny), false)
- t.Assert(m.SetIfNotExistFunc(3, getAny), true)
+ t.Assert(m.SetIfNotExistFunc(1, getAny), false)
+ t.Assert(m.SetIfNotExistFunc(3, getAny), true)
- t.Assert(m.SetIfNotExistFuncLock(2, getAny), false)
- t.Assert(m.SetIfNotExistFuncLock(4, getAny), true)
+ t.Assert(m.SetIfNotExistFuncLock(2, getAny), false)
+ t.Assert(m.SetIfNotExistFuncLock(4, getAny), true)
+ })
}
func Test_AnyAnyMap_Batch(t *testing.T) {
- m := gmap.NewAnyAnyMap()
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewAnyAnyMap()
- m.Sets(map[interface{}]interface{}{1: 1, 2: "2", 3: 3})
- t.Assert(m.Map(), map[interface{}]interface{}{1: 1, 2: "2", 3: 3})
- m.Removes([]interface{}{1, 2})
- t.Assert(m.Map(), map[interface{}]interface{}{3: 3})
+ m.Sets(map[interface{}]interface{}{1: 1, 2: "2", 3: 3})
+ t.Assert(m.Map(), map[interface{}]interface{}{1: 1, 2: "2", 3: 3})
+ m.Removes([]interface{}{1, 2})
+ t.Assert(m.Map(), map[interface{}]interface{}{3: 3})
+ })
}
func Test_AnyAnyMap_Iterator(t *testing.T) {
- expect := map[interface{}]interface{}{1: 1, 2: "2"}
- m := gmap.NewAnyAnyMapFrom(expect)
- m.Iterator(func(k interface{}, v interface{}) bool {
- t.Assert(expect[k], v)
- return true
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[interface{}]interface{}{1: 1, 2: "2"}
+ m := gmap.NewAnyAnyMapFrom(expect)
+ m.Iterator(func(k interface{}, v interface{}) bool {
+ t.Assert(expect[k], v)
+ return true
+ })
+ // 断言返回值对遍历控制
+ i := 0
+ j := 0
+ m.Iterator(func(k interface{}, v interface{}) bool {
+ i++
+ return true
+ })
+ m.Iterator(func(k interface{}, v interface{}) bool {
+ j++
+ return false
+ })
+ t.Assert(i, "2")
+ t.Assert(j, 1)
})
- // 断言返回值对遍历控制
- i := 0
- j := 0
- m.Iterator(func(k interface{}, v interface{}) bool {
- i++
- return true
- })
- m.Iterator(func(k interface{}, v interface{}) bool {
- j++
- return false
- })
- t.Assert(i, "2")
- t.Assert(j, 1)
-
}
func Test_AnyAnyMap_Lock(t *testing.T) {
- expect := map[interface{}]interface{}{1: 1, 2: "2"}
- m := gmap.NewAnyAnyMapFrom(expect)
- m.LockFunc(func(m map[interface{}]interface{}) {
- t.Assert(m, expect)
- })
- m.RLockFunc(func(m map[interface{}]interface{}) {
- t.Assert(m, expect)
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[interface{}]interface{}{1: 1, 2: "2"}
+ m := gmap.NewAnyAnyMapFrom(expect)
+ m.LockFunc(func(m map[interface{}]interface{}) {
+ t.Assert(m, expect)
+ })
+ m.RLockFunc(func(m map[interface{}]interface{}) {
+ t.Assert(m, expect)
+ })
})
}
@@ -130,53 +137,61 @@ func Test_AnyAnyMap_Clone(t *testing.T) {
}
func Test_AnyAnyMap_Merge(t *testing.T) {
- m1 := gmap.NewAnyAnyMap()
- m2 := gmap.NewAnyAnyMap()
- m1.Set(1, 1)
- m2.Set(2, "2")
- m1.Merge(m2)
- t.Assert(m1.Map(), map[interface{}]interface{}{1: 1, 2: "2"})
+ gtest.C(t, func(t *gtest.T) {
+ m1 := gmap.NewAnyAnyMap()
+ m2 := gmap.NewAnyAnyMap()
+ m1.Set(1, 1)
+ m2.Set(2, "2")
+ m1.Merge(m2)
+ t.Assert(m1.Map(), map[interface{}]interface{}{1: 1, 2: "2"})
+ })
}
func Test_AnyAnyMap_Map(t *testing.T) {
- m := gmap.NewAnyAnyMap()
- m.Set(1, 0)
- m.Set(2, 2)
- t.Assert(m.Get(1), 0)
- t.Assert(m.Get(2), 2)
- data := m.Map()
- t.Assert(data[1], 0)
- t.Assert(data[2], 2)
- data[3] = 3
- t.Assert(m.Get(3), 3)
- m.Set(4, 4)
- t.Assert(data[4], 4)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewAnyAnyMap()
+ m.Set(1, 0)
+ m.Set(2, 2)
+ t.Assert(m.Get(1), 0)
+ t.Assert(m.Get(2), 2)
+ data := m.Map()
+ t.Assert(data[1], 0)
+ t.Assert(data[2], 2)
+ data[3] = 3
+ t.Assert(m.Get(3), 3)
+ m.Set(4, 4)
+ t.Assert(data[4], 4)
+ })
}
func Test_AnyAnyMap_MapCopy(t *testing.T) {
- m := gmap.NewAnyAnyMap()
- m.Set(1, 0)
- m.Set(2, 2)
- t.Assert(m.Get(1), 0)
- t.Assert(m.Get(2), 2)
- data := m.MapCopy()
- t.Assert(data[1], 0)
- t.Assert(data[2], 2)
- data[3] = 3
- t.Assert(m.Get(3), nil)
- m.Set(4, 4)
- t.Assert(data[4], nil)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewAnyAnyMap()
+ m.Set(1, 0)
+ m.Set(2, 2)
+ t.Assert(m.Get(1), 0)
+ t.Assert(m.Get(2), 2)
+ data := m.MapCopy()
+ t.Assert(data[1], 0)
+ t.Assert(data[2], 2)
+ data[3] = 3
+ t.Assert(m.Get(3), nil)
+ m.Set(4, 4)
+ t.Assert(data[4], nil)
+ })
}
func Test_AnyAnyMap_FilterEmpty(t *testing.T) {
- m := gmap.NewAnyAnyMap()
- m.Set(1, 0)
- m.Set(2, 2)
- t.Assert(m.Get(1), 0)
- t.Assert(m.Get(2), 2)
- m.FilterEmpty()
- t.Assert(m.Get(1), nil)
- t.Assert(m.Get(2), 2)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewAnyAnyMap()
+ m.Set(1, 0)
+ m.Set(2, 2)
+ t.Assert(m.Get(1), 0)
+ t.Assert(m.Get(2), 2)
+ m.FilterEmpty()
+ t.Assert(m.Get(1), nil)
+ t.Assert(m.Get(2), 2)
+ })
}
func Test_AnyAnyMap_Json(t *testing.T) {
@@ -277,37 +292,37 @@ func Test_AnyAnyMap_Pops(t *testing.T) {
}
func TestAnyAnyMap_UnmarshalValue(t *testing.T) {
- type T struct {
+ type V struct {
Name string
Map *gmap.Map
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": []byte(`{"k1":"v1","k2":"v2"}`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get("k1"), "v1")
- t.Assert(t.Map.Get("k2"), "v2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get("k1"), "v1")
+ t.Assert(v.Map.Get("k2"), "v2")
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": g.Map{
"k1": "v1",
"k2": "v2",
},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get("k1"), "v1")
- t.Assert(t.Map.Get("k2"), "v2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get("k1"), "v1")
+ t.Assert(v.Map.Get("k2"), "v2")
})
}
diff --git a/container/gmap/gmap_z_unit_int_any_test.go b/container/gmap/gmap_z_unit_int_any_test.go
index 4c8efb98a..9bf922ed7 100644
--- a/container/gmap/gmap_z_unit_int_any_test.go
+++ b/container/gmap/gmap_z_unit_int_any_test.go
@@ -56,124 +56,141 @@ func Test_IntAnyMap_Basic(t *testing.T) {
})
}
func Test_IntAnyMap_Set_Fun(t *testing.T) {
- m := gmap.NewIntAnyMap()
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewIntAnyMap()
- m.GetOrSetFunc(1, getAny)
- m.GetOrSetFuncLock(2, getAny)
- t.Assert(m.Get(1), 123)
- t.Assert(m.Get(2), 123)
+ m.GetOrSetFunc(1, getAny)
+ m.GetOrSetFuncLock(2, getAny)
+ t.Assert(m.Get(1), 123)
+ t.Assert(m.Get(2), 123)
- t.Assert(m.SetIfNotExistFunc(1, getAny), false)
- t.Assert(m.SetIfNotExistFunc(3, getAny), true)
-
- t.Assert(m.SetIfNotExistFuncLock(2, getAny), false)
- t.Assert(m.SetIfNotExistFuncLock(4, getAny), true)
+ t.Assert(m.SetIfNotExistFunc(1, getAny), false)
+ t.Assert(m.SetIfNotExistFunc(3, getAny), true)
+ t.Assert(m.SetIfNotExistFuncLock(2, getAny), false)
+ t.Assert(m.SetIfNotExistFuncLock(4, getAny), true)
+ })
}
func Test_IntAnyMap_Batch(t *testing.T) {
- m := gmap.NewIntAnyMap()
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewIntAnyMap()
- m.Sets(map[int]interface{}{1: 1, 2: "2", 3: 3})
- t.Assert(m.Map(), map[int]interface{}{1: 1, 2: "2", 3: 3})
- m.Removes([]int{1, 2})
- t.Assert(m.Map(), map[int]interface{}{3: 3})
+ m.Sets(map[int]interface{}{1: 1, 2: "2", 3: 3})
+ t.Assert(m.Map(), map[int]interface{}{1: 1, 2: "2", 3: 3})
+ m.Removes([]int{1, 2})
+ t.Assert(m.Map(), map[int]interface{}{3: 3})
+ })
}
func Test_IntAnyMap_Iterator(t *testing.T) {
- expect := map[int]interface{}{1: 1, 2: "2"}
- m := gmap.NewIntAnyMapFrom(expect)
- m.Iterator(func(k int, v interface{}) bool {
- t.Assert(expect[k], v)
- return true
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[int]interface{}{1: 1, 2: "2"}
+ m := gmap.NewIntAnyMapFrom(expect)
+ m.Iterator(func(k int, v interface{}) bool {
+ t.Assert(expect[k], v)
+ return true
+ })
+ // 断言返回值对遍历控制
+ i := 0
+ j := 0
+ m.Iterator(func(k int, v interface{}) bool {
+ i++
+ return true
+ })
+ m.Iterator(func(k int, v interface{}) bool {
+ j++
+ return false
+ })
+ t.Assert(i, "2")
+ t.Assert(j, 1)
})
- // 断言返回值对遍历控制
- i := 0
- j := 0
- m.Iterator(func(k int, v interface{}) bool {
- i++
- return true
- })
- m.Iterator(func(k int, v interface{}) bool {
- j++
- return false
- })
- t.Assert(i, "2")
- t.Assert(j, 1)
}
func Test_IntAnyMap_Lock(t *testing.T) {
- expect := map[int]interface{}{1: 1, 2: "2"}
- m := gmap.NewIntAnyMapFrom(expect)
- m.LockFunc(func(m map[int]interface{}) {
- t.Assert(m, expect)
- })
- m.RLockFunc(func(m map[int]interface{}) {
- t.Assert(m, expect)
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[int]interface{}{1: 1, 2: "2"}
+ m := gmap.NewIntAnyMapFrom(expect)
+ m.LockFunc(func(m map[int]interface{}) {
+ t.Assert(m, expect)
+ })
+ m.RLockFunc(func(m map[int]interface{}) {
+ t.Assert(m, expect)
+ })
})
}
func Test_IntAnyMap_Clone(t *testing.T) {
- //clone 方法是深克隆
- m := gmap.NewIntAnyMapFrom(map[int]interface{}{1: 1, 2: "2"})
+ gtest.C(t, func(t *gtest.T) {
+ //clone 方法是深克隆
+ m := gmap.NewIntAnyMapFrom(map[int]interface{}{1: 1, 2: "2"})
- m_clone := m.Clone()
- m.Remove(1)
- //修改原 map,clone 后的 map 不影响
- t.AssertIN(1, m_clone.Keys())
+ m_clone := m.Clone()
+ m.Remove(1)
+ //修改原 map,clone 后的 map 不影响
+ t.AssertIN(1, m_clone.Keys())
- m_clone.Remove(2)
- //修改clone map,原 map 不影响
- t.AssertIN(2, m.Keys())
+ m_clone.Remove(2)
+ //修改clone map,原 map 不影响
+ t.AssertIN(2, m.Keys())
+ })
}
func Test_IntAnyMap_Merge(t *testing.T) {
- m1 := gmap.NewIntAnyMap()
- m2 := gmap.NewIntAnyMap()
- m1.Set(1, 1)
- m2.Set(2, "2")
- m1.Merge(m2)
- t.Assert(m1.Map(), map[int]interface{}{1: 1, 2: "2"})
+ gtest.C(t, func(t *gtest.T) {
+ m1 := gmap.NewIntAnyMap()
+ m2 := gmap.NewIntAnyMap()
+ m1.Set(1, 1)
+ m2.Set(2, "2")
+ m1.Merge(m2)
+ t.Assert(m1.Map(), map[int]interface{}{1: 1, 2: "2"})
+ })
}
func Test_IntAnyMap_Map(t *testing.T) {
- m := gmap.NewIntAnyMap()
- m.Set(1, 0)
- m.Set(2, 2)
- t.Assert(m.Get(1), 0)
- t.Assert(m.Get(2), 2)
- data := m.Map()
- t.Assert(data[1], 0)
- t.Assert(data[2], 2)
- data[3] = 3
- t.Assert(m.Get(3), 3)
- m.Set(4, 4)
- t.Assert(data[4], 4)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewIntAnyMap()
+ m.Set(1, 0)
+ m.Set(2, 2)
+ t.Assert(m.Get(1), 0)
+ t.Assert(m.Get(2), 2)
+ data := m.Map()
+ t.Assert(data[1], 0)
+ t.Assert(data[2], 2)
+ data[3] = 3
+ t.Assert(m.Get(3), 3)
+ m.Set(4, 4)
+ t.Assert(data[4], 4)
+ })
}
func Test_IntAnyMap_MapCopy(t *testing.T) {
- m := gmap.NewIntAnyMap()
- m.Set(1, 0)
- m.Set(2, 2)
- t.Assert(m.Get(1), 0)
- t.Assert(m.Get(2), 2)
- data := m.MapCopy()
- t.Assert(data[1], 0)
- t.Assert(data[2], 2)
- data[3] = 3
- t.Assert(m.Get(3), nil)
- m.Set(4, 4)
- t.Assert(data[4], nil)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewIntAnyMap()
+ m.Set(1, 0)
+ m.Set(2, 2)
+ t.Assert(m.Get(1), 0)
+ t.Assert(m.Get(2), 2)
+ data := m.MapCopy()
+ t.Assert(data[1], 0)
+ t.Assert(data[2], 2)
+ data[3] = 3
+ t.Assert(m.Get(3), nil)
+ m.Set(4, 4)
+ t.Assert(data[4], nil)
+ })
}
func Test_IntAnyMap_FilterEmpty(t *testing.T) {
- m := gmap.NewIntAnyMap()
- m.Set(1, 0)
- m.Set(2, 2)
- t.Assert(m.Size(), 2)
- t.Assert(m.Get(1), 0)
- t.Assert(m.Get(2), 2)
- m.FilterEmpty()
- t.Assert(m.Size(), 1)
- t.Assert(m.Get(2), 2)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewIntAnyMap()
+ m.Set(1, 0)
+ m.Set(2, 2)
+ t.Assert(m.Size(), 2)
+ t.Assert(m.Get(1), 0)
+ t.Assert(m.Get(2), 2)
+ m.FilterEmpty()
+ t.Assert(m.Size(), 1)
+ t.Assert(m.Get(2), 2)
+ })
}
func Test_IntAnyMap_Json(t *testing.T) {
@@ -260,37 +277,37 @@ func Test_IntAnyMap_Pops(t *testing.T) {
}
func TestIntAnyMap_UnmarshalValue(t *testing.T) {
- type T struct {
+ type V struct {
Name string
Map *gmap.IntAnyMap
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": []byte(`{"1":"v1","2":"v2"}`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get(1), "v1")
- t.Assert(t.Map.Get(2), "v2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get(1), "v1")
+ t.Assert(v.Map.Get(2), "v2")
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": g.MapIntAny{
1: "v1",
2: "v2",
},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get(1), "v1")
- t.Assert(t.Map.Get(2), "v2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get(1), "v1")
+ t.Assert(v.Map.Get(2), "v2")
})
}
diff --git a/container/gmap/gmap_z_unit_int_int_test.go b/container/gmap/gmap_z_unit_int_int_test.go
index 719916107..5a37ddcc2 100644
--- a/container/gmap/gmap_z_unit_int_int_test.go
+++ b/container/gmap/gmap_z_unit_int_int_test.go
@@ -56,127 +56,143 @@ func Test_IntIntMap_Basic(t *testing.T) {
})
}
func Test_IntIntMap_Set_Fun(t *testing.T) {
- m := gmap.NewIntIntMap()
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewIntIntMap()
- m.GetOrSetFunc(1, getInt)
- m.GetOrSetFuncLock(2, getInt)
- t.Assert(m.Get(1), 123)
- t.Assert(m.Get(2), 123)
- t.Assert(m.SetIfNotExistFunc(1, getInt), false)
- t.Assert(m.SetIfNotExistFunc(3, getInt), true)
-
- t.Assert(m.SetIfNotExistFuncLock(2, getInt), false)
- t.Assert(m.SetIfNotExistFuncLock(4, getInt), true)
+ m.GetOrSetFunc(1, getInt)
+ m.GetOrSetFuncLock(2, getInt)
+ t.Assert(m.Get(1), 123)
+ t.Assert(m.Get(2), 123)
+ t.Assert(m.SetIfNotExistFunc(1, getInt), false)
+ t.Assert(m.SetIfNotExistFunc(3, getInt), true)
+ t.Assert(m.SetIfNotExistFuncLock(2, getInt), false)
+ t.Assert(m.SetIfNotExistFuncLock(4, getInt), true)
+ })
}
func Test_IntIntMap_Batch(t *testing.T) {
- m := gmap.NewIntIntMap()
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewIntIntMap()
- m.Sets(map[int]int{1: 1, 2: 2, 3: 3})
- m.Iterator(intIntCallBack)
- t.Assert(m.Map(), map[int]int{1: 1, 2: 2, 3: 3})
- m.Removes([]int{1, 2})
- t.Assert(m.Map(), map[int]int{3: 3})
+ m.Sets(map[int]int{1: 1, 2: 2, 3: 3})
+ m.Iterator(intIntCallBack)
+ t.Assert(m.Map(), map[int]int{1: 1, 2: 2, 3: 3})
+ m.Removes([]int{1, 2})
+ t.Assert(m.Map(), map[int]int{3: 3})
+ })
}
func Test_IntIntMap_Iterator(t *testing.T) {
- expect := map[int]int{1: 1, 2: 2}
- m := gmap.NewIntIntMapFrom(expect)
- m.Iterator(func(k int, v int) bool {
- t.Assert(expect[k], v)
- return true
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[int]int{1: 1, 2: 2}
+ m := gmap.NewIntIntMapFrom(expect)
+ m.Iterator(func(k int, v int) bool {
+ t.Assert(expect[k], v)
+ return true
+ })
+ // 断言返回值对遍历控制
+ i := 0
+ j := 0
+ m.Iterator(func(k int, v int) bool {
+ i++
+ return true
+ })
+ m.Iterator(func(k int, v int) bool {
+ j++
+ return false
+ })
+ t.Assert(i, 2)
+ t.Assert(j, 1)
})
- // 断言返回值对遍历控制
- i := 0
- j := 0
- m.Iterator(func(k int, v int) bool {
- i++
- return true
- })
- m.Iterator(func(k int, v int) bool {
- j++
- return false
- })
- t.Assert(i, 2)
- t.Assert(j, 1)
}
func Test_IntIntMap_Lock(t *testing.T) {
- expect := map[int]int{1: 1, 2: 2}
- m := gmap.NewIntIntMapFrom(expect)
- m.LockFunc(func(m map[int]int) {
- t.Assert(m, expect)
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[int]int{1: 1, 2: 2}
+ m := gmap.NewIntIntMapFrom(expect)
+ m.LockFunc(func(m map[int]int) {
+ t.Assert(m, expect)
+ })
+ m.RLockFunc(func(m map[int]int) {
+ t.Assert(m, expect)
+ })
})
- m.RLockFunc(func(m map[int]int) {
- t.Assert(m, expect)
- })
-
}
func Test_IntIntMap_Clone(t *testing.T) {
- //clone 方法是深克隆
- m := gmap.NewIntIntMapFrom(map[int]int{1: 1, 2: 2})
+ gtest.C(t, func(t *gtest.T) {
+ //clone 方法是深克隆
+ m := gmap.NewIntIntMapFrom(map[int]int{1: 1, 2: 2})
- m_clone := m.Clone()
- m.Remove(1)
- //修改原 map,clone 后的 map 不影响
- t.AssertIN(1, m_clone.Keys())
+ m_clone := m.Clone()
+ m.Remove(1)
+ //修改原 map,clone 后的 map 不影响
+ t.AssertIN(1, m_clone.Keys())
- m_clone.Remove(2)
- //修改clone map,原 map 不影响
- t.AssertIN(2, m.Keys())
+ m_clone.Remove(2)
+ //修改clone map,原 map 不影响
+ t.AssertIN(2, m.Keys())
+ })
}
func Test_IntIntMap_Merge(t *testing.T) {
- m1 := gmap.NewIntIntMap()
- m2 := gmap.NewIntIntMap()
- m1.Set(1, 1)
- m2.Set(2, 2)
- m1.Merge(m2)
- t.Assert(m1.Map(), map[int]int{1: 1, 2: 2})
+ gtest.C(t, func(t *gtest.T) {
+ m1 := gmap.NewIntIntMap()
+ m2 := gmap.NewIntIntMap()
+ m1.Set(1, 1)
+ m2.Set(2, 2)
+ m1.Merge(m2)
+ t.Assert(m1.Map(), map[int]int{1: 1, 2: 2})
+ })
}
func Test_IntIntMap_Map(t *testing.T) {
- m := gmap.NewIntIntMap()
- m.Set(1, 0)
- m.Set(2, 2)
- t.Assert(m.Get(1), 0)
- t.Assert(m.Get(2), 2)
- data := m.Map()
- t.Assert(data[1], 0)
- t.Assert(data[2], 2)
- data[3] = 3
- t.Assert(m.Get(3), 3)
- m.Set(4, 4)
- t.Assert(data[4], 4)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewIntIntMap()
+ m.Set(1, 0)
+ m.Set(2, 2)
+ t.Assert(m.Get(1), 0)
+ t.Assert(m.Get(2), 2)
+ data := m.Map()
+ t.Assert(data[1], 0)
+ t.Assert(data[2], 2)
+ data[3] = 3
+ t.Assert(m.Get(3), 3)
+ m.Set(4, 4)
+ t.Assert(data[4], 4)
+ })
}
func Test_IntIntMap_MapCopy(t *testing.T) {
- m := gmap.NewIntIntMap()
- m.Set(1, 0)
- m.Set(2, 2)
- t.Assert(m.Get(1), 0)
- t.Assert(m.Get(2), 2)
- data := m.MapCopy()
- t.Assert(data[1], 0)
- t.Assert(data[2], 2)
- data[3] = 3
- t.Assert(m.Get(3), 0)
- m.Set(4, 4)
- t.Assert(data[4], 0)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewIntIntMap()
+ m.Set(1, 0)
+ m.Set(2, 2)
+ t.Assert(m.Get(1), 0)
+ t.Assert(m.Get(2), 2)
+ data := m.MapCopy()
+ t.Assert(data[1], 0)
+ t.Assert(data[2], 2)
+ data[3] = 3
+ t.Assert(m.Get(3), 0)
+ m.Set(4, 4)
+ t.Assert(data[4], 0)
+ })
}
func Test_IntIntMap_FilterEmpty(t *testing.T) {
- m := gmap.NewIntIntMap()
- m.Set(1, 0)
- m.Set(2, 2)
- t.Assert(m.Size(), 2)
- t.Assert(m.Get(1), 0)
- t.Assert(m.Get(2), 2)
- m.FilterEmpty()
- t.Assert(m.Size(), 1)
- t.Assert(m.Get(2), 2)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewIntIntMap()
+ m.Set(1, 0)
+ m.Set(2, 2)
+ t.Assert(m.Size(), 2)
+ t.Assert(m.Get(1), 0)
+ t.Assert(m.Get(2), 2)
+ m.FilterEmpty()
+ t.Assert(m.Size(), 1)
+ t.Assert(m.Get(2), 2)
+ })
}
func Test_IntIntMap_Json(t *testing.T) {
@@ -263,37 +279,37 @@ func Test_IntIntMap_Pops(t *testing.T) {
}
func TestIntIntMap_UnmarshalValue(t *testing.T) {
- type T struct {
+ type V struct {
Name string
Map *gmap.IntIntMap
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": []byte(`{"1":1,"2":2}`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get(1), "1")
- t.Assert(t.Map.Get(2), "2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get(1), "1")
+ t.Assert(v.Map.Get(2), "2")
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": g.MapIntAny{
1: 1,
2: 2,
},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get(1), "1")
- t.Assert(t.Map.Get(2), "2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get(1), "1")
+ t.Assert(v.Map.Get(2), "2")
})
}
diff --git a/container/gmap/gmap_z_unit_int_str_test.go b/container/gmap/gmap_z_unit_int_str_test.go
index 489ed525f..47622c24b 100644
--- a/container/gmap/gmap_z_unit_int_str_test.go
+++ b/container/gmap/gmap_z_unit_int_str_test.go
@@ -61,123 +61,137 @@ func Test_IntStrMap_Basic(t *testing.T) {
})
}
func Test_IntStrMap_Set_Fun(t *testing.T) {
- m := gmap.NewIntStrMap()
-
- m.GetOrSetFunc(1, getStr)
- m.GetOrSetFuncLock(2, getStr)
- t.Assert(m.Get(1), "z")
- t.Assert(m.Get(2), "z")
- t.Assert(m.SetIfNotExistFunc(1, getStr), false)
- t.Assert(m.SetIfNotExistFunc(3, getStr), true)
-
- t.Assert(m.SetIfNotExistFuncLock(2, getStr), false)
- t.Assert(m.SetIfNotExistFuncLock(4, getStr), true)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewIntStrMap()
+ m.GetOrSetFunc(1, getStr)
+ m.GetOrSetFuncLock(2, getStr)
+ t.Assert(m.Get(1), "z")
+ t.Assert(m.Get(2), "z")
+ t.Assert(m.SetIfNotExistFunc(1, getStr), false)
+ t.Assert(m.SetIfNotExistFunc(3, getStr), true)
+ t.Assert(m.SetIfNotExistFuncLock(2, getStr), false)
+ t.Assert(m.SetIfNotExistFuncLock(4, getStr), true)
+ })
}
func Test_IntStrMap_Batch(t *testing.T) {
- m := gmap.NewIntStrMap()
-
- m.Sets(map[int]string{1: "a", 2: "b", 3: "c"})
- t.Assert(m.Map(), map[int]string{1: "a", 2: "b", 3: "c"})
- m.Removes([]int{1, 2})
- t.Assert(m.Map(), map[int]interface{}{3: "c"})
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewIntStrMap()
+ m.Sets(map[int]string{1: "a", 2: "b", 3: "c"})
+ t.Assert(m.Map(), map[int]string{1: "a", 2: "b", 3: "c"})
+ m.Removes([]int{1, 2})
+ t.Assert(m.Map(), map[int]interface{}{3: "c"})
+ })
}
func Test_IntStrMap_Iterator(t *testing.T) {
- expect := map[int]string{1: "a", 2: "b"}
- m := gmap.NewIntStrMapFrom(expect)
- m.Iterator(func(k int, v string) bool {
- t.Assert(expect[k], v)
- return true
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[int]string{1: "a", 2: "b"}
+ m := gmap.NewIntStrMapFrom(expect)
+ m.Iterator(func(k int, v string) bool {
+ t.Assert(expect[k], v)
+ return true
+ })
+ // 断言返回值对遍历控制
+ i := 0
+ j := 0
+ m.Iterator(func(k int, v string) bool {
+ i++
+ return true
+ })
+ m.Iterator(func(k int, v string) bool {
+ j++
+ return false
+ })
+ t.Assert(i, 2)
+ t.Assert(j, 1)
})
- // 断言返回值对遍历控制
- i := 0
- j := 0
- m.Iterator(func(k int, v string) bool {
- i++
- return true
- })
- m.Iterator(func(k int, v string) bool {
- j++
- return false
- })
- t.Assert(i, 2)
- t.Assert(j, 1)
}
func Test_IntStrMap_Lock(t *testing.T) {
-
- expect := map[int]string{1: "a", 2: "b", 3: "c"}
- m := gmap.NewIntStrMapFrom(expect)
- m.LockFunc(func(m map[int]string) {
- t.Assert(m, expect)
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[int]string{1: "a", 2: "b", 3: "c"}
+ m := gmap.NewIntStrMapFrom(expect)
+ m.LockFunc(func(m map[int]string) {
+ t.Assert(m, expect)
+ })
+ m.RLockFunc(func(m map[int]string) {
+ t.Assert(m, expect)
+ })
})
- m.RLockFunc(func(m map[int]string) {
- t.Assert(m, expect)
- })
-
}
+
func Test_IntStrMap_Clone(t *testing.T) {
- //clone 方法是深克隆
- m := gmap.NewIntStrMapFrom(map[int]string{1: "a", 2: "b", 3: "c"})
+ gtest.C(t, func(t *gtest.T) {
+ //clone 方法是深克隆
+ m := gmap.NewIntStrMapFrom(map[int]string{1: "a", 2: "b", 3: "c"})
- m_clone := m.Clone()
- m.Remove(1)
- //修改原 map,clone 后的 map 不影响
- t.AssertIN(1, m_clone.Keys())
+ m_clone := m.Clone()
+ m.Remove(1)
+ //修改原 map,clone 后的 map 不影响
+ t.AssertIN(1, m_clone.Keys())
- m_clone.Remove(2)
- //修改clone map,原 map 不影响
- t.AssertIN(2, m.Keys())
+ m_clone.Remove(2)
+ //修改clone map,原 map 不影响
+ t.AssertIN(2, m.Keys())
+ })
}
func Test_IntStrMap_Merge(t *testing.T) {
- m1 := gmap.NewIntStrMap()
- m2 := gmap.NewIntStrMap()
- m1.Set(1, "a")
- m2.Set(2, "b")
- m1.Merge(m2)
- t.Assert(m1.Map(), map[int]string{1: "a", 2: "b"})
+ gtest.C(t, func(t *gtest.T) {
+ m1 := gmap.NewIntStrMap()
+ m2 := gmap.NewIntStrMap()
+ m1.Set(1, "a")
+ m2.Set(2, "b")
+ m1.Merge(m2)
+ t.Assert(m1.Map(), map[int]string{1: "a", 2: "b"})
+ })
}
func Test_IntStrMap_Map(t *testing.T) {
- m := gmap.NewIntStrMap()
- m.Set(1, "0")
- m.Set(2, "2")
- t.Assert(m.Get(1), "0")
- t.Assert(m.Get(2), "2")
- data := m.Map()
- t.Assert(data[1], "0")
- t.Assert(data[2], "2")
- data[3] = "3"
- t.Assert(m.Get(3), "3")
- m.Set(4, "4")
- t.Assert(data[4], "4")
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewIntStrMap()
+ m.Set(1, "0")
+ m.Set(2, "2")
+ t.Assert(m.Get(1), "0")
+ t.Assert(m.Get(2), "2")
+ data := m.Map()
+ t.Assert(data[1], "0")
+ t.Assert(data[2], "2")
+ data[3] = "3"
+ t.Assert(m.Get(3), "3")
+ m.Set(4, "4")
+ t.Assert(data[4], "4")
+ })
}
func Test_IntStrMap_MapCopy(t *testing.T) {
- m := gmap.NewIntStrMap()
- m.Set(1, "0")
- m.Set(2, "2")
- t.Assert(m.Get(1), "0")
- t.Assert(m.Get(2), "2")
- data := m.MapCopy()
- t.Assert(data[1], "0")
- t.Assert(data[2], "2")
- data[3] = "3"
- t.Assert(m.Get(3), "")
- m.Set(4, "4")
- t.Assert(data[4], "")
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewIntStrMap()
+ m.Set(1, "0")
+ m.Set(2, "2")
+ t.Assert(m.Get(1), "0")
+ t.Assert(m.Get(2), "2")
+ data := m.MapCopy()
+ t.Assert(data[1], "0")
+ t.Assert(data[2], "2")
+ data[3] = "3"
+ t.Assert(m.Get(3), "")
+ m.Set(4, "4")
+ t.Assert(data[4], "")
+ })
}
func Test_IntStrMap_FilterEmpty(t *testing.T) {
- m := gmap.NewIntStrMap()
- m.Set(1, "")
- m.Set(2, "2")
- t.Assert(m.Size(), 2)
- t.Assert(m.Get(2), "2")
- m.FilterEmpty()
- t.Assert(m.Size(), 1)
- t.Assert(m.Get(2), "2")
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewIntStrMap()
+ m.Set(1, "")
+ m.Set(2, "2")
+ t.Assert(m.Size(), 2)
+ t.Assert(m.Get(2), "2")
+ m.FilterEmpty()
+ t.Assert(m.Size(), 1)
+ t.Assert(m.Get(2), "2")
+ })
}
func Test_IntStrMap_Json(t *testing.T) {
@@ -264,37 +278,37 @@ func Test_IntStrMap_Pops(t *testing.T) {
}
func TestIntStrMap_UnmarshalValue(t *testing.T) {
- type T struct {
+ type V struct {
Name string
Map *gmap.IntStrMap
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": []byte(`{"1":"v1","2":"v2"}`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get(1), "v1")
- t.Assert(t.Map.Get(2), "v2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get(1), "v1")
+ t.Assert(v.Map.Get(2), "v2")
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": g.MapIntAny{
1: "v1",
2: "v2",
},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get(1), "v1")
- t.Assert(t.Map.Get(2), "v2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get(1), "v1")
+ t.Assert(v.Map.Get(2), "v2")
})
}
diff --git a/container/gmap/gmap_z_unit_list_map_test.go b/container/gmap/gmap_z_unit_list_map_test.go
index bc3ea2b59..ec8feb4c2 100644
--- a/container/gmap/gmap_z_unit_list_map_test.go
+++ b/container/gmap/gmap_z_unit_list_map_test.go
@@ -52,86 +52,100 @@ func Test_ListMap_Basic(t *testing.T) {
})
}
func Test_ListMap_Set_Fun(t *testing.T) {
- m := gmap.NewListMap()
- m.GetOrSetFunc("fun", getValue)
- m.GetOrSetFuncLock("funlock", getValue)
- t.Assert(m.Get("funlock"), 3)
- t.Assert(m.Get("fun"), 3)
- m.GetOrSetFunc("fun", getValue)
- t.Assert(m.SetIfNotExistFunc("fun", getValue), false)
- t.Assert(m.SetIfNotExistFuncLock("funlock", getValue), false)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewListMap()
+ m.GetOrSetFunc("fun", getValue)
+ m.GetOrSetFuncLock("funlock", getValue)
+ t.Assert(m.Get("funlock"), 3)
+ t.Assert(m.Get("fun"), 3)
+ m.GetOrSetFunc("fun", getValue)
+ t.Assert(m.SetIfNotExistFunc("fun", getValue), false)
+ t.Assert(m.SetIfNotExistFuncLock("funlock", getValue), false)
+ })
}
func Test_ListMap_Batch(t *testing.T) {
- m := gmap.NewListMap()
- m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
- t.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
- m.Removes([]interface{}{"key1", 1})
- t.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewListMap()
+ m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
+ t.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
+ m.Removes([]interface{}{"key1", 1})
+ t.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
+ })
}
func Test_ListMap_Iterator(t *testing.T) {
- expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
- m := gmap.NewListMapFrom(expect)
- m.Iterator(func(k interface{}, v interface{}) bool {
- t.Assert(expect[k], v)
- return true
+ m := gmap.NewListMapFrom(expect)
+ m.Iterator(func(k interface{}, v interface{}) bool {
+ t.Assert(expect[k], v)
+ return true
+ })
+ // 断言返回值对遍历控制
+ i := 0
+ j := 0
+ m.Iterator(func(k interface{}, v interface{}) bool {
+ i++
+ return true
+ })
+ m.Iterator(func(k interface{}, v interface{}) bool {
+ j++
+ return false
+ })
+ t.Assert(i, 2)
+ t.Assert(j, 1)
})
- // 断言返回值对遍历控制
- i := 0
- j := 0
- m.Iterator(func(k interface{}, v interface{}) bool {
- i++
- return true
- })
- m.Iterator(func(k interface{}, v interface{}) bool {
- j++
- return false
- })
- t.Assert(i, 2)
- t.Assert(j, 1)
}
func Test_ListMap_Clone(t *testing.T) {
- //clone 方法是深克隆
- m := gmap.NewListMapFrom(map[interface{}]interface{}{1: 1, "key1": "val1"})
- m_clone := m.Clone()
- m.Remove(1)
- //修改原 map,clone 后的 map 不影响
- t.AssertIN(1, m_clone.Keys())
+ gtest.C(t, func(t *gtest.T) {
+ //clone 方法是深克隆
+ m := gmap.NewListMapFrom(map[interface{}]interface{}{1: 1, "key1": "val1"})
+ m_clone := m.Clone()
+ m.Remove(1)
+ //修改原 map,clone 后的 map 不影响
+ t.AssertIN(1, m_clone.Keys())
- m_clone.Remove("key1")
- //修改clone map,原 map 不影响
- t.AssertIN("key1", m.Keys())
+ m_clone.Remove("key1")
+ //修改clone map,原 map 不影响
+ t.AssertIN("key1", m.Keys())
+ })
}
func Test_ListMap_Basic_Merge(t *testing.T) {
- m1 := gmap.NewListMap()
- m2 := gmap.NewListMap()
- m1.Set("key1", "val1")
- m2.Set("key2", "val2")
- m1.Merge(m2)
- t.Assert(m1.Map(), map[interface{}]interface{}{"key1": "val1", "key2": "val2"})
+ gtest.C(t, func(t *gtest.T) {
+ m1 := gmap.NewListMap()
+ m2 := gmap.NewListMap()
+ m1.Set("key1", "val1")
+ m2.Set("key2", "val2")
+ m1.Merge(m2)
+ t.Assert(m1.Map(), map[interface{}]interface{}{"key1": "val1", "key2": "val2"})
+ })
}
func Test_ListMap_Order(t *testing.T) {
- m := gmap.NewListMap()
- m.Set("k1", "v1")
- m.Set("k2", "v2")
- m.Set("k3", "v3")
- t.Assert(m.Keys(), g.Slice{"k1", "k2", "k3"})
- t.Assert(m.Values(), g.Slice{"v1", "v2", "v3"})
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewListMap()
+ m.Set("k1", "v1")
+ m.Set("k2", "v2")
+ m.Set("k3", "v3")
+ t.Assert(m.Keys(), g.Slice{"k1", "k2", "k3"})
+ t.Assert(m.Values(), g.Slice{"v1", "v2", "v3"})
+ })
}
func Test_ListMap_FilterEmpty(t *testing.T) {
- m := gmap.NewListMap()
- m.Set(1, "")
- m.Set(2, "2")
- t.Assert(m.Size(), 2)
- t.Assert(m.Get(2), "2")
- m.FilterEmpty()
- t.Assert(m.Size(), 1)
- t.Assert(m.Get(2), "2")
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewListMap()
+ m.Set(1, "")
+ m.Set(2, "2")
+ t.Assert(m.Size(), 2)
+ t.Assert(m.Get(2), "2")
+ m.FilterEmpty()
+ t.Assert(m.Size(), 1)
+ t.Assert(m.Get(2), "2")
+ })
}
func Test_ListMap_Json(t *testing.T) {
@@ -233,37 +247,37 @@ func Test_ListMap_Pops(t *testing.T) {
}
func TestListMap_UnmarshalValue(t *testing.T) {
- type T struct {
+ type V struct {
Name string
Map *gmap.ListMap
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": []byte(`{"1":"v1","2":"v2"}`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get("1"), "v1")
- t.Assert(t.Map.Get("2"), "v2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get("1"), "v1")
+ t.Assert(v.Map.Get("2"), "v2")
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": g.MapIntAny{
1: "v1",
2: "v2",
},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get("1"), "v1")
- t.Assert(t.Map.Get("2"), "v2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get("1"), "v1")
+ t.Assert(v.Map.Get("2"), "v2")
})
}
diff --git a/container/gmap/gmap_z_unit_str_any_test.go b/container/gmap/gmap_z_unit_str_any_test.go
index f8b5468d0..04965342f 100644
--- a/container/gmap/gmap_z_unit_str_any_test.go
+++ b/container/gmap/gmap_z_unit_str_any_test.go
@@ -54,124 +54,141 @@ func Test_StrAnyMap_Basic(t *testing.T) {
})
}
func Test_StrAnyMap_Set_Fun(t *testing.T) {
- m := gmap.NewStrAnyMap()
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewStrAnyMap()
- m.GetOrSetFunc("a", getAny)
- m.GetOrSetFuncLock("b", getAny)
- t.Assert(m.Get("a"), 123)
- t.Assert(m.Get("b"), 123)
- t.Assert(m.SetIfNotExistFunc("a", getAny), false)
- t.Assert(m.SetIfNotExistFunc("c", getAny), true)
-
- t.Assert(m.SetIfNotExistFuncLock("b", getAny), false)
- t.Assert(m.SetIfNotExistFuncLock("d", getAny), true)
+ m.GetOrSetFunc("a", getAny)
+ m.GetOrSetFuncLock("b", getAny)
+ t.Assert(m.Get("a"), 123)
+ t.Assert(m.Get("b"), 123)
+ t.Assert(m.SetIfNotExistFunc("a", getAny), false)
+ t.Assert(m.SetIfNotExistFunc("c", getAny), true)
+ t.Assert(m.SetIfNotExistFuncLock("b", getAny), false)
+ t.Assert(m.SetIfNotExistFuncLock("d", getAny), true)
+ })
}
func Test_StrAnyMap_Batch(t *testing.T) {
- m := gmap.NewStrAnyMap()
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewStrAnyMap()
- m.Sets(map[string]interface{}{"a": 1, "b": "2", "c": 3})
- t.Assert(m.Map(), map[string]interface{}{"a": 1, "b": "2", "c": 3})
- m.Removes([]string{"a", "b"})
- t.Assert(m.Map(), map[string]interface{}{"c": 3})
+ m.Sets(map[string]interface{}{"a": 1, "b": "2", "c": 3})
+ t.Assert(m.Map(), map[string]interface{}{"a": 1, "b": "2", "c": 3})
+ m.Removes([]string{"a", "b"})
+ t.Assert(m.Map(), map[string]interface{}{"c": 3})
+ })
}
func Test_StrAnyMap_Iterator(t *testing.T) {
- expect := map[string]interface{}{"a": true, "b": false}
- m := gmap.NewStrAnyMapFrom(expect)
- m.Iterator(func(k string, v interface{}) bool {
- t.Assert(expect[k], v)
- return true
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[string]interface{}{"a": true, "b": false}
+ m := gmap.NewStrAnyMapFrom(expect)
+ m.Iterator(func(k string, v interface{}) bool {
+ t.Assert(expect[k], v)
+ return true
+ })
+ // 断言返回值对遍历控制
+ i := 0
+ j := 0
+ m.Iterator(func(k string, v interface{}) bool {
+ i++
+ return true
+ })
+ m.Iterator(func(k string, v interface{}) bool {
+ j++
+ return false
+ })
+ t.Assert(i, 2)
+ t.Assert(j, 1)
})
- // 断言返回值对遍历控制
- i := 0
- j := 0
- m.Iterator(func(k string, v interface{}) bool {
- i++
- return true
- })
- m.Iterator(func(k string, v interface{}) bool {
- j++
- return false
- })
- t.Assert(i, 2)
- t.Assert(j, 1)
}
func Test_StrAnyMap_Lock(t *testing.T) {
- expect := map[string]interface{}{"a": true, "b": false}
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[string]interface{}{"a": true, "b": false}
- m := gmap.NewStrAnyMapFrom(expect)
- m.LockFunc(func(m map[string]interface{}) {
- t.Assert(m, expect)
- })
- m.RLockFunc(func(m map[string]interface{}) {
- t.Assert(m, expect)
+ m := gmap.NewStrAnyMapFrom(expect)
+ m.LockFunc(func(m map[string]interface{}) {
+ t.Assert(m, expect)
+ })
+ m.RLockFunc(func(m map[string]interface{}) {
+ t.Assert(m, expect)
+ })
})
}
func Test_StrAnyMap_Clone(t *testing.T) {
- //clone 方法是深克隆
- m := gmap.NewStrAnyMapFrom(map[string]interface{}{"a": 1, "b": "2"})
+ gtest.C(t, func(t *gtest.T) {
+ //clone 方法是深克隆
+ m := gmap.NewStrAnyMapFrom(map[string]interface{}{"a": 1, "b": "2"})
- m_clone := m.Clone()
- m.Remove("a")
- //修改原 map,clone 后的 map 不影响
- t.AssertIN("a", m_clone.Keys())
+ m_clone := m.Clone()
+ m.Remove("a")
+ //修改原 map,clone 后的 map 不影响
+ t.AssertIN("a", m_clone.Keys())
- m_clone.Remove("b")
- //修改clone map,原 map 不影响
- t.AssertIN("b", m.Keys())
+ m_clone.Remove("b")
+ //修改clone map,原 map 不影响
+ t.AssertIN("b", m.Keys())
+ })
}
func Test_StrAnyMap_Merge(t *testing.T) {
- m1 := gmap.NewStrAnyMap()
- m2 := gmap.NewStrAnyMap()
- m1.Set("a", 1)
- m2.Set("b", "2")
- m1.Merge(m2)
- t.Assert(m1.Map(), map[string]interface{}{"a": 1, "b": "2"})
+ gtest.C(t, func(t *gtest.T) {
+ m1 := gmap.NewStrAnyMap()
+ m2 := gmap.NewStrAnyMap()
+ m1.Set("a", 1)
+ m2.Set("b", "2")
+ m1.Merge(m2)
+ t.Assert(m1.Map(), map[string]interface{}{"a": 1, "b": "2"})
+ })
}
func Test_StrAnyMap_Map(t *testing.T) {
- m := gmap.NewStrAnyMap()
- m.Set("1", 1)
- m.Set("2", 2)
- t.Assert(m.Get("1"), 1)
- t.Assert(m.Get("2"), 2)
- data := m.Map()
- t.Assert(data["1"], 1)
- t.Assert(data["2"], 2)
- data["3"] = 3
- t.Assert(m.Get("3"), 3)
- m.Set("4", 4)
- t.Assert(data["4"], 4)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewStrAnyMap()
+ m.Set("1", 1)
+ m.Set("2", 2)
+ t.Assert(m.Get("1"), 1)
+ t.Assert(m.Get("2"), 2)
+ data := m.Map()
+ t.Assert(data["1"], 1)
+ t.Assert(data["2"], 2)
+ data["3"] = 3
+ t.Assert(m.Get("3"), 3)
+ m.Set("4", 4)
+ t.Assert(data["4"], 4)
+ })
}
func Test_StrAnyMap_MapCopy(t *testing.T) {
- m := gmap.NewStrAnyMap()
- m.Set("1", 1)
- m.Set("2", 2)
- t.Assert(m.Get("1"), 1)
- t.Assert(m.Get("2"), 2)
- data := m.MapCopy()
- t.Assert(data["1"], 1)
- t.Assert(data["2"], 2)
- data["3"] = 3
- t.Assert(m.Get("3"), nil)
- m.Set("4", 4)
- t.Assert(data["4"], nil)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewStrAnyMap()
+ m.Set("1", 1)
+ m.Set("2", 2)
+ t.Assert(m.Get("1"), 1)
+ t.Assert(m.Get("2"), 2)
+ data := m.MapCopy()
+ t.Assert(data["1"], 1)
+ t.Assert(data["2"], 2)
+ data["3"] = 3
+ t.Assert(m.Get("3"), nil)
+ m.Set("4", 4)
+ t.Assert(data["4"], nil)
+ })
}
func Test_StrAnyMap_FilterEmpty(t *testing.T) {
- m := gmap.NewStrAnyMap()
- m.Set("1", 0)
- m.Set("2", 2)
- t.Assert(m.Size(), 2)
- t.Assert(m.Get("1"), 0)
- t.Assert(m.Get("2"), 2)
- m.FilterEmpty()
- t.Assert(m.Size(), 1)
- t.Assert(m.Get("2"), 2)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewStrAnyMap()
+ m.Set("1", 0)
+ m.Set("2", 2)
+ t.Assert(m.Size(), 2)
+ t.Assert(m.Get("1"), 0)
+ t.Assert(m.Get("2"), 2)
+ m.FilterEmpty()
+ t.Assert(m.Size(), 1)
+ t.Assert(m.Get("2"), 2)
+ })
}
func Test_StrAnyMap_Json(t *testing.T) {
@@ -272,37 +289,37 @@ func Test_StrAnyMap_Pops(t *testing.T) {
}
func TestStrAnyMap_UnmarshalValue(t *testing.T) {
- type T struct {
+ type V struct {
Name string
Map *gmap.StrAnyMap
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": []byte(`{"k1":"v1","k2":"v2"}`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get("k1"), "v1")
- t.Assert(t.Map.Get("k2"), "v2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get("k1"), "v1")
+ t.Assert(v.Map.Get("k2"), "v2")
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": g.Map{
"k1": "v1",
"k2": "v2",
},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get("k1"), "v1")
- t.Assert(t.Map.Get("k2"), "v2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get("k1"), "v1")
+ t.Assert(v.Map.Get("k2"), "v2")
})
}
diff --git a/container/gmap/gmap_z_unit_str_int_test.go b/container/gmap/gmap_z_unit_str_int_test.go
index fc713aa1a..b20f23040 100644
--- a/container/gmap/gmap_z_unit_str_int_test.go
+++ b/container/gmap/gmap_z_unit_str_int_test.go
@@ -56,125 +56,141 @@ func Test_StrIntMap_Basic(t *testing.T) {
})
}
func Test_StrIntMap_Set_Fun(t *testing.T) {
- m := gmap.NewStrIntMap()
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewStrIntMap()
- m.GetOrSetFunc("a", getInt)
- m.GetOrSetFuncLock("b", getInt)
- t.Assert(m.Get("a"), 123)
- t.Assert(m.Get("b"), 123)
- t.Assert(m.SetIfNotExistFunc("a", getInt), false)
- t.Assert(m.SetIfNotExistFunc("c", getInt), true)
-
- t.Assert(m.SetIfNotExistFuncLock("b", getInt), false)
- t.Assert(m.SetIfNotExistFuncLock("d", getInt), true)
+ m.GetOrSetFunc("a", getInt)
+ m.GetOrSetFuncLock("b", getInt)
+ t.Assert(m.Get("a"), 123)
+ t.Assert(m.Get("b"), 123)
+ t.Assert(m.SetIfNotExistFunc("a", getInt), false)
+ t.Assert(m.SetIfNotExistFunc("c", getInt), true)
+ t.Assert(m.SetIfNotExistFuncLock("b", getInt), false)
+ t.Assert(m.SetIfNotExistFuncLock("d", getInt), true)
+ })
}
func Test_StrIntMap_Batch(t *testing.T) {
- m := gmap.NewStrIntMap()
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewStrIntMap()
- m.Sets(map[string]int{"a": 1, "b": 2, "c": 3})
- t.Assert(m.Map(), map[string]int{"a": 1, "b": 2, "c": 3})
- m.Removes([]string{"a", "b"})
- t.Assert(m.Map(), map[string]int{"c": 3})
+ m.Sets(map[string]int{"a": 1, "b": 2, "c": 3})
+ t.Assert(m.Map(), map[string]int{"a": 1, "b": 2, "c": 3})
+ m.Removes([]string{"a", "b"})
+ t.Assert(m.Map(), map[string]int{"c": 3})
+ })
}
func Test_StrIntMap_Iterator(t *testing.T) {
- expect := map[string]int{"a": 1, "b": 2}
- m := gmap.NewStrIntMapFrom(expect)
- m.Iterator(func(k string, v int) bool {
- t.Assert(expect[k], v)
- return true
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[string]int{"a": 1, "b": 2}
+ m := gmap.NewStrIntMapFrom(expect)
+ m.Iterator(func(k string, v int) bool {
+ t.Assert(expect[k], v)
+ return true
+ })
+ // 断言返回值对遍历控制
+ i := 0
+ j := 0
+ m.Iterator(func(k string, v int) bool {
+ i++
+ return true
+ })
+ m.Iterator(func(k string, v int) bool {
+ j++
+ return false
+ })
+ t.Assert(i, 2)
+ t.Assert(j, 1)
})
- // 断言返回值对遍历控制
- i := 0
- j := 0
- m.Iterator(func(k string, v int) bool {
- i++
- return true
- })
- m.Iterator(func(k string, v int) bool {
- j++
- return false
- })
- t.Assert(i, 2)
- t.Assert(j, 1)
-
}
func Test_StrIntMap_Lock(t *testing.T) {
- expect := map[string]int{"a": 1, "b": 2}
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[string]int{"a": 1, "b": 2}
- m := gmap.NewStrIntMapFrom(expect)
- m.LockFunc(func(m map[string]int) {
- t.Assert(m, expect)
- })
- m.RLockFunc(func(m map[string]int) {
- t.Assert(m, expect)
+ m := gmap.NewStrIntMapFrom(expect)
+ m.LockFunc(func(m map[string]int) {
+ t.Assert(m, expect)
+ })
+ m.RLockFunc(func(m map[string]int) {
+ t.Assert(m, expect)
+ })
})
}
func Test_StrIntMap_Clone(t *testing.T) {
- //clone 方法是深克隆
- m := gmap.NewStrIntMapFrom(map[string]int{"a": 1, "b": 2, "c": 3})
+ gtest.C(t, func(t *gtest.T) {
+ //clone 方法是深克隆
+ m := gmap.NewStrIntMapFrom(map[string]int{"a": 1, "b": 2, "c": 3})
- m_clone := m.Clone()
- m.Remove("a")
- //修改原 map,clone 后的 map 不影响
- t.AssertIN("a", m_clone.Keys())
+ m_clone := m.Clone()
+ m.Remove("a")
+ //修改原 map,clone 后的 map 不影响
+ t.AssertIN("a", m_clone.Keys())
- m_clone.Remove("b")
- //修改clone map,原 map 不影响
- t.AssertIN("b", m.Keys())
+ m_clone.Remove("b")
+ //修改clone map,原 map 不影响
+ t.AssertIN("b", m.Keys())
+ })
}
func Test_StrIntMap_Merge(t *testing.T) {
- m1 := gmap.NewStrIntMap()
- m2 := gmap.NewStrIntMap()
- m1.Set("a", 1)
- m2.Set("b", 2)
- m1.Merge(m2)
- t.Assert(m1.Map(), map[string]int{"a": 1, "b": 2})
+ gtest.C(t, func(t *gtest.T) {
+ m1 := gmap.NewStrIntMap()
+ m2 := gmap.NewStrIntMap()
+ m1.Set("a", 1)
+ m2.Set("b", 2)
+ m1.Merge(m2)
+ t.Assert(m1.Map(), map[string]int{"a": 1, "b": 2})
+ })
}
func Test_StrIntMap_Map(t *testing.T) {
- m := gmap.NewStrIntMap()
- m.Set("1", 1)
- m.Set("2", 2)
- t.Assert(m.Get("1"), 1)
- t.Assert(m.Get("2"), 2)
- data := m.Map()
- t.Assert(data["1"], 1)
- t.Assert(data["2"], 2)
- data["3"] = 3
- t.Assert(m.Get("3"), 3)
- m.Set("4", 4)
- t.Assert(data["4"], 4)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewStrIntMap()
+ m.Set("1", 1)
+ m.Set("2", 2)
+ t.Assert(m.Get("1"), 1)
+ t.Assert(m.Get("2"), 2)
+ data := m.Map()
+ t.Assert(data["1"], 1)
+ t.Assert(data["2"], 2)
+ data["3"] = 3
+ t.Assert(m.Get("3"), 3)
+ m.Set("4", 4)
+ t.Assert(data["4"], 4)
+ })
}
func Test_StrIntMap_MapCopy(t *testing.T) {
- m := gmap.NewStrIntMap()
- m.Set("1", 1)
- m.Set("2", 2)
- t.Assert(m.Get("1"), 1)
- t.Assert(m.Get("2"), 2)
- data := m.MapCopy()
- t.Assert(data["1"], 1)
- t.Assert(data["2"], 2)
- data["3"] = 3
- t.Assert(m.Get("3"), 0)
- m.Set("4", 4)
- t.Assert(data["4"], 0)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewStrIntMap()
+ m.Set("1", 1)
+ m.Set("2", 2)
+ t.Assert(m.Get("1"), 1)
+ t.Assert(m.Get("2"), 2)
+ data := m.MapCopy()
+ t.Assert(data["1"], 1)
+ t.Assert(data["2"], 2)
+ data["3"] = 3
+ t.Assert(m.Get("3"), 0)
+ m.Set("4", 4)
+ t.Assert(data["4"], 0)
+ })
}
func Test_StrIntMap_FilterEmpty(t *testing.T) {
- m := gmap.NewStrIntMap()
- m.Set("1", 0)
- m.Set("2", 2)
- t.Assert(m.Size(), 2)
- t.Assert(m.Get("1"), 0)
- t.Assert(m.Get("2"), 2)
- m.FilterEmpty()
- t.Assert(m.Size(), 1)
- t.Assert(m.Get("2"), 2)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewStrIntMap()
+ m.Set("1", 0)
+ m.Set("2", 2)
+ t.Assert(m.Size(), 2)
+ t.Assert(m.Get("1"), 0)
+ t.Assert(m.Get("2"), 2)
+ m.FilterEmpty()
+ t.Assert(m.Size(), 1)
+ t.Assert(m.Get("2"), 2)
+ })
}
func Test_StrIntMap_Json(t *testing.T) {
@@ -275,37 +291,37 @@ func Test_StrIntMap_Pops(t *testing.T) {
}
func TestStrIntMap_UnmarshalValue(t *testing.T) {
- type T struct {
+ type V struct {
Name string
Map *gmap.StrIntMap
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": []byte(`{"k1":1,"k2":2}`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get("k1"), 1)
- t.Assert(t.Map.Get("k2"), 2)
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get("k1"), 1)
+ t.Assert(v.Map.Get("k2"), 2)
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": g.Map{
"k1": 1,
"k2": 2,
},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get("k1"), 1)
- t.Assert(t.Map.Get("k2"), 2)
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get("k1"), 1)
+ t.Assert(v.Map.Get("k2"), 2)
})
}
diff --git a/container/gmap/gmap_z_unit_str_str_test.go b/container/gmap/gmap_z_unit_str_str_test.go
index 1a3ca665b..f18ecc98e 100644
--- a/container/gmap/gmap_z_unit_str_str_test.go
+++ b/container/gmap/gmap_z_unit_str_str_test.go
@@ -55,123 +55,140 @@ func Test_StrStrMap_Basic(t *testing.T) {
})
}
func Test_StrStrMap_Set_Fun(t *testing.T) {
- m := gmap.NewStrStrMap()
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewStrStrMap()
- m.GetOrSetFunc("a", getStr)
- m.GetOrSetFuncLock("b", getStr)
- t.Assert(m.Get("a"), "z")
- t.Assert(m.Get("b"), "z")
- t.Assert(m.SetIfNotExistFunc("a", getStr), false)
- t.Assert(m.SetIfNotExistFunc("c", getStr), true)
-
- t.Assert(m.SetIfNotExistFuncLock("b", getStr), false)
- t.Assert(m.SetIfNotExistFuncLock("d", getStr), true)
+ m.GetOrSetFunc("a", getStr)
+ m.GetOrSetFuncLock("b", getStr)
+ t.Assert(m.Get("a"), "z")
+ t.Assert(m.Get("b"), "z")
+ t.Assert(m.SetIfNotExistFunc("a", getStr), false)
+ t.Assert(m.SetIfNotExistFunc("c", getStr), true)
+ t.Assert(m.SetIfNotExistFuncLock("b", getStr), false)
+ t.Assert(m.SetIfNotExistFuncLock("d", getStr), true)
+ })
}
func Test_StrStrMap_Batch(t *testing.T) {
- m := gmap.NewStrStrMap()
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewStrStrMap()
- m.Sets(map[string]string{"a": "a", "b": "b", "c": "c"})
- t.Assert(m.Map(), map[string]string{"a": "a", "b": "b", "c": "c"})
- m.Removes([]string{"a", "b"})
- t.Assert(m.Map(), map[string]string{"c": "c"})
+ m.Sets(map[string]string{"a": "a", "b": "b", "c": "c"})
+ t.Assert(m.Map(), map[string]string{"a": "a", "b": "b", "c": "c"})
+ m.Removes([]string{"a", "b"})
+ t.Assert(m.Map(), map[string]string{"c": "c"})
+ })
}
func Test_StrStrMap_Iterator(t *testing.T) {
- expect := map[string]string{"a": "a", "b": "b"}
- m := gmap.NewStrStrMapFrom(expect)
- m.Iterator(func(k string, v string) bool {
- t.Assert(expect[k], v)
- return true
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[string]string{"a": "a", "b": "b"}
+ m := gmap.NewStrStrMapFrom(expect)
+ m.Iterator(func(k string, v string) bool {
+ t.Assert(expect[k], v)
+ return true
+ })
+ // 断言返回值对遍历控制
+ i := 0
+ j := 0
+ m.Iterator(func(k string, v string) bool {
+ i++
+ return true
+ })
+ m.Iterator(func(k string, v string) bool {
+ j++
+ return false
+ })
+ t.Assert(i, 2)
+ t.Assert(j, 1)
})
- // 断言返回值对遍历控制
- i := 0
- j := 0
- m.Iterator(func(k string, v string) bool {
- i++
- return true
- })
- m.Iterator(func(k string, v string) bool {
- j++
- return false
- })
- t.Assert(i, 2)
- t.Assert(j, 1)
}
func Test_StrStrMap_Lock(t *testing.T) {
- expect := map[string]string{"a": "a", "b": "b"}
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[string]string{"a": "a", "b": "b"}
- m := gmap.NewStrStrMapFrom(expect)
- m.LockFunc(func(m map[string]string) {
- t.Assert(m, expect)
- })
- m.RLockFunc(func(m map[string]string) {
- t.Assert(m, expect)
+ m := gmap.NewStrStrMapFrom(expect)
+ m.LockFunc(func(m map[string]string) {
+ t.Assert(m, expect)
+ })
+ m.RLockFunc(func(m map[string]string) {
+ t.Assert(m, expect)
+ })
})
}
func Test_StrStrMap_Clone(t *testing.T) {
- //clone 方法是深克隆
- m := gmap.NewStrStrMapFrom(map[string]string{"a": "a", "b": "b", "c": "c"})
+ gtest.C(t, func(t *gtest.T) {
+ //clone 方法是深克隆
+ m := gmap.NewStrStrMapFrom(map[string]string{"a": "a", "b": "b", "c": "c"})
- m_clone := m.Clone()
- m.Remove("a")
- //修改原 map,clone 后的 map 不影响
- t.AssertIN("a", m_clone.Keys())
+ m_clone := m.Clone()
+ m.Remove("a")
+ //修改原 map,clone 后的 map 不影响
+ t.AssertIN("a", m_clone.Keys())
- m_clone.Remove("b")
- //修改clone map,原 map 不影响
- t.AssertIN("b", m.Keys())
+ m_clone.Remove("b")
+ //修改clone map,原 map 不影响
+ t.AssertIN("b", m.Keys())
+ })
}
func Test_StrStrMap_Merge(t *testing.T) {
- m1 := gmap.NewStrStrMap()
- m2 := gmap.NewStrStrMap()
- m1.Set("a", "a")
- m2.Set("b", "b")
- m1.Merge(m2)
- t.Assert(m1.Map(), map[string]string{"a": "a", "b": "b"})
+ gtest.C(t, func(t *gtest.T) {
+ m1 := gmap.NewStrStrMap()
+ m2 := gmap.NewStrStrMap()
+ m1.Set("a", "a")
+ m2.Set("b", "b")
+ m1.Merge(m2)
+ t.Assert(m1.Map(), map[string]string{"a": "a", "b": "b"})
+ })
}
func Test_StrStrMap_Map(t *testing.T) {
- m := gmap.NewStrStrMap()
- m.Set("1", "1")
- m.Set("2", "2")
- t.Assert(m.Get("1"), "1")
- t.Assert(m.Get("2"), "2")
- data := m.Map()
- t.Assert(data["1"], "1")
- t.Assert(data["2"], "2")
- data["3"] = "3"
- t.Assert(m.Get("3"), "3")
- m.Set("4", "4")
- t.Assert(data["4"], "4")
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewStrStrMap()
+ m.Set("1", "1")
+ m.Set("2", "2")
+ t.Assert(m.Get("1"), "1")
+ t.Assert(m.Get("2"), "2")
+ data := m.Map()
+ t.Assert(data["1"], "1")
+ t.Assert(data["2"], "2")
+ data["3"] = "3"
+ t.Assert(m.Get("3"), "3")
+ m.Set("4", "4")
+ t.Assert(data["4"], "4")
+ })
}
func Test_StrStrMap_MapCopy(t *testing.T) {
- m := gmap.NewStrStrMap()
- m.Set("1", "1")
- m.Set("2", "2")
- t.Assert(m.Get("1"), "1")
- t.Assert(m.Get("2"), "2")
- data := m.MapCopy()
- t.Assert(data["1"], "1")
- t.Assert(data["2"], "2")
- data["3"] = "3"
- t.Assert(m.Get("3"), "")
- m.Set("4", "4")
- t.Assert(data["4"], "")
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewStrStrMap()
+ m.Set("1", "1")
+ m.Set("2", "2")
+ t.Assert(m.Get("1"), "1")
+ t.Assert(m.Get("2"), "2")
+ data := m.MapCopy()
+ t.Assert(data["1"], "1")
+ t.Assert(data["2"], "2")
+ data["3"] = "3"
+ t.Assert(m.Get("3"), "")
+ m.Set("4", "4")
+ t.Assert(data["4"], "")
+ })
}
func Test_StrStrMap_FilterEmpty(t *testing.T) {
- m := gmap.NewStrStrMap()
- m.Set("1", "")
- m.Set("2", "2")
- t.Assert(m.Size(), 2)
- t.Assert(m.Get("1"), "")
- t.Assert(m.Get("2"), "2")
- m.FilterEmpty()
- t.Assert(m.Size(), 1)
- t.Assert(m.Get("2"), "2")
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewStrStrMap()
+ m.Set("1", "")
+ m.Set("2", "2")
+ t.Assert(m.Size(), 2)
+ t.Assert(m.Get("1"), "")
+ t.Assert(m.Get("2"), "2")
+ m.FilterEmpty()
+ t.Assert(m.Size(), 1)
+ t.Assert(m.Get("2"), "2")
+ })
}
func Test_StrStrMap_Json(t *testing.T) {
@@ -272,37 +289,37 @@ func Test_StrStrMap_Pops(t *testing.T) {
}
func TestStrStrMap_UnmarshalValue(t *testing.T) {
- type T struct {
+ type V struct {
Name string
Map *gmap.StrStrMap
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": []byte(`{"k1":"v1","k2":"v2"}`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get("k1"), "v1")
- t.Assert(t.Map.Get("k2"), "v2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get("k1"), "v1")
+ t.Assert(v.Map.Get("k2"), "v2")
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": g.Map{
"k1": "v1",
"k2": "v2",
},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get("k1"), "v1")
- t.Assert(t.Map.Get("k2"), "v2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get("k1"), "v1")
+ t.Assert(v.Map.Get("k2"), "v2")
})
}
diff --git a/container/gmap/gmap_z_unit_tree_map_test.go b/container/gmap/gmap_z_unit_tree_map_test.go
index a1658c174..ae7ff082c 100644
--- a/container/gmap/gmap_z_unit_tree_map_test.go
+++ b/container/gmap/gmap_z_unit_tree_map_test.go
@@ -52,57 +52,65 @@ func Test_TreeMap_Basic(t *testing.T) {
})
}
func Test_TreeMap_Set_Fun(t *testing.T) {
- m := gmap.NewTreeMap(gutil.ComparatorString)
- m.GetOrSetFunc("fun", getValue)
- m.GetOrSetFuncLock("funlock", getValue)
- t.Assert(m.Get("funlock"), 3)
- t.Assert(m.Get("fun"), 3)
- m.GetOrSetFunc("fun", getValue)
- t.Assert(m.SetIfNotExistFunc("fun", getValue), false)
- t.Assert(m.SetIfNotExistFuncLock("funlock", getValue), false)
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewTreeMap(gutil.ComparatorString)
+ m.GetOrSetFunc("fun", getValue)
+ m.GetOrSetFuncLock("funlock", getValue)
+ t.Assert(m.Get("funlock"), 3)
+ t.Assert(m.Get("fun"), 3)
+ m.GetOrSetFunc("fun", getValue)
+ t.Assert(m.SetIfNotExistFunc("fun", getValue), false)
+ t.Assert(m.SetIfNotExistFuncLock("funlock", getValue), false)
+ })
}
func Test_TreeMap_Batch(t *testing.T) {
- m := gmap.NewTreeMap(gutil.ComparatorString)
- m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
- t.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
- m.Removes([]interface{}{"key1", 1})
- t.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
+ gtest.C(t, func(t *gtest.T) {
+ m := gmap.NewTreeMap(gutil.ComparatorString)
+ m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
+ t.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
+ m.Removes([]interface{}{"key1", 1})
+ t.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
+ })
}
func Test_TreeMap_Iterator(t *testing.T) {
- expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
+ gtest.C(t, func(t *gtest.T) {
+ expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
- m := gmap.NewTreeMapFrom(gutil.ComparatorString, expect)
- m.Iterator(func(k interface{}, v interface{}) bool {
- t.Assert(expect[k], v)
- return true
+ m := gmap.NewTreeMapFrom(gutil.ComparatorString, expect)
+ m.Iterator(func(k interface{}, v interface{}) bool {
+ t.Assert(expect[k], v)
+ return true
+ })
+ // 断言返回值对遍历控制
+ i := 0
+ j := 0
+ m.Iterator(func(k interface{}, v interface{}) bool {
+ i++
+ return true
+ })
+ m.Iterator(func(k interface{}, v interface{}) bool {
+ j++
+ return false
+ })
+ t.Assert(i, 2)
+ t.Assert(j, 1)
})
- // 断言返回值对遍历控制
- i := 0
- j := 0
- m.Iterator(func(k interface{}, v interface{}) bool {
- i++
- return true
- })
- m.Iterator(func(k interface{}, v interface{}) bool {
- j++
- return false
- })
- t.Assert(i, 2)
- t.Assert(j, 1)
}
func Test_TreeMap_Clone(t *testing.T) {
- //clone 方法是深克隆
- m := gmap.NewTreeMapFrom(gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"})
- m_clone := m.Clone()
- m.Remove(1)
- //修改原 map,clone 后的 map 不影响
- t.AssertIN(1, m_clone.Keys())
+ gtest.C(t, func(t *gtest.T) {
+ //clone 方法是深克隆
+ m := gmap.NewTreeMapFrom(gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"})
+ m_clone := m.Clone()
+ m.Remove(1)
+ //修改原 map,clone 后的 map 不影响
+ t.AssertIN(1, m_clone.Keys())
- m_clone.Remove("key1")
- //修改clone map,原 map 不影响
- t.AssertIN("key1", m.Keys())
+ m_clone.Remove("key1")
+ //修改clone map,原 map 不影响
+ t.AssertIN("key1", m.Keys())
+ })
}
func Test_TreeMap_Json(t *testing.T) {
@@ -150,37 +158,37 @@ func Test_TreeMap_Json(t *testing.T) {
}
func TestTreeMap_UnmarshalValue(t *testing.T) {
- type T struct {
+ type V struct {
Name string
Map *gmap.TreeMap
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": []byte(`{"k1":"v1","k2":"v2"}`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get("k1"), "v1")
- t.Assert(t.Map.Get("k2"), "v2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get("k1"), "v1")
+ t.Assert(v.Map.Get("k2"), "v2")
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"map": g.Map{
"k1": "v1",
"k2": "v2",
},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Map.Size(), 2)
- t.Assert(t.Map.Get("k1"), "v1")
- t.Assert(t.Map.Get("k2"), "v2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Map.Size(), 2)
+ t.Assert(v.Map.Get("k1"), "v1")
+ t.Assert(v.Map.Get("k2"), "v2")
})
}
diff --git a/container/gqueue/gqueue_unit_test.go b/container/gqueue/gqueue_unit_test.go
index 854008b3a..cc4d75b6b 100644
--- a/container/gqueue/gqueue_unit_test.go
+++ b/container/gqueue/gqueue_unit_test.go
@@ -17,41 +17,49 @@ import (
)
func TestQueue_Len(t *testing.T) {
- max := 100
- for n := 10; n < max; n++ {
- q1 := gqueue.New(max)
- for i := 0; i < max; i++ {
- q1.Push(i)
+ gtest.C(t, func(t *gtest.T) {
+ max := 100
+ for n := 10; n < max; n++ {
+ q1 := gqueue.New(max)
+ for i := 0; i < max; i++ {
+ q1.Push(i)
+ }
+ t.Assert(q1.Len(), max)
+ t.Assert(q1.Size(), max)
}
- t.Assert(q1.Len(), max)
- t.Assert(q1.Size(), max)
- }
+ })
}
func TestQueue_Basic(t *testing.T) {
- q := gqueue.New()
- for i := 0; i < 100; i++ {
- q.Push(i)
- }
- t.Assert(q.Pop(), 0)
- t.Assert(q.Pop(), 1)
+ gtest.C(t, func(t *gtest.T) {
+ q := gqueue.New()
+ for i := 0; i < 100; i++ {
+ q.Push(i)
+ }
+ t.Assert(q.Pop(), 0)
+ t.Assert(q.Pop(), 1)
+ })
}
func TestQueue_Pop(t *testing.T) {
- q1 := gqueue.New()
- q1.Push(1)
- q1.Push(2)
- q1.Push(3)
- q1.Push(4)
- i1 := q1.Pop()
- t.Assert(i1, 1)
+ gtest.C(t, func(t *gtest.T) {
+ q1 := gqueue.New()
+ q1.Push(1)
+ q1.Push(2)
+ q1.Push(3)
+ q1.Push(4)
+ i1 := q1.Pop()
+ t.Assert(i1, 1)
+ })
}
func TestQueue_Close(t *testing.T) {
- q1 := gqueue.New()
- q1.Push(1)
- q1.Push(2)
- time.Sleep(time.Millisecond)
- t.Assert(q1.Len(), 2)
- q1.Close()
+ gtest.C(t, func(t *gtest.T) {
+ q1 := gqueue.New()
+ q1.Push(1)
+ q1.Push(2)
+ time.Sleep(time.Millisecond)
+ t.Assert(q1.Len(), 2)
+ q1.Close()
+ })
}
diff --git a/container/gset/gset_z_unit_any_test.go b/container/gset/gset_z_unit_any_test.go
index a42751232..3ca5d9aa2 100644
--- a/container/gset/gset_z_unit_any_test.go
+++ b/container/gset/gset_z_unit_any_test.go
@@ -365,38 +365,38 @@ func TestSet_AddIfNotExistFunc(t *testing.T) {
}
func TestSet_UnmarshalValue(t *testing.T) {
- type T struct {
+ type Var struct {
Name string
Set *gset.Set
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(g.Map{
"name": "john",
"set": []byte(`["k1","k2","k3"]`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Set.Size(), 3)
- t.Assert(t.Set.Contains("k1"), true)
- t.Assert(t.Set.Contains("k2"), true)
- t.Assert(t.Set.Contains("k3"), true)
- t.Assert(t.Set.Contains("k4"), false)
+ t.Assert(v.Name, "john")
+ t.Assert(v.Set.Size(), 3)
+ t.Assert(v.Set.Contains("k1"), true)
+ t.Assert(v.Set.Contains("k2"), true)
+ t.Assert(v.Set.Contains("k3"), true)
+ t.Assert(v.Set.Contains("k4"), false)
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(g.Map{
"name": "john",
"set": g.Slice{"k1", "k2", "k3"},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Set.Size(), 3)
- t.Assert(t.Set.Contains("k1"), true)
- t.Assert(t.Set.Contains("k2"), true)
- t.Assert(t.Set.Contains("k3"), true)
- t.Assert(t.Set.Contains("k4"), false)
+ t.Assert(v.Name, "john")
+ t.Assert(v.Set.Size(), 3)
+ t.Assert(v.Set.Contains("k1"), true)
+ t.Assert(v.Set.Contains("k2"), true)
+ t.Assert(v.Set.Contains("k3"), true)
+ t.Assert(v.Set.Contains("k4"), false)
})
}
diff --git a/container/gset/gset_z_unit_int_test.go b/container/gset/gset_z_unit_int_test.go
index 8e5e17bd8..ee36c7805 100644
--- a/container/gset/gset_z_unit_int_test.go
+++ b/container/gset/gset_z_unit_int_test.go
@@ -328,38 +328,38 @@ func TestIntSet_AddIfNotExistFunc(t *testing.T) {
}
func TestIntSet_UnmarshalValue(t *testing.T) {
- type T struct {
+ type V struct {
Name string
Set *gset.IntSet
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(g.Map{
"name": "john",
"set": []byte(`[1,2,3]`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Set.Size(), 3)
- t.Assert(t.Set.Contains(1), true)
- t.Assert(t.Set.Contains(2), true)
- t.Assert(t.Set.Contains(3), true)
- t.Assert(t.Set.Contains(4), false)
+ t.Assert(v.Name, "john")
+ t.Assert(v.Set.Size(), 3)
+ t.Assert(v.Set.Contains(1), true)
+ t.Assert(v.Set.Contains(2), true)
+ t.Assert(v.Set.Contains(3), true)
+ t.Assert(v.Set.Contains(4), false)
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(g.Map{
"name": "john",
"set": g.Slice{1, 2, 3},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Set.Size(), 3)
- t.Assert(t.Set.Contains(1), true)
- t.Assert(t.Set.Contains(2), true)
- t.Assert(t.Set.Contains(3), true)
- t.Assert(t.Set.Contains(4), false)
+ t.Assert(v.Name, "john")
+ t.Assert(v.Set.Size(), 3)
+ t.Assert(v.Set.Contains(1), true)
+ t.Assert(v.Set.Contains(2), true)
+ t.Assert(v.Set.Contains(3), true)
+ t.Assert(v.Set.Contains(4), false)
})
}
diff --git a/container/gset/gset_z_unit_str_test.go b/container/gset/gset_z_unit_str_test.go
index d178dce4a..7f0fbb3a6 100644
--- a/container/gset/gset_z_unit_str_test.go
+++ b/container/gset/gset_z_unit_str_test.go
@@ -364,38 +364,38 @@ func TestStrSet_AddIfNotExistFunc(t *testing.T) {
}
func TestStrSet_UnmarshalValue(t *testing.T) {
- type T struct {
+ type V struct {
Name string
Set *gset.StrSet
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(g.Map{
"name": "john",
"set": []byte(`["1","2","3"]`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Set.Size(), 3)
- t.Assert(t.Set.Contains("1"), true)
- t.Assert(t.Set.Contains("2"), true)
- t.Assert(t.Set.Contains("3"), true)
- t.Assert(t.Set.Contains("4"), false)
+ t.Assert(v.Name, "john")
+ t.Assert(v.Set.Size(), 3)
+ t.Assert(v.Set.Contains("1"), true)
+ t.Assert(v.Set.Contains("2"), true)
+ t.Assert(v.Set.Contains("3"), true)
+ t.Assert(v.Set.Contains("4"), false)
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(g.Map{
"name": "john",
"set": g.SliceStr{"1", "2", "3"},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Set.Size(), 3)
- t.Assert(t.Set.Contains("1"), true)
- t.Assert(t.Set.Contains("2"), true)
- t.Assert(t.Set.Contains("3"), true)
- t.Assert(t.Set.Contains("4"), false)
+ t.Assert(v.Name, "john")
+ t.Assert(v.Set.Size(), 3)
+ t.Assert(v.Set.Contains("1"), true)
+ t.Assert(v.Set.Contains("2"), true)
+ t.Assert(v.Set.Contains("3"), true)
+ t.Assert(v.Set.Contains("4"), false)
})
}
diff --git a/container/gtree/gtree_z_avl_tree_test.go b/container/gtree/gtree_z_avl_tree_test.go
index 2eb3a4224..aa5b0b981 100644
--- a/container/gtree/gtree_z_avl_tree_test.go
+++ b/container/gtree/gtree_z_avl_tree_test.go
@@ -99,14 +99,17 @@ func Test_AVLTree_Get_Set_Var(t *testing.T) {
}
func Test_AVLTree_Batch(t *testing.T) {
- m := gtree.NewAVLTree(gutil.ComparatorString)
- m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
- t.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
- m.Removes([]interface{}{"key1", 1})
- t.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
+ gtest.C(t, func(t *gtest.T) {
+ m := gtree.NewAVLTree(gutil.ComparatorString)
+ m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
+ t.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
+ m.Removes([]interface{}{"key1", 1})
+ t.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
+ })
}
func Test_AVLTree_Iterator(t *testing.T) {
+
keys := []string{"1", "key1", "key2", "key3", "key4"}
keyLen := len(keys)
index := 0
@@ -114,18 +117,21 @@ func Test_AVLTree_Iterator(t *testing.T) {
expect := map[interface{}]interface{}{"key4": "val4", 1: 1, "key1": "val1", "key2": "val2", "key3": "val3"}
m := gtree.NewAVLTreeFrom(gutil.ComparatorString, expect)
- m.Iterator(func(k interface{}, v interface{}) bool {
- t.Assert(k, keys[index])
- index++
- t.Assert(expect[k], v)
- return true
- })
- m.IteratorDesc(func(k interface{}, v interface{}) bool {
- index--
- t.Assert(k, keys[index])
- t.Assert(expect[k], v)
- return true
+ gtest.C(t, func(t *gtest.T) {
+ m.Iterator(func(k interface{}, v interface{}) bool {
+ t.Assert(k, keys[index])
+ index++
+ t.Assert(expect[k], v)
+ return true
+ })
+
+ m.IteratorDesc(func(k interface{}, v interface{}) bool {
+ index--
+ t.Assert(k, keys[index])
+ t.Assert(expect[k], v)
+ return true
+ })
})
m.Print()
@@ -197,16 +203,18 @@ func Test_AVLTree_IteratorFrom(t *testing.T) {
}
func Test_AVLTree_Clone(t *testing.T) {
- //clone 方法是深克隆
- m := gtree.NewAVLTreeFrom(gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"})
- m_clone := m.Clone()
- m.Remove(1)
- //修改原 map,clone 后的 map 不影响
- t.AssertIN(1, m_clone.Keys())
+ gtest.C(t, func(t *gtest.T) {
+ //clone 方法是深克隆
+ m := gtree.NewAVLTreeFrom(gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"})
+ m_clone := m.Clone()
+ m.Remove(1)
+ //修改原 map,clone 后的 map 不影响
+ t.AssertIN(1, m_clone.Keys())
- m_clone.Remove("key1")
- //修改clone map,原 map 不影响
- t.AssertIN("key1", m.Keys())
+ m_clone.Remove("key1")
+ //修改clone map,原 map 不影响
+ t.AssertIN("key1", m.Keys())
+ })
}
func Test_AVLTree_LRNode(t *testing.T) {
diff --git a/container/gtree/gtree_z_b_tree_test.go b/container/gtree/gtree_z_b_tree_test.go
index 76197292a..469226de2 100644
--- a/container/gtree/gtree_z_b_tree_test.go
+++ b/container/gtree/gtree_z_b_tree_test.go
@@ -94,11 +94,13 @@ func Test_BTree_Get_Set_Var(t *testing.T) {
}
func Test_BTree_Batch(t *testing.T) {
- m := gtree.NewBTree(3, gutil.ComparatorString)
- m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
- t.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
- m.Removes([]interface{}{"key1", 1})
- t.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
+ gtest.C(t, func(t *gtest.T) {
+ m := gtree.NewBTree(3, gutil.ComparatorString)
+ m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
+ t.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
+ m.Removes([]interface{}{"key1", 1})
+ t.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
+ })
}
func Test_BTree_Iterator(t *testing.T) {
@@ -109,18 +111,21 @@ func Test_BTree_Iterator(t *testing.T) {
expect := map[interface{}]interface{}{"key4": "val4", 1: 1, "key1": "val1", "key2": "val2", "key3": "val3"}
m := gtree.NewBTreeFrom(3, gutil.ComparatorString, expect)
- m.Iterator(func(k interface{}, v interface{}) bool {
- t.Assert(k, keys[index])
- index++
- t.Assert(expect[k], v)
- return true
- })
- m.IteratorDesc(func(k interface{}, v interface{}) bool {
- index--
- t.Assert(k, keys[index])
- t.Assert(expect[k], v)
- return true
+ gtest.C(t, func(t *gtest.T) {
+ m.Iterator(func(k interface{}, v interface{}) bool {
+ t.Assert(k, keys[index])
+ index++
+ t.Assert(expect[k], v)
+ return true
+ })
+
+ m.IteratorDesc(func(k interface{}, v interface{}) bool {
+ index--
+ t.Assert(k, keys[index])
+ t.Assert(expect[k], v)
+ return true
+ })
})
m.Print()
@@ -191,16 +196,18 @@ func Test_BTree_IteratorFrom(t *testing.T) {
}
func Test_BTree_Clone(t *testing.T) {
- //clone 方法是深克隆
- m := gtree.NewBTreeFrom(3, gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"})
- m_clone := m.Clone()
- m.Remove(1)
- //修改原 map,clone 后的 map 不影响
- t.AssertIN(1, m_clone.Keys())
+ gtest.C(t, func(t *gtest.T) {
+ //clone 方法是深克隆
+ m := gtree.NewBTreeFrom(3, gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"})
+ m_clone := m.Clone()
+ m.Remove(1)
+ //修改原 map,clone 后的 map 不影响
+ t.AssertIN(1, m_clone.Keys())
- m_clone.Remove("key1")
- //修改clone map,原 map 不影响
- t.AssertIN("key1", m.Keys())
+ m_clone.Remove("key1")
+ //修改clone map,原 map 不影响
+ t.AssertIN("key1", m.Keys())
+ })
}
func Test_BTree_LRNode(t *testing.T) {
diff --git a/container/gtype/z_unit_bool_test.go b/container/gtype/z_unit_bool_test.go
index 1ea796791..2c38694be 100644
--- a/container/gtype/z_unit_bool_test.go
+++ b/container/gtype/z_unit_bool_test.go
@@ -98,28 +98,28 @@ func Test_Bool_JSON(t *testing.T) {
}
func Test_Bool_UnmarshalValue(t *testing.T) {
- type T struct {
+ type Var struct {
Name string
Var *gtype.Bool
}
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(map[string]interface{}{
"name": "john",
"var": "true",
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Var.Val(), true)
+ t.Assert(v.Name, "john")
+ t.Assert(v.Var.Val(), true)
})
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(map[string]interface{}{
"name": "john",
"var": "false",
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Var.Val(), false)
+ t.Assert(v.Name, "john")
+ t.Assert(v.Var.Val(), false)
})
}
diff --git a/container/gtype/z_unit_byte_test.go b/container/gtype/z_unit_byte_test.go
index f6dd88505..24f17f6ba 100644
--- a/container/gtype/z_unit_byte_test.go
+++ b/container/gtype/z_unit_byte_test.go
@@ -60,18 +60,18 @@ func Test_Byte_JSON(t *testing.T) {
}
func Test_Byte_UnmarshalValue(t *testing.T) {
- type T struct {
+ type Var struct {
Name string
Var *gtype.Byte
}
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(map[string]interface{}{
"name": "john",
"var": "2",
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Var.Val(), "2")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Var.Val(), "2")
})
}
diff --git a/container/gtype/z_unit_bytes_test.go b/container/gtype/z_unit_bytes_test.go
index 1100800b7..f34fa670d 100644
--- a/container/gtype/z_unit_bytes_test.go
+++ b/container/gtype/z_unit_bytes_test.go
@@ -46,18 +46,18 @@ func Test_Bytes_JSON(t *testing.T) {
}
func Test_Bytes_UnmarshalValue(t *testing.T) {
- type T struct {
+ type Var struct {
Name string
Var *gtype.Bytes
}
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(map[string]interface{}{
"name": "john",
"var": "123",
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Var.Val(), "123")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Var.Val(), "123")
})
}
diff --git a/container/gtype/z_unit_float32_test.go b/container/gtype/z_unit_float32_test.go
index 82c866ccd..178bc45ff 100644
--- a/container/gtype/z_unit_float32_test.go
+++ b/container/gtype/z_unit_float32_test.go
@@ -47,18 +47,18 @@ func Test_Float32_JSON(t *testing.T) {
}
func Test_Float32_UnmarshalValue(t *testing.T) {
- type T struct {
+ type Var struct {
Name string
Var *gtype.Float32
}
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(map[string]interface{}{
"name": "john",
"var": "123.456",
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Var.Val(), "123.456")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Var.Val(), "123.456")
})
}
diff --git a/container/gtype/z_unit_float64_test.go b/container/gtype/z_unit_float64_test.go
index deec6de15..cfbb12aac 100644
--- a/container/gtype/z_unit_float64_test.go
+++ b/container/gtype/z_unit_float64_test.go
@@ -45,18 +45,18 @@ func Test_Float64_JSON(t *testing.T) {
}
func Test_Float64_UnmarshalValue(t *testing.T) {
- type T struct {
+ type Var struct {
Name string
Var *gtype.Float64
}
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(map[string]interface{}{
"name": "john",
"var": "123.456",
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Var.Val(), "123.456")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Var.Val(), "123.456")
})
}
diff --git a/container/gtype/z_unit_int32_test.go b/container/gtype/z_unit_int32_test.go
index 3fba55d04..37d63fb89 100644
--- a/container/gtype/z_unit_int32_test.go
+++ b/container/gtype/z_unit_int32_test.go
@@ -58,18 +58,18 @@ func Test_Int32_JSON(t *testing.T) {
}
func Test_Int32_UnmarshalValue(t *testing.T) {
- type T struct {
+ type Var struct {
Name string
Var *gtype.Int32
}
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(map[string]interface{}{
"name": "john",
"var": "123",
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Var.Val(), "123")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Var.Val(), "123")
})
}
diff --git a/container/gtype/z_unit_int64_test.go b/container/gtype/z_unit_int64_test.go
index 5fc1e8560..db69a43dc 100644
--- a/container/gtype/z_unit_int64_test.go
+++ b/container/gtype/z_unit_int64_test.go
@@ -57,18 +57,18 @@ func Test_Int64_JSON(t *testing.T) {
}
func Test_Int64_UnmarshalValue(t *testing.T) {
- type T struct {
+ type Var struct {
Name string
Var *gtype.Int64
}
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(map[string]interface{}{
"name": "john",
"var": "123",
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Var.Val(), "123")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Var.Val(), "123")
})
}
diff --git a/container/gtype/z_unit_int_test.go b/container/gtype/z_unit_int_test.go
index d56322464..94fe2df54 100644
--- a/container/gtype/z_unit_int_test.go
+++ b/container/gtype/z_unit_int_test.go
@@ -57,18 +57,18 @@ func Test_Int_JSON(t *testing.T) {
}
func Test_Int_UnmarshalValue(t *testing.T) {
- type T struct {
+ type Var struct {
Name string
Var *gtype.Int
}
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(map[string]interface{}{
"name": "john",
"var": "123",
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Var.Val(), "123")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Var.Val(), "123")
})
}
diff --git a/container/gtype/z_unit_interface_test.go b/container/gtype/z_unit_interface_test.go
index 2f39de61f..1b0413af6 100644
--- a/container/gtype/z_unit_interface_test.go
+++ b/container/gtype/z_unit_interface_test.go
@@ -16,12 +16,12 @@ import (
func Test_Interface(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
- t := Temp{Name: "gf", Age: 18}
- t1 := Temp{Name: "gf", Age: 19}
- i := gtype.New(t)
+ t1 := Temp{Name: "gf", Age: 18}
+ t2 := Temp{Name: "gf", Age: 19}
+ i := gtype.New(t1)
iClone := i.Clone()
- t.AssertEQ(iClone.Set(t1), t)
- t.AssertEQ(iClone.Val().(Temp), t1)
+ t.AssertEQ(iClone.Set(t2), t1)
+ t.AssertEQ(iClone.Val().(Temp), t2)
//空参测试
i1 := gtype.New()
@@ -47,18 +47,18 @@ func Test_Interface_JSON(t *testing.T) {
}
func Test_Interface_UnmarshalValue(t *testing.T) {
- type T struct {
+ type Var struct {
Name string
Var *gtype.Interface
}
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(map[string]interface{}{
"name": "john",
"var": "123",
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Var.Val(), "123")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Var.Val(), "123")
})
}
diff --git a/container/gtype/z_unit_string_test.go b/container/gtype/z_unit_string_test.go
index a2cc47b50..1dbd455b9 100644
--- a/container/gtype/z_unit_string_test.go
+++ b/container/gtype/z_unit_string_test.go
@@ -45,18 +45,18 @@ func Test_String_JSON(t *testing.T) {
}
func Test_String_UnmarshalValue(t *testing.T) {
- type T struct {
+ type V struct {
Name string
Var *gtype.String
}
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"var": "123",
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Var.Val(), "123")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Var.Val(), "123")
})
}
diff --git a/container/gtype/z_unit_uint32_test.go b/container/gtype/z_unit_uint32_test.go
index 177e2c0dd..9ea1483b0 100644
--- a/container/gtype/z_unit_uint32_test.go
+++ b/container/gtype/z_unit_uint32_test.go
@@ -57,18 +57,18 @@ func Test_Uint32_JSON(t *testing.T) {
}
func Test_Uint32_UnmarshalValue(t *testing.T) {
- type T struct {
+ type V struct {
Name string
Var *gtype.Uint32
}
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"var": "123",
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Var.Val(), "123")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Var.Val(), "123")
})
}
diff --git a/container/gtype/z_unit_uint64_test.go b/container/gtype/z_unit_uint64_test.go
index dee3c861b..5e65b3bd9 100644
--- a/container/gtype/z_unit_uint64_test.go
+++ b/container/gtype/z_unit_uint64_test.go
@@ -62,18 +62,18 @@ func Test_Uint64_JSON(t *testing.T) {
}
func Test_Uint64_UnmarshalValue(t *testing.T) {
- type T struct {
+ type V struct {
Name string
Var *gtype.Uint64
}
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"var": "123",
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Var.Val(), "123")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Var.Val(), "123")
})
}
diff --git a/container/gtype/z_unit_uint_test.go b/container/gtype/z_unit_uint_test.go
index 7f8d42083..a5984ee73 100644
--- a/container/gtype/z_unit_uint_test.go
+++ b/container/gtype/z_unit_uint_test.go
@@ -56,18 +56,18 @@ func Test_Uint_JSON(t *testing.T) {
}
func Test_Uint_UnmarshalValue(t *testing.T) {
- type T struct {
+ type V struct {
Name string
Var *gtype.Uint
}
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *V
err := gconv.Struct(map[string]interface{}{
"name": "john",
"var": "123",
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Var.Val(), "123")
+ t.Assert(v.Name, "john")
+ t.Assert(v.Var.Val(), "123")
})
}
diff --git a/database/gdb/gdb_unit_init_test.go b/database/gdb/gdb_unit_init_test.go
index 8f29f2f82..24f1bd3df 100644
--- a/database/gdb/gdb_unit_init_test.go
+++ b/database/gdb/gdb_unit_init_test.go
@@ -195,11 +195,11 @@ func createInitTableWithDb(db gdb.DB, table ...string) (name string) {
}
result, err := db.BatchInsert(name, array.Slice())
- t.Assert(err, nil)
+ gtest.Assert(err, nil)
n, e := result.RowsAffected()
- t.Assert(e, nil)
- t.Assert(n, SIZE)
+ gtest.Assert(e, nil)
+ gtest.Assert(n, SIZE)
return
}
diff --git a/database/gdb/gdb_unit_z_mysql_method_test.go b/database/gdb/gdb_unit_z_mysql_method_test.go
index 148cd6f1f..3b3138f1c 100644
--- a/database/gdb/gdb_unit_z_mysql_method_test.go
+++ b/database/gdb/gdb_unit_z_mysql_method_test.go
@@ -635,13 +635,13 @@ func Test_DB_Time(t *testing.T) {
})
gtest.C(t, func(t *gtest.T) {
- t := time.Now()
+ t1 := time.Now()
result, err := db.Insert(table, g.Map{
"id": 300,
"passport": "t300",
"password": "123456",
"nickname": "T300",
- "create_time": &t,
+ "create_time": &t1,
})
if err != nil {
gtest.Error(err)
@@ -662,11 +662,10 @@ func Test_DB_Time(t *testing.T) {
}
func Test_DB_ToJson(t *testing.T) {
-
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
- t.Assert(err, nil)
+ gtest.Assert(err, nil)
gtest.C(t, func(t *gtest.T) {
result, err := db.Table(table).Fields("*").Where("id =? ", 1).Select()
@@ -737,11 +736,10 @@ func Test_DB_ToJson(t *testing.T) {
}
func Test_DB_ToXml(t *testing.T) {
-
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
- t.Assert(err, nil)
+ gtest.Assert(err, nil)
gtest.C(t, func(t *gtest.T) {
record, err := db.Table(table).Fields("*").Where("id = ?", 1).One()
@@ -807,7 +805,7 @@ func Test_DB_ToStringMap(t *testing.T) {
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
- t.Assert(err, nil)
+ gtest.Assert(err, nil)
gtest.C(t, func(t *gtest.T) {
id := "1"
result, err := db.Table(table).Fields("*").Where("id = ?", 1).Select()
@@ -843,7 +841,7 @@ func Test_DB_ToIntMap(t *testing.T) {
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
- t.Assert(err, nil)
+ gtest.Assert(err, nil)
gtest.C(t, func(t *gtest.T) {
id := 1
@@ -876,11 +874,10 @@ func Test_DB_ToIntMap(t *testing.T) {
}
func Test_DB_ToUintMap(t *testing.T) {
-
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
- t.Assert(err, nil)
+ gtest.Assert(err, nil)
gtest.C(t, func(t *gtest.T) {
id := 1
@@ -914,11 +911,10 @@ func Test_DB_ToUintMap(t *testing.T) {
}
func Test_DB_ToStringRecord(t *testing.T) {
-
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
- t.Assert(err, nil)
+ gtest.Assert(err, nil)
gtest.C(t, func(t *gtest.T) {
id := 1
@@ -953,11 +949,10 @@ func Test_DB_ToStringRecord(t *testing.T) {
}
func Test_DB_ToIntRecord(t *testing.T) {
-
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
- t.Assert(err, nil)
+ gtest.Assert(err, nil)
gtest.C(t, func(t *gtest.T) {
id := 1
@@ -991,11 +986,10 @@ func Test_DB_ToIntRecord(t *testing.T) {
}
func Test_DB_ToUintRecord(t *testing.T) {
-
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
- t.Assert(err, nil)
+ gtest.Assert(err, nil)
gtest.C(t, func(t *gtest.T) {
id := 1
@@ -1030,7 +1024,6 @@ func Test_DB_ToUintRecord(t *testing.T) {
func Test_DB_TableField(t *testing.T) {
name := "field_test"
dropTable(name)
-
defer dropTable(name)
_, err := db.Exec(fmt.Sprintf(`
CREATE TABLE %s (
@@ -1069,7 +1062,7 @@ func Test_DB_TableField(t *testing.T) {
if err != nil {
gtest.Fatal(err)
} else {
- t.Assert(n, 1)
+ gtest.Assert(n, 1)
}
result, err := db.Table(name).Fields("*").Where("field_int = ?", 2).Select()
@@ -1077,7 +1070,7 @@ func Test_DB_TableField(t *testing.T) {
gtest.Fatal(err)
}
- t.Assert(result[0], data)
+ gtest.Assert(result[0], data)
}
func Test_DB_Prefix(t *testing.T) {
diff --git a/database/gdb/gdb_unit_z_mysql_model_test.go b/database/gdb/gdb_unit_z_mysql_model_test.go
index 3a90f6592..37adfbb05 100644
--- a/database/gdb/gdb_unit_z_mysql_model_test.go
+++ b/database/gdb/gdb_unit_z_mysql_model_test.go
@@ -1515,7 +1515,7 @@ func Test_Model_Offset(t *testing.T) {
t.Assert(err, nil)
t.Assert(len(result), 2)
t.Assert(result[0]["id"], 6)
- t.Assert(result[1]["id"], 7)
+ tgit.Assert(result[1]["id"], 7)
}
func Test_Model_ForPage(t *testing.T) {
diff --git a/encoding/gbinary/gbinary_z_be_test.go b/encoding/gbinary/gbinary_z_be_test.go
index 533811be0..509424c62 100644
--- a/encoding/gbinary/gbinary_z_be_test.go
+++ b/encoding/gbinary/gbinary_z_be_test.go
@@ -14,71 +14,75 @@ import (
)
func Test_BeEncodeAndBeDecode(t *testing.T) {
- for k, v := range testData {
- ve := gbinary.BeEncode(v)
- ve1 := gbinary.BeEncodeByLength(len(ve), v)
+ gtest.C(t, func(t *gtest.T) {
+ for k, v := range testData {
+ ve := gbinary.BeEncode(v)
+ ve1 := gbinary.BeEncodeByLength(len(ve), v)
- //t.Logf("%s:%v, encoded:%v\n", k, v, ve)
- switch v.(type) {
- case int:
- t.Assert(gbinary.BeDecodeToInt(ve), v)
- t.Assert(gbinary.BeDecodeToInt(ve1), v)
- case int8:
- t.Assert(gbinary.BeDecodeToInt8(ve), v)
- t.Assert(gbinary.BeDecodeToInt8(ve1), v)
- case int16:
- t.Assert(gbinary.BeDecodeToInt16(ve), v)
- t.Assert(gbinary.BeDecodeToInt16(ve1), v)
- case int32:
- t.Assert(gbinary.BeDecodeToInt32(ve), v)
- t.Assert(gbinary.BeDecodeToInt32(ve1), v)
- case int64:
- t.Assert(gbinary.BeDecodeToInt64(ve), v)
- t.Assert(gbinary.BeDecodeToInt64(ve1), v)
- case uint:
- t.Assert(gbinary.BeDecodeToUint(ve), v)
- t.Assert(gbinary.BeDecodeToUint(ve1), v)
- case uint8:
- t.Assert(gbinary.BeDecodeToUint8(ve), v)
- t.Assert(gbinary.BeDecodeToUint8(ve1), v)
- case uint16:
- t.Assert(gbinary.BeDecodeToUint16(ve1), v)
- t.Assert(gbinary.BeDecodeToUint16(ve), v)
- case uint32:
- t.Assert(gbinary.BeDecodeToUint32(ve1), v)
- t.Assert(gbinary.BeDecodeToUint32(ve), v)
- case uint64:
- t.Assert(gbinary.BeDecodeToUint64(ve), v)
- t.Assert(gbinary.BeDecodeToUint64(ve1), v)
- case bool:
- t.Assert(gbinary.BeDecodeToBool(ve), v)
- t.Assert(gbinary.BeDecodeToBool(ve1), v)
- case string:
- t.Assert(gbinary.BeDecodeToString(ve), v)
- t.Assert(gbinary.BeDecodeToString(ve1), v)
- case float32:
- t.Assert(gbinary.BeDecodeToFloat32(ve), v)
- t.Assert(gbinary.BeDecodeToFloat32(ve1), v)
- case float64:
- t.Assert(gbinary.BeDecodeToFloat64(ve), v)
- t.Assert(gbinary.BeDecodeToFloat64(ve1), v)
- default:
- if v == nil {
- continue
+ //t.Logf("%s:%v, encoded:%v\n", k, v, ve)
+ switch v.(type) {
+ case int:
+ t.Assert(gbinary.BeDecodeToInt(ve), v)
+ t.Assert(gbinary.BeDecodeToInt(ve1), v)
+ case int8:
+ t.Assert(gbinary.BeDecodeToInt8(ve), v)
+ t.Assert(gbinary.BeDecodeToInt8(ve1), v)
+ case int16:
+ t.Assert(gbinary.BeDecodeToInt16(ve), v)
+ t.Assert(gbinary.BeDecodeToInt16(ve1), v)
+ case int32:
+ t.Assert(gbinary.BeDecodeToInt32(ve), v)
+ t.Assert(gbinary.BeDecodeToInt32(ve1), v)
+ case int64:
+ t.Assert(gbinary.BeDecodeToInt64(ve), v)
+ t.Assert(gbinary.BeDecodeToInt64(ve1), v)
+ case uint:
+ t.Assert(gbinary.BeDecodeToUint(ve), v)
+ t.Assert(gbinary.BeDecodeToUint(ve1), v)
+ case uint8:
+ t.Assert(gbinary.BeDecodeToUint8(ve), v)
+ t.Assert(gbinary.BeDecodeToUint8(ve1), v)
+ case uint16:
+ t.Assert(gbinary.BeDecodeToUint16(ve1), v)
+ t.Assert(gbinary.BeDecodeToUint16(ve), v)
+ case uint32:
+ t.Assert(gbinary.BeDecodeToUint32(ve1), v)
+ t.Assert(gbinary.BeDecodeToUint32(ve), v)
+ case uint64:
+ t.Assert(gbinary.BeDecodeToUint64(ve), v)
+ t.Assert(gbinary.BeDecodeToUint64(ve1), v)
+ case bool:
+ t.Assert(gbinary.BeDecodeToBool(ve), v)
+ t.Assert(gbinary.BeDecodeToBool(ve1), v)
+ case string:
+ t.Assert(gbinary.BeDecodeToString(ve), v)
+ t.Assert(gbinary.BeDecodeToString(ve1), v)
+ case float32:
+ t.Assert(gbinary.BeDecodeToFloat32(ve), v)
+ t.Assert(gbinary.BeDecodeToFloat32(ve1), v)
+ case float64:
+ t.Assert(gbinary.BeDecodeToFloat64(ve), v)
+ t.Assert(gbinary.BeDecodeToFloat64(ve1), v)
+ default:
+ if v == nil {
+ continue
+ }
+ res := make([]byte, len(ve))
+ err := gbinary.BeDecode(ve, res)
+ if err != nil {
+ t.Errorf("test data: %s, %v, error:%v", k, v, err)
+ }
+ t.Assert(res, v)
}
- res := make([]byte, len(ve))
- err := gbinary.BeDecode(ve, res)
- if err != nil {
- t.Errorf("test data: %s, %v, error:%v", k, v, err)
- }
- t.Assert(res, v)
}
- }
+ })
}
func Test_BeEncodeStruct(t *testing.T) {
- user := User{"wenzi1", 999, "www.baidu.com"}
- ve := gbinary.BeEncode(user)
- s := gbinary.BeDecodeToString(ve)
- t.Assert(string(s), s)
+ gtest.C(t, func(t *gtest.T) {
+ user := User{"wenzi1", 999, "www.baidu.com"}
+ ve := gbinary.BeEncode(user)
+ s := gbinary.BeDecodeToString(ve)
+ t.Assert(string(s), s)
+ })
}
diff --git a/encoding/ghtml/ghtml_test.go b/encoding/ghtml/ghtml_test.go
index 0b7f43421..bbc29fb7e 100644
--- a/encoding/ghtml/ghtml_test.go
+++ b/encoding/ghtml/ghtml_test.go
@@ -13,21 +13,27 @@ import (
)
func TestStripTags(t *testing.T) {
- src := `Test paragraph.
Other text`
- dst := `Test paragraph. Other text`
- t.Assert(ghtml.StripTags(src), dst)
+ gtest.C(t, func(t *gtest.T) {
+ src := `Test paragraph.
Other text`
+ dst := `Test paragraph. Other text`
+ t.Assert(ghtml.StripTags(src), dst)
+ })
}
func TestEntities(t *testing.T) {
- src := `A 'quote' "is" bold`
- dst := `A 'quote' "is" <b>bold</b>`
- t.Assert(ghtml.Entities(src), dst)
- t.Assert(ghtml.EntitiesDecode(dst), src)
+ gtest.C(t, func(t *gtest.T) {
+ src := `A 'quote' "is" bold`
+ dst := `A 'quote' "is" <b>bold</b>`
+ t.Assert(ghtml.Entities(src), dst)
+ t.Assert(ghtml.EntitiesDecode(dst), src)
+ })
}
func TestSpecialChars(t *testing.T) {
- src := `A 'quote' "is" bold`
- dst := `A 'quote' "is" <b>bold</b>`
- t.Assert(ghtml.SpecialChars(src), dst)
- t.Assert(ghtml.SpecialCharsDecode(dst), src)
+ gtest.C(t, func(t *gtest.T) {
+ src := `A 'quote' "is" bold`
+ dst := `A 'quote' "is" <b>bold</b>`
+ t.Assert(ghtml.SpecialChars(src), dst)
+ t.Assert(ghtml.SpecialCharsDecode(dst), src)
+ })
}
diff --git a/encoding/gjson/gjson_z_unit_implements_test.go b/encoding/gjson/gjson_z_unit_implements_test.go
index 0944857fa..2e125ea34 100644
--- a/encoding/gjson/gjson_z_unit_implements_test.go
+++ b/encoding/gjson/gjson_z_unit_implements_test.go
@@ -31,28 +31,28 @@ func TestJson_UnmarshalJSON(t *testing.T) {
}
func TestJson_UnmarshalValue(t *testing.T) {
- type T struct {
+ type Var struct {
Name string
Json *gjson.Json
}
// JSON
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(g.Map{
"name": "john",
"json": []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`),
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Json.Get("n"), "123456789")
- t.Assert(t.Json.Get("m"), g.Map{"k": "v"})
- t.Assert(t.Json.Get("m.k"), "v")
- t.Assert(t.Json.Get("a"), g.Slice{1, 2, 3})
- t.Assert(t.Json.Get("a.1"), 2)
+ t.Assert(v.Name, "john")
+ t.Assert(v.Json.Get("n"), "123456789")
+ t.Assert(v.Json.Get("m"), g.Map{"k": "v"})
+ t.Assert(v.Json.Get("m.k"), "v")
+ t.Assert(v.Json.Get("a"), g.Slice{1, 2, 3})
+ t.Assert(v.Json.Get("a.1"), 2)
})
// Map
gtest.C(t, func(t *gtest.T) {
- var t *T
+ var v *Var
err := gconv.Struct(g.Map{
"name": "john",
"json": g.Map{
@@ -60,13 +60,13 @@ func TestJson_UnmarshalValue(t *testing.T) {
"m": g.Map{"k": "v"},
"a": g.Slice{1, 2, 3},
},
- }, &t)
+ }, &v)
t.Assert(err, nil)
- t.Assert(t.Name, "john")
- t.Assert(t.Json.Get("n"), "123456789")
- t.Assert(t.Json.Get("m"), g.Map{"k": "v"})
- t.Assert(t.Json.Get("m.k"), "v")
- t.Assert(t.Json.Get("a"), g.Slice{1, 2, 3})
- t.Assert(t.Json.Get("a.1"), 2)
+ t.Assert(v.Name, "john")
+ t.Assert(v.Json.Get("n"), "123456789")
+ t.Assert(v.Json.Get("m"), g.Map{"k": "v"})
+ t.Assert(v.Json.Get("m.k"), "v")
+ t.Assert(v.Json.Get("a"), g.Slice{1, 2, 3})
+ t.Assert(v.Json.Get("a.1"), 2)
})
}
diff --git a/frame/gins/gins_z_unit_config_test.go b/frame/gins/gins_z_unit_config_test.go
index 0beb16ed3..0ba1cc54d 100644
--- a/frame/gins/gins_z_unit_config_test.go
+++ b/frame/gins/gins_z_unit_config_test.go
@@ -88,116 +88,112 @@ func Test_Config2(t *testing.T) {
func Test_Config3(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
- gtest.C(t, func(t *gtest.T) {
- var err error
- dirPath := gfile.Join(gfile.TempDir(), gtime.TimestampNanoStr())
- err = gfile.Mkdir(dirPath)
- t.Assert(err, nil)
- defer gfile.Remove(dirPath)
+ var err error
+ dirPath := gfile.Join(gfile.TempDir(), gtime.TimestampNanoStr())
+ err = gfile.Mkdir(dirPath)
+ t.Assert(err, nil)
+ defer gfile.Remove(dirPath)
- name := "test.toml"
- err = gfile.PutContents(gfile.Join(dirPath, name), configContent)
- t.Assert(err, nil)
+ name := "test.toml"
+ err = gfile.PutContents(gfile.Join(dirPath, name), configContent)
+ t.Assert(err, nil)
- err = gins.Config("test").AddPath(dirPath)
- t.Assert(err, nil)
+ err = gins.Config("test").AddPath(dirPath)
+ t.Assert(err, nil)
- defer gins.Config("test").Clear()
- gins.Config("test").SetFileName("test.toml")
+ defer gins.Config("test").Clear()
+ gins.Config("test").SetFileName("test.toml")
- t.Assert(gins.Config("test").Get("test"), "v=1")
- t.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
- t.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
- })
- // for gfsnotify callbacks to refresh cache of config file
- time.Sleep(500 * time.Millisecond)
-
- gtest.C(t, func(t *gtest.T) {
- var err error
- dirPath := gfile.Join(gfile.TempDir(), gtime.TimestampNanoStr())
- err = gfile.Mkdir(dirPath)
- t.Assert(err, nil)
- defer gfile.Remove(dirPath)
-
- name := "config/test.toml"
- err = gfile.PutContents(gfile.Join(dirPath, name), configContent)
- t.Assert(err, nil)
-
- err = gins.Config("test").AddPath(dirPath)
- t.Assert(err, nil)
-
- defer gins.Config("test").Clear()
- gins.Config("test").SetFileName("test.toml")
-
- t.Assert(gins.Config("test").Get("test"), "v=1")
- t.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
- t.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
- })
- // for gfsnotify callbacks to refresh cache of config file for next unit testing case.
- time.Sleep(500 * time.Millisecond)
+ t.Assert(gins.Config("test").Get("test"), "v=1")
+ t.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
+ t.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
})
+ // for gfsnotify callbacks to refresh cache of config file
+ time.Sleep(500 * time.Millisecond)
+
+ gtest.C(t, func(t *gtest.T) {
+ var err error
+ dirPath := gfile.Join(gfile.TempDir(), gtime.TimestampNanoStr())
+ err = gfile.Mkdir(dirPath)
+ t.Assert(err, nil)
+ defer gfile.Remove(dirPath)
+
+ name := "config/test.toml"
+ err = gfile.PutContents(gfile.Join(dirPath, name), configContent)
+ t.Assert(err, nil)
+
+ err = gins.Config("test").AddPath(dirPath)
+ t.Assert(err, nil)
+
+ defer gins.Config("test").Clear()
+ gins.Config("test").SetFileName("test.toml")
+
+ t.Assert(gins.Config("test").Get("test"), "v=1")
+ t.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
+ t.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
+ })
+ // for gfsnotify callbacks to refresh cache of config file for next unit testing case.
+ time.Sleep(500 * time.Millisecond)
}
func Test_Config4(t *testing.T) {
+ // absolute path
gtest.C(t, func(t *gtest.T) {
- // absolute path
- gtest.C(t, func(t *gtest.T) {
- path := fmt.Sprintf(`%s/%d`, gfile.TempDir(), gtime.TimestampNano())
- file := fmt.Sprintf(`%s/%s`, path, "config.toml")
- err := gfile.PutContents(file, configContent)
- t.Assert(err, nil)
- defer gfile.Remove(file)
- defer gins.Config().Clear()
+ path := fmt.Sprintf(`%s/%d`, gfile.TempDir(), gtime.TimestampNano())
+ file := fmt.Sprintf(`%s/%s`, path, "config.toml")
+ err := gfile.PutContents(file, configContent)
+ t.Assert(err, nil)
+ defer gfile.Remove(file)
+ defer gins.Config().Clear()
- t.Assert(gins.Config().AddPath(path), nil)
- t.Assert(gins.Config().Get("test"), "v=1")
- t.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
- t.Assert(gins.Config().Get("redis.disk"), "127.0.0.1:6379,0")
- })
- time.Sleep(500 * time.Millisecond)
+ t.Assert(gins.Config().AddPath(path), nil)
+ t.Assert(gins.Config().Get("test"), "v=1")
+ t.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
+ t.Assert(gins.Config().Get("redis.disk"), "127.0.0.1:6379,0")
+ })
+ time.Sleep(500 * time.Millisecond)
- gtest.C(t, func(t *gtest.T) {
- path := fmt.Sprintf(`%s/%d/config`, gfile.TempDir(), gtime.TimestampNano())
- file := fmt.Sprintf(`%s/%s`, path, "config.toml")
- err := gfile.PutContents(file, configContent)
- t.Assert(err, nil)
- defer gfile.Remove(file)
- defer gins.Config().Clear()
- t.Assert(gins.Config().AddPath(path), nil)
- t.Assert(gins.Config().Get("test"), "v=1")
- t.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
- t.Assert(gins.Config().Get("redis.disk"), "127.0.0.1:6379,0")
- })
- time.Sleep(500 * time.Millisecond)
+ gtest.C(t, func(t *gtest.T) {
+ path := fmt.Sprintf(`%s/%d/config`, gfile.TempDir(), gtime.TimestampNano())
+ file := fmt.Sprintf(`%s/%s`, path, "config.toml")
+ err := gfile.PutContents(file, configContent)
+ t.Assert(err, nil)
+ defer gfile.Remove(file)
+ defer gins.Config().Clear()
+ t.Assert(gins.Config().AddPath(path), nil)
+ t.Assert(gins.Config().Get("test"), "v=1")
+ t.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
+ t.Assert(gins.Config().Get("redis.disk"), "127.0.0.1:6379,0")
+ })
+ time.Sleep(500 * time.Millisecond)
- gtest.C(t, func(t *gtest.T) {
- path := fmt.Sprintf(`%s/%d`, gfile.TempDir(), gtime.TimestampNano())
- file := fmt.Sprintf(`%s/%s`, path, "test.toml")
- err := gfile.PutContents(file, configContent)
- t.Assert(err, nil)
- defer gfile.Remove(file)
- defer gins.Config("test").Clear()
- gins.Config("test").SetFileName("test.toml")
- t.Assert(gins.Config("test").AddPath(path), nil)
- t.Assert(gins.Config("test").Get("test"), "v=1")
- t.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
- t.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
- })
- time.Sleep(500 * time.Millisecond)
+ gtest.C(t, func(t *gtest.T) {
+ path := fmt.Sprintf(`%s/%d`, gfile.TempDir(), gtime.TimestampNano())
+ file := fmt.Sprintf(`%s/%s`, path, "test.toml")
+ err := gfile.PutContents(file, configContent)
+ t.Assert(err, nil)
+ defer gfile.Remove(file)
+ defer gins.Config("test").Clear()
+ gins.Config("test").SetFileName("test.toml")
+ t.Assert(gins.Config("test").AddPath(path), nil)
+ t.Assert(gins.Config("test").Get("test"), "v=1")
+ t.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
+ t.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
+ })
+ time.Sleep(500 * time.Millisecond)
- gtest.C(t, func(t *gtest.T) {
- path := fmt.Sprintf(`%s/%d/config`, gfile.TempDir(), gtime.TimestampNano())
- file := fmt.Sprintf(`%s/%s`, path, "test.toml")
- err := gfile.PutContents(file, configContent)
- t.Assert(err, nil)
- defer gfile.Remove(file)
- defer gins.Config().Clear()
- gins.Config("test").SetFileName("test.toml")
- t.Assert(gins.Config("test").AddPath(path), nil)
- t.Assert(gins.Config("test").Get("test"), "v=1")
- t.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
- t.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
- })
+ gtest.C(t, func(t *gtest.T) {
+ path := fmt.Sprintf(`%s/%d/config`, gfile.TempDir(), gtime.TimestampNano())
+ file := fmt.Sprintf(`%s/%s`, path, "test.toml")
+ err := gfile.PutContents(file, configContent)
+ t.Assert(err, nil)
+ defer gfile.Remove(file)
+ defer gins.Config().Clear()
+ gins.Config("test").SetFileName("test.toml")
+ t.Assert(gins.Config("test").AddPath(path), nil)
+ t.Assert(gins.Config("test").Get("test"), "v=1")
+ t.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
+ t.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
})
}
func Test_Basic2(t *testing.T) {
diff --git a/frame/gins/gins_z_unit_database_test.go b/frame/gins/gins_z_unit_database_test.go
index c0be272d4..3e1294f9e 100644
--- a/frame/gins/gins_z_unit_database_test.go
+++ b/frame/gins/gins_z_unit_database_test.go
@@ -20,18 +20,20 @@ import (
func Test_Database(t *testing.T) {
databaseContent := gfile.GetContents(gfile.Join(gdebug.TestDataPath(), "database", "config.toml"))
- var err error
- dirPath := gfile.Join(gfile.TempDir(), gtime.TimestampNanoStr())
- err = gfile.Mkdir(dirPath)
- t.Assert(err, nil)
- defer gfile.Remove(dirPath)
+ gtest.C(t, func(t *gtest.T) {
+ var err error
+ dirPath := gfile.Join(gfile.TempDir(), gtime.TimestampNanoStr())
+ err = gfile.Mkdir(dirPath)
+ t.Assert(err, nil)
+ defer gfile.Remove(dirPath)
- name := "config.toml"
- err = gfile.PutContents(gfile.Join(dirPath, name), databaseContent)
- t.Assert(err, nil)
+ name := "config.toml"
+ err = gfile.PutContents(gfile.Join(dirPath, name), databaseContent)
+ t.Assert(err, nil)
- err = gins.Config().AddPath(dirPath)
- t.Assert(err, nil)
+ err = gins.Config().AddPath(dirPath)
+ t.Assert(err, nil)
+ })
defer gins.Config().Clear()
diff --git a/frame/gins/gins_z_unit_redis_test.go b/frame/gins/gins_z_unit_redis_test.go
index 7ec312fa6..d4184f97a 100644
--- a/frame/gins/gins_z_unit_redis_test.go
+++ b/frame/gins/gins_z_unit_redis_test.go
@@ -20,18 +20,20 @@ import (
func Test_Redis(t *testing.T) {
redisContent := gfile.GetContents(gfile.Join(gdebug.TestDataPath(), "redis", "config.toml"))
- var err error
- dirPath := gfile.Join(gfile.TempDir(), gtime.TimestampNanoStr())
- err = gfile.Mkdir(dirPath)
- t.Assert(err, nil)
- defer gfile.Remove(dirPath)
+ gtest.C(t, func(t *gtest.T) {
+ var err error
+ dirPath := gfile.Join(gfile.TempDir(), gtime.TimestampNanoStr())
+ err = gfile.Mkdir(dirPath)
+ t.Assert(err, nil)
+ defer gfile.Remove(dirPath)
- name := "config.toml"
- err = gfile.PutContents(gfile.Join(dirPath, name), redisContent)
- t.Assert(err, nil)
+ name := "config.toml"
+ err = gfile.PutContents(gfile.Join(dirPath, name), redisContent)
+ t.Assert(err, nil)
- err = gins.Config().AddPath(dirPath)
- t.Assert(err, nil)
+ err = gins.Config().AddPath(dirPath)
+ t.Assert(err, nil)
+ })
defer gins.Config().Clear()
diff --git a/i18n/gi18n/gi18n_unit_test.go b/i18n/gi18n/gi18n_unit_test.go
index 189864360..34dc71fbc 100644
--- a/i18n/gi18n/gi18n_unit_test.go
+++ b/i18n/gi18n/gi18n_unit_test.go
@@ -28,48 +28,48 @@ import (
func Test_Basic(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
- t := gi18n.New(gi18n.Options{
+ i18n := gi18n.New(gi18n.Options{
Path: gdebug.CallerDirectory() + gfile.Separator + "testdata" + gfile.Separator + "i18n",
})
- t.SetLanguage("none")
- t.Assert(t.T("{#hello}{#world}"), "{#hello}{#world}")
+ i18n.SetLanguage("none")
+ t.Assert(i18n.T("{#hello}{#world}"), "{#hello}{#world}")
- t.SetLanguage("ja")
- t.Assert(t.T("{#hello}{#world}"), "こんにちは世界")
+ i18n.SetLanguage("ja")
+ t.Assert(i18n.T("{#hello}{#world}"), "こんにちは世界")
- t.SetLanguage("zh-CN")
- t.Assert(t.T("{#hello}{#world}"), "你好世界")
- t.SetDelimiters("{$", "}")
- t.Assert(t.T("{#hello}{#world}"), "{#hello}{#world}")
- t.Assert(t.T("{$hello}{$world}"), "你好世界")
+ i18n.SetLanguage("zh-CN")
+ t.Assert(i18n.T("{#hello}{#world}"), "你好世界")
+ i18n.SetDelimiters("{$", "}")
+ t.Assert(i18n.T("{#hello}{#world}"), "{#hello}{#world}")
+ t.Assert(i18n.T("{$hello}{$world}"), "你好世界")
})
gtest.C(t, func(t *gtest.T) {
- t := gi18n.New(gi18n.Options{
+ i18n := gi18n.New(gi18n.Options{
Path: gdebug.CallerDirectory() + gfile.Separator + "testdata" + gfile.Separator + "i18n-file",
})
- t.SetLanguage("none")
- t.Assert(t.T("{#hello}{#world}"), "{#hello}{#world}")
+ i18n.SetLanguage("none")
+ t.Assert(i18n.T("{#hello}{#world}"), "{#hello}{#world}")
- t.SetLanguage("ja")
- t.Assert(t.T("{#hello}{#world}"), "こんにちは世界")
+ i18n.SetLanguage("ja")
+ t.Assert(i18n.T("{#hello}{#world}"), "こんにちは世界")
- t.SetLanguage("zh-CN")
- t.Assert(t.T("{#hello}{#world}"), "你好世界")
+ i18n.SetLanguage("zh-CN")
+ t.Assert(i18n.T("{#hello}{#world}"), "你好世界")
})
gtest.C(t, func(t *gtest.T) {
- t := gi18n.New(gi18n.Options{
+ i18n := gi18n.New(gi18n.Options{
Path: gdebug.CallerDirectory() + gfile.Separator + "testdata" + gfile.Separator + "i18n-dir",
})
- t.SetLanguage("none")
- t.Assert(t.T("{#hello}{#world}"), "{#hello}{#world}")
+ i18n.SetLanguage("none")
+ t.Assert(i18n.T("{#hello}{#world}"), "{#hello}{#world}")
- t.SetLanguage("ja")
- t.Assert(t.T("{#hello}{#world}"), "こんにちは世界")
+ i18n.SetLanguage("ja")
+ t.Assert(i18n.T("{#hello}{#world}"), "こんにちは世界")
- t.SetLanguage("zh-CN")
- t.Assert(t.T("{#hello}{#world}"), "你好世界")
+ i18n.SetLanguage("zh-CN")
+ t.Assert(i18n.T("{#hello}{#world}"), "你好世界")
})
}
diff --git a/net/ghttp/ghttp_unit_websocket_test.go b/net/ghttp/ghttp_unit_websocket_test.go
index a21a1a704..31c0059a5 100644
--- a/net/ghttp/ghttp_unit_websocket_test.go
+++ b/net/ghttp/ghttp_unit_websocket_test.go
@@ -51,9 +51,9 @@ func Test_WebSocket(t *testing.T) {
err = conn.WriteMessage(websocket.TextMessage, msg)
t.Assert(err, nil)
- t, data, err := conn.ReadMessage()
+ mt, data, err := conn.ReadMessage()
t.Assert(err, nil)
- t.Assert(t, websocket.TextMessage)
+ t.Assert(mt, websocket.TextMessage)
t.Assert(data, msg)
})
}
diff --git a/os/gcron/gcron_unit_2_test.go b/os/gcron/gcron_unit_2_test.go
index 1432970c5..8635bff94 100644
--- a/os/gcron/gcron_unit_2_test.go
+++ b/os/gcron/gcron_unit_2_test.go
@@ -18,23 +18,22 @@ import (
func TestCron_Entry_Operations(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
-
- gtest.C(t, func(t *gtest.T) {
- cron := gcron.New()
- array := garray.New(true)
- cron.DelayAddTimes(500*time.Millisecond, "* * * * * *", 2, func() {
- glog.Println("add times")
- array.Append(1)
- })
- t.Assert(cron.Size(), 0)
- time.Sleep(800 * time.Millisecond)
- t.Assert(array.Len(), 0)
- t.Assert(cron.Size(), 1)
- time.Sleep(3000 * time.Millisecond)
- t.Assert(array.Len(), 2)
- t.Assert(cron.Size(), 0)
+ cron := gcron.New()
+ array := garray.New(true)
+ cron.DelayAddTimes(500*time.Millisecond, "* * * * * *", 2, func() {
+ glog.Println("add times")
+ array.Append(1)
})
+ t.Assert(cron.Size(), 0)
+ time.Sleep(800 * time.Millisecond)
+ t.Assert(array.Len(), 0)
+ t.Assert(cron.Size(), 1)
+ time.Sleep(3000 * time.Millisecond)
+ t.Assert(array.Len(), 2)
+ t.Assert(cron.Size(), 0)
+ })
+ gtest.C(t, func(t *gtest.T) {
cron := gcron.New()
array := garray.New(true)
entry, err1 := cron.Add("* * * * * *", func() {
diff --git a/os/gres/testdata/data/data.go b/os/gres/testdata/data/data.go
index a59864d77..46e1650d6 100644
--- a/os/gres/testdata/data/data.go
+++ b/os/gres/testdata/data/data.go
@@ -3,7 +3,7 @@ package data
import "github.com/gogf/gf/os/gres"
func init() {
- if err := gres.Add("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"); err != nil {
+ if err := gres.Add("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"); err != nil {
panic(err)
}
}
diff --git a/os/gres/testdata/testdata.go b/os/gres/testdata/testdata.go
index 4e0b16a3b..fc73a247b 100644
--- a/os/gres/testdata/testdata.go
+++ b/os/gres/testdata/testdata.go
@@ -3,7 +3,7 @@ package testdata
import "github.com/gogf/gf/os/gres"
func init() {
- if err := gres.Add("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"); err != nil {
+ if err := gres.Add("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"); err != nil {
panic(err)
}
}
diff --git a/os/gsession/gsession_unit_storage_redis_hashtable_test.go b/os/gsession/gsession_unit_storage_redis_hashtable_test.go
index 81c6f140a..f9f6cd3eb 100644
--- a/os/gsession/gsession_unit_storage_redis_hashtable_test.go
+++ b/os/gsession/gsession_unit_storage_redis_hashtable_test.go
@@ -18,7 +18,9 @@ import (
func Test_StorageRedisHashTable(t *testing.T) {
redis, err := gredis.NewFromStr("127.0.0.1:6379,0")
- t.Assert(err, nil)
+ gtest.C(t, func(t *gtest.T) {
+ t.Assert(err, nil)
+ })
storage := gsession.NewStorageRedisHashTable(redis)
manager := gsession.New(time.Second, storage)
@@ -78,7 +80,9 @@ func Test_StorageRedisHashTable(t *testing.T) {
func Test_StorageRedisHashTablePrefix(t *testing.T) {
redis, err := gredis.NewFromStr("127.0.0.1:6379,0")
- t.Assert(err, nil)
+ gtest.C(t, func(t *gtest.T) {
+ t.Assert(err, nil)
+ })
prefix := "s_"
storage := gsession.NewStorageRedisHashTable(redis, prefix)
diff --git a/os/gsession/gsession_unit_storage_redis_test.go b/os/gsession/gsession_unit_storage_redis_test.go
index 79f1aa61e..278c404ea 100644
--- a/os/gsession/gsession_unit_storage_redis_test.go
+++ b/os/gsession/gsession_unit_storage_redis_test.go
@@ -18,7 +18,7 @@ import (
func Test_StorageRedis(t *testing.T) {
redis, err := gredis.NewFromStr("127.0.0.1:6379,0")
- t.Assert(err, nil)
+ gtest.Assert(err, nil)
storage := gsession.NewStorageRedis(redis)
manager := gsession.New(time.Second, storage)
@@ -79,7 +79,7 @@ func Test_StorageRedis(t *testing.T) {
func Test_StorageRedisPrefix(t *testing.T) {
redis, err := gredis.NewFromStr("127.0.0.1:6379,0")
- t.Assert(err, nil)
+ gtest.Assert(err, nil)
prefix := "s_"
storage := gsession.NewStorageRedis(redis, prefix)
diff --git a/os/gtime/gtime_z_unit_json_test.go b/os/gtime/gtime_z_unit_json_test.go
index 39c0bde61..0c5c07592 100644
--- a/os/gtime/gtime_z_unit_json_test.go
+++ b/os/gtime/gtime_z_unit_json_test.go
@@ -19,10 +19,10 @@ func Test_Json_Pointer(t *testing.T) {
type T struct {
Time *gtime.Time
}
- t := new(T)
+ t1 := new(T)
s := "2006-01-02 15:04:05"
- t.Time = gtime.NewFromStr(s)
- j, err := json.Marshal(t)
+ t1.Time = gtime.NewFromStr(s)
+ j, err := json.Marshal(t1)
t.Assert(err, nil)
t.Assert(j, `{"Time":"2006-01-02 15:04:05"}`)
})
@@ -31,8 +31,8 @@ func Test_Json_Pointer(t *testing.T) {
type T struct {
Time *gtime.Time
}
- t := new(T)
- j, err := json.Marshal(t)
+ t1 := new(T)
+ j, err := json.Marshal(t1)
t.Assert(err, nil)
t.Assert(j, `{"Time":null}`)
})
@@ -41,18 +41,18 @@ func Test_Json_Pointer(t *testing.T) {
type T struct {
Time *gtime.Time `json:"time,omitempty"`
}
- t := new(T)
- j, err := json.Marshal(t)
+ t1 := new(T)
+ j, err := json.Marshal(t1)
t.Assert(err, nil)
t.Assert(j, `{}`)
})
// Unmarshal
gtest.C(t, func(t *gtest.T) {
- var t gtime.Time
+ var t1 gtime.Time
s := []byte(`"2006-01-02 15:04:05"`)
- err := json.Unmarshal(s, &t)
+ err := json.Unmarshal(s, &t1)
t.Assert(err, nil)
- t.Assert(t.String(), "2006-01-02 15:04:05")
+ t.Assert(t1.String(), "2006-01-02 15:04:05")
})
}
@@ -62,10 +62,10 @@ func Test_Json_Struct(t *testing.T) {
type T struct {
Time gtime.Time
}
- t := new(T)
+ t1 := new(T)
s := "2006-01-02 15:04:05"
- t.Time = *gtime.NewFromStr(s)
- j, err := json.Marshal(t)
+ t1.Time = *gtime.NewFromStr(s)
+ j, err := json.Marshal(t1)
t.Assert(err, nil)
t.Assert(j, `{"Time":"2006-01-02 15:04:05"}`)
})
@@ -74,8 +74,8 @@ func Test_Json_Struct(t *testing.T) {
type T struct {
Time gtime.Time
}
- t := new(T)
- j, err := json.Marshal(t)
+ t1 := new(T)
+ j, err := json.Marshal(t1)
t.Assert(err, nil)
t.Assert(j, `{"Time":""}`)
})
@@ -84,8 +84,8 @@ func Test_Json_Struct(t *testing.T) {
type T struct {
Time gtime.Time `json:"time,omitempty"`
}
- t := new(T)
- j, err := json.Marshal(t)
+ t1 := new(T)
+ j, err := json.Marshal(t1)
t.Assert(err, nil)
t.Assert(j, `{"time":""}`)
})
diff --git a/os/gtime/gtime_z_unit_time_test.go b/os/gtime/gtime_z_unit_time_test.go
index 405e84d18..35fb0a4f8 100644
--- a/os/gtime/gtime_z_unit_time_test.go
+++ b/os/gtime/gtime_z_unit_time_test.go
@@ -28,12 +28,12 @@ func Test_New(t *testing.T) {
func Test_Nil(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
- var t *gtime.Time
- t.Assert(t.String(), "")
+ var t1 *gtime.Time
+ t.Assert(t1.String(), "")
})
gtest.C(t, func(t *gtest.T) {
- var t gtime.Time
- t.Assert(t.String(), "")
+ var t1 gtime.Time
+ t.Assert(t1.String(), "")
})
}
diff --git a/os/gtimer/gtimer_z_unit_2_test.go b/os/gtimer/gtimer_z_unit_2_test.go
index 7c34f357e..dce9aed39 100644
--- a/os/gtimer/gtimer_z_unit_2_test.go
+++ b/os/gtimer/gtimer_z_unit_2_test.go
@@ -18,60 +18,68 @@ import (
)
func TestEntry_Start_Stop_Close(t *testing.T) {
- timer := New()
- array := garray.New(true)
- entry := timer.Add(200*time.Millisecond, func() {
- array.Append(1)
- })
- time.Sleep(250 * time.Millisecond)
- t.Assert(array.Len(), 1)
- entry.Stop()
- time.Sleep(250 * time.Millisecond)
- t.Assert(array.Len(), 1)
- entry.Start()
- time.Sleep(250 * time.Millisecond)
- t.Assert(array.Len(), 2)
- entry.Close()
- time.Sleep(250 * time.Millisecond)
- t.Assert(array.Len(), 2)
+ gtest.C(t, func(t *gtest.T) {
+ timer := New()
+ array := garray.New(true)
+ entry := timer.Add(200*time.Millisecond, func() {
+ array.Append(1)
+ })
+ time.Sleep(250 * time.Millisecond)
+ t.Assert(array.Len(), 1)
+ entry.Stop()
+ time.Sleep(250 * time.Millisecond)
+ t.Assert(array.Len(), 1)
+ entry.Start()
+ time.Sleep(250 * time.Millisecond)
+ t.Assert(array.Len(), 2)
+ entry.Close()
+ time.Sleep(250 * time.Millisecond)
+ t.Assert(array.Len(), 2)
- t.Assert(entry.Status(), gtimer.STATUS_CLOSED)
+ t.Assert(entry.Status(), gtimer.STATUS_CLOSED)
+ })
}
func TestEntry_Singleton(t *testing.T) {
- timer := New()
- array := garray.New(true)
- entry := timer.Add(200*time.Millisecond, func() {
- array.Append(1)
- time.Sleep(10 * time.Second)
- })
- t.Assert(entry.IsSingleton(), false)
- entry.SetSingleton(true)
- t.Assert(entry.IsSingleton(), true)
- time.Sleep(250 * time.Millisecond)
- t.Assert(array.Len(), 1)
+ gtest.C(t, func(t *gtest.T) {
+ timer := New()
+ array := garray.New(true)
+ entry := timer.Add(200*time.Millisecond, func() {
+ array.Append(1)
+ time.Sleep(10 * time.Second)
+ })
+ t.Assert(entry.IsSingleton(), false)
+ entry.SetSingleton(true)
+ t.Assert(entry.IsSingleton(), true)
+ time.Sleep(250 * time.Millisecond)
+ t.Assert(array.Len(), 1)
- time.Sleep(250 * time.Millisecond)
- t.Assert(array.Len(), 1)
+ time.Sleep(250 * time.Millisecond)
+ t.Assert(array.Len(), 1)
+ })
}
func TestEntry_SetTimes(t *testing.T) {
- timer := New()
- array := garray.New(true)
- entry := timer.Add(200*time.Millisecond, func() {
- array.Append(1)
+ gtest.C(t, func(t *gtest.T) {
+ timer := New()
+ array := garray.New(true)
+ entry := timer.Add(200*time.Millisecond, func() {
+ array.Append(1)
+ })
+ entry.SetTimes(2)
+ time.Sleep(1200 * time.Millisecond)
+ t.Assert(array.Len(), 2)
})
- entry.SetTimes(2)
- time.Sleep(1200 * time.Millisecond)
- t.Assert(array.Len(), 2)
}
func TestEntry_Run(t *testing.T) {
- timer := New()
- array := garray.New(true)
- entry := timer.Add(1000*time.Millisecond, func() {
- array.Append(1)
+ gtest.C(t, func(t *gtest.T) {
+ timer := New()
+ array := garray.New(true)
+ entry := timer.Add(1000*time.Millisecond, func() {
+ array.Append(1)
+ })
+ entry.Run()
+ t.Assert(array.Len(), 1)
})
- entry.Run()
- t.Assert(array.Len(), 1)
}
diff --git a/test/gtest/gtest_t.go b/test/gtest/gtest_t.go
index b4b522cdd..acdd8989c 100644
--- a/test/gtest/gtest_t.go
+++ b/test/gtest/gtest_t.go
@@ -12,7 +12,7 @@ import (
// T is the testing unit case management object.
type T struct {
- T *testing.T
+ *testing.T
}
// Assert checks and EQUAL.
diff --git a/text/gstr/gstr_z_unit_parse_test.go b/text/gstr/gstr_z_unit_parse_test.go
index fed8ae01d..d2e414ca7 100644
--- a/text/gstr/gstr_z_unit_parse_test.go
+++ b/text/gstr/gstr_z_unit_parse_test.go
@@ -18,20 +18,18 @@ import (
)
func Test_Parse(t *testing.T) {
+ // url
gtest.C(t, func(t *gtest.T) {
- // url
- gtest.C(t, func(t *gtest.T) {
- s := "goframe.org/index?name=john&score=100"
- u, err := url.Parse(s)
- t.Assert(err, nil)
- m, err := gstr.Parse(u.RawQuery)
- t.Assert(err, nil)
- t.Assert(m["name"], "john")
- t.Assert(m["score"], "100")
- })
+ s := "goframe.org/index?name=john&score=100"
+ u, err := url.Parse(s)
+ t.Assert(err, nil)
+ m, err := gstr.Parse(u.RawQuery)
+ t.Assert(err, nil)
+ t.Assert(m["name"], "john")
+ t.Assert(m["score"], "100")
// name overwrite
- m, err := gstr.Parse("a=1&a=2")
+ m, err = gstr.Parse("a=1&a=2")
t.Assert(err, nil)
t.Assert(m, g.Map{
"a": 2,
diff --git a/util/gvalid/gvalid_unit_customerror_test.go b/util/gvalid/gvalid_unit_customerror_test.go
index 894d59d4f..7e7ef3908 100755
--- a/util/gvalid/gvalid_unit_customerror_test.go
+++ b/util/gvalid/gvalid_unit_customerror_test.go
@@ -15,23 +15,27 @@ import (
)
func Test_Map(t *testing.T) {
- rule := "ipv4"
- val := "0.0.0"
- msg := map[string]string{
- "ipv4": "IPv4地址格式不正确",
- }
+ gtest.C(t, func(t *gtest.T) {
+ rule := "ipv4"
+ val := "0.0.0"
+ msg := map[string]string{
+ "ipv4": "IPv4地址格式不正确",
+ }
- err := gvalid.Check(val, rule, nil)
- t.Assert(err.Map(), msg)
+ err := gvalid.Check(val, rule, nil)
+ t.Assert(err.Map(), msg)
+ })
}
func Test_FirstString(t *testing.T) {
- rule := "ipv4"
- val := "0.0.0"
+ gtest.C(t, func(t *gtest.T) {
+ rule := "ipv4"
+ val := "0.0.0"
- err := gvalid.Check(val, rule, nil)
- n := err.FirstString()
- t.Assert(n, "IPv4地址格式不正确")
+ err := gvalid.Check(val, rule, nil)
+ n := err.FirstString()
+ t.Assert(n, "IPv4地址格式不正确")
+ })
}
func Test_SetDefaultErrorMsgs(t *testing.T) {