github.com/google/cadvisor@v0.49.1/utils/sysfs/sysfs_test.go (about)

     1  // Copyright 2020 Google Inc. All Rights Reserved.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package sysfs
    16  
    17  import (
    18  	"os"
    19  	"strconv"
    20  	"testing"
    21  
    22  	"github.com/stretchr/testify/assert"
    23  )
    24  
    25  func TestGetNodes(t *testing.T) {
    26  	//overwrite global variable
    27  	nodeDir = "./testdata/"
    28  
    29  	sysFs := NewRealSysFs()
    30  	nodesDirs, err := sysFs.GetNodesPaths()
    31  	assert.Nil(t, err)
    32  	assert.Equal(t, 2, len(nodesDirs))
    33  	assert.Contains(t, nodesDirs, "testdata/node0")
    34  	assert.Contains(t, nodesDirs, "testdata/node1")
    35  }
    36  
    37  func TestGetNodesWithNonExistingDir(t *testing.T) {
    38  	//overwrite global variable
    39  	nodeDir = "./testdata/NonExistingDir/"
    40  
    41  	sysFs := NewRealSysFs()
    42  	nodesDirs, err := sysFs.GetNodesPaths()
    43  	assert.Nil(t, err)
    44  	assert.Equal(t, 0, len(nodesDirs))
    45  }
    46  
    47  func TestGetCPUsPaths(t *testing.T) {
    48  	sysFs := NewRealSysFs()
    49  	cpuDirs, err := sysFs.GetCPUsPaths("./testdata/node0")
    50  	assert.Nil(t, err)
    51  	assert.Equal(t, 2, len(cpuDirs))
    52  	assert.Contains(t, cpuDirs, "testdata/node0/cpu0")
    53  	assert.Contains(t, cpuDirs, "testdata/node0/cpu1")
    54  }
    55  
    56  func TestGetCPUsPathsFromNodeWithoutCPU(t *testing.T) {
    57  	sysFs := NewRealSysFs()
    58  	cpuDirs, err := sysFs.GetCPUsPaths("./testdata/node1")
    59  	assert.Nil(t, err)
    60  	assert.Equal(t, 0, len(cpuDirs))
    61  }
    62  
    63  func TestGetCoreID(t *testing.T) {
    64  	sysFs := NewRealSysFs()
    65  	rawCoreID, err := sysFs.GetCoreID("./testdata/node0/cpu0")
    66  	assert.Nil(t, err)
    67  
    68  	coreID, err := strconv.Atoi(rawCoreID)
    69  	assert.Nil(t, err)
    70  	assert.Equal(t, 0, coreID)
    71  }
    72  
    73  func TestGetCoreIDWhenFileIsMissing(t *testing.T) {
    74  	sysFs := NewRealSysFs()
    75  	rawCoreID, err := sysFs.GetCoreID("./testdata/node0/cpu1")
    76  	assert.NotNil(t, err)
    77  	assert.Equal(t, "", rawCoreID)
    78  }
    79  
    80  func TestGetMemInfo(t *testing.T) {
    81  	sysFs := NewRealSysFs()
    82  	memInfo, err := sysFs.GetMemInfo("./testdata/node0")
    83  	assert.Nil(t, err)
    84  	assert.Equal(t, "Node 0 MemTotal:       32817192 kB", memInfo)
    85  }
    86  
    87  func TestGetMemInfoWhenFileIsMissing(t *testing.T) {
    88  	sysFs := NewRealSysFs()
    89  	memInfo, err := sysFs.GetMemInfo("./testdata/node1")
    90  	assert.NotNil(t, err)
    91  	assert.Equal(t, "", memInfo)
    92  }
    93  
    94  func TestGetHugePagesInfo(t *testing.T) {
    95  	sysFs := NewRealSysFs()
    96  	hugePages, err := sysFs.GetHugePagesInfo("./testdata/node0/hugepages")
    97  	assert.Nil(t, err)
    98  	assert.Equal(t, 2, len(hugePages))
    99  	assert.Equal(t, "hugepages-1048576kB", hugePages[0].Name())
   100  	assert.Equal(t, "hugepages-2048kB", hugePages[1].Name())
   101  }
   102  
   103  func TestGetHugePagesInfoWhenDirIsMissing(t *testing.T) {
   104  	sysFs := NewRealSysFs()
   105  	hugePages, err := sysFs.GetHugePagesInfo("./testdata/node1/hugepages")
   106  	assert.NotNil(t, err)
   107  	assert.Equal(t, []os.FileInfo([]os.FileInfo(nil)), hugePages)
   108  }
   109  
   110  func TestGetHugePagesNr(t *testing.T) {
   111  	sysFs := NewRealSysFs()
   112  	rawHugePageNr, err := sysFs.GetHugePagesNr("./testdata/node0/hugepages/", "hugepages-1048576kB")
   113  	assert.Nil(t, err)
   114  
   115  	hugePageNr, err := strconv.Atoi(rawHugePageNr)
   116  	assert.Nil(t, err)
   117  	assert.Equal(t, 1, hugePageNr)
   118  }
   119  
   120  func TestGetHugePagesNrWhenFileIsMissing(t *testing.T) {
   121  	sysFs := NewRealSysFs()
   122  	rawHugePageNr, err := sysFs.GetHugePagesNr("./testdata/node1/hugepages/", "hugepages-1048576kB")
   123  	assert.NotNil(t, err)
   124  	assert.Equal(t, "", rawHugePageNr)
   125  }
   126  
   127  func TestIsCPUOnline(t *testing.T) {
   128  	sysFs := &realSysFs{
   129  		cpuPath: "./testdata_epyc7402_nohyperthreading",
   130  	}
   131  	online := sysFs.IsCPUOnline("./testdata_epyc7402_nohyperthreading/cpu14")
   132  	assert.True(t, online)
   133  
   134  	online = sysFs.IsCPUOnline("./testdata_epyc7402_nohyperthreading/cpu13")
   135  	assert.False(t, online)
   136  }
   137  
   138  func TestIsCPUOnlineNoFileAndCPU0MustBeOnline(t *testing.T) {
   139  	// Test on x86.
   140  	origIsX86 := isX86
   141  	defer func() {
   142  		isX86 = origIsX86
   143  	}()
   144  	isX86 = false
   145  
   146  	sysFs := &realSysFs{
   147  		cpuPath: "./testdata/missing_online/node0",
   148  	}
   149  	online := sysFs.IsCPUOnline("./testdata/missing_online/node0/cpu33")
   150  	assert.True(t, online)
   151  }
   152  
   153  func TestIsCPU0OnlineOnx86(t *testing.T) {
   154  	// Test on x86.
   155  	origIsX86 := isX86
   156  	defer func() {
   157  		isX86 = origIsX86
   158  	}()
   159  	isX86 = true
   160  
   161  	sysFs := NewRealSysFs()
   162  	online := sysFs.IsCPUOnline("path/is/irrelevant/it/is/zero/that/matters/cpu0")
   163  	assert.True(t, online)
   164  }
   165  
   166  func TestCPU0OfflineOnNotx86(t *testing.T) {
   167  	// Test on arch other than x86.
   168  	origIsX86 := isX86
   169  	defer func() {
   170  		isX86 = origIsX86
   171  	}()
   172  	isX86 = false
   173  
   174  	sysFs := &realSysFs{
   175  		cpuPath: "./testdata_graviton2",
   176  	}
   177  	online := sysFs.IsCPUOnline("./testdata_graviton2/cpu0")
   178  	assert.False(t, online)
   179  }
   180  
   181  func TestIsCpuOnlineRaspberryPi4(t *testing.T) {
   182  	// Test on arch other than x86.
   183  	origIsX86 := isX86
   184  	defer func() {
   185  		isX86 = origIsX86
   186  	}()
   187  	isX86 = false
   188  
   189  	sysFS := &realSysFs{
   190  		cpuPath: "./testdata_rpi4",
   191  	}
   192  	online := sysFS.IsCPUOnline("./testdata_rpi4/cpu0")
   193  	assert.True(t, online)
   194  
   195  	online = sysFS.IsCPUOnline("./testdata_rpi4/cpu1")
   196  	assert.True(t, online)
   197  
   198  	online = sysFS.IsCPUOnline("./testdata_rpi4/cpu2")
   199  	assert.True(t, online)
   200  
   201  	online = sysFS.IsCPUOnline("./testdata_rpi4/cpu3")
   202  	assert.True(t, online)
   203  }
   204  
   205  func TestIsCpuOnlineGraviton2(t *testing.T) {
   206  	// Test on arch other than x86.
   207  	origIsX86 := isX86
   208  	defer func() {
   209  		isX86 = origIsX86
   210  	}()
   211  	isX86 = false
   212  
   213  	sysFS := &realSysFs{
   214  		cpuPath: "./testdata_graviton2",
   215  	}
   216  	online := sysFS.IsCPUOnline("./testdata_graviton2/cpu0")
   217  	assert.False(t, online)
   218  
   219  	online = sysFS.IsCPUOnline("./testdata_graviton2/cpu1")
   220  	assert.True(t, online)
   221  
   222  	online = sysFS.IsCPUOnline("./testdata_graviton2/cpu2")
   223  	assert.True(t, online)
   224  
   225  	online = sysFS.IsCPUOnline("./testdata_graviton2/cpu3")
   226  	assert.True(t, online)
   227  }
   228  
   229  func TestGetUniqueCPUPropertyCountOnRaspberryPi4(t *testing.T) {
   230  	// Test on arch other than x86.
   231  	origIsX86 := isX86
   232  	defer func() {
   233  		isX86 = origIsX86
   234  	}()
   235  	isX86 = false
   236  
   237  	count := GetUniqueCPUPropertyCount("./testdata_rpi4/", CPUPhysicalPackageID)
   238  	assert.Equal(t, 1, count)
   239  
   240  	count = GetUniqueCPUPropertyCount("./testdata_rpi4/", CPUCoreID)
   241  	assert.Equal(t, 4, count)
   242  }
   243  
   244  func TestGetUniqueCPUPropertyCountOnEpyc7402(t *testing.T) {
   245  	// Test on x86.
   246  	origIsX86 := isX86
   247  	defer func() {
   248  		isX86 = origIsX86
   249  	}()
   250  	isX86 = true
   251  
   252  	count := GetUniqueCPUPropertyCount("./testdata_epyc7402/", CPUPhysicalPackageID)
   253  	assert.Equal(t, 1, count)
   254  
   255  	count = GetUniqueCPUPropertyCount("./testdata_epyc7402/", CPUCoreID)
   256  	assert.Equal(t, 24, count)
   257  }
   258  
   259  func TestGetUniqueCPUPropertyCountOnEpyc7402NoHyperThreading(t *testing.T) {
   260  	// Test on x86.
   261  	origIsX86 := isX86
   262  	defer func() {
   263  		isX86 = origIsX86
   264  	}()
   265  	isX86 = true
   266  
   267  	count := GetUniqueCPUPropertyCount("./testdata_epyc7402_nohyperthreading/", CPUPhysicalPackageID)
   268  	assert.Equal(t, 1, count)
   269  
   270  	count = GetUniqueCPUPropertyCount("./testdata_epyc7402_nohyperthreading/", CPUCoreID)
   271  	assert.Equal(t, 17, count)
   272  }
   273  
   274  func TestGetUniqueCPUPropertyCountOnXeon4214(t *testing.T) {
   275  	// Test on x86.
   276  	origIsX86 := isX86
   277  	defer func() {
   278  		isX86 = origIsX86
   279  	}()
   280  	isX86 = true
   281  
   282  	count := GetUniqueCPUPropertyCount("./testdata_xeon4214_2socket/", CPUPhysicalPackageID)
   283  	assert.Equal(t, 2, count)
   284  
   285  	count = GetUniqueCPUPropertyCount("./testdata_xeon4214_2socket/", CPUCoreID)
   286  	assert.Equal(t, 24, count)
   287  }
   288  
   289  func TestGetUniqueCPUPropertyCountOnXeon5218NoHyperThreadingNoHotplug(t *testing.T) {
   290  	// Test on x86.
   291  	origIsX86 := isX86
   292  	defer func() {
   293  		isX86 = origIsX86
   294  	}()
   295  	isX86 = true
   296  
   297  	count := GetUniqueCPUPropertyCount("./testdata_xeon5218_nohyperthread_2socket_nohotplug/", CPUPhysicalPackageID)
   298  	assert.Equal(t, 2, count)
   299  
   300  	count = GetUniqueCPUPropertyCount("./testdata_xeon5218_nohyperthread_2socket_nohotplug/", CPUCoreID)
   301  	assert.Equal(t, 32, count)
   302  }
   303  
   304  func TestUniqueCPUPropertyOnSingleSocketMultipleNUMAsSystem(t *testing.T) {
   305  	// Test on x86.
   306  	origIsX86 := isX86
   307  	defer func() {
   308  		isX86 = origIsX86
   309  	}()
   310  	isX86 = true
   311  
   312  	count := GetUniqueCPUPropertyCount("./testdata_single_socket_many_NUMAs/", CPUPhysicalPackageID)
   313  	assert.Equal(t, 16, count)
   314  
   315  	count = GetUniqueCPUPropertyCount("./testdata_single_socket_many_NUMAs/", CPUCoreID)
   316  	assert.Equal(t, 16, count)
   317  }
   318  
   319  func TestGetDistances(t *testing.T) {
   320  	sysFs := NewRealSysFs()
   321  	distances, err := sysFs.GetDistances("./testdata/node0")
   322  	assert.Nil(t, err)
   323  	assert.Equal(t, "10 11", distances)
   324  }
   325  
   326  func TestGetDistancesFileIsMissing(t *testing.T) {
   327  	sysFs := NewRealSysFs()
   328  	distances, err := sysFs.GetDistances("./testdata/node1")
   329  	assert.NotNil(t, err)
   330  	assert.Equal(t, "", distances)
   331  }