/**
         * Create a new legacy result representing the result of resolving build dependencies.
         */
        public static LegacyResolverResults buildDependenciesResolved(LegacyVisitedArtifactSet artifacts) {
            return new DefaultLegacyResolverResults(artifacts, null);
        }

        /**
         * Create a new legacy result representing the result of resolving the dependency graph.
         */

        }
        2.times {
            fails 'entryPoint', '-PfinalizerDepDep1.broken', '--continue'
            result.assertTasksExecuted(':entryPoint', ':finalizerDepDep1', ':finalizerDepDep2', ':finalizerDep2')
            result.assertTaskOrder ':entryPoint', ':finalizerDepDep1'

        return buildOperationRunner.call(new CallableBuildOperation<Result>() {
            @Override
            public Result call(BuildOperationContext operationContext) {
                Result result = executeInternal(work, context);
                operationContext.setResult(Operation.Result.INSTANCE);
                return result;
            }

            @Override

            public WorkResult call(BuildOperationContext context) {
                WorkResult result = delegate.execute(spec);
                context.setResult(toBuildOperationResult(result));
                return result;
            }

            private Result toBuildOperationResult(WorkResult result) {
                if (result instanceof ApiCompilerResult) {

        when:
        resolver.resolveArtifact(component, artifact, result)
        then:
        result.hasResult()
        cache.size() == 1
        cache.values().contains(result.result)
        and:
        0 * _._

        when:
        result.result.file
        then:
        1 * localAccess2.resolveArtifact(artifact, moduleSources, _) >> {

                void bar() {
                }
            }
        """)

        val result = runTaskWithFailure("build")

        assertEquals(TaskOutcome.FAILED, result.task(":checkstyleMain")?.outcome)
        assertTrue(result.output.contains("Checkstyle rule violations were found."))
        assertTrue(result.output.contains("Checkstyle violations by severity: [error:1]"))
    }

    @Test

            AllProjects result = new AllProjects();

            GradleBuild buildModel = controller.getBuildModel();
            result.rootBuild = buildModel;
            result.rootIdeaProject = controller.getModel(IdeaProject.class);

            collectAllNestedBuilds(buildModel, controller, result);

            result.allIdeaProjects.add(result.rootIdeaProject);

		Disabled   simulation.Result
		Permissive simulation.Result
		Strict     simulation.Result
	}{
		{
			Name: "tcp",
			Call: simulation.Call{
				Port:     70,
				Protocol: simulation.TCP,
				CallMode: simulation.CallModeInbound,
			},
			Disabled: simulation.Result{
				ClusterMatched: "inbound|70||",
			},
			Permissive: simulation.Result{
				ClusterMatched: "inbound|70||",
			},

        ArrayList<DependencyScope> result = new ArrayList<>();
        result.add(internalScopeManager.createDependencyScope(DS_COMPILE, true, all()));
        result.add(internalScopeManager.createDependencyScope(
                DS_RUNTIME, true, byBuildPath(CommonBuilds.BUILD_PATH_RUNTIME)));
        result.add(internalScopeManager.createDependencyScope(
                DS_PROVIDED,

        runner.useDaemon = false
        runner.warmUpRuns = 2
        runner.runs = 8
        runner.addBuildMutator { cleanLocalCache() }

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()
    }

    @RunFor(
        @Scenario(type = PER_DAY, operatingSystems = [LINUX], testProjects = ["smallJavaMultiProjectManyExternalDependencies"])
    )