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

Merge branch '完善garray测试'

Browse Source
This commit is contained in:
jroam
2019-06-30 12:44:57 +08:00
parent 0801245871 42214f17fc
commit 007c8a7b64
1 changed files with 257 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

257
g/container/garray/garray_z_unit_int_test.go
View File

@ -621,3 +621,260 @@ func TestIntArray_Remove(t *testing.T) {
gtest.Assert(array1.Len(), 2)
})
}
func TestSortedIntArray_LockFunc(t *testing.T) {
gtest.Case(t, func() {
n1 := []int{1, 2, 4, 3}
a1 := garray.NewSortedIntArrayFrom(n1)
ch1 := make(chan int64, 2)
go a1.LockFunc(func(n1 []int) { //互斥锁
for i := 1; i <= 4; i++ {
gtest.Assert(i, n1[i-1])
}
n1[3] = 7
time.Sleep(3 * time.Second) //暂停一秒
})
go func() {
time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
a1.Len()
ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
}()
t1 := <-ch1
t2 := <-ch1
// 相差大于0.6秒，说明在读取a1.len时，发生了等待。 防止ci抖动,以豪秒为单位
gtest.AssertGT(t2-t1, 600)
gtest.Assert(a1.Contains(7), true)
})
}
func TestSortedIntArray_RLockFunc(t *testing.T) {
gtest.Case(t, func() {
n1 := []int{1, 2, 4, 3}
a1 := garray.NewSortedIntArrayFrom(n1)
ch1 := make(chan int64, 2)
go a1.RLockFunc(func(n1 []int) { //读锁
n1[3] = 7
time.Sleep(3 * time.Second) //暂停一秒
})
go func() {
time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
a1.Len()
ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
}()
t1 := <-ch1
t2 := <-ch1
// 由于另一个goroutine加的读锁，其它可读,所以ch1的操作间隔是很小的.a.len 操作并没有等待,
// 防止ci抖动,以豪秒为单位
gtest.AssertLT(t2-t1, 2)
gtest.Assert(a1.Contains(7), true)
})
}
func TestSortedIntArray_Merge(t *testing.T) {
gtest.Case(t, func() {
n1 := []int{1, 2, 4, 3}
n2 := []int{7, 8, 9}
n3 := []int{3, 6}
s1 := []string{"a", "b", "c"}
in1 := []interface{}{1, "a", 2, "b"}
func1 := func(v1, v2 interface{}) int {
return strings.Compare(gconv.String(v1), gconv.String(v2))
}
a1 := garray.NewSortedIntArrayFrom(n1)
b1 := garray.NewStringArrayFrom(s1)
b2 := garray.NewIntArrayFrom(n3)
b3 := garray.NewArrayFrom(in1)
b4 := garray.NewSortedStringArrayFrom(s1)
b5 := garray.NewSortedIntArrayFrom(n3)
b6 := garray.NewSortedArrayFrom(in1, func1)
gtest.Assert(a1.Merge(n2).Len(), 7)
gtest.Assert(a1.Merge(n3).Len(), 9)
gtest.Assert(a1.Merge(b1).Len(), 12)
gtest.Assert(a1.Merge(b2).Len(), 14)
gtest.Assert(a1.Merge(b3).Len(), 18)
gtest.Assert(a1.Merge(b4).Len(), 21)
gtest.Assert(a1.Merge(b5).Len(), 23)
gtest.Assert(a1.Merge(b6).Len(), 27)
})
}
func TestSortedArray_LockFunc(t *testing.T) {
gtest.Case(t, func() {
n1 := []interface{}{1, 2, 4, 3}
func1 := func(v1, v2 interface{}) int {
return strings.Compare(gconv.String(v1), gconv.String(v2))
}
a1 := garray.NewSortedArrayFrom(n1, func1)
ch1 := make(chan int64, 2)
go a1.LockFunc(func(n1 []interface{}) { //互斥锁
n1[3] = 7
time.Sleep(3 * time.Second) //暂停一秒
})
go func() {
time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
a1.Len()
ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
}()
t1 := <-ch1
t2 := <-ch1
// 相差大于0.6秒，说明在读取a1.len时，发生了等待。 防止ci抖动,以豪秒为单位
gtest.AssertGT(t2-t1, 600)
gtest.Assert(a1.Contains(7), true)
})
}
func TestSortedArray_RLockFunc(t *testing.T) {
gtest.Case(t, func() {
n1 := []interface{}{1, 2, 4, 3}
func1 := func(v1, v2 interface{}) int {
return strings.Compare(gconv.String(v1), gconv.String(v2))
}
a1 := garray.NewSortedArrayFrom(n1, func1)
ch1 := make(chan int64, 2)
go a1.RLockFunc(func(n1 []interface{}) { //互斥锁
n1[3] = 7
time.Sleep(3 * time.Second) //暂停一秒
})
go func() {
time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
a1.Len()
ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
}()
t1 := <-ch1
t2 := <-ch1
// 由于另一个goroutine加的读锁，其它可读,所以ch1的操作间隔是很小的.a.len 操作并没有等待,
// 防止ci抖动,以豪秒为单位
gtest.AssertLT(t2-t1, 20)
gtest.Assert(a1.Contains(7), true)
})
}
func TestSortedArray_Merge(t *testing.T) {
gtest.Case(t, func() {
n1 := []interface{}{1, 2, 4, 3}
n2 := []int{7, 8, 9}
n3 := []int{3, 6}
s1 := []string{"a", "b", "c"}
in1 := []interface{}{1, "a", 2, "b"}
func1 := func(v1, v2 interface{}) int {
return strings.Compare(gconv.String(v1), gconv.String(v2))
}
a1 := garray.NewSortedArrayFrom(n1, func1)
b1 := garray.NewStringArrayFrom(s1)
b2 := garray.NewIntArrayFrom(n3)
b3 := garray.NewArrayFrom(in1)
b4 := garray.NewSortedStringArrayFrom(s1)
b5 := garray.NewSortedIntArrayFrom(n3)
gtest.Assert(a1.Merge(n2).Len(), 7)
gtest.Assert(a1.Merge(n3).Len(), 9)
gtest.Assert(a1.Merge(b1).Len(), 12)
gtest.Assert(a1.Merge(b2).Len(), 14)
gtest.Assert(a1.Merge(b3).Len(), 18)
gtest.Assert(a1.Merge(b4).Len(), 21)
gtest.Assert(a1.Merge(b5).Len(), 23)
})
}
func TestIntArray_SortFunc(t *testing.T) {
gtest.Case(t, func() {
n1 := []int{1, 2, 3, 5, 4}
a1 := garray.NewIntArrayFrom(n1)
func1 := func(v1, v2 int) bool {
if v1 > v2 {
return false
}
return true
}
func2 := func(v1, v2 int) bool {
if v1 > v2 {
return true
}
return true
}
a2 := a1.SortFunc(func1)
gtest.Assert(a2, []int{1, 2, 3, 4, 5})
a3 := a1.SortFunc(func2)
gtest.Assert(a3, []int{5, 4, 3, 2, 1})
})
}
func TestIntArray_LockFunc(t *testing.T) {
gtest.Case(t, func() {
n1 := []int{1, 2, 4, 3}
a1 := garray.NewIntArrayFrom(n1)
ch1 := make(chan int64, 2)
go a1.LockFunc(func(n1 []int) { //互斥锁
n1[3] = 7
time.Sleep(3 * time.Second) //暂停一秒
})
go func() {
time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
a1.Len()
ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
}()
t1 := <-ch1
t2 := <-ch1
// 相差大于0.6秒，说明在读取a1.len时，发生了等待。 防止ci抖动,以豪秒为单位
gtest.AssertGT(t2-t1, 600)
gtest.Assert(a1.Contains(7), true)
})
}
func TestIntArray_RLockFunc(t *testing.T) {
gtest.Case(t, func() {
n1 := []int{1, 2, 4, 3}
a1 := garray.NewIntArrayFrom(n1)
ch1 := make(chan int64, 2)
go a1.RLockFunc(func(n1 []int) { // 互斥锁
n1[3] = 7
time.Sleep(3 * time.Second) // 暂停一秒
})
go func() {
time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
a1.Len()
ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
}()
t1 := <-ch1
t2 := <-ch1
// 由于另一个goroutine加的读锁，其它可读,所以ch1的操作间隔是很小的.a.len 操作并没有等待,
// 防止ci抖动,以豪秒为单位
gtest.AssertLT(t2-t1, 20)
gtest.Assert(a1.Contains(7), true)
})
}