}

                    String adjustment = null;

                    if (lastSlash > -1) {
                        moduleName = moduleName.substring(lastSlash + 1);
                        adjustment = modulePath.substring(0, lastSlash);
                    }

                    moduleAdjustments.put(moduleName, adjustment);
                }
            }
        }

        if (username == null) {
            value = StringUtil.EMPTY;
        } else if (maxLength >= 0 && username.length() > maxLength) {
            value = username.substring(0, maxLength);
        } else {
            value = username;
        }
        return String.format(getSystemProperty(Constants.LDAP_SECURITY_PRINCIPAL, StringUtil.EMPTY), value);
    }

    public static String createSuggestTextId(final String text) {
        final String id = encoder.encodeToString(text.getBytes(CoreLibConstants.CHARSET_UTF_8));
        if (id.length() > ID_MAX_LENGTH) {
            return id.substring(0, ID_MAX_LENGTH);
        }
        return id;
    }

    /**
     * Parses the given query string and returns an array of keywords.
     *
     * @param q the query string to be parsed

      if (path == null || !path.startsWith("/")) {
        val encodedPath = url.encodedPath
        val lastSlash = encodedPath.lastIndexOf('/')
        path = if (lastSlash != 0) encodedPath.substring(0, lastSlash) else "/"
      }

      return Cookie(
        cookieName,
        cookieValue,
        expiresAt,
        domain,
        path,
        secureOnly,
        httpOnly,

            // wrong state
            return;
        }

        final int idx = url.indexOf('/', url.indexOf("://") + 3);
        String hostUrl;
        if (idx >= 0) {
            hostUrl = url.substring(0, idx);
        } else {
            hostUrl = url;
        }
        final String robotTxtUrl = hostUrl + "/robots.txt";

        // check url

      checkState(hasMore());
      int startPosition = position;
      position = matcher.negate().indexIn(input, startPosition);
      return hasMore() ? input.substring(startPosition, position) : input.substring(startPosition);
    }

    String consumeToken(CharMatcher matcher) {
      int startPosition = position;
      String token = consumeTokenIfPresent(matcher);

                .stream()
                .filter(key -> key.endsWith(".overwrite")) //
                .collect(Collectors.toList())
                .forEach(key -> {
                    final String baseKey = key.substring(0, key.length() - ".overwrite".length());
                    final Object value = dataMap.remove(key);
                    dataMap.put(baseKey, value);
                });
    }

    /**

    void testServerInfo1GetTypeVariousTypes(String typeHex, int expectedType) throws Exception {
        NetServerEnum2Response.ServerInfo1 server = response.new ServerInfo1();
        server.type = (int) Long.parseLong(typeHex.substring(2), 16);
        assertEquals(expectedType, server.getType());
    }

    @Test
    @DisplayName("Test ServerInfo1 getName")
    void testServerInfo1GetName() throws Exception {

                            if (isPrefix || "xmlns".equals(aname)) {
                                final int index = aname.indexOf(':');
                                final String p = isPrefix ? aname.substring(index + 1) : StringUtil.EMPTY;
                                if (p.equals(prefix)) {
                                    namespace = attr.getNodeValue();
                                    break;

    static Chopper suffix(String suffix) {
      return new Chopper() {
        @Override
        Optional<String> chop(String str) {
          if (str.endsWith(suffix)) {
            return Optional.of(str.substring(0, str.length() - suffix.length()));
          } else {
            return Optional.absent();
          }
        }
      };
    }
  }