import aQute.bnd.gradle.BundleTaskExtension

import net.ltgt.gradle.errorprone.CheckSeverity

import org.jetbrains.kotlin.gradle.dsl.JvmTarget

import org.jetbrains.kotlin.gradle.dsl.KotlinVersion

import org.objectweb.asm.ClassReader

import org.objectweb.asm.ClassWriter

import org.objectweb.asm.tree.ClassNode

import java.text.SimpleDateFormat

buildscript {

repositories { mavenCentral() }

dependencies {

classpath 'org.ow2.asm:asm:9.9.1'

classpath 'org.ow2.asm:asm-tree:9.9.1'

}

}

plugins {

id 'java'

id 'java-library'

id 'maven-publish'

id 'antlr'

id 'signing'

id "com.gradleup.shadow" version "9.4.2"

id "biz.aQute.bnd.builder" version "7.1.0"

id "io.github.gradle-nexus.publish-plugin" version "2.0.0"

id "groovy"

id "me.champeau.jmh" version "0.7.3"

id "io.github.reyerizo.gradle.jcstress" version "0.9.0"

id "net.ltgt.errorprone" version '5.1.0'

id 'jacoco'

//

// Kotlin just for tests - not production code

id 'org.jetbrains.kotlin.jvm' version '2.3.20'

}

java {

toolchain {

languageVersion = JavaLanguageVersion.of(25) // build on 25 - release on 11

}

}

kotlin {

compilerOptions {

apiVersion = KotlinVersion.KOTLIN_2_0

languageVersion = KotlinVersion.KOTLIN_2_0

jvmTarget = JvmTarget.JVM_11

javaParameters = true

freeCompilerArgs = [

'-Xemit-jvm-type-annotations',

'-Xjspecify-annotations=strict',

]

}

}

def makeDevelopmentVersion(parts) {

def version = String.join("-", parts)

println "created development version: $version"

return version

}

static private List<List> invisibleAnnotationLists(ClassNode classNode) {

def annotationLists = []

if (classNode.invisibleAnnotations != null) {

annotationLists.add(classNode.invisibleAnnotations)

}

classNode.fields.each { field ->

if (field.invisibleAnnotations != null) {

annotationLists.add(field.invisibleAnnotations)

}

}

classNode.methods.each { method ->

if (method.invisibleAnnotations != null) {

annotationLists.add(method.invisibleAnnotations)

}

method.invisibleParameterAnnotations?.each { annotations ->

if (annotations != null) {

annotationLists.add(annotations)

}

}

}

classNode.recordComponents?.each { recordComponent ->

if (recordComponent.invisibleAnnotations != null) {

annotationLists.add(recordComponent.invisibleAnnotations)

}

}

return annotationLists

}

static private int removeListedInvisibleAnnotations(ClassNode classNode, Set<String> annotationsToRemove) {

int removedAnnotationCount = 0

invisibleAnnotationLists(classNode).each { annotations ->

int originalSize = annotations.size()

annotations.removeAll { annotation -> annotationsToRemove.contains(annotation.desc) }

removedAnnotationCount += originalSize - annotations.size()

}

classNode.methods.each { method ->

if (method.invisibleParameterAnnotations == null) return

if (!method.invisibleParameterAnnotations.every { it == null || it.isEmpty() }) return

method.invisibleParameterAnnotations = null

method.invisibleAnnotableParameterCount = 0

}

return removedAnnotationCount

}

static private String classEntryForAnnotationDescriptor(String descriptor) {

if (!descriptor.startsWith('L') || !descriptor.endsWith(';')) {

throw new GradleException("Invalid annotation descriptor: ${descriptor}")

}

return descriptor.substring(1, descriptor.length() - 1) + '.class'

}

static private Map<String, Integer> rewriteClassFiles(File directory, Closure<Integer> rewriteClass) {

int modifiedClassCount = 0

int modificationCount = 0

directory.eachFileRecurse(groovy.io.FileType.FILES) { file ->

if (!file.name.endsWith('.class')) return

byte[] originalBytes = file.bytes

def reader = new ClassReader(originalBytes)

def classNode = new ClassNode()

reader.accept(classNode, 0)

int classModificationCount = rewriteClass.call(classNode)

if (classModificationCount == 0) return

def writer = new ClassWriter(reader, 0)

classNode.accept(writer)

file.bytes = writer.toByteArray()

modifiedClassCount++

modificationCount += classModificationCount

}

return [modifiedClassCount: modifiedClassCount, modificationCount: modificationCount]

}

def getDevelopmentVersion() {

def dateTime = new SimpleDateFormat('yyyy-MM-dd\'T\'HH-mm-ss').format(new Date())

def gitCheckOutput = new StringBuilder()

def gitCheckError = new StringBuilder()

def gitCheck = ["git", "-C", projectDir.toString(), "rev-parse", "--is-inside-work-tree"].execute()

gitCheck.waitForProcessOutput(gitCheckOutput, gitCheckError)

def isGit = gitCheckOutput.toString().trim()

if (isGit != "true") {

return makeDevelopmentVersion(["0.0.0", dateTime, "no-git"])

}

// a default Github Action env variable set to 'true'

def isCi = Boolean.parseBoolean(System.env.CI)

if (isCi) {

def gitHashOutput = new StringBuilder()

def gitHashError = new StringBuilder()

def gitShortHash = ["git", "-C", projectDir.toString(), "rev-parse", "--short", "HEAD"].execute()

gitShortHash.waitForProcessOutput(gitHashOutput, gitHashError)

def gitHash = gitHashOutput.toString().trim()

if (gitHash.isEmpty()) {

println "git hash is empty: error: ${gitHashError.toString()}"

throw new IllegalStateException("git hash could not be determined")

}

return makeDevelopmentVersion(["0.0.0", dateTime, gitHash])

}

def gitRevParseOutput = new StringBuilder()

def gitRevParseError = new StringBuilder()

def gitRevParse = ["git", "-C", projectDir.toString(), "rev-parse", "--abbrev-ref", "HEAD"].execute()

gitRevParse.waitForProcessOutput(gitRevParseOutput, gitRevParseError)

def branchName = gitRevParseOutput.toString().trim().replaceAll('[/\\\\]', '-')

return makeDevelopmentVersion(["0.0.0", branchName, "SNAPSHOT"])

}

def reactiveStreamsVersion = '1.0.3'

def releaseVersion = System.env.RELEASE_VERSION

def antlrVersion = '4.13.2' // https://mvnrepository.com/artifact/org.antlr/antlr4-runtime

def guavaVersion = '32.1.2-jre'

version = releaseVersion ? releaseVersion : getDevelopmentVersion()

group = 'com.graphql-java'

def plainJarDir = layout.buildDirectory.dir('intermediates/plain-jar')

def shadowJarDir = layout.buildDirectory.dir('intermediates/shadow-jar')

gradle.buildFinished { buildResult ->

println "*******************************"

println "*"

if (buildResult.failure != null) {

println "* FAILURE - ${buildResult.failure}"

} else {

println "* SUCCESS"

}

println "* Version: $version"

println "*"

println "*******************************"

}

repositories {

mavenCentral()

mavenLocal()

}

jar {

// The regular Java JAR is an input to the shading pipeline, not a

// publishable artifact. Keep it out of build/libs so it cannot be mistaken

// for the final GraphQL Java JAR.

archiveClassifier.set('plain')

destinationDirectory.set(plainJarDir)

from "LICENSE.md"

from "src/main/antlr/Graphql.g4"

from "src/main/antlr/GraphqlOperation.g4"

from "src/main/antlr/GraphqlSDL.g4"

from "src/main/antlr/GraphqlCommon.g4"

manifest {

attributes('Automatic-Module-Name': 'com.graphqljava')

}

}

shadow {

// GraphQL Java has additional post-processing after shadowJar. Do not let

// Shadow expose its intermediate artifact through the Java component or

// add it directly to assemble; buildFinalJar owns both responsibilities.

addShadowVariantIntoJavaComponent.set(false)

addShadowJarToAssembleLifecycle.set(false)

// The shadow runtime variant is disabled below because it would expose the

// uncleaned intermediate JAR. It therefore has no need for a target JVM

// attribute. Disabling this also prevents Shadow's afterEvaluate hook from

// trying to mutate that configuration after it has become non-consumable.

addTargetJvmVersionAttribute.set(false)

}

dependencies {

api 'com.graphql-java:java-dataloader:6.0.0'

api 'org.reactivestreams:reactive-streams:' + reactiveStreamsVersion

api "org.jspecify:jspecify:1.0.0"

implementation 'org.antlr:antlr4-runtime:' + antlrVersion

implementation 'com.google.guava:guava:' + guavaVersion

testImplementation 'org.junit.jupiter:junit-jupiter:5.14.3'

testImplementation 'org.spockframework:spock-core:2.4-groovy-5.0'

testImplementation 'net.bytebuddy:byte-buddy:1.18.8'

testImplementation 'org.objenesis:objenesis:3.5'

testImplementation 'org.apache.groovy:groovy:5.0.5'

testImplementation 'org.apache.groovy:groovy-json:5.0.5'

testImplementation 'com.google.code.gson:gson:2.13.2'

testImplementation 'org.eclipse.jetty:jetty-server:11.0.26'

testImplementation 'com.fasterxml.jackson.core:jackson-databind:2.21.1'

testImplementation 'org.awaitility:awaitility-groovy:4.3.0'

testImplementation 'com.github.javafaker:javafaker:1.0.2'

testImplementation 'org.reactivestreams:reactive-streams-tck:' + reactiveStreamsVersion

testImplementation "io.reactivex.rxjava2:rxjava:2.2.21"

testImplementation "io.projectreactor:reactor-core:3.8.4"

testImplementation 'org.testng:testng:7.12.0' // use for reactive streams test inheritance

testImplementation "com.tngtech.archunit:archunit-junit5:1.4.1"

testImplementation 'org.openjdk.jmh:jmh-core:1.37' // required for ArchUnit to check JMH tests

// JUnit Platform launcher required for Gradle 9

testRuntimeOnly 'org.junit.platform:junit-platform-launcher:1.14.3'

antlr 'org.antlr:antlr4:' + antlrVersion

// this is needed for the idea jmh plugin to work correctly

jmh 'org.openjdk.jmh:jmh-core:1.37'

jmh 'org.openjdk.jmh:jmh-generator-annprocess:1.37'

jmh 'me.bechberger:ap-loader-all:4.3-13'

// comment this in if you want to run JMH benchmarks from idea

errorprone 'com.uber.nullaway:nullaway:0.12.10'

errorprone 'com.google.errorprone:error_prone_core:2.48.0'

// just tests - no Kotlin otherwise

testImplementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'

}

shadowJar {

minimize()

// This is deliberately an intermediate artifact. The only unclassified

// binary JAR is produced by buildFinalJar after cleanup.

archiveClassifier.set('shadow')

destinationDirectory.set(shadowJarDir)

configurations = [project.configurations.compileClasspath]

relocate('com.google.common', 'graphql.com.google.common') {

include 'com.google.common.collect.*'

include 'com.google.common.base.*'

include 'com.google.common.math.*'

include 'com.google.common.primitives.*'

}

relocate('org.antlr.v4.runtime', 'graphql.org.antlr.v4.runtime')

dependencies {

include(dependency('com.google.guava:guava:' + guavaVersion))

include(dependency('org.antlr:antlr4-runtime:' + antlrVersion))

}

from "LICENSE.md"

from "src/main/antlr/Graphql.g4"

from "src/main/antlr/GraphqlOperation.g4"

from "src/main/antlr/GraphqlSDL.g4"

from "src/main/antlr/GraphqlCommon.g4"

manifest {

attributes('Automatic-Module-Name': 'com.graphqljava')

}

}

tasks.named('shadowJar').configure {

// Get the BundleTaskExtension added by bnd plugin

def bundle = extensions.findByType(BundleTaskExtension)

if (bundle != null) {

//Configure bnd for shadowJar

// -exportcontents: graphql.* Adds all packages of graphql and below to the exported packages list

// -removeheaders: Private-Package Removes the MANIFEST.MF header Private-Package, which contains all the internal packages and

// also the repackaged packages like guava, which would be wrong after repackaging.

// Import-Package: Changes the imported packages header, to exclude guava and dependencies from the import list (! excludes packages)

// Guava was repackaged and included inside the jar, so we need to remove it.

// ANTLR was shaded, so we need to remove it.

// sun.misc is a JRE internal-only class that is not directly used by graphql-java. It was causing problems in libraries using graphql-java.

// The last ,* copies all the existing imports from the other dependencies, which is required.

bundle.bnd('''

''')

}

}

tasks.named('jmhJar') {

duplicatesStrategy = DuplicatesStrategy.EXCLUDE

from {

project.configurations.jmhRuntimeClasspath

.filter { it.exists() }

.collect { it.isDirectory() ? it : zipTree(it) }

}

}

jcstress {

}

tasks.named('jcstress') {

javaLauncher = javaToolchains.launcherFor {

languageVersion = JavaLanguageVersion.of(25)

}

}

jmh {

if (project.hasProperty('jmhInclude')) {

includes = [project.property('jmhInclude')]

}

if (project.hasProperty('jmhProfilers')) {

def profStr = project.property('jmhProfilers') as String

if (profStr.startsWith('async')) {

// Resolve native lib from ap-loader JAR on the jmh classpath

def apJar = configurations.jmh.files.find { it.name.contains('ap-loader') }

if (apJar) {

def proc = ['java', '-jar', apJar.absolutePath, 'agentpath'].execute()

proc.waitFor(10, java.util.concurrent.TimeUnit.SECONDS)

def libPath = proc.text.trim()

if (libPath && new File(libPath).exists()) {

if (profStr == 'async') {

profilers = ["async:libPath=${libPath}"]

} else {

profilers = [profStr.replaceFirst('async:', "async:libPath=${libPath};")]

}

} else {

profilers = [profStr]

}

} else {

profilers = [profStr]

}

} else {

profilers = [profStr]

}

}

if (project.hasProperty('jmhFork')) {

fork = project.property('jmhFork') as int

}

if (project.hasProperty('jmhIterations')) {

iterations = project.property('jmhIterations') as int

}

if (project.hasProperty('jmhWarmupIterations')) {

warmupIterations = project.property('jmhWarmupIterations') as int

}

}

def extractedShadowJarDir = layout.buildDirectory.dir('intermediates/shadow-jar-extracted')

def annotationCleanedShadowJarDir = layout.buildDirectory.dir('intermediates/annotation-cleaned')

def annotationsToRemoveFromShadedJar = [

'Lcom/google/common/annotations/Beta;',

'Lcom/google/common/annotations/GwtCompatible;',

'Lcom/google/common/annotations/GwtIncompatible;',

'Lcom/google/common/annotations/J2ktIncompatible;',

'Lcom/google/common/annotations/VisibleForTesting;',

'Lcom/google/errorprone/annotations/CanIgnoreReturnValue;',

'Lcom/google/errorprone/annotations/CompatibleWith;',

'Lcom/google/errorprone/annotations/DoNotCall;',

'Lcom/google/errorprone/annotations/ForOverride;',

'Lcom/google/errorprone/annotations/InlineMe;',

'Lcom/google/errorprone/annotations/InlineMeValidationDisabled;',

'Lcom/google/errorprone/annotations/concurrent/GuardedBy;',

'Lcom/google/j2objc/annotations/RetainedWith;',

'Lcom/google/j2objc/annotations/Weak;',

'Ljavax/annotation/meta/TypeQualifierNickname;',

] as Set<String>

task extractWithoutGuava(type: Sync) {

description = 'Extract the shaded jar without unrelocated dependency classes'

from({ zipTree(tasks.named('shadowJar').get().archiveFile) }) {

exclude('/com/**')

}

into extractedShadowJarDir

}

extractWithoutGuava.dependsOn shadowJar

tasks.register('cleanShadedClassAnnotations', Sync) {

description = 'Remove selected invisible annotations from shaded class files'

dependsOn extractWithoutGuava

from extractedShadowJarDir

into annotationCleanedShadowJarDir

inputs.property('annotationsToRemove', annotationsToRemoveFromShadedJar.toList().sort())

doLast {

def outputDir = annotationCleanedShadowJarDir.get().asFile

def result = rewriteClassFiles(outputDir) { classNode ->

removeListedInvisibleAnnotations(classNode, annotationsToRemoveFromShadedJar)

}

logger.lifecycle("Removed ${result.modificationCount} invisible annotations; modified ${result.modifiedClassCount} shaded class files")

}

}

def buildFinalJar = tasks.register('buildFinalJar', Jar) {

group = 'build'

description = 'Build the published jar from cleaned shaded class files'

dependsOn cleanShadedClassAnnotations

from(annotationCleanedShadowJarDir) {

exclude 'META-INF/MANIFEST.MF'

}

archiveClassifier.set('')

destinationDirectory.set(layout.buildDirectory.dir('libs'))

manifest {

from annotationCleanedShadowJarDir.map { it.file("META-INF/MANIFEST.MF") }

}

}

assemble.dependsOn buildFinalJar

configurations.named('apiElements') {

outgoing.artifacts.clear()

outgoing.artifact(buildFinalJar)

}

configurations.named('runtimeElements') {

outgoing.artifacts.clear()

outgoing.artifact(buildFinalJar)

}

configurations.named('shadowRuntimeElements') {

canBeConsumed = false

}

def verifyShadedClassAnnotations = tasks.register('verifyShadedClassAnnotations') {

group = 'verification'

description = 'Verify invisible annotations are bundled or removed from the published jar'

dependsOn buildFinalJar

def shadedJar = buildFinalJar.flatMap { it.archiveFile }

inputs.file(shadedJar)

inputs.property('annotationsToRemove', annotationsToRemoveFromShadedJar.toList().sort())

doLast {

def annotationsThatShouldHaveBeenRemoved = []

def unresolvableAnnotations = []

boolean graphqlContractFound = false

new java.util.jar.JarFile(shadedJar.get().asFile).withCloseable { jarFile ->

jarFile.entries().each { entry ->

if (entry.directory || !entry.name.endsWith('.class')) return

byte[] classBytes = jarFile.getInputStream(entry).withCloseable { it.bytes }

def classNode = new ClassNode()

new ClassReader(classBytes).accept(classNode, 0)

invisibleAnnotationLists(classNode).each { annotations ->

annotations.each { annotation ->

if (annotationsToRemoveFromShadedJar.contains(annotation.desc)) {

annotationsThatShouldHaveBeenRemoved.add("${entry.name}: ${annotation.desc}")

} else {

def annotationClassEntry = classEntryForAnnotationDescriptor(annotation.desc)

if (jarFile.getJarEntry(annotationClassEntry) == null) {

unresolvableAnnotations.add("${entry.name}: ${annotation.desc}")

}

}

if (annotation.desc == 'Lgraphql/Contract;') {

graphqlContractFound = true

}

}

}

}

}

def verificationErrors = []

if (!annotationsThatShouldHaveBeenRemoved.isEmpty()) {

verificationErrors.add("Found annotations that should have been removed:\n${annotationsThatShouldHaveBeenRemoved.join('\n')}")

}

if (!unresolvableAnnotations.isEmpty()) {

verificationErrors.add("Found invisible annotations whose types are not bundled; add them to annotationsToRemoveFromShadedJar:\n${unresolvableAnnotations.join('\n')}")

}

if (!graphqlContractFound) {

verificationErrors.add('graphql.Contract was removed from the shaded jar')

}

if (!verificationErrors.isEmpty()) {

throw new GradleException(verificationErrors.join('\n\n'))

}

}

}

def compileShadedJarConsumer = tasks.register('compileShadedJarConsumer', JavaCompile) {

group = 'verification'

description = 'Compile a consumer against the shaded jar with class-file warnings treated as errors'

dependsOn buildFinalJar

source fileTree('src/test/compiler') {

include '**/*.java'

}

classpath = files(buildFinalJar.flatMap { it.archiveFile })

destinationDirectory = layout.buildDirectory.dir('classes/shaded-jar-consumer')

options.release = 11

options.compilerArgs.addAll(['-Xlint:classfile', '-Werror'])

}

check.dependsOn verifyShadedClassAnnotations, compileShadedJarConsumer

def buildExpectedTestngSkips() {

def pkg = 'graphql.execution.reactive.tck.'

def allClasses = [

'CompletionStageMappingOrderedPublisherTckVerificationTest',

'CompletionStageMappingOrderedPublisherRandomCompleteTckVerificationTest',

'CompletionStageMappingPublisherTckVerificationTest',

'CompletionStageMappingPublisherRandomCompleteTckVerificationTest',

'SingleSubscriberPublisherTckVerificationTest',

]

def multiSubscriberClasses = allClasses - ['SingleSubscriberPublisherTckVerificationTest']

// 8 methods skipped by all 5 classes (required_spec317 + 7 untested) = 40

def commonSkippedMethods = [

'required_spec317_mustNotSignalOnErrorWhenPendingAboveLongMaxValue',

'untested_spec106_mustConsiderSubscriptionCancelledAfterOnErrorOrOnCompleteHasBeenCalled',

'untested_spec107_mustNotEmitFurtherSignalsOnceOnErrorHasBeenSignalled',

'untested_spec108_possiblyCanceledSubscriptionShouldNotReceiveOnErrorOrOnCompleteSignals',

'untested_spec109_subscribeShouldNotThrowNonFatalThrowable',

'untested_spec110_rejectASubscriptionRequestIfTheSameSubscriberSubscribesTwice',

'untested_spec304_requestShouldNotPerformHeavyComputations',

'untested_spec305_cancelMustNotSynchronouslyPerformHeavyComputation',

]

// 1 method skipped by 4 multi-subscriber classes = 4

def multiSubscriberSkippedMethods = [

'stochastic_spec103_mustSignalOnMethodsSequentially',

]

// 5 methods skipped by SingleSubscriber only = 5

def singleSubscriberSkippedMethods = [

'optional_spec111_maySupportMultiSubscribe',

'optional_spec111_multicast_mustProduceTheSameElementsInTheSameSequenceToAllOfItsSubscribersWhenRequestingManyUpfront',

'optional_spec111_multicast_mustProduceTheSameElementsInTheSameSequenceToAllOfItsSubscribersWhenRequestingManyUpfrontAndCompleteAsExpected',

'optional_spec111_multicast_mustProduceTheSameElementsInTheSameSequenceToAllOfItsSubscribersWhenRequestingOneByOne',

'optional_spec111_registeredSubscribersMustReceiveOnNextOrOnCompleteSignals',

]

def expected = [] as Set<String>

allClasses.each { cls ->

commonSkippedMethods.each { method -> expected.add(pkg + cls + '.' + method) }

}

multiSubscriberClasses.each { cls ->

multiSubscriberSkippedMethods.each { method -> expected.add(pkg + cls + '.' + method) }

}

singleSubscriberSkippedMethods.each { method ->

expected.add(pkg + 'SingleSubscriberPublisherTckVerificationTest.' + method)

}

return expected // 40 + 4 + 5 = 49

}

def verifyTestngSkips(Task task, Set<String> expected) {

def xmlDir = task.reports.junitXml.outputLocation.asFile.get()

def actualSkips = [] as Set<String>

xmlDir.eachFileMatch(~/TEST-.*\.xml/) { file ->

def testsuite = new groovy.xml.XmlSlurper().parse(file)

testsuite.testcase.each { tc ->

if (tc.skipped.size() > 0) {

actualSkips.add(tc.@classname.toString() + '.' + tc.@name.toString())

}

}

}

def unexpected = actualSkips - expected

def missing = expected - actualSkips

if (unexpected || missing) {

def msg = new StringBuilder("TestNG TCK skip verification failed!\n")

if (unexpected) {

msg.append("\nUnexpected skips (tests that should pass but were skipped):\n")

unexpected.toSorted().each { msg.append(" + ${it}\n") }

}

if (missing) {

msg.append("\nMissing skips (tests that should be skipped but were not):\n")

missing.toSorted().each { msg.append(" - ${it}\n") }

}

msg.append("\nUpdate buildExpectedTestngSkips() in build.gradle if these changes are intentional.")

throw new GradleException(msg.toString())

}

logger.lifecycle("TestNG TCK skip verification passed: ${actualSkips.size()} skips match expected set.")

}

def expectedTestngSkips = buildExpectedTestngSkips()

task testng(type: Test) {

useTestNG()

testClassesDirs = sourceSets.test.output.classesDirs

classpath = sourceSets.test.runtimeClasspath

dependsOn tasks.named('testClasses')

doLast { verifyTestngSkips(it, expectedTestngSkips) }

}

compileJava {

options.compilerArgs += ["-parameters"]

source file("build/generated-src"), sourceSets.main.java

// Gradle 9 requires explicit task dependencies

mustRunAfter generateTestGrammarSource, generateJmhGrammarSource, generateJcstressGrammarSource

}

tasks.withType(GroovyCompile) {

// Options when compiling Java using the Groovy plugin.

// (Groovy itself defaults to UTF-8 for Groovy code)

options.encoding = 'UTF-8'

sourceCompatibility = '11'

targetCompatibility = '11'

groovyOptions.forkOptions.memoryMaximumSize = "4g"

}

tasks.withType(JavaCompile) {

options.release = 11

options.errorprone {

disableAllChecks = true

check("NullAway", CheckSeverity.ERROR)

//

// end state has us with this config turned on - eg all classes

//

//option("NullAway:AnnotatedPackages", "graphql")

option("NullAway:CustomContractAnnotations", "graphql.Contract")

option("NullAway:OnlyNullMarked", "true")

option("NullAway:JSpecifyMode", "true")

}

// Include to disable NullAway on test code

if (name.toLowerCase().contains("test") || name.toLowerCase().contains("jcstress")) {

options.errorprone {

disable("NullAway")

}

}

}

generateGrammarSource {

includes = ['Graphql.g4']

maxHeapSize = "64m"

arguments += ["-visitor"]

outputDirectory = file("${project.buildDir}/generated-src/antlr/main/graphql/parser/antlr")

}

generateGrammarSource.inputs

.dir('src/main/antlr')

.withPropertyName('sourceDir')

.withPathSensitivity(PathSensitivity.RELATIVE)

task sourcesJar(type: Jar) {

dependsOn classes

archiveClassifier = 'sources'

from sourceSets.main.allSource

}

task javadocJar(type: Jar, dependsOn: javadoc) {

archiveClassifier = 'javadoc'

from javadoc.destinationDir

}

javadoc {

options.encoding = 'UTF-8'

}

List<TestDescriptor> failedTests = []

Map<String, Integer> testsAndTime = [:]

Map<String, Integer> testClassesAndTime = [:]

int testCount = 0

long testTime = 0L

tasks.withType(Test) {

if (!name.startsWith('testng')) {

useJUnitPlatform()

}

maxHeapSize = "1g"

testLogging {

events "FAILED", "SKIPPED"

exceptionFormat = "FULL"

}

// Required for JMH ArchUnit tests

classpath += sourceSets.jmh.output

dependsOn "jmhClasses"

afterTest { TestDescriptor descriptor, TestResult result ->

testCount++

if (result.getFailedTestCount() > 0) {

failedTests.add(descriptor)

}

def ms = (int) (result.endTime - result.startTime)

testTime += ms

String className = descriptor.className ?: "unknown"

String name = className + "." + descriptor.displayName

if (ms > 500) {

testsAndTime[name] = ms

testClassesAndTime.compute(className) { k, v -> v == null ? ms : v + ms }

println "\tTest '$name' took ${ms}ms"

}

}

}

tasks.register('testWithJava21', Test) {

javaLauncher = javaToolchains.launcherFor {

languageVersion = JavaLanguageVersion.of(21)

}

testClassesDirs = sourceSets.test.output.classesDirs

classpath = sourceSets.test.runtimeClasspath

classpath += sourceSets.jmh.output

dependsOn "jmhClasses"

dependsOn tasks.named('testClasses')

}

tasks.register('testWithJava17', Test) {

javaLauncher = javaToolchains.launcherFor {

languageVersion = JavaLanguageVersion.of(17)

}

testClassesDirs = sourceSets.test.output.classesDirs

classpath = sourceSets.test.runtimeClasspath

classpath += sourceSets.jmh.output

dependsOn "jmhClasses"

dependsOn tasks.named('testClasses')

}

tasks.register('testWithJava11', Test) {

javaLauncher = javaToolchains.launcherFor {

languageVersion = JavaLanguageVersion.of(11)

}

testClassesDirs = sourceSets.test.output.classesDirs

classpath = sourceSets.test.runtimeClasspath

dependsOn tasks.named('testClasses')

classpath += sourceSets.jmh.output

dependsOn "jmhClasses"

}

['11', '17', '21'].each { ver ->

tasks.register("testngWithJava${ver}", Test) {

useTestNG()

javaLauncher = javaToolchains.launcherFor {

languageVersion = JavaLanguageVersion.of(ver)

}

testClassesDirs = sourceSets.test.output.classesDirs

classpath = sourceSets.test.runtimeClasspath

dependsOn tasks.named('testClasses')

doLast { verifyTestngSkips(it, expectedTestngSkips) }

}

}

jacoco {

toolVersion = "0.8.14"

}

jacocoTestReport {

dependsOn test

reports {

xml.required = true

html.required = true

csv.required = false

}

// Use the modified classes from classes-jacoco/ (with @Generated annotations)

// so CRC64 checksums match the execution data recorded during tests.

// Also exclude generated ANTLR code and shaded dependencies from coverage.

afterEvaluate {

classDirectories.setFrom(files(

fileTree(dir: layout.buildDirectory.dir('classes-jacoco/java/main'), exclude: [

'graphql/parser/antlr/**',

'graphql/com/google/**',

'graphql/org/antlr/**'

])

))

}

}

tasks.register('markGeneratedEqualsHashCode') {

description = 'Add @Generated annotation to equals/hashCode so JaCoCo ignores them'

dependsOn classes

def originalDir = layout.buildDirectory.dir('classes/java/main')

def jacocoDir = layout.buildDirectory.dir('classes-jacoco/java/main')

inputs.dir(originalDir)

inputs.property("generatedAnnotationTaskVersion", 2)

outputs.dir(jacocoDir)

doLast {

def src = originalDir.get().asFile

def dest = jacocoDir.get().asFile

project.delete(dest)

if (!src.exists()) return

// Copy all class files to a separate directory for JaCoCo

ant.copy(todir: dest) {

fileset(dir: src)

}

def ANNOTATION = 'Lgraphql/coverage/Generated;'

rewriteClassFiles(dest) { classNode ->

int addedAnnotationCount = 0

for (method in classNode.methods) {

if ((method.name == 'equals' && method.desc == '(Ljava/lang/Object;)Z') ||

(method.name == 'hashCode' && method.desc == '()I')) {

if (method.invisibleAnnotations == null) {

method.invisibleAnnotations = []

}

if (!method.invisibleAnnotations.any { it.desc == ANNOTATION }) {

method.invisibleAnnotations.add(new org.objectweb.asm.tree.AnnotationNode(ANNOTATION))

addedAnnotationCount++

}

}

}

return addedAnnotationCount

}

}

}

tasks.named('test') { dependsOn markGeneratedEqualsHashCode }

tasks.named('compileTestJava') { dependsOn markGeneratedEqualsHashCode }

tasks.named('test', Test) {

classpath = files(layout.buildDirectory.dir('classes-jacoco/java/main')) + classpath

}

gradle.buildFinished {

println "\n\n"

println "============================"

println "$testCount tests run in $testTime ms"

println "============================"

if (!failedTests.isEmpty()) {

println "\n\n"

println "============================"

println "These are the test failures"

println "============================"

for (td in failedTests) {

println "${td.getClassName()}.${td.getDisplayName()}"

}

println "============================"

}

// slowest tests

println "\n\n"

println "============================"

println "Top 20 slowest test classes"

println "============================"

showTestResults(testClassesAndTime,20) { e ->

println "\tTest class ${e.key} took ${e.value}ms"

}

println "\n\n"

println "============================"

println "Top 50 slowest tests"

println "============================"

showTestResults(testsAndTime,50) { e ->

println "\tTest ${e.key} took ${e.value}ms"

}

}

static private showTestResults(Map<String, Integer> testMap, int limit, Closure closure) {

testMap.entrySet().stream()

.sorted { e1, e2 -> e2.getValue() - e1.getValue() }

.limit(limit)

.forEach(closure)

}

allprojects {

tasks.withType(Javadoc) {

exclude('**/antlr/**')

}

}

publishing {

publications {

graphqlJava(MavenPublication) {

version = version

from components.java

artifact sourcesJar {

archiveClassifier = "sources"

}

artifact javadocJar {

archiveClassifier = "javadoc"

}

pom.withXml {

// Removing antlr4 below (introduced in `1ac98bf`) addresses an issue with

// the Gradle ANTLR plugin. `1ac98bf` can be reverted and this comment removed once