verify(mockDeferredNdrBuffer, times(9)).enc_ndr_long(anyInt()); // 3 enc_ndr_long for each of 3 unicode strings
        verify(mockDeferredNdrBuffer, times(3)).enc_ndr_long(0);
        verify(mockDeferredNdrBuffer, times(3)).advance(anyInt());
        verify(mockDeferredNdrBuffer, times(4)).derive(anyInt()); // 3 for strings + 1 for guid
        verify(mockDeferredNdrBuffer, times(18)).enc_ndr_short(0); // 5+6+7 shorts with value 0

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.timer;

import java.lang.reflect.Method;

import org.codelibs.core.timer.TimeoutTarget;
import org.codelibs.fess.unit.UnitFessTestCase;

/**
 * Test class for SystemMonitorTarget.
 */
public class SystemMonitorTargetTest extends UnitFessTestCase {

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.timer;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.function.Supplier;

import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.commons.text.StringEscapeUtils;
import org.codelibs.core.timer.TimeoutTarget;
import org.codelibs.fess.Constants;

        assertEquals(400L, mockAllocInfo.getFree(), "free space should match stubbed value");
        verify(mockAllocInfo, times(1)).getCapacity();
        verify(mockAllocInfo, times(1)).getFree();
    }

    /**
     * Parameterised test of capacity values, including edge cases such as
     * zero and negative capacities.
     */
    @ParameterizedTest

        // Act
        pipe.customizeCreate(req, resp);

        // Assert: verify interactions with dependencies
        verify(req, times(1)).addFlags0(0x16);
        verify(resp, times(1)).setExtended(true);
        verify(resp, never()).setExtended(false);
    }

    @Test
    @DisplayName("openPipe returns a handle bound to this pipe")

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

import java.io.IOException;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;

        return status == STOPPED;
    }

    /**
     * Stops the timer.
     */
    public void stop() {
        if (status != ACTIVE) {
            throw new ClIllegalStateException(String.valueOf(status));
        }
        status = STOPPED;
    }

    /**
     * Restarts the timer.
     */
    public void restart() {
        status = ACTIVE;

        h.close(777L);

        // Verify SMB2 close path
        verify(tree, times(1)).send(isA(Smb2CloseRequest.class), eq(RequestParam.NO_RETRY));
        // Tree is always released in finally
        verify(tree, times(1)).release();
    }

    @Test
    @DisplayName("close(long) sends SMB1 close request and releases tree when SMB1")

        Assertions.assertEquals(19L, s);

        Mockito.verify(mock, Mockito.times(1)).getAttributes();
        Mockito.verify(mock, Mockito.times(1)).getCreateTime();
        Mockito.verify(mock, Mockito.times(1)).getLastWriteTime();
        Mockito.verify(mock, Mockito.times(1)).getLastAccessTime();
        Mockito.verify(mock, Mockito.times(1)).getSize();
        Mockito.verifyNoMoreInteractions(mock);
    }

        // getConfig() is called twice: once in Kerb5Authenticator and once in NtlmPasswordAuthenticator
        verify(tc, times(2)).getConfig();
        verify(config, times(1)).isAllowNTLMFallback();
        verify(config, times(1)).isUseRawNTLM();
    }

    @Test
    @DisplayName("refresh: throws unsupported operation")
    void refresh_throwsUnsupported() {