protected AbstractFuture() {}

  /**
   * {@inheritDoc}
   *
   * <p>The default {@link AbstractFuture} implementation throws {@code InterruptedException} if the
   * current thread is interrupted during the call, even if the value is already available.
   *
   * @throws CancellationException {@inheritDoc}
   */
  @CanIgnoreReturnValue
  @Override
  @ParametricNullness

        }
    }

    /**
     * Applies delay based on the configured interval rules.
     * This method calculates the appropriate delay for the current time
     * and applies it by sleeping the current thread.
     */
    public void delayByRules() {
        final long delay = getDelay();
        if (delay > 0) {
            ThreadUtil.sleep(delay);
        }
    }

    /**

        ByteArrayOutputStream os = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(os, true);
        new Thread(() -> {
            try {
                BufferedReader reader = new BufferedReader(new InputStreamReader(forkedProcessOutput, UTF_8));
                String line;

}

// From https://github.com/Kotlin/kotlinx-atomicfu/blob/master/atomicfu/build.gradle.kts
val compileJavaModuleInfo by tasks.registering(JavaCompile::class) {
  val moduleName = "okhttp3"
  val compilation = kotlin.targets["jvm"].compilations["main"]
  val compileKotlinTask = compilation.compileTaskProvider.get() as KotlinJvmCompile
  val targetDir = compileKotlinTask.destinationDirectory.dir("../java9")
  val sourceDir = file("src/jvmMain/java9/")

 * #createStarted(Ticker)} to supply a fake or mock ticker. This allows you to simulate any valid
 * behavior of the stopwatch.
 *
 * <p><b>Note:</b> This class is not thread-safe.
 *
 * <p><b>Warning for Android users:</b> a stopwatch with default behavior may not continue to keep
 * time while the device is asleep. Instead, create one like this:
 *
 * {@snippet :
 * Stopwatch.createStarted(

 *
 * <p>The {@link org.apache.maven.api.Session} interface is the main entry point for Maven operations.
 * It maintains the state of a Maven execution and provides access to all core services and components.
 * Sessions are thread-safe and can be obtained in session-scoped components using the
 * {@link org.apache.maven.api.di.SessionScoped} annotation.</p>
 *
 * <p>Key capabilities provided through the Session include:</p>
 * <ul>

     */
    protected void loadProtocols(final String basePackage) {
        final List<String> subPackages = new ArrayList<>();
        final String path = basePackage.replace('.', '/');
        final ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        try {
            final Enumeration<java.net.URL> resources = classLoader.getResources(path);

            while (resources.hasMoreElements()) {

 *       #FileBackedOutputStream(int, boolean) the two-arg constructor} with {@code true} for the
 *       second parameter. Relying on this second approach is discouraged.
 * </ul>
 *
 * <p>This class is thread-safe.
 *
 * @author Chris Nokleberg
 * @since 1.0
 */
@Beta
@J2ktIncompatible
@GwtIncompatible
@J2ObjCIncompatible
public final class FileBackedOutputStream extends OutputStream {

                }
            }
        } catch (final MalformedURLException mue) {
            throw new SmbException(src.getURL().toString(), mue);
        }
    }

}

class WriterThread extends Thread {

    private byte[] b;
    private int n;
    private boolean ready;
    private SmbFileOutputStream out;

    private SmbException e = null;

    WriterThread() {

    void testElapsedTime() throws InterruptedException {
        // Given
        exception = new SmbOperationException(SmbOperationException.ErrorCode.BUSY, "Server busy");

        // When
        Thread.sleep(100);

        // Then
        assertTrue(exception.getElapsedTime() >= 100);
        assertTrue(exception.getElapsedTime() < 200);
    }

    @Test