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)
			}

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


        def actualText = reportText
        assert actualText == expectedReportContents
    }

	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 {

        @OptIn(KaAnalysisNonPublicApi::class)
        val actualText = analyseForTest(mainFile) {
            val snapshot = getExitPointSnapshot(statements)
            stringRepresentation(snapshot)
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(actualText)
    }

    private fun findStatements(mainFile: KtFile, textRange: TextRange): List<KtExpression> {

            val actualText = classSymbol.getSealedClassInheritors().joinToString("\n\n") { inheritor ->
                "${inheritor.classId!!}\n${inheritor.render(KaDeclarationRendererForDebug.WITH_QUALIFIED_NAMES)}"
            }

            testServices.assertions.assertEqualsToTestDataFileSibling(actualText)
        }
    }

		{pod: pods[1], status: &kubecontainer.PodStatus{}, error: statusErr},
	}
	for i, c := range cases {
		testStr := fmt.Sprintf("test[%d]", i)
		actualStatus, actualErr := pleg.cache.Get(c.pod.ID)
		assert.Equal(t, c.status, actualStatus, testStr)
		assert.Equal(t, c.error, actualErr, testStr)
	}
	// pleg should not generate any event for pods[1] because of the error.
	assert.Exactly(t, []*PodLifecycleEvent{events[0]}, actualEvents)

        analyze(mainFile) {
            val diagnostics = targetDeclaration.getDiagnostics(KaDiagnosticCheckerFilter.EXTENDED_AND_COMMON_CHECKERS)

            val actualText = buildString {
                if (diagnostics.isNotEmpty()) {
                    for (diagnostic in diagnostics) {
                        append(diagnostic.factoryName).append(": ")

        }
        if (errors.isNotEmpty()) {
            testServices.assertions.fail { errors.joinToString("\n") }
        }
        val actualText = actualTextBuilder.toString()
        if (actualText != originalText) {
            testServices.assertions.assertEqualsToFile(testDataPath, actualText)
        }
    }

    override fun configureTest(builder: TestConfigurationBuilder) {
        super.configureTest(builder)

		}
		if actualErr == nil && !testCase.shouldPass {
			t.Errorf("Test %d: %s: Expected to fail with <ERROR> \"%s\", but passed instead.", i+1, instanceType, testCase.expectedError.Error())
		}
		// Failed as expected, but does it fail for the expected reason.
		if actualErr != nil && !testCase.shouldPass {
			if testCase.expectedError.Error() != actualErr.Error() {