pathToLease.remove(entry.getValue().getPath());
                    cleaned++;
                    log.debug("Cleaned up expired lease: {}", entry.getKey());
                }
            }

            if (cleaned > 0) {
                log.info("Cleaned up {} expired leases", cleaned);
            }

            return cleaned;
        } finally {
            lock.writeLock().unlock();
        }
    }

 * certificate is signed by the certificate that follows, and the last certificate is a trusted CA
 * certificate.
 *
 * Use of the chain cleaner is necessary to omit unexpected certificates that aren't relevant to
 * the TLS handshake and to extract the trusted CA certificate for the benefit of certificate
 * pinning.
 */
abstract class CertificateChainCleaner {

                        .execute()) {
                    if (deleteResponse.getHttpStatusCode() == 200) {
                        if (logger.isInfoEnabled()) {
                            logger.info("Cleaned up stale operation: operation={}, previousOwner={}", operationName, ownerInstanceId);
                        }
                        // Retry creation

        final boolean result = testClient.reindexConfigIndices(false, allTargetPrefixes());

        assertFalse(result);
        // Backup should be cleaned up
        assertTrue(testClient.deletedIndices.size() > 0, "Backup indices should be cleaned up");
    }

    @Test
    public void test_reindexConfigIndices_reindexFromBackupFailureCleansUp() {
        testClient.existsIndexResult = true;

        assertEquals(TaskOutcome.FAILED, result.task(":failed-test-with-leftover:test")!!.outcome)

        // leftover files failed tests are reported but not counted as an exception, but cleaned up eventually
        assertEquals(2, StringUtils.countMatches(result.output, "Found non-empty test files dir"))
        assertEquals(2, StringUtils.countMatches(result.output, "Failed to stop service 'testFilesCleanupBuildService'"))

     */
    public ReqHeaderPager() {
        // Default constructor - initialization handled by field defaults and clear() method
    }

    /**
     * Clears all pager data and resets to default values.
     * This method resets pagination state and clears all request header fields.
     */
    public void clear() {
        allRecordCount = 0;
        allPageCount = 0;
        existPrePage = false;

        assert items == {"foo": {"name": "Fighters"}, "bar": {"name": "Tenders"}}

    # The end of the "with TestClient" block simulates terminating the app, so
    # the lifespan ends and items are cleaned up

   * has consumed the entire input and they are ready to output a {@code HashCode}. The order of the
   * hashers are the same order as the functions given to the constructor.
   */
  // this could be cleaner if it passed HashCode[], but that would create yet another array...
  /* protected */ abstract HashCode makeHash(Hasher[] hashers);

  @Override
  public Hasher newHasher() {

    vcs.useAbsoluteVcs(VersionedSettingsBranch.fromDslContext().vcsRootId())

    features {
        freeDiskSpace {
            // Lower the limit such that the agent work directories aren't cleaned during the AMI baking process
            requiredSpace = "100mb"
        }
    }

    params {
        param("defaultBranchName", "master")
        param("env.JAVA_HOME", javaHome(BuildToolBuildJvm, Os.LINUX))

plugins {
    id("gradlebuild.build-logic.kotlin-dsl-gradle-plugin")
    id("gradlebuild.build-logic.groovy-dsl-gradle-plugin")
}

description = "Provides a plugin that cleans up after executing tests"

dependencies {
    implementation("gradlebuild:basics")
    implementation("gradlebuild:module-identity")