abstract class PublishRelease(
    prepTask: String,
    promoteTask: String,
    requiredConfirmationCode: String,
    promotedBranch: String,
    init: PublishRelease.() -> Unit = {},
) : PublishGradleDistributionFullBuild(
        promotedBranch = promotedBranch,
        prepTask = prepTask,
        promoteTask = promoteTask,
        triggerName = "ReadyforRelease",

    taskFilter: (Task) -> Boolean,
    /* pass the collected information in build-logic and main build to Build Scan */
    buildScanAction: (gradleRootProject: Project, infoCollectedInBuildLogic: Any, infoCollectedInMainBuild: Any) -> Unit
) {
    val gradleRootProject = when {
        project.name == "gradle" -> project.rootProject
        project.rootProject.name == "build-logic" -> rootProject.gradle.parent?.rootProject

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertEquals;

/**
 * Unit tests for the Help goal.
 */
class HelpTest {

    private Help help;

    @BeforeEach
    void setUp() {
        help = new Help();
    }

    private UpgradeContext createMockContext() {

import java.util.concurrent.TimeUnit;
import org.jspecify.annotations.Nullable;

/**
 * A TimeLimiter implementation which actually does not attempt to limit time at all. This may be
 * desirable to use in some unit tests. More importantly, attempting to debug a call which is
 * time-limited would be extremely annoying, so this gives you a time-limiter you can easily swap in
 * for your real time-limiter while you're debugging.
 *

/**
 * Test Fixtures Plugin.
 *
 * Configures the Project as a test fixtures producer if `src/testFixtures` is a directory:
 * - adds a new `testFixtures` source set which should contain utilities/fixtures to assist in unit testing
 *   classes from the main source set,
 * - the test fixtures are automatically made available to the test classpath.
 *

import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.List;

import org.junit.jupiter.api.Test;

/**
 * Unit tests for RdmaProviderFactory
 */
public class RdmaProviderFactoryTest {

    @Test
    public void testCreateProviderAuto() {
        RdmaProvider provider = RdmaProviderFactory.createProvider("auto");

import java.io.IOException;

import org.bouncycastle.asn1.ASN1ObjectIdentifier;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

/**
 * Unit tests for {@link NegTokenTarg}. The class has no external
 * collaborators so tests are mostly focused on round‑trip
 * serialisation and invalid input handling.
 */
class NegTokenTargTest {

    @Test

     * The precision of this field is seconds; further precision will be truncated.
     */
    fun duration(
      duration: Long,
      unit: TimeUnit,
    ) = apply {
      val now = System.currentTimeMillis()
      validityInterval(now, now + unit.toMillis(duration))
    }

    /**
     * Adds a subject alternative name (SAN) to the certificate. This is usually a literal hostname,

```
# X.509 Certificate options
#
# DN options

# The organization of the subject.
organization = "Example Inc."

# The organizational unit of the subject.
#unit = "sleeping dept."

# The state of the certificate owner.
state = "Example"

# The country of the subject. Two letter code.
country = "EX"

# The common name of the certificate owner.

import org.codelibs.fess.opensearch.client.SearchEngineClient;
import org.codelibs.fess.util.ComponentUtil;
import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsResponse;
import org.opensearch.common.unit.TimeValue;

/**
 * Monitor target for tracking hot threads in the OpenSearch cluster.
 * This class extends MonitorTarget to provide monitoring functionality for