void onSuccess(@ParametricNullness V result);

  /**
   * Invoked when a {@code Future} computation fails or is canceled.
   *
   * <p>If the future's {@link Future#get() get} method throws an {@link ExecutionException}, then
   * the cause is passed to this method. Any other thrown object is passed unaltered.
   */
  void onFailure(Throwable t);

    /**
     * @throws Exception
     */
    @Test
    public void testGet() throws Exception {
        final BeanMap map = new BeanMap();
        map.put("aaa", 1);
        map.put("bbb", 2);
        assertThat(map.get("aaa"), is((Object) 1));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGet_NotContains() throws Exception {
        exception.expect(IllegalKeyOfBeanMapException.class);

        lru.put("ccc", "333");
        assertThat(lru.get("aaa"), is("111"));
        Iterator<String> i = lru.keySet().iterator();
        assertThat(i.next(), is("bbb"));
        assertThat(i.next(), is("ccc"));
        assertThat(i.next(), is("aaa"));
        lru.put("ddd", "444");
        assertThat(lru.size(), is(3));
        assertThat(lru.get("bbb"), is(nullValue()));
        i = lru.keySet().iterator();

        raise HTTPException(status_code=400, detail="Inactive user")
    return current_user


@app.post("/token")
async def login(form_data: OAuth2PasswordRequestForm = Depends()):
    user_dict = fake_users_db.get(form_data.username)
    if not user_dict:
        raise HTTPException(status_code=400, detail="Incorrect username or password")
    user = UserInDB(**user_dict)
    hashed_password = fake_hash_password(form_data.password)

        if (testVersionProvider.get().canCompileOrRun(9)) {
            listOf("--add-opens", "java.base/java.lang=ALL-UNNAMED")
        } else {
            emptyList()
        }
    })
    jvmArgumentProviders.add(CommandLineArgumentProvider {
        val testVersion = testVersionProvider.get()
        if (testVersion.canCompileOrRun(9) && !testVersion.canCompileOrRun(17)) {

    public FieldConfigs(final Map<String, String> params) {
        this.params = params;
    }

    public OptionalThing<Config> getConfig(final String fieldName) {
        final String value = params.get(fieldName);
        if (StringUtil.isNotBlank(value)) {
            return OptionalThing.of(new Config(value));
        }
        return OptionalThing.empty();
    }

    public static class Config {

        messages = new ArrayList<>();
    }

    public int getMessageCount() {
        return messages.size();
    }

    public String getMessage(int i) {
        return messages.get(i);
    }

    public List<String> getMessages() {
        return Collections.unmodifiableList(messages);
    }

    public void addMessage(String message) {
        messages.add(message);
    }

import org.opensearch.action.fieldcaps.FieldCapabilitiesResponse;
import org.opensearch.action.get.GetRequest;
import org.opensearch.action.get.GetRequestBuilder;
import org.opensearch.action.get.GetResponse;
import org.opensearch.action.get.MultiGetRequest;
import org.opensearch.action.get.MultiGetRequestBuilder;
import org.opensearch.action.get.MultiGetResponse;
import org.opensearch.action.index.IndexRequest;

    val encodedFragment: String? = httpUrl.encodedFragment()
    val fragment: String? = httpUrl.fragment()
    val getFromUrl: HttpUrl? = HttpUrl.get(URL(""))
    val getFromUri: HttpUrl? = HttpUrl.get(URI(""))
    val parse: HttpUrl? = HttpUrl.parse("")
  }

  @Test @Disabled
  fun handshakeCertificates() {
    val handshakeCertificates = HandshakeCertificates.Builder().build()

          Platform.get().getSelectedProtocol(sslSocket)
        } else {
          null
        }
      socket = sslSocket
      source = sslSocket.source().buffer()
      sink = sslSocket.sink().buffer()
      protocol = if (maybeProtocol != null) Protocol.get(maybeProtocol) else Protocol.HTTP_1_1
      success = true
    } finally {
      Platform.get().afterHandshake(sslSocket)
      if (!success) {