```

## Development

### Build Commands
```bash
# Compile the source code
mvn compile

# Build JAR file
mvn package

# Clean and rebuild
mvn clean compile

# Install to local repository
mvn install
```

### Testing
```bash
# Run all tests (JUnit 4 based)
mvn test

# Run specific test class
mvn test -Dtest=SpecificTest

# Alternative test runner

        # By default, queries listed here will override any specified in a config file.
        # Prefix the list here with "+" to use these queries and those in the config file.
        # queries: ./path/to/local/query, your-org/your-repo/queries@main

    - name: Compile with Gradle with Build Scan
      if: ${{ matrix.language == 'java' && github.repository_owner == 'gradle' }}

      host
    }
  return if (includeDefaultPort || port != defaultPort(scheme)) {
    "$host:$port"
  } else {
    host
  }
}

/** Returns a [Locale.US] formatted [String]. */
internal fun format(
  format: String,
  vararg args: Any,
): String = String.format(Locale.US, format, *args)

/**
 * will also strip BOM from the source
 */
@Throws(IOException::class)

import org.apache.maven.api.annotations.NotThreadSafe;
import org.apache.maven.api.annotations.Nullable;

import static java.util.Objects.requireNonNull;

/**
 * A request for installing one or more artifacts in the local repository.
 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface ArtifactInstallerRequest extends Request<Session> {

    @Nonnull
    Collection<ProducedArtifact> getArtifacts();

import java.lang.annotation.Annotation;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;
import java.util.Locale;
import junit.framework.TestCase;

/**
 * Since annotations have some reusability issues that force copy and paste all over the place, it's

/**
 * Subset of the elemental2 IThenable interface without the single-parameter overload, which allows
 * us to implement it using a default implementation in J2cl ListenableFuture.
 */
@JsType(isNative = true, namespace = JsPackage.GLOBAL, name = "IThenable")
interface IThenable<T extends @Nullable Object> {
  <V extends @Nullable Object> IThenable<V> then(
      @JsOptional @Nullable IThenOnFulfilledCallbackFn<? super T, ? extends V> onFulfilled,

import jetbrains.buildServer.configs.kotlin.BuildSteps
import jetbrains.buildServer.configs.kotlin.buildSteps.script
import java.io.File
import java.util.LinkedList
import java.util.Locale

interface PerformanceTestBucketProvider {
    fun createPerformanceTestsFor(
        stage: Stage,
        performanceTestCoverage: PerformanceTestCoverage,
    ): List<PerformanceTest>
}

import static java.util.concurrent.Executors.defaultThreadFactory;
import static org.junit.Assert.assertThrows;

import com.google.common.testing.NullPointerTester;
import java.lang.Thread.UncaughtExceptionHandler;
import java.util.Locale;
import java.util.concurrent.ThreadFactory;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests for ThreadFactoryBuilder.
 *
 * @author Kurt Alfred Kluever

            }

            if ( versioning.getLastUpdated() == null || versioning.getLastUpdated().length() == 0 )
            {
                // this should only be for historical reasons - we assume local is newer
                versioning.setLastUpdated( v.getLastUpdated() );
            }

            if ( v.getLastUpdated() == null || v.getLastUpdated().length() == 0

            public void removeAttribute(String name) {
            }

            @Override
            public java.util.Locale getLocale() {
                return null;
            }

            @Override
            public java.util.Enumeration<java.util.Locale> getLocales() {
                return null;
            }

            @Override
            public boolean isSecure() {