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
		}

	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

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !linux && !solaris

package unix

func KernelVersion() (major int, minor int) {
	return 0, 0

      Port: 1
  images:
  - names:
    - namesValue
    sizeBytes: 2
  nodeInfo:
    architecture: architectureValue
    bootID: bootIDValue
    containerRuntimeVersion: containerRuntimeVersionValue
    kernelVersion: kernelVersionValue
    kubeProxyVersion: kubeProxyVersionValue
    kubeletVersion: kubeletVersionValue
    machineID: machineIDValue
    operatingSystem: operatingSystemValue
    osImage: osImageValue

	assert.NotZero(t, id)
}

func TestGetVersionInfo(t *testing.T) {
	client := perfCounterNodeStatsClient{
		nodeInfo: nodeInfo{
			kernelVersion:  "foo",
			osImageVersion: "lish",
		},
	}

	info, _ := client.getVersionInfo()
	expected := &cadvisorapi.VersionInfo{
		KernelVersion:      "foo",
		ContainerOsVersion: "lish",
	}
	assert.Equal(t, expected, info)
}

func TestCollectMetricsData(t *testing.T) {

			klog.InfoS("Running under a user namespace - tmpfs noswap is not supported")
			return false
		}

		kernelVersion, err := utilkernel.GetVersion()
		if err != nil {
			klog.ErrorS(err, "cannot determine kernel version, unable to determine is tmpfs noswap is supported")
			return false
		}

		if kernelVersion.AtLeast(version.MustParseGeneric(utilkernel.TmpfsNoswapSupportKernelVersion)) {
			return true
		}