} else {
                return locationFromStackTrace(exception, true, true, NO_OP);
            }
        }

        @Override
        public ProblemDiagnostics forCurrentCaller() {
            return locationFromStackTrace(getImplicitThrowable(EXCEPTION_FACTORY), false, false, NO_OP);
        }

        @Override

@NonNullApi
public class InstrumentedExecutionAccess {

    private static final Listener NO_OP = new Listener() {

        @Override
        public void disallowedAtExecutionInjectedServiceAccessed(Class<?> injectedServiceType, String propertyName, String consumer) {
        }
    };

    private static final AtomicReference<Listener> LISTENER = new AtomicReference<>(NO_OP);

    private static Listener listener() {
        return LISTENER.get();

    private static final NoOpGroovySystemLoader NO_OP = new NoOpGroovySystemLoader();

    public GroovySystemLoader forClassLoader(ClassLoader classLoader) {
        try {
            Class<?> groovySystem = getGroovySystem(classLoader);
            if (groovySystem == null || groovySystem.getClassLoader() != classLoader) {
                return NO_OP;
            }

        def value = Mock(LifecycleAwareValue)
        def valueWrapper = Stub(PropertyValue)
        def property = new DefaultFinalizingValidatingProperty("name", valueWrapper, false, ValidationActions.NO_OP)

        given:
        valueWrapper.call() >> value

        when:
        property.prepareValue()

        then:
        1 * value.prepareValue()
        0 * value._

        when:

package org.gradle.api.internal.artifacts;

import org.gradle.api.internal.artifacts.dsl.ModuleReplacementsData;

public interface ComponentModuleMetadataProcessor {
    ComponentModuleMetadataProcessor NO_OP = () -> ModuleReplacementsData.NO_OP;

    ModuleReplacementsData getModuleReplacements();

    private static final CancellationExceptionTransformer NO_OP = new CancellationExceptionTransformer() {
        @Override
        public RuntimeException transform(RuntimeException e) {
            return e;
        }
    };

    static CancellationExceptionTransformer transformerFor(VersionDetails versionDetails) {
        if (versionDetails.honorsContractOnCancel()) {
            return NO_OP;
        }

 * limitations under the License.
 */

package org.gradle.internal.logging.events;

public interface OutputEventListener {
    void onOutput(OutputEvent event);

    OutputEventListener NO_OP = new OutputEventListener() {
        @Override
        public void onOutput(OutputEvent event) {
        }
    };

    InternalProblems getProblemsService();

    List<Problem> getProblems();

    ImmutableSet<Class<?>> getValidatedTypes();

    interface TypeOriginInspector {
        TypeOriginInspector NO_OP = type -> Optional.empty();

        Optional<PluginId> findPluginDefining(Class<?> type);
    }

import org.gradle.api.tasks.diagnostics.internal.graph.nodes.RenderableDependency;
import org.gradle.internal.logging.text.StyledTextOutput;

public interface NodeRenderer {
    NodeRenderer NO_OP = (output, node, alreadyRendered) -> {
    };

    void renderNode(StyledTextOutput output, RenderableDependency node, boolean alreadyRendered);

 * limitations under the License.
 */

package org.gradle.model.internal.asm;

import org.objectweb.asm.MethodVisitor;

public interface BytecodeFragment {

    BytecodeFragment NO_OP = visitor -> {};

    void emit(MethodVisitor visitor);