Parser parser = new DisconnectedParser(getParseContext(), moduleDescriptorConverter, res, descriptorURL, properties, moduleIdentifierFactory, metadataFactory);
            parser.setValidate(isValidate());
            return parser;
        }

        @Override
        protected ModuleDescriptor parseOtherIvyFile(String parentOrganisation,

            parser.setValidate(validate);
            return parser;
        }

        public void setValidate(boolean validate) {
            this.validate = validate;
        }

        public boolean isValidate() {
            return validate;
        }

        public DescriptorParseContext getParseContext() {
            return parseContext;
        }

        public void parse() throws ParseException {

    }

    @Override
    boolean isAllowEmptyChildren() {
        return false
    }

    def "invalidate #vfsSpec.searchedPath removes child #vfsSpec.selectedChildPath (#vfsSpec)"() {
        setupTest(vfsSpec)

        when:
        def resultRoot = initialRoot.invalidate(searchedPath, CASE_SENSITIVE, diffListener).get()
        then:
        resultRoot.children == childrenWithSelectedChildRemoved()

    }

    @Override
    boolean isAllowEmptyChildren() {
        return true
    }

    def "invalidate #vfsSpec.searchedPath removes child #vfsSpec.selectedChildPath (#vfsSpec)"() {
        setupTest(vfsSpec)

        when:
        def resultRoot = initialRoot.invalidate(searchedPath, CASE_SENSITIVE, diffListener).get()
        then:
        resultRoot.children == childrenWithSelectedChildRemoved()

                return directory(location, [])
            } as Supplier<FileSystemLocationSnapshot>)
        }
        async {
            thread.blockUntil.snapshottingStarted
            vfs.invalidate(['/my/location/new/something'])
            instant.invalidated
        }
        then:
        instant.snapshottingStarted < instant.invalidated
        instant.invalidated < instant.snapshottingFinished

        }
        insertAll(urlFilterList, OpType.INDEX);
        invalidateSet.forEach(s -> excludeFilterCache.invalidate(s));
    }

    @Override
    public void delete(final String sessionId) {
        deleteBySessionId(sessionId);
        includeFilterCache.invalidate(sessionId);
        excludeFilterCache.invalidate(sessionId);
    }

    @Override

    @Override
    protected FileSystemLocationSnapshot mockChild() {
        Mock(FileSystemLocationSnapshot)
    }

    def "invalidate child with no common pathToParent creates a partial directory node (#vfsSpec)"() {
        setupTest(vfsSpec)

        when:
        def resultRoot = initialRoot.invalidate(searchedPath, CASE_SENSITIVE, diffListener).get()
        then:
        resultRoot instanceof PartialDirectoryNode

    }

    def "can invalidate child of file"() {
        def file = tmpDir.createFile("some/dir/file.txt")
        def set = snapshot(file)

        when:
        set = invalidate(set, file.file("child"))
        then:
        assertHasNoMetadata(set, file)
    }

    def "can invalidate branching off of snapshot"() {
        def dir = tmpDir.createDir("some/sub/dir")

        then:
        1 * watcher.startWatching({ equalIgnoringOrder(it, [rootDir.parentFile]) })
        0 * _

        when:
        invalidate(rootDirSnapshot.children[0])
        invalidate(rootDirSnapshot.children[1])
        then:
        0 * _

        when:
        invalidate(rootDirSnapshot.children[2])
        then:
        1 * watcher.stopWatching({ equalIgnoringOrder(it, [rootDir.parentFile]) })
        0 * _

        );
    }

    @Override
    public SnapshotHierarchy invalidate(String absolutePath, NodeDiffListener diffListener) {
        VfsRelativePath relativePath = VfsRelativePath.of(absolutePath);
        if (relativePath.isEmpty()) {
            diffListener.nodeRemoved(rootNode);
            return empty();
        }
        return rootNode.invalidate(relativePath, caseSensitivity, diffListener)