NamespaceScoped: tt.NamespaceScoped,
				Subresource:     tt.Subresource,
			}
			_, err := modifier.Replace(tt.Namespace, "foo", tt.Overwrite, tt.Object)
			if (err != nil) != tt.Err {
				t.Fatalf("unexpected error: %t %v", tt.Err, err)
			}
			if err != nil {
				return
			}
			if tt.Req != nil && (client.Req == nil || !tt.Req(tt.ExpectPath, client.Req)) {
				t.Fatalf("unexpected request: %#v", client.Req)
			}

			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := NewIAMRoleARN(tt.args.resourceID, tt.args.serverRegion)
			if (err != nil) != tt.wantErr {
				t.Errorf("NewIAMRoleARN() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("NewIAMRoleARN() got = %v, want %v", got, tt.want)
			}
		})
	}
}

		},
	}

	for idx, tt := range tests {
		t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
			// Save a copy to report errors with
			tmp := make(host.Names, len(tt.in))
			copy(tmp, tt.in)

			sort.Sort(tt.in)
			if !reflect.DeepEqual(tt.in, tt.want) {
				t.Fatalf("sort.Sort(%v) = %v, want %v", tmp, tt.in, tt.want)
			}
		})
	}
}

	case "plan9", "windows", "js", "wasip1":
		t.Skipf("not supported on %s", runtime.GOOS)
	}

	for _, tt := range fileConnTests {
		if !testableNetwork(tt.network) {
			t.Logf("skipping %s test", tt.network)
			continue
		}

		var network, address string
		switch tt.network {
		case "udp":
			c := newLocalPacketListener(t, tt.network)
			defer c.Close()
			network = c.LocalAddr().Network()
			address = c.LocalAddr().String()

		},
	}

	for _, tt := range tests {
		t.Run(tt.desc, func(t *testing.T) {
			root := make(map[string]any)
			err := yaml.Unmarshal([]byte(tt.yamlStr), &root)
			if err != nil {
				t.Fatalf("yaml.Unmarshal(%s): got error %s", tt.desc, err)
			}
			errs := CheckValues(util.MustStruct(root))
			if gotErr, wantErr := errs, tt.wantErrs; !util.EqualErrors(gotErr, wantErr) {

			output:      "",
			errExpected: true,
		},
	}
	for _, tt := range tmplTests {
		t.Run(tt.name, func(t *testing.T) {
			outbytes, err := ParseTemplate(tt.template, tt.data)
			if tt.errExpected != (err != nil) {
				t.Errorf(
					"failed TestParseTemplate:\n\texpected err: %t\n\t  actual: %s",
					tt.errExpected,
					err,
				)
			}
			if tt.output != string(outbytes) {
				t.Errorf(

		},
	}
	for _, tt := range tests {
		t.Run(tt.desc, func(t *testing.T) {
			if tt.startRender {
				err := tt.objFileTemplateReader.Run()
				if err != nil && tt.wantErr != nil {
					if err.Error() != tt.wantErr.Error() {
						t.Errorf("%s: expected err: %q got %q", tt.desc, tt.wantErr.Error(), err.Error())
					}
				}
			}

	}

	var gcpEnvVar Environment
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			shouldFillMetadata, projectIDFn, numericProjectIDFn, clusterLocationFn, clusterNameFn,
				instanceNameFn, instanceIDFn, instanceTemplateFn, createdByFn = tt.shouldFill, tt.projectIDFn,
				tt.numericProjectIDFn, tt.locationFn, tt.clusterNameFn, tt.instanceNameFn, tt.instanceIDFn, tt.instanceTemplateFn, tt.instanceCreatedByFn

		},
	}
	for _, tt := range cases {
		t.Run(tt.name, func(t *testing.T) {
			dockerCred, err := sc.GetDockerCredential(tt.name, tt.namespace)
			if tt.expectedDockerCred != "" && tt.expectedDockerCred != string(dockerCred) {
				t.Errorf("got docker credential %q, want %q", string(dockerCred), tt.expectedDockerCred)
			}
			if tt.expectedDockerError != "" && tt.expectedDockerError != errString(err) {

}

func testRead(t *testing.T, tests []readTest, read func(io.Reader) ([]byte, error)) {
	for i, tt := range tests {
		var in, testOut string
		j := strings.Index(tt.in, "ℙ")
		if j < 0 {
			in = tt.in
			testOut = tt.in
		} else {
			in = tt.in[:j] + tt.in[j+len("ℙ"):]
			testOut = tt.in[:j]
		}
		d := strings.Index(tt.in, "𝔻")
		if d >= 0 {
			in = in[:d] + in[d+len("𝔻"):]
			testOut = testOut[d+len("𝔻"):]