_ = 0x12_34.P1_2_3
	_ = 0X1_2_3_4.P-1_2_3

	// imaginaries
	_ = 0i
	_ = 00i
	_ = 08i
	_ = 0000000000i
	_ = 0123i
	_ = 0000000123i
	_ = 0000056789i
	_ = 1234i
	_ = 1234567i

	_ = 0i
	_ = 0_0i
	_ = 0_8i
	_ = 0_000_000_000i
	_ = 0_123i
	_ = 0_000_000_123i
	_ = 0_000_056_789i
	_ = 1_234i
	_ = 1_234_567i

	_ = 0.i
	_ = 123.i
	_ = 0123.i

	_	= 0x12_34.P1_2_3
	_	= 0X1_2_3_4.P-1_2_3

	// imaginaries
	_	= 0i
	_	= 00i
	_	= 08i
	_	= 0000000000i
	_	= 0123i
	_	= 0000000123i
	_	= 0000056789i
	_	= 1234i
	_	= 1234567i

	_	= 0i
	_	= 0_0i
	_	= 0_8i
	_	= 0_000_000_000i
	_	= 0_123i
	_	= 0_000_000_123i
	_	= 0_000_056_789i
	_	= 1_234i
	_	= 1_234_567i

	_	= 0.i
	_	= 123.i
	_	= 0123.i

    // Test many non-escaped characters.
    s =
        "!@#$%^*()_+=-/?\\|]}[{,.;:"
            + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
            + "1234567890";
    assertSame(s, htmlEscaper().escape(s));
  }

        given:
        WorkerConfig original = new WorkerConfig(
            LogLevel.ERROR,
            true,
            "/path/to/user/home",
            new MultiChoiceAddress(new UUID(123, 456), 789, [InetAddress.getByName("example.com")]),
            987,
            "name",
            new TestAction("value"),
            NativeServicesMode.ENABLED
        )

        when:

	C  byte
	P2 [7]byte
	P3 struct {
		F [8]float32
	}
}

func TestBlankFields(t *testing.T) {
	for _, enc := range encoders {
		t.Run(enc.name, func(t *testing.T) {
			b1 := BlankFields{A: 1234567890, B: 2.718281828, C: 42}
			buf, err := enc.fn(LittleEndian, &b1)
			if err != nil {
				t.Error(err)
			}

			// zero values must have been written for blank fields
			var p BlankFieldsProbe

		t.Skip("skipping test in short mode.")
	}

	testKubelet := newTestKubelet(t, false /* controllerAttachDetachEnabled */)
	defer testKubelet.Cleanup()
	kubelet := testKubelet.kubelet

	pod := podWithUIDNameNsSpec("12345678", "foo", "test", v1.PodSpec{
		Containers: []v1.Container{
			{
				Name: "container1",
				VolumeMounts: []v1.VolumeMount{
					{
						Name:      "vol1",
						MountPath: "/mnt/vol1",
					},
					{

		{
			pod:             &noRequestLimit,
			memoryCapacity:  4000000000,
			lowOOMScoreAdj:  1000,
			highOOMScoreAdj: 1000,
		},
		{
			pod:             &equalRequestLimitCPUMemory,
			memoryCapacity:  123456789,
			lowOOMScoreAdj:  -997,
			highOOMScoreAdj: -997,
		},
		{
			pod:             &cpuUnlimitedMemoryLimitedWithRequests,
			memoryCapacity:  standardMemoryAmount,
			lowOOMScoreAdj:  495,

	_, imageService, m, err := createTestRuntimeManager()
	assert.NoError(t, err)

	runAsUser := int64(1000)
	runAsGroup := int64(2000)
	pod := &v1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			UID:       "12345678",
			Name:      "bar",
			Namespace: "new",
		},
		Spec: v1.PodSpec{
			Containers: []v1.Container{
				{
					Name:            "foo",
					Image:           "busybox",

					test.in, s, test.out)
			}
		}
	}

	// Override when base is illegal
	defer func() {
		if r := recover(); r == nil {
			t.Fatalf("expected panic due to illegal base")
		}
	}()
	FormatUint(12345678, 1)
}

type uitob64Test struct {
	in   uint64
	base int
	out  string
}

var uitob64tests = []uitob64Test{
	{1<<63 - 1, 10, "9223372036854775807"},
	{1 << 63, 10, "9223372036854775808"},

				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
				{Type: v1.NodeHostName, Address: testKubeletHostname},
			},
			expectedAddresses: []v1.NodeAddress{
				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
				{Type: v1.NodeHostName, Address: testKubeletHostname},
			},
			shouldError: false,
		},