} 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();

        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);
    }

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

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