import org.gradle.util.TestUtil
import spock.lang.Specification

class DefaultRootComponentMetadataBuilderTest extends Specification {

    DependencyMetaDataProvider metaDataProvider = Mock() {
        getModule() >> Mock(Module)
    }
    ComponentIdentifierFactory componentIdentifierFactory = Mock()
    ImmutableModuleIdentifierFactory moduleIdentifierFactory = Mock()

            return tryGroupSetUnion((GroupSetExclude) right, left);
        }
        return null;
    }

    private ExcludeSpec tryModuleUnion(ModuleExclude left, ExcludeSpec right) {
        String leftModule = left.getModule();
        if (right instanceof ModuleIdExclude) {
            ModuleIdExclude mie = (ModuleIdExclude) right;
            if (mie.getModuleId().getName().equals(leftModule)) {
                return left;
            }

        }
        return false;
    }

    private static void validateDynamicSelectors(ComponentState selected) {
        List<SelectorState> selectors = ImmutableList.copyOf(selected.getModule().getSelectors());
        if (!selectors.isEmpty()) {
            if (selectors.stream().allMatch(DependencyGraphBuilder::isDynamic)) {
                // when all selectors are dynamic, result is undoubtedly unstable

        project.getExtensions().add(SwiftXCTestSuite.class, "xctest", testSuite);
        project.getComponents().add(testSuite);

        // Setup component
        testSuite.getModule().set(GUtil.toCamelCase(project.getName() + "Test"));

        final DefaultSwiftXCTestSuite testComponent = testSuite;

    init {
        LowMemoryWatcher.register(::clearCaches, project)
    }

    override fun getAnalysisSession(useSiteKtElement: KtElement): KaSession {
        val module = ProjectStructureProvider.getModule(project, useSiteKtElement, contextualModule = null)
        return getAnalysisSessionByUseSiteKtModule(module)
    }

    override fun getAnalysisSessionByUseSiteKtModule(useSiteKtModule: KtModule): KaSession {

        }

        val candidateDeclaration = candidateSymbol.firSymbol.fir as FirMemberDeclaration

        val positionModule = firResolveSession.moduleProvider.getModule(position)
        val candidateModule = candidateDeclaration.llFirModuleData.ktModule

        val effectiveSession = if (positionModule is KtDanglingFileModule && candidateModule != positionModule) {

            if (dependencyNotation instanceof IvyModule) {
                module = dependencyNotation
            }
            createSpecs()
        }

        IvyModule getModule() {
           super.module
        }

        void validate() {
            singleValidation(true, withModuleMetadataSpec)
            singleValidation(false, withoutModuleMetadataSpec)
        }

        }

        @Override
        public boolean isSatisfiedBy(ComponentSelection selection) {
            return selection.getCandidate().getGroup().equals(target.getGroup()) && selection.getCandidate().getModule().equals(target.getName());
        }
    }

        return KaSymbolOrigin.SOURCE
    }

    private fun getHandler(useSiteElement: KtElement): KaFe10AnalysisHandlerExtension {
        val project = useSiteElement.project
        val ktModule = ProjectStructureProvider.getModule(project, useSiteElement, contextualModule = null)
        return KaFe10AnalysisHandlerExtension.getInstance(project, ktModule)
    }

    private fun <T : Any> T?.orThrowResolutionNotPerformedError(): T =

            DefaultDependencyConstraint dependencyConstraint = instantiator.newInstance(DefaultDependencyConstraint.class, notation.getModule(), notation.getVersionConstraint());
            if (notation instanceof DependencyVariant) {
                dependencyConstraint.setAttributesFactory(attributesFactory);