@Input
    @Option(option = "http", description = "Configures the http protocol to be allowed.")
    public abstract Property<Boolean> getHttp();

    @Option(option = "url", description = "Configures the URL to send the request to.")
    public void setUrl(String url) {
        if (!getHttp().getOrElse(true) && url.startsWith("http://")) {
            throw new IllegalArgumentException("HTTP is not allowed");
        } else {

 * The store implementation can be supplied with a {@link java.util.function.Predicate} to identify generated getters.
 * If the {@code is}-getter is generated, and the {@code get}-getter is not ignored explicitly, then the generated
 * {@code is}-getter is automatically ignored in favor of the {@code get}-getter.
 * </p>
 */
@ServiceScope(Scope.Global.class)
public interface TypeAnnotationMetadataStore {

	r.Lock()
	defer r.Unlock()
	return r.pods
}

// NewTestRuntimeCache creates a new instance of TestRuntimeCache.
func NewTestRuntimeCache(getter podsGetter) *TestRuntimeCache {
	return &TestRuntimeCache{
		runtimeCache: runtimeCache{
			getter: getter,
		},
	}

        if (spec instanceof Closure) {
            def getter = spec as Closure
            assert getter(actual) == getter(expected)
        } else if (spec instanceof List) {
            assert spec.size() == 2
            def getter = spec[0] as Closure
            def checker = spec[1]
            def actualValue = getter(actual)
            def expectedValue = getter(expected)
            if (checker instanceof Closure) {

    }

    def "injects service using getter injection"() {
        given:
        services.add(String, "string")

        when:
        def result = instantiator.newInstance(HasGetterInjection)

        then:
        result.someService == 'string'
    }

    def "injects service using abstract getter injection"() {
        given:
        services.add(String, "string")

     *
     * 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
     *

        "normal getter"       | "call site" | "getTestString()"                             | { it.testString }                    | false
        "boolean getter"      | "call site" | "isTestFlag()"                                | { it.testFlag }                      | false

	return func(ctx resource.Context) (err error) {
		*ns, err = New(ctx, cfg)
		return
	}
}

// Getter for a namespace Instance
type Getter func() Instance

// Get is a utility method that helps in readability of call sites.
func (g Getter) Get() Instance {
	return g()
}

// Future creates a Getter for a variable that namespace that will be set at sometime in the future.

                }
            }

            extensions.create("thing", Thing, "a", 12)
        """

        expect:
        succeeds()
    }

    def "can inject service using getter"() {
        buildFile """
            class Thing {
                Thing(String a) {
                }

                @Inject
                ObjectFactory getObjects() { }
            }

        get() = withValidityAssertion { descriptor.isExtension }

    override val getter: KaPropertyGetterSymbol
        get() = withValidityAssertion {
            val getter = descriptor.getter ?: return KaFe10DescDefaultPropertyGetterSymbol(descriptor, analysisContext)
            return KaFe10DescPropertyGetterSymbol(getter, analysisContext)
        }

    override val javaGetterSymbol: KaFunctionSymbol