return Collections.emptySet();
  }

  protected Collection<Method> suppressForCheckedSortedMap() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForEmptyMap() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForSingletonMap() {
    return Collections.emptySet();
  }

public class Lifecycles {

    static Lifecycle.Phase phase(String name) {
        return new DefaultPhase(name, Collections.emptyList(), Collections.emptyList());
    }

    static Lifecycle.Phase phase(String name, Plugin plugin) {
        return new DefaultPhase(name, Collections.singletonList(plugin), Collections.emptyList());
    }

    static Plugin plugin(String coord, String phase) {
        String[] c = coord.split(":");

        given:
        def results1 = new DefaultVisitedGraphResults(resolutionResult, Collections.emptySet(), null)
        def results2 = new DefaultVisitedGraphResults(resolutionResult, Collections.singleton(Mock(UnresolvedDependency)), null)
        def results3 = new DefaultVisitedGraphResults(resolutionResult, Collections.emptySet(), Mock(ResolveException))

        expect:
        !results1.hasAnyFailure()

        Thread th = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ignore) {}
            deferred.resolve(new SuggestResponse("", 0, Collections.emptyList(), 0, null));
        });
        th.start();

        final CountDownLatch latch = new CountDownLatch(1);
        deferred.promise().then(response -> latch.countDown());

            isHiddenInDeclarativeDsl = false,
            isDirectAccessOnly = false,
            claimedFunctions = emptyList()
        )
    }

    override fun propertyExtractors(): List<PropertyExtractor> = when (projectAccessorsExtension) {
        null -> emptyList()
        else -> listOf(
            TypesafeProjectPropertyProducer(),

            Collections.<Feature<?>>emptySet()));

    assertEquals(
        FeatureUtil.buildTesterRequirements(ExampleDerivedInterfaceTester.class),
        new TesterRequirements(
            Sets.<Feature<?>>newHashSet(
                ExampleBaseFeature.BASE_FEATURE_1, ExampleDerivedFeature.DERIVED_FEATURE_2),
            Collections.<Feature<?>>emptySet()));
  }

        generatedPrimaryConstructorProperty?.let { return getAllOverriddenSymbols(it) }
        return emptyList()
    }

    protected fun KaValueParameterSymbol.getDirectlyOverriddenSymbols(): List<KaCallableSymbol> {
        generatedPrimaryConstructorProperty?.let { return getDirectlyOverriddenSymbols(it) }
        return emptyList()
    }

    val nestedObjectAccess: List<NestedObjectAccessRecord>,
    val errors: List<ResolutionError>,
    val conventionAssignments: List<AssignmentRecord> = emptyList(),
    val conventionAdditions: List<DataAdditionRecord> = emptyList(),
    val conventionNestedObjectAccess: List<NestedObjectAccessRecord> = emptyList()
)


data class DataAdditionRecord(val container: ObjectOrigin, val dataObject: ObjectOrigin)

    override fun getEnumEntries(classSymbol: KaNamedClassOrObjectSymbol): List<KaEnumEntrySymbol> {
        val enumDescriptor = getSymbolDescriptor(classSymbol) as? ClassDescriptor ?: return emptyList()
        if (enumDescriptor.kind != ClassKind.ENUM_CLASS) {
            return emptyList()
        }

        val result = mutableListOf<KaEnumEntrySymbol>()

        for (entryDescriptor in enumDescriptor.unsubstitutedMemberScope.getContributedDescriptors()) {

    final override val typeParameters: List<KaTypeParameterSymbol>
        get() = withValidityAssertion { emptyList() }

    final override val contextReceivers: List<KaContextReceiver> get() = withValidityAssertion { emptyList() }

    public abstract val isDefault: Boolean
    public abstract val isInline: Boolean
    public abstract val isOverride: Boolean