initializer.accept(cache);
        }
        return cache;
    }

    public PersistentCache open(File cacheDir, String displayName) {
        return new InMemoryCache(cacheDir, displayName, CleanupAction.NO_OP);
    }

    @Override
    public void visitCaches(CacheVisitor visitor) {
        throw new UnsupportedOperationException();
    }

    private class InMemoryCache implements PersistentCache {

            Set<ImmutableAttributes> candidates = attributeBasedMappings.keySet();
            List<ImmutableAttributes> matches = matcher.matches(candidates, variantAttributes, AttributeMatchingExplanationBuilder.NO_OP);
            if (matches.size() == 1) {
                Collection<Action<? super VariantVersionMappingStrategy>> actions = attributeBasedMappings.get(matches.get(0));

import org.gradle.util.Path;

import java.util.function.Supplier;

@ServiceScope(Scope.BuildTree.class)
public interface ProjectScopedScriptResolution {
    ProjectScopedScriptResolution NO_OP = new ProjectScopedScriptResolution() {
        @Override
        public <T> T resolveScriptsForProject(Path identityPath, Supplier<T> action) {
            return action.get();
        }
    };

	switch e := n.(type) {
	case *ast.IndexExpr:
		return e.X, e.Lbrack, []ast.Expr{e.Index}, e.Rbrack
	case *ast.IndexListExpr:
		return e.X, e.Lbrack, e.Indices, e.Rbrack
	}
	return nil, token.NoPos, nil, token.NoPos
}

// PackIndexExpr returns an *ast.IndexExpr or *ast.IndexListExpr, depending on
// the cardinality of indices. Calling PackIndexExpr with len(indices) == 0
// will panic.

			Pod:  createPodWithVolume("pod_1", "PVC_2"),
			Node: &v1.Node{
				ObjectMeta: metav1.ObjectMeta{
					Name:   "host1",
					Labels: map[string]string{v1.LabelFailureDomainBetaRegion: "no_us-west1", "uselessLabel": "none"},
				},
			},
			wantFilterStatus: framework.NewStatus(framework.UnschedulableAndUnresolvable, ErrReasonConflict),
		},
		{
			name: "beta zone label doesn't match",

	return &Var{object: object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}}
}

// NewParam returns a new variable representing a function parameter.
func NewParam(pos token.Pos, pkg *Package, name string, typ Type) *Var {
	return &Var{object: object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}, used: true} // parameters are always 'used'
}

    static AttributeMatchingExplanationBuilder logging() {
        if (LOGGER.isDebugEnabled()) {
            return INSTANCE;
        }
        return AttributeMatchingExplanationBuilder.NO_OP;
    }

    @Override
    public boolean canSkipExplanation() {
        return true;
    }

    @Override
    public <T extends HasAttributes> void noCandidates(AttributeContainerInternal requested) {

    private textOutput = new TestStyledTextOutput().ignoreStyle()
    private graphRenderer = new GraphRenderer(textOutput)
    private renderer = new DependencyGraphsRenderer(textOutput, graphRenderer, NodeRenderer.NO_OP, new SimpleNodeRenderer())

    def "renders graph"() {
        def root = new SimpleDependency("root")
        def dep1 = new SimpleDependency("dep1")
        def dep11 = new SimpleDependency("dep1.1")

 */
@EventScope(Scope.Build.class)
public interface ChangingValueDependencyResolutionListener {
    ChangingValueDependencyResolutionListener NO_OP = new ChangingValueDependencyResolutionListener() {
        @Override
        public void onDynamicVersionSelection(ModuleComponentSelector requested, Expiry expiry, Set<ModuleVersionIdentifier> versions) {
        }

 * </ol>
 */
public abstract class LoggingServiceRegistry extends DefaultServiceRegistry {

    public static final ServiceRegistrationProvider NO_OP = new ServiceRegistrationProvider() {
        @Provides
        OutputEventListener createOutputEventListener() {
            return OutputEventListener.NO_OP;
        }
    };

    private TextStreamOutputEventListener stdoutListener;