assertTrue(Range.closed(5, 6).isConnected(Range.closed(3, 5)));
    assertTrue(Range.closed(3, 5).isConnected(Range.openClosed(5, 5)));
    assertTrue(Range.open(3, 5).isConnected(Range.closed(5, 6)));
    assertTrue(Range.closed(3, 7).isConnected(Range.open(6, 8)));
    assertTrue(Range.open(3, 7).isConnected(Range.closed(5, 6)));
    assertFalse(Range.closed(3, 5).isConnected(Range.closed(7, 8)));

    rangeSet.add(Range.closed(3, 6));
    rangeSet.remove(Range.closed(6, 9));
    testInvariants(rangeSet);
    assertThat(rangeSet.asRanges()).containsExactly(Range.closedOpen(3, 6));
  }

  public void testRemoveExact() {
    TreeRangeSet<Integer> rangeSet = TreeRangeSet.create();
    rangeSet.add(Range.closed(3, 6));
    rangeSet.remove(Range.closed(3, 6));
    testInvariants(rangeSet);

    assertEquals(
        ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(9, 10), 2), sub.asMapOfRanges());
    sub.putCoalescing(Range.closed(7, 9), 2);
    assertEquals(
        ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(7, 10), 2), sub.asMapOfRanges());
    assertEquals(
        ImmutableMap.of(Range.open(3, 7), 1, Range.closed(7, 10), 2, Range.closed(12, 16), 3),

    TestInputStream in = new TestInputStream(new ByteArrayInputStream(new byte[10]));
    assertFalse(in.closed());
    sink.writeFrom(in);
    assertFalse(in.closed());
  }

  public void testClosesOnErrors_copyingFromByteSourceThatThrows() {
    for (TestOption option : EnumSet.of(OPEN_THROWS, READ_THROWS, CLOSE_THROWS)) {
      TestByteSource failSource = new TestByteSource(new byte[10], option);

   *
   * @param inputStream the input stream to be closed, or {@code null} in which case this method
   *     does nothing
   * @since 17.0
   */
  public static void closeQuietly(@CheckForNull InputStream inputStream) {
    try {
      close(inputStream, true);
    } catch (IOException impossible) {
      throw new AssertionError(impossible);
    }
  }

  /**

    }

    @Override
    BoundType typeAsLowerBound() {
      return BoundType.CLOSED;
    }

    @Override
    BoundType typeAsUpperBound() {
      return BoundType.OPEN;
    }

    @Override
    Cut<C> withLowerBoundType(BoundType boundType, DiscreteDomain<C> domain) {
      switch (boundType) {
        case CLOSED:
          return this;
        case OPEN:

    flush();
  }

  @Override
  public void write(String str, int off, int len) throws IOException {
    super.write(str, off, len);
    flush();
  }

  public boolean closed() {
    return out.closed();
  }

    assertEquals(
        GeneralRange.range(ORDERING, 3, CLOSED, 4, OPEN),
        range.intersect(GeneralRange.range(ORDERING, 3, CLOSED, 4, CLOSED)));
  }

  public void testIntersectOverlappingRange() {
    GeneralRange<Integer> range = GeneralRange.range(ORDERING, 2, OPEN, 4, CLOSED);
    assertEquals(
        GeneralRange.range(ORDERING, 3, CLOSED, 4, CLOSED),

    Writer writer = new AppendableWriter(spy);

    writer.write("Hello");
    assertFalse(spy.flushed);
    assertFalse(spy.closed);

    writer.flush();
    assertTrue(spy.flushed);
    assertFalse(spy.closed);

    writer.close();
    assertTrue(spy.flushed);
    assertTrue(spy.closed);
  }

  public void testCloseIsFinal() throws IOException {
    StringBuilder builder = new StringBuilder();

        ImmutableRangeSet.<Integer>builder()
            .add(Range.closed(5, 8))
            .add(Range.closedOpen(1, 3))
            .build();

    assertThat(rangeSet.asRanges())
        .containsExactly(Range.closedOpen(1, 3), Range.closed(5, 8))
        .inOrder();

    assertTrue(rangeSet.intersects(Range.closed(1, 2)));
    assertTrue(rangeSet.intersects(Range.open(5, 8)));