t.Run(tc.name, func(t *testing.T) {
			kernelVersion, err := getVersion(tc.readFileFunc)

			if tc.err != nil {
				assert.Equal(t, tc.err.Error(), err.Error())
				assert.Nil(t, kernelVersion)
			} else {
				assert.NoError(t, err)
				assert.Equal(t, tc.expected.Major(), kernelVersion.Major())
				assert.Equal(t, tc.expected.Minor(), kernelVersion.Minor())
				assert.Equal(t, tc.expected.Patch(), kernelVersion.Patch())

				"net.ipv4.tcp_syncookies",
				"net.ipv4.ping_group_range",
				"net.ipv4.ip_unprivileged_port_start",
				"net.ipv4.ip_local_reserved_ports",
			},
		},
		{
			name: "kernelVersion is 5.15.0, return safeSysctls with no kernelVersion limit and kernelVersion below 5.15.0",
			getVersion: func() (*version.Version, error) {
				kernelVersionStr := "5.15.0-75-generic"
				return version.ParseGeneric(kernelVersionStr)
			},
			want: []string{

	Sysname  [257]byte
	Nodename [257]byte
	Release  [257]byte
	Version  [257]byte
	Machine  [257]byte
}

// KernelVersion returns major and minor kernel version numbers
// parsed from the syscall.Uname's Version field, or (0, 0) if the
// version can't be obtained or parsed.
func KernelVersion() (major int, minor int) {
	var un utsname

	kernelVersion, err := getVersion()
	if err != nil {
		klog.ErrorS(err, "failed to get kernel version, unable to determine which sysctls are available")
	}

	var safeSysctlAllowlist []string
	for _, sc := range safeSysctls {
		if sc.kernel == "" {
			safeSysctlAllowlist = append(safeSysctlAllowlist, sc.name)
			continue
		}

// license that can be found in the LICENSE file.

package unix

import (
	"syscall"
)

// KernelVersion returns major and minor kernel version numbers, parsed from
// the syscall.Uname's Release field, or 0, 0 if the version can't be obtained
// or parsed.
//
// Currently only implemented for Linux.
func KernelVersion() (major, minor int) {
	var uname syscall.Utsname
	if err := syscall.Uname(&uname); err != nil {
		return
	}

	MachineID               *string `json:"machineID,omitempty"`
	SystemUUID              *string `json:"systemUUID,omitempty"`
	BootID                  *string `json:"bootID,omitempty"`
	KernelVersion           *string `json:"kernelVersion,omitempty"`
	OSImage                 *string `json:"osImage,omitempty"`
	ContainerRuntimeVersion *string `json:"containerRuntimeVersion,omitempty"`

		memoryPrivWorkingSetBytes: 1234,
		memoryCommittedBytes:      12345,
		timeStamp:                 timeStamp,
	}, nil
}

func (f fakeWinNodeStatsClient) getNodeInfo() nodeInfo {
	return nodeInfo{
		kernelVersion:               "v42",
		memoryPhysicalCapacityBytes: 1.6e+10,
	}
}
func (f fakeWinNodeStatsClient) getMachineInfo() (*cadvisorapi.MachineInfo, error) {
	return &cadvisorapi.MachineInfo{
		NumCores:       4,

	gotAccept4 := unix.SupportAccept4()
	if wantAccept4 != gotAccept4 {
		t.Fatalf("SupportAccept4, got %t; want %t", gotAccept4, wantAccept4)
	}

	// Test that the version returned by KernelVersion matches expectations.
	major, minor := unix.KernelVersion()
	t.Logf("Kernel version: %d.%d", major, minor)
	if runtime.GOOS == "illumos" {
		if gotSock && gotAccept4 && (major < 5 || (major == 5 && minor < 11)) {

	if err != nil {
		return nil, fmt.Errorf("failed to read os-release file: %s", err.Error())
	}

	kernelVersion, err := version.ParseGeneric(strings.TrimSpace(string(fileContent)))
	if err != nil {
		return nil, fmt.Errorf("failed to parse kernel version: %s", err.Error())
	}

	return kernelVersion, nil

// license that can be found in the LICENSE file.

package net

import (
	"internal/syscall/unix"
	"testing"
)

func TestMaxAckBacklog(t *testing.T) {
	n := 196602
	major, minor := unix.KernelVersion()
	backlog := maxAckBacklog(n)
	expected := 1<<16 - 1
	if major > 4 || (major == 4 && minor >= 1) {
		expected = n
	}
	if backlog != expected {