"lang_sv": {
          "match": "*_sv",
          "mapping": {
            "type": "text",
            "analyzer": "swedish_analyzer"
          }
        }
      },
      {
        "lang_ta": {
          "match": "*_ta",
          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      },
      {
        "lang_te": {

        "lang_sv": {
          "match": "*_sv",
          "mapping": {
            "type": "text",
            "analyzer": "swedish_analyzer"
          }
        }
      },
      {
        "lang_ta": {
          "match": "*_ta",
          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      },
      {
        "lang_te": {

        "lang_sv": {
          "match": "*_sv",
          "mapping": {
            "type": "text",
            "analyzer": "swedish_analyzer"
          }
        }
      },
      {
        "lang_ta": {
          "match": "*_ta",
          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      },
      {
        "lang_te": {

            return a;
        }
        if (a.length == 0) {
            return b;
        }
        if (b.length == 0) {
            return a;
        }
        final boolean[] array = (boolean[]) Array.newInstance(boolean.class, a.length + b.length);
        System.arraycopy(a, 0, array, 0, a.length);
        System.arraycopy(b, 0, array, a.length, b.length);
        return array;
    }

    /**

        assertEquals((testStringTrue.length() + 1) * 2, unicodeStringTrue.length, "Length should include zterm");
        assertEquals((testStringTrue.length() + 1) * 2, unicodeStringTrue.maximum_length, "Maximum length should include zterm");
        assertNotNull(unicodeStringTrue.buffer, "Buffer should not be null");
        assertEquals(testStringTrue.length() + 1, unicodeStringTrue.buffer.length, "Buffer length should include zterm");

        }
        return compress(data, 0, data.length, algorithm);
    }

    @Override
    public byte[] compress(byte[] data, int offset, int length, int algorithm) throws CIFSException {
        if (data == null) {
            throw new CIFSException("Data cannot be null");
        }
        if (offset < 0 || length < 0 || offset + length > data.length) {
            throw new CIFSException("Invalid offset or length");

      result = murmurHash64WithSeed(bytes, offset, length, K0 ^ K1 ^ K2);
    } else if (length <= 64) {
      result = hashLength33To64(bytes, offset, length);
    } else {
      result = fullFingerprint(bytes, offset, length);
    }

    long u = length >= 8 ? load64(bytes, offset) : K0;
    long v = length >= 9 ? load64(bytes, offset + length - 8) : K0;
    result = hash128to64(result + v, u);

        assertEquals(2, protocolHelper.getWebProtocols().length);
        assertEquals(3, protocolHelper.getFileProtocols().length);
    }

    public void test_loadProtocols() {
        final ProtocolHelper protocolHelper = new ProtocolHelper();
        protocolHelper.loadProtocols("org.codelibs.fess.test.net.protocol");

        assertEquals(1, protocolHelper.getWebProtocols().length);

     * @param pointer the pointer/offset to the string data
     */
    public PacUnicodeString(final short length, final short maxLength, final int pointer) {
        this.length = length;
        this.maxLength = maxLength;
        this.pointer = pointer;
    }

    /**
     * Gets the actual length of the string in bytes.
     *
     * @return the string length
     */
    public short getLength() {

      TYPE_RST_STREAM -> readRstStream(handler, length, flags, streamId)
      TYPE_SETTINGS -> readSettings(handler, length, flags, streamId)
      TYPE_PUSH_PROMISE -> readPushPromise(handler, length, flags, streamId)
      TYPE_PING -> readPing(handler, length, flags, streamId)
      TYPE_GOAWAY -> readGoAway(handler, length, flags, streamId)
      TYPE_WINDOW_UPDATE -> readWindowUpdate(handler, length, flags, streamId)