use of org.gradle.api.tasks.testing.Test in project intellij-community by JetBrains.
the class ModuleExtendedModelBuilderImpl method buildAll.
@Nullable
@Override
public Object buildAll(String modelName, Project project) {
final String moduleName = project.getName();
final String moduleGroup = project.getGroup().toString();
final String moduleVersion = project.getVersion().toString();
final File buildDir = project.getBuildDir();
String javaSourceCompatibility = null;
for (Task task : project.getTasks()) {
if (task instanceof JavaCompile) {
JavaCompile javaCompile = (JavaCompile) task;
javaSourceCompatibility = javaCompile.getSourceCompatibility();
if (task.getName().equals("compileJava"))
break;
}
}
final ModuleExtendedModelImpl moduleVersionModel = new ModuleExtendedModelImpl(moduleName, moduleGroup, moduleVersion, buildDir, javaSourceCompatibility);
final List<File> artifacts = new ArrayList<File>();
for (Task task : project.getTasks()) {
if (task instanceof Jar) {
Jar jar = (Jar) task;
artifacts.add(jar.getArchivePath());
}
}
moduleVersionModel.setArtifacts(artifacts);
final Set<String> sourceDirectories = new HashSet<String>();
final Set<String> testDirectories = new HashSet<String>();
final Set<String> resourceDirectories = new HashSet<String>();
final Set<String> testResourceDirectories = new HashSet<String>();
final List<File> testClassesDirs = new ArrayList<File>();
for (Task task : project.getTasks()) {
if (task instanceof Test) {
Test test = (Test) task;
testClassesDirs.add(test.getTestClassesDir());
if (test.hasProperty(TEST_SRC_DIRS_PROPERTY)) {
Object testSrcDirs = test.property(TEST_SRC_DIRS_PROPERTY);
if (testSrcDirs instanceof Iterable) {
for (Object dir : Iterable.class.cast(testSrcDirs)) {
addFilePath(testDirectories, dir);
}
}
}
}
}
IdeaCompilerOutputImpl compilerOutput = new IdeaCompilerOutputImpl();
if (project.hasProperty(SOURCE_SETS_PROPERTY)) {
Object sourceSets = project.property(SOURCE_SETS_PROPERTY);
if (sourceSets instanceof SourceSetContainer) {
SourceSetContainer sourceSetContainer = (SourceSetContainer) sourceSets;
for (SourceSet sourceSet : sourceSetContainer) {
SourceSetOutput output = sourceSet.getOutput();
if (SourceSet.TEST_SOURCE_SET_NAME.equals(sourceSet.getName())) {
compilerOutput.setTestClassesDir(output.getClassesDir());
compilerOutput.setTestResourcesDir(output.getResourcesDir());
}
if (SourceSet.MAIN_SOURCE_SET_NAME.equals(sourceSet.getName())) {
compilerOutput.setMainClassesDir(output.getClassesDir());
compilerOutput.setMainResourcesDir(output.getResourcesDir());
}
for (File javaSrcDir : sourceSet.getAllJava().getSrcDirs()) {
boolean isTestDir = isTestDir(sourceSet, testClassesDirs);
addFilePath(isTestDir ? testDirectories : sourceDirectories, javaSrcDir);
}
for (File resourcesSrcDir : sourceSet.getResources().getSrcDirs()) {
boolean isTestDir = isTestDir(sourceSet, testClassesDirs);
addFilePath(isTestDir ? testResourceDirectories : resourceDirectories, resourcesSrcDir);
}
}
}
}
File projectDir = project.getProjectDir();
IdeaContentRootImpl contentRoot = new IdeaContentRootImpl(projectDir);
final Set<String> ideaSourceDirectories = new HashSet<String>();
final Set<String> ideaTestDirectories = new HashSet<String>();
final Set<String> ideaGeneratedDirectories = new HashSet<String>();
final Set<File> excludeDirectories = new HashSet<File>();
enrichDataFromIdeaPlugin(project, excludeDirectories, ideaSourceDirectories, ideaTestDirectories, ideaGeneratedDirectories);
if (ideaSourceDirectories.isEmpty()) {
sourceDirectories.clear();
resourceDirectories.clear();
}
if (ideaTestDirectories.isEmpty()) {
testDirectories.clear();
testResourceDirectories.clear();
}
ideaSourceDirectories.removeAll(resourceDirectories);
sourceDirectories.removeAll(ideaTestDirectories);
sourceDirectories.addAll(ideaSourceDirectories);
ideaTestDirectories.removeAll(testResourceDirectories);
testDirectories.addAll(ideaTestDirectories);
// ensure disjoint directories with different type
resourceDirectories.removeAll(sourceDirectories);
testDirectories.removeAll(sourceDirectories);
testResourceDirectories.removeAll(testDirectories);
for (String javaDir : sourceDirectories) {
contentRoot.addSourceDirectory(new IdeaSourceDirectoryImpl(new File(javaDir), ideaGeneratedDirectories.contains(javaDir)));
}
for (String testDir : testDirectories) {
contentRoot.addTestDirectory(new IdeaSourceDirectoryImpl(new File(testDir), ideaGeneratedDirectories.contains(testDir)));
}
for (String resourceDir : resourceDirectories) {
contentRoot.addResourceDirectory(new IdeaSourceDirectoryImpl(new File(resourceDir)));
}
for (String testResourceDir : testResourceDirectories) {
contentRoot.addTestResourceDirectory(new IdeaSourceDirectoryImpl(new File(testResourceDir)));
}
for (File excludeDir : excludeDirectories) {
contentRoot.addExcludeDirectory(excludeDir);
}
moduleVersionModel.setContentRoots(Collections.<ExtIdeaContentRoot>singleton(contentRoot));
moduleVersionModel.setCompilerOutput(compilerOutput);
ConfigurationContainer configurations = project.getConfigurations();
SortedMap<String, Configuration> configurationsByName = configurations.getAsMap();
Map<String, Set<File>> artifactsByConfiguration = new HashMap<String, Set<File>>();
for (Map.Entry<String, Configuration> configurationEntry : configurationsByName.entrySet()) {
Set<File> files = configurationEntry.getValue().getAllArtifacts().getFiles().getFiles();
artifactsByConfiguration.put(configurationEntry.getKey(), files);
}
moduleVersionModel.setArtifactsByConfiguration(artifactsByConfiguration);
return moduleVersionModel;
}
use of org.gradle.api.tasks.testing.Test in project gradle by gradle.
the class TestExecutionBuildConfigurationAction method configureTestTasks.
private void configureTestTasks(Set<Test> allTestTasksToRun) {
for (Test task : allTestTasksToRun) {
task.setIgnoreFailures(true);
task.getFilter().setFailOnNoMatchingTests(false);
task.getOutputs().upToDateWhen(Specs.SATISFIES_NONE);
}
}
use of org.gradle.api.tasks.testing.Test in project gradle by gradle.
the class TestExecutionBuildConfigurationAction method configure.
@Override
public void configure(BuildExecutionContext context) {
final Set<Test> allTestTasksToRun = new LinkedHashSet<Test>();
final GradleInternal gradleInternal = context.getGradle();
allTestTasksToRun.addAll(configureBuildForTestDescriptors(gradleInternal, testExecutionRequest));
allTestTasksToRun.addAll(configureBuildForInternalJvmTestRequest(gradleInternal, testExecutionRequest));
configureTestTasks(allTestTasksToRun);
gradle.getTaskGraph().addTasks(allTestTasksToRun);
}
use of org.gradle.api.tasks.testing.Test in project curiostack by curioswitch.
the class CuriostackPlugin method setupJavaProject.
private static void setupJavaProject(Project project) {
PluginContainer plugins = project.getPlugins();
plugins.apply(AptPlugin.class);
plugins.apply(AptIdeaPlugin.class);
plugins.apply(BaselineIdea.class);
plugins.apply(DependencyManagementPlugin.class);
plugins.apply(ErrorPronePlugin.class);
plugins.apply(LicensePlugin.class);
plugins.apply(SpotlessPlugin.class);
plugins.apply(VersionsPlugin.class);
project.getTasks().withType(JavaCompile.class, task -> {
task.getOptions().setIncremental(true);
task.getOptions().getCompilerArgs().addAll(ImmutableList.of("-XepDisableWarningsInGeneratedCode", "-XepExcludedPaths:(.*/build/.*|.*/gen-src/.*)", "-Xep:AutoFactoryAtInject:ERROR", "-Xep:ClassName:ERROR", "-Xep:ComparisonContractViolated:ERROR", "-Xep:DepAnn:ERROR", "-Xep:DivZero:ERROR", "-Xep:EmptyIf:ERROR", "-Xep:FuzzyEqualsShouldNotBeUsedInEqualsMethod:ERROR", "-Xep:InjectInvalidTargetingOnScopingAnnotation:ERROR", "-Xep:InjectScopeAnnotationOnInterfaceOrAbstractClass:ERROR", "-Xep:InsecureCryptoUsage:ERROR", "-Xep:IterablePathParameter:ERROR", "-Xep:LongLiteralLowerCaseSuffix:ERROR", "-Xep:NumericEquality:ERROR", "-Xep:ParameterPackage:ERROR", "-Xep:ProtoStringFieldReferenceEquality:ERROR", "-Xep:AssistedInjectAndInjectOnConstructors:ERROR", "-Xep:BigDecimalLiteralDouble:ERROR", "-Xep:ConstructorLeaksThis:ERROR", "-Xep:InconsistentOverloads:ERROR", "-Xep:MissingDefault:ERROR", "-Xep:PrimitiveArrayPassedToVarargsMethod:ERROR", "-Xep:RedundantThrows:ERROR", "-Xep:StaticQualifiedUsingExpression:ERROR", "-Xep:StringEquality:ERROR", "-Xep:TestExceptionChecker:ERROR", "-Xep:FieldMissingNullable:ERROR", "-Xep:LambdaFunctionalInterface:ERROR", "-Xep:MethodCanBeStatic:ERROR", "-Xep:MixedArrayDimensions:ERROR", "-Xep:MultiVariableDeclaration:ERROR", "-Xep:MultipleTopLevelClasses:ERROR", "-Xep:MultipleUnaryOperatorsInMethodCall:ERROR", "-Xep:PackageLocation:ERROR", "-Xep:ParameterComment:ERROR", "-Xep:ParameterNotNullable:ERROR", "-Xep:PrivateConstructorForUtilityClass:ERROR", "-Xep:RemoveUnusedImports:ERROR", "-Xep:ReturnMissingNullable:ERROR", "-Xep:SwitchDefault:ERROR", "-Xep:ThrowsUncheckedException:ERROR", "-Xep:UngroupedOverloads:ERROR", "-Xep:UnnecessaryStaticImport:ERROR", "-Xep:UseBinds:ERROR", "-Xep:WildcardImport:ERROR"));
project.getTasks().withType(SpotlessTask.class, spotlessTask -> spotlessTask.dependsOn(task));
});
JavaPluginConvention javaPlugin = project.getConvention().getPlugin(JavaPluginConvention.class);
javaPlugin.setSourceCompatibility(JavaVersion.VERSION_1_9);
javaPlugin.setTargetCompatibility(JavaVersion.VERSION_1_9);
Test test = project.getTasks().withType(Test.class).getByName("test");
if (project.getRootProject().hasProperty("updateSnapshots")) {
test.jvmArgs(ImmutableList.of("-Dorg.curioswitch.testing.updateSnapshots=true"));
}
test.useJUnitPlatform(platform -> platform.includeEngines("junit-jupiter", "junit-vintage"));
// While Gradle attempts to generate a unique module name automatically,
// it doesn't seem to always work properly, so we just always use unique
// module names.
project.getPlugins().withType(IdeaPlugin.class, plugin -> {
IdeaModule module = plugin.getModel().getModule();
String moduleName = project.getName();
Project ancestor = project.getParent();
while (ancestor != null && ancestor != project.getRootProject()) {
moduleName = ancestor.getName() + "-" + moduleName;
ancestor = ancestor.getParent();
}
module.setName(moduleName);
project.getTasks().getByName("clean").doLast(unused -> project.file(project.getName() + ".iml").delete());
new DslObject(module).getConvention().getPlugin(ModuleAptConvention.class).getApt().setAddAptDependencies(false);
});
DependencyManagementExtension dependencyManagement = project.getExtensions().getByType(DependencyManagementExtension.class);
dependencyManagement.dependencies(dependencies -> {
for (DependencySet set : StandardDependencies.DEPENDENCY_SETS) {
dependencies.dependencySet(ImmutableMap.of("group", set.group(), "version", set.version()), dependencySet -> set.modules().forEach(dependencySet::entry));
}
StandardDependencies.DEPENDENCIES.forEach(dependencies::dependency);
});
// Pretty much all java code needs at least the Generated annotation.
project.getDependencies().add(JavaPlugin.IMPLEMENTATION_CONFIGURATION_NAME, "javax.annotation:javax.annotation-api");
project.afterEvaluate(CuriostackPlugin::addStandardJavaTestDependencies);
project.getConfigurations().all(configuration -> configuration.exclude(ImmutableMap.of("group", "com.google.guava", "module", "guava-jdk5")));
Javadoc javadoc = (Javadoc) project.getTasks().getByName("javadoc");
CoreJavadocOptions options = (CoreJavadocOptions) javadoc.getOptions();
options.quiet();
options.addBooleanOption("Xdoclint:all,-missing", true);
project.getTasks().create("javadocJar", Jar.class, javadocJar -> {
javadocJar.dependsOn(javadoc);
javadocJar.setClassifier("javadoc");
javadocJar.from(javadoc.getDestinationDir());
});
SourceSetContainer sourceSets = javaPlugin.getSourceSets();
project.getTasks().create("sourceJar", Jar.class, sourceJar -> {
sourceJar.setClassifier("sources");
sourceJar.from(sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME).getAllSource());
});
SpotlessExtension spotless = project.getExtensions().getByType(SpotlessExtension.class);
spotless.java((extension) -> extension.googleJavaFormat(GOOGLE_JAVA_FORMAT_VERSION));
project.getTasks().create("resolveDependencies", resolveDependencies -> resolveDependencies.doLast(unused -> {
project.getConfigurations().all(configuration -> {
if (configuration.isCanBeResolved()) {
configuration.resolve();
}
});
}));
// Protobuf plugin doesn't add proto sourceset to allSource, which seems like an omission.
// We add it to make sure license plugin picks up the files.
project.getPlugins().withType(ProtobufPlugin.class, unused -> {
for (SourceSet sourceSet : sourceSets) {
sourceSet.getAllSource().source(((ExtensionAware) sourceSet).getExtensions().getByType(ProtobufSourceDirectorySet.class));
}
});
project.getPlugins().withType(JMHPlugin.class, unused -> {
JMHPluginExtension jmh = project.getExtensions().getByType(JMHPluginExtension.class);
// Benchmarks are usually very small and converge quickly. If this stops being the
// case
// these numbers can be adjusted.
jmh.setFork(2);
jmh.setIterations(5);
jmh.setProfilers(ImmutableList.of("hs_comp"));
jmh.setJmhVersion("1.19");
Object jmhRegex = project.getRootProject().findProperty("jmhRegex");
if (jmhRegex != null) {
jmh.setInclude((String) jmhRegex);
}
// We will use the jmhManaged for any dependencies that should only be applied to JMH
// but should be resolved by our managed dependencies. We need a separate
// configuration
// to be able to provide the resolution workaround described below.
Configuration jmhManaged = project.getConfigurations().create("jmhManaged");
Configuration jmhConfiguration = project.getConfigurations().getByName("jmh");
jmhConfiguration.extendsFrom(jmhManaged);
// JMH plugin uses a detached configuration to build an uber-jar, which
// dependencyManagement
// doesn't know about. Work around this by forcing parent configurations to be
// resolved and
// added directly to the jmh configuration, which overwrites the otherwise
// unresolvable
// dependency.
project.afterEvaluate(p -> {
jmhConfiguration.getExtendsFrom().forEach(parent -> {
parent.getResolvedConfiguration().getFirstLevelModuleDependencies().forEach(dep -> {
project.getDependencies().add("jmh", dep.getModule().toString());
});
});
});
});
project.getPlugins().withType(JooqPlugin.class, unused -> {
project.getTasks().withType(JooqTask.class, t -> {
for (String dependency : ImmutableList.of("javax.activation:activation", "javax.xml.bind:jaxb-api", "com.sun.xml.bind:jaxb-core", "com.sun.xml.bind:jaxb-impl", "mysql:mysql-connector-java", // Not sure why this isn't automatically added.
"com.google.guava:guava", "com.google.cloud.sql:mysql-socket-factory")) {
project.getDependencies().add("jooqRuntime", dependency);
}
});
});
// It is very common to want to pass in command line system properties to the binary, so just
// always forward properties. It won't affect production since no one runs binaries via Gradle
// in production.
project.getTasks().withType(JavaExec.class, task -> System.getProperties().entrySet().stream().filter(entry -> !entry.getKey().equals("java.endorsed.dirs")).forEach(entry -> task.systemProperty((String) entry.getKey(), entry.getValue())));
}
use of org.gradle.api.tasks.testing.Test in project gradle by gradle.
the class ClientForwardingTestOperationListener method started.
@Override
public void started(BuildOperationDescriptor buildOperation, OperationStartEvent startEvent) {
Object details = buildOperation.getDetails();
if (details instanceof ExecuteTaskBuildOperationDetails) {
Task task = ((ExecuteTaskBuildOperationDetails) details).getTask();
if (!(task instanceof Test)) {
return;
}
runningTasks.put(buildOperation.getId(), task.getPath());
} else if (details instanceof ExecuteTestBuildOperationType.Details) {
ExecuteTestBuildOperationType.Details testOperationDetails = (ExecuteTestBuildOperationType.Details) details;
TestDescriptorInternal testDescriptor = (TestDescriptorInternal) testOperationDetails.getTestDescriptor();
eventConsumer.dispatch(new DefaultTestStartedProgressEvent(testOperationDetails.getStartTime(), adapt(testDescriptor)));
}
}
Aggregations