return AnalysisContext(
            DefaultAnalysisSchema(
                DefaultDataClass(DefaultFqName("", ""), emptySet(), emptyList(), emptyList(), emptyList()),
                emptyMap(),
                emptyMap(),
                emptyMap(),
                emptySet()
            ),
            emptyMap(),
            errorCollector,
            DefaultOperationGenerationId.finalEvaluation
        )

        @Override
        public Set<Task> getTasks() {
            return Collections.emptySet();
        }

        @Override
        public Set<Task> getRequestedTasks() {
            return Collections.emptySet();
        }

        @Override
        public Set<Task> getFilteredTasks() {
            return Collections.emptySet();
        }

        @Override
        public int size() {
            return 0;

        return null;
    }

    @Override
    public List<ResolvedVariantResult> getResolvedVariants() {
        return Collections.emptyList();
    }

    @Override
    public List<ResolvedVariantResult> getAllVariants() {
        return Collections.emptyList();
    }

    @Override
    public ResolutionState getResolutionState() {
        return ResolutionState.UNRESOLVED;
    }

    @Override

        if (kotlinFile.packageFqName != packageFqName) {
            return emptyList()
        }

        return listOf(kotlinFile)
    }

    override fun findFilesForFacade(facadeFqName: FqName): Collection<KtFile> {
        if (kotlinFile.javaFileFacadeFqName != facadeFqName) return emptyList()

        for (declaration in topLevelDeclarations) {

        fe10Annotations.hasAnnotation(classId.asSingleFqName())
    }

    override fun get(classId: ClassId): List<KaAnnotation> = withValidityAssertion {
        if (classId in ignoredAnnotations) return@withValidityAssertion emptyList()

        fe10Annotations.mapIndexedNotNull { index, annotation ->
            if (annotation.classIdForAnnotation != classId) {
                return@mapIndexedNotNull null
            }

        return disambiguationRule;
    }

    @Override
    public List<AttributeDescriber> getConsumerDescribers() {
        return Collections.emptyList();
    }

    @Override
    public void addConsumerDescriber(AttributeDescriber describer) {
        throw new UnsupportedOperationException();
    }

    @Override

        return false
    }

    override fun get(classId: ClassId): List<KaAnnotation> = withValidityAssertion {
        return emptyList()
    }

    override val classIds: Set<ClassId>
        get() = withValidityAssertion { emptySet() }

            is ErrorType -> return emptySet()
            is CapturedType, is NewCapturedType -> return constructor.supertypes.flatMapTo(mutableSetOf()) { it.collectLowerBounds() }
            is SimpleType -> {
                val typeParameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(this)
                if (typeParameterDescriptor != null) {
                    return emptySet()
                }

        def action = new TestExecutionRequestAction(new BuildEventSubscriptions([OperationType.TASK] as Set), startParameter, Collections.emptySet(), Collections.emptySet(), Collections.emptySet(), new DefaultDebugOptions(), Collections.emptyMap(), false, Collections.emptyList())

        expect:
        def result = serialize(action, BuildActionSerializer.create())
        result instanceof TestExecutionRequestAction

            }

            @Override
            protected List<PerformanceReportScenario> getCrossBuildScenarios() {
                return Collections.emptyList();
            }

            @Override
            protected String determineScenarioBackgroundColorCss(PerformanceReportScenario scenario) {
                return isFlaky(scenario) ? "alert-warning" : "alert-info";