fullfil unit test cases of gset

g/container/gset/gset.go

@@ -9,9 +9,226 @@
 // 并发安全集合.
 package gset
 
-type Set = InterfaceSet
+import (
+    "fmt"
+    "gitee.com/johng/gf/g/internal/rwmutex"
+)
+
+type Set struct {
+    mu *rwmutex.RWMutex
+    m  map[interface{}]struct{}
+}
 
-// 默认Set类型
 func New(unsafe...bool) *Set {
-    return NewInterfaceSet(unsafe...)
+    return NewSet(unsafe...)
+}
+
+func NewSet(unsafe...bool) *Set {
+    return &Set{
+        m  : make(map[interface{}]struct{}),
+        mu : rwmutex.New(unsafe...),
+    }
+}
+
+// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+func (set *Set) Iterator(f func (v interface{}) bool) *Set {
+    set.mu.RLock()
+    defer set.mu.RUnlock()
+    for k, _ := range set.m {
+        if !f(k) {
+            break
+        }
+    }
+    return set
+}
+
+// 添加
+func (set *Set) Add(item interface{}) *Set {
+    set.mu.Lock()
+    set.m[item] = struct{}{}
+    set.mu.Unlock()
+    return set
+}
+
+// 批量添加
+func (set *Set) BatchAdd(items []interface{}) *Set {
+    set.mu.Lock()
+    for _, item := range items {
+        set.m[item] = struct{}{}
+    }
+    set.mu.Unlock()
+    return set
+}
+
+// 键是否存在
+func (set *Set) Contains(item interface{}) bool {
+    set.mu.RLock()
+    _, exists := set.m[item]
+    set.mu.RUnlock()
+    return exists
+}
+
+// 删除键值对
+func (set *Set) Remove(key interface{}) *Set {
+    set.mu.Lock()
+    delete(set.m, key)
+    set.mu.Unlock()
+    return set
+}
+
+// 大小
+func (set *Set) Size() int {
+    set.mu.RLock()
+    l := len(set.m)
+    set.mu.RUnlock()
+    return l
+}
+
+// 清空set
+func (set *Set) Clear() *Set {
+    set.mu.Lock()
+    set.m = make(map[interface{}]struct{})
+    set.mu.Unlock()
+    return set
+}
+
+// 转换为数组
+func (set *Set) Slice() []interface{} {
+    set.mu.RLock()
+    i   := 0
+    ret := make([]interface{}, len(set.m))
+    for item := range set.m {
+        ret[i] = item
+        i++
+    }
+    set.mu.RUnlock()
+    return ret
+}
+
+// 转换为字符串
+func (set *Set) String() string {
+    return fmt.Sprint(set.Slice())
+}
+
+func (set *Set) LockFunc(f func(m map[interface{}]struct{})) *Set {
+    set.mu.Lock(true)
+    defer set.mu.Unlock(true)
+    f(set.m)
+    return set
+}
+
+func (set *Set) RLockFunc(f func(m map[interface{}]struct{})) *Set {
+    set.mu.RLock(true)
+    defer set.mu.RUnlock(true)
+    f(set.m)
+    return set
+}
+
+// 判断两个集合是否相等.
+func (set *Set) Equal(other *Set) bool {
+    if set == other {
+        return true
+    }
+    set.mu.RLock()
+    defer set.mu.RUnlock()
+    other.mu.RLock()
+    defer other.mu.RUnlock()
+    if len(set.m) != len(other.m) {
+        return false
+    }
+    for key := range set.m {
+        if _, ok := other.m[key]; !ok {
+            return false
+        }
+    }
+    return true
+}
+
+// 判断当前集合是否为other集合的子集.
+func (set *Set) IsSubsetOf(other *Set) bool {
+    if set == other {
+        return true
+    }
+    set.mu.RLock()
+    defer set.mu.RUnlock()
+    other.mu.RLock()
+    defer other.mu.RUnlock()
+    for key := range set.m {
+        if _, ok := other.m[key]; !ok {
+            return false
+        }
+    }
+    return true
+}
+
+// 并集, 返回新的集合：属于set或属于other的元素为元素的集合.
+func (set *Set) Union(other *Set) (newSet *Set) {
+    newSet = NewSet(true)
+    set.mu.RLock()
+    defer set.mu.RUnlock()
+    if set != other {
+        other.mu.RLock()
+        defer other.mu.RUnlock()
+    }
+    for k, v := range set.m {
+        newSet.m[k] = v
+    }
+    if set != other {
+        for k, v := range other.m {
+            newSet.m[k] = v
+        }
+    }
+    return
+}
+
+// 差集, 返回新的集合: 属于set且不属于other的元素为元素的集合.
+func (set *Set) Diff(other *Set) (newSet *Set) {
+    newSet = NewSet(true)
+    if set == other {
+        return newSet
+    }
+    set.mu.RLock()
+    defer set.mu.RUnlock()
+    other.mu.RLock()
+    defer other.mu.RUnlock()
+
+    for k, v := range set.m {
+        if _, ok := other.m[k]; !ok {
+            newSet.m[k] = v
+        }
+    }
+    return
+}
+
+// 交集, 返回新的集合: 属于set且属于other的元素为元素的集合.
+func (set *Set) Inter(other *Set) (newSet *Set) {
+    newSet = NewSet(true)
+    set.mu.RLock()
+    defer set.mu.RUnlock()
+    if set != other {
+        other.mu.RLock()
+        defer other.mu.RUnlock()
+    }
+    for k, v := range set.m {
+        if _, ok := other.m[k]; ok {
+            newSet.m[k] = v
+        }
+    }
+    return
+}
+
+// 补集, 返回新的集合: (前提: set应当为full的子集)属于全集full不属于集合set的元素组成的集合.
+// 如果给定的full集合不是set的全集时，返回full与set的差集.
+func (set *Set) Complement(full *Set) (newSet *Set) {
+    newSet = NewSet(true)
+    set.mu.RLock()
+    defer set.mu.RUnlock()
+    full.mu.RLock()
+    defer full.mu.RUnlock()
+    for k, v := range full.m {
+        if _, ok := set.m[k]; !ok {
+            newSet.m[k] = v
+        }
+    }
+    return
 }

g/container/gset/gset_int_set.go

@@ -92,8 +92,8 @@ func (set *IntSet) Slice() []int {
 	set.mu.RLock()
 	ret := make([]int, len(set.m))
 	i := 0
-	for item := range set.m {
-		ret[i] = item
+	for k, _ := range set.m {
+		ret[i] = k
 		i++
 	}
 	set.mu.RUnlock()
@@ -139,8 +139,8 @@ func (set *IntSet) Equal(other *IntSet) bool {
 	return true
 }
 
-// 判断other集合是否为当前集合的子集.
-func (set *IntSet) IsSubset(other *IntSet) bool {
+// 判断当前集合是否为other集合的子集.
+func (set *IntSet) IsSubsetOf(other *IntSet) bool {
     if set == other {
         return true
     }
@@ -148,11 +148,8 @@ func (set *IntSet) IsSubset(other *IntSet) bool {
     defer set.mu.RUnlock()
     other.mu.RLock()
     defer other.mu.RUnlock()
-    if len(set.m) != len(other.m) {
-        return false
-    }
-    for key := range other.m {
-        if _, ok := set.m[key]; !ok {
+    for key := range set.m {
+        if _, ok := other.m[key]; !ok {
             return false
         }
     }
@@ -216,6 +213,7 @@ func (set *IntSet) Inter(other *IntSet) (newSet *IntSet) {
 }
 
 // 补集, 返回新的集合: (前提: set应当为full的子集)属于全集full不属于集合set的元素组成的集合.
+// 如果给定的full集合不是set的全集时，返回full与set的差集.
 func (set *IntSet) Complement(full *IntSet) (newSet *IntSet) {
     newSet = NewIntSet(true)
     set.mu.RLock()

g/container/gset/gset_interface_set.go

@@ -1,230 +0,0 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://gitee.com/johng/gf.
-//
-
-package gset
-
-import (
-	"fmt"
-	"gitee.com/johng/gf/g/internal/rwmutex"
-)
-
-type InterfaceSet struct {
-	mu *rwmutex.RWMutex
-	m  map[interface{}]struct{}
-}
-
-func NewInterfaceSet(unsafe...bool) *InterfaceSet {
-	return &InterfaceSet{
-		m  : make(map[interface{}]struct{}),
-		mu : rwmutex.New(unsafe...),
-    }
-}
-
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
-func (set *InterfaceSet) Iterator(f func (v interface{}) bool) *InterfaceSet {
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    for k, _ := range set.m {
-		if !f(k) {
-			break
-		}
-    }
-    return set
-}
-
-// 添加
-func (set *InterfaceSet) Add(item interface{}) *InterfaceSet {
-	set.mu.Lock()
-	set.m[item] = struct{}{}
-	set.mu.Unlock()
-	return set
-}
-
-// 批量添加
-func (set *InterfaceSet) BatchAdd(items []interface{}) *InterfaceSet {
-	set.mu.Lock()
-	for _, item := range items {
-		set.m[item] = struct{}{}
-	}
-	set.mu.Unlock()
-    return set
-}
-
-// 键是否存在
-func (set *InterfaceSet) Contains(item interface{}) bool {
-	set.mu.RLock()
-	_, exists := set.m[item]
-	set.mu.RUnlock()
-	return exists
-}
-
-// 删除键值对
-func (set *InterfaceSet) Remove(key interface{}) *InterfaceSet {
-	set.mu.Lock()
-	delete(set.m, key)
-	set.mu.Unlock()
-	return set
-}
-
-// 大小
-func (set *InterfaceSet) Size() int {
-	set.mu.RLock()
-	l := len(set.m)
-	set.mu.RUnlock()
-	return l
-}
-
-// 清空set
-func (set *InterfaceSet) Clear() *InterfaceSet {
-	set.mu.Lock()
-	set.m = make(map[interface{}]struct{})
-	set.mu.Unlock()
-    return set
-}
-
-// 转换为数组
-func (set *InterfaceSet) Slice() []interface{} {
-	set.mu.RLock()
-	i   := 0
-	ret := make([]interface{}, len(set.m))
-	for item := range set.m {
-		ret[i] = item
-		i++
-	}
-	set.mu.RUnlock()
-	return ret
-}
-
-// 转换为字符串
-func (set *InterfaceSet) String() string {
-	return fmt.Sprint(set.Slice())
-}
-
-func (set *InterfaceSet) LockFunc(f func(m map[interface{}]struct{})) *InterfaceSet {
-	set.mu.Lock(true)
-	defer set.mu.Unlock(true)
-	f(set.m)
-    return set
-}
-
-func (set *InterfaceSet) RLockFunc(f func(m map[interface{}]struct{})) *InterfaceSet {
-	set.mu.RLock(true)
-	defer set.mu.RUnlock(true)
-	f(set.m)
-    return set
-}
-
-// 判断两个集合是否相等.
-func (set *InterfaceSet) Equal(other *InterfaceSet) bool {
-	if set == other {
-		return true
-	}
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-	if len(set.m) != len(other.m) {
-		return false
-	}
-	for key := range set.m {
-		if _, ok := other.m[key]; !ok {
-			return false
-		}
-	}
-	return true
-}
-
-// 判断other集合是否为当前集合的子集.
-func (set *InterfaceSet) IsSubset(other *InterfaceSet) bool {
-	if set == other {
-		return true
-	}
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-	if len(set.m) != len(other.m) {
-		return false
-	}
-	for key := range other.m {
-		if _, ok := set.m[key]; !ok {
-			return false
-		}
-	}
-	return true
-}
-
-// 并集, 返回新的集合：属于set或属于other的元素为元素的集合.
-func (set *InterfaceSet) Union(other *InterfaceSet) (newSet *InterfaceSet) {
-	newSet = NewInterfaceSet(true)
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	if set != other {
-		other.mu.RLock()
-		defer other.mu.RUnlock()
-	}
-	for k, v := range set.m {
-		newSet.m[k] = v
-	}
-	if set != other {
-		for k, v := range other.m {
-			newSet.m[k] = v
-		}
-	}
-	return
-}
-
-// 差集, 返回新的集合: 属于set且不属于other的元素为元素的集合.
-func (set *InterfaceSet) Diff(other *InterfaceSet) (newSet *InterfaceSet) {
-	newSet = NewInterfaceSet(true)
-	if set == other {
-		return newSet
-	}
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	other.mu.RLock()
-	defer other.mu.RUnlock()
-
-	for k, v := range set.m {
-		if _, ok := other.m[k]; !ok {
-			newSet.m[k] = v
-		}
-	}
-	return
-}
-
-// 交集, 返回新的集合: 属于set且属于other的元素为元素的集合.
-func (set *InterfaceSet) Inter(other *InterfaceSet) (newSet *InterfaceSet) {
-	newSet = NewInterfaceSet(true)
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	if set != other {
-		other.mu.RLock()
-		defer other.mu.RUnlock()
-	}
-	for k, v := range set.m {
-		if _, ok := other.m[k]; ok {
-			newSet.m[k] = v
-		}
-	}
-	return
-}
-
-// 补集, 返回新的集合: (前提: set应当为full的子集)属于全集full不属于集合set的元素组成的集合.
-func (set *InterfaceSet) Complement(full *InterfaceSet) (newSet *InterfaceSet) {
-	newSet = NewInterfaceSet(true)
-	set.mu.RLock()
-	defer set.mu.RUnlock()
-	full.mu.RLock()
-	defer full.mu.RUnlock()
-	for k, v := range full.m {
-		if _, ok := set.m[k]; !ok {
-			newSet.m[k] = v
-		}
-	}
-	return
-}

g/container/gset/gset_string_set.go

@@ -139,8 +139,8 @@ func (set *StringSet) Equal(other *StringSet) bool {
 	return true
 }
 
-// 判断other集合是否为当前集合的子集.
-func (set *StringSet) IsSubset(other *StringSet) bool {
+// 判断当前集合是否为other集合的子集.
+func (set *StringSet) IsSubsetOf(other *StringSet) bool {
 	if set == other {
 		return true
 	}
@@ -148,11 +148,8 @@ func (set *StringSet) IsSubset(other *StringSet) bool {
 	defer set.mu.RUnlock()
 	other.mu.RLock()
 	defer other.mu.RUnlock()
-	if len(set.m) != len(other.m) {
-		return false
-	}
-	for key := range other.m {
-		if _, ok := set.m[key]; !ok {
+	for key := range set.m {
+		if _, ok := other.m[key]; !ok {
 			return false
 		}
 	}
@@ -216,6 +213,7 @@ func (set *StringSet) Inter(other *StringSet) (newSet *StringSet) {
 }
 
 // 补集, 返回新的集合: (前提: set应当为full的子集)属于全集full不属于集合set的元素组成的集合.
+// 如果给定的full集合不是set的全集时，返回full与set的差集.
 func (set *StringSet) Complement(full *StringSet) (newSet *StringSet) {
 	newSet = NewStringSet(true)
 	set.mu.RLock()

g/container/gset/gset_z_bench_test.go

@@ -15,7 +15,7 @@ import (
 )
 
 var ints  = gset.NewIntSet()
-var itfs  = gset.NewInterfaceSet()
+var itfs  = gset.NewSet()
 var strs  = gset.NewStringSet()
 
 func Benchmark_IntSet_Add(b *testing.B) {
@@ -36,19 +36,19 @@ func Benchmark_IntSet_Remove(b *testing.B) {
     }
 }
 
-func Benchmark_InterfaceSet_Add(b *testing.B) {
+func Benchmark_Set_Add(b *testing.B) {
     for i := 0; i < b.N; i++ {
         itfs.Add(i)
     }
 }
 
-func Benchmark_InterfaceSet_Contains(b *testing.B) {
+func Benchmark_Set_Contains(b *testing.B) {
     for i := 0; i < b.N; i++ {
         itfs.Contains(i)
     }
 }
 
-func Benchmark_InterfaceSet_Remove(b *testing.B) {
+func Benchmark_Set_Remove(b *testing.B) {
     for i := 0; i < b.N; i++ {
         itfs.Remove(i)
     }

g/container/gset/gset_z_bench_unsafe_test.go

@@ -15,7 +15,7 @@ import (
 )
 
 var intsUnsafe  = gset.NewIntSet(true)
-var itfsUnsafe  = gset.NewInterfaceSet(true)
+var itfsUnsafe  = gset.NewSet(true)
 var strsUnsafe  = gset.NewStringSet(true)
 
 func Benchmark_Unsafe_IntSet_Add(b *testing.B) {
@@ -36,19 +36,19 @@ func Benchmark_Unsafe_IntSet_Remove(b *testing.B) {
     }
 }
 
-func Benchmark_Unsafe_InterfaceSet_Add(b *testing.B) {
+func Benchmark_Unsafe_Set_Add(b *testing.B) {
     for i := 0; i < b.N; i++ {
         itfsUnsafe.Add(i)
     }
 }
 
-func Benchmark_Unsafe_InterfaceSet_Contains(b *testing.B) {
+func Benchmark_Unsafe_Set_Contains(b *testing.B) {
     for i := 0; i < b.N; i++ {
         itfsUnsafe.Contains(i)
     }
 }
 
-func Benchmark_Unsafe_InterfaceSet_Remove(b *testing.B) {
+func Benchmark_Unsafe_Set_Remove(b *testing.B) {
     for i := 0; i < b.N; i++ {
         itfsUnsafe.Remove(i)
     }

g/container/gset/gset_z_unit_int_test.go

@@ -0,0 +1,160 @@
+// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://gitee.com/johng/gf.
+
+// go test *.go
+
+package gset_test
+
+import (
+    "gitee.com/johng/gf/g/container/garray"
+    "gitee.com/johng/gf/g/container/gset"
+    "gitee.com/johng/gf/g/test/gtest"
+    "testing"
+)
+
+func TestIntSet_Basic(t *testing.T) {
+    gtest.Case(t, func() {
+        s := gset.NewIntSet()
+        s.Add(1).Add(1).Add(2)
+        s.BatchAdd([]int{3,4})
+        gtest.Assert(s.Size(), 4)
+        gtest.AssertIN(1, s.Slice())
+        gtest.AssertIN(2, s.Slice())
+        gtest.AssertIN(3, s.Slice())
+        gtest.AssertIN(4, s.Slice())
+        gtest.AssertNI(0, s.Slice())
+        gtest.Assert(s.Contains(4), true)
+        gtest.Assert(s.Contains(5), false)
+        s.Remove(1)
+        gtest.Assert(s.Size(), 3)
+        s.Clear()
+        gtest.Assert(s.Size(), 0)
+    })
+}
+
+func TestIntSet_Iterator(t *testing.T) {
+    gtest.Case(t, func() {
+        s := gset.NewIntSet()
+        s.Add(1).Add(2).Add(3)
+        gtest.Assert(s.Size(), 3)
+
+        a1 := garray.New(0, 0)
+        a2 := garray.New(0, 0)
+        s.Iterator(func(v int) bool {
+            a1.Append(1)
+            return false
+        })
+        s.Iterator(func(v int) bool {
+            a2.Append(1)
+            return true
+        })
+        gtest.Assert(a1.Len(), 1)
+        gtest.Assert(a2.Len(), 3)
+    })
+}
+
+func TestIntSet_LockFunc(t *testing.T) {
+    gtest.Case(t, func() {
+        s := gset.NewIntSet()
+        s.Add(1).Add(2).Add(3)
+        gtest.Assert(s.Size(), 3)
+        s.LockFunc(func(m map[int]struct{}) {
+            delete(m, 1)
+        })
+        gtest.Assert(s.Size(), 2)
+        s.RLockFunc(func(m map[int]struct{}) {
+            gtest.Assert(m, map[int]struct{}{
+                3 : struct{}{},
+                2 : struct{}{},
+            })
+        })
+    })
+}
+
+func TestIntSet_Equal(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewIntSet()
+        s2 := gset.NewIntSet()
+        s3 := gset.NewIntSet()
+        s1.Add(1).Add(2).Add(3)
+        s2.Add(1).Add(2).Add(3)
+        s3.Add(1).Add(2).Add(3).Add(4)
+        gtest.Assert(s1.Equal(s2), true)
+        gtest.Assert(s1.Equal(s3), false)
+    })
+}
+
+func TestIntSet_IsSubsetOf(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewIntSet()
+        s2 := gset.NewIntSet()
+        s3 := gset.NewIntSet()
+        s1.Add(1).Add(2)
+        s2.Add(1).Add(2).Add(3)
+        s3.Add(1).Add(2).Add(3).Add(4)
+        gtest.Assert(s1.IsSubsetOf(s2), true)
+        gtest.Assert(s2.IsSubsetOf(s3), true)
+        gtest.Assert(s1.IsSubsetOf(s3), true)
+        gtest.Assert(s2.IsSubsetOf(s1), false)
+        gtest.Assert(s3.IsSubsetOf(s2), false)
+    })
+}
+
+func TestIntSet_Union(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewIntSet()
+        s2 := gset.NewIntSet()
+        s1.Add(1).Add(2)
+        s2.Add(3).Add(4)
+        s3 := s1.Union(s2)
+        gtest.Assert(s3.Contains(1), true)
+        gtest.Assert(s3.Contains(2), true)
+        gtest.Assert(s3.Contains(3), true)
+        gtest.Assert(s3.Contains(4), true)
+    })
+}
+
+func TestIntSet_Diff(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewIntSet()
+        s2 := gset.NewIntSet()
+        s1.Add(1).Add(2).Add(3)
+        s2.Add(3).Add(4).Add(5)
+        s3 := s1.Diff(s2)
+        gtest.Assert(s3.Contains(1), true)
+        gtest.Assert(s3.Contains(2), true)
+        gtest.Assert(s3.Contains(3), false)
+        gtest.Assert(s3.Contains(4), false)
+    })
+}
+
+func TestIntSet_Inter(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewIntSet()
+        s2 := gset.NewIntSet()
+        s1.Add(1).Add(2).Add(3)
+        s2.Add(3).Add(4).Add(5)
+        s3 := s1.Inter(s2)
+        gtest.Assert(s3.Contains(1), false)
+        gtest.Assert(s3.Contains(2), false)
+        gtest.Assert(s3.Contains(3), true)
+        gtest.Assert(s3.Contains(4), false)
+    })
+}
+
+func TestIntSet_Complement(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewIntSet()
+        s2 := gset.NewIntSet()
+        s1.Add(1).Add(2).Add(3)
+        s2.Add(3).Add(4).Add(5)
+        s3 := s1.Complement(s2)
+        gtest.Assert(s3.Contains(1), false)
+        gtest.Assert(s3.Contains(2), false)
+        gtest.Assert(s3.Contains(4), true)
+        gtest.Assert(s3.Contains(5), true)
+    })
+}

g/container/gset/gset_z_unit_string_test.go

@@ -0,0 +1,160 @@
+// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://gitee.com/johng/gf.
+
+// go test *.go
+
+package gset_test
+
+import (
+    "gitee.com/johng/gf/g/container/garray"
+    "gitee.com/johng/gf/g/container/gset"
+    "gitee.com/johng/gf/g/test/gtest"
+    "testing"
+)
+
+func TestStringSet_Basic(t *testing.T) {
+    gtest.Case(t, func() {
+        s := gset.NewStringSet()
+        s.Add("1").Add("1").Add("2")
+        s.BatchAdd([]string{"3","4"})
+        gtest.Assert(s.Size(), 4)
+        gtest.AssertIN("1", s.Slice())
+        gtest.AssertIN("2", s.Slice())
+        gtest.AssertIN("3", s.Slice())
+        gtest.AssertIN("4", s.Slice())
+        gtest.AssertNI("0", s.Slice())
+        gtest.Assert(s.Contains("4"), true)
+        gtest.Assert(s.Contains("5"), false)
+        s.Remove("1")
+        gtest.Assert(s.Size(), 3)
+        s.Clear()
+        gtest.Assert(s.Size(), 0)
+    })
+}
+
+func TestStringSet_Iterator(t *testing.T) {
+    gtest.Case(t, func() {
+        s := gset.NewStringSet()
+        s.Add("1").Add("2").Add("3")
+        gtest.Assert(s.Size(), 3)
+
+        a1 := garray.New(0, 0)
+        a2 := garray.New(0, 0)
+        s.Iterator(func(v string) bool {
+            a1.Append("1")
+            return false
+        })
+        s.Iterator(func(v string) bool {
+            a2.Append("1")
+            return true
+        })
+        gtest.Assert(a1.Len(), 1)
+        gtest.Assert(a2.Len(), 3)
+    })
+}
+
+func TestStringSet_LockFunc(t *testing.T) {
+    gtest.Case(t, func() {
+        s := gset.NewStringSet()
+        s.Add("1").Add("2").Add("3")
+        gtest.Assert(s.Size(), 3)
+        s.LockFunc(func(m map[string]struct{}) {
+            delete(m, "1")
+        })
+        gtest.Assert(s.Size(), 2)
+        s.RLockFunc(func(m map[string]struct{}) {
+            gtest.Assert(m, map[string]struct{}{
+                "3" : struct{}{},
+                "2" : struct{}{},
+            })
+        })
+    })
+}
+
+func TestStringSet_Equal(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewStringSet()
+        s2 := gset.NewStringSet()
+        s3 := gset.NewStringSet()
+        s1.Add("1").Add("2").Add("3")
+        s2.Add("1").Add("2").Add("3")
+        s3.Add("1").Add("2").Add("3").Add("4")
+        gtest.Assert(s1.Equal(s2), true)
+        gtest.Assert(s1.Equal(s3), false)
+    })
+}
+
+func TestStringSet_IsSubsetOf(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewStringSet()
+        s2 := gset.NewStringSet()
+        s3 := gset.NewStringSet()
+        s1.Add("1").Add("2")
+        s2.Add("1").Add("2").Add("3")
+        s3.Add("1").Add("2").Add("3").Add("4")
+        gtest.Assert(s1.IsSubsetOf(s2), true)
+        gtest.Assert(s2.IsSubsetOf(s3), true)
+        gtest.Assert(s1.IsSubsetOf(s3), true)
+        gtest.Assert(s2.IsSubsetOf(s1), false)
+        gtest.Assert(s3.IsSubsetOf(s2), false)
+    })
+}
+
+func TestStringSet_Union(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewStringSet()
+        s2 := gset.NewStringSet()
+        s1.Add("1").Add("2")
+        s2.Add("3").Add("4")
+        s3 := s1.Union(s2)
+        gtest.Assert(s3.Contains("1"), true)
+        gtest.Assert(s3.Contains("2"), true)
+        gtest.Assert(s3.Contains("3"), true)
+        gtest.Assert(s3.Contains("4"), true)
+    })
+}
+
+func TestStringSet_Diff(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewStringSet()
+        s2 := gset.NewStringSet()
+        s1.Add("1").Add("2").Add("3")
+        s2.Add("3").Add("4").Add("5")
+        s3 := s1.Diff(s2)
+        gtest.Assert(s3.Contains("1"), true)
+        gtest.Assert(s3.Contains("2"), true)
+        gtest.Assert(s3.Contains("3"), false)
+        gtest.Assert(s3.Contains("4"), false)
+    })
+}
+
+func TestStringSet_Inter(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewStringSet()
+        s2 := gset.NewStringSet()
+        s1.Add("1").Add("2").Add("3")
+        s2.Add("3").Add("4").Add("5")
+        s3 := s1.Inter(s2)
+        gtest.Assert(s3.Contains("1"), false)
+        gtest.Assert(s3.Contains("2"), false)
+        gtest.Assert(s3.Contains("3"), true)
+        gtest.Assert(s3.Contains("4"), false)
+    })
+}
+
+func TestStringSet_Complement(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewStringSet()
+        s2 := gset.NewStringSet()
+        s1.Add("1").Add("2").Add("3")
+        s2.Add("3").Add("4").Add("5")
+        s3 := s1.Complement(s2)
+        gtest.Assert(s3.Contains("1"), false)
+        gtest.Assert(s3.Contains("2"), false)
+        gtest.Assert(s3.Contains("4"), true)
+        gtest.Assert(s3.Contains("5"), true)
+    })
+}

g/container/gset/gset_z_unit_test.go

@@ -9,17 +9,152 @@
 package gset_test
 
 import (
+    "gitee.com/johng/gf/g/container/garray"
     "gitee.com/johng/gf/g/container/gset"
     "gitee.com/johng/gf/g/test/gtest"
     "testing"
 )
 
-func TestIntSet_Basic(t *testing.T) {
+func TestSet_Basic(t *testing.T) {
     gtest.Case(t, func() {
-        s := gset.NewIntSet()
+        s := gset.NewSet()
         s.Add(1).Add(1).Add(2)
-        s.BatchAdd([]int{3,4})
-        gtest.Assert(s.Size(), 3)
+        s.BatchAdd([]interface{}{3,4})
+        gtest.Assert(s.Size(), 4)
+        gtest.AssertIN(1, s.Slice())
+        gtest.AssertIN(2, s.Slice())
+        gtest.AssertIN(3, s.Slice())
+        gtest.AssertIN(4, s.Slice())
+        gtest.AssertNI(0, s.Slice())
         gtest.Assert(s.Contains(4), true)
+        gtest.Assert(s.Contains(5), false)
+        s.Remove(1)
+        gtest.Assert(s.Size(), 3)
+        s.Clear()
+        gtest.Assert(s.Size(), 0)
     })
 }
+
+func TestSet_Iterator(t *testing.T) {
+    gtest.Case(t, func() {
+        s := gset.NewSet()
+        s.Add(1).Add(2).Add(3)
+        gtest.Assert(s.Size(), 3)
+
+        a1 := garray.New(0, 0)
+        a2 := garray.New(0, 0)
+        s.Iterator(func(v interface{}) bool {
+            a1.Append(1)
+            return false
+        })
+        s.Iterator(func(v interface{}) bool {
+            a2.Append(1)
+            return true
+        })
+        gtest.Assert(a1.Len(), 1)
+        gtest.Assert(a2.Len(), 3)
+    })
+}
+
+func TestSet_LockFunc(t *testing.T) {
+    gtest.Case(t, func() {
+        s := gset.NewSet()
+        s.Add(1).Add(2).Add(3)
+        gtest.Assert(s.Size(), 3)
+        s.LockFunc(func(m map[interface{}]struct{}) {
+            delete(m, 1)
+        })
+        gtest.Assert(s.Size(), 2)
+        s.RLockFunc(func(m map[interface{}]struct{}) {
+            gtest.Assert(m, map[interface{}]struct{}{
+                3 : struct{}{},
+                2 : struct{}{},
+            })
+        })
+    })
+}
+
+func TestSet_Equal(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewSet()
+        s2 := gset.NewSet()
+        s3 := gset.NewSet()
+        s1.Add(1).Add(2).Add(3)
+        s2.Add(1).Add(2).Add(3)
+        s3.Add(1).Add(2).Add(3).Add(4)
+        gtest.Assert(s1.Equal(s2), true)
+        gtest.Assert(s1.Equal(s3), false)
+    })
+}
+
+func TestSet_IsSubsetOf(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewSet()
+        s2 := gset.NewSet()
+        s3 := gset.NewSet()
+        s1.Add(1).Add(2)
+        s2.Add(1).Add(2).Add(3)
+        s3.Add(1).Add(2).Add(3).Add(4)
+        gtest.Assert(s1.IsSubsetOf(s2), true)
+        gtest.Assert(s2.IsSubsetOf(s3), true)
+        gtest.Assert(s1.IsSubsetOf(s3), true)
+        gtest.Assert(s2.IsSubsetOf(s1), false)
+        gtest.Assert(s3.IsSubsetOf(s2), false)
+    })
+}
+
+func TestSet_Union(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewSet()
+        s2 := gset.NewSet()
+        s1.Add(1).Add(2)
+        s2.Add(3).Add(4)
+        s3 := s1.Union(s2)
+        gtest.Assert(s3.Contains(1), true)
+        gtest.Assert(s3.Contains(2), true)
+        gtest.Assert(s3.Contains(3), true)
+        gtest.Assert(s3.Contains(4), true)
+    })
+}
+
+func TestSet_Diff(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewSet()
+        s2 := gset.NewSet()
+        s1.Add(1).Add(2).Add(3)
+        s2.Add(3).Add(4).Add(5)
+        s3 := s1.Diff(s2)
+        gtest.Assert(s3.Contains(1), true)
+        gtest.Assert(s3.Contains(2), true)
+        gtest.Assert(s3.Contains(3), false)
+        gtest.Assert(s3.Contains(4), false)
+    })
+}
+
+func TestSet_Inter(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewSet()
+        s2 := gset.NewSet()
+        s1.Add(1).Add(2).Add(3)
+        s2.Add(3).Add(4).Add(5)
+        s3 := s1.Inter(s2)
+        gtest.Assert(s3.Contains(1), false)
+        gtest.Assert(s3.Contains(2), false)
+        gtest.Assert(s3.Contains(3), true)
+        gtest.Assert(s3.Contains(4), false)
+    })
+}
+
+func TestSet_Complement(t *testing.T) {
+    gtest.Case(t, func() {
+        s1 := gset.NewSet()
+        s2 := gset.NewSet()
+        s1.Add(1).Add(2).Add(3)
+        s2.Add(3).Add(4).Add(5)
+        s3 := s1.Complement(s2)
+        gtest.Assert(s3.Contains(1), false)
+        gtest.Assert(s3.Contains(2), false)
+        gtest.Assert(s3.Contains(4), true)
+        gtest.Assert(s3.Contains(5), true)
+    })
+}

g/test/gtest/gtest.go

@@ -33,14 +33,18 @@ func Case(t *testing.T, f func()) {
 
 // 断言判断, 相等
 func Assert(value, expect interface{}) {
-    rvValue := reflect.ValueOf(value)
+    rvValue  := reflect.ValueOf(value)
+    rvExpect := reflect.ValueOf(expect)
     if rvValue.Kind() == reflect.Ptr {
         if rvValue.IsNil() {
             value = nil
         }
     }
-    if err := compareMap(value, expect); err != nil {
-        panic(err)
+    if rvExpect.Kind() == reflect.Map {
+        if err := compareMap(value, expect); err != nil {
+            panic(err)
+        }
+        return
     }
     if fmt.Sprintf("%v", value) != fmt.Sprintf("%v", expect) {
         panic(fmt.Sprintf(`[ASSERT] EXPECT %v == %v`, value, expect))
@@ -62,26 +66,11 @@ func AssertEQ(value, expect interface{}) {
             value = nil
         }
     }
-    // map类型比较
     if rvExpect.Kind() == reflect.Map {
-        if rvValue.Kind() == reflect.Map {
-            if rvExpect.Len() == rvValue.Len() {
-                ksExpect := rvExpect.MapKeys()
-                for _, key := range ksExpect {
-                    if rvValue.MapIndex(key).Interface() != rvExpect.MapIndex(key).Interface() {
-                        panic(fmt.Sprintf(`[ASSERT] EXPECT VALUE map["%v"]:%v == %v`,
-                            key,
-                            rvValue.MapIndex(key).Interface(),
-                            rvExpect.MapIndex(key).Interface(),
-                        ))
-                    }
-                }
-            } else {
-                panic(fmt.Sprintf(`[ASSERT] EXPECT MAP LENGTH %d == %d`, rvExpect.Len(), rvValue.Len()))
-            }
-        } else {
-            panic(fmt.Sprint(`[ASSERT] EXPECT VALUE TO BE A MAP`))
+        if err := compareMap(value, expect); err != nil {
+            panic(err)
         }
+        return
     }
     if fmt.Sprintf("%v", value) != fmt.Sprintf("%v", expect) {
         panic(fmt.Sprintf(`[ASSERT] EXPECT %v == %v`, value, expect))
@@ -90,12 +79,19 @@ func AssertEQ(value, expect interface{}) {
 
 // 断言判断, 不相等
 func AssertNE(value, expect interface{}) {
-    rvValue := reflect.ValueOf(value)
+    rvValue  := reflect.ValueOf(value)
+    rvExpect := reflect.ValueOf(expect)
     if rvValue.Kind() == reflect.Ptr {
         if rvValue.IsNil() {
             value = nil
         }
     }
+    if rvExpect.Kind() == reflect.Map {
+        if err := compareMap(value, expect); err == nil {
+            panic(fmt.Sprintf(`[ASSERT] EXPECT %v != %v`, value, expect))
+        }
+        return
+    }
     if fmt.Sprintf("%v", value) == fmt.Sprintf("%v", expect) {
         panic(fmt.Sprintf(`[ASSERT] EXPECT %v != %v`, value, expect))
     }