Um contêiner está rodando enquanto o **processo principal** (comando ou programa) estiver rodando.

Um contêiner normalmente tem um **único processo**, mas também é possível iniciar sub-processos a partir do processo principal, e dessa forma você terá **vários processos** no mesmo contêiner.

Mas não é possível ter um contêiner rodando sem **pelo menos um processo rodando**. Se o processo principal parar, o contêiner também para.

            public void run() {
                if (state != State.STARTED) {
                    throw new IllegalStateException("Test classes cannot be processed until a command to start processing has been received");
                }
                try {
                    processor.processTestClass(testClass);
                } catch (AccessControlException e) {
                    throw e;
                } finally {

     * This path is also used for annotation processor discovery. The classpath can be empty,
     * which means use the compile classpath; if you want to disable annotation processing,
     * then use {@code -proc:none} as a compiler argument.
     *
     * @return The annotation processor path. Never returns null.
     * @since 4.6
     */
    FileCollection getAnnotationProcessorPath();

        then: 1 * processor.started({ it.id == 2 && it.name == 'Gradle test' && it.className == null }, { it.parentId == 1 })
        then: 1 * processor.started({ it.id == 3 && it.name == 'ok' && it.className == ATestNGClass.name }, { it.parentId == 2 })
        then: 1 * processor.completed(3, { it.resultType == ResultType.SUCCESS })
        then: 1 * processor.completed(2, { it.resultType == null })

            // But we have to collect annotation processor dependencies, so these classes are correctly deleted, since annotation processor is able to output classes from these independent classes.
            classesToCompile = independentClasses.isEmpty()
                ? Collections.emptySet()

import org.codelibs.fess.crawler.exception.ChildUrlsException;
import org.codelibs.fess.crawler.exception.CrawlerSystemException;
import org.codelibs.fess.crawler.processor.ResponseProcessor;
import org.codelibs.fess.crawler.processor.impl.DefaultResponseProcessor;
import org.codelibs.fess.crawler.rule.Rule;
import org.codelibs.fess.crawler.rule.RuleManager;
import org.codelibs.fess.crawler.transformer.Transformer;

        1 * processor.started({ it.id == 3 && it.name == "ok" && it.className == ATestClassWithRunner.name }, { it.parentId == 1 })
        1 * processor.failure(2, CustomRunner.failure)
        1 * processor.completed(3, { it.resultType == null })
        1 * processor.completed(2, { it.resultType == null })
        1 * processor.completed(1, { it.resultType == null })
        0 * processor._
    }

        }
    }

    def "explicit -processor option overrides automatic detection"() {
        buildFile << """
            dependencies {
                compileOnly project(":annotation")
                annotationProcessor project(":processor")
            }
            compileJava.options.compilerArgs << "-processor" << "unknown.Processor"
        """

        expect:
        fails("compileJava")

        skipped(':compileJava')
        executedAndNotSkipped(':compileScala')
        new File(testDirectory, 'generated.txt').exists()
    }

    def "processes annotation for Java class with processor option if annotation processor is available on processor path"() {
        when:
        AnnotationProcessorPublisher annotationProcessorPublisher = new AnnotationProcessorPublisher()
        annotationProcessorPublisher.writeSourceFiles()

            processor.started(suiteDescriptor, suiteStartEvent)
            processor.started(testDescriptor, testStartEvent)
            processor.completed("test", finishEvent)
            processor.completed("suite", finishEvent)

            processor.started(suiteDescriptor, suiteStartEvent)
            processor.completed("suite", finishEvent)
        }
    }