listener.cacheConditionalHit(call, response)
    listener.cacheHit(call, response)
    listener.cacheMiss(call)
    listener.satisfactionFailure(call, response)
    logRecorder
      .assertLogMatch(Regex("""cacheConditionalHit: Response\{protocol=h2, code=200, message=, url=$url\}"""))
      .assertLogMatch(Regex("""cacheHit: Response\{protocol=h2, code=200, message=, url=$url\}"""))

    def setup() {
        executer.requireOwnGradleUserHomeDir()
        root = new FileTreeBuilder(testDirectory)
        cachesDir = new File(homeDirectory, 'caches')
        def versionCaches = new File(cachesDir, GradleVersion.current().version)
        scriptCachesDir = new File(versionCaches, 'scripts')
        remappedCachesDir = new File(versionCaches, 'scripts-remapped')
    }

	if err != nil {
		return nil, err
	}

	// This is only for a test.  We need the watch cache to have a resource version that works for the test.
	// When new REST storage is created, the storage cacher for the CR starts asynchronously.
	// REST API operations return like list use the RV of etcd, but the storage cacher's reflector's list

}

// === Declarative DSL ===
performanceTest.registerTestProject("largeEmptyMultiProjectDeclarativeDsl", JavaExecProjectGeneratorTask) {
    outputs.dir new File(buildDir, "largeEmptyMultiProjectDeclarativeDsl")
    outputs.cacheIf { true }
    inputs.property('template', "largeEmptyMultiProjectDeclarativeDsl")
    inputs.property('args') { // Arguments are covered by the testProjectName and the outputs. We don't want them to contain the absolute path

        buildFile << """
            task myTask(type: TaskWithActionProperty) {
                outputs.cacheIf { true }
                action = providers.gradleProperty("anonymous").isPresent()
                    ? ${anonymousClassName}.ACTION
                    : ${lambdaClassName}.ACTION
            }
        """

                    .withPropertyName("classpath")
                    .withNormalizer(ClasspathNormalizer)
                outputs.file(outputFile)
                    .withPropertyName("outputFile")
                outputs.cacheIf { true }

                doLast {
                    outputFile.text = "done"
                }
            }
        """
        when:
        run "customTask"
        then:

   * Response and normal event sequences will not be received.
   *
   * This event will only be received when a Cache is configured for the client.
   */
  open fun cacheHit(
    call: Call,
    response: Response,
  ) {
  }

  /**
   * Invoked when a response will be served from the network. The Response will be
   * available from normal event sequences.
   *

        private final static long MINIMAL_CLEANUP_INTERVAL = 30000;

        // For stats we don't really care about thread safety
        private int cacheMiss;
        private int cacheHit;
        private int evict;

        private CountdownTimer cleanupTimer = Time.startCountdownTimer(MINIMAL_CLEANUP_INTERVAL);

        private static class MethodInvocationKey {

                    from 'web-inf'
                }
                webXml = file('web.xml')
                destinationDirectory = buildDir
                archiveFileName = 'test.war'
                outputs.cacheIf { true }
            }
        """

        when:
        withBuildCache().run "clean", "war"

        then:
        executedAndNotSkipped ':war'

        and:

		if vhosts, exists := vHostCache[listenerPort]; exists {
			virtualHosts = getVirtualHostsForSniffedServicePort(vhosts, routeName)
			cacheHit = true
		}
	}
	if !cacheHit {
		virtualHosts, resource, routeCache = BuildSidecarOutboundVirtualHosts(node, req.Push, routeName, listenerPort, efKeys, configgen.Cache)
		if resource != nil {
			return resource, true
		}
		if listenerPort > 0 {