* limitations under the License.
 */
package okhttp3

import kotlin.reflect.KClass
import okio.IOException
import okio.Timeout

/**
 * A call is a request that has been prepared for execution. A call can be canceled. As this object
 * represents a single request/response pair (stream), it cannot be executed twice.
 */
interface Call : Cloneable {
  /** Returns the original request that initiated this call. */

   * result.
   *
   * @return the next element if there was one. If {@code endOfData} was called during execution,
   *     the return value will be ignored.
   * @throws RuntimeException if any unrecoverable error happens. This exception will propagate
   *     outward to the {@code hasNext()}, {@code next()}, or {@code peek()} invocation that invoked

        }
    }

    /**
     * Executes the export job, writing each matching document as a file.
     *
     * @return a string containing the execution result or error messages
     */
    public String execute() {
        final SearchEngineClient searchEngineClient = ComponentUtil.getSearchEngineClient();
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

        // TODO: change this to a loop?
        boolean success
        try {
            success = waitCondition(this, ant)
        } catch (Exception e) {
            String msg = "Wait condition caught exception for ${name}"
            logger.error(msg, e)
            fail(msg, e)
        }
        if (success == false) {
            fail("Wait condition failed for ${name}")
        }

 * @author mike nonemacher
 */

@NullUnmarked
public class GcFinalizationTest extends TestCase {

  // ----------------------------------------------------------------
  // Ordinary tests of successful method execution
  // ----------------------------------------------------------------

  public void testAwait_countDownLatch() {
    CountDownLatch latch = new CountDownLatch(1);
    Object unused =
        new Object() {

            // Verify it doesn't take too long (parallel execution should help)
            assertTrue("Search took too long: " + elapsed + "ms", elapsed < 5000);
        }
    }

    /**
     * Searcher that throws an exception during search.
     */
    static class ExceptionThrowingSearcher extends RankFusionSearcher {
        private final RuntimeException exception;

* the contents your program gave to the system to be written to disk
* a remote API operation
* a database operation to finish
* a database query to return the results
* etc.

As the execution time is consumed mostly by waiting for <abbr title="Input and Output">I/O</abbr> operations, they call them "I/O bound" operations.

    <!-- These packages are duplicated in workers and daemon-server-worker, don't require a package-info.java in each place -->
    <suppress checks="JavadocPackage"
              files=".*[/\\]platforms[/\\]core-execution[/\\]daemon-server-worker[/\\]src[/\\]main[/\\]java[/\\]org[/\\]gradle[/\\]workers[/\\][^/\\]+"/>

    <!-- These packages are duplicated in code-quality and code-quality-workers, don't require a package-info.java in each place -->

import java.io.IOException;
import java.io.ObjectInputFilter;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Set;

import org.codelibs.core.exception.ClassNotFoundRuntimeException;
import org.codelibs.core.exception.IORuntimeException;

/**
 * Utility for serializing objects with security protections.
 * <p>
 * This utility provides object serialization and deserialization with built-in

void TF_SetTracingImplementation(const char* name, TF_Status* s) {
  tsl::Set_TF_Status_from_Status(s, SetDefaultTracingEngine(name));
}

// Creates a new TensorFlow function, it is an execution context attached to a
// given tracing context.
TF_ExecutionContext* TF_CreateFunction(const char* fn_name, TF_Status* s) {
  return wrap(CreateTracingExecutionContext(fn_name, s));
}