alias("generate-test-sources", TEST_SOURCES),
                    alias("process-test-sources", AFTER + TEST_SOURCES),
                    alias("generate-test-resources", TEST_RESOURCES),
                    alias("process-test-resources", AFTER + TEST_RESOURCES),
                    alias("process-test-classes", AFTER + TEST_COMPILE),

    @Test
    @DisplayName("connectLogon invokes underlying implementation")
    void connectLogon_invocation_isForwarded() throws Exception {
        // Act
        tree.connectLogon(context);

        // Assert - verify interaction with dependency
        verify(tree, times(1)).connectLogon(context);
        verify(tree, never()).close();
    }

    @Test

    protected ArtifactRepository badLocalRepository() throws Exception {
        String path = "target/test-repositories/" + component() + "/bad-local-repository";

        File f = new File(getBasedir(), path);

        f.createNewFile();

        return artifactRepositoryFactory.createArtifactRepository(
                "test", "file://" + f.getPath(), repoLayout, null, null);
    }

    protected String getRepositoryLayout() {

import java.util.concurrent.TimeUnit
import kotlin.test.assertFailsWith
import kotlin.time.Duration.Companion.seconds
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.TimeoutCancellationException
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.job
import kotlinx.coroutines.supervisorScope
import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.withContext

    }

    @Test
    void testRegistrationIdUniqueness() throws Exception {
        WitnessRegistration registration2 =
                new WitnessRegistration("\\\\server\\share2", InetAddress.getByName("192.168.1.101"), WitnessServiceType.CLUSTER_WITNESS);

        assertNotEquals(registration.getRegistrationId(), registration2.getRegistrationId());
    }

    @Test
    void testFlagsModification() {

    // Happy path: transport is returned and verified
    @Test
    @DisplayName("getTransport returns mocked transport")
    void getTransport_happy() {
        when(session.getTransport()).thenReturn(transport);
        assertSame(transport, session.getTransport());
        verify(session).getTransport();
    }

    // Happy path: connect to logon share completes without exception
    @Test

}

tasks.withType<Test>().configureEach {
  environment("OKHTTP_ROOT", rootDir)
}

plugins.withId("org.jetbrains.kotlin.jvm") {
  val test = tasks.named("test")
  tasks.register("jvmTest") {
    description = "Get 'gradlew jvmTest' to run the tests of JVM-only modules"
    dependsOn(test)
  }

  }

  /*
   * TODO: b/318391980 - Once we test only under Java 20 and higher, avoid calling Thread.stop. As
   * of Java 20, it always throws an exception, and as of Java 26, the method does not even exist.
   * For now, we continue using it to clean up under older JDKs.
   *
   * Our usages should at least be *relatively* safe: Typically, threads started by a test are dying

 */

package gradlebuild.binarycompatibility

import org.junit.Test

class JSpecifyNullUnmarkedChangesTest : AbstractBinaryCompatibilityTest() {

    private val nullableAnnotationName = "org.jspecify.annotations.Nullable"
    private val nullUnmarkedAnnotationName = "org.jspecify.annotations.NullUnmarked"

    @Test
    fun `from non-null returning to null-unmarked returning is breaking`() {

import com.google.common.collect.testing.google.TestStringMultisetGenerator;
import java.util.ArrayList;
import java.util.List;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.jspecify.annotations.NullMarked;

/**
 * Unit test for {@link LinkedHashMultiset}.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@NullMarked