// Assert throwing/catching behavior with assertThrows
        SMBProtocolDecodingException thrown = assertThrows(SMBProtocolDecodingException.class, () -> {
            throw new SMBProtocolDecodingException();
        }, "Should be throwable via assertThrows");
        assertTrue(thrown instanceof CIFSException, "Thrown instance should also be CIFSException subtype");
    }

    @ParameterizedTest
    @NullAndEmptySource

     * @param bufferIndex the starting offset in the buffer
     * @param len the length of data to decode
     * @throws IOException if an I/O error occurs during decoding
     */
    public SecurityDescriptor(final byte[] buffer, final int bufferIndex, final int len) throws IOException {
        this.decode(buffer, bufferIndex, len);
    }

    /**
     * Decodes a security descriptor from a byte buffer.
     *

@Deprecated
public class JdkPrefixProfileActivator extends DetectedProfileActivator {
    private static final String JDK_VERSION = System.getProperty("java.version");

    @Override
    public boolean isActive(Profile profile) throws ProfileActivationException {
        Activation activation = profile.getActivation();

        String jdk = activation.getJdk();

   *
   * <p>This bug is this: if you create an iterator from a TreeSet and call next() on that iterator
   * when hasNext() is false, so that next() throws a NoSuchElementException, then subsequent calls
   * to remove() will incorrectly throw an IllegalStateException, instead of removing the last
   * element returned.
   *
   * <p>See <a href="https://bugs.openjdk.org/browse/JDK-6529795">JDK-6529795</a>
   */

     */
    public FormScheme(final Map<String, String> parameterMap) {
        this.parameterMap = parameterMap;
    }

    @Override
    public void processChallenge(final Header header) throws MalformedChallengeException {
        // no-op
    }

    @Override
    public String getSchemeName() {
        return "form";
    }

    @Override

        int i = 0, n;

        while (i < len) {
            n = in.read(b, off + i, len - i);
            if (n <= 0) {
                break;
            }
            i += n;
        }

        return i;
    }

    static int readPacketType(final InputStream in, final byte[] buffer, final int bufferIndex) throws IOException {

    void testReadParameterWordsWithShortBuffer() {
        byte[] buffer = new byte[] { 0x00, 0x01, 0x02 }; // only three bytes
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> response.readParameterWordsWireFormat(buffer, 0));
    }

    @Test
    @DisplayName("readParameterWordsWireFormat with null buffer - throws NullPointerException")

            .findVirtual(clazz, "update", MethodType.methodType(void.class, ByteBuffer.class));
      } catch (ClassNotFoundException e) {
        throw new AssertionError(e);
      } catch (IllegalAccessException e) {
        // That API is public.
        throw newLinkageError(e);
      } catch (NoSuchMethodException e) {
        // Only introduced in Java 9.
        return null;
      }
    }

            assertEquals("Array element at index " + i + " differs", expected[i], actual[i]);
        }
    }

    @Override
    public void setUp() throws Exception {
        super.setUp();
        crawlJob = new CrawlJob();
    }

    @Override
    public void tearDown() throws Exception {
        super.tearDown();
    }

    // Test constructor and field initialization
    public void test_constructor() {

  override fun writeTo(sink: BufferedSink) {
    requestBodySinks.add(sink)
  }

  override fun isDuplex(): Boolean = true

  @Throws(InterruptedException::class)
  fun takeSink(): BufferedSink = requestBodySinks.poll(5, SECONDS) ?: throw AssertionError("no sink to take")

  fun assertNoMoreSinks() {
    assertTrue(requestBodySinks.isEmpty())
  }