javaProject.gradle

/* ###
 * IP: GHIDRA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/*****************************************************************************************
	This file is a "mix-in" gradle script that individual gradle projects should include if they
	have java code.
	
	A gradle project can add java support by including the following to its build.gradle file:

		apply from: "$rootProject.projectDir/gradle/support/distributableGhidraModule.gradle"
 *****************************************************************************************/

import org.gradle.plugins.ide.eclipse.model.Container;
import org.gradle.plugins.ide.eclipse.model.Library;


/*********************************************************************************
 * Subproject configuration 
 *  - all subs will have access to these properties.
 *********************************************************************************/

apply plugin: 'java-library'

// Rec 25: ratchet -Xlint back on.
//
// Was: -Xlint:none across compileJava + compileTestJava. That muted
// every javac warning in the tree and hid genuine bugs (the audit
// found dozens of obvious deprecation + unchecked-cast sites).
//
// Stage 1 (shipped earlier): -Xlint:deprecation,unchecked. First
// sweep to make warnings visible. No -Werror.
//
// Stage 2 (Sprint 8): widen to deprecation,unchecked,rawtypes,cast.
// rawtypes flags `List` vs `List<T>` usage; cast flags redundant
// casts. The build does NOT fail on warnings yet — this just
// surfaces the next ratchet level so we can measure the per-
// subproject count toward Stage 3 (pre-clean ≥50-warning
// subprojects, then -Werror promotion).
//
// To opt a single subproject out (temporary, while fixing its
// backlog), set `ext.lintOpts = ['none']` in that subproject's
// build.gradle.
// `-Xmaxwarns 0` removes javac's default cap of 100 warnings per compile.
// Sprint 9 Stage 3 prep: the cap hides the true count for the largest
// subprojects (Generic/Emulation/Features/Base were all at exactly 100
// in the post-Stage-2 master log — almost certainly all >100 with the
// rest truncated). We need accurate per-subproject counts before the
// `-Werror` flip so we know what to pre-clean. See
// docs/testing/STAGE3_ENUMERATION.md.
compileJava {
	def lintOpts = project.hasProperty('lintOpts') ? project.lintOpts : ['deprecation', 'unchecked', 'rawtypes', 'cast']
	options.compilerArgs << "-Xlint:${lintOpts.join(',')}".toString()
	options.compilerArgs << '-XDignore.symbol.file'
	options.compilerArgs << '-Xmaxwarns' << '0'
	options.fork = true
	options.warnings = true
}

compileTestJava {
	def lintOpts = project.hasProperty('lintOpts') ? project.lintOpts : ['deprecation', 'unchecked', 'rawtypes', 'cast']
	options.compilerArgs << "-Xlint:${lintOpts.join(',')}".toString()
	options.compilerArgs << '-XDignore.symbol.file'
	options.compilerArgs << '-Xmaxwarns' << '0'
	options.fork = true
	options.warnings = true
}

processResources {
	duplicatesStrategy = 'exclude'
}

processTestResources {
	duplicatesStrategy = 'exclude'
}
	
java {
	sourceCompatibility = "${rootProject.JAVA_COMPILER}"
	targetCompatibility = "${rootProject.JAVA_COMPILER}"
}


jar {
    manifest {
        attributes (
            "Specification-Title": "${project.name}",
            "Specification-Version": "${rootProject.RELEASE_VERSION}",
            "Specification-Vendor": "Ghidra"
        )
    }
}


sourceSets {
	main {
		java {
			srcDir 'src/main/java'
		}
		resources {
			srcDir 'src/main/resources'
		}
	}
	test {
		java {
			srcDir 'src/test/java'
		}
		resources {
			srcDir 'src/test/resources'
		}
	}
	integrationTest {
		java {
			srcDirs = ['src/test.slow/java'] // overwrite srcDir with new path
			compileClasspath += main.output + test.output
			runtimeClasspath += main.output + test.output
		}
		resources {
			srcDirs = ['src/test.slow/resources']
		}
	}
	screenShots {
		java {
			srcDir 'src/screen/java'
			
			// Screenshots are essentially tests, and depend on classes in several other
			// test directories so they must be included here
			compileClasspath += main.output + test.output + integrationTest.output
			runtimeClasspath += main.output + test.output + integrationTest.output
		}
	}
	pcodeTest {
		java {
			srcDir 'src/test.processors/java'
			compileClasspath += main.output
			runtimeClasspath += main.output
		}
		resources {
			srcDir 'src/test.processors/resources'
		}
	}
	scripts {
		java {
			srcDir 'developer_scripts'
			srcDir 'ghidra_scripts'
			compileClasspath += main.output
		}
	}
}
	
configurations {
	integrationTestImplementation.extendsFrom testImplementation
	integrationTestRuntimeOnly.extendsFrom testRuntimeOnly, integrationTestImplementation
	pcodeTestImplementation.extendsFrom implementation
	cspecTestImplementation.extendsFrom implementation
	scriptsImplementation.extendsFrom implementation
	testArtifacts.extendsFrom testRuntimeOnly
	integrationTestArtifacts.extendsFrom integrationTestRuntimeOnly
	screenShotsImplementation.extendsFrom integrationTestImplementation
}

task testJar(type: Jar) {
	archiveClassifier.set("test") // value part of file name
	from sourceSets.test.output
}

task integrationTestJar(type: Jar) {
	archiveClassifier.set("integrationTest") // value part of file name
	from sourceSets.integrationTest.output
}
artifacts {
	testArtifacts testJar
	integrationTestArtifacts integrationTestJar
	
}

/*
	Provide test dependencies here so each build file does not have to.
*/  
dependencies {
	integrationTestImplementation "org.hamcrest:hamcrest:2.2"

	testImplementation "org.hamcrest:hamcrest:2.2"

	testImplementation "junit:junit:4.13.2"
	pcodeTestImplementation "junit:junit:4.13.2"
	cspecTestImplementation "junit:junit:4.13.2"

	// Rec 27: Mockito for the next generation of unit tests. New tests
	// should prefer Mockito over heavyweight real-Swing/real-Program
	// setup; existing tests are migrated opportunistically.
	// See docs/testing/MOCKITO_ADOPTION.md.
	testImplementation "org.mockito:mockito-core:5.12.0"
	testImplementation "org.mockito:mockito-junit-jupiter:5.12.0"

	// Rec 29 Stage 1: add JUnit 5 (Jupiter) + the Vintage engine that
	// runs JUnit 4 tests through the JUnit Platform. The above JUnit 4
	// dependencies stay; existing tests are unchanged. New tests may
	// be written in JUnit 5 immediately. See
	// docs/testing/JUNIT5_MIGRATION.md.
	testImplementation "org.junit.jupiter:junit-jupiter:5.10.2"
	testRuntimeOnly "org.junit.vintage:junit-vintage-engine:5.10.2"
	testRuntimeOnly "org.junit.platform:junit-platform-launcher:1.10.2"
}

// For Java 9, we must explicitly export references to the internal classes we are using.
// We export them to all "unnamed" modules, which are modules that don't define themselves
// as a new Java 9 style module.  Ghidra is currently using unnamed modules everywhere.
ext.addExports = { List<String> exports ->
	tasks.withType(JavaCompile) {
		exports.each {
			options.compilerArgs.addAll(['--add-exports', it])
		}
	}

	eclipse.classpath.file.whenMerged { classpath ->
		classpath.entries.each { ent ->
			if (ent instanceof Container && ent.path.contains('JRE_CONTAINER')) {
				ent.entryAttributes.put('module', true);
				ent.entryAttributes.put('add-exports', exports.join(':'));
			}
		}
	}
}

// Customize generated Eclipse projects
apply plugin: 'eclipse'
eclipse {
	classpath {
	
		// Expose test classes to dependent projects
		containsTestFixtures = true 
		
		// Customizing which Eclipse source directories should be marked as test.
		// Only screenShots must be added...test and integrationTest are automatically picked up.
		// NOTE: When we upgrade to Gradle 7.5+, we can just set the "testSourceSets" property
		file {
			whenMerged { classpath ->
				classpath.entries.findAll {
					it.kind == 'src' &&  it.path.startsWith('src/screen/')
				}.each {
					it.entryAttributes['test'] = 'true'
				}
			}
		}
	}
}