*
     * @return a string containing the execution result with the number of deleted files or error message
     */
    public String execute() {
        try {
            final long count = ComponentUtil.getThumbnailManager().purge(getExpiry());
            return "Deleted " + count + " thumbnail files.";
        } catch (final Exception e) {
            logger.error("Failed to purge thumbnails.", e);

            throw new IOException("Connection rejected by circuit breaker: " + e.getMessage(), e);
        } catch (RuntimeException e) {
            // Unwrap IOException from RuntimeException
            if (e.getCause() instanceof IOException) {
                throw (IOException) e.getCause();
            }
            throw new IOException("Connection failed", e);
        } catch (Exception e) {

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;

class ModelXmlTest {

    @Test
    void testXmlRoundtripWithProperties() throws Exception {
        Map<String, String> props = new LinkedHashMap<>();
        props.put("javax.version", "3.1.0");
        props.put("mockito.version", "1.10.19");
        props.put("hamcret.version", "2.1");

    val subjectCaCerts = subjectToCaCerts[issuer] ?: return null

    return subjectCaCerts.firstOrNull {
      try {
        cert.verify(it.publicKey)
        return@firstOrNull true
      } catch (_: Exception) {
        return@firstOrNull false
      }
    }
  }

  override fun equals(other: Any?): Boolean =
    other === this ||
      (other is BasicTrustRootIndex && other.subjectToCaCerts == subjectToCaCerts)

    platform.assumeJdk9()
    val applicationProtocolUnsupported =
      object : DelegatingSSLSocket(null) {
        override fun getApplicationProtocol(): String = throw UnsupportedOperationException("Mock exception")
      }
    assertThat(Jdk9Platform().getSelectedProtocol(applicationProtocolUnsupported)).isNull()
  }

 * Android.
 */
@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public class AbstractFutureDefaultAtomicHelperTest extends TestCase {
  public void testUsingExpectedAtomicHelper() throws Exception {
    if (isAndroid()) {
      assertThat(AbstractFutureState.atomicHelperTypeForTest()).isEqualTo("UnsafeAtomicHelper");
    } else {
      assertThat(AbstractFutureState.atomicHelperTypeForTest())

@GwtCompatible
public abstract class UnmodifiableIterator<E extends @Nullable Object> implements Iterator<E> {
  /** Constructor for use by subclasses. */
  protected UnmodifiableIterator() {}

  /**
   * Guaranteed to throw an exception and leave the underlying data unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override

          include(name: "**/daemon-${ProcessHandle.current().pid()}*.log")
        }

        fileset(dir: "${gradle.gradleUserHomeDir}/workers", followsymlinks: false)
      }
    } catch (Exception e) {
      logger.lifecycle("Failed to archive additional logs", e)
    }
  }

    private String processOrigin;
    private ServletRequest processRequest;
    private ServletResponse processResponse;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        responseHeaders = new HashMap<>();
        processCalled = false;
        processOrigin = null;
        processRequest = null;
        processResponse = null;

    }

    /**
     * Tests that the ordering of the map resembles the ordering of the input collection of artifacts.
     */
    @Test
    void testArtifactMapByVersionlessIdOrdering() throws Exception {
        List<Artifact> list = new ArrayList<>();
        list.add(newArtifact("b"));
        list.add(newArtifact("a"));
        list.add(newArtifact("c"));
        list.add(newArtifact("e"));