github.com/cilium/ebpf@v0.10.0/internal/testutils/feature.go (about)

     1  package testutils
     2  
     3  import (
     4  	"errors"
     5  	"os"
     6  	"testing"
     7  
     8  	"github.com/cilium/ebpf/internal"
     9  )
    10  
    11  func MustKernelVersion() internal.Version {
    12  	v, err := internal.KernelVersion()
    13  	if err != nil {
    14  		panic(err)
    15  	}
    16  	return v
    17  }
    18  
    19  func CheckFeatureTest(t *testing.T, fn func() error) {
    20  	checkFeatureTestError(t, fn())
    21  }
    22  
    23  func checkFeatureTestError(t *testing.T, err error) {
    24  	if err == nil {
    25  		return
    26  	}
    27  
    28  	var ufe *internal.UnsupportedFeatureError
    29  	if errors.As(err, &ufe) {
    30  		checkKernelVersion(t, ufe)
    31  	} else {
    32  		t.Error("Feature test failed:", err)
    33  	}
    34  }
    35  
    36  func CheckFeatureMatrix[K comparable](t *testing.T, fm internal.FeatureMatrix[K]) {
    37  	t.Helper()
    38  
    39  	for key, ft := range fm {
    40  		t.Run(ft.Name, func(t *testing.T) {
    41  			checkFeatureTestError(t, fm.Result(key))
    42  		})
    43  	}
    44  }
    45  
    46  func SkipIfNotSupported(tb testing.TB, err error) {
    47  	tb.Helper()
    48  
    49  	if err == internal.ErrNotSupported {
    50  		tb.Fatal("Unwrapped ErrNotSupported")
    51  	}
    52  
    53  	var ufe *internal.UnsupportedFeatureError
    54  	if errors.As(err, &ufe) {
    55  		checkKernelVersion(tb, ufe)
    56  		tb.Skip(ufe.Error())
    57  	}
    58  	if errors.Is(err, internal.ErrNotSupported) {
    59  		tb.Skip(err.Error())
    60  	}
    61  }
    62  
    63  func checkKernelVersion(tb testing.TB, ufe *internal.UnsupportedFeatureError) {
    64  	if ufe.MinimumVersion.Unspecified() {
    65  		return
    66  	}
    67  
    68  	kernelVersion := MustKernelVersion()
    69  	if ufe.MinimumVersion.Less(kernelVersion) {
    70  		tb.Helper()
    71  		tb.Fatalf("Feature '%s' isn't supported even though kernel %s is newer than %s",
    72  			ufe.Name, kernelVersion, ufe.MinimumVersion)
    73  	}
    74  }
    75  
    76  func SkipOnOldKernel(tb testing.TB, minVersion, feature string) {
    77  	tb.Helper()
    78  
    79  	if IsKernelLessThan(tb, minVersion) {
    80  		tb.Skipf("Test requires at least kernel %s (due to missing %s)", minVersion, feature)
    81  	}
    82  }
    83  
    84  func IsKernelLessThan(tb testing.TB, minVersion string) bool {
    85  	tb.Helper()
    86  
    87  	minv, err := internal.NewVersion(minVersion)
    88  	if err != nil {
    89  		tb.Fatalf("Invalid version %s: %s", minVersion, err)
    90  	}
    91  
    92  	if max := os.Getenv("CI_MAX_KERNEL_VERSION"); max != "" {
    93  		maxv, err := internal.NewVersion(max)
    94  		if err != nil {
    95  			tb.Fatalf("Invalid version %q in CI_MAX_KERNEL_VERSION: %s", max, err)
    96  		}
    97  
    98  		if maxv.Less(minv) {
    99  			tb.Fatalf("Test for %s will never execute on CI since %s is the most recent kernel", minv, maxv)
   100  		}
   101  	}
   102  
   103  	return MustKernelVersion().Less(minv)
   104  }