github.com/opencontainers/runc@v1.2.0-rc.1.0.20240520010911-492dc558cdd6/libcontainer/cgroups/fs/stats_util_test.go (about)

     1  package fs
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"reflect"
     7  	"testing"
     8  
     9  	"github.com/opencontainers/runc/libcontainer/cgroups"
    10  )
    11  
    12  func blkioStatEntryEquals(expected, actual []cgroups.BlkioStatEntry) error {
    13  	if len(expected) != len(actual) {
    14  		return errors.New("blkioStatEntries length do not match")
    15  	}
    16  	for i, expValue := range expected {
    17  		actValue := actual[i]
    18  		if expValue != actValue {
    19  			return fmt.Errorf("expected: %v, actual: %v", expValue, actValue)
    20  		}
    21  	}
    22  	return nil
    23  }
    24  
    25  func expectBlkioStatsEquals(t *testing.T, expected, actual cgroups.BlkioStats) {
    26  	t.Helper()
    27  	if err := blkioStatEntryEquals(expected.IoServiceBytesRecursive, actual.IoServiceBytesRecursive); err != nil {
    28  		t.Errorf("blkio IoServiceBytesRecursive do not match: %s", err)
    29  	}
    30  
    31  	if err := blkioStatEntryEquals(expected.IoServicedRecursive, actual.IoServicedRecursive); err != nil {
    32  		t.Errorf("blkio IoServicedRecursive do not match: %s", err)
    33  	}
    34  
    35  	if err := blkioStatEntryEquals(expected.IoQueuedRecursive, actual.IoQueuedRecursive); err != nil {
    36  		t.Errorf("blkio IoQueuedRecursive do not match: %s", err)
    37  	}
    38  
    39  	if err := blkioStatEntryEquals(expected.SectorsRecursive, actual.SectorsRecursive); err != nil {
    40  		t.Errorf("blkio SectorsRecursive do not match: %s", err)
    41  	}
    42  
    43  	if err := blkioStatEntryEquals(expected.IoServiceTimeRecursive, actual.IoServiceTimeRecursive); err != nil {
    44  		t.Errorf("blkio IoServiceTimeRecursive do not match: %s", err)
    45  	}
    46  
    47  	if err := blkioStatEntryEquals(expected.IoWaitTimeRecursive, actual.IoWaitTimeRecursive); err != nil {
    48  		t.Errorf("blkio IoWaitTimeRecursive do not match: %s", err)
    49  	}
    50  
    51  	if err := blkioStatEntryEquals(expected.IoMergedRecursive, actual.IoMergedRecursive); err != nil {
    52  		t.Errorf("blkio IoMergedRecursive do not match: expected: %v, actual: %v", expected.IoMergedRecursive, actual.IoMergedRecursive)
    53  	}
    54  
    55  	if err := blkioStatEntryEquals(expected.IoTimeRecursive, actual.IoTimeRecursive); err != nil {
    56  		t.Errorf("blkio IoTimeRecursive do not match: %s", err)
    57  	}
    58  }
    59  
    60  func expectThrottlingDataEquals(t *testing.T, expected, actual cgroups.ThrottlingData) {
    61  	t.Helper()
    62  	if expected != actual {
    63  		t.Errorf("Expected throttling data: %v, actual: %v", expected, actual)
    64  	}
    65  }
    66  
    67  func expectHugetlbStatEquals(t *testing.T, expected, actual cgroups.HugetlbStats) {
    68  	t.Helper()
    69  	if expected != actual {
    70  		t.Errorf("Expected hugetlb stats: %v, actual: %v", expected, actual)
    71  	}
    72  }
    73  
    74  func expectMemoryStatEquals(t *testing.T, expected, actual cgroups.MemoryStats) {
    75  	t.Helper()
    76  	expectMemoryDataEquals(t, expected.Usage, actual.Usage)
    77  	expectMemoryDataEquals(t, expected.SwapUsage, actual.SwapUsage)
    78  	expectMemoryDataEquals(t, expected.KernelUsage, actual.KernelUsage)
    79  	expectPageUsageByNUMAEquals(t, expected.PageUsageByNUMA, actual.PageUsageByNUMA)
    80  
    81  	if expected.UseHierarchy != actual.UseHierarchy {
    82  		t.Errorf("Expected memory use hierarchy: %v, actual: %v", expected.UseHierarchy, actual.UseHierarchy)
    83  	}
    84  
    85  	for key, expValue := range expected.Stats {
    86  		actValue, ok := actual.Stats[key]
    87  		if !ok {
    88  			t.Errorf("Expected memory stat key %s not found", key)
    89  		}
    90  		if expValue != actValue {
    91  			t.Errorf("Expected memory stat value: %d, actual: %d", expValue, actValue)
    92  		}
    93  	}
    94  }
    95  
    96  func expectMemoryDataEquals(t *testing.T, expected, actual cgroups.MemoryData) {
    97  	t.Helper()
    98  	if expected.Usage != actual.Usage {
    99  		t.Errorf("Expected memory usage: %d, actual: %d", expected.Usage, actual.Usage)
   100  	}
   101  	if expected.MaxUsage != actual.MaxUsage {
   102  		t.Errorf("Expected memory max usage: %d, actual: %d", expected.MaxUsage, actual.MaxUsage)
   103  	}
   104  	if expected.Failcnt != actual.Failcnt {
   105  		t.Errorf("Expected memory failcnt %d, actual: %d", expected.Failcnt, actual.Failcnt)
   106  	}
   107  	if expected.Limit != actual.Limit {
   108  		t.Errorf("Expected memory limit: %d, actual: %d", expected.Limit, actual.Limit)
   109  	}
   110  }
   111  
   112  func expectPageUsageByNUMAEquals(t *testing.T, expected, actual cgroups.PageUsageByNUMA) {
   113  	t.Helper()
   114  	if !reflect.DeepEqual(expected.Total, actual.Total) {
   115  		t.Errorf("Expected total page usage by NUMA: %#v, actual: %#v", expected.Total, actual.Total)
   116  	}
   117  	if !reflect.DeepEqual(expected.File, actual.File) {
   118  		t.Errorf("Expected file page usage by NUMA: %#v, actual: %#v", expected.File, actual.File)
   119  	}
   120  	if !reflect.DeepEqual(expected.Anon, actual.Anon) {
   121  		t.Errorf("Expected anon page usage by NUMA: %#v, actual: %#v", expected.Anon, actual.Anon)
   122  	}
   123  	if !reflect.DeepEqual(expected.Unevictable, actual.Unevictable) {
   124  		t.Errorf("Expected unevictable page usage by NUMA: %#v, actual: %#v", expected.Unevictable, actual.Unevictable)
   125  	}
   126  	if !reflect.DeepEqual(expected.Hierarchical.Total, actual.Hierarchical.Total) {
   127  		t.Errorf("Expected hierarchical total page usage by NUMA: %#v, actual: %#v", expected.Hierarchical.Total, actual.Hierarchical.Total)
   128  	}
   129  	if !reflect.DeepEqual(expected.Hierarchical.File, actual.Hierarchical.File) {
   130  		t.Errorf("Expected hierarchical file page usage by NUMA: %#v, actual: %#v", expected.Hierarchical.File, actual.Hierarchical.File)
   131  	}
   132  	if !reflect.DeepEqual(expected.Hierarchical.Anon, actual.Hierarchical.Anon) {
   133  		t.Errorf("Expected hierarchical anon page usage by NUMA: %#v, actual: %#v", expected.Hierarchical.Anon, actual.Hierarchical.Anon)
   134  	}
   135  	if !reflect.DeepEqual(expected.Hierarchical.Unevictable, actual.Hierarchical.Unevictable) {
   136  		t.Errorf("Expected hierarchical total page usage by NUMA: %#v, actual: %#v", expected.Hierarchical.Unevictable, actual.Hierarchical.Unevictable)
   137  	}
   138  }