org.gradle.api.tasks.testing

## Class Test

- java.lang.Object
- - org.gradle.api.internal.AbstractTask
  - - org.gradle.api.DefaultTask
    - - org.gradle.api.internal.ConventionTask
      - - org.gradle.api.tasks.testing.Test

- All Implemented Interfaces:
    Comparable<Task>, org.gradle.api.internal.DynamicObjectAware, org.gradle.api.internal.IConventionAware, org.gradle.api.internal.TaskInternal, ExtensionAware, Reporting<TestTaskReports>, Task, PatternFilterable, VerificationTask, JavaForkOptions, ProcessForkOptions, org.gradle.util.Configurable<Task>

      @CacheableTask
      public class Test
      extends org.gradle.api.internal.ConventionTask
      implements JavaForkOptions, PatternFilterable, VerificationTask, Reporting<TestTaskReports>

  Executes JUnit (3.8.x or 4.x) or TestNG tests. Test are always run in (one or more) separate JVMs. The sample below shows various configuration options.

       apply plugin: 'java' // adds 'test' task

       test {
         // enable TestNG support (default is JUnit)
         useTestNG()

         // set a system property for the test JVM(s)
         systemProperty 'some.prop', 'value'

         // explicitly include or exclude tests
         include 'org/foo/**'
         exclude 'org/boo/**'

         // show standard out and standard error of the test JVM(s) on the console
         testLogging.showStandardStreams = true

         // set heap size for the test JVM(s)
         minHeapSize = "128m"
         maxHeapSize = "512m"

         // set JVM arguments for the test JVM(s)
         jvmArgs '-XX:MaxPermSize=256m'

         // listen to events in the test execution lifecycle
         beforeTest { descriptor ->
            logger.lifecycle("Running test: " + descriptor)
         }

         // listen to standard out and standard error of the test JVM(s)
         onOutput { descriptor, event ->
            logger.lifecycle("Test: " + descriptor + " produced standard out/err: " + event.message )
         }
       }

  The test process can be started in debug mode (see `getDebug()`) in an ad-hoc manner by supplying the `--debug-jvm` switch when invoking the build.

       gradle someTestTask --debug-jvm

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface org.gradle.api.Task

      `Task.Namer`

  - ### Field Summary

    - ### Fields inherited from interface org.gradle.api.Task

      `TASK_ACTION, TASK_DEPENDS_ON, TASK_DESCRIPTION, TASK_GROUP, TASK_NAME, TASK_OVERWRITE, TASK_TYPE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Test()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addTestListener(TestListener listener)` Registers a test listener with this task.
    `void` | `addTestOutputListener(TestOutputListener listener)` Registers a output listener with this task.
    `void` | `afterSuite(Closure closure)` Adds a closure to be notified after a test suite has executed.
    `void` | `afterTest(Closure closure)` Adds a closure to be notified after a test has executed.
    `void` | `beforeSuite(Closure closure)` Adds a closure to be notified before a test suite is executed.
    `void` | `beforeTest(Closure closure)` Adds a closure to be notified before a test is executed.
    `Test` | `bootstrapClasspath(Object... classpath)` Adds the given values to the end of the bootstrap classpath for the process.
    `Test` | `copyTo(JavaForkOptions target)` Copies these options to the given options.
    `Test` | `copyTo(ProcessForkOptions target)` Copies these options to the given target options.
    `Test` | `environment(Map<String,?> environmentVariables)` Adds some environment variables to the environment for this process.
    `Test` | `environment(String name, Object value)` Adds an environment variable to the environment for this process.
    `Test` | `exclude(Closure excludeSpec)` Adds an exclude spec.
    `Test` | `exclude(Iterable<String> excludes)` Adds exclude patterns for the files in the test classes directory (e.g.
    `Test` | `exclude(Spec<FileTreeElement> excludeSpec)` Adds an exclude spec.
    `Test` | `exclude(String... excludes)` Adds exclude patterns for the files in the test classes directory (e.g.
    `Test` | `executable(Object executable)` Sets the name of the executable to use.
    `void` | `executeTests()`
    `void` | `filter(Action<TestFilter> action)` Executes the action against the `getFilter()`.
    `protected org.gradle.internal.actor.ActorFactory` | `getActorFactory()`
    `List<String>` | `getAllJvmArgs()` Returns the full set of arguments to use to launch the JVM for the process.
    `File` | `getBinResultsDir()` Returns the root folder for the test results in internal binary format.
    `FileCollection` | `getBootstrapClasspath()` Returns the bootstrap classpath to use for the process.
    `protected org.gradle.internal.operations.BuildOperationProcessor` | `getBuildOperationProcessor()`
    `FileTree` | `getCandidateClassFiles()` Returns the classes files to scan for test classes.
    `protected org.gradle.api.internal.initialization.loadercache.ClassLoaderCache` | `getClassLoaderCache()`
    `FileCollection` | `getClasspath()` Returns the classpath to use to execute the tests.
    `boolean` | `getDebug()` Returns true if debugging is enabled for the process.
    `String` | `getDefaultCharacterEncoding()` Returns the default character encoding to use.
    `boolean` | `getEnableAssertions()` Returns true if assertions are enabled for the process.
    `Map<String,Object>` | `getEnvironment()` The environment variables to use for the process.
    `Set<String>` | `getExcludes()` Returns the exclude patterns for test execution.
    `String` | `getExecutable()` Returns the name of the executable to use.
    `protected org.gradle.api.internal.file.FileResolver` | `getFileResolver()`
    `TestFilter` | `getFilter()` Allows filtering tests for execution.
    `long` | `getForkEvery()` Returns the maximum number of test classes to execute in a forked test process.
    `boolean` | `getIgnoreFailures()` Specifies whether the build should break when the verifications performed by this task fail.
    `Set<String>` | `getIncludes()` Returns the include patterns for test execution.
    `protected org.gradle.internal.remote.internal.inet.InetAddressFactory` | `getInetAddressFactory()`
    `protected org.gradle.internal.reflect.Instantiator` | `getInstantiator()`
    `List<String>` | `getJvmArgs()` Returns the extra arguments to use to launch the JVM for the process.
    `protected org.gradle.internal.event.ListenerManager` | `getListenerManager()`
    `String` | `getMaxHeapSize()` Returns the maximum heap size for the process, if any.
    `int` | `getMaxParallelForks()` Returns the maximum number of forked test processes to execute in parallel.
    `String` | `getMinHeapSize()` Returns the minimum heap size for the process, if any.
    `protected org.gradle.api.internal.classpath.ModuleRegistry` | `getModuleRegistry()`
    `TestFrameworkOptions` | `getOptions()` Returns test framework specific options.
    `protected org.gradle.process.internal.worker.WorkerProcessFactory` | `getProcessBuilderFactory()`
    `protected org.gradle.internal.logging.progress.ProgressLoggerFactory` | `getProgressLoggerFactory()`
    `TestTaskReports` | `getReports()` The reports that this task potentially produces.
    `Map<String,Object>` | `getSystemProperties()` Returns the system properties which will be used for the process.
    `File` | `getTestClassesDir()` Returns the root folder for the compiled test sources.
    `org.gradle.api.internal.tasks.testing.TestFramework` | `getTestFramework()`
    `TestLoggingContainer` | `getTestLogging()` Allows to set options related to which test events are logged to the console, and on which detail level.
    `protected org.gradle.internal.logging.text.StyledTextOutputFactory` | `getTextOutputFactory()`
    `File` | `getWorkingDir()` Returns the working directory for the process.
    `Test` | `include(Closure includeSpec)` Adds an include spec.
    `Test` | `include(Iterable<String> includes)` Adds include patterns for the files in the test classes directory (e.g.
    `Test` | `include(Spec<FileTreeElement> includeSpec)` Adds an include spec.
    `Test` | `include(String... includes)` Adds include patterns for the files in the test classes directory (e.g.
    `boolean` | `isScanForTestClasses()` Specifies whether test classes should be detected.
    `Test` | `jvmArgs(Iterable<?> arguments)` Adds some arguments to use to launch the JVM for the process.
    `Test` | `jvmArgs(Object... arguments)` Adds some arguments to use to launch the JVM for the process.
    `void` | `onOutput(Closure closure)` Adds a closure to be notified when output from the test received.
    `TestFrameworkOptions` | `options(Closure testFrameworkConfigure)` Configures test framework specific options.
    `void` | `removeTestListener(TestListener listener)` Unregisters a test listener with this task.
    `void` | `removeTestOutputListener(TestOutputListener listener)` Unregisters a test output listener with this task.
    `TestTaskReports` | `reports(Action<? super TestTaskReports> configureAction)` Configures the reports that this task potentially produces.
    `TestTaskReports` | `reports(Closure closure)` Configures the reports that this task potentially produces.
    `void` | `setAllJvmArgs(Iterable<?> arguments)` Sets the full set of arguments to use to launch the JVM for the process.
    `void` | `setBinResultsDir(File binResultsDir)` Sets the root folder for the test results in internal binary format.
    `void` | `setBootstrapClasspath(FileCollection classpath)` Sets the bootstrap classpath to use for the process.
    `void` | `setClasspath(FileCollection classpath)`
    `void` | `setDebug(boolean enabled)` Enable or disable debugging for the process.
    `void` | `setDefaultCharacterEncoding(String defaultCharacterEncoding)` Sets the default character encoding to use.
    `void` | `setEnableAssertions(boolean enabled)` Enable or disable assertions for the process.
    `void` | `setEnvironment(Map<String,?> environmentVariables)` Sets the environment variable to use for the process.
    `Test` | `setExcludes(Iterable<String> excludes)` Sets the exclude patterns for test execution.
    `void` | `setExecutable(Object executable)` Sets the name of the executable to use.
    `void` | `setForkEvery(Long forkEvery)` Sets the maximum number of test classes to execute in a forked test process.
    `void` | `setIgnoreFailures(boolean ignoreFailures)` Specifies whether the build should break when the verifications performed by this task fail.
    `Test` | `setIncludes(Iterable<String> includes)` Sets the include patterns for test execution.
    `void` | `setJvmArgs(Iterable<?> arguments)` Sets the extra arguments to use to launch the JVM for the process.
    `void` | `setMaxHeapSize(String heapSize)` Sets the maximum heap size for the process.
    `void` | `setMaxParallelForks(int maxParallelForks)` Sets the maximum number of forked test processes to execute in parallel.
    `void` | `setMinHeapSize(String heapSize)` Sets the minimum heap size for the process.
    `void` | `setScanForTestClasses(boolean scanForTestClasses)`
    `void` | `setSystemProperties(Map<String,?> properties)` Sets the system properties to use for the process.
    `void` | `setTestClassesDir(File testClassesDir)` Sets the root folder for the compiled test sources.
    `Test` | `setTestNameIncludePatterns(List<String> testNamePattern)` Sets the test name patterns to be included in execution.
    `void` | `setWorkingDir(Object dir)` Sets the working directory for the process.
    `Test` | `systemProperties(Map<String,?> properties)` Adds some system properties to use for the process.
    `Test` | `systemProperty(String name, Object value)` Adds a system property to use for the process.
    `org.gradle.api.internal.tasks.testing.TestFramework` | `testFramework(Closure testFrameworkConfigure)`
    `void` | `testLogging(Closure closure)` Allows configuring the logging of the test execution, for example log eagerly the standard output, etc.
    `void` | `useJUnit()` Specifies that JUnit should be used to execute the tests.
    `void` | `useJUnit(Closure testFrameworkConfigure)` Specifies that JUnit should be used to execute the tests, configuring JUnit specific options.
    `void` | `useTestNG()` Specifies that TestNG should be used to execute the tests.
    `void` | `useTestNG(Closure testFrameworkConfigure)` Specifies that TestNG should be used to execute the tests, configuring TestNG specific options.
    `Test` | `workingDir(Object dir)` Sets the working directory for the process.

    - ### Methods inherited from class org.gradle.api.internal.ConventionTask

      `conventionMapping, conventionMapping, getConventionMapping`

    - ### Methods inherited from class org.gradle.api.internal.AbstractTask

      `addValidator, appendParallelSafeAction, compareTo, configure, deleteAllActions, dependsOn, dependsOnTaskDidWork, doFirst, doFirst, doLast, doLast, execute, finalizedBy, getActionClassLoaders, getActions, getAnt, getAsDynamicObject, getConvention, getDependsOn, getDescription, getDidWork, getEnabled, getExecuter, getExtensions, getFinalizedBy, getGroup, getImpliesSubProjects, getInputs, getLogger, getLogging, getMustRunAfter, getName, getOnlyIf, getOutputs, getPath, getProject, getServices, getShouldRunAfter, getStandardOutputCapture, getState, getTaskActions, getTaskDependencies, getTemporaryDir, getTemporaryDirFactory, getValidators, hasProperty, injectIntoNewInstance, isEnabled, isHasCustomActions, leftShift, mustRunAfter, onlyIf, onlyIf, prependParallelSafeAction, property, setActions, setDependsOn, setDescription, setDidWork, setEnabled, setExecuter, setFinalizedBy, setGroup, setImpliesSubProjects, setMustRunAfter, setOnlyIf, setOnlyIf, setProperty, setShouldRunAfter, shouldRunAfter, toString`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### Test

          public Test()

  - ### Method Detail

    - #### getInetAddressFactory

          @Inject
          protected org.gradle.internal.remote.internal.inet.InetAddressFactory getInetAddressFactory()

    - #### getProgressLoggerFactory

          @Inject
          protected org.gradle.internal.logging.progress.ProgressLoggerFactory getProgressLoggerFactory()

    - #### getInstantiator

          @Inject
          protected org.gradle.internal.reflect.Instantiator getInstantiator()

    - #### getActorFactory

          @Inject
          protected org.gradle.internal.actor.ActorFactory getActorFactory()

    - #### getClassLoaderCache

          @Inject
          protected org.gradle.api.internal.initialization.loadercache.ClassLoaderCache getClassLoaderCache()

    - #### getProcessBuilderFactory

          @Inject
          protected org.gradle.process.internal.worker.WorkerProcessFactory getProcessBuilderFactory()

    - #### getFileResolver

          @Inject
          protected org.gradle.api.internal.file.FileResolver getFileResolver()

    - #### getTextOutputFactory

          @Inject
          protected org.gradle.internal.logging.text.StyledTextOutputFactory getTextOutputFactory()

    - #### getListenerManager

          @Inject
          protected org.gradle.internal.event.ListenerManager getListenerManager()

    - #### getBuildOperationProcessor

          @Inject
          protected org.gradle.internal.operations.BuildOperationProcessor getBuildOperationProcessor()

    - #### getModuleRegistry

          @Inject
          protected org.gradle.api.internal.classpath.ModuleRegistry getModuleRegistry()

    - #### getWorkingDir

          @Input
          public File getWorkingDir()

      Returns the working directory for the process. Defaults to the project directory.
      Specified by:
        `getWorkingDir` in interface `ProcessForkOptions`
      Returns:
        The working directory. Never returns null.

    - #### setWorkingDir

          public void setWorkingDir(Object dir)

      Sets the working directory for the process. The supplied argument is evaluated as per `Project.file(Object)`.
      Specified by:
        `setWorkingDir` in interface `ProcessForkOptions`
      Parameters:
        `dir` - The working directory. Must not be null.

    - #### workingDir

          public Test workingDir(Object dir)

      Sets the working directory for the process. The supplied argument is evaluated as per `Project.file(Object)`.
      Specified by:
        `workingDir` in interface `ProcessForkOptions`
      Parameters:
        `dir` - The working directory. Must not be null.
      Returns:
        this

    - #### getExecutable

          @Input
          public String getExecutable()

      Returns the name of the executable to use.
      Specified by:
        `getExecutable` in interface `ProcessForkOptions`
      Returns:
        The executable.

    - #### executable

          public Test executable(Object executable)

      Sets the name of the executable to use.
      Specified by:
        `executable` in interface `ProcessForkOptions`
      Parameters:
        `executable` - The executable. Must not be null.
      Returns:
        this

    - #### setExecutable

          public void setExecutable(Object executable)

      Sets the name of the executable to use.
      Specified by:
        `setExecutable` in interface `ProcessForkOptions`
      Parameters:
        `executable` - The executable. Must not be null.

    - #### getSystemProperties

          public Map<String,Object> getSystemProperties()

      Returns the system properties which will be used for the process.
      Specified by:
        `getSystemProperties` in interface `JavaForkOptions`
      Returns:
        The system properties. Returns an empty map when there are no system properties.

    - #### setSystemProperties

          public void setSystemProperties(Map<String,?> properties)

      Sets the system properties to use for the process.
      Specified by:
        `setSystemProperties` in interface `JavaForkOptions`
      Parameters:
        `properties` - The system properties. Must not be null.

    - #### systemProperties

          public Test systemProperties(Map<String,?> properties)

      Adds some system properties to use for the process.
      Specified by:
        `systemProperties` in interface `JavaForkOptions`
      Parameters:
        `properties` - The system properties. Must not be null.
      Returns:
        this

    - #### systemProperty

          public Test systemProperty(String name,
                            Object value)

      Adds a system property to use for the process.
      Specified by:
        `systemProperty` in interface `JavaForkOptions`
      Parameters:
        `name` - The name of the property
        `value` - The value for the property. May be null.
      Returns:
        this

    - #### getBootstrapClasspath

          public FileCollection getBootstrapClasspath()

      Returns the bootstrap classpath to use for the process. The default bootstrap classpath for the JVM is used when this classpath is empty.
      Specified by:
        `getBootstrapClasspath` in interface `JavaForkOptions`
      Returns:
        The bootstrap classpath. Never returns null.

    - #### setBootstrapClasspath

          public void setBootstrapClasspath(FileCollection classpath)

      Sets the bootstrap classpath to use for the process. Set to an empty classpath to use the default bootstrap classpath for the specified JVM.
      Specified by:
        `setBootstrapClasspath` in interface `JavaForkOptions`
      Parameters:
        `classpath` - The classpath. Must not be null. Can be empty.

    - #### bootstrapClasspath

          public Test bootstrapClasspath(Object... classpath)

      Adds the given values to the end of the bootstrap classpath for the process.
      Specified by:
        `bootstrapClasspath` in interface `JavaForkOptions`
      Parameters:
        `classpath` - The classpath.
      Returns:
        this

    - #### getMinHeapSize

          public String getMinHeapSize()

      Returns the minimum heap size for the process, if any.
      Specified by:
        `getMinHeapSize` in interface `JavaForkOptions`
      Returns:
        The minimum heap size. Returns null if the default minimum heap size should be used.

    - #### getDefaultCharacterEncoding

          public String getDefaultCharacterEncoding()

      Returns the default character encoding to use.
      Specified by:
        `getDefaultCharacterEncoding` in interface `JavaForkOptions`
      Returns:
        The default character encoding. Returns null if the `default character encoding of this JVM` should be used.

    - #### setDefaultCharacterEncoding

          public void setDefaultCharacterEncoding(String defaultCharacterEncoding)

      Sets the default character encoding to use. Note: Many JVM implementations support the setting of this attribute via system property on startup (namely, the `file.encoding` property). For JVMs where this is the case, setting the `file.encoding` property via `JavaForkOptions.setSystemProperties(java.util.Map)` or similar will have no effect as this value will be overridden by the value specified by `JavaForkOptions.getDefaultCharacterEncoding()`.
      Specified by:
        `setDefaultCharacterEncoding` in interface `JavaForkOptions`
      Parameters:
        `defaultCharacterEncoding` - The default character encoding. Use null to use `this JVM's default charset`

    - #### setMinHeapSize

          public void setMinHeapSize(String heapSize)

      Sets the minimum heap size for the process.
      Specified by:
        `setMinHeapSize` in interface `JavaForkOptions`
      Parameters:
        `heapSize` - The minimum heap size. Use null for the default minimum heap size.

    - #### getMaxHeapSize

          public String getMaxHeapSize()

      Returns the maximum heap size for the process, if any.
      Specified by:
        `getMaxHeapSize` in interface `JavaForkOptions`
      Returns:
        The maximum heap size. Returns null if the default maximum heap size should be used.

    - #### setMaxHeapSize

          public void setMaxHeapSize(String heapSize)

      Sets the maximum heap size for the process.
      Specified by:
        `setMaxHeapSize` in interface `JavaForkOptions`
      Parameters:
        `heapSize` - The heap size. Use null for the default maximum heap size.

    - #### getJvmArgs

          public List<String> getJvmArgs()

      Returns the extra arguments to use to launch the JVM for the process. Does not include system properties and the minimum/maximum heap size.
      Specified by:
        `getJvmArgs` in interface `JavaForkOptions`
      Returns:
        The arguments. Returns an empty list if there are no arguments.

    - #### setJvmArgs

          public void setJvmArgs(Iterable<?> arguments)

      Sets the extra arguments to use to launch the JVM for the process. System properties and minimum/maximum heap size are updated.
      Specified by:
        `setJvmArgs` in interface `JavaForkOptions`
      Parameters:
        `arguments` - The arguments. Must not be null.

    - #### jvmArgs

          public Test jvmArgs(Iterable<?> arguments)

      Adds some arguments to use to launch the JVM for the process.
      Specified by:
        `jvmArgs` in interface `JavaForkOptions`
      Parameters:
        `arguments` - The arguments. Must not be null.
      Returns:
        this

    - #### jvmArgs

          public Test jvmArgs(Object... arguments)

      Adds some arguments to use to launch the JVM for the process.
      Specified by:
        `jvmArgs` in interface `JavaForkOptions`
      Parameters:
        `arguments` - The arguments.
      Returns:
        this

    - #### getEnableAssertions

          public boolean getEnableAssertions()

      Returns true if assertions are enabled for the process.
      Specified by:
        `getEnableAssertions` in interface `JavaForkOptions`
      Returns:
        true if assertions are enabled, false if disabled

    - #### setEnableAssertions

          public void setEnableAssertions(boolean enabled)

      Enable or disable assertions for the process.
      Specified by:
        `setEnableAssertions` in interface `JavaForkOptions`
      Parameters:
        `enabled` - true to enable assertions, false to disable.

    - #### getDebug

          public boolean getDebug()

      Returns true if debugging is enabled for the process. When enabled, the process is started suspended and listening on port 5005.
      Specified by:
        `getDebug` in interface `JavaForkOptions`
      Returns:
        true when debugging is enabled, false to disable.

    - #### setDebug

          public void setDebug(boolean enabled)

      Enable or disable debugging for the process. When enabled, the process is started suspended and listening on port 5005.
      Specified by:
        `setDebug` in interface `JavaForkOptions`
      Parameters:
        `enabled` - true to enable debugging, false to disable.

    - #### getAllJvmArgs

          public List<String> getAllJvmArgs()

      Returns the full set of arguments to use to launch the JVM for the process. This includes arguments to define system properties, the minimum/maximum heap size, and the bootstrap classpath.
      Specified by:
        `getAllJvmArgs` in interface `JavaForkOptions`
      Returns:
        The arguments. Returns an empty list if there are no arguments.

    - #### setAllJvmArgs

          public void setAllJvmArgs(Iterable<?> arguments)

      Sets the full set of arguments to use to launch the JVM for the process. Overwrites any previously set system properties, minimum/maximum heap size, assertions, and bootstrap classpath.
      Specified by:
        `setAllJvmArgs` in interface `JavaForkOptions`
      Parameters:
        `arguments` - The arguments. Must not be null.

    - #### getEnvironment

          @Internal
          public Map<String,Object> getEnvironment()

      The environment variables to use for the process. Defaults to the environment of this process.
      Specified by:
        `getEnvironment` in interface `ProcessForkOptions`
      Returns:
        The environment. Returns an empty map when there are no environment variables.

    - #### environment

          public Test environment(Map<String,?> environmentVariables)

      Adds some environment variables to the environment for this process.
      Specified by:
        `environment` in interface `ProcessForkOptions`
      Parameters:
        `environmentVariables` - The environment variables. Must not be null.
      Returns:
        this

    - #### environment

          public Test environment(String name,
                         Object value)

      Adds an environment variable to the environment for this process.
      Specified by:
        `environment` in interface `ProcessForkOptions`
      Parameters:
        `name` - The name of the variable.
        `value` - The value for the variable. Must not be null.
      Returns:
        this

    - #### setEnvironment

          public void setEnvironment(Map<String,?> environmentVariables)

      Sets the environment variable to use for the process.
      Specified by:
        `setEnvironment` in interface `ProcessForkOptions`
      Parameters:
        `environmentVariables` - The environment variables. Must not be null.

    - #### copyTo

          public Test copyTo(ProcessForkOptions target)

      Copies these options to the given target options.
      Specified by:
        `copyTo` in interface `ProcessForkOptions`
      Parameters:
        `target` - The target options
      Returns:
        this

    - #### copyTo

          public Test copyTo(JavaForkOptions target)

      Copies these options to the given options.
      Specified by:
        `copyTo` in interface `JavaForkOptions`
      Parameters:
        `target` - The target options.
      Returns:
        this

    - #### executeTests

          public void executeTests()

    - #### addTestListener

          public void addTestListener(TestListener listener)

      Registers a test listener with this task. Consider also the following handy methods for quicker hooking into test execution: `beforeTest(groovy.lang.Closure)`, `afterTest(groovy.lang.Closure)`, `beforeSuite(groovy.lang.Closure)`, `afterSuite(groovy.lang.Closure)`

      This listener will NOT be notified of tests executed by other tasks. To get that behavior, use `Gradle.addListener(Object)`.

      Parameters:
        `listener` - The listener to add.

    - #### addTestOutputListener

          public void addTestOutputListener(TestOutputListener listener)

      Registers a output listener with this task. Quicker way of hooking into output events is using the `onOutput(groovy.lang.Closure)` method.
      Parameters:
        `listener` - The listener to add.

    - #### removeTestListener

          public void removeTestListener(TestListener listener)

      Unregisters a test listener with this task. This method will only remove listeners that were added by calling `addTestListener(org.gradle.api.tasks.testing.TestListener)` on this task. If the listener was registered with Gradle using `Gradle.addListener(Object)` this method will not do anything. Instead, use `Gradle.removeListener(Object)`.
      Parameters:
        `listener` - The listener to remove.

    - #### removeTestOutputListener

          public void removeTestOutputListener(TestOutputListener listener)

      Unregisters a test output listener with this task. This method will only remove listeners that were added by calling `addTestOutputListener(org.gradle.api.tasks.testing.TestOutputListener)` on this task. If the listener was registered with Gradle using `Gradle.addListener(Object)` this method will not do anything. Instead, use `Gradle.removeListener(Object)`.
      Parameters:
        `listener` - The listener to remove.

    - #### beforeSuite

          public void beforeSuite(Closure closure)

      Adds a closure to be notified before a test suite is executed. A `TestDescriptor` instance is passed to the closure as a parameter.

      This method is also called before any test suites are executed. The provided descriptor will have a null parent suite.

      Parameters:
        `closure` - The closure to call.

    - #### afterSuite

          public void afterSuite(Closure closure)

      Adds a closure to be notified after a test suite has executed. A `TestDescriptor` and `TestResult` instance are passed to the closure as a parameter.

      This method is also called after all test suites are executed. The provided descriptor will have a null parent suite.

      Parameters:
        `closure` - The closure to call.

    - #### beforeTest

          public void beforeTest(Closure closure)

      Adds a closure to be notified before a test is executed. A `TestDescriptor` instance is passed to the closure as a parameter.
      Parameters:
        `closure` - The closure to call.

    - #### afterTest

          public void afterTest(Closure closure)

      Adds a closure to be notified after a test has executed. A `TestDescriptor` and `TestResult` instance are passed to the closure as a parameter.
      Parameters:
        `closure` - The closure to call.

    - #### onOutput

          public void onOutput(Closure closure)

      Adds a closure to be notified when output from the test received. A `TestDescriptor` and `TestOutputEvent` instance are passed to the closure as a parameter.

           apply plugin: 'java'

           test { onOutput { descriptor, event -> if (event.destination == TestOutputEvent.Destination.StdErr) { logger.error("Test: " + descriptor + ", error: " + event.message) } } }

      Parameters:
        `closure` - The closure to call.

    - #### include

          public Test include(String... includes)

      Adds include patterns for the files in the test classes directory (e.g. '**F;*Test.class')).
      Specified by:
        `include` in interface `PatternFilterable`
      Parameters:
        `includes` - a vararg list of include patterns
      Returns:
        this
      See Also:
        `setIncludes(Iterable)`

    - #### include

          public Test include(Iterable<String> includes)

      Adds include patterns for the files in the test classes directory (e.g. '**F;*Test.class')).
      Specified by:
        `include` in interface `PatternFilterable`
      Parameters:
        `includes` - a Iterable providing more include patterns
      Returns:
        this
      See Also:
        `setIncludes(Iterable)`

    - #### include

          public Test include(Spec<FileTreeElement> includeSpec)

      Adds an include spec. This method may be called multiple times to append new specs. If includes are not provided, then all files in this container will be included. If includes are provided, then a file must match at least one of the include patterns or specs to be included.
      Specified by:
        `include` in interface `PatternFilterable`
      Parameters:
        `includeSpec` - the spec to add
      Returns:
        this
      See Also:
        `Pattern Format`

    - #### include

          public Test include(Closure includeSpec)

      Adds an include spec. This method may be called multiple times to append new specs. The given closure is passed a `FileTreeElement` as its parameter. If includes are not provided, then all files in this container will be included. If includes are provided, then a file must match at least one of the include patterns or specs to be included.
      Specified by:
        `include` in interface `PatternFilterable`
      Parameters:
        `includeSpec` - the spec to add
      Returns:
        this
      See Also:
        `Pattern Format`

    - #### exclude

          public Test exclude(String... excludes)

      Adds exclude patterns for the files in the test classes directory (e.g. '**F;*Test.class')).
      Specified by:
        `exclude` in interface `PatternFilterable`
      Parameters:
        `excludes` - a vararg list of exclude patterns
      Returns:
        this
      See Also:
        `setExcludes(Iterable)`

    - #### exclude

          public Test exclude(Iterable<String> excludes)

      Adds exclude patterns for the files in the test classes directory (e.g. '**F;*Test.class')).
      Specified by:
        `exclude` in interface `PatternFilterable`
      Parameters:
        `excludes` - a Iterable providing new exclude patterns
      Returns:
        this
      See Also:
        `setExcludes(Iterable)`

    - #### exclude

          public Test exclude(Spec<FileTreeElement> excludeSpec)

      Adds an exclude spec. This method may be called multiple times to append new specs. If excludes are not provided, then no files will be excluded. If excludes are provided, then files must not match any exclude pattern to be processed.
      Specified by:
        `exclude` in interface `PatternFilterable`
      Parameters:
        `excludeSpec` - the spec to add
      Returns:
        this
      See Also:
        `Pattern Format`

    - #### exclude

          public Test exclude(Closure excludeSpec)

      Adds an exclude spec. This method may be called multiple times to append new specs.The given closure is passed a `FileTreeElement` as its parameter. The closure should return true or false. Example:

           copySpec {
             from 'source'
             into 'destination'
             //an example of excluding files from certain configuration:
             exclude { it.file in configurations.someConf.files }
           }

      If excludes are not provided, then no files will be excluded. If excludes are provided, then files must not match any exclude pattern to be processed.
      Specified by:
        `exclude` in interface `PatternFilterable`
      Parameters:
        `excludeSpec` - the spec to add
      Returns:
        this
      See Also:
        `FileTreeElement`

    - #### setTestNameIncludePatterns

          @Incubating
          public Test setTestNameIncludePatterns(List<String> testNamePattern)

      Sets the test name patterns to be included in execution. Classes or method names are supported, wildcard '*' is supported. For more information see the user guide chapter on testing. For more information on supported patterns see `TestFilter`

    - #### getTestClassesDir

          @Internal
          public File getTestClassesDir()

      Returns the root folder for the compiled test sources.
      Returns:
        All test class directories to be used.

    - #### setTestClassesDir

          public void setTestClassesDir(File testClassesDir)

      Sets the root folder for the compiled test sources.
      Parameters:
        `testClassesDir` - The root folder

    - #### getBinResultsDir

          @OutputDirectory
          @Incubating
          public File getBinResultsDir()

      Returns the root folder for the test results in internal binary format.
      Returns:
        the test result directory, containing the test results in binary format.

    - #### setBinResultsDir

          @Incubating
          public void setBinResultsDir(File binResultsDir)

      Sets the root folder for the test results in internal binary format.
      Parameters:
        `binResultsDir` - The root folder

    - #### getIncludes

          @Internal
          public Set<String> getIncludes()

      Returns the include patterns for test execution.
      Specified by:
        `getIncludes` in interface `PatternFilterable`
      Returns:
        The include patterns. Returns an empty set when there are no include patterns.
      See Also:
        `include(String...)`

    - #### setIncludes

          public Test setIncludes(Iterable<String> includes)

      Sets the include patterns for test execution.
      Specified by:
        `setIncludes` in interface `PatternFilterable`
      Parameters:
        `includes` - The patterns list
      Returns:
        this
      See Also:
        `include(String...)`

    - #### getExcludes

          @Internal
          public Set<String> getExcludes()

      Returns the exclude patterns for test execution.
      Specified by:
        `getExcludes` in interface `PatternFilterable`
      Returns:
        The exclude patterns. Returns an empty set when there are no exclude patterns.
      See Also:
        `exclude(String...)`

    - #### setExcludes

          public Test setExcludes(Iterable<String> excludes)

      Sets the exclude patterns for test execution.
      Specified by:
        `setExcludes` in interface `PatternFilterable`
      Parameters:
        `excludes` - The patterns list
      Returns:
        this
      See Also:
        `exclude(String...)`

    - #### getIgnoreFailures

          @Input
          public boolean getIgnoreFailures()

      Specifies whether the build should break when the verifications performed by this task fail.
      Specified by:
        `getIgnoreFailures` in interface `VerificationTask`
      Returns:
        false, when the build should break on failure, true when the failures should be ignored.

    - #### setIgnoreFailures

          public void setIgnoreFailures(boolean ignoreFailures)

      Specifies whether the build should break when the verifications performed by this task fail.
      Specified by:
        `setIgnoreFailures` in interface `VerificationTask`
      Parameters:
        `ignoreFailures` - false to break the build on failure, true to ignore the failures. The default is false.

    - #### getTestFramework

          @Internal
          public org.gradle.api.internal.tasks.testing.TestFramework getTestFramework()

    - #### testFramework

          public org.gradle.api.internal.tasks.testing.TestFramework testFramework(Closure testFrameworkConfigure)

    - #### getOptions

          public TestFrameworkOptions getOptions()

      Returns test framework specific options. Make sure to call `useJUnit()` or `useTestNG()` before using this method.
      Returns:
        The test framework options.

    - #### options

          public TestFrameworkOptions options(Closure testFrameworkConfigure)

      Configures test framework specific options. Make sure to call `useJUnit()` or `useTestNG()` before using this method.
      Returns:
        The test framework options.

    - #### useJUnit

          public void useJUnit()

      Specifies that JUnit should be used to execute the tests.

      To configure JUnit specific options, see `useJUnit(groovy.lang.Closure)`.

    - #### useJUnit

          public void useJUnit(Closure testFrameworkConfigure)

      Specifies that JUnit should be used to execute the tests, configuring JUnit specific options.

      The supplied closure configures an instance of `JUnitOptions`, which can be used to configure how JUnit runs.

      Parameters:
        `testFrameworkConfigure` - A closure used to configure the JUnit options.

    - #### useTestNG

          public void useTestNG()

      Specifies that TestNG should be used to execute the tests.

      To configure TestNG specific options, see `useTestNG(Closure)`.

    - #### useTestNG

          public void useTestNG(Closure testFrameworkConfigure)

      Specifies that TestNG should be used to execute the tests, configuring TestNG specific options.

      The supplied closure configures an instance of `TestNGOptions`, which can be used to configure how TestNG runs.

      Parameters:
        `testFrameworkConfigure` - A closure used to configure the TestNG options.

    - #### getClasspath

          @Classpath
          public FileCollection getClasspath()

      Returns the classpath to use to execute the tests.

    - #### setClasspath

          public void setClasspath(FileCollection classpath)

    - #### isScanForTestClasses

          @Input
          public boolean isScanForTestClasses()

      Specifies whether test classes should be detected. When `true` the classes which match the include and exclude patterns are scanned for test classes, and any found are executed. When `false` the classes which match the include and exclude patterns are executed.

    - #### setScanForTestClasses

          public void setScanForTestClasses(boolean scanForTestClasses)

    - #### getForkEvery

          @Input
          public long getForkEvery()

      Returns the maximum number of test classes to execute in a forked test process. The forked test process will be restarted when this limit is reached. The default value is 0 (no maximum).
      Returns:
        The maximum number of test classes. Returns 0 when there is no maximum.

    - #### setForkEvery

          public void setForkEvery(Long forkEvery)

      Sets the maximum number of test classes to execute in a forked test process. Use null or 0 to use no maximum.
      Parameters:
        `forkEvery` - The maximum number of test classes. Use null or 0 to specify no maximum.

    - #### getMaxParallelForks

          @Input
          public int getMaxParallelForks()

      Returns the maximum number of forked test processes to execute in parallel. The default value is 1 (no parallel test execution).
      Returns:
        The maximum number of forked test processes.

    - #### setMaxParallelForks

          public void setMaxParallelForks(int maxParallelForks)

      Sets the maximum number of forked test processes to execute in parallel. Set to 1 to disable parallel test execution.
      Parameters:
        `maxParallelForks` - The maximum number of forked test processes.

    - #### getCandidateClassFiles

          @PathSensitive(value=RELATIVE)
          @InputFiles
          public FileTree getCandidateClassFiles()

      Returns the classes files to scan for test classes.
      Returns:
        The candidate class files.

    - #### getTestLogging

          @Internal
          public TestLoggingContainer getTestLogging()

      Allows to set options related to which test events are logged to the console, and on which detail level. For example, to show more information about exceptions use:

           apply plugin: 'java'

           test.testLogging { exceptionFormat "full" }

      For further information see `TestLoggingContainer`.
      Returns:
        this

    - #### testLogging

          public void testLogging(Closure closure)

      Allows configuring the logging of the test execution, for example log eagerly the standard output, etc.

           apply plugin: 'java'

           //makes the standard streams (err and out) visible at console when running tests test.testLogging { showStandardStreams = true }

      Parameters:
        `closure` - configure closure

    - #### getReports

          public TestTaskReports getReports()

      The reports that this task potentially produces.
      Specified by:
        `getReports` in interface `Reporting<TestTaskReports>`
      Returns:
        The reports that this task potentially produces

    - #### reports

          public TestTaskReports reports(Closure closure)

      Configures the reports that this task potentially produces.
      Specified by:
        `reports` in interface `Reporting<TestTaskReports>`
      Parameters:
        `closure` - The configuration
      Returns:
        The reports that this task potentially produces

    - #### reports

          public TestTaskReports reports(Action<? super TestTaskReports> configureAction)

      Configures the reports that this task potentially produces.
      Specified by:
        `reports` in interface `Reporting<TestTaskReports>`
      Parameters:
        `configureAction` - The configuration
      Returns:
        The reports that this task potentially produces

    - #### getFilter

          @Incubating
          public TestFilter getFilter()

      Allows filtering tests for execution.
      Returns:
        filter object
      Since:
        1.10

    - #### filter

          @Incubating
          public void filter(Action<TestFilter> action)

      Executes the action against the `getFilter()`.
      Parameters:
        `action` - configuration of the test filter
      Since:
        1.10