def binary = Mock(BinarySpecInternal)
    def taskFactory = Mock(NamedEntityInstantiator)
    def tasks = new DefaultBinaryTasksCollection(binary, taskFactory, CollectionCallbackActionDecorator.NOOP)
    def task = Mock(Task)

    def "can create task"() {
        def action = Mock(Action)
        def task = Stub(Task)

        when:
        tasks.create("foo", DefaultTask, action)

        then:

    %control_5 = tf_executor.island(%control, %control_4) wraps "tf.NoOp"() : () -> ()
    tf_executor.fetch %control_5 : !tf_executor.control
  }
  func.return
}

// -----

// CHECK-LABEL: func.func @convert_xla_must_compile

		return err
	}
	_, _, err := c.cmd(250, "RSET")
	return err
}

// Noop sends the NOOP command to the server. It does nothing but check
// that the connection to the server is okay.
func (c *Client) Noop() error {
	if err := c.hello(); err != nil {
		return err
	}
	_, _, err := c.cmd(250, "NOOP")
	return err
}

// Quit sends the QUIT command and closes the connection to the server.

	// RemoveEndpoints removes this apiserver's lease.
	RemoveEndpoints(serviceName string, ip net.IP, endpointPorts []corev1.EndpointPort) error
	// StopReconciling turns any later ReconcileEndpoints call into a noop.
	StopReconciling()
	// Destroy shuts down all internal structures.
	// Destroy needs to be implemented in thread-safe way and be prepared for being
	// called more than once.
	Destroy()
}

      %control_27 = tf_executor.island(%control_2, %control_26) wraps "tf.NoOp"() : () -> ()
      tf_executor.fetch %control_27 : !tf_executor.control
    }
    func.return
  }

            [apiUsingUsage(), apiUsingUsage("fromResolutionOf('compileClasspath')")],
            [runtimeUsingUsage(), runtimeUsingUsage("fromResolutionOf('runtimeClasspath')")]
        ].combinations() + [[allVariants(), noop()]])
    }

    def "dependency constraints which are unresolved are published as is"() {
        javaLibrary(mavenRepo.module("org.test", "foo", "1.0")).withModuleMetadata().publish()

class DefaultPublishArtifactSetTest extends Specification {
    final store = new DefaultDomainObjectSet<PublishArtifact>(PublishArtifact, CollectionCallbackActionDecorator.NOOP)
    final set = new DefaultPublishArtifactSet('artifacts', store, fileCollectionFactory(), TestFiles.taskDependencyFactory())

    def "set is built by the union of the tasks that build the publish artifacts"() {

    static class TestReportContainer extends DefaultReportContainer {
        TestReportContainer(Closure c) {
            super(Report, TestUtil.instantiatorFactory().decorateLenient(), CollectionCallbackActionDecorator.NOOP)

            c.delegate = new Object() {
                Report createReport(String name) {
                    add(TestReport, name, Describables.of(name), Report.OutputType.FILE)
                }
            }

int *nilp;

int main(int argc, char** argv) {
	int verbose;
	int test;

	if (argc < 2) {
		printf("Missing argument\n");
		return 1;
	}

	test = atoi(argv[1]);

	verbose = (argc > 2);

	Noop();

	switch (test) {
		case 1: {
			if (verbose) {
				printf("attempting segfault\n");
			}

			*nilp = 0;
			break;
		}

		case 2: {
			struct timeval tv;

			if (verbose) {

    @VisibleForTesting
    public static void visitProperties(PropertyWalker propertyWalker, TaskInternal task, PropertyVisitor visitor) {
        visitProperties(propertyWalker, task, TypeValidationContext.NOOP, visitor);
    }

    /**
     * Visits both properties declared via annotations on the properties of the task type as well as
     * properties declared via the runtime API ({@link org.gradle.api.tasks.TaskInputs} etc.).