assertThrows(PACDecodingException.class, () -> new KerberosToken(wrongOidToken));
    }

    /**
     * Test constructor with a malformed Kerberos token (invalid inner structure).
     *
     * @throws IOException if an I/O error occurs
     */
    @Test
    void testConstructorWithMalformedKerberosToken() throws IOException {

    val body = newFixedLengthSource(response.request.url, contentLength)
    body.skipAll(Int.MAX_VALUE, MILLISECONDS)
    body.close()
  }

  /** An HTTP request body. */
  private inner class KnownLengthSink : Sink {
    private val timeout = ForwardingTimeout(socket.sink.timeout())
    private var closed: Boolean = false

    override fun timeout(): Timeout = timeout

    override fun write(

  }

  public void testConverter_nullConversions() {
    for (CaseFormat outer : CaseFormat.values()) {
      for (CaseFormat inner : CaseFormat.values()) {
        assertThat(outer.converterTo(inner).convert(null)).isNull();
        assertThat(outer.converterTo(inner).reverse().convert(null)).isNull();
      }
    }
  }

  public void testConverter_toString() {

        assertTrue(s.endsWith("]"), "expected suffix ] but got " + s);
        String inner = s.substring("SmbComLogoffAndX[".length(), s.length() - 1);
        assertFalse(inner.isEmpty(), "inner part of toString should not be empty");
    }

    @Test
    @DisplayName("constructor sets correct command value")
    void constructorSetsCorrectCommand() {

        CustomSmbTree inner = middle.unwrap(CustomSmbTree.class);

        assertNotNull(middle, "Middle tree should not be null");
        assertNotNull(inner, "Inner tree should not be null");
        assertSame(middleTree, middle, "Should return correct middle tree");
        assertSame(innerTree, inner, "Should return correct inner tree");
    }

    /**

 *
 * @author Kurt Alfred Kluever
 */
@NullUnmarked
public class SynchronizedDequeTest extends TestCase {

  protected Deque<String> create() {
    TestDeque<String> inner = new TestDeque<>();
    Deque<String> outer = Synchronized.deque(inner, inner.mutex);
    outer.add("foo"); // necessary because we try to remove elements later on
    return outer;
  }

  private static final class TestDeque<E> implements Deque<E> {

    private byte[] mechanismToken;

    private byte[] mechanismListMIC;

    /**
     * Gets the inner mechanism token wrapped in this SPNEGO token
     * @return the mechanism token bytes
     */
    public byte[] getMechanismToken() {
        return this.mechanismToken;
    }

    /**
     * Sets the inner mechanism token to be wrapped in this SPNEGO token
     * @param mechanismToken the mechanism token bytes
     */

 *
 * @author Kurt Alfred Kluever
 */
@NullUnmarked
public class SynchronizedDequeTest extends TestCase {

  protected Deque<String> create() {
    TestDeque<String> inner = new TestDeque<>();
    Deque<String> outer = Synchronized.deque(inner, inner.mutex);
    outer.add("foo"); // necessary because we try to remove elements later on
    return outer;
  }

  private static final class TestDeque<E> implements Deque<E> {

            HMACT64 hmac = new HMACT64(TEST_KEY);
            byte[] result = hmac.engineDigest();

            assertArrayEquals(finalDigest, result);
            verify(mockMd5, times(1)).digest(); // First call for inner digest
            verify(mockMd5, times(2)).update(any(byte[].class)); // Once in constructor with ipad, once in engineDigest with opad
            verify(mockMd5, times(1)).digest(innerDigest); // Second call for final digest

public class SynchronizedMapTest extends TestCase {
  public final Object mutex = new Object[0]; // something Serializable

  protected <K, V> Map<K, V> create() {
    TestMap<K, V> inner = new TestMap<>(new HashMap<K, V>(), mutex);
    Map<K, V> outer = Synchronized.map(inner, mutex);
    return outer;
  }

  static class TestMap<K, V> extends ForwardingMap<K, V> implements Serializable {
    public final Object mutex;