) {
        Action<? super ArtifactResolutionDetails> filter = Actions.doNothing();
        if (repository instanceof ContentFilteringRepository) {
            filter = ((ContentFilteringRepository) repository).getContentFilter();
        }

        if (filter == Actions.doNothing()) {
            return moduleComponentRepository;
        }

        return doCreate(name, type, NO_ARGS, Actions.doNothing());
    }

    @Override
    public <T extends Task> T create(final String name, final Class<T> type, final Object... constructorArgs) throws InvalidUserDataException {
        assertMutable("create(String, Class, Object...)");
        return doCreate(name, type, constructorArgs, Actions.doNothing());
    }

    /**

                fileLock.close();
            } finally {
                fileLock = null;
            }
        }
    }

    @Override
    public Runnable acquireFileLock() {
        return Runnables.doNothing();
    }

    @Override
    public <T> T withFileLock(Supplier<T> factory) {
        return factory.get();
    }

    }

    public <T extends ArtifactRepository> T addRepository(T repository, String defaultName) {
        return addRepository(repository, defaultName, Actions.doNothing());
    }

    public <T extends ArtifactRepository> T addRepository(T repository, String defaultName, Action<? super T> configureAction) {
        configureAction.execute(repository);

import org.jetbrains.kotlin.psi.stubs.elements.KtConstantExpressionElementType
import org.jetbrains.kotlin.psi.stubs.elements.KtNameReferenceExpressionElementType
import org.jetbrains.kotlin.utils.doNothing


class GrammarToTree(
    private val sourceIdentifier: SourceIdentifier,
    private val sourceCode: String,
    private val sourceOffset: Int,
    private val suffixLength: Int
) {

    inner

        buildFile << """
task someTask {
    inputs.property "someValue", new CustomType("value1")
    outputs.dir file("build/out")
    doLast ${Actions.name}.doNothing()
}

"""

        given:
        run "someTask"

        when:
        run "someTask"

        then:
        skipped(":someTask")

        // Change to "equal" value

    assertThat(result).isEqualTo(RETURN_VALUE);
  }

  public void testRunWithTimeout_returnsWithoutException() throws Exception {
    timeLimiter.runWithTimeout(Runnables.doNothing(), DELAY_MS, TimeUnit.MILLISECONDS);
  }

  public void testRunWithTimeout_wrapsUncheckedException() throws Exception {
    RuntimeException exception = new RuntimeException("test");
    UncheckedExecutionException e =

    protected Action<ModuleDependency> toMutationValidator(final Configuration clientConfiguration) {
        return clientConfiguration instanceof MutationValidator ? new MutationValidationAction(clientConfiguration) : Actions.doNothing();
    }

    @Override
    public String toString() {
        return displayName.getDisplayName();
    }

    @Override
    public TaskDependency getBuildDependencies() {

====

[source.multi-language-sample,kotlin]
----
> gradle --init-script init.gradle.kts -q doNothing
include::{snippetsPath}/initScripts/externalDependency/tests-common/externalInitDependency.out[]
----
[source.multi-language-sample,groovy]
----
> gradle --init-script init.gradle -q doNothing
include::{snippetsPath}/initScripts/externalDependency/tests-common/externalInitDependency.out[]
----

        return children;
    }

    @Override
    public <C> DefaultModelSchemaExtractionContext<C> child(ModelType<C> type, String description) {
        return child(type, description, Actions.doNothing());
    }

    @Override
    public <C> DefaultModelSchemaExtractionContext<C> child(ModelType<C> type, String description, Action<? super ModelSchema<C>> validator) {