int getMaxMessageSize();

    /**
     * Clean up provider resources
     *
     * This method should be called when the provider is no longer needed
     * to release any system resources.
     */
    void shutdown();

            // Verify
            assertNotNull(result);
            assertEquals(1, result.size());
            assertEquals(fileNotifyInfo1, result.get(0));
        } finally {
            executor.shutdown();
        }
    }

    /**
     * Test close() method
     */
    @Test
    void testClose() throws CIFSException {
        // Execute
        watchHandle.close();

  @StartStop
  private val server = MockWebServer()

  private val socksProxy = SocksProxy()

  @BeforeEach
  fun setUp() {
    socksProxy.play()
  }

  @AfterEach
  fun tearDown() {
    socksProxy.shutdown()
  }

  @Test
  fun proxy() {
    server.enqueue(MockResponse.Builder().body("abc").build())
    server.enqueue(MockResponse.Builder().body("def").build())
    val client =
      clientTestRule

            throw new AssertionError(
                "ForwardingExecutorService should have used the default method"
                    + " ExecutorService.close() (which would forward to methods like shutdown() on"
                    + " the delegate) instead of forwarding to delegate.close()");
          }
        };
    ExecutorService wrapper =
        new ForwardingExecutorService() {
          @Override

    ListeningScheduledExecutorService executor = TestingExecutors.noOpScheduledExecutor();
    assertFalse(executor.isShutdown());
    assertFalse(executor.isTerminated());
    executor.shutdown();
    assertTrue(executor.isShutdown());
    assertTrue(executor.isTerminated());
  }

  public void testNoOpScheduledExecutorInvokeAll() throws ExecutionException, InterruptedException {

    ListeningScheduledExecutorService executor = TestingExecutors.noOpScheduledExecutor();
    assertFalse(executor.isShutdown());
    assertFalse(executor.isTerminated());
    executor.shutdown();
    assertTrue(executor.isShutdown());
    assertTrue(executor.isTerminated());
  }

  public void testNoOpScheduledExecutorInvokeAll() throws ExecutionException, InterruptedException {

    }

    @Test
    public void testShutdown() {
        // Should not throw exception
        assertDoesNotThrow(() -> provider.shutdown());
    }

    }

    @AfterEach
    public void tearDown() throws Exception {
        if (directoryLeaseManager != null) {
            directoryLeaseManager.shutdown();
        }
        if (baseLeaseManager != null) {
            baseLeaseManager.shutdown();
        }
        if (mocks != null) {
            mocks.close();
        }
    }

    @Test

        },
    )
  }

  public open fun setFailFast(failFastResponse: MockResponse?) {
    this.failFastResponse = failFastResponse
  }

  private companion object {
    /**
     * Enqueued on shutdown to release threads waiting on [dispatch]. Note that this response
     * isn't transmitted because the connection is closed before this response is returned.
     */

            fileCache.remove(path);
        }
    }

    /**
     * Shutdown the lease manager
     */
    public void shutdown() {
        log.info("Shutting down lease manager");

        // Stop cleanup executor
        if (cleanupExecutor != null) {
            cleanupExecutor.shutdown();
            try {
                if (!cleanupExecutor.awaitTermination(5, TimeUnit.SECONDS)) {