ExecutorService delegate = mock(ExecutorService.class);
    ListeningExecutorService service = listeningDecorator(delegate);
    Runnable task = () -> {};
    service.execute(task);
    verify(delegate).execute(task);
  }

  public void testListeningDecorator_scheduleSuccess() throws Exception {
    CountDownLatch completed = new CountDownLatch(1);
    ScheduledThreadPoolExecutor delegate =

import org.elasticsearch.gradle.internal.conventions.precommit.PrecommitTask;
import org.gradle.api.GradleException;
import org.gradle.api.file.RegularFileProperty;
import org.gradle.api.tasks.InputFile;
import org.gradle.api.tasks.TaskAction;

import java.io.FileReader;
import java.util.Collection;
import java.util.function.Consumer;
import java.util.function.Predicate;

------------------------------

== Running verification tasks

To run all verification tasks, including static checks, unit tests, and integration tests:

---------------------------------------------------------------------------
./gradlew check
---------------------------------------------------------------------------

Note that this will also run the unit tests and precommit tasks first. If you want to just

# /---------------------------------------------------------------------------
# databaseInfoMap: (Required)
#
# The database information for the tasks of DBFlute.
# You should specify before your first generating.
#
# o driver   -- The class name of JDBC-Driver.
# o url      -- The URL for connecting database.
# o schema   -- The schema name.
# o user     -- The database user name.
# o password -- The database password.

tasks.withType<AbstractPublishToMaven>().configureEach {
    val noUpload = project.gradleProperty("noUpload")
    this.onlyIf { !noUpload.map { it == "true" }.orElse(false).get() }
    if (name.endsWith("ToRemoteRepository")) {
        failEarlyIfUrlOrCredentialsAreNotSet(this)
        // packageBuild task executes tests, so we must run after it
        mustRunAfter(":packageBuild")

import org.elasticsearch.gradle.internal.InternalPlugin;
import org.elasticsearch.gradle.internal.conventions.precommit.PrecommitPlugin;
import org.gradle.api.Project;
import org.gradle.api.Task;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.tasks.TaskProvider;
import org.gradle.internal.jvm.Jvm;

import java.nio.file.Path;

public class ThirdPartyAuditPrecommitPlugin extends PrecommitPlugin implements InternalPlugin {

import org.gradle.api.artifacts.ProjectDependency;
import org.gradle.api.DefaultTask;
import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.InputFiles;
import org.gradle.api.tasks.TaskAction;

import java.util.HashSet;
import java.util.Set;

/**
 * A task to generate a dependency graph of our runtime dependencies and push that via
 * an API call to a given endpoint of a SCA tool/service.

 * limitations under the License.
 */

package gradlebuild.buildutils.tasks

import com.google.gson.Gson
import org.gradle.api.DefaultTask
import org.gradle.api.file.RegularFileProperty
import org.gradle.api.provider.Property
import org.gradle.api.tasks.Internal
import org.gradle.api.tasks.options.Option
import org.gradle.work.DisableCachingByDefault
import java.net.URI

            }

            final int totalCount = process(options);
            if (totalCount != 0) {
                logger.info("Processed {} thumbnail task(s).", totalCount);
            } else {
                logger.info("No thumbnail tasks to process.");
            }
            exitCode = 0;
        } catch (final ContainerNotAvailableException e) {
            if (logger.isDebugEnabled()) {

    }

    def "can filter source files"() {
        given:
        buildFile << """
        plugins {
            id 'java'
            id 'elasticsearch.internal-licenseheaders'
        }

        tasks.named("licenseHeaders").configure {
            excludes << 'org/acme/filtered/**/*'
        }
        """
        dualLicensedFile()
        unknownSourceFile("src/main/java/org/acme/filtered/FilteredUnknownLicensed.java")