mirror of
https://gitlab.com/pulsechaincom/prysm-pulse.git
synced 2024-12-31 23:41:22 +00:00
cec6c8de83
* rem txpool * standardize repo shared utils, remove deprecated items * complete * package lvl godoc
709 lines
18 KiB
Go
709 lines
18 KiB
Go
package sliceutil
|
|
|
|
import (
|
|
"bytes"
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/prysmaticlabs/prysm/shared/ssz"
|
|
)
|
|
|
|
func TestGenericIntersection(t *testing.T) {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{2, 3, 5}, []uint64{3}, []uint64{3}},
|
|
{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{5, 3, 2}, []uint64{5, 3, 2}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{}, []uint64{}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
result, err := GenericIntersection(tt.setA, tt.setB)
|
|
if err != nil {
|
|
if !reflect.DeepEqual(result, tt.out) {
|
|
t.Errorf("got %d, want %d", result, tt.out)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func TestGenericIntersectionWithSSZ(t *testing.T) {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{2, 3, 5}, []uint64{3}, []uint64{3}},
|
|
{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{5, 3, 2}, []uint64{5, 3, 2}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{}, []uint64{}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
b1 := new(bytes.Buffer)
|
|
err := ssz.Encode(b1, tt.setA)
|
|
|
|
b2 := new(bytes.Buffer)
|
|
err1 := ssz.Encode(b2, tt.setA)
|
|
if err1 == nil && err == nil {
|
|
|
|
result, err := GenericIntersection(b1.Bytes(), b2.Bytes())
|
|
if err != nil {
|
|
if !reflect.DeepEqual(result, tt.out) {
|
|
t.Errorf("got %d, want %d", result, tt.out)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func TestFloatGenericIntersection(t *testing.T) {
|
|
testCases := []struct {
|
|
setA []float32
|
|
setB []float32
|
|
out []float32
|
|
}{
|
|
{[]float32{2, 3, 5}, []float32{3}, []float32{3}},
|
|
{[]float32{2, 3, 5}, []float32{3, 5}, []float32{3, 5}},
|
|
{[]float32{2, 3, 5}, []float32{5, 3, 2}, []float32{5, 3, 2}},
|
|
{[]float32{2, 3, 5}, []float32{2, 3, 5}, []float32{2, 3, 5}},
|
|
{[]float32{2, 3, 5}, []float32{}, []float32{}},
|
|
{[]float32{}, []float32{2, 3, 5}, []float32{}},
|
|
{[]float32{}, []float32{}, []float32{}},
|
|
{[]float32{1}, []float32{1}, []float32{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
result, err := GenericIntersection(tt.setA, tt.setB)
|
|
if err != nil {
|
|
|
|
if !reflect.DeepEqual(result, tt.out) {
|
|
t.Errorf("got %d, want %d", result, tt.out)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func TestStringGenericIntersection(t *testing.T) {
|
|
testCases := []struct {
|
|
setA []string
|
|
setB []string
|
|
out []string
|
|
}{
|
|
{[]string{"hello", "world"}, []string{"world"}, []string{"world"}},
|
|
{[]string{"hello"}, []string{"world"}, []string{}},
|
|
}
|
|
for _, tt := range testCases {
|
|
result, err := GenericIntersection(tt.setA, tt.setB)
|
|
if err != nil {
|
|
|
|
if !reflect.DeepEqual(result, tt.out) {
|
|
t.Errorf("got %d, want %d", result, tt.out)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func TestIntGenericIntersection(t *testing.T) {
|
|
testCases := []struct {
|
|
setA []int32
|
|
setB []int32
|
|
out []int32
|
|
}{
|
|
{[]int32{2, 3, 5}, []int32{3}, []int32{3}},
|
|
{[]int32{2, 3, 5}, []int32{3, 5}, []int32{3, 5}},
|
|
{[]int32{2, 3, 5}, []int32{5, 3, 2}, []int32{5, 3, 2}},
|
|
{[]int32{2, 3, 5}, []int32{2, 3, 5}, []int32{2, 3, 5}},
|
|
{[]int32{2, 3, 5}, []int32{}, []int32{}},
|
|
{[]int32{}, []int32{2, 3, 5}, []int32{}},
|
|
{[]int32{}, []int32{}, []int32{}},
|
|
{[]int32{1}, []int32{1}, []int32{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
result, err := GenericIntersection(tt.setA, tt.setB)
|
|
if err != nil {
|
|
|
|
if !reflect.DeepEqual(result, tt.out) {
|
|
t.Errorf("got %d, want %d", result, tt.out)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func TestGenericNot(t *testing.T) {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{4, 6}, []uint64{2, 3, 5, 4, 6}, []uint64{2, 3, 5}},
|
|
{[]uint64{3, 5}, []uint64{2, 3, 5}, []uint64{2}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{}},
|
|
{[]uint64{2}, []uint64{2, 3, 5}, []uint64{3, 5}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{}},
|
|
}
|
|
for _, tt := range testCases {
|
|
result, err := GenericNot(tt.setA, tt.setB)
|
|
if err != nil {
|
|
|
|
if !reflect.DeepEqual(result, tt.out) {
|
|
t.Errorf("got %d, want %d", result, tt.out)
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func TestFloatGenericNot(t *testing.T) {
|
|
testCases := []struct {
|
|
setA []float32
|
|
setB []float32
|
|
out []float32
|
|
}{
|
|
{[]float32{4, 6}, []float32{2, 3, 5, 4, 6}, []float32{2, 3, 5}},
|
|
{[]float32{3, 5}, []float32{2, 3, 5}, []float32{2}},
|
|
{[]float32{2, 3, 5}, []float32{2, 3, 5}, []float32{}},
|
|
{[]float32{2}, []float32{2, 3, 5}, []float32{3, 5}},
|
|
{[]float32{}, []float32{2, 3, 5}, []float32{2, 3, 5}},
|
|
{[]float32{}, []float32{}, []float32{}},
|
|
{[]float32{1}, []float32{1}, []float32{}},
|
|
}
|
|
for _, tt := range testCases {
|
|
result, err := GenericNot(tt.setA, tt.setB)
|
|
if err != nil {
|
|
|
|
if !reflect.DeepEqual(result, tt.out) {
|
|
t.Errorf("got %d, want %d", result, tt.out)
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func TestStringGenericNot(t *testing.T) {
|
|
testCases := []struct {
|
|
setA []string
|
|
setB []string
|
|
out []string
|
|
}{
|
|
{[]string{"hello", "world"}, []string{"hello", "world", "its", "go"}, []string{"its", "go"}},
|
|
{[]string{}, []string{}, []string{}},
|
|
}
|
|
for _, tt := range testCases {
|
|
result, err := GenericNot(tt.setA, tt.setB)
|
|
if err != nil {
|
|
|
|
if !reflect.DeepEqual(result, tt.out) {
|
|
t.Errorf("got %d, want %d", result, tt.out)
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func TestIntGenericNot(t *testing.T) {
|
|
testCases := []struct {
|
|
setA []int32
|
|
setB []int32
|
|
out []int32
|
|
}{
|
|
{[]int32{4, 6}, []int32{2, 3, 5, 4, 6}, []int32{2, 3, 5}},
|
|
{[]int32{3, 5}, []int32{2, 3, 5}, []int32{2}},
|
|
{[]int32{2, 3, 5}, []int32{2, 3, 5}, []int32{}},
|
|
{[]int32{2}, []int32{2, 3, 5}, []int32{3, 5}},
|
|
{[]int32{}, []int32{2, 3, 5}, []int32{2, 3, 5}},
|
|
{[]int32{}, []int32{}, []int32{}},
|
|
{[]int32{1}, []int32{1}, []int32{}},
|
|
}
|
|
for _, tt := range testCases {
|
|
result, err := GenericNot(tt.setA, tt.setB)
|
|
if err != nil {
|
|
|
|
if !reflect.DeepEqual(result, tt.out) {
|
|
t.Errorf("got %d, want %d", result, tt.out)
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func TestGenericUnion(t *testing.T) {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{2, 3, 5}, []uint64{4, 6}, []uint64{2, 3, 5, 4, 6}},
|
|
{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{}, []uint64{2, 3, 5}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
result, err := GenericUnion(tt.setA, tt.setB)
|
|
if err != nil {
|
|
|
|
if !reflect.DeepEqual(result, tt.out) {
|
|
t.Errorf("got %d, want %d", result, tt.out)
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func TestFloatGenericUnion(t *testing.T) {
|
|
testCases := []struct {
|
|
setA []float32
|
|
setB []float32
|
|
out []float32
|
|
}{
|
|
{[]float32{2, 3, 5}, []float32{4, 6}, []float32{2, 3, 5, 4, 6}},
|
|
{[]float32{2, 3, 5}, []float32{4, 6}, []float32{2, 3, 5, 4, 6}},
|
|
{[]float32{2, 3, 5}, []float32{3, 5}, []float32{2, 3, 5}},
|
|
{[]float32{2, 3, 5}, []float32{2, 3, 5}, []float32{2, 3, 5}},
|
|
{[]float32{2, 3, 5}, []float32{}, []float32{2, 3, 5}},
|
|
{[]float32{}, []float32{2, 3, 5}, []float32{2, 3, 5}},
|
|
{[]float32{}, []float32{}, []float32{}},
|
|
{[]float32{1}, []float32{1}, []float32{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
result, err := GenericUnion(tt.setA, tt.setB)
|
|
if err != nil {
|
|
if !reflect.DeepEqual(result, tt.out) {
|
|
t.Errorf("got %d, want %d", result, tt.out)
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func TestGenericIsIn(t *testing.T) {
|
|
testCases := []struct {
|
|
a uint64
|
|
b []uint64
|
|
result bool
|
|
}{
|
|
{0, []uint64{}, false},
|
|
{0, []uint64{0}, true},
|
|
{4, []uint64{2, 3, 5, 4, 6}, true},
|
|
{100, []uint64{2, 3, 5, 4, 6}, false},
|
|
}
|
|
for _, tt := range testCases {
|
|
result := GenericIsIn(tt.a, tt.b)
|
|
if result != tt.result {
|
|
t.Errorf("IsIn(%d, %v)=%v, wanted: %v",
|
|
tt.a, tt.b, result, tt.result)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkGenericIntersection(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{2, 3, 5}, []uint64{3}, []uint64{3}},
|
|
{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{5, 3, 2}, []uint64{5, 3, 2}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{}, []uint64{}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
res, err := GenericIntersection(tt.setA, tt.setB)
|
|
if err != nil {
|
|
b.Errorf("Benchmark error for %v", res)
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func BenchmarkIntersection(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{2, 3, 5}, []uint64{3}, []uint64{3}},
|
|
{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{5, 3, 2}, []uint64{5, 3, 2}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{}, []uint64{}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
Intersection(tt.setA, tt.setB)
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkUnion(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{2, 3, 5}, []uint64{3}, []uint64{3}},
|
|
{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{5, 3, 2}, []uint64{5, 3, 2}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{}, []uint64{}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
Union(tt.setA, tt.setB)
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func BenchmarkGenericUnion(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{2, 3, 5}, []uint64{3}, []uint64{3}},
|
|
{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{5, 3, 2}, []uint64{5, 3, 2}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{}, []uint64{}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
res, err := GenericUnion(tt.setA, tt.setB)
|
|
if err != nil {
|
|
b.Errorf("Benchmark error for %v", res)
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkNot(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{2, 3, 5}, []uint64{3}, []uint64{3}},
|
|
{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{5, 3, 2}, []uint64{5, 3, 2}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{}, []uint64{}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
Not(tt.setA, tt.setB)
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func BenchmarkGenericNot(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{2, 3, 5}, []uint64{3}, []uint64{3}},
|
|
{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{5, 3, 2}, []uint64{5, 3, 2}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{}, []uint64{}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
res, err := GenericNot(tt.setA, tt.setB)
|
|
if err != nil {
|
|
b.Errorf("Benchmark error for %v", res)
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func BenchmarkIsIn(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testCases := []struct {
|
|
a uint64
|
|
b []uint64
|
|
result bool
|
|
}{
|
|
{0, []uint64{}, false},
|
|
{0, []uint64{0}, true},
|
|
{4, []uint64{2, 3, 5, 4, 6}, true},
|
|
{100, []uint64{2, 3, 5, 4, 6}, false},
|
|
}
|
|
for _, tt := range testCases {
|
|
IsIn(tt.a, tt.b)
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func BenchmarkGenericIsIn(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testCases := []struct {
|
|
a uint64
|
|
b []uint64
|
|
result bool
|
|
}{
|
|
{0, []uint64{}, false},
|
|
{0, []uint64{0}, true},
|
|
{4, []uint64{2, 3, 5, 4, 6}, true},
|
|
{100, []uint64{2, 3, 5, 4, 6}, false},
|
|
}
|
|
for _, tt := range testCases {
|
|
GenericIsIn(tt.a, tt.b)
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func BenchmarkGenericIntersectionWithSSZ(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{2, 3, 5}, []uint64{3}, []uint64{3}},
|
|
{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{5, 3, 2}, []uint64{5, 3, 2}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{}, []uint64{}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
b1 := new(bytes.Buffer)
|
|
err := ssz.Encode(b1, tt.setA)
|
|
|
|
b2 := new(bytes.Buffer)
|
|
err1 := ssz.Encode(b2, tt.setA)
|
|
if err1 == nil && err == nil {
|
|
|
|
res, err := GenericIntersection(b1.Bytes(), b2.Bytes())
|
|
if err != nil {
|
|
b.Errorf("Benchmark error for %v", res)
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkIntersectionWithSSZ(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{2, 3, 5}, []uint64{3}, []uint64{3}},
|
|
{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{5, 3, 2}, []uint64{5, 3, 2}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{}, []uint64{}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
b1 := new(bytes.Buffer)
|
|
err := ssz.Encode(b1, tt.setA)
|
|
|
|
b2 := new(bytes.Buffer)
|
|
err1 := ssz.Encode(b2, tt.setA)
|
|
if err1 == nil && err == nil {
|
|
|
|
ByteIntersection(b1.Bytes(), b2.Bytes())
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkGenericUnionWithSSZ(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{2, 3, 5}, []uint64{3}, []uint64{3}},
|
|
{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{5, 3, 2}, []uint64{5, 3, 2}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{}, []uint64{}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
b1 := new(bytes.Buffer)
|
|
err := ssz.Encode(b1, tt.setA)
|
|
|
|
b2 := new(bytes.Buffer)
|
|
err1 := ssz.Encode(b2, tt.setA)
|
|
if err1 == nil && err == nil {
|
|
|
|
res, err := GenericUnion(b1.Bytes(), b2.Bytes())
|
|
if err != nil {
|
|
b.Errorf("Benchmark error for %v", res)
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkUnionWithSSZ(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{2, 3, 5}, []uint64{3}, []uint64{3}},
|
|
{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{5, 3, 2}, []uint64{5, 3, 2}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{}, []uint64{}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
b1 := new(bytes.Buffer)
|
|
err := ssz.Encode(b1, tt.setA)
|
|
|
|
b2 := new(bytes.Buffer)
|
|
err1 := ssz.Encode(b2, tt.setA)
|
|
if err1 == nil && err == nil {
|
|
|
|
ByteUnion(b1.Bytes(), b2.Bytes())
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkGenericNotWithSSZ(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{2, 3, 5}, []uint64{3}, []uint64{3}},
|
|
{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{5, 3, 2}, []uint64{5, 3, 2}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{}, []uint64{}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
b1 := new(bytes.Buffer)
|
|
err := ssz.Encode(b1, tt.setA)
|
|
|
|
b2 := new(bytes.Buffer)
|
|
err1 := ssz.Encode(b2, tt.setA)
|
|
if err1 == nil && err == nil {
|
|
|
|
res, err := GenericNot(b1.Bytes(), b2.Bytes())
|
|
if err != nil {
|
|
b.Errorf("Benchmark error for %v", res)
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkNotWithSSZ(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
testCases := []struct {
|
|
setA []uint64
|
|
setB []uint64
|
|
out []uint64
|
|
}{
|
|
{[]uint64{2, 3, 5}, []uint64{3}, []uint64{3}},
|
|
{[]uint64{2, 3, 5}, []uint64{3, 5}, []uint64{3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{5, 3, 2}, []uint64{5, 3, 2}},
|
|
{[]uint64{2, 3, 5}, []uint64{2, 3, 5}, []uint64{2, 3, 5}},
|
|
{[]uint64{2, 3, 5}, []uint64{}, []uint64{}},
|
|
{[]uint64{}, []uint64{2, 3, 5}, []uint64{}},
|
|
{[]uint64{}, []uint64{}, []uint64{}},
|
|
{[]uint64{1}, []uint64{1}, []uint64{1}},
|
|
}
|
|
for _, tt := range testCases {
|
|
b1 := new(bytes.Buffer)
|
|
err := ssz.Encode(b1, tt.setA)
|
|
|
|
b2 := new(bytes.Buffer)
|
|
err1 := ssz.Encode(b2, tt.setA)
|
|
if err1 == nil && err == nil {
|
|
ByteNot(b1.Bytes(), b2.Bytes())
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|