withConnection { connection ->
            def build = connection.newBuild()
                .addProgressListener(progressEventCollector)
                .forTasks('test')
            if (enableStdoutProxying) {
                build.setStandardOutput(System.out).setStandardError(System.err)
            }
            build.run()
        }
    }

    }

    private void runBuild(String... tasks) {
        withConnection {
            ProjectConnection connection ->
                connection.newBuild()
                    .forTasks(tasks)
                    .addProgressListener(events, EnumSet.of(OperationType.TASK))
                    .run()
        }
    }

    private Set<? extends OperationDescriptor> tasks(String... paths) {

        build.run()
    }

    private BuildLauncher basicBuildConfiguration(ProjectConnection connection) {
        def build = connection.newBuild()
        collectOutputs(build)
        build.forTasks(DUMMY_TASK_NAME)
        build
    }

    private String getOutput() {
        stdout.toString()
    }

    }

    private void runBuild(String task, Action<BuildLauncher> config = {}) {
        withConnection {
                def launcher = newBuild()
                    .forTasks(task)
                    .addProgressListener(events, EnumSet.of(OperationType.TASK))
                config.execute(launcher)
                launcher.run()
        }
    }

        '''.stripIndent()

        TestOutputStream stdout = new TestOutputStream()

        when:
        withConnection { connection -> connection.newBuild().setStandardOutput(stdout).forTasks('hello').run() }
        String output = stdout.toString()

        then:
        output.contains('system_property_available in buildSrc:                 true')

        TestOperationCollector collector = new TestOperationCollector()
        withConnection { connection ->
            def build = connection.newBuild()
            build.addProgressListener(collector)
            build.forTasks(":other-build:sub:test").run()
        }
        TestOperationDescriptor descriptor = collector.descriptors.find { it.name == "myTestMethod" }

        when:
        withConnection { connection ->

            }
        """

        when:
        def events = ProgressEvents.create()

        withConnection {
            ProjectConnection connection ->
                connection.newBuild().forTasks('publish')
                    .addProgressListener(events).run()
        }

        then:
        def publishTask = events.operation('Task :publishMavenPublicationToMavenRepository')

    }

    private void runCacheableBuild(listener, String task = "cacheable") {
        withConnection {
            ProjectConnection connection ->
                connection.newBuild().withArguments("--build-cache").forTasks(task).addProgressListener(listener, EnumSet.of(OperationType.GENERIC, OperationType.TASK)).run()
        }
    }

    int maybeIncludeLocalBuildOperations(int expectedNumber) {
        hasLocalBuildCacheOperations()

	if cp.Checksum == 0 {
		// accept empty checksum for compatibility with old file backend
		return nil
	}

	ck := cp.Checksum
	cp.Checksum = 0
	object := dump.ForHash(cp)
	object = strings.Replace(object, "CPUManagerCheckpointV1", "CPUManagerCheckpoint", 1)
	cp.Checksum = ck

	hash := fnv.New32a()
	fmt.Fprintf(hash, "%v", object)

        def model = modelFor([])

        then:
        model.groups as List == []
    }

    private SingleProjectTaskReportModel modelFor(List<Task> tasks) {
        SingleProjectTaskReportModel.forTasks(tasks, factory)
    }

    private static Path pathOf(Task t) {
        Path.path(t.path)
    }