}

    static String queryLookup(final String query, final String param) {
        final char in[] = query.toCharArray();
        int i, ch, st, eq;

        st = eq = 0;
        for (i = 0; i < in.length; i++) {
            ch = in[i];
            if (ch == '&') {
                if (eq > st) {
                    final String p = new String(in, st, eq - st);

     * Retrieve a <code>String</code>. If the key cannot be found,
     * the provided <code>def</code> default parameter will be returned.
     *
     * @param key the property key to look up
     * @param def the default value to return if the property is not found
     * @return the property value, or the default value if not found
     */

    public static String getProperty(final String key, final String def) {

 */
@Suppress("NAME_SHADOWING")
class Cookie private constructor(
  /** Returns a non-empty string with this cookie's name. */
  @get:JvmName("name") val name: String,
  /** Returns a possibly-empty string with this cookie's value. */
  @get:JvmName("value") val value: String,
  /**
   * Returns the time that this cookie expires, in the same format as [System.currentTimeMillis].

    // Helper classes for testing
    private static class TestLoginCredential implements LoginCredential {
        private final String username;

        public TestLoginCredential(String username) {
            this.username = username;
        }

        @Override
        public String toString() {
            return username;
        }
    }

                .toList();
    }

    @Nonnull
    @Override
    public Map<String, String> getUserProperties() {
        return Collections.unmodifiableMap(new PropertiesAsMap(getMavenSession().getUserProperties()));
    }

    @Nonnull
    @Override
    public Map<String, String> getSystemProperties() {

    /**
     * Converts an array of {@literal CharSequence} to a {@literal List} of {@literal String}.
     *
     * @param array
     *            An array of {@literal CharSequence}
     * @return A {@literal List} of {@literal String}
     */
    protected static List<String> toStringList(final CharSequence[] array) {
        final List<String> list = newArrayList(array.length);
        for (final CharSequence element : array) {

	Preload(association string, query func(db PreloadBuilder) error) ChainInterface[T]
	Select(query string, args ...interface{}) CreateInterface[T]
	Omit(columns ...string) CreateInterface[T]
	MapColumns(m map[string]string) ChainInterface[T]
	Distinct(args ...interface{}) ChainInterface[T]
	Group(name string) ChainInterface[T]
	Having(query interface{}, args ...interface{}) ChainInterface[T]

        results = relatedContentHelper.getRelatedContents("test");
        assertEquals("Updated Content", results[0]);
    }

    // Helper methods

    private RelatedContent createRelatedContent(String term, String content, String virtualHost) {
        RelatedContent entity = new RelatedContent();
        entity.setTerm(term);
        entity.setContent(content);
        entity.setVirtualHost(virtualHost);
        return entity;

     * @param propertyNames
     *            An array of property names. Each element must not be {@literal null} or an empty string.
     * @return A {@link CopyOptions} with a date converter applied.
     * @see CopyOptions#dateConverter(String, CharSequence...)
     * @see DateConverter
     */
    public static CopyOptions dateConverter(final String pattern, final CharSequence... propertyNames) {

import java.util.Set;

/**
 * {@link Set} that is case-insensitive.
 *
 * @author higa
 */
public class CaseInsensitiveSet extends AbstractSet<String> implements Set<String>, Serializable {

    static final long serialVersionUID = 0L;

    private transient Map<String, Object> map = new CaseInsensitiveMap<>();

    private static final Object PRESENT = new Object();

    /**
     * Creates a {@link CaseInsensitiveSet}.