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,
		},
	}

            applyServiceInjectionToGetter(property, null, getter);
        }

        @Override
        public void applyServiceInjectionToGetter(PropertyMetadata property, @Nullable final Class<? extends Annotation> annotation, MethodMetadata getter) {

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

        @Override
        boolean claimPropertyImplementation(PropertyMetadata property) {
            // Skip properties with non-abstract getter or setter implementations
            for (MethodMetadata getter : property.getters) {
                if (getter.shouldImplement() && !getter.isAbstract()) {
                    return false;
                }
            }
            for (Method setter : property.setters) {

        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) {

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

    }

    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")

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Attach this annotation to an abstract getter that should receive the artifact dependencies of the {@link InputArtifact} of an artifact transform.
 *
 * <p>

        "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.