}

    @Test
    public void testMultipleReadingsConversion() {
        // Test conversion of multiple readings to SuggestItem format
        String word = "multi reading";
        float boost = 1.0f;
        List<String> readings = Arrays.asList("reading1", "reading2", "reading3", "reading4", "reading5");
        List<String> fields = Arrays.asList("field1");
        List<String> tags = Arrays.asList("tag1");

    protected void setUp() throws Exception {
        file1 = File.createTempFile("kuromoji_", ".txt");
        FileUtil.write(
                file1.getAbsolutePath(),
                "token1,seg1,reading1,pos1\ntoken2,seg2,reading2,pos2\ntoken3,seg3,reading3,pos3"
                        .getBytes(Constants.UTF_8));
    }

    @Override
        protected void tearDown(TestInfo testInfo) throws Exception {
        file1.delete();
    }

        // Multiple spaces should be collapsed to single space
        assertTrue("Should query reading_0", queryString.contains("reading_0"));
        assertTrue("Should query reading_1", queryString.contains("reading_1"));
        // Should NOT have reading_2 (spaces collapsed)
        assertFalse("Should not have reading_2", queryString.contains("reading_2"));
    }

    @Test
    public void test_buildQuery_withNormalizer() {

        String[][] readings = { { "reading1" } };
        String[] fields = { "field1" };
        String[] tags = { "tag1" };
        String[] roles = { "role1" };
        String[] languages = { "en" };
        long docFreq = 10L;
        long queryFreq = 5L;
        float userBoost = 1.5f;

        SuggestItem item =

        dst[dstIndex++] = (byte) (val >> 8 & 0xFF);
        dst[dstIndex] = (byte) (val & 0xFF);
    }

    static int readInt2(final byte[] src, final int srcIndex) {
        return ((src[srcIndex] & 0xFF) << 8) + (src[srcIndex + 1] & 0xFF);
    }

    static int readInt4(final byte[] src, final int srcIndex) {
        return ((src[srcIndex] & 0xFF) << 24) + ((src[srcIndex + 1] & 0xFF) << 16) + ((src[srcIndex + 2] & 0xFF) << 8)

        if (in.read(buffer, bufferIndex, this.length) != this.length) {
            throw new IOException("unexpected EOF reading netbios retarget session response");
        }
        final int addr = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        new NbtAddress(null, addr, false, NbtAddress.B_NODE);
        readInt2(buffer, bufferIndex);
        return this.length;
    }

     * @param srcIndex the starting index in the source array
     * @return the 64-bit integer value
     */
    public static long readInt8(final byte[] src, final int srcIndex) {
        return (readInt4(src, srcIndex) & 0xFFFFFFFFL) + ((long) readInt4(src, srcIndex + 4) << 32);
    }

    /**
     * Writes a 64-bit integer value to a byte array in little-endian format
     * @param val the value to write

     *
     * @param elevateWord the elevate word
     * @param boost the boost value
     * @param readings the list of readings
     * @param fields the list of fields
     * @param tags the list of tags
     * @param roles the list of roles
     */
    public ElevateWord(final String elevateWord, final float boost, final List<String> readings, final List<String> fields,
            final List<String> tags, final List<String> roles) {

                if (readings != null && readings.length > i && readings[i].length > 0) {
                    for (final String reading : readings[i]) {
                        if (!l.contains(reading)) {
                            l.add(reading);
                        }
                    }
                }

                wordsList.add(word);

 */
public interface ContentsParser {
    /**
     * Parses the given search words and creates a SuggestItem.
     *
     * @param words the array of search words
     * @param readings the array of readings corresponding to the search words
     * @param fields the array of fields associated with the search words
     * @param tags the array of tags associated with the search words