import org.gradle.api.artifacts.ComponentMetadata;
import org.gradle.internal.component.external.model.ModuleComponentResolveMetadata;

public interface ComponentMetadataProcessor {
    ComponentMetadataProcessor NO_OP = new ComponentMetadataProcessor() {
        @Override
        public ModuleComponentResolveMetadata processMetadata(ModuleComponentResolveMetadata metadata) {
            return metadata;
        }

        @Override

import org.gradle.api.internal.attributes.AttributeValue;

import java.util.Collection;

public interface AttributeMatchingExplanationBuilder {
    AttributeMatchingExplanationBuilder NO_OP = () -> true;

    static AttributeMatchingExplanationBuilder logging() {
        return LoggingAttributeMatchingExplanationBuilder.logging();
    }

    boolean canSkipExplanation();

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

#include "tensorflow/cc/ops/linalg_ops.h"
#include "tensorflow/cc/ops/logging_ops.h"
#include "tensorflow/cc/ops/lookup_ops.h"
#include "tensorflow/cc/ops/math_ops.h"
#include "tensorflow/cc/ops/nn_ops.h"
#include "tensorflow/cc/ops/no_op.h"
#include "tensorflow/cc/ops/parsing_ops.h"
#include "tensorflow/cc/ops/random_ops.h"
#include "tensorflow/cc/ops/sparse_ops.h"
#include "tensorflow/cc/ops/state_ops.h"
#include "tensorflow/cc/ops/string_ops.h"

                ? this.executionListenerFactory
                : () -> DefaultBuildOperationRunner.BuildOperationExecutionListener.NO_OP;

            return new DefaultBuildOperationRunner(
                CurrentBuildOperationRef.instance(),
                timeSupplier,
                new DefaultBuildOperationIdFactory(),

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

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

    def services = (DefaultServiceRegistry) ServiceRegistryBuilder.builder()
            .parent(NativeServicesTestFixture.getInstance())
            .provider(LoggingServiceRegistry.NO_OP)
            .provider(new GlobalScopeServices(false, AgentStatus.disabled()))
            .build()

    def factory = services.get(CacheFactory.class)
    def currentGradleVersion = GradleVersion.current()

                def filePropertyFactory = new DefaultFilePropertyFactory(PropertyHost.NO_OP, fileResolver, fileCollectionFactory)
                return new DefaultProjectLayout(fileResolver.resolve("."), fileResolver, DefaultTaskDependencyFactory.withNoAssociatedProject(), PatternSets.getNonCachingPatternSetFactory(), PropertyHost.NO_OP, fileCollectionFactory, filePropertyFactory, filePropertyFactory)
            }
        })