}
			var actualResponses []*drapbv1alpha3.NodeListAndWatchResourcesResponse
			var actualErr error
			for {
				resp, err := stream.Recv()
				if err != nil {
					actualErr = err
					break
				}
				actualResponses = append(actualResponses, resp)
			}
			assert.Equal(t, test.responses, actualResponses)
			assert.Contains(t, actualErr.Error(), test.expectError)
		})
	}

    }

    @Override
    public ExecutionResult assertContentContains(String actualText, String expectedOutput, String label) {
        String expectedText = LogContent.of(expectedOutput).withNormalizedEol();
        if (!actualText.contains(expectedText)) {
            if (!expectedText.contains("\n")) {
                Arrays.stream(actualText.split("\n"))
                    // Measure Levenshtein distance for each line

            val actualText = when (result) {
                is KaCompilationResult.Failure -> result.errors.joinToString("\n") { dumpDiagnostic(it) }
                is KaCompilationResult.Success -> dumpClassFiles(result.output)
            }

            testServices.assertions.assertEqualsToTestDataFileSibling(actualText)

            if (result is KaCompilationResult.Success) {

			actualUpgrades, actualErr := GetAvailableUpgrades(rt.vg, rt.allowExperimental, rt.allowRCs, client, &output.TextPrinter{})
			if diff := cmp.Diff(rt.expectedUpgrades, actualUpgrades); len(diff) > 0 {
				t.Errorf("failed TestGetAvailableUpgrades\n\texpected upgrades:\n%v\n\tgot:\n%v\n\tdiff:\n%v", rt.expectedUpgrades, actualUpgrades, diff)
			}
			if rt.errExpected && actualErr == nil {
				t.Error("unexpected success")

			expectedAPIErr: toAPIErrorCode(GlobalContext, errDiskNotFound),
		},
	}

	for i, test := range testCases {
		actualErr := toAdminAPIErrCode(GlobalContext, test.err)
		if actualErr != test.expectedAPIErr {
			t.Errorf("Test %d: Expected %v but received %v",
				i+1, test.expectedAPIErr, actualErr)
		}
	}
}

func TestExtractHealInitParams(t *testing.T) {

			}
			_, actualErr := xl.DeleteObject(ctx, test.bucket, test.object, ObjectOptions{})
			if test.expectedErr != nil && actualErr != test.expectedErr {
				t.Errorf("Expected to fail with %s, but failed with %s", test.expectedErr, actualErr)
			}
			if test.expectedErr == nil && actualErr != nil {
				t.Errorf("Expected to pass, but failed with %s", actualErr)
			}
		})
	}

				}
			}

			actualErr := StaticPodControlPlane(
				nil,
				waiter,
				pathMgr,
				newcfg,
				true,
				true,
				fakeTLSEtcdClient{
					TLS: false,
				},
				fakePodManifestEtcdClient{
					ManifestDir:     pathMgr.RealManifestDir(),
					CertificatesDir: newcfg.CertificatesDir,
				},
			)
			if (actualErr != nil) != rt.expectedErr {
				t.Errorf(

			}
			claims := tc.claims
			if claims == nil {
				claims = claimList{}
			}
			actualResources, actualErr := newResourceModel(tCtx.Logger(), slices, claims, &inFlightAllocations)

			if actualErr != nil {
				if !tc.wantErr {
					tCtx.Fatalf("unexpected error: %v", actualErr)
				}
				return
			}
			if tc.wantErr {
				tCtx.Fatalf("did not get expected error")
			}

	expectedErr := fmt.Errorf("deadline error")
	tc = &tunnelingWebsocketUpgraderConn{conn: &mockConn{deadlineErr: expectedErr}}
	expected = time.Now()
	actualErr := tc.SetDeadline(expected)
	assert.Equal(t, expectedErr, actualErr, "SetDeadline() expected error returned")
	// Connection nil, returns nil error.
	tc.conn = nil

			Error:              test.err,
		}
		actual, actualErr := GetDeletableResources(logger, client)
		if !reflect.DeepEqual(test.deletableResources, actual) {
			t.Errorf("expected resources:\n%v\ngot:\n%v", test.deletableResources, actual)
		}
		if !reflect.DeepEqual(test.err, actualErr) {
			t.Errorf("expected error:\n%v\ngot:\n%v", test.err, actualErr)
		}
	}
}