return 0;
    }

    /**
     * {@inheritDoc}
     *
     * @throws SMBProtocolDecodingException if there is an error decoding the response
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#readBytesWireFormat(byte[], int)
     */
    @Override
    protected int readBytesWireFormat(final byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
        final int start = bufferIndex;

    @Nested
    @DisplayName("Decode Method Tests")
    class DecodeMethodTests {

        @Test
        @DisplayName("Should decode buffer with typical values correctly")
        void shouldDecodeBufferWithTypicalValues() throws SMBProtocolDecodingException {
            // Given - prepare buffer with typical file system values
            ByteBuffer buffer = ByteBuffer.allocate(32);
            buffer.order(ByteOrder.LITTLE_ENDIAN);

import org.codelibs.fess.suggest.request.suggest.SuggestResponse;
import org.junit.Test;

public class DeferredTest {
    @Test
    public void test_doneBeforeResolve() throws Exception {
        final Deferred<SuggestResponse> deferred = new Deferred<>();

        Thread th = new Thread(() -> {
            try {
                Thread.sleep(1000);

            assertEquals(0, buffer[2]); // salt length
            assertEquals(0, buffer[3]);
        }

        @Test
        @DisplayName("Should decode context correctly")
        void testDecode() throws SMBProtocolDecodingException {
            // Arrange
            context = new PreauthIntegrityNegotiateContext();
            byte[] buffer = new byte[] { 0x02, 0x00, // 2 hash algos

  }

  public void testMethod_notDeclaredByType() throws NoSuchMethodException {
    Method sizeMethod = Map.class.getMethod("size");
    assertThrows(IllegalArgumentException.class, () -> TypeToken.of(List.class).method(sizeMethod));
  }

  public void testMethod_declaredBySuperclass() throws Exception {
    Method toStringMethod = Object.class.getMethod("toString");

    sortedMap.put("two", 2);
    sortedMap.put("three", 3);
    return sortedMap;
  }

  @Override
  protected String getKeyNotInPopulatedMap() throws UnsupportedOperationException {
    return "minus one";
  }

  @Override
  protected Integer getValueNotInPopulatedMap() throws UnsupportedOperationException {
    return -1;
  }

  @J2ktIncompatible // https://youtrack.jetbrains.com/issue/KT-58242/ undefined behavior (crash)

    /**
     *
     * @return this pipe's output stream
     * @throws CIFSException if an error occurs
     */
    @Override
    SmbPipeOutputStream getOutput() throws CIFSException;

    /**
     * Ensures that the tree connection is established and returns it.
     *
     * @return tree connection
     * @throws CIFSException if an error occurs connecting to the tree
     */

    @Deprecated(
      message = "moved to var",
      replaceWith = ReplaceWith(expression = "level"),
      level = DeprecationLevel.ERROR,
    )
    fun getLevel(): Level = level

    @Throws(IOException::class)
    override fun intercept(chain: Interceptor.Chain): Response {
      val level = this.level

      val request = chain.request()
      if (level == Level.NONE) {

    @BeforeEach
    void setUp() throws Exception {
        domainSid = new SID("S-1-5-21-1-2-3");
        userSid = new SID("S-1-5-21-1-2-3-1000");
    }

    private void writeLittleEndianShort(DataOutputStream dos, short value) throws IOException {
        dos.writeShort(Short.reverseBytes(value));
    }

    private void writeLittleEndianInt(DataOutputStream dos, int value) throws IOException {

    @Test
    void testLsarCloseEncodeIn() throws NdrException {
        rpc.policy_handle mockHandle = mock(rpc.policy_handle.class);
        lsarpc.LsarClose lsarClose = new lsarpc.LsarClose(mockHandle);

        lsarClose.encode_in(mockNdrBuffer);

        verify(mockHandle).encode(mockNdrBuffer);
    }

    @Test
    void testLsarCloseDecodeOut() throws NdrException {