public static <V extends @Nullable Object> V getDone(Future<V> future) throws ExecutionException {
    /*
     * We throw IllegalStateException, since the call could succeed later. Perhaps we "should" throw
     * IllegalArgumentException, since the call could succeed with a different argument. Those
     * exceptions' docs suggest that either is acceptable. Google's Java Practices page recommends

                            val call = createKtCall(psi, this, calleeReference, null, resolveFragmentOfCall)
                                ?: errorWithFirSpecificEntries(
                                    "expect `createKtCall` to succeed for resolvable case with callable symbol",
                                    fir = this,
                                    psi = psi
                                )
                            KtSuccessCallInfo(call)

  // - Warn: This will send a warning via the standard warning response
  // header for each unknown field that is dropped from the object, and
  // for each duplicate field that is encountered. The request will
  // still succeed if there are no other errors, and will only persist
  // the last of any duplicate fields. This is the default in v1.23+
  // - Strict: This will fail the request with a BadRequest error if

                          remote_device) != device_names.end());
  }

  // Create a variable using `ctx_0`.
  // Read the variable using `ctx_1`. This read should succeed.
  // 1. Create a variable on `remote_device`, using `ctx_0`.
  TFE_TensorHandle* handle_0 =
      CreateVariable(ctx_0, 1.2, remote_device, /*variable_name=*/"var2");

        response.body.string()
      }
    }

    // The second call succeeds.
    val call2 = client.newCall(Request(server.url("/")))
    call2.execute().use { response ->
      assertThat(
        response.body.string(),
      ).isEqualTo("b")
    }

    // Calls succeed after the degraded pong timeout because the degraded pong was received.

	if err = xlStorage.MakeVol(context.Background(), "success-vol"); err != nil {
		t.Fatalf("Unable to create volume, %s", err)
	}
	if err = xlStorage.AppendFile(context.Background(), "success-vol", "abc/def/ghi/success-file", []byte("Hello, world")); err != nil {
		t.Fatalf("Unable to create file, %s", err)
	}
	if err = xlStorage.AppendFile(context.Background(), "success-vol", "abc/xyz/ghi/success-file", []byte("Hello, world")); err != nil {

		                          </Rule>
		                          </LifecycleConfiguration>`))
	lc, err := ParseLifecycleConfigWithID(r)
	if err != nil {
		t.Fatalf("Expected parsing to succeed but failed with %v", err)
	}
	for _, rule := range lc.Rules {
		if rule.ID == "" {
			t.Fatalf("Expected all rules to have a unique id assigned %#v", rule)
		}
	}
}

		formValues.Set("Key", strings.ReplaceAll(formValues.Get("Key"), "${filename}", fileName))
	}
	object := trimLeadingSlash(formValues.Get("Key"))

	successRedirect := formValues.Get("success_action_redirect")
	successStatus := formValues.Get("success_action_status")
	var redirectURL *url.URL
	if successRedirect != "" {
		redirectURL, err = url.Parse(successRedirect)
		if err != nil {

func (ri *batchJobInfo) trackMultipleObjectVersions(bucket string, info ObjectInfo, success bool) {
	if success {
		ri.Objects += int64(info.NumVersions)
	} else {
		ri.ObjectsFailed += int64(info.NumVersions)
	}
}

func (ri *batchJobInfo) trackCurrentBucketObject(bucket string, info ObjectInfo, success bool) {
	if ri == nil {
		return
	}

	ri.mu.Lock()
	defer ri.mu.Unlock()

    error_msg: (String) String with one and only one '%s'. Formatted with each
      invalid response upon check_success(input) failure.
    suppress_default_error: (Bool) Suppress the above error message in favor of
      one from the check_success function.
    resolve_symlinks: (Bool) Translate symbolic links into the real filepath.
    n_ask_attempts: (Integer) Number of times to query for valid input before