/**
     * Pending cancel flag - indicates cancel was pending at sender
     */
    int DCERPC_PENDING_CANCEL = 0x04; /* Cancel was pending at sender */
    /**
     * Reserved flag for future use
     */
    int DCERPC_RESERVED_1 = 0x08;
    /**
     * Supports concurrent multiplexing flag.
     */
    int DCERPC_CONC_MPX = 0x10; /* supports concurrent multiplexing */
    /**

            Thread.interrupted();
            if (interruptingThread.isAlive()) {
              // This will be hidden by test-output redirection:
              logger.severe("InterruptenatorTask did not exit; future tests may be affected");
              /*
               * This won't do any good under JUnit 3, but I'll leave it around in
               * case we ever switch to JUnit 4:
               */
              fail();

But it's provided here to be compliant with the specifications.

Also, there might be tools that expect and use it (now or in the future) and that might be useful for you or your users, now or in the future.

That's the benefit of standards...

///

## See it in action { #see-it-in-action }

	defaultCertsDir   = &ConfigDir{path: getDefaultCertsDir()}
	defaultCertsCADir = &ConfigDir{path: getDefaultCertsCADir()}

	// Points to current configuration directory -- deprecated, to be removed in future.
	globalConfigDir = defaultConfigDir
	// Points to current certs directory set by user with --certs-dir
	globalCertsDir = defaultCertsDir
	// Points to relative path to certs directory and is <value-of-certs-dir>/CAs

   * @throws IllegalStateException when the call has already been executed.
   */
  @Throws(IOException::class)
  fun execute(): Response

  /**
   * Schedules the request to be executed at some point in the future.
   *
   * The [dispatcher][OkHttpClient.dispatcher] defines when the request will run: usually
   * immediately unless there are several other requests currently being executed.
   *

 * connections should expect repetition of stream IDs.
 *
 * Return true to request cancellation of a pushed stream.  Note that this does not guarantee
 * future frames won't arrive on the stream ID.
 */
interface PushObserver {
  /**
   * Describes the request that the server intends to push a response for.
   *
   * @param streamId server-initiated stream ID: an even number.

            Thread.interrupted();
            if (interruptingThread.isAlive()) {
              // This will be hidden by test-output redirection:
              logger.severe("InterruptenatorTask did not exit; future tests may be affected");
              /*
               * This won't do any good under JUnit 3, but I'll leave it around in
               * case we ever switch to JUnit 4:
               */
              fail();

 * Otherwise, at least reduce <i>explicit</i> dependencies on this type by using lambda expressions
 * or method references instead of classes, leaving your code easier to migrate in the future.
 *
 * <p>The {@link Predicates} class provides common predicates and related utilities.
 *
 * <p>See the Guava User Guide article on <a

import com.google.common.collect.Lists;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Test case for {@link EventBus}.
 *
 * @author Cliff Biffle
 */

Il est également conçu pour fonctionner comme une référence future.

Vous pouvez donc revenir et voir exactement ce dont vous avez besoin.

## Exécuter le code

Tous les blocs de code peuvent être copiés et utilisés directement (il s'agit en fait de fichiers Python testés).