public void testRemoveIf_unsupportedEmptyCollection() {
    try {
      assertFalse(
          "removeIf(Predicate) should return false or throw UnsupportedOperationException",
          collection.removeIf(
              x -> {
                throw new AssertionError("predicate should never be called");
              }));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

        pkcs8Base64Text.decodeBase64()
          ?: throw IllegalArgumentException("failed to decode private key")

      // The private key doesn't tell us its type but it's okay because the certificate knows!
      val keyType =
        when (certificate.publicKey) {
          is ECPublicKey -> "EC"
          is RSAPublicKey -> "RSA"
          else -> throw IllegalArgumentException("unexpected key type: ${certificate.publicKey}")

    @Test
    void testFailureWithNoAlternativeChannels() throws Exception {
        failedChannel.addPendingOperation(mockOperation);

        when(mockLoadBalancer.selectChannel(mockOperation)).thenThrow(new ChannelLoadBalancer.NoAvailableChannelException("No channels"));

        IOException error = new IOException("Connection failed");

        // Should not throw exception even if no alternative channels

   *
   * <p>The default implementation throws {@code NoSuchElementException}.
   *
   * @return the minimum value of type {@code C}; never null
   * @throws NoSuchElementException if the type has no (practical) minimum value; for example,
   *     {@link java.math.BigInteger}
   */
  @CanIgnoreReturnValue
  public C minValue() {
    throw new NoSuchElementException();
  }

  /**

        void testSetResponseNull() {
            testRequest.setResponse(null);
            assertNull(testRequest.getResponse());
        }

        @Test
        @DisplayName("setResponse should throw exception for incompatible response")
        void testSetResponseIncompatible() {
            CommonServerMessageBlockResponse incompatibleResponse = mock(CommonServerMessageBlockResponse.class);

        keyManager.storeSessionKey("session", testKey, "AES");

        keyManager.close();
        keyManager.close(); // Should not throw

        assertEquals(0, keyManager.getKeyCount(), "Should have no keys after close");
    }

    @Test
    public void testAutoCloseable() throws Exception {
        try (SecureKeyManager manager = new SecureKeyManager()) {
            manager.storeSessionKey("auto-session", testKey, "AES");

    }

    public void test_hook_withNullAssistantDirector() {
        // When & Then - Should not throw exception
        try {
            curtainBeforeHook.hook(null);
        } catch (Exception e) {
            fail("Should not throw exception with null AssistantDirector");
        }
    }

    public void test_multipleHookCalls_maintainsSameTimeZone() {
        // Given

                }

                isEstablished = true;
                state++;
                break;
            } catch (final Exception e) {
                throw new SmbException(e.getMessage(), e);
            }
        default:
            throw new SmbException("Invalid state");
        }
        return token;
    }

                    return null;
                } while (dr != start);
                throw e;
            }
        } catch (final IOException ioe) {
            if (tf.getConfig().isDfsStrictView() && ioe instanceof SmbAuthException) {
                throw (SmbAuthException) ioe;
            }
        }
        return null;
    }

    /**

    val request =
      Request
        .Builder()
        .url("https://publicobject.com/robots.txt")
        .build()

    client.newCall(request).execute().use { response ->
      if (!response.isSuccessful) throw IOException("Unexpected code $response")

      for (certificate in response.handshake!!.peerCertificates) {
        println(CertificatePinner.pin(certificate))
      }
    }
  }
}

fun main() {