</c:when>
                                <c:when test="${f:h(allRecordCount) > 0}">
                                    <div id="subheader" class="row top10">
                                        <div class="col-12">
                                            <c:if test="${allRecordCountRelation=='EQUAL_TO'}">

      MockResponse
        .Builder()
        .code(HttpURLConnection.HTTP_MOVED_TEMP)
        .setHeader("Location", "/b")
        .headersDelay(100, TimeUnit.MILLISECONDS)
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .code(HttpURLConnection.HTTP_MOVED_TEMP)
        .setHeader("Location", "/c")
        .headersDelay(100, TimeUnit.MILLISECONDS)
        .build(),
    )

        ComponentUtil.setFessConfig(null);
        super.tearDown();
    }

    // Test with no Origin header
    public void test_doFilter_noOriginHeader() throws IOException, ServletException {
        mockRequest.setHeader("Origin", null);

        corsFilter.doFilter(mockRequest, mockResponse, mockFilterChain);

        assertTrue(mockFilterChain.wasDoFilterCalled());
        assertFalse(corsHandlerFactory.wasGetCalled());
    }

  @Test
  @Throws(IOException::class)
  fun wrongConnectionHeader() {
    webServer.enqueue(
      MockResponse
        .Builder()
        .code(101)
        .setHeader("Upgrade", "websocket")
        .setHeader("Connection", "Downgrade")
        .setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk=")
        .build(),
    )
    webServer.enqueue(
      MockResponse
        .Builder()

        @DisplayName("Test decode basic message")
        void testDecodeBasicMessage() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[1024];
            System.arraycopy(SMBUtil.SMB_HEADER, 0, buffer, 0, SMBUtil.SMB_HEADER.length);

            buffer[SmbConstants.CMD_OFFSET] = 0x25;
            SMBUtil.writeInt4(0, buffer, SmbConstants.ERROR_CODE_OFFSET);
            buffer[SmbConstants.FLAGS_OFFSET] = 0x12;

    void testSMBHeader() {
        assertNotNull(SMBUtil.SMB_HEADER);
        assertEquals(24, SMBUtil.SMB_HEADER.length);

        // Verify SMB header signature
        assertEquals((byte) 0xFF, SMBUtil.SMB_HEADER[0]);
        assertEquals((byte) 'S', SMBUtil.SMB_HEADER[1]);
        assertEquals((byte) 'M', SMBUtil.SMB_HEADER[2]);
        assertEquals((byte) 'B', SMBUtil.SMB_HEADER[3]);

        // Verify remaining bytes are zeros

        when(request.getHeader("Authorization")).thenReturn(null);

        networkExplorer.doGet(request, response);

        verify(response).setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        verify(response).setHeader("WWW-Authenticate", "NTLM");
        verify(response).flushBuffer();
    }

    /**
     * Test doGet with NTLM authentication for directory listing

     */
    public fun webSocketUpgrade(listener: WebSocketListener): Builder =
      apply {
        status = "HTTP/1.1 101 Switching Protocols"
        setHeader("Connection", "Upgrade")
        setHeader("Upgrade", "websocket")
        webSocketListener = listener
      }

    /**
     * Configures this response to be served as a response to an HTTP CONNECT request, either for

      .assertNoMoreLogs()
  }

  @Test
  fun bodyResponseGzipEncoded() {
    setLevel(Level.BODY)
    server.enqueue(
      MockResponse
        .Builder()
        .setHeader("Content-Encoding", "gzip")
        .setHeader("Content-Type", PLAIN)
        .body(Buffer().write("H4sIAAAAAAAAAPNIzcnJ11HwQKIAdyO+9hMAAAA=".decodeBase64()!!))
        .build(),
    )

            url = file.getLocator().getPath();
            resp.setContentType("text/plain");
            resp.setContentType(URLConnection.guessContentTypeFromName(url));
            resp.setHeader("Content-Length", file.length() + "");
            resp.setHeader("Accept-Ranges", "Bytes");

            while ((n = in.read(buf)) != -1) {
                out.write(buf, 0, n);
            }
        }
    }

    /**