private static final int TIME_1970_MILLIS_64LE = 8;

    /**
     *
     */
    private Encdec() {
    }

    /*
     * Encode integers
     */

    /**
     * Encodes a 16-bit unsigned integer in big-endian byte order.
     *
     * @param s the short value to encode
     * @param dst the destination byte array
     * @param di the starting index in the destination array

    @Test
    @DisplayName("Test FileInformation encode method")
    void testFileInformationEncode() {
        // Create mock
        FileInformation mockFileInfo = mock(FileInformation.class);
        byte[] dst = new byte[100];

        // Define behavior
        when(mockFileInfo.encode(dst, 0)).thenReturn(8);
        when(mockFileInfo.size()).thenReturn(8);

        // Test encode

        String encodedFieldName = BaseEncoding.base64().encode(fieldName.getBytes(StandardCharsets.UTF_8));
        String fullFieldName = Constants.FACET_FIELD_PREFIX + encodedFieldName;

        assertTrue(fullFieldName.startsWith("field:"));
        assertTrue(fullFieldName.contains(encodedFieldName));

        String queryName = "title:test";
        String encodedQueryName = BaseEncoding.base64().encode(queryName.getBytes(StandardCharsets.UTF_8));

        // Test basic encoding
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };
        ByteEncodable encodable = new ByteEncodable(data, 1, 3);
        byte[] dest = new byte[5];

        int encodedLen = encodable.encode(dest, 0);

        // Verify encoded length
        assertEquals(3, encodedLen, "Encoded length should be equal to the specified length");

        // Verify content

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.core.beans.util.BeanUtil;
import org.codelibs.core.exception.ResourceNotFoundRuntimeException;
import org.codelibs.core.io.FileUtil;
import org.codelibs.core.io.ResourceUtil;
import org.codelibs.core.lang.StringUtil;
import org.codelibs.core.lang.ThreadUtil;
import org.codelibs.curl.CurlResponse;
import org.codelibs.fesen.client.EngineInfo;

 */
package org.codelibs.fess.app.web.admin.webconfig;

import static org.codelibs.core.stream.StreamUtil.split;
import static org.codelibs.core.stream.StreamUtil.stream;

import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.core.lang.StringUtil;
import org.codelibs.fess.Constants;

          codePoint == '\r'.code
      )
    ) {
      // Skip this character.
    } else if (codePoint == ' '.code && encodeSet === FORM_ENCODE_SET) {
      // Encode ' ' as '+'.
      writeUtf8("+")
    } else if (codePoint == '+'.code && plusIsSpace) {
      // Encode '+' as '%2B' since we permit ' ' to be encoded as either '+' or '%20'.
      writeUtf8(if (alreadyEncoded) "+" else "%2B")
    } else if (codePoint < 0x20 ||

	"testing"
	"time"

	"github.com/tinylib/msgp/msgp"
)

func BenchmarkDecodeVolInfoMsgp(b *testing.B) {
	v := VolInfo{
		Name:    "uuid",
		Created: time.Now(),
	}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	rd := msgp.NewEndlessReader(buf.Bytes(), b)
	dc := msgp.NewReader(rd)
	b.Log("Size:", buf.Len(), "bytes")
	b.SetBytes(1)
	b.ReportAllocs()

	for b.Loop() {
		err := v.DecodeMsg(dc)
		if err != nil {

        // Given
        request.setSessionBinding(true);
        byte[] buffer = new byte[512];
        int headerStart = 50;

        // Encode the full message to set headerStart
        request.encode(buffer, headerStart);

        // Then - verify the body was written correctly
        int bodyOffset = headerStart + Smb2Constants.SMB2_HEADER_LENGTH;

        // Test that constants have expected values
        assertEquals("score", QueryFieldConfig.SCORE_FIELD);
        assertEquals("_score", QueryFieldConfig.DOC_SCORE_FIELD);
        assertEquals("site", QueryFieldConfig.SITE_FIELD);
        assertEquals("inurl", QueryFieldConfig.INURL_FIELD);
        assertEquals("score", QueryFieldConfig.SCORE_SORT_VALUE);
    }

    public void test_constructor() {