virtcontainers: Add to utils unit tests

Expand unit tests for virtcontainers/utils/utils.go to include testing
CleanupFds, CPU calculations, ID string creation, and memory alignment
functions.

Fixes #2877

Signed-off-by: Chelsea Mafrica <[email protected]>

virtcontainers/utils/utils_test.go

@@ -94,6 +94,28 @@ func TestRevereString(t *testing.T) {
 	assert.Equal(reversed, "rtstseT")
 }
 
+func TestCleanupFds(t *testing.T) {
+	assert := assert.New(t)
+
+	tmpFile, err := ioutil.TempFile("", "testFds1")
+	assert.NoError(err)
+	filename := tmpFile.Name()
+	defer os.Remove(filename)
+
+	numFds := 1
+	fds := make([]*os.File, numFds)
+	assert.NotNil(fds)
+	assert.Equal(len(fds), 1)
+
+	fds[0] = tmpFile
+
+	CleanupFds(fds, 0)
+	CleanupFds(fds, 1)
+
+	err = tmpFile.Close()
+	assert.Error(err)
+}
+
 func TestWriteToFile(t *testing.T) {
 	assert := assert.New(t)
 
@@ -118,6 +140,29 @@ func TestWriteToFile(t *testing.T) {
 	assert.True(reflect.DeepEqual(testData, data))
 }
 
+func TestCalculateMilliCPUs(t *testing.T) {
+	assert := assert.New(t)
+
+	n := CalculateMilliCPUs(1, 1)
+	expected := uint32(1000)
+	assert.Equal(n, expected)
+
+	n = CalculateMilliCPUs(1, 0)
+	expected = uint32(0)
+	assert.Equal(n, expected)
+
+	n = CalculateMilliCPUs(-1, 1)
+	assert.Equal(n, expected)
+}
+
+func TestCaluclateVCpusFromMilliCpus(t *testing.T) {
+	assert := assert.New(t)
+
+	n := CalculateVCpusFromMilliCpus(1)
+	expected := uint32(1)
+	assert.Equal(n, expected)
+}
+
 func TestConstraintsToVCPUs(t *testing.T) {
 	assert := assert.New(t)
 
@@ -187,8 +232,10 @@ func TestGetSCSIIdLun(t *testing.T) {
 		assert.Equal(lun, test.expectedLun)
 	}
 
-	_, _, err := GetSCSIIdLun(maxSCSIDevices + 1)
-	assert.NotNil(err)
+	_, _, err := GetSCSIIdLun(-1)
+	assert.Error(err)
+	_, _, err = GetSCSIIdLun(maxSCSIDevices + 1)
+	assert.Error(err)
 }
 
 func TestGetSCSIAddress(t *testing.T) {
@@ -209,6 +256,17 @@ func TestGetSCSIAddress(t *testing.T) {
 		assert.NoError(err)
 		assert.Equal(scsiAddr, test.expectedSCSIAddress)
 	}
+
+	_, err := GetSCSIAddress(-1)
+	assert.Error(err)
+}
+
+func TestMakeNameID(t *testing.T) {
+	assert := assert.New(t)
+
+	nameID := MakeNameID("testType", "testID", 14)
+	expected := "testType-testI"
+	assert.Equal(expected, nameID)
 }
 
 func TestBuildSocketPath(t *testing.T) {
@@ -272,3 +330,43 @@ func TestSupportsVsocks(t *testing.T) {
 
 	assert.True(SupportsVsocks())
 }
+
+func TestAlignMem(t *testing.T) {
+	assert := assert.New(t)
+
+	memSize := MemUnit(1024) * MiB
+	blockSize := MemUnit(512) * MiB
+	resultMem := memSize.AlignMem(blockSize)
+	expected := memSize
+	assert.Equal(expected, resultMem)
+
+	memSize = MemUnit(512) * MiB
+	blockSize = MemUnit(1024) * MiB
+	resultMem = memSize.AlignMem(blockSize)
+	expected = blockSize
+	assert.Equal(expected, resultMem)
+
+	memSize = MemUnit(1024) * MiB
+	blockSize = MemUnit(50) * MiB
+	resultMem = memSize.AlignMem(blockSize)
+	expected = memSize + (blockSize - (memSize % blockSize))
+	assert.Equal(expected, resultMem)
+}
+
+func TestToMiB(t *testing.T) {
+	assert := assert.New(t)
+
+	memSize := MemUnit(1) * GiB
+	result := memSize.ToMiB()
+	expected := uint64(1024)
+	assert.Equal(expected, result)
+}
+
+func TestToBytes(t *testing.T) {
+	assert := assert.New(t)
+
+	memSize := MemUnit(1) * GiB
+	result := memSize.ToBytes()
+	expected := uint64(1073741824)
+	assert.Equal(expected, result)
+}