closeHandleCaptor = ArgumentCaptor.forClass(MsrpcSamrCloseHandle.class);
    }

    @Test
    void constructor_shouldOpenDomainSuccessfully() throws IOException {
        // Arrange
        int access = 0x01; // Example access value
        // Simulate successful RPC call
        doAnswer(invocation -> {
            MsrpcSamrOpenDomain rpc = invocation.getArgument(0);

    }

    @Test
    @DisplayName("Default constructor sets the expected message and no cause")
    void defaultConstructor_setsExpectedMessage_andNoCause() {
        // Arrange & Act
        SmbUnsupportedOperationException ex = new SmbUnsupportedOperationException();

        // Assert
        assertEquals("Operation is not supported with the negotiated capabilities", ex.getMessage(),

    assertTrue(range.encloses(Range.closed(3, 4)));

    assertFalse(range.encloses(Range.openClosed(2, 5)));
    assertFalse(range.encloses(Range.closedOpen(2, 5)));
    assertFalse(range.encloses(Range.closed(1, 4)));
    assertFalse(range.encloses(Range.closed(3, 6)));
    assertFalse(range.encloses(Range.greaterThan(3)));
    assertFalse(range.encloses(Range.lessThan(3)));
    assertFalse(range.encloses(Range.atLeast(3)));

    assertEquals(
        ImmutableMap.of(Range.open(3, 7), 1, Range.closed(7, 10), 2, Range.closed(12, 16), 3),
        rangeMap.asMapOfRanges());

    sub.putCoalescing(Range.singleton(7), 1);
    assertEquals(
        ImmutableMap.of(Range.closed(5, 7), 1, Range.openClosed(7, 10), 2), sub.asMapOfRanges());
    assertEquals(
        ImmutableMap.of(

    assertTrue(rangeSet.intersects(Range.closed(3, 4)));
    assertTrue(rangeSet.intersects(Range.closedOpen(0, 2)));
    assertTrue(rangeSet.intersects(Range.closedOpen(3, 7)));
    assertTrue(rangeSet.intersects(Range.greaterThan(2)));
    assertFalse(rangeSet.intersects(Range.greaterThan(7)));

    assertTrue(rangeSet.encloses(Range.closed(3, 4)));

    @Mock
    Throwable mockCause;

    @Test
    @DisplayName("No-arg constructor: null message and cause; can be thrown")
    void defaultConstructor_behavesAsExpected() {
        // Arrange & Act
        SMBProtocolDecodingException ex = new SMBProtocolDecodingException();

        // Assert state
        assertNull(ex.getMessage(), "Default constructor should have null message");

    @DisplayName("renew() behaviors across implementations")
    void renewBehaviorsAcrossImplementations(String label, Supplier<SmbRenewableCredentials> supplier, boolean expectSame,
            boolean expectNew) {
        // Arrange: create an implementation instance
        SmbRenewableCredentials impl = supplier.get();

        // Act: call renew
        CredentialsInternal renewed = impl.renew();

        }
    }

    /**
     * Test that the constructor initializes all fields correctly
     */
    @Test
    public void testConstructor() {
        // Arrange
        int fid = 0x1234;
        int offset = 100;
        int remaining = 50;
        byte[] buffer = new byte[100];
        int off = 10;
        int len = 40;

        // Act

      return null;
    } else {
      Range<K> range = ranges.get(index);
      return range.contains(key) ? immutableEntry(range, values.get(index)) : null;
    }
  }

  @Override
  public Range<K> span() {
    if (ranges.isEmpty()) {
      throw new NoSuchElementException();
    }
    Range<K> firstRange = ranges.get(0);
    Range<K> lastRange = ranges.get(ranges.size() - 1);

  }

  /**
   * Returns an immutable range set containing the specified single range. If {@link Range#isEmpty()
   * range.isEmpty()}, this is equivalent to {@link ImmutableRangeSet#of()}.
   */
  public static <C extends Comparable> ImmutableRangeSet<C> of(Range<C> range) {
    checkNotNull(range);
    if (range.isEmpty()) {
      return of();
    } else if (range.equals(Range.all())) {
      return all();
    } else {