var actualKey []byte
			var actualCert []byte
			if certInfo != nil {
				actualKey = certInfo.Key
				actualCert = certInfo.Cert
			}
			if tt.key != string(actualKey) {
				t.Errorf("got key %q, wanted %q", string(actualKey), tt.key)
			}
			if tt.cert != string(actualCert) {
				t.Errorf("got cert %q, wanted %q", string(actualCert), tt.cert)
			}

			actualSpecified := test.specifiedFn(test.config)
			if actualSpecified != test.expectedSpecified {
				t.Error(actualSpecified)
			}

			actualCert, actualKey := test.filesFn(test.config)
			if actualCert != test.expectedCert {
				t.Error(actualCert)
			}
			if actualKey != test.expectedKey {
				t.Error(actualKey)
			}
		})
	}

		actualResult, actualErr := mapper.ResourceFor(schema.GroupVersionResource{})
		if e, a := tc.result, actualResult; e != a {
			t.Errorf("%s: expected %v, got %v", tc.name, e, a)
		}
		if len(tc.err) == 0 && actualErr == nil {
			continue
		}
		if len(tc.err) == 0 && actualErr != nil {
			t.Errorf("%s: unexpected err: %v", tc.name, actualErr)
			continue
		}

func TestErrorChannel(t *testing.T) {
	errCh := NewErrorChannel()

	if actualErr := errCh.ReceiveError(); actualErr != nil {
		t.Errorf("expect nil from err channel, but got %v", actualErr)
	}

	err := errors.New("unknown error")
	errCh.SendError(err)
	if actualErr := errCh.ReceiveError(); actualErr != err {
		t.Errorf("expect %v from err channel, but got %v", err, actualErr)
	}

	ctx, cancel := context.WithCancel(context.Background())

		},
	}

	for _, tc := range tcs {
		actualResult, actualErr := tc.mapper.ResourceFor(tc.input)
		if e, a := tc.result, actualResult; e != a {
			t.Errorf("%s: expected %v, got %v", tc.name, e, a)
		}
		switch {
		case tc.err == nil && actualErr == nil:
		case tc.err == nil:
			t.Errorf("%s: unexpected error: %v", tc.name, actualErr)
		case actualErr == nil:
			t.Errorf("%s: expected error: %v got nil", tc.name, tc.err)

			if actualHost != rt.expectedHost {
				t.Errorf("%s returned invalid host %s, expected %s", rt.name, actualHost, rt.expectedHost)
				return
			}

			if actualPort != rt.expectedPort {
				t.Errorf("%s returned invalid port %s, expected %s", rt.name, actualPort, rt.expectedPort)
			}
		})
	}
}

func TestParsePort(t *testing.T) {

	var tests = []struct {
		name          string
		port          string

                .sort()
                .join(PROBLEM_SEPARATOR)
                .replaceAll("\r\n", "\n")
                .replaceAll("\n+", "\n")


        def actualText = reportText
        assert actualText == expectedReportContents
    }

	// object with id filled.
	actualStatus, actualErr := cache.Get(podID)
	assert.Equal(t, status, actualStatus)
	assert.Equal(t, nil, actualErr)
}

func TestDelete(t *testing.T) {
	cache := &cache{pods: map[types.UID]*data{}}
	// Write a new pod status into the cache.
	podID, status := getTestPodIDAndStatus(3)
	cache.Set(podID, status, nil, time.Time{})
	actualStatus, actualErr := cache.Get(podID)

	expectedSet := sets.New[string]()
	for _, u := range expected {
		expectedSet.Insert(string(u))
	}
	actualSet := sets.New[string]()
	for _, u := range actual {
		actualSet.Insert(string(u))
	}
	if !expectedSet.Equal(actualSet) {
		t.Errorf("Expected %#v, got %#v", sets.List(expectedSet), sets.List(actualSet))
	}
}

func TestGetWork(t *testing.T) {
	q, clock := newTestBasicWorkQueue()

		objInfo, actualErr := obj.PutObject(context.Background(), testCase.bucketName, testCase.objName, in, ObjectOptions{UserDefined: testCase.inputMeta})
		if actualErr != nil && testCase.expectedError == nil {
			t.Errorf("Test %d: %s: Expected to pass, but failed with: error %s.", i, instanceType, actualErr.Error())
			continue
		}
		if actualErr == nil && testCase.expectedError != nil {