try {
            throw new DictionaryExpiredException();
        } catch (RuntimeException e) {
            assertNotNull(e);
            assertTrue(e instanceof DictionaryExpiredException);
        } catch (Exception e) {
            fail("Should have caught as RuntimeException");
        }
    }

    @Test
    public void test_serialization() throws Exception {

        else -> type
      }

  companion object {
    @Throws(IOException::class)
    @JvmStatic
    @JvmName("get")
    fun SSLSession.handshake(): Handshake {
      val cipherSuite =
        when (val cipherSuiteString = checkNotNull(cipherSuite) { "cipherSuite == null" }) {
          "TLS_NULL_WITH_NULL_NULL", "SSL_NULL_WITH_NULL_NULL" -> {
            throw IOException("cipherSuite == $cipherSuiteString")
          }

        assertProvideThrowsException("Test😀Classification");
    }

    // Helper method to assert that provide() throws ProvidedClassificationNotFoundException
    private void assertProvideThrowsException(String classificationName) {
        try {
            provider.provide(classificationName);
            fail("Should throw ProvidedClassificationNotFoundException for: " + classificationName);

 */
@GwtCompatible
@NullMarked
public class EvictingQueueTest extends TestCase {

  public void testCreateWithNegativeSize() throws Exception {
    assertThrows(IllegalArgumentException.class, () -> EvictingQueue.create(-1));
  }

  public void testCreateWithZeroSize() throws Exception {
    EvictingQueue<String> queue = EvictingQueue.create(0);
    assertEquals(0, queue.size());

    assertTrue(queue.add("hi"));

   * the first invocation of {@code hasNext} or {@code next} following each successful call to
   * {@code next}. Once the implementation either invokes {@code endOfData} or throws an exception,
   * {@code computeNext} is guaranteed to never be called again.
   *
   * <p>If this method throws an exception, it will propagate outward to the {@code hasNext} or
   * {@code next} invocation that invoked this method. Any further attempts to use the iterator will

        @Test
        @DisplayName("Should throw exception when encoding null UUID")
        void testPolicyHandleEncodeNullUuidThrowsException() {
            // Given: A policy handle with null UUID
            rpc.policy_handle policyHandle = new rpc.policy_handle();
            policyHandle.type = 123;
            policyHandle.uuid = null;

            // When/Then: Should throw NdrException

     * @param clientChallenge the client challenge bytes
     * @return the calculated response
     * @throws GeneralSecurityException if a cryptographic error occurs
     */
    public static byte[] getNTLM2Response(final byte[] passwordHash, final byte[] serverChallenge, final byte[] clientChallenge)
            throws GeneralSecurityException {
        final byte[] sessionHash = new byte[8];

            throws ArtifactResolutionException, ArtifactNotFoundException {
        if (Artifact.LATEST_VERSION.equals(artifact.getVersion())) {
            try {
                String version = resolveVersion(artifact, request);
                if (Artifact.LATEST_VERSION.equals(version)) {
                    throw new ArtifactNotFoundException("Unable to determine the latest version", artifact);

        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")