ApplyOOMScoreAdj:          fakeApplyOOMScoreAdj,
		ApplyOOMScoreAdjContainer: fakeApplyOOMScoreAdjContainer,
	}
}

func fakeApplyOOMScoreAdj(pid int, oomScoreAdj int) error {
	return nil
}

func fakeApplyOOMScoreAdjContainer(cgroupName string, oomScoreAdj, maxTries int) error {
	return nil

			highOOMScoreAdj: -997,
		},
	}
	for _, test := range oomTests {
		oomScoreAdj := GetContainerOOMScoreAdjust(test.pod, &test.pod.Spec.Containers[0], test.memoryCapacity)
		if oomScoreAdj < test.lowOOMScoreAdj || oomScoreAdj > test.highOOMScoreAdj {
			t.Errorf("oom_score_adj should be between %d and %d, but was %d", test.lowOOMScoreAdj, test.highOOMScoreAdj, oomScoreAdj)
		}
	}

		ApplyOOMScoreAdjContainer: unsupportedApplyOOMScoreAdjContainer,
	}
}

func unsupportedApplyOOMScoreAdj(pid int, oomScoreAdj int) error {
	return unsupportedErr
}

func unsupportedApplyOOMScoreAdjContainer(cgroupName string, oomScoreAdj, maxTries int) error {
	return unsupportedErr

func applyOOMScoreAdj(pid int, oomScoreAdj int) error {
	if pid < 0 {
		return fmt.Errorf("invalid PID %d specified for oom_score_adj", pid)
	}

	var pidStr string
	if pid == 0 {
		pidStr = "self"
	} else {
		pidStr = strconv.Itoa(pid)
	}

	maxTries := 2
	oomScoreAdjPath := path.Join("/proc", pidStr, "oom_score_adj")
	value := strconv.Itoa(oomScoreAdj)

type OOMAdjuster struct {
	pidLister                 func(cgroupName string) ([]int, error)
	ApplyOOMScoreAdj          func(pid int, oomScoreAdj int) error
	ApplyOOMScoreAdjContainer func(cgroupName string, oomScoreAdj, maxTries int) error

			[]v1.ContainerStatus{},
			&runtimeapi.LinuxContainerResources{CpuShares: 256, MemoryLimitInBytes: 786432000, OomScoreAdj: 970},
		},
		{
			"best-effort qos - no container status",
			true,
			nil,
			nil,
			[]v1.ContainerStatus{},
			&runtimeapi.LinuxContainerResources{CpuShares: 2, OomScoreAdj: 1000},
		},
		{
			"requests & limits, cpu & memory, guaranteed qos - empty resources container status",
			true,

      infoBufferSize: "0"
  verbosity: 0
metricsBindAddress: 127.0.0.1:10249
mode: ""
nftables:
  masqueradeAll: false
  masqueradeBit: 14
  minSyncPeriod: 1s
  syncPeriod: 30s
nodePortAddresses: null
oomScoreAdj: -999
portRange: ""
showHiddenMetricsForVersion: ""
winkernel:
  enableDSR: false
  forwardHealthCheckVip: false
  networkName: ""
  rootHnsEndpointName: ""

	allErrs = append(allErrs, validateClientConnectionConfiguration(config.ClientConnection, newPath.Child("ClientConnection"))...)

	if config.OOMScoreAdj != nil && (*config.OOMScoreAdj < -1000 || *config.OOMScoreAdj > 1000) {
		allErrs = append(allErrs, field.Invalid(newPath.Child("OOMScoreAdj"), *config.OOMScoreAdj, "must be within the range [-1000, 1000]"))
	}

	if config.ConfigSyncPeriod.Duration <= 0 {

	out.DetectLocal = in.DetectLocal
	if in.NodePortAddresses != nil {
		in, out := &in.NodePortAddresses, &out.NodePortAddresses
		*out = make([]string, len(*in))
		copy(*out, *in)
	}
	if in.OOMScoreAdj != nil {
		in, out := &in.OOMScoreAdj, &out.OOMScoreAdj
		*out = new(int32)
		**out = **in
	}
	in.Conntrack.DeepCopyInto(&out.Conntrack)
	out.ConfigSyncPeriod = in.ConfigSyncPeriod
	return
}

					MasqueradeBit: ptr.To[int32](14),
					MasqueradeAll: false,
					SyncPeriod:    metav1.Duration{Duration: 30 * time.Second},
					MinSyncPeriod: metav1.Duration{Duration: 1 * time.Second},
				},
				OOMScoreAdj: &oomScore,
				Conntrack: kubeproxyconfigv1alpha1.KubeProxyConntrackConfiguration{
					MaxPerCore:            &ctMaxPerCore,
					Min:                   &ctMin,