}

	patchString := dedent.Dedent(`
	metadata:
	  annotations:
	    patched: "true"
	`)

	err = os.WriteFile(filepath.Join(patchesPath, kubeadmconstants.Etcd+".yaml"), []byte(patchString), 0644)
	if err != nil {
		t.Fatalf("WriteFile returned unexpected error: %v", err)
	}

	manifestPath := filepath.Join(tmpdir, kubeadmconstants.ManifestsSubDirName)

	// The types are not allocated at runtime.
	if hugeSink != nil {
		// 400MB on 32 bots, 4TB on 64-bits.
		const n = (400 << 20) + (unsafe.Sizeof(uintptr(0))-4)<<40
		hugeSink = new([n]*byte)
		hugeSink = new([n]uintptr)
		hugeSink = new(struct {
			x float64
			y [n]*byte
			z []string
		})
		hugeSink = new(struct {
			x float64
			y [n]uintptr

    stride_h = 1 : i32, stride_w = 1 : i32} : (
      tensor<?x5x5x2xf32>, tensor<3x5x5x2xf32>, tensor<3xf32>) -> tensor<?x1x1x3xf32>
  %4 = "quantfork.stats"(%3) {
    layerStats = dense<[0.0, 4.0]> : tensor<2xf32>
  } : (tensor<?x1x1x3xf32>) -> tensor<?x1x1x3xf32>
  %5 = "tfl.sqrt"(%4) : (tensor<?x1x1x3xf32>) -> tensor<?x1x1x3xf32>
  %6 = "quantfork.stats"(%5) {
    layerStats = dense<[0.0, 2.0]> : tensor<2xf32>

00000190  44 52 f0 08 26 4c b3 e7  71 b3 89 b3 5c 78 7e db  |DR..&L..q...\x~.|
000001a0  34 31 dc dc 7c 7d 28 e1  41 96 f4 2f 28 60 9f 5b  |41..|}(.A../(`.[|
000001b0  b2 2b 37 6b 3f 3a 37 e2  38 7a 66 40 fe 44 44 72  |.+7k?:7.8zf@.DDr|
000001c0  b4 e3 97 f3 db 73 c8 af  96 c8 a6 24 ef ea 34 8f  |.....s.....$..4.|
000001d0  5e 4b 21 22 19 d8 4a db  2e f1 23 90 d0 d2 38 f3  |^K!"..J...#...8.|

	}
	t.Parallel()

	d := t.TempDir()
	if err := WriteFile(filepath.Join(d, "control.txt"), []byte(string("Hello, world!")), 0644); err != nil {
		t.Fatal(err)
	}
	if err := WriteFile(filepath.Join(d, `e:xperi\ment.txt`), []byte(string("Hello, colon and backslash!")), 0644); err != nil {
		t.Fatal(err)
	}

	fsys := DirFS(d)
	err := fs.WalkDir(fsys, ".", func(path string, e fs.DirEntry, err error) error {

		if err != nil {
			fail(err)
		}
		fn := f.Name()
		f.Close()
		defer os.Remove(fn)

		if err := os.WriteFile(fn, []byte(gccgoSupportsCgoIncompleteCode), 0644); err != nil {
			fail(err)
		}

		on := strings.TrimSuffix(fn, ".go") + ".o"
		if cfg.BuildN || cfg.BuildX {
			sh.ShowCmd(tmpdir, "%s -c -o %s %s || true", tools.compiler(), on, fn)

  // CHECK-DAG: %[[OPERAND:.*]] = mhlo.uniform_quantize %arg0 : (tensor<3x2xf32>) -> tensor<3x2x!quant.uniform<i32:f32:1, {2.000000e+00:4,2.000000e+00:4}>>
  %0 = "tf.UniformQuantize"(%input, %scales, %zps) {
    quantization_axis = 1 : i64, quantization_min_val = -2147483648 : i64, quantization_max_val = 2147483647 : i64

        "dirPermissions"     | "dirPermissions { unix(\"0700\") }"               | "dirPermissions { unix(\"0755\") }"
        "filePermissions"    | "filePermissions { unix(\"0600\") }"              | "filePermissions { unix(\"0644\") }"
        "filteringCharset"   | "filteringCharset = 'iso8859-1'"                  | "filteringCharset = 'utf-8'"
    }

    def "null action is forbidden for #method"() {
        given:

            );
    ImmutableSet<String> nonIsatapAddresses =
        ImmutableSet.of(
            "::1.2.3.4",
            "3ffe::1",
            "::",
            "::1",
            "2001:db8::0040:5efe:102:304",
            "2001:db8::5ffe:102:304",
            "2001:db8::5eff:102:304",
            "2001:0:102:203:200:5efe:506:708" // Teredo address; not ISATAP
            );

	}

	if testing.Short() {
		t.Skip("skipping building a binary in short mode")
	}
	testenv.MustHaveGoRun(t)

	fn := filepath.Join(t.TempDir(), "x.go")
	if err := os.WriteFile(fn, []byte(testingProg), 0644); err != nil {
		t.Fatal(err)
	}

	cmd := testenv.Command(t, testenv.GoToolPath(t), "run", fn)
	out, err := cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("%v failed: %v\n%s", cmd, err, out)
	}