assertSideEffectFree(hash);
    assertReadableBytes(hash);
  }

  private static void assertSideEffectFree(HashCode hash) {
    byte[] original = hash.asBytes();
    byte[] mutated = hash.asBytes();
    mutated[0]++;
    assertThat(hash.asBytes()).isEqualTo(original);
  }

  private static void assertReadableBytes(HashCode hashCode) {
    assertThat(hashCode.bits()).isAtLeast(32); // sanity

     * @return accepted api changes reported upon, as a file
     */
    private static File getAcceptedApiChangesFile(RichReportData data) {
        def matcher = data.description =~ acceptedChangesRegex
        return new File(matcher[0][1])
    }

    private static RichReportData enrichReport(RichReportData data) {
        String currentApiChanges = getAcceptedApiChangesFile(data).text

 * SmbPipeHandle contract is tested for correctness.
 */
public class SmbPipeHandleTest {

    private SmbPipeHandle smbPipeHandle;
    private SmbPipeResource mockPipeResource;
    private SmbPipeHandleInternal mockSmbPipeHandleInternal;
    private InputStream mockInputStream;
    private OutputStream mockOutputStream;

    /**
     * Sets up the test environment before each test.

        }

        private static class DefaultSettingsBuilderRequest extends BaseRequest<ProtoSession>
                implements SettingsBuilderRequest {
            private final Source installationSettingsSource;
            private final Source projectSettingsSource;
            private final Source userSettingsSource;
            private final UnaryOperator<String> interpolationSource;

 * @see Clock
 */
public class MonotonicClock extends Clock {
    private static final MonotonicClock CLOCK = new MonotonicClock();

    private final long startNanos;
    private final Instant startInstant;

    /**
     * Private constructor to enforce singleton pattern.
     * Initializes the clock with the current system time and nanoTime.
     */
    private MonotonicClock() {
        this.startNanos = System.nanoTime();

@Deprecated
public final class CLIReportingUtils {
    // CHECKSTYLE_OFF: MagicNumber
    public static final long MB = 1024 * 1024;

    private static final long ONE_SECOND = 1000L;

    private static final long ONE_MINUTE = 60 * ONE_SECOND;

    private static final long ONE_HOUR = 60 * ONE_MINUTE;

    private static final long ONE_DAY = 24 * ONE_HOUR;
    // CHECKSTYLE_ON: MagicNumber

     * rely on the class node analysis since it doesn't give the right superclass because
     * resolution is not complete when this visitor is executed.
     */
    private
    fun isIntegrationTest(current: ClassNode) = current.name.endsWith("Test")
        || current.name.endsWith("Spec")

    override fun shouldVisitMethod(node: MethodNode): Boolean = isIntegrationTest(node.declaringClass)

import org.apache.maven.api.Project;
import org.apache.maven.api.Session;
import org.apache.maven.execution.ExecutionEvent;

public class DefaultEvent implements Event {
    private final InternalMavenSession session;
    private final ExecutionEvent delegate;
    private final EventType eventType;

    public DefaultEvent(InternalMavenSession session, ExecutionEvent delegate, EventType eventType) {
        this.session = session;

 * to become available when attempting to connect to a busy pipe.
 *
 * @author mbechler
 */
public class FsctlPipeWaitRequest implements Encodable {

    private final byte[] nameBytes;
    private final long timeout;
    private final boolean timeoutSpecified;

    /**
     * Constructs a pipe wait request without timeout.
     *
     * @param name the pipe name to wait for
     */

   * much faster to initialize than [BasicTrustRootIndex] because it doesn't need to load and
   * index trusted CA certificates.
   */
  internal data class CustomTrustRootIndex(
    private val trustManager: X509TrustManager,
    private val findByIssuerAndSignatureMethod: Method,
  ) : TrustRootIndex {
    override fun findByIssuerAndSignature(cert: X509Certificate): X509Certificate? =
      try {
        val trustAnchor =