:KUBE-RESTORED - [0:0]
		:KUBE-MISC-CHAIN - [0:0]
		:KUBE-MISC-TWO - [0:0]
		:KUBE-EMPTY - [0:0]
		-A KUBE-TEST -j ACCEPT
		-A KUBE-RESTORED -m comment --comment "restored chain" -j ACCEPT
		-A KUBE-MISC-CHAIN -s 1.2.3.4 -j KUBE-MISC-TWO
		-A KUBE-MISC-CHAIN -d 5.6.7.8 -j MASQUERADE
		-A KUBE-MISC-TWO -j ACCEPT
		COMMIT
		*filter
		:INPUT - [0:0]
		:FORWARD - [0:0]
		:OUTPUT - [0:0]
		COMMIT
		*mangle
		COMMIT

public class SnapshotUtil {

    public static Map<String, FileSystemLocationSnapshot> indexByAbsolutePath(FileSystemSnapshot snapshot) {
        HashMap<String, FileSystemLocationSnapshot> index = new HashMap<>();
        snapshot.accept(entrySnapshot -> {
            index.put(entrySnapshot.getAbsolutePath(), entrySnapshot);
            return SnapshotVisitResult.CONTINUE;
        });
        return index;
    }

            // FileCollection is-a Iterable, Buildable and TaskDependencyContainer, so check before checking for these things
            visitor.accept((FileCollectionInternal) element);
            return;
        }
        if (element instanceof DirectoryTree) {
            visitor.accept(new FileTreeAdapter((MinimalFileTree) element, taskDependencyFactory, patternSetFactory));
            return;
        }

      "ResponseBodyEnd",
      "ConnectionReleased",
      "CallEnd",
    )
  }

  private fun newEventSource(accept: String? = null): EventSource {
    val builder =
      Request.Builder()
        .url(server.url("/"))
    if (accept != null) {
      builder.header("Accept", accept)
    }
    val request = builder.build()
    val factory = createFactory(client)

     *
     * @param candidate the candidate version
     */
    boolean accept(String candidate);

    /**
     * Indicates if the selector matches the given candidate version.
     * Only called if {@link #requiresMetadata()} returned {@code false}.
     *
     * @param candidate the candidate version
     */
    boolean accept(Version candidate);

    /**

/**
 * Transparent Brotli response support.
 *
 * Adds Accept-Encoding: br to request and checks (and strips) for Content-Encoding: br in
 * responses.  n.b. this replaces the transparent gzip compression in BridgeInterceptor.
 */
object BrotliInterceptor : Interceptor {
  override fun intercept(chain: Interceptor.Chain): Response {
    return if (chain.request().header("Accept-Encoding") == null) {
      val request =

        }

        @Override
        public boolean accept(String propertyName, ChangeVisitor visitor) {
            return inputFileChangesDelegate.accept(propertyName, visitor);
        }

        @Override
        public boolean accept(ChangeVisitor visitor) {
            return changeContainerDelegate.accept(visitor);
        }
    }

            @Override
            void accept(OutputFrame outputFrame) {
                super.accept(outputFrame)
                println(outputFrame.utf8String)
            }
        }
        def stderrConsumer = new ToStringConsumer() {
            @Override
            void accept(OutputFrame outputFrame) {
                super.accept(outputFrame)
                System.err.println(outputFrame.utf8String)

        .url(server.url("/"))
        .header("Accept", "text/plain")
        .build()
    val response = client.newCall(request).execute()
    assertThat(response.code).isEqualTo(200)
    assertThat(response.body.string()).isEqualTo("hello, OkHttp")

    val recorded = server.takeRequest()
    assertThat(recorded.headers["Accept"]).isEqualTo("text/plain")
    assertThat(recorded.headers["Accept-Encoding"]).isEqualTo("gzip")

        1 * initAction.requiresInitialization(sharedLock) >> false

        then:
        1 * onOpenAction.accept(sharedLock)
        0 * _

        when:
        cacheAccess.close()

        then:
        1 * onCloseAction.accept(sharedLock)
        1 * sharedLock.close()
        0 * _
    }

    def "releases lock when cache initialization fails"() {