.get(1)
                .getActivation()
                .getFile()
                .getExists();

        assertEquals(originalExists, resultExists);
        assertTrue(result.getEffectiveModel()
                .getProfiles()
                .get(1)
                .getActivation()
                .getFile()
                .getExists()
                .contains(BASE_DIR));
    }

    }

    @Override
    protected String getDefaultName() {
        return original.getName();
    }

    @Override
    protected String getDefaultType() {
        return getFileExtension(getFile().getName());
    }

    @Override
    protected String getDefaultExtension() {
        return original.getExtension() + "." + getType();
    }

    @Override
    protected String getDefaultClassifier() {

        return resource(resource);
    }

    @Override
    public LocallyAvailableExternalResource resource(ExternalResourceName location) {
        File localFile = getFile(location);
        return new LocalFileStandInExternalResource(localFile, fileSystem, listener);
    }

    @Override
    public LocallyAvailableExternalResource resource(File file) {

        cos.write(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 });
        assertFalse(cos.done);
        assertFalse(cos.isInMemory());
        File file = cos.getFile();
        assertTrue(cos.done);
        assertTrue(file.exists());
        cos.close();
        assertTrue(cos.done);
        assertTrue(file.exists());
    }

    @Test

        backingModule.getSha512File(file)
    }

    @Override
    String getPath() {
        return "${modulePath}/${backingArtifact.path}"
    }

    @Override
    TestFile getFile() {
        return backingArtifact.getFile()
    }

    @Override
    String getName() {
        return backingArtifact.name
    }

        }
    }

    project {
        ipr {
            whenMerged { it.wildcards += '!?*.ruby' }
        }
    }
}
'''
        //then
        def iml = getFile([:], 'root.iml').text
        assert iml.contains('1.44')

        def ipr = getFile([:], 'root.ipr').text
        assert ipr.contains('!?*.ruby')
    }


    private containsDir(path, urls) {
        urls.any { it.endsWith(path) }
    }

        assertFalse(result.isMissing());
        assertTrue(result.isResolved());
        Artifact artifact = result.getArtifact();
        assertNotNull(artifact.getFile());
        assertEquals(filename, artifact.getFile().getName());
    }

    @Test
    void testResolveArtifacts() throws Exception {
        ArtifactRequest req1 = new ArtifactRequest();

            return new ByteArrayInputStream(out.getData());
        }
        return new FileInputStream(out.getFile());
    }

    protected long getContentLength(final DeferredFileOutputStream out) throws IOException {
        if (out.isInMemory()) {
            return out.getData().length;
        }
        return out.getFile().length();
    }

        super(taskDependencyFactory);
        this.publishArtifact = publishArtifact;
    }

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

    @Override
    protected String getDefaultExtension() {
        return publishArtifact.getExtension();
    }

    @Override
    protected String getDefaultClassifier() {

        return null;
    }

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

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

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