fileInternalInfo.decode(buffer3, 0, buffer3.length);
        assertEquals(indexNumber3, fileInternalInfo.getIndexNumber());
    }

    @Test
    @DisplayName("Test toString method")
    void testToString() throws SMBProtocolDecodingException {
        // Setup test data
        byte[] buffer = new byte[8];
        long expectedIndexNumber = 0x9876543210ABCDEFL;
        SMBUtil.writeInt8(expectedIndexNumber, buffer, 0);

    ExecutionException expected =
        assertThrows(ExecutionException.class, () -> first.get(10, SECONDS));
    assertThat(expected).hasCauseThat().isInstanceOf(RejectedExecutionException.class);
  }

  public void testToString() {
    Runnable[] currentTask = new Runnable[1];
    Executor delegate =
        new Executor() {
          @Override
          public void execute(Runnable task) {
            currentTask[0] = task;

        // Then
        assertEquals(0, bytesRead);
    }

    @Test
    @DisplayName("Test toString method")
    void testToString() {
        // Given
        transCallNamedPipe = new TransCallNamedPipe(mockConfig, TEST_PIPE_NAME, TEST_DATA, 0, TEST_DATA.length);

        // When
        String result = transCallNamedPipe.toString();

        assertEquals(smb1.hashCode(), smb2.hashCode());
        assertNotEquals(smb1.hashCode(), smb3.hashCode());
        assertNotEquals(smb1, new Object());
    }

    @Test
    void testToString() {
        smb.command = ServerMessageBlock.SMB_COM_ECHO;
        smb.errorCode = 0;
        smb.mid = 1;
        String str = smb.toString();
        assertTrue(str.contains("command=SMB_COM_ECHO"));

        assertThat(expectSuccess).isTrue();
      } catch (IllegalArgumentException e) {
        assertThat(expectSuccess).isFalse();
      }
    }
  }

  public void testToString() {
    for (long value : TEST_LONGS) {
      UnsignedLong unsignedValue = UnsignedLong.fromLongBits(value);
      assertThat(unsignedValue.toString()).isEqualTo(unsignedValue.bigIntegerValue().toString());
    }
  }

        assertEquals(dataSize, result);
        for (int i = 0; i < dataSize; i++) {
            assertEquals(sourceData[i], outputBuffer[i]);
        }
    }

    @Test
    void testToString() {
        String result = response.toString();
        assertNotNull(result);
        assertTrue(result.startsWith("TransCallNamedPipeResponse["));
        assertTrue(result.endsWith("]"));
    }

        byte[] buffer = new byte[256];
        int bytesWritten = response.writeBytesWireFormat(buffer, 0);

        assertEquals(0, bytesWritten);
    }

    @Test
    void testToString() {
        // Test toString method
        response = new SmbComQueryInformationResponse(mockConfig, 0L);

        // Set test values
        setFieldValue(response, "fileAttributes", 0x0021);

        // Then
        assertEquals(0, result);
    }

    /**
     * Test toString method
     */
    @Test
    @DisplayName("Test toString returns properly formatted string")
    public void testToString() {
        // Given
        String oldFileName = "oldFile.txt";
        String newFileName = "newFile.txt";
        smbComRename = new SmbComRename(config, oldFileName, newFileName);

        // When

        assertEquals(expectedOffset, notifyInfo.getNextEntryOffset());
    }

    @Test
    @DisplayName("Test toString contains expected information")
    void testToString() throws SMBProtocolDecodingException {
        String fileName = "log.txt";
        int action = FileNotifyInformation.FILE_ACTION_MODIFIED;
        byte[] buffer = createValidNotificationBuffer(fileName, action);

    }

    @Nested
    @DisplayName("toString() Tests")
    class ToStringTests {

        @Test
        @DisplayName("toString() should return correctly formatted UUID string")
        void testToString() {
            // Arrange
            rpc.uuid_t rpcUuid = new rpc.uuid_t();
            rpcUuid.time_low = TIME_LOW;
            rpcUuid.time_mid = TIME_MID;