public void test_throwAndCatchWithCause() {
        // Test throwing and catching the exception with cause
        String expectedMessage = "SAML assertion validation failed";
        Exception expectedCause = new IllegalStateException("Invalid SAML response");

        try {
            throw new SsoProcessException(expectedMessage, expectedCause);
        } catch (SsoProcessException e) {

  }

  public void testBase64CannotUpperCase() {
    assertThrows(IllegalStateException.class, () -> base64().upperCase());
  }

  public void testBase64CannotLowerCase() {
    assertThrows(IllegalStateException.class, () -> base64().lowerCase());
  }

  public void testBase64CannotIgnoreCase() {
    assertThrows(IllegalStateException.class, () -> base64().ignoreCase());
  }

    ByteSource checker =
        new ByteSource() {
          @Override
          public InputStream openStream() throws IOException {
            if (counter[0]++ != 0) {
              throw new IllegalStateException("More than one source open");
            }
            return new FilterInputStream(source.openStream()) {
              @Override
              public void close() throws IOException {
                super.close();

            return null;
        }

        @Override
        public AsyncContext startAsync() throws IllegalStateException {
            return null;
        }

        @Override
        public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException {
            return null;
        }

        @Override
        public boolean isAsyncStarted() {

 *
 * <p><b>Warning:</b> The caller is responsible for not attempting to read past the end of the
 * array. If any method encounters the end of the array prematurely, it throws {@link
 * IllegalStateException} to signify <i>programmer error</i>. This behavior is a technical violation
 * of the supertype's contract, which specifies a checked exception.
 *
 * @author Kevin Bourrillion
 * @since 1.0
 */
@J2ktIncompatible

  @Test
  fun firstConnectionCrashesWithUncheckedException() {
    val plan0 = routePlanner.addPlan()
    plan0.tcpConnectThrowable = IllegalStateException("boom!")
    routePlanner.addPlan() // This plan should not be used.

    taskRunner.newQueue().execute("connect") {
      assertFailsWith<IllegalStateException> {
        finder.find()
      }.also { expected ->
        assertThat(expected).hasMessage("boom!")
      }
    }

    assertFailsWith<IllegalStateException> {
      Request
        .Builder()
        .url("https://square.com/")
        .gzip()
        .build()
    }.also {
      assertThat(it).hasMessage("cannot gzip a request that has no body")
    }
  }

  @Test
  fun cannotGzipWithAnotherContentEncoding() {
    assertFailsWith<IllegalStateException> {
      Request
        .Builder()

        Thread.currentThread().interrupt() // Retain interrupted status.
      }
    }

    if (!::bytes.isInitialized) {
      // May have failed with an IOException
      throw IllegalStateException("Unable to load $path resource.").apply {
        initCause(readFailure)
      }
    }
  }

  abstract val path: Any

  /**

        ResourceManager.ManagedResource<TestResource> managed = resourceManager.manage(resource);

        managed.close();
        assertTrue(resource.isClosed());

        assertThrows(IllegalStateException.class, managed::get);
    }

    @Test
    @DisplayName("Test resource unregistration")
    void testResourceUnregistration() {
        TestResource resource = new TestResource("test5");

            doThrow(new RuntimeException("Test Exception")).when(mockMd5).digest(any(byte[].class), anyInt(), anyInt());

            HMACT64 hmac = new HMACT64(TEST_KEY);
            assertThrows(IllegalStateException.class, () -> hmac.engineDigest(new byte[10], 0, 10));
        }
    }

    @Test
    void testClone() throws NoSuchAlgorithmException, CloneNotSupportedException {
        // Test clone() method