LOGGER.warn("Invalidating {} as it was not closed cleanly.", DefaultPersistentDirectoryCache.this);
                }
                return true;
            }

            if (!properties.isEmpty()) {
                if (!propertiesFile.exists()) {

        build.waitForFinish()
        pathsInvalidated()

        cleanup:
        block?.releaseAll()
        build?.waitForFinish()
    }

    @TargetGradleVersion(">=3.0 <6.1")
    def "invalidating paths has no effect on older daemons"() {
        when:
        createIdleDaemon()
        def executedCommandCount = countExecutedCommands()

        then:
        executedCommandCount == 3

        }
    }

    @Override
    public void invalidate(Iterable<String> locations) {
        LOGGER.debug("Invalidating VFS paths: {}", locations);
        updateRootUnderLock(root -> {
            SnapshotHierarchy result = root;
            VersionHierarchyRoot newVersionHierarchyRoot = versionHierarchyRoot;

            gradleUserHomeScopeServiceRegistry.getCurrentServices().ifPresent(currentServices -> {
                LOGGER.info("Invalidating {}", command.getChangedPaths());
                FileSystemAccess fileSystemAccess = currentServices.get(FileSystemAccess.class);
                fileSystemAccess.invalidate(command.getChangedPaths());
            });

                                if (absolutePath == null) {
                                    LOGGER.info("Overflow detected (type: {}), invalidating all watched files", type);
                                    fileWatcherUpdater.getWatchedFiles().visitRoots(watchedRoot ->
                                        handler.handleChange(OVERFLOW, Paths.get(watchedRoot)));

        addedNodes.empty
        interaction { noMoreInteractions() }

        where:
        vfsSpec << (IS_PREFIX_OF_CHILD + SAME_PATH).findAll { it.childPaths.size() > 1 }
    }

    def "invalidating the only child by #vfsSpec.searchedPath removes the node (#vfsSpec)"() {
        setupTest(vfsSpec)

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

		log.Fatalf("mmap: %v", err)
	}

	// Create a hole in the mapping that's PROT_NONE.
	// Note that we can't use munmap here because the Go runtime
	// could create a mapping that ends up in this hole otherwise,
	// invalidating the test.
	hole := data[len(data)/2 : 3*(len(data)/4)]
	if err := syscall.Mprotect(hole, syscall.PROT_NONE); err != nil {
		log.Fatalf("mprotect: %v", err)
	}

	// Check that memcopy returns the actual amount copied

        if (previousState == null) {
            outOfDate = true;
        } else if (currentCacheState.hasBeenUpdatedSince(previousState)) {
            LOG.info("Invalidating in-memory cache of {}", cacheId);
            outOfDate = true;
        }
        if (outOfDate) {
            inMemoryCache.invalidateAll();
        }
        delegate.afterLockAcquire(currentCacheState);

            this.calculator = calculator;
        }

        @Override
        public void invalidateCachesFor(Iterable<String> affectedOutputPaths) {
            // A very dumb strategy for invalidating cache
            locationCache.clear();
        }

        @Override
        public V get(File file) {
            return locationCache.computeIfAbsent(file,

                return entry.getResult();
            } else if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Invalidating result for rule {} and key {} in cache", rules, key);
            }
        }

        RESULT result = executeRule(key, action, detailsToResult, onCacheMiss);