assertEquals(4, SMBUtil.readInt2(buf, offset));
        // Reserved (2 bytes, LE) == 0
        assertEquals(0, SMBUtil.readInt2(buf, offset + 2));
    }

    @Test
    @DisplayName("writeBytesWireFormat throws when buffer too small")
    void writeBytesWireFormat_throwsIfInsufficientSpace() {
        // Arrange
        Smb2LogoffRequest req = newRequest();
        byte[] tiny = new byte[3]; // less than 4 bytes available

import java.io.IOException;
import java.util.Map;

import org.codelibs.fess.unit.UnitFessTestCase;

public class EncodingFilterTest extends UnitFessTestCase {
    public void test_normal() throws IOException {
        final EncodingFilter filter = new EncodingFilter();
        Map<String, String[]> paramMap;

        paramMap = filter.parseQueryString("a=1", "UTF-8");
        assertEquals(1, paramMap.size());

public class FessTimeResourceProviderTest extends UnitFessTestCase {

    private FessTimeResourceProvider provider;
    private FessConfig mockConfig;

    @Override
    public void setUp() throws Exception {
        super.setUp();

        // Create FessConfig mock
        mockConfig = new FessConfig.SimpleImpl() {
            private static final long serialVersionUID = 1L;

            @Override

    private FessConfig originalFessConfig;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        ComponentUtil.register(new SystemHelper(), "systemHelper");
        apiFailureHook = new FessApiFailureHook();
        originalFessConfig = ComponentUtil.getFessConfig();
    }

    @Override
    public void tearDown() throws Exception {
        if (originalFessConfig != null) {

    private RequestManager requestManager;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        provider = new FessUserTimeZoneProcessProvider();
        requestManager = createMockRequestManager();
    }

    @Override
    public void tearDown() throws Exception {
        provider = null;
        requestManager = null;
        super.tearDown();
    }

     */
    public boolean isValidResponse() {
        return isSuccess() && responseSequenceNumber == sequenceNumber;
    }

    @Override
    protected void encodeWitnessParameters(NdrBuffer buf) throws NdrException {
        // Encode input parameters for WitnessHeartbeat

        // Context handle (20 bytes)
        if (contextHandle != null) {

    public void getArtifact(Artifact artifact, ArtifactRepository repository)
            throws TransferFailedException, ResourceDoesNotExistException {
        getArtifact(artifact, repository, null, false);
    }

    @Override
    public void getArtifact(Artifact artifact, List<ArtifactRepository> remoteRepositories)
            throws TransferFailedException, ResourceDoesNotExistException {

import org.dbflute.utflute.core.PlainTestCase;

public class HandlerTest extends PlainTestCase {
    @Override
    protected void setUp() throws Exception {
        super.setUp();
        new StandardCrawlerContainer();
    }

    public void test_protocol() throws Exception {
        URL url = new URL("storage:/home/foo");
        assertEquals("storage", url.getProtocol());
    }

        itr.next();
        assertThat(itr.hasNext(), is(true));
        itr.next();
        assertThat(itr.hasNext(), is(not(true)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testRemove() throws Exception {
        exception.expect(ClUnsupportedOperationException.class);
        exception.expectMessage(is("remove"));

    tester.testAllPublicStaticMethods(Hashing.class);
  }

  public void testSeedlessHashFunctionEquals() throws Exception {
    assertSeedlessHashFunctionEquals(Hashing.class);
  }

  public void testSeededHashFunctionEquals() throws Exception {
    assertSeededHashFunctionEquals(Hashing.class);
  }

  /**