given:
        1 * callable.call() >> null

        when:
        dependency.add(callable)

        then:
        dependency.getDependencies(task) == emptySet()
    }

    def "delegates to Provider to determine build dependencies"() {
        def provider = Mock(ProviderInternal)

        given:
        1 * provider.producer >> ValueSupplier.ValueProducer.task(otherTask)

        when:

import java.io.File;
import java.io.IOException;

/**
 * A {@link FileContentCacheFactory} that delegates to the global cache for files that are known to be immutable and shared between different builds.
 * All other requests are delegated to the build-local cache. Closing this factory will only close the local delegate, not the global one.
 */
public class SplitFileContentCacheFactory implements FileContentCacheFactory, Closeable {

 */
public class FlatteningNotationParser<N, T> implements NotationParser<N, Set<T>> {

    private final NotationParser<N, T> delegate;

    public FlatteningNotationParser(NotationParser<N, T> delegate) {
        assert delegate != null : "delegate cannot be null";
        this.delegate = delegate;
    }

    @Override

	return r.store.GetResetFields()
}

// ConvertToTable delegates to the store, implements TableConverter
func (r *StatusREST) ConvertToTable(ctx context.Context, object runtime.Object, tableOptions runtime.Object) (*metav1.Table, error) {
	return r.store.ConvertToTable(ctx, object, tableOptions)
}

// Update alters the status subset of an object. Delegates to the store

    def delegateResult = Stub(CachingResult) {
        duration >> Duration.ZERO
        execution >> Try.successful(delegateExecution)
    }
    def step = new AssignMutableWorkspaceStep<>(delegate)
    def work = Stub(MutableUnitOfWork)

    def "delegates with assigned mutable workspace"() {
        def delegateOutput = new Object()
        def workspace = file("workspace")
        def workspaceProvider = Mock(MutableWorkspaceProvider)

class IdentifyStepTest extends StepSpec<ExecutionRequestContext> {
    def delegateResult = Mock(Result)
    def inputFingerprinter = Mock(InputFingerprinter)
    def step = new IdentifyStep<>(buildOperationRunner, delegate)


    def "delegates with assigned workspace"() {
        def inputSnapshot = Mock(ValueSnapshot)
        def inputFilesFingerprint = Mock(CurrentFileCollectionFingerprint)

        when:

import spock.lang.Specification

class MavenUniqueSnapshotExternalResourceArtifactResolverTest extends Specification {

    def delegate = Mock(ExternalResourceArtifactResolver)
    def resolver = new MavenUniqueSnapshotExternalResourceArtifactResolver(delegate, new MavenUniqueSnapshotModuleSource("timestamp"))

    def "creates timestamped artifact"() {
        when:

 * limitations under the License.
 */

package org.gradle.api.internal.project


import spock.lang.Specification

class DefaultIsolatedProjectSpec extends Specification {

    def "delegates equals and hashCode to project"() {
        given:
        def project = Mock(ProjectInternal)
        def subject = new DefaultIsolatedProject(project, project)

        when:
        def hashCode = subject.hashCode()

 * the License.
 */
package com.google.common.collect;

import java.util.Collection;
import org.checkerframework.checker.nullness.qual.Nullable;

/** Never actually created; instead delegates to JdkBackedImmutableMultiset. */
@ElementTypesAreNonnullByDefault
class RegularImmutableMultiset<E> extends ImmutableMultiset<E> {
  static final ImmutableMultiset<Object> EMPTY =

 * under the License.
 */
package org.apache.maven.repository.legacy.resolver.conflict;

import javax.inject.Named;
import javax.inject.Singleton;

/**
 * The default conflict resolver that delegates to the nearest strategy.
 *
 * @see NearestConflictResolver
 * @deprecated As of 3.0, use a specific implementation instead, e.g. {@link NearestConflictResolver}
 */
@Deprecated
@Named
@Singleton