bingyi/gf
1
0
Fork 0
mirror of https://gitee.com/johng/gf synced 2026-06-06 16:21:40 +08:00
Code Issues Packages Projects Releases Wiki Activity

add UnmarshalJSON func tion for gset

Browse Source
This commit is contained in:
John
2019-09-30 14:37:05 +08:00
parent ee1414c010
commit 7fe9c641f4
6 changed files with 267 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
container/gset/gset.go
View File

@ -16,8 +16,8 @@ import (
)
type Set struct {
mu *rwmutex.RWMutex
m map[interface{}]struct{}
mu *rwmutex.RWMutex
data map[interface{}]struct{}
}
// New create and returns a new set, which contains un-repeated items.
@ -30,8 +30,8 @@ func New(safe ...bool) *Set {
// See New.
func NewSet(safe ...bool) *Set {
return &Set{
m: make(map[interface{}]struct{}),
mu: rwmutex.New(safe...),
data: make(map[interface{}]struct{}),
mu: rwmutex.New(safe...),
}
}
@ -43,8 +43,8 @@ func NewFrom(items interface{}, safe ...bool) *Set {
m[v] = struct{}{}
}
return &Set{
m: m,
mu: rwmutex.New(safe...),
data: m,
mu: rwmutex.New(safe...),
}
}
@ -53,7 +53,7 @@ func NewFrom(items interface{}, safe ...bool) *Set {
func (set *Set) Iterator(f func(v interface{}) bool) *Set {
set.mu.RLock()
defer set.mu.RUnlock()
for k, _ := range set.m {
for k, _ := range set.data {
if !f(k) {
break
}
@ -65,7 +65,7 @@ func (set *Set) Iterator(f func(v interface{}) bool) *Set {
func (set *Set) Add(item ...interface{}) *Set {
set.mu.Lock()
for _, v := range item {
set.m[v] = struct{}{}
set.data[v] = struct{}{}
}
set.mu.Unlock()
return set
@ -74,7 +74,7 @@ func (set *Set) Add(item ...interface{}) *Set {
// Contains checks whether the set contains <item>.
func (set *Set) Contains(item interface{}) bool {
set.mu.RLock()
_, exists := set.m[item]
_, exists := set.data[item]
set.mu.RUnlock()
return exists
}
@ -82,7 +82,7 @@ func (set *Set) Contains(item interface{}) bool {
// Remove deletes <item> from set.
func (set *Set) Remove(item interface{}) *Set {
set.mu.Lock()
delete(set.m, item)
delete(set.data, item)
set.mu.Unlock()
return set
}
@ -90,7 +90,7 @@ func (set *Set) Remove(item interface{}) *Set {
// Size returns the size of the set.
func (set *Set) Size() int {
set.mu.RLock()
l := len(set.m)
l := len(set.data)
set.mu.RUnlock()
return l
}
@ -98,7 +98,7 @@ func (set *Set) Size() int {
// Clear deletes all items of the set.
func (set *Set) Clear() *Set {
set.mu.Lock()
set.m = make(map[interface{}]struct{})
set.data = make(map[interface{}]struct{})
set.mu.Unlock()
return set
}
@ -107,8 +107,8 @@ func (set *Set) Clear() *Set {
func (set *Set) Slice() []interface{} {
set.mu.RLock()
i := 0
ret := make([]interface{}, len(set.m))
for item := range set.m {
ret := make([]interface{}, len(set.data))
for item := range set.data {
ret[i] = item
i++
}
@ -130,14 +130,14 @@ func (set *Set) String() string {
func (set *Set) LockFunc(f func(m map[interface{}]struct{})) {
set.mu.Lock()
defer set.mu.Unlock()
f(set.m)
f(set.data)
}
// RLockFunc locks reading with callback function <f>.
func (set *Set) RLockFunc(f func(m map[interface{}]struct{})) {
set.mu.RLock()
defer set.mu.RUnlock()
f(set.m)
f(set.data)
}
// Equal checks whether the two sets equal.
@ -149,11 +149,11 @@ func (set *Set) Equal(other *Set) bool {
defer set.mu.RUnlock()
other.mu.RLock()
defer other.mu.RUnlock()
if len(set.m) != len(other.m) {
if len(set.data) != len(other.data) {
return false
}
for key := range set.m {
if _, ok := other.m[key]; !ok {
for key := range set.data {
if _, ok := other.data[key]; !ok {
return false
}
}
@ -169,8 +169,8 @@ func (set *Set) IsSubsetOf(other *Set) bool {
defer set.mu.RUnlock()
other.mu.RLock()
defer other.mu.RUnlock()
for key := range set.m {
if _, ok := other.m[key]; !ok {
for key := range set.data {
if _, ok := other.data[key]; !ok {
return false
}
}
@ -187,12 +187,12 @@ func (set *Set) Union(others ...*Set) (newSet *Set) {
if set != other {
other.mu.RLock()
}
for k, v := range set.m {
newSet.m[k] = v
for k, v := range set.data {
newSet.data[k] = v
}
if set != other {
for k, v := range other.m {
newSet.m[k] = v
for k, v := range other.data {
newSet.data[k] = v
}
}
if set != other {
@ -214,9 +214,9 @@ func (set *Set) Diff(others ...*Set) (newSet *Set) {
continue
}
other.mu.RLock()
for k, v := range set.m {
if _, ok := other.m[k]; !ok {
newSet.m[k] = v
for k, v := range set.data {
if _, ok := other.data[k]; !ok {
newSet.data[k] = v
}
}
other.mu.RUnlock()
@ -234,9 +234,9 @@ func (set *Set) Intersect(others ...*Set) (newSet *Set) {
if set != other {
other.mu.RLock()
}
for k, v := range set.m {
if _, ok := other.m[k]; ok {
newSet.m[k] = v
for k, v := range set.data {
if _, ok := other.data[k]; ok {
newSet.data[k] = v
}
}
if set != other {
@ -259,9 +259,9 @@ func (set *Set) Complement(full *Set) (newSet *Set) {
full.mu.RLock()
defer full.mu.RUnlock()
}
for k, v := range full.m {
if _, ok := set.m[k]; !ok {
newSet.m[k] = v
for k, v := range full.data {
if _, ok := set.data[k]; !ok {
newSet.data[k] = v
}
}
return
@ -275,8 +275,8 @@ func (set *Set) Merge(others ...*Set) *Set {
if set != other {
other.mu.RLock()
}
for k, v := range other.m {
set.m[k] = v
for k, v := range other.data {
set.data[k] = v
}
if set != other {
other.mu.RUnlock()
@ -291,7 +291,7 @@ func (set *Set) Merge(others ...*Set) *Set {
func (set *Set) Sum() (sum int) {
set.mu.RLock()
defer set.mu.RUnlock()
for k, _ := range set.m {
for k, _ := range set.data {
sum += gconv.Int(k)
}
return
@ -301,7 +301,7 @@ func (set *Set) Sum() (sum int) {
func (set *Set) Pop() interface{} {
set.mu.RLock()
defer set.mu.RUnlock()
for k, _ := range set.m {
for k, _ := range set.data {
return k
}
return nil
@ -311,12 +311,12 @@ func (set *Set) Pop() interface{} {
func (set *Set) Pops(size int) []interface{} {
set.mu.RLock()
defer set.mu.RUnlock()
if size > len(set.m) {
size = len(set.m)
if size > len(set.data) {
size = len(set.data)
}
index := 0
array := make([]interface{}, size)
for k, _ := range set.m {
for k, _ := range set.data {
array[index] = k
index++
if index == size {
@ -330,3 +330,21 @@ func (set *Set) Pops(size int) []interface{} {
func (set *Set) MarshalJSON() ([]byte, error) {
return json.Marshal(set.Slice())
}
// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
func (set *Set) UnmarshalJSON(b []byte) error {
if set.mu == nil {
set.mu = rwmutex.New()
set.data = make(map[interface{}]struct{})
}
set.mu.Lock()
defer set.mu.Unlock()
var array []interface{}
if err := json.Unmarshal(b, &array); err != nil {
return err
}
for _, v := range array {
set.data[v] = struct{}{}
}
return nil
}

100
container/gset/gset_int_set.go
View File

@ -16,8 +16,8 @@ import (
)
type IntSet struct {
mu *rwmutex.RWMutex
m map[int]struct{}
mu *rwmutex.RWMutex
data map[int]struct{}
}
// New create and returns a new set, which contains un-repeated items.
@ -25,8 +25,8 @@ type IntSet struct {
// which is false in default.
func NewIntSet(safe ...bool) *IntSet {
return &IntSet{
m: make(map[int]struct{}),
mu: rwmutex.New(safe...),
mu: rwmutex.New(safe...),
data: make(map[int]struct{}),
}
}
@ -37,8 +37,8 @@ func NewIntSetFrom(items []int, safe ...bool) *IntSet {
m[v] = struct{}{}
}
return &IntSet{
m: m,
mu: rwmutex.New(safe...),
mu: rwmutex.New(safe...),
data: m,
}
}
@ -47,7 +47,7 @@ func NewIntSetFrom(items []int, safe ...bool) *IntSet {
func (set *IntSet) Iterator(f func(v int) bool) *IntSet {
set.mu.RLock()
defer set.mu.RUnlock()
for k, _ := range set.m {
for k, _ := range set.data {
if !f(k) {
break
}
@ -59,7 +59,7 @@ func (set *IntSet) Iterator(f func(v int) bool) *IntSet {
func (set *IntSet) Add(item ...int) *IntSet {
set.mu.Lock()
for _, v := range item {
set.m[v] = struct{}{}
set.data[v] = struct{}{}
}
set.mu.Unlock()
return set
@ -68,7 +68,7 @@ func (set *IntSet) Add(item ...int) *IntSet {
// Contains checks whether the set contains <item>.
func (set *IntSet) Contains(item int) bool {
set.mu.RLock()
_, exists := set.m[item]
_, exists := set.data[item]
set.mu.RUnlock()
return exists
}
@ -76,7 +76,7 @@ func (set *IntSet) Contains(item int) bool {
// Remove deletes <item> from set.
func (set *IntSet) Remove(item int) *IntSet {
set.mu.Lock()
delete(set.m, item)
delete(set.data, item)
set.mu.Unlock()
return set
}
@ -84,7 +84,7 @@ func (set *IntSet) Remove(item int) *IntSet {
// Size returns the size of the set.
func (set *IntSet) Size() int {
set.mu.RLock()
l := len(set.m)
l := len(set.data)
set.mu.RUnlock()
return l
}
@ -92,7 +92,7 @@ func (set *IntSet) Size() int {
// Clear deletes all items of the set.
func (set *IntSet) Clear() *IntSet {
set.mu.Lock()
set.m = make(map[int]struct{})
set.data = make(map[int]struct{})
set.mu.Unlock()
return set
}
@ -100,9 +100,9 @@ func (set *IntSet) Clear() *IntSet {
// Slice returns the a of items of the set as slice.
func (set *IntSet) Slice() []int {
set.mu.RLock()
ret := make([]int, len(set.m))
ret := make([]int, len(set.data))
i := 0
for k, _ := range set.m {
for k, _ := range set.data {
ret[i] = k
i++
}
@ -124,14 +124,14 @@ func (set *IntSet) String() string {
func (set *IntSet) LockFunc(f func(m map[int]struct{})) {
set.mu.Lock()
defer set.mu.Unlock()
f(set.m)
f(set.data)
}
// RLockFunc locks reading with callback function <f>.
func (set *IntSet) RLockFunc(f func(m map[int]struct{})) {
set.mu.RLock()
defer set.mu.RUnlock()
f(set.m)
f(set.data)
}
// Equal checks whether the two sets equal.
@ -143,11 +143,11 @@ func (set *IntSet) Equal(other *IntSet) bool {
defer set.mu.RUnlock()
other.mu.RLock()
defer other.mu.RUnlock()
if len(set.m) != len(other.m) {
if len(set.data) != len(other.data) {
return false
}
for key := range set.m {
if _, ok := other.m[key]; !ok {
for key := range set.data {
if _, ok := other.data[key]; !ok {
return false
}
}
@ -163,8 +163,8 @@ func (set *IntSet) IsSubsetOf(other *IntSet) bool {
defer set.mu.RUnlock()
other.mu.RLock()
defer other.mu.RUnlock()
for key := range set.m {
if _, ok := other.m[key]; !ok {
for key := range set.data {
if _, ok := other.data[key]; !ok {
return false
}
}
@ -181,12 +181,12 @@ func (set *IntSet) Union(others ...*IntSet) (newSet *IntSet) {
if set != other {
other.mu.RLock()
}
for k, v := range set.m {
newSet.m[k] = v
for k, v := range set.data {
newSet.data[k] = v
}
if set != other {
for k, v := range other.m {
newSet.m[k] = v
for k, v := range other.data {
newSet.data[k] = v
}
}
if set != other {
@ -208,9 +208,9 @@ func (set *IntSet) Diff(others ...*IntSet) (newSet *IntSet) {
continue
}
other.mu.RLock()
for k, v := range set.m {
if _, ok := other.m[k]; !ok {
newSet.m[k] = v
for k, v := range set.data {
if _, ok := other.data[k]; !ok {
newSet.data[k] = v
}
}
other.mu.RUnlock()
@ -228,9 +228,9 @@ func (set *IntSet) Intersect(others ...*IntSet) (newSet *IntSet) {
if set != other {
other.mu.RLock()
}
for k, v := range set.m {
if _, ok := other.m[k]; ok {
newSet.m[k] = v
for k, v := range set.data {
if _, ok := other.data[k]; ok {
newSet.data[k] = v
}
}
if set != other {
@ -253,9 +253,9 @@ func (set *IntSet) Complement(full *IntSet) (newSet *IntSet) {
full.mu.RLock()
defer full.mu.RUnlock()
}
for k, v := range full.m {
if _, ok := set.m[k]; !ok {
newSet.m[k] = v
for k, v := range full.data {
if _, ok := set.data[k]; !ok {
newSet.data[k] = v
}
}
return
@ -269,8 +269,8 @@ func (set *IntSet) Merge(others ...*IntSet) *IntSet {
if set != other {
other.mu.RLock()
}
for k, v := range other.m {
set.m[k] = v
for k, v := range other.data {
set.data[k] = v
}
if set != other {
other.mu.RUnlock()
@ -285,7 +285,7 @@ func (set *IntSet) Merge(others ...*IntSet) *IntSet {
func (set *IntSet) Sum() (sum int) {
set.mu.RLock()
defer set.mu.RUnlock()
for k, _ := range set.m {
for k, _ := range set.data {
sum += k
}
return
@ -295,7 +295,7 @@ func (set *IntSet) Sum() (sum int) {
func (set *IntSet) Pop() int {
set.mu.RLock()
defer set.mu.RUnlock()
for k, _ := range set.m {
for k, _ := range set.data {
return k
}
return 0
@ -305,12 +305,12 @@ func (set *IntSet) Pop() int {
func (set *IntSet) Pops(size int) []int {
set.mu.RLock()
defer set.mu.RUnlock()
if size > len(set.m) {
size = len(set.m)
if size > len(set.data) {
size = len(set.data)
}
index := 0
array := make([]int, size)
for k, _ := range set.m {
for k, _ := range set.data {
array[index] = k
index++
if index == size {
@ -324,3 +324,21 @@ func (set *IntSet) Pops(size int) []int {
func (set *IntSet) MarshalJSON() ([]byte, error) {
return json.Marshal(set.Slice())
}
// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
func (set *IntSet) UnmarshalJSON(b []byte) error {
if set.mu == nil {
set.mu = rwmutex.New()
set.data = make(map[int]struct{})
}
set.mu.Lock()
defer set.mu.Unlock()
var array []int
if err := json.Unmarshal(b, &array); err != nil {
return err
}
for _, v := range array {
set.data[v] = struct{}{}
}
return nil
}

100
container/gset/gset_str_set.go
View File

@ -16,8 +16,8 @@ import (
)
type StrSet struct {
mu *rwmutex.RWMutex
m map[string]struct{}
mu *rwmutex.RWMutex
data map[string]struct{}
}
// New create and returns a new set, which contains un-repeated items.
@ -25,8 +25,8 @@ type StrSet struct {
// which is false in default.
func NewStrSet(safe ...bool) *StrSet {
return &StrSet{
m: make(map[string]struct{}),
mu: rwmutex.New(safe...),
mu: rwmutex.New(safe...),
data: make(map[string]struct{}),
}
}
@ -37,8 +37,8 @@ func NewStrSetFrom(items []string, safe ...bool) *StrSet {
m[v] = struct{}{}
}
return &StrSet{
m: m,
mu: rwmutex.New(safe...),
mu: rwmutex.New(safe...),
data: m,
}
}
@ -47,7 +47,7 @@ func NewStrSetFrom(items []string, safe ...bool) *StrSet {
func (set *StrSet) Iterator(f func(v string) bool) *StrSet {
set.mu.RLock()
defer set.mu.RUnlock()
for k, _ := range set.m {
for k, _ := range set.data {
if !f(k) {
break
}
@ -59,7 +59,7 @@ func (set *StrSet) Iterator(f func(v string) bool) *StrSet {
func (set *StrSet) Add(item ...string) *StrSet {
set.mu.Lock()
for _, v := range item {
set.m[v] = struct{}{}
set.data[v] = struct{}{}
}
set.mu.Unlock()
return set
@ -68,7 +68,7 @@ func (set *StrSet) Add(item ...string) *StrSet {
// Contains checks whether the set contains <item>.
func (set *StrSet) Contains(item string) bool {
set.mu.RLock()
_, exists := set.m[item]
_, exists := set.data[item]
set.mu.RUnlock()
return exists
}
@ -76,7 +76,7 @@ func (set *StrSet) Contains(item string) bool {
// Remove deletes <item> from set.
func (set *StrSet) Remove(item string) *StrSet {
set.mu.Lock()
delete(set.m, item)
delete(set.data, item)
set.mu.Unlock()
return set
}
@ -84,7 +84,7 @@ func (set *StrSet) Remove(item string) *StrSet {
// Size returns the size of the set.
func (set *StrSet) Size() int {
set.mu.RLock()
l := len(set.m)
l := len(set.data)
set.mu.RUnlock()
return l
}
@ -92,7 +92,7 @@ func (set *StrSet) Size() int {
// Clear deletes all items of the set.
func (set *StrSet) Clear() *StrSet {
set.mu.Lock()
set.m = make(map[string]struct{})
set.data = make(map[string]struct{})
set.mu.Unlock()
return set
}
@ -100,9 +100,9 @@ func (set *StrSet) Clear() *StrSet {
// Slice returns the a of items of the set as slice.
func (set *StrSet) Slice() []string {
set.mu.RLock()
ret := make([]string, len(set.m))
ret := make([]string, len(set.data))
i := 0
for item := range set.m {
for item := range set.data {
ret[i] = item
i++
}
@ -125,14 +125,14 @@ func (set *StrSet) String() string {
func (set *StrSet) LockFunc(f func(m map[string]struct{})) {
set.mu.Lock()
defer set.mu.Unlock()
f(set.m)
f(set.data)
}
// RLockFunc locks reading with callback function <f>.
func (set *StrSet) RLockFunc(f func(m map[string]struct{})) {
set.mu.RLock()
defer set.mu.RUnlock()
f(set.m)
f(set.data)
}
// Equal checks whether the two sets equal.
@ -144,11 +144,11 @@ func (set *StrSet) Equal(other *StrSet) bool {
defer set.mu.RUnlock()
other.mu.RLock()
defer other.mu.RUnlock()
if len(set.m) != len(other.m) {
if len(set.data) != len(other.data) {
return false
}
for key := range set.m {
if _, ok := other.m[key]; !ok {
for key := range set.data {
if _, ok := other.data[key]; !ok {
return false
}
}
@ -164,8 +164,8 @@ func (set *StrSet) IsSubsetOf(other *StrSet) bool {
defer set.mu.RUnlock()
other.mu.RLock()
defer other.mu.RUnlock()
for key := range set.m {
if _, ok := other.m[key]; !ok {
for key := range set.data {
if _, ok := other.data[key]; !ok {
return false
}
}
@ -182,12 +182,12 @@ func (set *StrSet) Union(others ...*StrSet) (newSet *StrSet) {
if set != other {
other.mu.RLock()
}
for k, v := range set.m {
newSet.m[k] = v
for k, v := range set.data {
newSet.data[k] = v
}
if set != other {
for k, v := range other.m {
newSet.m[k] = v
for k, v := range other.data {
newSet.data[k] = v
}
}
if set != other {
@ -209,9 +209,9 @@ func (set *StrSet) Diff(others ...*StrSet) (newSet *StrSet) {
continue
}
other.mu.RLock()
for k, v := range set.m {
if _, ok := other.m[k]; !ok {
newSet.m[k] = v
for k, v := range set.data {
if _, ok := other.data[k]; !ok {
newSet.data[k] = v
}
}
other.mu.RUnlock()
@ -229,9 +229,9 @@ func (set *StrSet) Intersect(others ...*StrSet) (newSet *StrSet) {
if set != other {
other.mu.RLock()
}
for k, v := range set.m {
if _, ok := other.m[k]; ok {
newSet.m[k] = v
for k, v := range set.data {
if _, ok := other.data[k]; ok {
newSet.data[k] = v
}
}
if set != other {
@ -254,9 +254,9 @@ func (set *StrSet) Complement(full *StrSet) (newSet *StrSet) {
full.mu.RLock()
defer full.mu.RUnlock()
}
for k, v := range full.m {
if _, ok := set.m[k]; !ok {
newSet.m[k] = v
for k, v := range full.data {
if _, ok := set.data[k]; !ok {
newSet.data[k] = v
}
}
return
@ -270,8 +270,8 @@ func (set *StrSet) Merge(others ...*StrSet) *StrSet {
if set != other {
other.mu.RLock()
}
for k, v := range other.m {
set.m[k] = v
for k, v := range other.data {
set.data[k] = v
}
if set != other {
other.mu.RUnlock()
@ -286,7 +286,7 @@ func (set *StrSet) Merge(others ...*StrSet) *StrSet {
func (set *StrSet) Sum() (sum int) {
set.mu.RLock()
defer set.mu.RUnlock()
for k, _ := range set.m {
for k, _ := range set.data {
sum += gconv.Int(k)
}
return
@ -296,7 +296,7 @@ func (set *StrSet) Sum() (sum int) {
func (set *StrSet) Pop() string {
set.mu.RLock()
defer set.mu.RUnlock()
for k, _ := range set.m {
for k, _ := range set.data {
return k
}
return ""
@ -306,12 +306,12 @@ func (set *StrSet) Pop() string {
func (set *StrSet) Pops(size int) []string {
set.mu.RLock()
defer set.mu.RUnlock()
if size > len(set.m) {
size = len(set.m)
if size > len(set.data) {
size = len(set.data)
}
index := 0
array := make([]string, size)
for k, _ := range set.m {
for k, _ := range set.data {
array[index] = k
index++
if index == size {
@ -325,3 +325,21 @@ func (set *StrSet) Pops(size int) []string {
func (set *StrSet) MarshalJSON() ([]byte, error) {
return json.Marshal(set.Slice())
}
// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
func (set *StrSet) UnmarshalJSON(b []byte) error {
if set.mu == nil {
set.mu = rwmutex.New()
set.data = make(map[string]struct{})
}
set.mu.Lock()
defer set.mu.Unlock()
var array []string
if err := json.Unmarshal(b, &array); err != nil {
return err
}
for _, v := range array {
set.data[v] = struct{}{}
}
return nil
}

30
container/gset/gset_z_unit_int_test.go
View File

@ -9,6 +9,7 @@
package gset_test
import (
"encoding/json"
"strings"
"testing"
@ -215,3 +216,32 @@ func TestIntSet_Pop(t *testing.T) {
gtest.Assert(s1.Size(), 3)
})
}
func TestIntSet_Json(t *testing.T) {
gtest.Case(t, func() {
s1 := []int{1, 3, 2, 4}
a1 := gset.NewIntSetFrom(s1)
b1, err1 := json.Marshal(a1)
b2, err2 := json.Marshal(s1)
gtest.Assert(len(b1), len(b2))
gtest.Assert(err1, err2)
a2 := gset.NewIntSet()
err2 = json.Unmarshal(b2, &a2)
gtest.Assert(err2, nil)
gtest.Assert(a2.Contains(1), true)
gtest.Assert(a2.Contains(2), true)
gtest.Assert(a2.Contains(3), true)
gtest.Assert(a2.Contains(4), true)
gtest.Assert(a2.Contains(5), false)
var a3 gset.IntSet
err := json.Unmarshal(b2, &a3)
gtest.Assert(err, nil)
gtest.Assert(a2.Contains(1), true)
gtest.Assert(a2.Contains(2), true)
gtest.Assert(a2.Contains(3), true)
gtest.Assert(a2.Contains(4), true)
gtest.Assert(a2.Contains(5), false)
})
}

30
container/gset/gset_z_unit_str_test.go
View File

@ -9,6 +9,7 @@
package gset_test
import (
"encoding/json"
"strings"
"testing"
@ -255,3 +256,32 @@ func TestStrSet_Pops(t *testing.T) {
gtest.AssertIN(str2, []string{"a", "b", "c"})
})
}
func TestStrSet_Json(t *testing.T) {
gtest.Case(t, func() {
s1 := []string{"a", "b", "d", "c"}
a1 := gset.NewStrSetFrom(s1)
b1, err1 := json.Marshal(a1)
b2, err2 := json.Marshal(s1)
gtest.Assert(len(b1), len(b2))
gtest.Assert(err1, err2)
a2 := gset.NewStrSet()
err2 = json.Unmarshal(b2, &a2)
gtest.Assert(err2, nil)
gtest.Assert(a2.Contains("a"), true)
gtest.Assert(a2.Contains("b"), true)
gtest.Assert(a2.Contains("c"), true)
gtest.Assert(a2.Contains("d"), true)
gtest.Assert(a2.Contains("e"), false)
var a3 gset.StrSet
err := json.Unmarshal(b2, &a3)
gtest.Assert(err, nil)
gtest.Assert(a3.Contains("a"), true)
gtest.Assert(a3.Contains("b"), true)
gtest.Assert(a3.Contains("c"), true)
gtest.Assert(a3.Contains("d"), true)
gtest.Assert(a3.Contains("e"), false)
})
}

30
container/gset/gset_z_unit_test.go
View File

@ -9,6 +9,7 @@
package gset_test
import (
"encoding/json"
"strings"
"github.com/gogf/gf/container/garray"
@ -267,3 +268,32 @@ func TestSet_Pops(t *testing.T) {
gtest.Assert(len(s1.Pops(2)), 2)
})
}
func TestSet_Json(t *testing.T) {
gtest.Case(t, func() {
s1 := []interface{}{"a", "b", "d", "c"}
a1 := gset.NewFrom(s1)
b1, err1 := json.Marshal(a1)
b2, err2 := json.Marshal(s1)
gtest.Assert(len(b1), len(b2))
gtest.Assert(err1, err2)
a2 := gset.New()
err2 = json.Unmarshal(b2, &a2)
gtest.Assert(err2, nil)
gtest.Assert(a2.Contains("a"), true)
gtest.Assert(a2.Contains("b"), true)
gtest.Assert(a2.Contains("c"), true)
gtest.Assert(a2.Contains("d"), true)
gtest.Assert(a2.Contains("e"), false)
var a3 gset.Set
err := json.Unmarshal(b2, &a3)
gtest.Assert(err, nil)
gtest.Assert(a3.Contains("a"), true)
gtest.Assert(a3.Contains("b"), true)
gtest.Assert(a3.Contains("c"), true)
gtest.Assert(a3.Contains("d"), true)
gtest.Assert(a3.Contains("e"), false)
})
}