import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
public static BuildTask executeGradleRunner(
	File projectDir, String... taskPath) {

	GradleRunner runner = GradleRunner.create().withProjectDir(projectDir);

	GradleRunner runnerWithArguments = runner.withArguments(taskPath);

	BuildResult buildResult = runnerWithArguments.build();

	BuildTask buildtask = null;

	for (BuildTask task : buildResult.getTasks()) {
		if (task.getPath().endsWith(taskPath[taskPath.length - 1])) {
			buildtask = task;
			break;
		}
	}

	return buildtask;
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
@Override
public List<BuildTask> tasks(final TaskOutcome outcome) {
    return Collections.unmodifiableList(CollectionUtils.filter(tasks, new Spec<BuildTask>() {
        public boolean isSatisfiedBy(BuildTask element) {
            return element.getOutcome() == outcome;
        }
    }));
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
@Override
public List<String> taskPaths(TaskOutcome outcome) {
    return Collections.unmodifiableList(CollectionUtils.collect(tasks(outcome), new Transformer<String, BuildTask>() {
        public String transform(BuildTask buildTask) {
            return buildTask.getPath();
        }
    }));
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
private BuildTask determineBuildTask(TaskOperationResult result, String taskPath) {
    if (isFailed(result)) {
        return createBuildTask(taskPath, FAILED);
    } else if (isSkipped(result)) {
        return createBuildTask(taskPath, SKIPPED);
    } else if (isFromCache(result)) {
        return createBuildTask(taskPath, FROM_CACHE);
    } else if (isUpToDate(result)) {
        return createBuildTask(taskPath, UP_TO_DATE);
    }

    return createBuildTask(taskPath, SUCCESS);
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
/** Extract task as a list of path strings. */
public static List<String> extractTasks(BuildResult buildResult) {

  return FluentIterable.from(buildResult.getTasks())
      .transform(
          new Function<BuildTask, String>() {
            @Override
            public String apply(BuildTask buildTask) {
              return buildTask.getPath();
            }
          })
      .toList();
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
@Test
public void testServiceBuilderGradleTemplate() throws Exception {
	File projectPath = BladeCLIUtil.createProject(
		_testDir, "service-builder", "guestbook", "-p",
		"com.liferay.docs.guestbook");

	BuildTask buildService = GradleRunnerUtil.executeGradleRunner(
		projectPath, "buildService");

	GradleRunnerUtil.verifyGradleRunnerOutput(buildService);

	BuildTask buildtask = GradleRunnerUtil.executeGradleRunner(
		projectPath, "build");

	GradleRunnerUtil.verifyGradleRunnerOutput(buildtask);

	File buildApiOutput = new File(
		projectPath + "/guestbook-api/build/libs" +
			"/com.liferay.docs.guestbook.api-1.0.0.jar");
	File buildServiceOutput = new File(
		projectPath + "/guestbook-service/build/libs" +
			"/com.liferay.docs.guestbook.service-1.0.0.jar");

	Assert.assertTrue(buildApiOutput.exists());
	Assert.assertTrue(buildServiceOutput.exists());

	String bundleIDApi = BladeCLIUtil.installBundle(buildApiOutput);
	String bundleIDService = BladeCLIUtil.installBundle(buildServiceOutput);

	BladeCLIUtil.startBundle(bundleIDApi);
	BladeCLIUtil.startBundle(bundleIDService);

	BladeCLIUtil.uninstallBundle(bundleIDApi, bundleIDService);
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
@Test
public void halt_build_on_duplicate_command_handling_methods() {
    final BuildResult result = newProjectWithJava(
            "io/spine/model/verify/DuplicateAggregate.java",
            "io/spine/model/verify/DuplicateCommandHandler.java")
            .executeAndFail(VERIFY_MODEL);
    final BuildTask task = result.task(toPath(VERIFY_MODEL));
    assertNotNull(task);
    final TaskOutcome generationResult = task.getOutcome();
    assertEquals(FAILED, generationResult);
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
@Ignore // TODO:2017-08-25:dmytro.dashenkov: Re-enable when Model is capable of checking the handler methods.
        // https://github.com/SpineEventEngine/base/issues/49
@Test
public void halt_build_on_malformed_command_handling_methods() {
    final BuildResult result =
            newProjectWithJava("io/spine/model/verify/MalformedAggregate.java")
            .executeAndFail(VERIFY_MODEL);
    final BuildTask task = result.task(toPath(VERIFY_MODEL));
    assertNotNull(task);
    final TaskOutcome generationResult = task.getOutcome();
    assertEquals(FAILED, generationResult);
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
static String buildResultToString(BuildResult result) {
	return StringPrinter.buildString(printer -> {
		for (BuildTask task : result.getTasks()) {
			printer.println(task.getPath() + " " + task.getOutcome());
		}
	});
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
/**
 * Create a task
 * @param taskName the task's name
 * @param parameters the download parameters
 * @return the task
 * @throws Exception if anything went wrong
 */
protected BuildTask runTask(String taskName, Parameters parameters) throws Exception {
    return createRunner(parameters)
            .withArguments(parameters.offline ? asList("--offline", taskName) :
                singletonList(taskName))
            .build()
            .task(taskName);
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
public DefaultBuildResult(String output, List<BuildTask> tasks) {
    this.output = output;
    this.tasks = tasks;
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
@Override
public List<BuildTask> getTasks() {
    return Collections.unmodifiableList(tasks);
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
public FeatureCheckBuildResult(BuildOperationParameters buildOperationParameters, String output, List<BuildTask> tasks) {
    delegateBuildResult = new DefaultBuildResult(output, tasks);
    outputFeatureCheck = new BuildResultOutputFeatureCheck(buildOperationParameters.getTargetGradleVersion(), buildOperationParameters.isEmbedded());
    tasksFeatureCheck = new BuildResultTasksFeatureCheck(buildOperationParameters.getTargetGradleVersion());
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
@Override
public List<BuildTask> getTasks() {
    tasksFeatureCheck.verify();
    return delegateBuildResult.getTasks();
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
@Override
public List<BuildTask> tasks(TaskOutcome outcome) {
    tasksFeatureCheck.verify();
    return delegateBuildResult.tasks(outcome);
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
@Nullable
@Override
public BuildTask task(String taskPath) {
    tasksFeatureCheck.verify();
    return delegateBuildResult.task(taskPath);
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
public GradleExecutionResult(BuildOperationParameters buildOperationParameters, String standardOutput, List<BuildTask> tasks) {
    this(buildOperationParameters, standardOutput, tasks, null);
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
public List<BuildTask> getTasks() {
    return tasks;
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
public TaskExecutionProgressListener(List<BuildTask> tasks) {
    this.tasks = tasks;
}
 

import org.gradle.testkit.runner.BuildTask; //导入依赖的package包/类
private BuildTask createBuildTask(String taskPath, TaskOutcome outcome) {
    return new DefaultBuildTask(taskPath, outcome);
}