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

                .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()

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

	actualUtilizationRatio, actualCurrentUtilization, actualRawAverageValue, actualErr := GetResourceUtilizationRatio(tc.metrics, tc.requests, tc.targetUtilization)

	if tc.expectedErr != nil {
		assert.Error(t, actualErr, "there should be an error getting the utilization ratio")
		assert.Contains(t, fmt.Sprintf("%v", actualErr), fmt.Sprintf("%v", tc.expectedErr), "the error message should be as expected")
		return
	}

        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)

 */
abstract class AbstractVisibilityCheckerTest : AbstractAnalysisApiBasedTest() {
    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val actualText = analyseForTest(mainFile) {
            val declarationSymbol = getSingleTestTargetSymbolOfType<KaSymbolWithVisibility>(mainFile, testDataPath)

					rt.expectedObjectJSON,
					objBytes,
				)
			}

			if (actualErr != nil) != rt.expectedErr {
				t.Errorf(
					"failed HandleGetAction:\n\texpected error: %t\n\t  actual: %t %v",
					rt.expectedErr,
					(actualErr != nil),
					rt.action,
				)
			}
		})
	}