From b7f6b8f8f1868309a06f307914e58e02f074f03e Mon Sep 17 00:00:00 2001 From: nolancon Date: Tue, 28 May 2019 05:00:04 +0100 Subject: [PATCH] Updated unit test for socketmask --- .../socketmask/socketmask_test.go | 328 ++++++++++++++---- 1 file changed, 257 insertions(+), 71 deletions(-) diff --git a/pkg/kubelet/cm/topologymanager/socketmask/socketmask_test.go b/pkg/kubelet/cm/topologymanager/socketmask/socketmask_test.go index 624221a931a..01df68999c0 100644 --- a/pkg/kubelet/cm/topologymanager/socketmask/socketmask_test.go +++ b/pkg/kubelet/cm/topologymanager/socketmask/socketmask_test.go @@ -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) } } }