listener.transferInitiated(event(session, resource, TransferEvent.EventType.INITIATED));

        Thread.sleep(500); // to make sure queue is processed, cancellation applied

        // subsequent call will cancel
        assertThrows(
                TransferCancelledException.class,

    compileOnly(project(":internal-instrumentation-api"))
    compileOnly(libs.asm)
    compileOnly(libs.asmUtil)
    compileOnly(libs.asmTree)
    annotationProcessor(project(":internal-instrumentation-processor"))
    annotationProcessor(platform(project(":distributions-dependencies")))
}

tasks.named<JavaCompile>("compileJava") {
    // Without this, javac will complain about unclaimed org.gradle.api.NonNullApi annotation

    annotationProcessor(project(":internal-instrumentation-processor"))
    annotationProcessor(platform(project(":distributions-dependencies")))

    testInterceptorsImplementation(platform(project(":distributions-dependencies")))
    "testInterceptorsAnnotationProcessor"(project(":internal-instrumentation-processor"))
    "testInterceptorsAnnotationProcessor"(platform(project(":distributions-dependencies")))
}

}

description = "Collection of test fixtures for both unit tests and integration tests, internal use only"

sourceSets {
    main {
        // Incremental Groovy joint-compilation doesn't work with the Error Prone annotation processor
        errorprone.enabled = false
    }
}

dependencies {
    api(project(":base-services"))
    api(project(":concurrent"))
    api(project(":hashing"))
    api(project(":stdlib-java-extensions"))

        else -> KaConstantInitializerValue(evaluated, ktExpression)
    }
}

internal fun FirEqualityOperatorCall.processEqualsFunctions(
    session: FirSession,
    analysisSession: KaFirSession,
    processor: (FirNamedFunctionSymbol) -> Unit,
) {
    val lhs = arguments.firstOrNull() ?: return
    val scope = lhs.resolvedType.scope(
        useSiteSession = session,

		return
	}
	defer req.Body.Close()
	data, err := io.ReadAll(req.Body)
	if err != nil {
		log.Errorf("Failed to read log report from cni plugin: %v", err)
		return
	}
	l.processLog(data)
}

func (l *UDSLogger) processLog(body []byte) {
	cniLogs := make([]string, 0)
	err := json.Unmarshal(body, &cniLogs)
	if err != nil {
		log.Errorf("Failed to unmarshal CNI plugin logs: %v", err)
		return
	}

}

description = "Plugins for integration with native projects in XCode and Visual Studio IDEs"

sourceSets {
    main {
        // Incremental Groovy joint-compilation doesn't work with the Error Prone annotation processor
        errorprone.enabled = false
    }
}

dependencies {
    api(libs.groovy)
    api(libs.guava)
    api(libs.inject)
    api(libs.jsr305)
    api(libs.plist)
    api(project(":base-ide-plugins"))

}

description = "Collection of test fixtures for performance tests, internal use only"

sourceSets {
    main {
        // Incremental Groovy joint-compilation doesn't work with the Error Prone annotation processor
        errorprone.enabled = false
    }
}

val reports by configurations.creating
val flamegraph by configurations.creating
configurations.compileOnly { extendsFrom(flamegraph) }

repositories {

}

description = "Plugins and integration with code quality (Checkstyle, PMD, CodeNarc)"

sourceSets {
    main {
        // Incremental Groovy joint-compilation doesn't work with the Error Prone annotation processor
        errorprone.enabled = false
    }
}

dependencies {
    api(projects.stdlibJavaExtensions)
    api(project(":base-services"))
    api(project(":core"))
    api(project(":core-api"))

					"launcher",
					"time",
					"logging-api",
					"kotlin-dsl-plugins",
					"serialization",
					"toolchains-jvm-shared",
					"docs-asciidoctor-extensions-base",
					"internal-instrumentation-processor",
					"security",
					"input-tracking",
					"base-ide-plugins"
				]
			},
			{
				"parallelizationMethod":{
					"name":"TestDistribution"
				},
				"subprojects":[
					"testing-jvm",