github.com/cilium/ebpf@v0.15.0/internal/version_test.go (about)

     1  package internal
     2  
     3  import (
     4  	"os"
     5  	"testing"
     6  )
     7  
     8  func TestVersion(t *testing.T) {
     9  	a, err := NewVersion("1.2")
    10  	if err != nil {
    11  		t.Fatal(err)
    12  	}
    13  
    14  	b, err := NewVersion("2.2.1")
    15  	if err != nil {
    16  		t.Fatal(err)
    17  	}
    18  
    19  	if !a.Less(b) {
    20  		t.Error("A should be less than B")
    21  	}
    22  
    23  	if b.Less(a) {
    24  		t.Error("B shouldn't be less than A")
    25  	}
    26  
    27  	v200 := Version{2, 0, 0}
    28  	if !a.Less(v200) {
    29  		t.Error("1.2.1 should not be less than 2.0.0")
    30  	}
    31  
    32  	if v200.Less(a) {
    33  		t.Error("2.0.0 should not be less than 1.2.1")
    34  	}
    35  }
    36  
    37  func TestKernelVersion(t *testing.T) {
    38  	// Kernels 4.4 and 4.9 have a SUBLEVEL of over 255 and clamp it to 255.
    39  	// In our implementation, the other version segments are truncated.
    40  	if v, want := (Version{256, 256, 256}), uint32(255); v.Kernel() != want {
    41  		t.Errorf("256.256.256 should result in a kernel version of %d, got: %d", want, v.Kernel())
    42  	}
    43  
    44  	// Known good version.
    45  	if v, want := (Version{4, 9, 128}), uint32(264576); v.Kernel() != want {
    46  		t.Errorf("4.9.1 should result in a kernel version of %d, got: %d", want, v.Kernel())
    47  	}
    48  }
    49  
    50  func TestCurrentKernelVersion(t *testing.T) {
    51  	v, err := KernelVersion()
    52  	if err != nil {
    53  		t.Fatal(err)
    54  	}
    55  	if evStr := os.Getenv("KERNEL_VERSION"); evStr != "" {
    56  		ev, err := NewVersion(evStr)
    57  		if err != nil {
    58  			t.Fatal(err)
    59  		}
    60  		if ev[0] != v[0] || ev[1] != v[1] {
    61  			t.Errorf("expected kernel version %d.%d, got %d.%d", ev[0], ev[1], v[0], v[1])
    62  		}
    63  	}
    64  }
    65  
    66  func TestVersionFromCode(t *testing.T) {
    67  	var tests = []struct {
    68  		name string
    69  		code uint32
    70  		v    Version
    71  	}{
    72  		{"0.0.0", 0, Version{0, 0, 0}},
    73  		{"1.0.0", 0x10000, Version{1, 0, 0}},
    74  		{"4.4.255", 0x404ff, Version{4, 4, 255}},
    75  		{"255.255.255", 0xffffff, Version{255, 255, 255}},
    76  	}
    77  
    78  	for _, tt := range tests {
    79  		t.Run(tt.name, func(t *testing.T) {
    80  			v := NewVersionFromCode(tt.code)
    81  			if v != tt.v {
    82  				t.Errorf("unexpected version for code '%d'. got: %v, want: %v", tt.code, v, tt.v)
    83  			}
    84  		})
    85  	}
    86  }
    87  
    88  func TestKernelRelease(t *testing.T) {
    89  	r, err := KernelRelease()
    90  	if err != nil {
    91  		t.Fatal(err)
    92  	}
    93  
    94  	if r == "" {
    95  		t.Fatal("unexpected empty kernel release")
    96  	}
    97  }