}
        return ranges;
    }

    private static class RangeValue {
        private String value;

        private boolean closed;

        RangeValue(String value, boolean closed) {
            this.value = value.trim();
            this.closed = closed;
        }

        @Override
        public String toString() {
            return value;
        }
    }

        }
    }

    @Override
    public void close() throws IOException {
        state = RdmaConnectionState.CLOSING;

        try {
            if (socketChannel != null) {
                socketChannel.close();
            }
        } finally {
            state = RdmaConnectionState.CLOSED;
        }

        log.debug("TCP RDMA connection closed");
    }

          val source = Buffer().writeUtf8("hello")
          return object : ForwardingSource(source) {
            override fun close() {
              closed = true
              super.close()
            }
          }.buffer()
        }
      }
    body.source().close()
    assertThat(closed).isTrue()
  }

  @Test
  fun throwingUnderlyingSourceClosesQuietly() {
    val body: ResponseBody =

        if (rpc.retval != 0) {
            throw new SmbException(rpc.retval, false);
        }
    }

    /**
     * Closes this SAM alias handle.
     *
     * @throws IOException if an I/O error occurs during handle closure
     */
    public void close() throws IOException {
        final MsrpcSamrCloseHandle rpc = new MsrpcSamrCloseHandle(this);
        handle.sendrecv(rpc);
        if (rpc.retval != 0) {

    assertThat(sink.getString()).isEqualTo(STRING);
  }

  public void testWriteFromStream_doesNotCloseThatStream() throws IOException {
    TestReader in = new TestReader();
    assertFalse(in.closed());
    sink.writeFrom(in);
    assertFalse(in.closed());
  }

  public void testWriteLines_withSpecificSeparator() throws IOException {
    sink.writeLines(ImmutableList.of("foo", "bar", "baz"), "\n");

        assertArgumentNotNull("zis", zis);

        try {
            zis.reset();
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Closes the {@link ZipInputStream}.
     * <p>
     * If {@link ZipInputStream#closeEntry()} throws an exception, an error message is logged.
     * The exception is not rethrown.
     * </p>
     *
     * @param zis

    }

    @Test
    @DisplayName("Test initial state is CLOSED")
    void testInitialState() {
        assertEquals(SimpleCircuitBreaker.State.CLOSED, circuitBreaker.getState());
        assertTrue(circuitBreaker.allowsRequests());
    }

    @Test
    @DisplayName("Test successful calls in CLOSED state")
    void testSuccessfulCalls() throws Exception {

// When the returned WriteCloser is closed, it will wait for all data to be read before returning.
func (r *RingBuffer) WriteCloser() io.WriteCloser {
	return &writeCloser{RingBuffer: r}
}

type writeCloser struct {
	*RingBuffer
}

// Close provides a close method for the WriteCloser.
func (wc *writeCloser) Close() error {
	wc.CloseWriter()
	return wc.Flush()

     * Checks if storage is properly configured and accessible.
     *
     * @return true if storage is available
     */
    boolean isAvailable();

    /**
     * Closes the client and releases resources.
     */
    @Override
    void close();

	}

	if err := target.send(eventData); err != nil {
		return err
	}

	// Delete the event from store.
	return target.store.Del(key)
}

// Close - closes underneath connections to NSQD server.
func (target *NSQTarget) Close() (err error) {
	close(target.quitCh)
	if target.producer != nil {
		// this blocks until complete:
		target.producer.Stop()
	}
	return nil
}