mirror of
https://github.com/k3s-io/kubernetes.git
synced 2025-07-22 03:11:40 +00:00
Updated unit test for socketmask
This commit is contained in:
nolancon
parent
283dff9335
commit
b7f6b8f8f1
@ -1,5 +1,5 @@
|
||||
/*
|
||||
Copyright 2015 The Kubernetes Authors.
|
||||
Copyright 2019 The Kubernetes Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
@ -21,84 +21,270 @@ import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestGetSocketmask(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
socketmask [][]int64
|
||||
maskholder []string
|
||||
count int
|
||||
expectedMaskHolder []string
|
||||
expectedFinalSocketMask SocketMask
|
||||
}{
|
||||
{
|
||||
name: "Empty MaskHolder and count set as 0",
|
||||
socketmask: [][]int64{{1, 0}, {0, 1}, {1, 1}},
|
||||
maskholder: []string{""},
|
||||
count: 0,
|
||||
expectedMaskHolder: []string{"10", "01", "11"},
|
||||
expectedFinalSocketMask: SocketMask{1, 0},
|
||||
},
|
||||
{
|
||||
name: "MaskHolder non zero, count set as 1",
|
||||
socketmask: [][]int64{{1, 0}, {0, 1}, {1, 1}},
|
||||
maskholder: []string{"10", "01", "11"},
|
||||
count: 1,
|
||||
expectedMaskHolder: []string{"10", "01", "11"},
|
||||
expectedFinalSocketMask: SocketMask{1, 0},
|
||||
},
|
||||
|
||||
{
|
||||
name: "Empty MaskHolder and count set as 0",
|
||||
socketmask: [][]int64{{0, 1}, {1, 1}},
|
||||
maskholder: []string{""},
|
||||
count: 0,
|
||||
expectedMaskHolder: []string{"01", "11"},
|
||||
expectedFinalSocketMask: SocketMask{0, 1},
|
||||
},
|
||||
{
|
||||
name: "MaskHolder non zero, count set as 1",
|
||||
socketmask: [][]int64{{0, 1}, {1, 1}},
|
||||
maskholder: []string{"01", "11"},
|
||||
count: 1,
|
||||
expectedMaskHolder: []string{"01", "11"},
|
||||
expectedFinalSocketMask: SocketMask{0, 1},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range tcases {
|
||||
|
||||
sm := NewSocketMask(nil)
|
||||
actualSocketMask, actualMaskHolder := sm.GetSocketMask(tc.socketmask, tc.maskholder, tc.count)
|
||||
if !reflect.DeepEqual(actualSocketMask, tc.expectedFinalSocketMask) {
|
||||
t.Errorf("Expected final socketmask to be %v, got %v", tc.expectedFinalSocketMask, actualSocketMask)
|
||||
}
|
||||
|
||||
if !reflect.DeepEqual(actualMaskHolder, tc.expectedMaskHolder) {
|
||||
t.Errorf("Expected maskholder to be %v, got %v", tc.expectedMaskHolder, actualMaskHolder)
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewSocketMask(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
Mask []int64
|
||||
expectedMask []int64
|
||||
socket int
|
||||
expectedMask string
|
||||
}{
|
||||
{
|
||||
name: "Mask as an int64 binary array",
|
||||
Mask: []int64{1, 0},
|
||||
expectedMask: []int64{1, 0},
|
||||
name: "New SocketMask with socket 0 set",
|
||||
socket: int(0),
|
||||
expectedMask: "1000000000000000000000000000000000000000000000000000000000000000",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range tcases {
|
||||
|
||||
sm := NewSocketMask(nil)
|
||||
|
||||
if reflect.DeepEqual(sm, tc.expectedMask) {
|
||||
t.Errorf("Expected socket mask to be %v, got %v", tc.expectedMask, sm)
|
||||
sm, _ := NewSocketMask(0)
|
||||
if sm.String() != tc.expectedMask {
|
||||
t.Errorf("Expected mask to be %v, got %v", tc.expectedMask, sm)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdd(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
firstSocket int
|
||||
secondSocket int
|
||||
expectedMask string
|
||||
}{
|
||||
{
|
||||
name: "Reset bit 1 SocketMask to 0",
|
||||
firstSocket: 0,
|
||||
secondSocket: 1,
|
||||
expectedMask: "1100000000000000000000000000000000000000000000000000000000000000",
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask()
|
||||
mask.Add(tc.firstSocket, tc.secondSocket)
|
||||
if mask.String() != tc.expectedMask {
|
||||
t.Errorf("Expected mask to be %v, got %v", tc.expectedMask, mask)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestRemove(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
firstSocketSet int
|
||||
secondSocketSet int
|
||||
firstSocketRemove int
|
||||
expectedMask string
|
||||
}{
|
||||
{
|
||||
name: "Reset bit 1 SocketMask to 0",
|
||||
firstSocketSet: 0,
|
||||
secondSocketSet: 1,
|
||||
firstSocketRemove: 0,
|
||||
expectedMask: "0100000000000000000000000000000000000000000000000000000000000000",
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask(tc.firstSocketSet, tc.secondSocketSet)
|
||||
mask.Remove(tc.firstSocketRemove)
|
||||
if mask.String() != tc.expectedMask {
|
||||
t.Errorf("Expected mask to be %v, got %v", tc.expectedMask, mask)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnd(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
firstMaskBit int
|
||||
secondMaskBit int
|
||||
andMask string
|
||||
}{
|
||||
{
|
||||
name: "And socket masks",
|
||||
firstMaskBit: 0,
|
||||
secondMaskBit: 0,
|
||||
andMask: "1000000000000000000000000000000000000000000000000000000000000000",
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
firstMask, _ := NewSocketMask(tc.firstMaskBit)
|
||||
secondMask, _ := NewSocketMask(tc.secondMaskBit)
|
||||
firstMask.And(secondMask)
|
||||
if firstMask.String() != string(tc.andMask) {
|
||||
t.Errorf("Expected mask to be %v, got %v", tc.andMask, firstMask)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestOr(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
firstMaskBit int
|
||||
secondMaskBit int
|
||||
orMask string
|
||||
}{
|
||||
{
|
||||
name: "Or socket masks",
|
||||
firstMaskBit: int(0),
|
||||
secondMaskBit: int(1),
|
||||
orMask: "1100000000000000000000000000000000000000000000000000000000000000",
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
firstMask, _ := NewSocketMask(tc.firstMaskBit)
|
||||
secondMask, _ := NewSocketMask(tc.secondMaskBit)
|
||||
firstMask.Or(secondMask)
|
||||
if firstMask.String() != string(tc.orMask) {
|
||||
t.Errorf("Expected mask to be %v, got %v", tc.orMask, firstMask)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestClear(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
firstBit int
|
||||
secondBit int
|
||||
clearedMask string
|
||||
}{
|
||||
{
|
||||
name: "Clear socket masks",
|
||||
firstBit: int(0),
|
||||
secondBit: int(1),
|
||||
clearedMask: "0000000000000000000000000000000000000000000000000000000000000000",
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask(tc.firstBit, tc.secondBit)
|
||||
mask.Clear()
|
||||
if mask.String() != string(tc.clearedMask) {
|
||||
t.Errorf("Expected mask to be %v, got %v", tc.clearedMask, mask)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestFill(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
filledMask string
|
||||
}{
|
||||
{
|
||||
name: "Fill socket masks",
|
||||
filledMask: "1111111111111111111111111111111111111111111111111111111111111111",
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask()
|
||||
mask.Fill()
|
||||
if mask.String() != string(tc.filledMask) {
|
||||
t.Errorf("Expected mask to be %v, got %v", tc.filledMask, mask)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestIsEmpty(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
maskBit int
|
||||
expectedEmpty bool
|
||||
}{
|
||||
{
|
||||
name: "Check if mask is empty",
|
||||
maskBit: int(0),
|
||||
expectedEmpty: false,
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask(tc.maskBit)
|
||||
empty := mask.IsEmpty()
|
||||
if empty {
|
||||
t.Errorf("Expected value to be %v, got %v", tc.expectedEmpty, empty)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestIsSet(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
maskBit int
|
||||
expectedSet bool
|
||||
}{
|
||||
{
|
||||
name: "Check if mask bit is set",
|
||||
maskBit: int(0),
|
||||
expectedSet: true,
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask(tc.maskBit)
|
||||
set := mask.IsSet(tc.maskBit)
|
||||
if !set {
|
||||
t.Errorf("Expected value to be %v, got %v", tc.expectedSet, set)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestIsEqual(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
firstMaskBit int
|
||||
secondMaskBit int
|
||||
isEqual bool
|
||||
}{
|
||||
{
|
||||
name: "And socket masks",
|
||||
firstMaskBit: int(0),
|
||||
secondMaskBit: int(0),
|
||||
isEqual: true,
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
firstMask, _ := NewSocketMask(tc.firstMaskBit)
|
||||
secondMask, _ := NewSocketMask(tc.secondMaskBit)
|
||||
isEqual := firstMask.IsEqual(secondMask)
|
||||
if !isEqual {
|
||||
t.Errorf("Expected mask to be %v, got %v", tc.isEqual, isEqual)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestCount(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
maskBit int
|
||||
expectedCount int
|
||||
}{
|
||||
{
|
||||
name: "Count number of bits set in full mask",
|
||||
maskBit: 0,
|
||||
expectedCount: 1,
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask(tc.maskBit)
|
||||
count := mask.Count()
|
||||
if count != tc.expectedCount {
|
||||
t.Errorf("Expected value to be %v, got %v", tc.expectedCount, count)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetSockets(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
firstSocket int
|
||||
secondSocket int
|
||||
expectedSockets []int
|
||||
}{
|
||||
{
|
||||
name: "Get number of each socket which has been set",
|
||||
firstSocket: 0,
|
||||
secondSocket: 1,
|
||||
expectedSockets: []int{0, 1},
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask(tc.firstSocket, tc.secondSocket)
|
||||
sockets := mask.GetSockets()
|
||||
if !reflect.DeepEqual(sockets, tc.expectedSockets) {
|
||||
t.Errorf("Expected value to be %v, got %v", tc.expectedSockets, sockets)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user