if len(want.Cache) != len(got.Cache) {
		t.Errorf("deserialize mismatch length\nwant: %+v\ngot:  %+v", len(want.Cache), len(got.Cache))
	}
	for wkey, wval := range want.Cache {
		gotv := got.Cache[wkey]
		if !equalAsJSON(gotv, wval) {
			t.Errorf("deserialize mismatch, key %v\nwant: %#v\ngot:  %#v", wkey, wval, gotv)
		}
	}
}

// equalAsJSON returns whether the values are equal when encoded as JSON.
func equalAsJSON(a, b any) bool {

      builder.addHeader("", "Value")
    }
  }

  @Test
  fun headerAllowsTabOnlyInValues() {
    val builder = Request.Builder()
    builder.header("key", "sample\tvalue")
    assertFailsWith<IllegalArgumentException> {
      builder.header("sample\tkey", "value")
    }
  }

  @Test
  fun headerForbidsControlCharacters() {
    assertForbiddenHeader("\u0000")
    assertForbiddenHeader("\r")

			Key:   target.MySQLPort,
			Value: cfg.Port,
		},
		config.KV{
			Key:   target.MySQLUsername,
			Value: cfg.User,
		},
		config.KV{
			Key:   target.MySQLPassword,
			Value: cfg.Password,
		},
		config.KV{
			Key:   target.MySQLDatabase,
			Value: cfg.Database,
		},
		config.KV{
			Key:   target.MySQLQueueDir,
			Value: cfg.QueueDir,
		},
		config.KV{

  }

  public void testContainsKeyAndValue() {
    for (LoadingCache<Key, String> cache : caches()) {
      // maintain strong refs so these won't be collected, regardless of cache's key/value strength
      Key key = new Key(1);
      String value = key.toString();
      assertThat(cache.getUnchecked(key)).isSameInstanceAs(value);
      assertThat(cache.asMap().containsKey(key)).isTrue();
      assertThat(cache.asMap().containsValue(value)).isTrue();

                log.debug("Failed to remove key from KeyStore: {}", e.getMessage());
            }
        }

        log.debug("Removed and wiped session key for session: {}", sessionId);
    }

    /**
     * Derive a new key from an existing key
     *
     * @param baseKey the base key
     * @param label key derivation label
     * @param context key derivation context

			asRoot: false,

			policy: `{"Effect": "Allow",
					"Action": ["kms:KeyStatus"],
					"Resource": ["arn:minio:kms:::abc-test-*"] }`,

			wantStatusCode: http.StatusOK,
			wantResp:       []string{"abc-test-key"},
		},
		{
			name:   "key status as user set policy to allow non-matching key",
			method: http.MethodGet,
			path:   kmsKeyStatusPath,

<h3 id="searchOptionsLabel">
	<la:message key="labels.search_options" />
</h3>
<div>
	<fieldset class="mb-3">
		<legend><la:message key="labels.index_num" /></legend>
		<label for="numSearchOption"><la:message key="labels.index_num" /></label>
		<la:select property="num" styleId="numSearchOption"
			styleClass="form-control">
			<option value="10">
				<la:message key="labels.search_result_select_num" />
			</option>

<h3 id="searchOptionsLabel">
	<la:message key="labels.search_options" />
</h3>
<div>
	<fieldset class="mb-3">
		<legend><la:message key="labels.index_num" /></legend>
		<label for="numSearchOption"><la:message key="labels.index_num" /></label>
		<la:select property="num" styleId="numSearchOption"
			styleClass="form-control">
			<option value="10">
				<la:message key="labels.search_result_select_num" />
			</option>

        // Then
        assertNotNull(signingKey, "Signing key should not be null");
        assertEquals(16, signingKey.length, "Signing key should be 16 bytes");
        assertFalse(Arrays.equals(sessionKey, signingKey), "Signing key should be different from session key");
    }

    @Test
    @DisplayName("Should derive signing key for SMB 3.1.1 dialect")
    void testDeriveSigningKey_SMB311() {
        // Given

     */
    public static <KEY, VALUE> Maps<KEY, VALUE> hashMap(final KEY key, final VALUE value) {
        return new Maps<>(new HashMap<KEY, VALUE>()).$(key, value);
    }

    /**
     * Returns a {@literal Maps} for constructing a {@link Hashtable} with the specified key and value.
     *
     * @param <KEY> the key type of the <code>Map</code>