{[]string{nonLoopBackIP + ":9000"}, handler, nil},
		{[]string{"127.0.0.1:9000", nonLoopBackIP + ":9000"}, handler, nil},
		{[]string{"127.0.0.1:9000"}, handler, getCert},
		{[]string{nonLoopBackIP + ":9000"}, handler, getCert},
		{[]string{"127.0.0.1:9000", nonLoopBackIP + ":9000"}, handler, getCert},
	}

	for i, testCase := range testCases {
		server := NewServer(testCase.addrs).
			UseHandler(testCase.handler)
		if testCase.certFn != nil {

        builder.append(' ');
        builder.append(name);
        return builder.toString();
    }

    public MethodMetaData getGetter() {
        return getter;
    }

    public void setGetter(MethodMetaData getter) {
        this.getter = getter;
    }

    public MethodMetaData getSetter() {
        return setter;
    }

    public void setSetter(MethodMetaData setter) {
        this.setter = setter;

        MethodMetaData getter = Mock()
        MethodMetaData overriddenGetter = Mock()
        ClassMetaData overriddenClass = Mock()
        PropertyMetaData overriddenProperty = Mock()
        propertyMetaData.getter = getter

        when:
        def p = propertyMetaData.overriddenProperty

        then:
        p == overriddenProperty
        _ * getter.overriddenMethod >> overriddenGetter

     *
     * Here we automatically accept the following cases:
     * - A setter `setX` of an upgraded property is removed
     * - A boolean `isX` of an upgraded property is removed
     * - A new getter `getX` is added, where the old getter is a boolean getter `isX` of an upgraded property
     * - A return type is changed for a getter `getX` of an upgraded property
     *

        for (O option : options) {
            Optional<T> o = getter.apply(option);
            if (o.isPresent()) {
                return o;
            }
        }
        return Optional.empty();
    }

    protected Optional<List<String>> collectListIfPresentOrEmpty(Function<O, Optional<List<String>>> getter) {
        int had = 0;

            Logger.error("Failed to create suggest index. ", e);
            return internalServerError();
        }
    }



    public static Result createContent() {
        ContentsCreator getter = new ContentsCreator();
        getter.create();
        return ok("Finished to create content index;");
    }

        }

        MetadataGraphNode node = new MetadataGraphNode(md);
        addNode(node);
        return node;
    }

    /**
     * getter
     */
    public MetadataGraphNode getEntry() {
        return entry;
    }

    /**
     * getter
     */
    public Collection<MetadataGraphNode> getNodes() {
        return nodes;
    }

        return (Class<T>) propertyType;
    }

    @Override
    public final Method getReadMethod() {
        return readMethod;
    }

    /**
     * getterメソッドを設定します。
     *
     * @param readMethod
     *            getterメソッド
     */
    protected final void setReadMethod(final Method readMethod) {
        this.readMethod = readMethod;
        if (readMethod != null) {
            readable = true;

    }

    protected QueryBuilder convertPhraseQuery(final QueryContext context, final PhraseQuery phraseQuery, final float boost) {
        final Term[] terms = phraseQuery.getTerms();
        if (terms.length == 0) {
            throw new InvalidQueryException(messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),
                    "Unknown phrase query: " + phraseQuery);

    for (p in properties) {
        when (jvmSignature) {
            p.fieldSignature?.toString() -> return predicate.match(p)
            p.getterSignature?.toString() -> return predicate.match(p.getter)
            p.setterSignature?.toString() -> return p.setter?.let { predicate.match(it) } ?: false
        }
    }
    return false
}

interface AttributePredicate {