github.com/cloudwego/kitex@v0.9.0/pkg/utils/ring_test.go

/*
 * Copyright 2021 CloudWeGo Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package utils

import (
	"sync"
	"sync/atomic"
	"testing"

	"github.com/cloudwego/kitex/internal/test"
)

// TestNewRing test new a ring object
func TestNewRing(t *testing.T) {
	r := NewRing(10)

	obj1 := r.Pop()
	test.Assert(t, obj1 == nil)

	obj2 := "test string"
	err := r.Push(obj2)
	test.Assert(t, err == nil)

	obj3 := r.Pop()
	test.Assert(t, obj3.(string) == obj2)

	r = NewRing(1)
	test.Assert(t, r.length == 1)

	test.Panic(t, func() {
		r = NewRing(0)
	})
}

// TestRing_Push test ring push
func TestRing_Push(t *testing.T) {
	var err error
	// size > 0
	r := NewRing(10)
	for i := 0; i < 20; i++ {
		err = r.Push(i)

		if i < 10 {
			test.Assert(t, err == nil)
		} else {
			test.Assert(t, err != nil)
		}
	}

	// size == 1
	r = NewRing(1)
	err = r.Push(1)
	test.Assert(t, err == nil)
}

// TestRing_Pop test ring pop
func TestRing_Pop(t *testing.T) {
	// size > 0
	r := NewRing(10)
	for i := 0; i < 10; i++ {
		err := r.Push(i)
		test.Assert(t, err == nil)
	}

	for i := 0; i < 20; i++ {
		if i < 10 {
			elem := r.Pop()
			test.Assert(t, elem != nil)
		} else {
			elem := r.Pop()
			test.Assert(t, elem == nil)
		}
	}

	// size == 1
	r = NewRing(1)
	err := r.Push(1)
	test.Assert(t, err == nil)
	elem := r.Pop()
	test.Assert(t, elem != nil)
}

// TestRing_Dump test dump data of a ring
func TestRing_Dump(t *testing.T) {
	elemTotal := 97
	r := NewRing(elemTotal)
	for i := 0; i < elemTotal; i++ {
		err := r.Push(i)
		test.Assert(t, err == nil)
	}

	dumpRet := r.Dump().(*ringDump)
	test.Assert(t, dumpRet != nil)
	test.Assert(t, dumpRet.Len == elemTotal)
	test.Assert(t, dumpRet.Cap >= elemTotal)
	for i := 0; i < elemTotal; i++ {
		test.Assert(t, dumpRet.Array[i].(int) == i)
	}
}

// TestRing_SingleDump test dump data of a ring node
func TestRing_SingleDump(t *testing.T) {
	elemTotal := 10
	r := NewRing(elemTotal)
	for i := 0; i < elemTotal; i++ {
		err := r.Push(i)
		test.Assert(t, err == nil)
	}

	singleDump := &ringDump{}
	r.rings[0].Dump(singleDump)
	test.Assert(t, singleDump != nil)
	test.Assert(t, singleDump.Cap == r.rings[0].size+1)
	test.Assert(t, singleDump.Len == r.rings[0].size)
	for i := 0; i < singleDump.Len; i++ {
		test.Assert(t, singleDump.Array[i].(int) == r.rings[0].arr[i])
	}
}

func TestRing_Parallel(t *testing.T) {
	r := NewRing(10)
	var wg sync.WaitGroup

	flag := make([]bool, 100)
	var errCount int64
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func(v int) {
			defer wg.Done()
			if err := r.Push(v); err != nil {
				atomic.AddInt64(&errCount, 1)
			} else {
				flag[v] = true
			}
		}(i)
	}
	wg.Wait()
	test.Assert(t, errCount == 90)

	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			if x := r.Pop(); x != nil {
				j, ok := x.(int)
				test.Assert(t, ok)
				test.Assert(t, flag[j])
			}
		}()
	}
	wg.Wait()
}

func BenchmarkRing(b *testing.B) {
	size := 1024
	r := NewRing(size)
	for i := 0; i < size; i++ {
		r.Push(struct{}{})
	}

	// benchmark
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		obj := r.Pop()
		r.Push(obj)
	}
}

func BenchmarkRing_Dump(b *testing.B) {
	size := 1000000
	r := NewRing(size)
	for i := 0; i < size; i++ {
		r.Push(struct{}{})
	}

	// benchmark
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_ = r.Dump()
	}
}

func BenchmarkRing_Parallel(b *testing.B) {
	size := 1024
	r := NewRing(size)
	for i := 0; i < size; i++ {
		r.Push(struct{}{})
	}

	// benchmark
	b.ReportAllocs()
	b.SetParallelism(128)
	b.ResetTimer()
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			obj := r.Pop()
			r.Push(obj)
		}
	})
}