return null;
    }

    @Override
    protected TaskDependency getDefaultBuildDependencies() {
        return artifact.getBuildDependencies();
    }

    @Override
    public File getFile() {
        return artifact.getFile();
    }

    @Override
    public boolean shouldBePublished() {
        return PublishArtifactInternal.shouldBePublished(artifact);
    }

        .thenComparing(VerificationEntry::getModule)
        .thenComparing(VerificationEntry::getVersion)
        .thenComparing(VerificationEntry::getFile)
        .thenComparing(VerificationEntry::getArtifactKind)
        .thenComparing(VerificationEntry::getOrder);

    protected final ModuleComponentArtifactIdentifier id;

configurations {
    compileClasspath {
        resolutionStrategy.activateDependencyLocking()
    }
}

dependencies {
    implementation 'groupOne:artifactTwo:[2.0,3.0)'
}
"""
        def content = getFile([print : true], 'root.iml').text

        //then
        assert content.count("artifactTwo-2.0.jar") == 1
        assert content.count("unresolved dependency - groupOne artifactTwo") >= 1
    }

    @Test

        return executer.withTasks(taskName).run()
    }

    protected TestFile getFile(Map options, String filename) {
        def file = options?.project ? file(options.project, filename) : file(filename)
        if (options?.print) { println file.text }
        file
    }

    protected parseFile(Map options, String filename) {
        def file = getFile(options, filename)
        new XmlSlurper().parse(file)
    }

        this.builder = builder;
    }

    @SuppressWarnings("deprecation")
    public void injectTransformedArtifacts(RepositorySystemSession session, MavenProject project) throws IOException {
        if (project.getFile() == null) {
            // If there is no build POM there is no reason to inject artifacts for the consumer POM.
            return;
        }
        if (Features.buildConsumer(session.getUserProperties())) {

                moduleEntries.add(createWbDependentModuleEntry(artifact.getFile(), wtp.getFileReferenceFactory(), deployPath));
            }
        }

        @Override
        public void visitFileDependency(ResolvedArtifactResult artifact, boolean testDependency) {
            if (includeLibraries()) {
                fileEntries.add(createWbDependentModuleEntry(artifact.getFile(), wtp.getFileReferenceFactory(), deployPath));
            }

            if (change.getChangeType() == ChangeType.REMOVED) {
                File relocatedFileLocation = relocatedObject(change.getFile());
                relocatedFileLocation.delete();
            } else {
                if (change.getFile().isFile()) {
                    unexportMainSymbol(change.getFile());
                }
            }
        }
    }

    private void unexportMainSymbol(File object) {

        def project = rootXcodeProject
        project.projectFile.getFile().assertExists()
        project.schemeFiles*.file*.assertExists()
        project.workspaceSettingsFile.assertExists()
        project.dir.assertExists()

        when:
        succeeds("cleanXcode")

        then:
        executedAndNotSkipped(":cleanXcodeProject")

        project.projectFile.getFile().assertDoesNotExist()

    @Override
    public String getType() {
        return "";
    }

    @Override
    public String getClassifier() {
        return getValue().getClassifier();
    }

    @Override
    public File getFile() {
        return fileSystemLocation.getAsFile();
    }

    @Override
    public Date getDate() {
        return new Date();
    }

    @Override
    public TaskDependency getBuildDependencies() {

    }

    @Override
    public boolean getHasEmptyContent() {
        return true;
    }

    @Override
    public File getFile() {
        // Returns null as there is no file that contains this resource's contents,
        // however {@link ResourceLocation#getFile()} would still return the given `sourceFile`
        return null;
    }

    @Override
    public Charset getCharset() {
        return null;