DEROctetString encOctets = ASN1Util.as(DEROctetString.class, ASN1Util.as(ASN1TaggedObject.class, encSequence, 2));
                byte[] crypt = encOctets.getOctets();

                if (keys == null) {
                    try {
                        keys = new KerberosCredentials().getKeys();
                    } catch (LoginException e) {
                        throw new PACDecodingException("Login failure", e);

public class Handler extends URLStreamHandler {

    public static final String PROTOCOL_TYPE = "test";

    @Override
    protected URLConnection openConnection(URL u) throws IOException {
        return null;
    }

    protected int maxReadWriteSize;

    /**
     * Create new RDMA connection
     *
     * @param remote remote socket address
     * @param local local socket address, may be null
     */
    public RdmaConnection(InetSocketAddress remote, InetSocketAddress local) {
        this.remoteAddress = remote;
        this.localAddress = local;
        this.sendCredits = new AtomicInteger(0);

        assertSame(session, result);
        verify(handle).getSession();
    }

    @Test
    @DisplayName("getSession(): may return null and should be observed as such")
    void getSession_returnsNull() {
        // Arrange
        when(handle.getSession()).thenReturn(null);

        // Act
        SmbSession result = handle.getSession();

        // Assert
        assertNull(result);

        response.useUnicode = false;
        String expected = "test";
        // Simulate OEM encoding with a null terminator
        byte[] src = (expected + "\0").getBytes(StandardCharsets.UTF_8);
        String result = response.readString(src, 0, src.length);
        // The method should remove the null terminator
        assertEquals(expected, result.substring(0, expected.length()));
    }

    @Test

        // Second close should not throw
        assertDoesNotThrow(managed::close);
    }

    @Test
    @DisplayName("Test null resource registration throws exception")
    void testNullResourceRegistration() {
        assertThrows(IllegalArgumentException.class, () -> resourceManager.registerResource(null));
    }

    @Test
    @DisplayName("Test configuration updates")
    void testConfigurationUpdates() {

    enableProtocol(Protocol.HTTP_2)
    val credential = basic("jesse", "secret")
    client =
      client
        .newBuilder()
        .authenticator(RecordingOkAuthenticator(credential, null))
        .build()
    val body1 =
      MockSocketHandler()
        .sendResponse("please authenticate!\n")
        .requestIOException()
        .exhaustResponse()
    server.enqueue(
      MockResponse

    }

    /**
     * Returns true if the item has been updated.
     *
     * @return True if the item has been updated.
     */
    public boolean isUpdated() {
        return newToken != null;
    }

    /**
     * Returns true if the item has been deleted.
     *
     * @return True if the item has been deleted.
     */
    public boolean isDeleted() {

 * full queue, the queue automatically removes its head element. This is different from conventional
 * bounded queues, which either block or reject new elements when full.
 *
 * <p>This class is not thread-safe, and does not accept null elements.
 *
 * @author Kurt Alfred Kluever
 * @since 15.0
 */
@GwtCompatible
public final class EvictingQueue<E> extends ForwardingQueue<E> implements Serializable {

  private final Queue<E> delegate;

        assertThrows(IllegalArgumentException.class, () -> {
            DialectVersion.valueOf("INVALID");
        });

        // Test valueOf with null
        assertThrows(NullPointerException.class, () -> {
            DialectVersion.valueOf(null);
        });
    }

    @Test
    @DisplayName("Should maintain SMB2 flag consistency")
    void testSMB2FlagConsistency() {