SystemReservedEnforcementKey  = "system-reserved"
	KubeReservedEnforcementKey    = "kube-reserved"
	NodeAllocatableNoneKey        = "none"
)

// SwapBehavior types
const (
	LimitedSwap = "LimitedSwap"
	NoSwap      = "NoSwap"

			// https://github.com/kubernetes/kubernetes/issues/125137
			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
		}

		{
			name:                       "Swap disabled on node, NodeSwap feature gate turned off, cgroups v2, LimitedSwap",
			swapDisabledOnNode:         true,
			cgroupVersion:              cgroupV2,
			qosClass:                   v1.PodQOSBurstable,
			nodeSwapFeatureGateEnabled: false,
			swapBehavior:               types.LimitedSwap,
		},

		// With no swapBehavior, NoSwap should be the default
		{

			if testCase.tmpfsNoswapSupported && !doesStringArrayContainSubstring(options, swap.TmpfsNoswapOption) {
				t.Errorf("tmpfs noswap option is expected when supported. options: %v", options)
			}
			if !testCase.tmpfsNoswapSupported && doesStringArrayContainSubstring(options, swap.TmpfsNoswapOption) {
				t.Errorf("tmpfs noswap option is not expected when unsupported. options: %v", options)
			}

		}
	}
	if localFeatureGate.Enabled(features.NodeSwap) {
		switch kc.MemorySwap.SwapBehavior {
		case "":
		case kubetypes.NoSwap:
		case kubetypes.LimitedSwap:
		default:
			allErrors = append(allErrors, fmt.Errorf("invalid configuration: memorySwap.swapBehavior %q must be one of: \"\", %q or %q", kc.MemorySwap.SwapBehavior, kubetypes.LimitedSwap, kubetypes.NoSwap))
		}
	}

		}
	}

	return lcr
}

// configureContainerSwapResources configures the swap resources for a specified (linux) container.
// Swap is only configured if a swap cgroup controller is available and the NodeSwap feature gate is enabled.
func (m *kubeGenericRuntimeManager) configureContainerSwapResources(lcr *runtimeapi.LinuxContainerResources, pod *v1.Pod, container *v1.Container) {

				IPTablesDropBit:                           utilpointer.Int32(1),
				FailSwapOn:                                utilpointer.Bool(true),
				MemorySwap:                                v1beta1.MemorySwapConfiguration{SwapBehavior: "NoSwap"},
				ContainerLogMaxSize:                       "1Mi",
				ContainerLogMaxFiles:                      utilpointer.Int32(1),
				ContainerLogMaxWorkers:                    utilpointer.Int32(1),

			conf.FeatureGates = map[string]bool{"NodeSwap": true}
			conf.MemorySwap.SwapBehavior = "invalid-behavior"
			return conf
		},
		errMsg: "invalid configuration: memorySwap.swapBehavior \"invalid-behavior\" must be one of: \"\", \"LimitedSwap\" or \"NoSwap\"",
	}, {
		name: "specify MemorySwap.SwapBehavior without enabling NodeSwap",

				// This is just a log because we are using a default of NoSwap.
				klog.InfoS("NoSwap is set due to memorySwapBehavior not specified", "memorySwapBehavior", s.MemorySwap.SwapBehavior, "FailSwapOn", s.FailSwapOn)
			}
		}

		kubeDeps.ContainerManager, err = cm.NewContainerManager(
			kubeDeps.Mounter,
			kubeDeps.CAdvisorInterface,
			cm.NodeConfig{
				NodeName:              nodeName,

	}

	isSwapOn, err := swap.IsSwapOn()
	if err != nil {
		return nil, fmt.Errorf("failed to determine if swap is on: %w", err)
	}

	if isSwapOn {
		if failSwapOn {
			return nil, fmt.Errorf("running with swap on is not supported, please disable swap or set --fail-swap-on flag to false")
		}

		if !swap.IsTmpfsNoswapOptionSupported(mountUtil, nodeConfig.KubeletRootDir) {