def "updateFile throws integrity exception when not cleanly unlocked file"() {
        given:
        unlockUncleanly()

        and:
        def lock = createLock(Exclusive)

        when:
        lock.updateFile {}

        then:
        thrown FileIntegrityViolationException
    }

    def "writeFile does not throw integrity exception when not cleanly unlocked file"() {
        given:

/**
 * Indicates the state of the daemon when it stops doing work.
 */
public enum DaemonStopState {
    /**
     * Daemon was stopped cleanly and all work stopped.
     */
    Clean,
    /**
     * Daemon could not be stopped cleanly and some work may still be running.
     */
    Forced

                            if (state != null) {
                                // Could not cancel cleanly, so stop
                                return state;
                            }
                            // Else, cancelled cleanly, so keep doing work
                            break;
                        case Broken:

	}
	_ = b[j/64]
	// Clear leading bits.
	b[i/64] &^= ^uint64(0) << (i % 64)
	clear(b[i/64+1 : j/64])
	// Clear trailing bits.
	b[j/64] &^= (uint64(1) << (j%64 + 1)) - 1
}

// clearAll frees all the bits of b.
func (b *pageBits) clearAll() {
	clear(b[:])
}

// clearBlock64 clears the 64-bit aligned block of bits containing the i'th bit that
// are set in v.
func (b *pageBits) clearBlock64(i uint, v uint64) {

    ) {
        this.userInput = userInput;
        // Use a single reader thread, and make it a daemon thread so that it does not block process shutdown
        // In most cases, we try to cleanly shut down all threads. However, in this case it is difficult to disconnect a thread blocked trying to read from the
        // process' stdin, so use a daemon thread instead.
        executor = Executors.newSingleThreadExecutor(r -> {

        this.stopState.set(stopState);
    }

    @Override
    public void close() {
        if (stopState.get() == DaemonStopState.Forced) {
            // The daemon could not be stopped cleanly, so the services could still be doing work.
            // Don't attempt to stop the services, just stop this process
            return;
        }

        // Daemon has finished work, so stop the services

            if (!lock.getUnlockedCleanly()) {
                if (lock.getState().canDetectChanges() && !lock.getState().isInInitialState()) {
                    LOGGER.warn("Invalidating {} as it was not closed cleanly.", DefaultPersistentDirectoryCache.this);
                }
                return true;
            }

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

func (s *DiscoveryServer) dropCacheForRequest(req *model.PushRequest) {
	// If we don't know what updated, cannot safely cache. Clear the whole cache
	if len(req.ConfigsUpdated) == 0 {
		s.Cache.ClearAll()
	} else {
		// Otherwise, just clear the updated configs
		s.Cache.Clear(req.ConfigsUpdated)
	}
}

// Push is called to push changes on config updates using ADS.

     *
     * Any files in the module that are included in this scope will be removed from analysis results. This allows the files provided by
     * [getKtFiles] to cleanly replace those files from the module.
     *
     * If this resolve extension is being used to generate declarations that would normally be provided by sources generated by an external

        then:
        0 * _  // Does not call initialization action.
        dir.file("cache.properties").isFile()
        dir.file("some-file").isFile()
    }

    def "will rebuild cache if not unlocked cleanly"() {
        given:
        def dir = temporaryFolder.testDirectory.createDir("cache")
        def initialized = false
        def init = { initialized = true } as Consumer