// later requests within the cache window don't hit the backend
		{name: "alice cached request", attr: aliceAttr, allow: false, statusCode: 500, expectedErr: false, expectedAuthorized: true, expectedCalls: 0},

		// a request with different attributes doesn't hit the cache

        if (hits.length > 0) {
            index = hits[0].getIndex();
        } else {
            index = SuggestConstants.EMPTY_STRING;
        }

        for (final SearchHit hit : hits) {
            final Map<String, Object> source = hit.getSourceAsMap();
            final String text = source.get(FieldNames.TEXT).toString();
            words.add(text);

            if (detail) {

          {{if .Instructions -}}
            {{/* instructions for this source line */ -}}
            <span class=asm>{{"" -}}
            {{range .Instructions -}}
              {{/* separate when we hit a new basic block */ -}}
              {{if .NewBlock -}}{{printf " %8s %28s\n" "" "⋮"}}{{end -}}

              {{/* inlined calls leading to this instruction */ -}}
              {{range .InlinedCalls -}}

                    SuggestUtil.deleteScrollContext(client, scrollId);
                    isFinished.set(true);
                }

                for (final SearchHit hit : hits) {
                    final Map<String, Object> source = hit.getSourceAsMap();
                    if (limitOfDocumentSize > 0) {
                        long size = 0;
                        for (final String field : supportedFields) {

		}
	}

	// Verify mock openID discovery http://localhost:9999/.well-known/openid-configuration was called three times.
	if got, want := ms.OpenIDHitNum, uint64(3); got != want {
		t.Errorf("Mock OpenID discovery Hit number => expected %d but got %d", want, got)
	}
}

func TestGetPublicKey(t *testing.T) {
	r := NewJwksResolver(JwtPubKeyEvictionDuration, JwtPubKeyRefreshInterval, JwtPubKeyRefreshIntervalOnFailure, testRetryInterval)

    assertFalse(InetAddresses.isInetAddress("016.016.016.016"));
  }

  public void testForStringIPv4Input() throws UnknownHostException {
    String ipStr = "192.168.0.1";
    // Shouldn't hit DNS, because it's an IP string literal.
    InetAddress ipv4Addr = InetAddress.getByName(ipStr);
    assertEquals(ipv4Addr, InetAddresses.forString(ipStr));
    assertTrue(InetAddresses.isInetAddress(ipStr));
  }

        then:
        isolatedProjectsEvents().enabled == [enabled]
        configurationCacheEvents().enabled == [GradleContextualExecuter.configCache || enabled]

        // Ensure events are produced on CC hit as well
        when:
        succeeds("help", "-Dorg.gradle.unsafe.isolated-projects=$enabled")
        then:
        isolatedProjectsEvents().enabled == [enabled]

		monitoring.WithEnabled(enableStats),
	)

	xdsCacheHits             = xdsCacheReads.With(typeTag.Value("hit"))
	xdsCacheMisses           = xdsCacheReads.With(typeTag.Value("miss"))
	xdsCacheEvictionsOnClear = xdsCacheEvictions.With(typeTag.Value("clear"))
	xdsCacheEvictionsOnSize  = xdsCacheEvictions.With(typeTag.Value("size"))
)

func hit() {
	xdsCacheHits.Increment()
}

func miss() {
	xdsCacheMisses.Increment()
}

	client.Jar.SetCookies(u, expectedCookies)

	client.Get(us) // Note: doesn't hit network
	matchReturnedCookies(t, expectedCookies, tr.req.Cookies())

	client.Head(us) // Note: doesn't hit network
	matchReturnedCookies(t, expectedCookies, tr.req.Cookies())

	client.Post(us, "text/plain", strings.NewReader("body")) // Note: doesn't hit network
	matchReturnedCookies(t, expectedCookies, tr.req.Cookies())

			},
			wantFileName:    fmt.Sprintf("%s.wasm", httpDataCheckSum),
			wantVisitServer: true,
		},
		{
			name: "cache hit",
			initialCachedModules: map[moduleKey]cacheEntry{
				{name: moduleNameFromURL(ts.URL), checksum: cacheHitSum}: {modulePath: "test.wasm"},
			},
			initialCachedChecksums: map[string]*checksumEntry{},