func (c *lockRESTClient) IsOnline() bool {
	return c.connection.State() == grid.StateConnected
}

// Not a local locker
func (c *lockRESTClient) IsLocal() bool {
	return false
}

// Close - marks the client as closed.
func (c *lockRESTClient) Close() error {
	return nil
}

// String - returns the remote host of the connection.
func (c *lockRESTClient) String() string {
	return c.connection.Remote
}

func clear[T ~[]Type | ~map[Type]Type1](t T)

// The close built-in function closes a channel, which must be either
// bidirectional or send-only. It should be executed only by the sender,
// never the receiver, and has the effect of shutting down the channel after
// the last sent value is received. After the last value has been received
// from a closed channel c, any receive from c will succeed without

  }

  public void testCopyToAppendable_doesNotCloseIfWriter() throws IOException {
    TestWriter writer = new TestWriter();
    assertFalse(writer.closed());
    source.copyTo(writer);
    assertFalse(writer.closed());
  }

  public void testClosesOnErrors_copyingToCharSinkThatThrows() {
    for (TestOption option : EnumSet.of(OPEN_THROWS, WRITE_THROWS, CLOSE_THROWS)) {

      )

    val part = parts.nextPart()!!
    parts.close()

    assertFailsWith<IllegalStateException> {
      part.body.request(10)
    }.also { expected ->
      assertThat(expected).hasMessage("closed")
    }
  }

  @Test fun `cannot call nextPart after calling close`() {
    val parts =
      MultipartReader(
        boundary = "simple boundary",

          .build(),
      )

    val exception =
      assertFailsWith<IOException> {
        call2.execute()
      }
    assertThat(exception.message).isIn("Socket closed", "Socket is closed")
  }

   * CharStreams} method returns a singleton writer whose {@code close} method has no effect, while
   * the {@link Writer#nullWriter()} method returns a new instance whose methods throw after the
   * instance is {@link Writer#close() closed}.
   *
   * @since 15.0
   */
  public static Writer nullWriter() {
    return NullWriter.INSTANCE;
  }

        }
    }

    /**
     * Closes the {@link Statement}.
     * <p>
     * If {@link Statement#close()} throws an exception, an error message is logged. The exception is not rethrown.
     * </p>
     *
     * @param statement
     *            {@link Statement}
     * @see Statement#close()
     */
    public static void close(final Statement statement) {
        if (statement == null) {

     */
    protected ResultSetUtil() {
    }

    /**
     * Closes the result set.
     * <p>
     * If {@link ResultSet#close()} throws an exception, an error message is logged. The exception is not rethrown.
     * </p>
     *
     * @param resultSet
     *            The result set
     */
    public static void close(final ResultSet resultSet) {
        if (resultSet == null) {
            return;

            lenient().doNothing().when((DcerpcHandle) handle).close();

            // Setup close to call real method which will then call our mocked components
            doCallRealMethod().when(handle).close();

            handle.close();

            verify(mockSmbPipeHandleInternal).close();
            verify(mockSmbNamedPipe).close();
        }

        @Test

        this.clientMap = clientMap;
    }

    /**
     * Closes all clients in the factory.
     */
    @Override
    public void close() {
        clientMap.values().stream().distinct().forEach(client -> {
            try {
                client.close();
            } catch (final Exception e) {
                logger.warn("Failed to close {}.", client.getClass().getCanonicalName(), e);
            }
        });