Java GradleRunner类代码示例

import org.gradle.testkit.runner.GradleRunner; //导入依赖的package包/类
@Test
public void findsUniqueBuildStepsReportFileName() throws IOException {
    assertTrue(new File(reportsDir, "gradle").mkdirs());
    assertTrue(new File(reportsDir, "gradle/build.xml").createNewFile());
    assertTrue(new File(reportsDir, "gradle/build2.xml").createNewFile());

    BuildResult result = GradleRunner.create()
            .withProjectDir(projectDir.getRoot())
            .withArguments("--stacktrace", "failingTask")
            .buildAndFail();
    assertThat(result.getOutput()).contains("This task will always fail");

    File report = new File(reportsDir, "gradle/build3.xml");
    assertThat(report).exists();
    String reportXml = Files.asCharSource(report, UTF_8).read();
    assertThat(reportXml).contains("message=\"RuntimeException: This task will always fail\"");
}
 

import org.gradle.testkit.runner.GradleRunner; //导入依赖的package包/类
@Test
public void testHelloWorldTask() throws IOException {
    String buildFileContent = "task helloWorld {" +
                              "    doLast {" +
                              "        println 'Hello world!'" +
                              "    }" +
                              "}";
    writeFile(buildFile, buildFileContent);

    BuildResult result = GradleRunner.create()
        .withProjectDir(testProjectDir.getRoot())
        .withArguments("helloWorld")
        .build();

    assertTrue(result.getOutput().contains("Hello world!"));
    assertEquals(result.task(":helloWorld").getOutcome(), SUCCESS);
}
 

import org.gradle.testkit.runner.GradleRunner; //导入依赖的package包/类
private void assertBuild(String project, String[] expectedGavtcs) throws IOException {
    SrcdepsCoreUtils.deleteDirectory(testProjectRootDir);
    SrcdepsCoreUtils.copyDirectory(quickstartsDir.resolve(project), testProjectRootDir);
    List<Path> expectedToExist = new ArrayList<>();
    for (String gavtcPattern : expectedGavtcs) {
        for (Gavtc gavtc : Gavtc.ofPattern(gavtcPattern)) {
            SrcdepsCoreUtils.deleteDirectory(mvnLocalRepo.resolveGroup(gavtc.getGroupId()));
            expectedToExist.add(mvnLocalRepo.resolve(gavtc));
        }
    }

    BuildResult result = GradleRunner.create() //
            .withProjectDir(testProjectRootDir.toFile()) //
            .withArguments("clean", "build", "install") //
            .build();

    Assert.assertEquals(result.task(":test").getOutcome(), SUCCESS);

    for (Path p : expectedToExist) {
        assertExists(p);
    }
}
 

import org.gradle.testkit.runner.GradleRunner; //导入依赖的package包/类
@Test
public void testExplodeWar_withoutExtension() throws IOException {
    loadBuildFileFromClasspath("exploded-archives_withoutExt.gradle");

    BuildResult result = GradleRunner.create()
            .withProjectDir(testProjectDir.getRoot())
            .withArguments("eW", "--stacktrace")
            .withPluginClasspath()
            .withDebug(true)
            .build();

    assertEquals(result.task(":explodeWar").getOutcome(), SUCCESS);

    String name = testProjectDir.getRoot().getName();

    File targetDir = new File(testProjectDir.getRoot(), "build/libs/exploded/" + name);

    assertThat(targetDir).exists();
    assertThat(targetDir).isDirectory();
}
 

import org.gradle.testkit.runner.GradleRunner; //导入依赖的package包/类
@Test
public void testExplodeWar_withExtension() throws IOException {
    loadBuildFileFromClasspath("exploded-archives_withExt.gradle");

    BuildResult result = GradleRunner.create()
            .withProjectDir(testProjectDir.getRoot())
            .withArguments("eW", "--stacktrace")
            .withPluginClasspath()
            .withDebug(true)
            .build();

    assertEquals(result.task(":explodeWar").getOutcome(), SUCCESS);

    String name = testProjectDir.getRoot().getName() + ".war";

    File targetDir = new File(testProjectDir.getRoot(), "build/libs/exploded/" + name);

    assertThat(targetDir).exists();
    assertThat(targetDir).isDirectory();
}
 

import org.gradle.testkit.runner.GradleRunner; //导入依赖的package包/类
@Test
public void testExplodeWar_customDir() throws IOException {
    loadBuildFileFromClasspath("exploded-archives_customDir.gradle");

    BuildResult result = GradleRunner.create()
            .withProjectDir(testProjectDir.getRoot())
            .withArguments("eW", "--stacktrace")
            .withPluginClasspath()
            .withDebug(true)
            .build();

    assertEquals(result.task(":explodeWar").getOutcome(), SUCCESS);

    File targetDir = new File(testProjectDir.getRoot(), "build/foo");

    assertThat(targetDir).exists();
    assertThat(targetDir).isDirectory();
}
 

import org.gradle.testkit.runner.GradleRunner; //导入依赖的package包/类
@Test
public void testDeploy() throws ProcessRunnerException, IOException {
  BuildResult buildResult =
      GradleRunner.create()
          .withProjectDir(testProjectDir.getRoot())
          .withPluginClasspath()
          .withDebug(true)
          .withArguments("appengineDeploy")
          .build();

  Assert.assertThat(
      buildResult.getOutput(),
      CoreMatchers.containsString("Deployed service [standard-project]"));

  CloudSdk cloudSdk =
      new CloudSdk.Builder().exitListener(new NonZeroExceptionExitListener()).build();
  cloudSdk.runAppCommand(Arrays.asList("services", "delete", "standard-project"));
}
 

import org.gradle.testkit.runner.GradleRunner; //导入依赖的package包/类
@Test
public void testDeploy() throws ProcessRunnerException {

  BuildResult buildResult =
      GradleRunner.create()
          .withProjectDir(testProjectDir.getRoot())
          .withPluginClasspath()
          .withDebug(true)
          .withArguments("appengineDeploy")
          .build();

  Assert.assertThat(
      buildResult.getOutput(),
      CoreMatchers.containsString("Deployed service [flexible-project]"));

  CloudSdk cloudSdk =
      new CloudSdk.Builder().exitListener(new NonZeroExceptionExitListener()).build();
  cloudSdk.runAppCommand(Arrays.asList("services", "delete", "flexible-project"));
}
 

import org.gradle.testkit.runner.GradleRunner; //导入依赖的package包/类
@Test
public void testCreateSourceContextViaAssemble_taskTree() throws IOException {
  setUpTestProject();
  BuildResult buildResult =
      GradleRunner.create()
          .withProjectDir(testProjectDir.getRoot())
          .withPluginClasspath()
          .withArguments("assemble", "--dry-run")
          .build();

  final List<String> expected =
      Arrays.asList(
          ":_createSourceContext",
          ":compileJava",
          ":processResources",
          ":classes",
          ":war",
          ":explodeWar",
          ":assemble");

  Assert.assertEquals(expected, BuildResultFilter.extractTasks(buildResult));
}
 

import org.gradle.testkit.runner.GradleRunner; //导入依赖的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.GradleRunner; //导入依赖的package包/类
/** Copy project and run gradle build. */
public BuildResult build() throws URISyntaxException, IOException {
  FileUtils.copyDirectory(
      new File(getClass().getClassLoader().getResource(projectPathInResources).toURI()), testDir);
  if (application != null) {
    injectApplicationId(testDir, application);
  }
  if (hostname != null) {
    injectHostname(hostname);
  }
  if (basePath != null) {
    injectBasePath(basePath);
  }
  return GradleRunner.create()
      .withProjectDir(testDir)
      .withPluginClasspath()
      .withArguments(gradleRunnerArgs)
      .build();
}
 

import org.gradle.testkit.runner.GradleRunner; //导入依赖的package包/类
@Test
public void javafxProguardGradleJfxJar() {
    GRADLE_VERSIONS_TO_TEST_AGAINST.forEach(gradleVersion -> {
        GradleRunner runner = GradleRunner.create().withGradleVersion(gradleVersion).forwardOutput();

        try{
            Path targetFolder = Files.createTempDirectory("javafx-gradle-plugin-tests-" + this.getClass().getSimpleName() + "-javafxProguardGradle");
            Path sourceFolder = new File("examples/javafx-proguard-gradle").toPath();
            // create copyto work on
            copyFolderRecursive(sourceFolder, targetFolder);

            writePluginVersionIntoBuildScript(targetFolder);

            // run build
            BuildResult buildResult = runner.withProjectDir(targetFolder.toAbsolutePath().toFile())
                    .withArguments("clean", "jfxJar", "--stacktrace")
                    .withDebug(true)
                    .build();
        } catch(IOException e){

        }
    });
}
 

import org.gradle.testkit.runner.GradleRunner; //导入依赖的package包/类
@Test
public void additionalBundlerFilesJfxNative() {
    GRADLE_VERSIONS_TO_TEST_AGAINST.forEach(gradleVersion -> {
        GradleRunner runner = GradleRunner.create().withGradleVersion(gradleVersion).forwardOutput();

        try{
            Path targetFolder = Files.createTempDirectory("javafx-gradle-plugin-tests-" + this.getClass().getSimpleName() + "-additionalBundlerFiles");
            Path sourceFolder = new File("examples/additional-bundler-files").toPath();
            // create copyto work on
            copyFolderRecursive(sourceFolder, targetFolder);

            writePluginVersionIntoBuildScript(targetFolder);

            // run build
            BuildResult buildResult = runner.withProjectDir(targetFolder.toAbsolutePath().toFile())
                    .withArguments("clean", "jfxNative", "--stacktrace")
                    .withDebug(true)
                    .build();
        } catch(IOException e){

        }
    });
}
 

import org.gradle.testkit.runner.GradleRunner; //导入依赖的package包/类
@Test
public void minimalSetupJfxNative() {
    GRADLE_VERSIONS_TO_TEST_AGAINST.forEach(gradleVersion -> {
        GradleRunner runner = GradleRunner.create().withGradleVersion(gradleVersion).forwardOutput();

        try{
            Path targetFolder = Files.createTempDirectory("javafx-gradle-plugin-tests-" + this.getClass().getSimpleName() + "-minimalSetupJfxNative");
            Path sourceFolder = new File("examples/minimal-setup-jfxnative").toPath();
            // create copyto work on
            copyFolderRecursive(sourceFolder, targetFolder);

            writePluginVersionIntoBuildScript(targetFolder);

            // run build
            BuildResult buildResult = runner.withProjectDir(targetFolder.toAbsolutePath().toFile())
                    .withArguments("clean", "jfxNative", "--stacktrace")
                    .withDebug(true)
                    .build();
            // TODO check result (currently this is only a "runs without problems"-test)
        } catch(IOException e){

        }
    });
}
 

import org.gradle.testkit.runner.GradleRunner; //导入依赖的package包/类
@Test
public void minimalSetupJfxNative() {
    GRADLE_VERSIONS_TO_TEST_AGAINST.forEach(gradleVersion -> {
        GradleRunner runner = GradleRunner.create().withGradleVersion(gradleVersion).forwardOutput();

        try{
            Path targetFolder = Files.createTempDirectory("javafx-gradle-plugin-tests-" + this.getClass().getSimpleName() + "-minimalSetupWithoutJre");
            Path sourceFolder = new File("examples/minimal-setup-without-bundled-jre").toPath();
            // create copyto work on
            copyFolderRecursive(sourceFolder, targetFolder);

            writePluginVersionIntoBuildScript(targetFolder);

            // run build
            BuildResult buildResult = runner.withProjectDir(targetFolder.toAbsolutePath().toFile())
                    .withArguments("clean", "jfxNative", "--stacktrace")
                    .withDebug(true)
                    .build();
            // TODO check result (currently this is only a "runs without problems"-test)
        } catch(IOException e){

        }
    });
}