</div>
                            <div class="card-body">
                                <div>
                                    <la:info id="msg" message="true">
                                        <div class="alert alert-info">${msg}</div>
                                    </la:info>
                                    <la:errors property="_global"/>

        synchronized (BUF) {
            ServerMessageBlock smb = (ServerMessageBlock) request;
            final int n = smb.encode(BUF, 4);
            Encdec.enc_uint32be(n & 0xFFFF, BUF, 0); /* 4 byte session message header */
            if (LogStream.level >= 4) {
                do {
                    log.println(smb);

      // treats an incomplete response body as a ProtocolException.
    } catch (ioe: IOException) {
      // Change in https://bugs.openjdk.org/browse/JDK-8335135
      assertThat(ioe.message).isEqualTo("Premature EOF")
    }
  }

  private fun headersToList(response: MockResponse): List<String> {
    val headers = response.headers
    val size = headers.size

  private class ClosableCall : FailingCall() {
    private val response =
      Response
        .Builder()
        .request(Request("https://example.com/".toHttpUrl()))
        .protocol(Protocol.HTTP_1_1)
        .message("OK")
        .code(200)
        .body(
          object : ResponseBody() {
            override fun contentType() = null

            override fun contentLength() = -1L

      key = "has_space "
      cache.edit(key)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("keys must match regex [a-z0-9_-]{1,120}: \"$key\"")
    }
    assertFailsWith<IllegalArgumentException> {
      key = "has_CR\r"
      cache.edit(key)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("keys must match regex [a-z0-9_-]{1,120}: \"$key\"")
    }

import jcifs.internal.smb2.ServerMessageBlock2Request;
import jcifs.internal.smb2.Smb2Constants;
import jcifs.internal.util.SMBUtil;
import jcifs.util.Hexdump;

/**
 * SMB2 Close request message. This command is used to close a file or directory
 * that was previously opened.
 *
 * @author mbechler
 *
 */

  }

  private void readObject(ObjectInputStream stream) throws InvalidObjectException {
    throw new InvalidObjectException("Use SerializedForm");
  }

  /** Hasher that updates a message digest. */
  private static final class MessageDigestHasher extends AbstractByteHasher {
    private final MessageDigest digest;
    private final int bytes;
    private boolean done;

    assertFailsWith<IOException> {
      source.read(Buffer(), 1)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("stream closed")
    }
    assertFailsWith<IOException> {
      out.writeUtf8("a")
      out.flush()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("stream finished")
    }
    assertThat(connection.openStreamCount()).isEqualTo(0)

    /**
     * Do not instantiate.
     */
    protected ResultSetUtil() {
    }

    /**
     * Closes the result set.
     * <p>
     * If {@link ResultSet#close()} throws an exception, an error message is logged. The exception is not rethrown.
     * </p>
     *
     * @param resultSet
     *            The result set
     */
    public static void close(final ResultSet resultSet) {
        if (resultSet == null) {

 *       }
 *     });
 *   }
 *
 *   public void test() {
 *     SomeClass.foo();
 *     LogRecord firstRecord = handler.getStoredLogRecords().get(0);
 *     assertEquals("some message", firstRecord.getMessage());
 *   }
 * </pre>
 *
 * @author Kevin Bourrillion
 * @since 10.0
 */
@GwtCompatible
@NullMarked
public class TestLogHandler extends Handler {