*/
    protected int uid;
    /**
     * Multiplex identifier for correlating requests and responses.
     */
    protected int mid;
    /**
     * Count of parameter words in the SMB message.
     */
    protected int wordCount;
    /**
     * Count of data bytes in the SMB message.
     */
    protected int byteCount;
    /**
     * Tree identifier for the connected share.
     */

        // Then
        assertArrayEquals(testFileId, customRequest.getFileId(), "Custom implementation should store file ID correctly");
        assertEquals(1, customRequest.getSetCount(), "Should track set count correctly");
    }

            assertEquals(EncryptionNegotiateContext.CIPHER_AES128_GCM, SMBUtil.readInt2(buffer, 4));
        }

        @Test
        @DisplayName("Should encode null ciphers as zero count")
        void testEncodeNullCiphers() {
            EncryptionNegotiateContext context = new EncryptionNegotiateContext(mockConfig, null);

            int bytesWritten = context.encode(buffer, 0);

    }

    @Override
    Multiset<E> delegate() {
      return (Multiset<E>) super.delegate();
    }

    @Override
    public int count(@Nullable Object o) {
      synchronized (mutex) {
        return delegate().count(o);
      }
    }

    @Override
    public int add(@ParametricNullness E e, int n) {
      synchronized (mutex) {
        return delegate().add(e, n);
      }

    }

    @Override
    Multiset<E> delegate() {
      return (Multiset<E>) super.delegate();
    }

    @Override
    public int count(@Nullable Object o) {
      synchronized (mutex) {
        return delegate().count(o);
      }
    }

    @Override
    public int add(@ParametricNullness E e, int n) {
      synchronized (mutex) {
        return delegate().add(e, n);
      }

        src[0] = 0x00;
        src[1] = 0x01; // Transaction ID
        src[2] = 0x00; // Flags
        src[3] = 0x00; // Flags
        src[4] = 0x00;
        src[5] = 0x01; // Question count

        // Act
        int result = nodeStatusRequest.readWireFormat(src, 0);

        // Assert
        assertTrue(result >= NameServicePacket.HEADER_LENGTH);
    }

    @Test

      int before = processCalled;
      super.processRemaining(bb);
      int after = processCalled;
      assertEquals(before + 1, after); // default implementation pads and calls process()
      processCalled--; // don't count the tail invocation (makes tests a bit more understandable)
    }

    // ensures that the number of invocations looks sane
    void assertInvariants(int expectedBytes) {

     * the web socket! It's possible that we're writing faster than the peer can read.
     */
    private const val MAX_QUEUE_SIZE = 16L * 1024 * 1024 // 16 MiB.

    /**
     * The maximum amount of time after the client calls [close] to wait for a graceful shutdown. If
     * the server doesn't respond the web socket will be canceled.
     */
    const val CANCEL_AFTER_CLOSE_MILLIS = 60L * 1000

    /**

        long count = client.prepareSearch(TEST_INDEX)
                .setQuery(QueryBuilders.termQuery("field", "value1"))
                .execute()
                .actionGet()
                .getHits()
                .getTotalHits()
                .value();
        assertEquals(0, count);
    }

    @Test
    public void testDeleteByQueryWithNoMatches() {

        when(handle.getPipe()).thenReturn(pipe);
        when(tree.isSMB2()).thenReturn(smb2);
        return new SmbPipeInputStream(handle, tree);
    }

    @Test
    @DisplayName("available() on SMB2 returns peeked byte count and interacts with tree")
    void available_smb2_happyPath() throws Exception {
        // Verify SMB2 path: IOCTL peek result is returned and resources are closed
        SmbPipeInputStream stream = newStreamWithMinimalStubs(true);