github.com/opencontainers/runc@v1.2.0-rc.1.0.20240520010911-492dc558cdd6/libcontainer/system/kernelversion/kernel_linux_test.go (about)

     1  /*
     2     Copyright The containerd Authors.
     3  
     4     Licensed under the Apache License, Version 2.0 (the "License");
     5     you may not use this file except in compliance with the License.
     6     You may obtain a copy of the License at
     7  
     8         http://www.apache.org/licenses/LICENSE-2.0
     9  
    10     Unless required by applicable law or agreed to in writing, software
    11     distributed under the License is distributed on an "AS IS" BASIS,
    12     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13     See the License for the specific language governing permissions and
    14     limitations under the License.
    15  
    16     File copied and customized based on
    17     https://github.com/moby/moby/tree/v20.10.14/profiles/seccomp/kernel_linux_test.go
    18  */
    19  
    20  package kernelversion
    21  
    22  import (
    23  	"fmt"
    24  	"testing"
    25  )
    26  
    27  func TestGetKernelVersion(t *testing.T) {
    28  	version, err := getKernelVersion()
    29  	if err != nil {
    30  		t.Fatal(err)
    31  	}
    32  	if version == nil {
    33  		t.Fatal("version is nil")
    34  	}
    35  	if version.Kernel == 0 {
    36  		t.Fatal("no kernel version")
    37  	}
    38  }
    39  
    40  func TestParseRelease(t *testing.T) {
    41  	tests := []struct {
    42  		in          string
    43  		out         KernelVersion
    44  		expectedErr error
    45  	}{
    46  		{in: "3.8", out: KernelVersion{Kernel: 3, Major: 8}},
    47  		{in: "3.8.0", out: KernelVersion{Kernel: 3, Major: 8}},
    48  		{in: "3.8.0-19-generic", out: KernelVersion{Kernel: 3, Major: 8}},
    49  		{in: "3.4.54.longterm-1", out: KernelVersion{Kernel: 3, Major: 4}},
    50  		{in: "3.10.0-862.2.3.el7.x86_64", out: KernelVersion{Kernel: 3, Major: 10}},
    51  		{in: "3.12.8tag", out: KernelVersion{Kernel: 3, Major: 12}},
    52  		{in: "3.12-1-amd64", out: KernelVersion{Kernel: 3, Major: 12}},
    53  		{in: "3.12foobar", out: KernelVersion{Kernel: 3, Major: 12}},
    54  		{in: "99.999.999-19-generic", out: KernelVersion{Kernel: 99, Major: 999}},
    55  		{in: "", expectedErr: fmt.Errorf(`failed to parse kernel version "": EOF`)},
    56  		{in: "3", expectedErr: fmt.Errorf(`failed to parse kernel version "3": unexpected EOF`)},
    57  		{in: "3.", expectedErr: fmt.Errorf(`failed to parse kernel version "3.": EOF`)},
    58  		{in: "3a", expectedErr: fmt.Errorf(`failed to parse kernel version "3a": input does not match format`)},
    59  		{in: "3.a", expectedErr: fmt.Errorf(`failed to parse kernel version "3.a": expected integer`)},
    60  		{in: "a", expectedErr: fmt.Errorf(`failed to parse kernel version "a": expected integer`)},
    61  		{in: "a.a", expectedErr: fmt.Errorf(`failed to parse kernel version "a.a": expected integer`)},
    62  		{in: "a.a.a-a", expectedErr: fmt.Errorf(`failed to parse kernel version "a.a.a-a": expected integer`)},
    63  		{in: "-3", expectedErr: fmt.Errorf(`failed to parse kernel version "-3": expected integer`)},
    64  		{in: "-3.", expectedErr: fmt.Errorf(`failed to parse kernel version "-3.": expected integer`)},
    65  		{in: "-3.8", expectedErr: fmt.Errorf(`failed to parse kernel version "-3.8": expected integer`)},
    66  		{in: "-3.-8", expectedErr: fmt.Errorf(`failed to parse kernel version "-3.-8": expected integer`)},
    67  		{in: "3.-8", expectedErr: fmt.Errorf(`failed to parse kernel version "3.-8": expected integer`)},
    68  	}
    69  	for _, tc := range tests {
    70  		tc := tc
    71  		t.Run(tc.in, func(t *testing.T) {
    72  			version, err := parseRelease(tc.in)
    73  			if tc.expectedErr != nil {
    74  				if err == nil {
    75  					t.Fatal("expected an error")
    76  				}
    77  				if err.Error() != tc.expectedErr.Error() {
    78  					t.Fatalf("expected: %s, got: %s", tc.expectedErr, err)
    79  				}
    80  				return
    81  			}
    82  			if err != nil {
    83  				t.Fatal("unexpected error:", err)
    84  			}
    85  			if version == nil {
    86  				t.Fatal("version is nil")
    87  			}
    88  			if version.Kernel != tc.out.Kernel || version.Major != tc.out.Major {
    89  				t.Fatalf("expected: %d.%d, got: %d.%d", tc.out.Kernel, tc.out.Major, version.Kernel, version.Major)
    90  			}
    91  		})
    92  	}
    93  }
    94  
    95  func TestGreaterEqualThan(t *testing.T) {
    96  	// Get the current kernel version, so that we can make test relative to that
    97  	v, err := getKernelVersion()
    98  	if err != nil {
    99  		t.Fatal(err)
   100  	}
   101  
   102  	tests := []struct {
   103  		doc      string
   104  		in       KernelVersion
   105  		expected bool
   106  	}{
   107  		{
   108  			doc:      "same version",
   109  			in:       KernelVersion{v.Kernel, v.Major},
   110  			expected: true,
   111  		},
   112  		{
   113  			doc:      "kernel minus one",
   114  			in:       KernelVersion{v.Kernel - 1, v.Major},
   115  			expected: true,
   116  		},
   117  		{
   118  			doc:      "kernel plus one",
   119  			in:       KernelVersion{v.Kernel + 1, v.Major},
   120  			expected: false,
   121  		},
   122  		{
   123  			doc:      "major plus one",
   124  			in:       KernelVersion{v.Kernel, v.Major + 1},
   125  			expected: false,
   126  		},
   127  	}
   128  	for _, tc := range tests {
   129  		tc := tc
   130  		t.Run(tc.doc+": "+tc.in.String(), func(t *testing.T) {
   131  			ok, err := GreaterEqualThan(tc.in)
   132  			if err != nil {
   133  				t.Fatal("unexpected error:", err)
   134  			}
   135  			if ok != tc.expected {
   136  				t.Fatalf("expected: %v, got: %v", tc.expected, ok)
   137  			}
   138  		})
   139  	}
   140  }