}

    @Test
    @DisplayName("Test with empty data")
    void testWithEmptyData() {
        // Given
        byte[] emptyData = new byte[0];
        transCallNamedPipe = new TransCallNamedPipe(mockConfig, TEST_PIPE_NAME, emptyData, 0, 0);
        byte[] dst = new byte[10];

        // When
        int bytesWritten = transCallNamedPipe.writeDataWireFormat(dst, 0);

        // Then

        assertEquals(0, msg.writeBytesWireFormat(null, index));
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, -1, 7 })
    @DisplayName("readParameterWordsWireFormat always returns 0")
    void readParameterWordsWireFormatReturnsZero(int index) {
        SmbComLogoffAndX msg = new SmbComLogoffAndX(null);
        assertEquals(0, msg.readParameterWordsWireFormat(new byte[5], index));

    StringBuilder builder = new StringBuilder();
    Writer writer = new AppendableWriter(builder);

    writer.append("Hello,");
    writer.append(' ');
    writer.append("The World Wide Web", 4, 9);
    writer.append("!");

    assertEquals("Hello, World!", builder.toString());
  }

  public void testCloseFlush() throws IOException {
    SpyAppendable spy = new SpyAppendable();

        MojoExecutionScope scope = new MojoExecutionScope();
        scope.enter();

        final AtomicInteger beforeExecution = new AtomicInteger();
        final AtomicInteger afterExecutionSuccess = new AtomicInteger();
        final AtomicInteger afterExecutionFailure = new AtomicInteger();
        final WeakMojoExecutionListener instance = new WeakMojoExecutionListener() {
            @Override

        try {
            return new Settings(delegate.read(reader, strict, null));
        } catch (XMLStreamException e) {
            throw new XmlPullParserException(e.getMessage(), null, e);
        }
    }

    public Settings read(Reader reader) throws IOException, XmlPullParserException {
        try {
            return new Settings(delegate.read(reader));
        } catch (XMLStreamException e) {

            byte[] emptyFileId = new byte[16];
            assertDoesNotThrow(() -> new Smb2WriteRequest(mockConfig, emptyFileId));
        }
    }

    @Nested
    @DisplayName("FileId Tests")
    class FileIdTests {

        @Test
        @DisplayName("Should set file ID correctly")
        void testSetFileId() {
            byte[] newFileId = new byte[16];
            new SecureRandom().nextBytes(newFileId);

  @Override
  public void setUp() {
    fakePool = new FakeExecutor();
    e = new SequentialExecutor(fakePool);
  }

  public void testConstructingWithNullExecutor_fails() {
    assertThrows(NullPointerException.class, () -> new SequentialExecutor(null));
  }

  public void testBasics() {
    AtomicInteger totalCalls = new AtomicInteger();
    Runnable intCounter =
        new Runnable() {
          @Override

        Properties props = new Properties();
        props.setProperty("jcifs.smb.client.useMultiChannel", "false");

        PropertyConfiguration config = new PropertyConfiguration(props);
        assertFalse(config.isUseMultiChannel());

        props.setProperty("jcifs.smb.client.useMultiChannel", "true");
        config = new PropertyConfiguration(props);
        assertTrue(config.isUseMultiChannel());

            final ExtractData extractData = new ExtractData(new String(FileUtil.readBytes(outputFile), outputEncoding));
            if (StringUtil.isNotBlank(resourceName)) {
                extractData.putValues("resourceName", new String[] { resourceName });
            }

            return extractData;
        } catch (final IOException e) {
            throw new ExtractException("Could not extract a content.", e);

    }

    @Test
    @DisplayName("Test force cleanup")
    @Timeout(value = 5, unit = TimeUnit.SECONDS)
    void testForceCleanup() {
        TestResource resource1 = new TestResource("cleanup1");
        TestResource resource2 = new TestResource("cleanup2");

        resourceManager.registerResource(resource1);
        resourceManager.registerResource(resource2);

        assertFalse(resource1.isClosed());