b.io/okhttp/4.x/okhttp/okhttp3/-tls-version/) and [cipher suites](https://square.github.io/okhttp/4.x/okhttp/okhttp3/-cipher-suite/) to offer. A client that wants to maximize connectivity would include obsolete TLS versions and weak-by-design cipher suites. A strict client that wants to maximize security would be limited to only the latest TLS version and strongest cipher suites.

Specific security vs. connectivity decisions are implemented by [ConnectionSpec](https://square.github.io/ok...

     */
    @Test
    void testSuccessfulHandshake() throws IOException, SecurityException {
        // This test is simplified to verify basic handshake behavior
        // Full NTLM handshake testing would require more complex mocking

        // Arrange - Mock a server that supports NTLM
        mockResponse(HTTP_UNAUTHORIZED, "Unauthorized", Collections.singletonMap("WWW-Authenticate", Collections.singletonList("NTLM")),

     * replacement character.
     *
     * Implementation note: An alternative to the following would be to make a map that simply
     * replaces the allowed ASCII whitespace characters with themselves and to set the minimum safe
     * character to 0x20. However this would slow down the escaping of simple strings that contain
     * \t, \n, or \r.
     */

        }

        @Test
        public void testGetTypeForShare() throws Exception {
            SmbFile share = new SmbFile("smb1://server/share/");
            // To test this properly, we would need to mock connect0() and the tree object.
            // This is a limitation of unit testing such a coupled class.
            // We expect an SmbException because it will try to connect.

        this.loadLines()
        if (!options.noInit) this.init()
    }

    loadLines() {
        // Load all the lines and create the container so that the size is fixed
        // Otherwise it would be changing and the user viewport would be constantly
        // moving as she/he scrolls
        const finish = this.generateFinish()
        finish.style.visibility = 'hidden'
        this.container.appendChild(finish)

        for (int i = 0; i < length; i++) {
            switch (state) {
            case 0:
                if (in[i] != '/') {
                    // Checked exception (e.g. MalformedURLException) would be better
                    // but this would be a nightmare API wise
                    throw new RuntimeCIFSException("Invalid smb: URL: " + this.url);
                }
                out[prefixLen] = in[i];
                prefixLen++;

        return keyGenerator.getAndIncrement();
    }

    @Override
    protected long getBufferAddress(ByteBuffer buffer) {
        // Return a fake address for TCP
        // In real RDMA implementations, this would be the native memory address
        return buffer.hashCode();
    }

    }

    /**
     * Null pointer scenario – calls on a null reference should raise
     * {@link NullPointerException}. This test is defensive; in real code it
     * would likely be handled elsewhere.
     */
    @Test
    @DisplayName("calling getters on null reference throws NPE")
    void testNullReference() {
        AllocInfo nullRef = null;

     * field should be used for calculating that. This would likely be zero
     * but an implemantation that encorporates the transport header(for
     * efficiency) might use a different initial bufferIndex. For example,
     * to eliminate copying data when writing NbtSession data one might
     * manage that 4 byte header specifically and therefore the initial
     * bufferIndex, and thus headerStart, would be 4).(NOTE: If one where

    }

    /**
     * Validate buffer access bounds
     *
     * @param buffer the buffer
     * @param offset offset to access
     * @param length length to read
     * @throws SmbException if access would exceed bounds
     */
    public void validateBufferAccess(byte[] buffer, int offset, int length) throws SmbException {
        totalValidations.incrementAndGet();

        if (buffer == null) {