int cleaned = forceCleanup();

        // Shutdown executor
        cleanupExecutor.shutdown();
        try {
            if (!cleanupExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                cleanupExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            cleanupExecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }

        if (!closed.compareAndSet(false, true)) {
            return;
        }

        cleanupScheduler.shutdownNow();
        try {
            cleanupScheduler.awaitTermination(5, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.warn("Interrupted while shutting down cleanup scheduler", e);
        }

        }
    }

    /**
     * Shutdown the failover handler
     */
    public void shutdown() {
        executor.shutdown();
        try {
            if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }

        localhostIpv6,
      )

    client =
      clientTestRule
        .newClientBuilder()
        .eventListenerFactory(clientTestRule.wrap(listener))
        .connectTimeout(60, TimeUnit.SECONDS) // Deliberately exacerbate slow fallbacks.
        .dns { dnsResults }
        .fastFallback(true)
        .build()
    url =
      serverIpv4
        .url("/")
        .newBuilder()

        this.scope = scope;
        this.createTime = System.currentTimeMillis();
        this.lastUpdateTime = createTime;
        this.lastAccessTime = createTime;
        this.maxAge = 30000; // 30 seconds default

        this.children = new ConcurrentHashMap<>();
        this.lock = new ReentrantReadWriteLock();
        this.isComplete = false;
        this.hasChanges = false;
    }

    /**

        } catch (Exception e) {
            // Expected
        }
        long duration = System.currentTimeMillis() - startTime;

        // Test should complete in under 1 second (much less than the original 25+ seconds)
        assertTrue("Test should complete quickly (duration: " + duration + "ms)", duration < 1000);
    }

    // Fast mock implementations to minimize overhead

		return nil, nil, errInvalidArgument
	}

	// prepare getElapsedTime() to calculate elapsed time since we started trying formatting disks.
	// All times are rounded to avoid showing milli, micro and nano seconds
	formatStartTime := time.Now().Round(time.Second)
	getElapsedTime := func() string {
		return time.Now().Round(time.Second).Sub(formatStartTime).String()
	}

	var (
		tries   int
		verbose bool
	)

 */

package com.google.common.testing;

import static com.google.common.truth.Truth.assertThat;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.Assert.assertThrows;

import com.google.common.base.CharMatcher;
import com.google.common.base.Equivalence;
import com.google.common.base.Joiner;
import com.google.common.base.Predicate;

        
        // Load persisted handles on startup
        loadPersistedHandles();
        
        // Schedule periodic persistence
        scheduler.scheduleAtFixedRate(this::persistHandles, 30, 30, TimeUnit.SECONDS);
    }
    
    public static class HandleInfo implements Serializable {
        private static final long serialVersionUID = 1L;
        
        private final String path;

This can be quite noticeable when using `docker compose`. See this Docker Compose FAQ section for more technical details: <a href="https://docs.docker.com/compose/faq/#why-do-my-services-take-10-seconds-to-recreate-or-stop" class="external-link" target="_blank">Why do my services take 10 seconds to recreate or stop?</a>.

#### Directory Structure { #directory-structure }

You should now have a directory structure like:

```
.
├── app