* Creates a new session service packet instance.
     */
    public SessionServicePacket() {
        // Default constructor
    }

    // session service packet types
    static final int SESSION_MESSAGE = 0x00;
    static final int SESSION_REQUEST = 0x81;
    /**
     * NetBIOS positive session response packet type.
     */
    public static final int POSITIVE_SESSION_RESPONSE = 0x82;

      serverSocketChannel.configureBlocking(true);
      serverSocketChannel.socket().bind(address);
    }

    @Override public int getLocalPort() {
      return 1; // A white lie. There is no local port.
    }

    @Override public SocketAddress getLocalSocketAddress() {
      return endpoint;
    }

    @Override public Socket accept() throws IOException {
      try {

        assertThrows(IOException.class, () -> sis.read());
    }

    @Test
    @DisplayName("Unknown packet type is handled by continuing to next packet")
    void unknownPacketTypeHandled() throws IOException {
        // According to the SocketInputStream implementation, unknown packet types
        // are handled in the switch statement's default case which continues the loop
        byte[] data = new byte[] { 1, 2 };

  ): RealConnection {
    val result =
      RealConnection.newTestConnection(
        taskRunner = taskRunner,
        connectionPool = pool,
        route = route,
        socket = Socket(),
        idleAtNs = idleAtNanos,
      )
    result.withLock { pool.put(result) }
    return result
  }

  fun newConnectionPool(
    taskRunner: TaskRunner = this.taskRunner,

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.connection

import java.net.Socket as JavaNetSocket
import okio.BufferedSink
import okio.BufferedSource
import okio.Socket as OkioSocket
import okio.asOkioSocket
import okio.buffer

interface BufferedSocket : OkioSocket {
  override val source: BufferedSource
  override val sink: BufferedSink

            new KerberosRelevantAuthData(malformedToken, keys);
        }, "A PACDecodingException should be thrown for a malformed token.");

        assertEquals("Malformed kerberos ticket", exception.getMessage(), "The exception message should indicate a malformed ticket.");
    }

    /**
     * Test constructor with an empty token.
     * Empty token causes readObject() to return null, which leads to NullPointerException.
     */

    result = 31 * result + proxy.hashCode()
    result = 31 * result + socketAddress.hashCode()
    return result
  }

  /**
   * Returns a string with the URL hostname, socket IP address, and socket port, like one of these:
   *
   *  * `example.com:80 at 1.2.3.4:8888`
   *  * `example.com:443 via proxy [::1]:8888`
   *
   * This omits duplicate information when possible.
   */

    } else {
      eventListener.callEnd(this)
    }
    return result
  }

  /**
   * Remove this call from the connection's list of allocations. Returns a socket that the caller
   * should close.
   */
  internal fun releaseConnectionNoEvents(): Socket? {
    val connection = this.connection!!
    connection.assertLockHeld()

    val calls = connection.calls

 */

package jcifs.smb1.netbios;

import java.io.IOException;
import java.io.InputStream;

/**
 * NetBIOS session request packet for establishing sessions.
 * This packet is sent to request a NetBIOS session with a remote host.
 */
public class SessionRequestPacket extends SessionServicePacket {

    private final Name calledName, callingName;

fs.s3a.max.total.tasks=2048 # Maximum number of parallel tasks
fs.s3a.multipart.size=512M # Size of each multipart chunk
fs.s3a.multipart.threshold=512M # Size before using multipart uploads
fs.s3a.socket.recv.buffer=65536 # Read socket buffer hint
fs.s3a.socket.send.buffer=65536 # Write socket buffer hint
fs.s3a.threads.max=2048 # Maximum number of threads for S3A
```

The rest of the other optimization options are discussed in the links below