cr.createNewFile();
                assertNotified(w, FileNotifyInformation.FILE_ACTION_ADDED, "created", null);
            }
        }
        catch ( TimeoutException e ) {
            log.info("Timeout waiting", e);
            fail("Did not recieve notification");
        }
    }


    @Test
    public void testWatchModified () throws InterruptedException, ExecutionException, IOException {

import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Timeout
import org.junit.jupiter.api.extension.RegisterExtension
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource

@Flaky // STDOUT logging enabled for test
@Timeout(30)
@Tag("Slow")
open class ConnectionListenerTest {
  @RegisterExtension
  val platform = PlatformRule()

  void awaitRunning();

  /**
   * Waits for the {@link Service} to reach the {@linkplain State#RUNNING running state} for no more
   * than the given time.
   *
   * @param timeout the maximum time to wait
   * @param unit the time unit of the timeout argument
   * @throws TimeoutException if the service has not reached the given state within the deadline

All the HTTP client configuration lives in `OkHttpClient` including proxy settings, timeouts, and caches. When you need to change the configuration of a single call, call `OkHttpClient.newBuilder()`. This returns a builder that shares the same connection pool, dispatcher, and configuration with the original client. In the example below, we make one request with a 500 ms timeout and another with a 3000 ms timeout.

=== ":material-language-kotlin: Kotlin"
    ```kotlin

      | * EventSourceListener
      | * WebSocketListener
      |(It is safe to call contentType() and contentLength() on these response bodies.)
      """.trimMargin(),
    )
  }

  override fun timeout() = Timeout.NONE

  override fun close() {
  }
}

fun Response.stripBody(): Response {
  return newBuilder()
    .body(UnreadableResponseBody(body.contentType(), body.contentLength()))
    .build()
}

      assertTrue(thread.isAlive());
    }
  }

  /** Checks that future.get times out, with the default timeout of {@code timeoutMillis()}. */
  void assertFutureTimesOut(Future<?> future) {
    assertFutureTimesOut(future, timeoutMillis());
  }

  /** Checks that future.get times out, with the given millisecond timeout. */
  void assertFutureTimesOut(Future<?> future, long timeoutMillis) {
    long startTime = System.nanoTime();

/**
 * @author mbechler
 *
 */
public class SmbComLockingAndX extends AndXServerMessageBlock {

    private int fid;
    private byte typeOfLock;
    private byte newOpLockLevel;
    private long timeout;
    private LockingAndXRange[] locks;
    private LockingAndXRange[] unlocks;
    private boolean largeFile;


    /**
     * @param config
     */
    public SmbComLockingAndX ( Configuration config ) {

	defer func() {
		if err != nil {
			if xnet.IsNetworkOrHostDown(err, false) {
				h.status.Store(statusOffline)
			}
			h.failedMessages.Add(int64(payloadCount))
		} else {
			h.status.Store(statusOnline)
		}
	}()

	ctx, cancel := context.WithTimeout(ctx, timeout)
	defer cancel()

      call.execute()
    }
    val elapsedNanos = System.nanoTime() - startNanos
    org.junit.jupiter.api.Assertions.assertTrue(
      elapsedNanos < TimeUnit.SECONDS.toNanos(5),
      "Timeout should have taken ~100ms but was " + elapsedNanos / 1e6 + " ms",
    )
  }

  @Test
  fun chainWithReadTimeout() {
    val interceptor1 =
      Interceptor { chainA: Interceptor.Chain ->

      assertTrue(thread.isAlive());
    }
  }

  /** Checks that future.get times out, with the default timeout of {@code timeoutMillis()}. */
  void assertFutureTimesOut(Future<?> future) {
    assertFutureTimesOut(future, timeoutMillis());
  }

  /** Checks that future.get times out, with the given millisecond timeout. */
  void assertFutureTimesOut(Future<?> future, long timeoutMillis) {
    long startTime = System.nanoTime();