We Keep Coding

Could not find or load main class gradle 7.0 spring-boot 2.5.6

I just made an update from spring boot version "2.2.1.RELEASE" to 2.5.6 and along with that I also updated the gradle version to 7.0. Before the update everything worked fine but after the update it seems that the bootRun task doesn't find the main class.
This is the error received:
Deprecated Gradle features were used in this build, making it
incompatible with Gradle 8.0. Use '--warning-mode all' to show the
individual deprecation warnings. See
https://docs.gradle.org/7.0/userguide/command_line_interface.html#sec:command_line_warnings
12 actionable tasks: 12 executed
Error: Could not find or load main class com.test.TestApplication
FAILURE: Build failed with an exception.
I ve followed the documentation https://docs.spring.io/spring-boot/docs/current/gradle-plugin/reference/htmlsingle/#running-your-application and I have the following build.gradle
buildscript {
ext {
springBootVersion = '2.5.6'
}
repositories {
// ..
}
dependencies {
classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
classpath "org.springframework.boot:spring-boot-starter-jersey:${springBootVersion}"
classpath("net.ltgt.gradle:gradle-apt-plugin:0.15")
classpath 'gradle.plugin.com.palantir.gradle.gitversion:gradle-git-version:0.11.0'
}
}
apply plugin: "java"
apply plugin: "war"
apply plugin: 'eclipse'
apply plugin: "idea"
apply plugin: "org.sonarqube"
apply plugin: "jacoco"
apply plugin: "maven-publish"
apply plugin: "net.ltgt.apt"
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
apply plugin: 'com.palantir.git-version'
def mapStructVersion = "1.3.0.Final"
def swaggerVersion = "1.6.3"
def junitVersion = "4.13.2"
sourceCompatibility = 1.8
sourceSets {
main {
java {
srcDir "${buildDir.absolutePath}/generated/source/apt/main"
}
}
test {
java {
srcDir "${buildDir.absolutePath}/generated/source/apt/main"
}
}
}
configurations.all {
resolutionStrategy.cacheChangingModulesFor 0, "seconds"
}
repositories {
// ...
}
task preBuild {
delete "${buildDir.absolutePath}/generated/source/apt/main"
}
build.dependsOn preBuild
configurations {
developmentOnly.extendsFrom compile
runtimeClasspath {
extendsFrom developmentOnly
}
}
/**
* Fix extension/file too long issue under windows
*/
task pathingJar(type: Jar) {
dependsOn configurations.developmentOnly
archiveAppendix = 'pathing'
doFirst {
manifest {
attributes "Class-Path": configurations.developmentOnly.files.collect {
it.toURI().toString().replaceFirst(/file:\/+/, '/')
}.join(' ')
}
}
}
/**
* With gradle 7, a duplicate strategy must be set in order to not encountering error during copy operation.
* Solution: EXCLUDE strategy do not allow duplicates by ignoring subsequent items to be created at the same path.
*/
processIntegrationTestResources {
duplicatesStrategy(DuplicatesStrategy.EXCLUDE)
}
bootRun {
main = 'com.test.TestApplication'
dependsOn pathingJar
doFirst {
classpath = files(sourceSets.main.output.files, pathingJar.archiveFile)
}
def debugPort = project.properties["${project.name}.debugPort"]
if (debugPort) {
jvmArgs = ["-Xdebug", "-Xnoagent", "-Djava.compiler=NONE", "-Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=${debugPort}"]
}
if (System.getProperty("LOG_PATH") == null) {
System.setProperty("LOG_PATH", project.projectDir.getCanonicalPath() + "/log")
}
if (System.getProperty("spring.profiles.active") == null) {
System.setProperty("spring.profiles.active", "some-profile")
}
if (System.getProperty("servicelayer.rrLogHumanReadable") == null) {
System.setProperty("servicelayer.rrLogHumanReadable", "true")
}
systemProperties = System.properties
}
def compileDependencies = [
"org.springframework.cloud:spring-cloud-starter-bootstrap:3.0.4",
"org.springframework.boot:spring-boot-starter-web",
"org.springframework.boot:spring-boot-starter-jersey",
"org.springframework.boot:spring-boot-starter-security",
"org.springframework.boot:spring-boot-starter-actuator",
"org.springframework.boot:spring-boot-starter-data-jpa",
"org.springframework.boot:spring-boot-starter-cache",
"io.swagger:swagger-jersey2-jaxrs:${swaggerVersion}",
"io.jsonwebtoken:jjwt:0.9.0",
"org.bitbucket.b_c:jose4j:0.6.3",
'org.flywaydb:flyway-core',
"org.mapstruct:mapstruct-jdk8:${mapStructVersion}",
"com.github.ben-manes.caffeine:caffeine",
'org.bouncycastle:bcprov-jdk15on:1.60'
]
// defined some dependencies. Not relevant
dependencies {
implementation compileDependencies
providedRuntime providedRuntimeDependencies
testImplementation testCompileDependencies
}
I tried both ways, from command line and from ide (IntelliJ)
clean bootRun -Dspring.profiles.active="some-profile"

I found the solution and the issue has been inside the task pathingJar.
Before:
task pathingJar(type: Jar) {
dependsOn configurations.developmentOnly
archiveAppendix = 'pathing'
doFirst {
manifest {
attributes "Class-Path": configurations.developmentOnly.files.collect {
it.toURI().toString().replaceFirst(/file:\/+/, '/')
}.join(' ')
}
}
}
After:
task pathingJar(type: Jar) {
dependsOn configurations.runtimeClasspath
archiveAppendix = 'pathing'
doFirst {
manifest {
attributes "Class-Path": configurations.runtimeClasspath.files.collect {
it.toURI().toString().replaceFirst(/file:\/+/, '/')
}.join(' ')
}
}
}
So the solution has been to change the following two lines of code
dependsOn configurations.developmentOnly -> dependsOn configurations.runtimeClasspath
attributes "Class-Path": configurations.developmentOnly.files.collect {...} -> attributes "Class-Path": configurations.runtimeClasspath.files.collect {...}
Long story short is that somehow another tasks interfered with this task on developmentOnly scope and I had to change it to runtimeClasspah
Edit:
Another issue might be inside of bootRun task. You can define the package where is the main class.
bootRun {
main = 'edu.somepacke.MyMainClass'
dependsOn pathingJar
doFirst {
classpath = files(sourceSets.main.output.files, pathingJar.archiveFile)
}
//extra logic
}

Error Prone and NullAway Illegal Access Exception

I am incorporating null away and error prone into my app and have added the following to my top-level build.gradle
buildscript {
repositories {
google()
maven { url 'https://plugins.gradle.org/m2/' }
...
}
dependencies {
classpath 'com.android.tools.build:gradle:3.1.2'
classpath "net.ltgt.gradle:gradle-errorprone-plugin:0.0.16"
}
}
subprojects {
apply from: rootProject.file("gradle/nullaway.gradle")
}
...
then in the nullaway.gradle file I have
buildscript {
repositories {
maven {
url "https://plugins.gradle.org/m2/"
}
}
}
apply plugin: 'net.ltgt.errorprone'
if (this.name == 'javalib1' || this.name == 'javalib2') {
apply plugin: 'java-library'
dependencies {
annotationProcessor deps.thirdparty.nullaway
errorprone deps.thirdparty.error_prone
}
} else {
if (this.name == 'app') {
apply plugin: 'com.android.application'
} else {
apply plugin: 'com.android.library'
}
dependencies {
annotationProcessor deps.thirdparty.nullaway
errorprone deps.thirdparty.error_prone
}
}
tasks.withType(JavaCompile) {
if (!name.toLowerCase().contains("test")) {
options.compilerArgs += [
"-Xep:NullAway:WARN",
"-XepOpt:NullAway:AnnotatedPackages=com.mypackage",
"-Xep:RestrictTo:WARN",
"-XepExcludedPaths:.*/build/generated/.*"]
}
}
With this setup whenever I try to build my app I get an exception
Caused by: java.lang.IllegalAccessError: tried to access class com.google.common.graph.BaseGraph from class com.google.common.graph.Traverser
at com.google.common.graph.Traverser.forTree(Traverser.java:134)
at dagger.internal.codegen.ValidationReport.<clinit>(ValidationReport.java:63)
at dagger.internal.codegen.InjectValidator.validateMembersInjectionType(InjectValidator.java:257)
at dagger.internal.codegen.InjectBindingRegistryImpl.tryRegisterMembersInjectedType(InjectBindingRegistryImpl.java:269)
at dagger.internal.codegen.InjectBindingRegistryImpl.tryRegisterMembersInjectedType(InjectBindingRegistryImpl.java:253)
at dagger.internal.codegen.InjectProcessingStep$1.visitVariableAsField(InjectProcessingStep.java:67)
at dagger.internal.codegen.InjectProcessingStep$1.visitVariableAsField(InjectProcessingStep.java:57)
at com.sun.tools.javac.code.Symbol$VarSymbol.accept(Symbol.java:1550)
at dagger.internal.codegen.InjectProcessingStep.process(InjectProcessingStep.java:56)
at dagger.shaded.auto.common.BasicAnnotationProcessor.process(BasicAnnotationProcessor.java:330)
at dagger.shaded.auto.common.BasicAnnotationProcessor.process(BasicAnnotationProcessor.java:181)
I check the notes and I am using dagger version 2.16 and as you can see I have the exclude for build/generated files. What am I missing?

Enabling assertions in Gradle/JUnit

My project uses gradle and JUnit 5.01. The JUnit assertions are working fine. However, my regular Java assertions in the tested code itself are not firing. I would expect a failed assert to throw an AssertionError that would be caught and reported by JUnit.
I found this: How to disable assert in gradle test, and so created this build.gradle:
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'org.junit.platform:junit-platform-gradle-plugin:1.0.2'
}
}
apply plugin: 'java'
apply plugin: 'application'
apply plugin: 'maven'
apply plugin: 'org.junit.platform.gradle.plugin'
compileJava {
options.compilerArgs += "-Xlint:unchecked"
}
tasks.withType(Test) {
enableAssertions = true
}
repositories {
mavenCentral()
}
dependencies {
testCompile('org.junit.jupiter:junit-jupiter-api:5.0.1')
testCompile('org.apiguardian:apiguardian-api:1.0.0')
testRuntime('org.junit.jupiter:junit-jupiter-engine:5.0.1')
}
// Define the main class for the application
mainClassName = 'CMS'
jar {
manifest {
attributes 'Implementation-Title': 'CMS',
'Main-Class': 'com.brandli.cms.CMS'
}
}
junitPlatform {
filters {
includeClassNamePattern '.*'
}
}
test {
testLogging {
exceptionFormat = 'full'
}
}
What am I doing wrong?

Digging into gradle, and a lot of experimenting, led me to find that replacing
tasks.withType(Test) {
enableAssertions = true
}
with
junitPlatformTest {
enableAssertions = true
}
did the trick. I don't know why.

could not find ant-javafx in gradle app

While writing my first app using JavaFX, I ensured that JAVA_HOME is setup properly, and included the javafx-gradle-plugin into my app, but got an error of missing ant-javafx-library which actually available in my JDK :(
my build.gradle and the error msg I got are below:
// set up the kotlin-gradle plugin
buildscript {
ext.kotlin_version = '1.1.60'
repositories {
mavenLocal() // mavenCentral()
}
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
classpath "de.dynamicfiles.projects.gradle.plugins:javafx-gradle-plugin:8.8.2"
}
}
// apply the kotlin-gradle plugin
apply plugin: "kotlin"
apply plugin: 'javafx-gradle-plugin'
// add kotlin-stdlib dependencies.
repositories {
mavenLocal() // mavenCentral()
}
dependencies {
//dependencies from a remote repositor
compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
compile "no.tornado:tornadofx:1.7.12"
compile "de.dynamicfiles.projects.gradle.plugins:javafx-gradle-plugin:8.8.2"
}
jar {
manifest {
//Define mainClassName as: '[your_namespace].[your_arctifact]Kt'
attributes ('Main-Class': 'MyAppKt', "Implementation-Title": "Gradle",
"Implementation-Version": 1)
}
// NEW LINE HERE !!!
from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
}
sourceSets {
main.kotlin.srcDirs += 'src/kotlin'
main.resources.srcDirs += 'src/resources'
}
kotlin {
experimental.coroutines 'enable'
}
compileKotlin {
kotlinOptions.jvmTarget= 1.8 // optional, Minimum jvmTarget of 1.8 needed since Kotlin 1.1
kotlinOptions.suppressWarnings = true
}

I was able to solve it, by downloading the javafx.plugin from here.
Then created a 'plugin' folder, and copied that file in it.
Last, I installed this plugging into my gradle.build as:
apply from: "plugins/javafx.plugin"
So, my last gradle.build is:
// set up the kotlin-gradle plugin
buildscript {
ext.kotlin_version = '1.1.60'
repositories {
mavenLocal() // mavenCentral()
}
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
// classpath files('plugins/javafx.plugin')
}
}
// apply the kotlin-gradle plugin
apply plugin: "kotlin"
apply from: "plugins/javafx.plugin" // apply from: "http://dl.bintray.com/content/shemnon/javafx-gradle/8.1.1/javafx.plugin"
// add kotlin-stdlib dependencies.
repositories {
mavenLocal() // mavenCentral()
}
dependencies {
//dependencies from a remote repositor
compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
compile "no.tornado:tornadofx:1.7.12"
}
jar {
manifest {
//Define mainClassName as: '[your_namespace].[your_arctifact]Kt'
attributes ('Main-Class': 'MainKt', "Implementation-Title": "Gradle",
"Implementation-Version": 1)
}
// NEW LINE HERE !!!
from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
}
sourceSets {
main.kotlin.srcDirs += 'src/kotlin'
main.resources.srcDirs += 'src/resources'
}
kotlin {
experimental.coroutines 'enable'
}
compileKotlin {
kotlinOptions.jvmTarget= 1.8 // optional, Minimum jvmTarget of 1.8 needed since Kotlin 1.1
kotlinOptions.suppressWarnings = true
}
and my app structure, is:
UPDATE
OPTION 2
Install the new plugin here by:
buildscript {
repositories {
mavenCentral() // or mavenLocal()
}
dependencies {
compile "de.dynamicfiles.projects.gradle.plugins:javafx-gradle-plugin:8.8.2"
}
}
If interested in using mavenLocal() then is can be downloaded using the below command:
mvn dependency:get -DrepoUrl=https://mvnrepository.com/artifact/de.dynamicfiles.projects.gradle.plugins/javafx-gradle-plugin/8.8.2 -Dartifact=de.dynamicfiles.projects.gradle.plugins:javafx-gradle-plugin:8.8.2
To get the mvn command line, you get download it from here, add it to your path then call it from anywhere.

Test package does not read Kotlin classes defined in main package

I cannot seem to access main classes within the test package in my Kotlin module within an Android Studio project. Please note that all code shown below is within a Kotlin JVM module that is imported into the Android app.
Here's my src/main/java code:
import com.google.gson.annotations.SerializedName
data class Customer(val password1: String,
val password2: String,
#SerializedName("last_name") val lastName: String,
#SerializedName("first_name") val firstName: String,
val email: String)
My test code in src/test/java:
class CreateUser {
#Test
fun createRandomUser() {
val random = Random()
val randomNumber = random.nextInt(10000000)
val customer = Customer("password", "password", "lastName", "firstName", "ted$randomNumber#gmail.com")
}
}
My build.gradle code looks like the following:
buildscript {
ext.kotlin_version = '1.1.4-3'
repositories {
mavenCentral()
jcenter()
}
dependencies {
classpath 'me.tatarka:gradle-retrolambda:3.7.0'
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}
apply plugin: 'java'
apply plugin: 'maven'
apply plugin: 'me.tatarka.retrolambda'
apply plugin: 'kotlin'
repositories {
mavenCentral()
jcenter()
}
dependencies {
// some other compile dependencies
compile "org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version"
testCompile "org.hamcrest:hamcrest-all:1.3"
testCompile 'junit:junit:4.11'
testCompile 'org.mockito:mockito-all:1.9.5'
testCompile "org.jetbrains.kotlin:kotlin-test"
testCompile "org.jetbrains.kotlin:kotlin-test-junit"
}
task javadocJar(type: Jar) {
classifier = 'javadoc'
from javadoc
}
task sourcesJar(type: Jar) {
classifier = 'sources'
from sourceSets.main.allSource
}
artifacts {
archives sourcesJar
archives javadocJar
}
compileKotlin {
kotlinOptions {
jvmTarget = "1.6"
}
}
compileTestKotlin {
kotlinOptions {
jvmTarget = "1.6"
}
}
The root build.gradle file looks as follows:
// Top-level build file where you can add configuration options
common to all sub-projects/modules.
buildscript {
repositories {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:2.3.3'
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
}
}
allprojects {
repositories {
jcenter()
maven {
url "https://jitpack.io"
credentials { username authToken }
}
}
}
task clean(type: Delete) {
delete rootProject.buildDir
}
ext {
versionName = "0.1.1"
rxJavaVersion = "2.1.3"
okHttpVersion = "3.9.0"
retrofitVersion = "2.3.0"
rxJava2AdapterVersion = "1.0.0"
googleGsonVersion = "2.8.0"
}
The error I get is that gradle cannot resolve Customer (Unresolved reference: Customer) in the Test class. It doesn't seem to include main classes into the test source directory. Yet, it resolves in the IDE.

Ok, I have found the solution. It seems I have to specify the src folders explicitly in my build.gradle and put all Kotlin code in src/main/kotlin and src/test/kotlin respectively.
sourceSets {
main.kotlin.srcDirs = ['src/main/kotlin', 'src/main/java']
main.java.srcDirs = []
test.kotlin.srcDirs = ['src/test/kotlin', 'src/test/java']
test.java.srcDirs = ['src/test/kotlin', 'src/test/java']
}
Once I did that, the tests started to work as expected - reports are even generated on Jenkins which is great.