SecurityContext: &core.PodSecurityContext{
					Sysctls: []core.Sysctl{{
						Name:  "kernel.shmmni",
						Value: "32768",
					}, {
						Name:  "kernel.shmmax",
						Value: "1000000000",
					}, {
						Name:  "knet.ipv4.route.min_pmtu",
						Value: "1000",
					}},
				},
			},
		},
		"valid extended resources for init container": {

		currentReplicas:  2,
		expectedReplicas: 2,
		podPhase:         []v1.PodPhase{v1.PodRunning, v1.PodRunning, v1.PodRunning},
		metric: &metricInfo{
			name:          "qps",
			levels:        []int64{10000, 10000},
			targetUsage:   17000,
			expectedUsage: 10000,
			metricType:    podMetric,
		},
	}
	tc.runTest(t)
}

// TestComputedToleranceAlgImplementation is a regression test which

		medium: newPodInodeStats(medium, resource.MustParse("100000"), resource.MustParse("150000"), resource.MustParse("50000")), // 300000
		high:   newPodInodeStats(high, resource.MustParse("200000"), resource.MustParse("150000"), resource.MustParse("50000")),   // 400000
	}
	statsFn := func(pod *v1.Pod) (statsapi.PodStats, bool) {

			g.Expect(httpProtocolOptions.CommonHttpProtocolOptions.IdleTimeout).To(Not(BeNil()))
			g.Expect(httpProtocolOptions.CommonHttpProtocolOptions.IdleTimeout).To(Equal(durationpb.New(time.Duration(15000000000))))
		})
	}
}

// clusterTest defines a structure containing all information needed to build a cluster for tests
type clusterTest struct {
	// Required
	t                 testing.TB

pkg time, const RFC850 = "Monday, 02-Jan-06 15:04:05 MST"
pkg time, const RubyDate = "Mon Jan 02 15:04:05 -0700 2006"
pkg time, const Saturday = 6
pkg time, const Second = 1000000000
pkg time, const September = 9
pkg time, const Stamp = "Jan _2 15:04:05"
pkg time, const StampMicro = "Jan _2 15:04:05.000000"
pkg time, const StampMilli = "Jan _2 15:04:05.000"

type RangeAllocation struct {
	metav1.TypeMeta
	// +optional
	metav1.ObjectMeta
	// A string representing a unique label for a range of resources, such as a CIDR "10.0.0.0/8" or
	// port range "10000-30000". Range is not strongly schema'd here. The Range is expected to define
	// a start and end unless there is an implicit end.
	Range string

		expect: true,
	}, {
		name: "ClusterIPs_wrong",
		input: svcTestCase{
			svc:              svctest.MakeService("foo", svctest.SetTypeClusterIP, svctest.SetClusterIPs("10.0.0.0", "2000:0")),
			expectClusterIPs: true,
		},
		output: svctest.MakeService("foo", svctest.SetTypeClusterIP, svctest.SetClusterIPs("10.0.0.1", "2000:1")),
		expect: false,
	}, {
		name: "ClusterIPs_partial",

1024                int16       1024 is in the set of 16-bit integers
42.0                byte        42 is in the set of unsigned 8-bit integers
1e10                uint64      10000000000 is in the set of unsigned 64-bit integers
2.718281828459045   float32     2.718281828459045 rounds to 2.7182817 which is in the set of float32 values

	// difference in the resulting rounding. Therefore, we
	// preserve it, and OR (not ADD) it back in. The case
	// that matters is when the eleven discarded bits are
	// equal to 10000000001; that rounds up, and the 1 cannot
	// be lost else it would round down if the LSB of the
	// candidate mantissa is 0.
	cmp := s.newValue2(cvttab.leq, types.Types[types.TBOOL], s.zeroVal(ft), x)
	b := s.endBlock()

1024                int16       1024 is in the set of 16-bit integers
42.0                byte        42 is in the set of unsigned 8-bit integers
1e10                uint64      10000000000 is in the set of unsigned 64-bit integers
2.718281828459045   float32     2.718281828459045 rounds to 2.7182817 which is in the set of float32 values