*
         * @param active true to activate
         */
        public void setActive(boolean active) {
            this.active = active;
        }

        /**
         * Gets the future for asynchronous notification completion
         * @return the notification future
         */
        public CompletableFuture<Void> getNotificationFuture() {
            return notificationFuture;
        }

            super(new byte[16], false);
        }

        @Override
        void sign(byte[] data, int offset, int length, ServerMessageBlock request, ServerMessageBlock response) {
            called = true;
            lastLength = length;
        }
    }

    @Test
    @DisplayName("Constructor with andx sets next command")
    void testConstructorWithAndx() {
        DummyPlainSMB next = new DummyPlainSMB();

@ExtendWith(MockitoExtension.class)
class SmbWatchHandleImplTest {

    @Mock
    SmbFileHandleImpl handle;

    @Mock
    SmbTreeHandleImpl tree;

    // Prepare SMB2 flow with a given response
    private void setupSmb2(NotifyResponse resp, byte[] fileId) throws Exception {
        when(handle.isValid()).thenReturn(true);
        when(handle.getTree()).thenReturn(tree);
        when(tree.isSMB2()).thenReturn(true);

    @Test
    @DisplayName("Should test interface with anonymous implementation")
    void testAnonymousImplementation() {
        // Given
        byte[] capturedFileId = new byte[1];
        RequestWithFileId anonymousImpl = new RequestWithFileId() {
            private byte[] fileId;

            @Override
            public void setFileId(byte[] fileId) {
                this.fileId = fileId;

    private CommonServerMessageBlock message;

    private byte[] testData;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        testData = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
    }

    @Test
    @DisplayName("Test sign method with valid parameters")
    void testSignWithValidParameters() {
        // Arrange
        int offset = 0;

    @BeforeEach
    public void setUp() throws CIFSException {
        MockitoAnnotations.openMocks(this);
        config = new PropertyConfiguration(new Properties());
    }

    /**
     * Test constructor initialization with valid parameters
     */
    @Test
    @DisplayName("Test constructor initializes fields correctly")
    public void testConstructor() throws Exception {
        // Given

    void constructor_nullTree_byteArray_throwsNPE() {
        lenient().when(cfg.isTraceResourceUsage()).thenReturn(false);
        assertThrows(NullPointerException.class,
                () -> new SmbFileHandleImpl(cfg, new byte[] { 1, 2 }, null, "//server/share", 0, 0, 0, 0, 0L));
    }

    @Test
    @DisplayName("Constructor with null cfg throws NPE")
    void constructor_nullCfg_throwsNPE() {

    logHandler.clear();
    return logRecord.getThrown();
  }

  private void checkNothingLogged() {
    assertThat(logHandler.getStoredLogRecords()).isEmpty();
  }

  private void checkLoggedCause(Throwable t) {
    assertThat(popLoggedThrowable()).hasCauseThat().isSameInstanceAs(t);
  }

  private void checkLoggedInvalidLoad() {
    assertThat(popLoggedThrowable()).isInstanceOf(InvalidCacheLoadException.class);

 */
public class RdmaProviderFactoryTest {

    @Test
    public void testCreateProviderAuto() {
        RdmaProvider provider = RdmaProviderFactory.createProvider("auto");
        assertNotNull(provider, "Auto provider selection should return a provider");
        assertTrue(provider.isAvailable(), "Returned provider should be available");
    }

    @Test
    public void testCreateProviderTcp() {

 *
 * @author Eric Chang
 */
public class TestingExecutorsTest extends TestCase {
  private volatile boolean taskDone;

  public void testNoOpScheduledExecutor() throws InterruptedException {
    taskDone = false;
    Runnable task =
        new Runnable() {
          @Override
          public void run() {
            taskDone = true;
          }
        };
    ScheduledFuture<?> future =