import static org.gradle.internal.Actions.doNothing
import static org.gradle.internal.Actions.filter
import static org.gradle.internal.Actions.toAction

class ActionsTest extends Specification {

    def "do nothing indeed does nothing"() {
        given:
        def thing = Mock(Object)

        when:
        doNothing().execute(thing)

        then:
        0 * thing._(*_)
    }

    }

    @Override
    public NamedDomainObjectProvider<ResolvableConfiguration> resolvable(String name) {
        assertMutable("resolvable(String)");
        return registerResolvableConfiguration(name, Actions.doNothing());
    }

    @Override
    public NamedDomainObjectProvider<ResolvableConfiguration> resolvable(String name, Action<? super ResolvableConfiguration> action) {

        final Set<ResolvedComponentResult> out = new LinkedHashSet<>();
        eachElement(getRoot(), Actions.doNothing(), Actions.doNothing(), out);
        return out;
    }

    @Override
    public void allComponents(final Action<? super ResolvedComponentResult> action) {
        eachElement(getRoot(), action, Actions.doNothing(), new HashSet<>());
    }

    @Override
    @SuppressWarnings("rawtypes")

        when:
        strategy.dependencySubstitutionRule.execute(details)

        then:
        _ * dependencySubstitutions.ruleAction >> Actions.doNothing()
        _ * globalDependencySubstitutions.ruleAction >> Actions.doNothing()
        _ * details.getRequested() >> DefaultModuleComponentSelector.newSelector(mid, new DefaultMutableVersionConstraint("1.0"))

 *
 * @author Olivier Pernet
 */
@GwtCompatible
public class RunnablesTest extends TestCase {
  public void testDoNothingRunnableIsSingleton() {
    assertSame(Runnables.doNothing(), Runnables.doNothing());
  }

package clause

type OnConflict struct {
	Columns      []Column
	Where        Where
	TargetWhere  Where
	OnConstraint string
	DoNothing    bool
	DoUpdates    Set
	UpdateAll    bool
}

func (OnConflict) Name() string {
	return "ON CONFLICT"
}

// Build build onConflict clause
func (onConflict OnConflict) Build(builder Builder) {
	if onConflict.OnConstraint != "" {
		builder.WriteString("ON CONSTRAINT ")

			errExpected: false,
		},
		{
			name:     "should noop if there aren't any {{ .foo }} present",
			template: doNothing,
			data: struct{ ImageRepository, Arch string }{
				ImageRepository: "registry.k8s.io",
				Arch:            "amd64",
			},
			output:      doNothing,
			errExpected: false,
		},
		{
			name:        "invalid syntax, passing nil",
			template:    invalidTmpl1,
			data:        nil,

            "create(String, Action)": { container.create("b", Actions.doNothing()) },
            "register(String)": { container.register("b") },
            "register(String, Action)": { container.register("b", Actions.doNothing()) },
            "NamedDomainObjectProvider.configure(Action)": { container.named("a").configure(Actions.doNothing()) }
        ]
    }

        1 * operationLogger.getLogLocation() >> LOG_LOCATION
        1 * buildOperationExecutor.runAll(commandLineTool, _) >> { worker, action -> action.execute(queue) }
        1 * invocationContext.getArgAction() >> Actions.doNothing()
        1 * invocationContext.createInvocation("linking lib", outputFile.parentFile, expectedArgs, operationLogger) >> invocation
        1 * queue.add(invocation)
        1 * queue.setLogLocation(LOG_LOCATION)
        0 * _

-- $GOPATH/src/github.com/clsung/go-vendor-issue-14613/./vendor_test.go --
package main

import (
	"testing"

	"github.com/clsung/fake"
)

func TestVendor(t *testing.T) {
	ret := fake.DoNothing()
	expected := "Ok"
	if expected != ret {
		t.Errorf("fake returned %q, expected %q", ret, expected)
	}
}

-- $GOPATH/src/github.com/clsung/go-vendor-issue-14613/./vendor/mylibtesttest/myapp/myapp_test.go --