}

  private fun logWithTime(message: String) {
    val startNs = startNs
    val timeMs =
      if (startNs == null) {
        // Event occurred before start, for an example an early cancel.
        0L
      } else {
        TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs)
      }

    logger.invoke("[$timeMs ms] $message")
  }

     * @param level The logging level, never {@code null}.
     * @param message The logging message, never {@code null}.
     * @param error The error, if applicable.
     */
    record Entry(@Nonnull Level level, @Nonnull String message, @Nullable Throwable error) {}

    /**
     * If this is an accumulating log, it will "drain" this instance. It returns the accumulated log entries, and

    timeout: Int = 90,
    maxParallelForks: String = "%maxParallelForks%",
    extraSteps: BuildSteps.() -> Unit = {}, // the steps after runner steps
    preSteps: BuildSteps.() -> Unit = {}, // the steps before runner steps
) {
    buildType.applyDefaultSettings(os, timeout = timeout, buildJvm = buildJvm, arch = arch)

    buildType.steps {
        preSteps()
    }

import java.security.cert.Certificate
import java.security.cert.X509Certificate
import javax.net.ssl.SSLPeerUnverifiedException
import javax.net.ssl.SSLSession
import okhttp3.internal.toImmutableList

/**
 * A record of a TLS handshake. For HTTPS clients, the client is *local* and the remote server is
 * its *peer*.
 *
 * This value object describes a completed handshake. Use [ConnectionSpec] to set policy for new
 * handshakes.
 */

   * {@code C}:
   *
   * <ul>
   *   <li>If {@code C} explicitly implements {@link Object#equals}, the deserialized instance will
   *       be checked to be equal to the instance before serialization.
   *   <li>If {@code C} doesn't explicitly implement {@code equals} but instead inherits it from a
   *       superclass, no equality check is done on the deserialized instance because it's not clear

///

### Editor support { #editor-support }

All the framework was designed to be easy and intuitive to use, all the decisions were tested on multiple editors even before starting development, to ensure the best development experience.

        return webAuthenticationBhv.selectByPK(id);
    }

    /**
     * Stores a web authentication configuration.
     * Parameters are encrypted before storage.
     *
     * @param webAuthentication The web authentication configuration to store
     */
    public void store(final WebAuthentication webAuthentication) {

  /**
   * Records the provided object in {@link #methodArgument} and sets {@link #methodCalled}. This
   * method is called reflectively by Subscriber during tests, and must remain public.
   *
   * @param arg argument to record.
   */
  @Subscribe
  public void recordingMethod(Object arg) {
    assertFalse(methodCalled);
    methodCalled = true;
    methodArgument = arg;
  }

  @Subscribe

class SmbFileHandleTest {

    @Mock
    private SmbFileHandle smbFileHandle;

    @Mock
    private SmbTreeHandle smbTreeHandle;

    @BeforeEach
    void setUp() throws CIFSException {
        // Reset mock before each test if necessary, though MockitoExtension does this.
    }

    /**
     * Test that getTree() returns the correct SmbTreeHandle.
     */
    @Test
    void testGetTree() {

        for (int i = 0; i < expected.length; i++) {
            final int idx = i;
            assertEquals(expected[i], dst[offset + i], () -> "byte index " + idx);
        }
        // The region before offset and after the payload must remain untouched.
        for (int i = 0; i < offset; i++) {
            final int idx = i;
            assertEquals(0, dst[i], () -> "pre-offset byte " + idx + " modified");
        }