CL 582097 - an x/build CL working on relnote itself; it doesn't need a release note
CL 561935 - crypto CL that used purego tag and mentioned accepted-but-not-implemented proposal https://go.dev/issue/23172 to document purego tag; doesn't need a release note
CL 568340 - fixed a spurious race in time.Ticker.Reset (added via accepted proposal https://go.dev/issue/33184), doesn't seem to need a release note

dependencies {
    // All dependencies should be compileOnly, since this project is added also to worker classpath, so we don't pollute it.
    // If we need some dependency also at runtime we need to build a separate classpath and add it to :launcher project or :distributions-core project directly.
    compileOnly(project(":core"))
    compileOnly(projects.stdlibJavaExtensions)

 *
 * #### Implementation Notes
 *
 * Analysis API platforms need to take care of publishing modification topics via the [analysisMessageBus]. In general, if your platform
 * works with static code and static module structure, you do not need to publish any events. However, keep in mind the contracts of the

 */

package org.jetbrains.kotlin.analysis.api.platform

/**
 * An **engine service** as defined by the Platform Interface (see the README).
 *
 * Engine services do not need to be implemented by a platform. Quite the contrary, they are implemented by the Analysis API engine and
 * intended to support platform implementations. They are defined in the Platform Interface, as opposed to the user-facing Analysis API,

    implementation(libs.commonsLang)
    implementation(libs.maven3SettingsBuilder)
    implementation(libs.maven3Model)
    implementation(libs.slf4jApi)
    implementation(libs.plexusUtils)

    // We need to handle the Maven dependencies specially otherwise it breaks some cross version tests
    // TODO Figure out why and fix it - Move the two deps below to implementation and api and run ProjectTheExtensionCrossVersionSpec

		w := uint32(state)
		if v == 0 {
			// Counter is 0, no need to wait.
			if race.Enabled {
				race.Enable()
				race.Acquire(unsafe.Pointer(wg))
			}
			return
		}
		// Increment waiters count.
		if wg.state.CompareAndSwap(state, state+1) {
			if race.Enabled && w == 0 {
				// Wait must be synchronized with the first Add.
				// Need to model this is as a write to race with the read in Add.

		// We have no good way to distinguish between these two cases from here. But we don't need to!
		// Existing pods will be handled by the dataplane using `GetAmbientPods`,
		// and the initial enqueueNamespace, and new pods will be handled by the CNI.

	case controllers.EventUpdate:
		// For update, we just need to handle opt outs
		newPod := event.New.(*corev1.Pod)
		oldPod := event.Old.(*corev1.Pod)

}

gradlebuildJava.usedInWorkers()

description = """JVM-specific test infrastructure, including support for bootstrapping and configuring test workers
and executing tests.
Few projects should need to depend on this module directly. Most external interactions with this module are through the
various implementations of WorkerTestClassProcessorFactory.
"""

dependencies {
    api(projects.stdlibJavaExtensions)

  // TODO(b/165919229): This code will need changing if/when we port to a
  // big-endian platform.
  memcpy(*buffer, &num_strings, sizeof(int32_t));

  // Set offset of strings.
  int32_t start = sizeof(int32_t) * (num_strings + 2);
  for (size_t i = 0; i < offset_.size(); i++) {
    // TODO(b/165919229): This code will need changing if/when we port to a
    // big-endian platform.

gradlebuildJava.usedInWorkers()

dependencies {

    api(projects.stdlibJavaExtensions)

    implementation(project(":files")) {
        because("We need org.gradle.internal.file.PathTraversalChecker")
    }

    testImplementation(project(":base-services"))
    testImplementation(project(":core-api"))
    testImplementation(project(":native"))