Class 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 AbstractTestTask
    implements JavaForkOptions, PatternFilterable
    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
     
    • Constructor Detail

      • Test

        public Test()
    • Method Detail

      • 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()
      • getModuleRegistry

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

        @Internal
        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​(File dir)
        Sets the working directory for the process.
        Specified by:
        setWorkingDir in interface ProcessForkOptions
        Parameters:
        dir - The working directory. Must not be 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
      • getJavaVersion

        @Input
        public JavaVersion getJavaVersion()
        Returns the version of Java used to run the tests based on the executable specified by getExecutable().
        Since:
        3.3
      • 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​(String executable)
        Sets the name of the executable to use.
        Specified by:
        setExecutable in interface ProcessForkOptions
        Parameters:
        executable - The executable. Must not be null.
      • 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.
      • 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​(List<String> 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.
      • 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​(List<String> 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.
      • 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​(JavaForkOptions target)
        Copies these options to the given options.
        Specified by:
        copyTo in interface JavaForkOptions
        Parameters:
        target - The target options.
        Returns:
        this
      • createTestExecutionSpec

        protected org.gradle.api.internal.tasks.testing.JvmTestExecutionSpec createTestExecutionSpec()
        Creates test execution specification. For internal use only.
        Specified by:
        createTestExecutionSpec in class AbstractTestTask
        Since:
        4.4
      • createTestExecuter

        protected org.gradle.api.internal.tasks.testing.TestExecuter<org.gradle.api.internal.tasks.testing.JvmTestExecutionSpec> createTestExecuter()
        Description copied from class: AbstractTestTask
        Creates test executer. For internal use only.
        Specified by:
        createTestExecuter in class AbstractTestTask
      • include

        public Test include​(String... includes)
        Adds include patterns for the files in the test classes directory (e.g. '**/*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. '**/*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. '**/*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. '**/*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
      • getTestClassesDirs

        @Internal
        public FileCollection getTestClassesDirs()
        Returns the directories for the compiled test sources.
        Returns:
        All test class directories to be used.
        Since:
        4.0
      • setTestClassesDirs

        public void setTestClassesDirs​(FileCollection testClassesDirs)
        Sets the directories to scan for compiled test sources. Typically, this would be configured to use the output of a source set:
         apply plugin: 'java'
        
         sourceSets {
            integrationTest {
               compileClasspath += main.output
               runtimeClasspath += main.output
            }
         }
        
         task integrationTest(type: Test) {
             // Runs tests from src/integrationTest
             testClassesDirs = sourceSets.integrationTest.output.classesDirs
             classpath = sourceSets.integrationTest.runtimeClasspath
         }
         
        Parameters:
        testClassesDirs - All test class directories to be used.
        Since:
        4.0
      • getTestFramework

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

        public org.gradle.api.internal.tasks.testing.TestFramework testFramework​(Closure testFrameworkConfigure)
      • 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.
      • useJUnit

        public void useJUnit​(Action<? super JUnitOptions> testFrameworkConfigure)
        Specifies that JUnit should be used to execute the tests, configuring JUnit specific options.

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

        Parameters:
        testFrameworkConfigure - An action used to configure the JUnit options.
        Since:
        3.5
      • 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.
      • useTestNG

        public void useTestNG​(Action<? super TestFrameworkOptions> testFrameworkConfigure)
        Specifies that TestNG should be used to execute the tests, configuring TestNG specific options.

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

        Parameters:
        testFrameworkConfigure - An action used to configure the TestNG options.
        Since:
        3.5
      • 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

        @Internal
        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

        @Internal
        public int getMaxParallelForks()
        Returns the maximum number of forked test processes to execute in parallel. The default value is 1 (no parallel test execution). It cannot exceed the value of max-workers for the current build.
        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.
      • getFilter

        @Incubating
        public TestFilter getFilter()
        Allows filtering tests for execution.
        Returns:
        filter object
        Since:
        1.10