import org.jboss.arquillian.core.api.Event; //导入依赖的package包/类
public boolean decide(org.jboss.arquillian.core.spi.event.Event event, TestResult testResult) {

            boolean taking = false;

            for (final RecorderStrategy<?> recorderStrategy : recorderStrategyRegister.getAll()) {
                if (recorderStrategy instanceof AnnotationScreenshootingStrategy && !hasScreenshotAnnotation(event)) {
                    continue;
                }
                if (testResult == null) {
                    taking = recorderStrategy.isTakingAction(event);
                } else {
                    taking = recorderStrategy.isTakingAction(event, testResult);
                }
            }

            return taking;
        }
 

import org.jboss.arquillian.core.api.Event; //导入依赖的package包/类
private boolean hasScreenshotAnnotation(org.jboss.arquillian.core.spi.event.Event event) {
    if (event instanceof Before) {
        return ScreenshotAnnotationScanner.getScreenshotAnnotation(((Before) event).getTestMethod()) != null;
    } else if (event instanceof AfterTestLifecycleEvent) {
        return ScreenshotAnnotationScanner
            .getScreenshotAnnotation(((AfterTestLifecycleEvent) event).getTestMethod()) != null;
    }
    return false;
}
 

import org.jboss.arquillian.core.api.Event; //导入依赖的package包/类
private void report(org.jboss.arquillian.core.spi.event.Event event, ArquillianDescriptor descriptor) {
    if (shouldReport(event, configuration.get().getReportAfterEvery())) {
        List<ExtensionReport> extensionReports = reporter.get().getReport().getExtensionReports();
        if (extensionReports.isEmpty()) {
            extensionReports.addAll(getExtensionReports(descriptor));
        }

        reporter.get().getLastTestClassReport().setStop(new Date(System.currentTimeMillis()));
        reporter.get().getLastTestSuiteReport().setStop(new Date(System.currentTimeMillis()));

        exportReportEvent.fire(new ExportReport(reporter.get().getReport()));
    }
}
 

import org.jboss.arquillian.core.api.Event; //导入依赖的package包/类
private boolean shouldReport(org.jboss.arquillian.core.spi.event.Event event, String frequency) {
    if (event instanceof AfterClass && ReportFrequency.CLASS.toString().equals(frequency)
            || (event instanceof After && ReportFrequency.METHOD.toString().equals(frequency)) ) {
        return true;
    }
    return false;
}
 

import org.jboss.arquillian.core.api.Event; //导入依赖的package包/类
@Override
public SECTIONTYPE fire(Event<SectionEvent> injectedSectionEvent) {
    sectionEvent.setReport(report);
    injectedSectionEvent.fire(sectionEvent);
    return sectionEvent;
}
 

import org.jboss.arquillian.core.api.Event; //导入依赖的package包/类
public void setPropertyReportEvent(Event<PropertyReportEvent> propertyReportEvent) {
    this.propertyReportEvent = propertyReportEvent;
}
 

import org.jboss.arquillian.core.api.Event; //导入依赖的package包/类
public TakeResponse(Event<SectionEvent> reportEvent, ReporterConfiguration reporterConfiguration) {
    this.reportEvent = reportEvent;
    this.reporterConfiguration = reporterConfiguration;
}
 

import org.jboss.arquillian.core.api.Event; //导入依赖的package包/类
public TakeRequest(Event<SectionEvent> reportEvent, ReporterConfiguration reporterConfiguration) {
    this.reportEvent = reportEvent;
    this.reporterConfiguration = reporterConfiguration;
}
 

import org.jboss.arquillian.core.api.Event; //导入依赖的package包/类
@Override
public Statement apply(Statement base, Description description) {
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {

            List<Throwable> errors = new ArrayList<>();

            // Inject Arquillian resources
            container = containerBuilder.build();
            final Optional<Field> hostIpContextField = Reflections.findFieldByGenericType(Container.class, Instance.class, HostIpContext.class);

            if (hostIpContextField.isPresent()) {
                Reflections.injectObject(container, hostIpContextField.get(), (Instance) () -> new HostIpContext(dockerClientExecutor.getDockerServerIp()));
            }

            final Optional<Field> dockerClientExecutorField = Reflections.findFieldByGenericType(Container.class, Instance.class, DockerClientExecutor.class);

            if (dockerClientExecutorField.isPresent()) {
                Reflections.injectObject(container, dockerClientExecutorField.get(), (Instance) () -> dockerClientExecutor);
            }

            DockerCube dockerCube = new DockerCube(container.getContainerName(), container.getCubeContainer(), dockerClientExecutor);
            LocalCubeRegistry localCubeRegistry = new LocalCubeRegistry();
            localCubeRegistry.addCube(dockerCube);

            final Optional<Field> cubeRegistryField = Reflections.findFieldByGenericType(Container.class, Instance.class, CubeRegistry.class);

            if (cubeRegistryField.isPresent()) {
                Reflections.injectObject(container, cubeRegistryField.get(), (Instance) () -> localCubeRegistry);
            }

            final Optional<Field> eventField = Reflections.findFieldByGenericType(DockerCube.class, Event.class, CubeLifecyleEvent.class);

            if (eventField.isPresent()) {
                Reflections.injectObject(dockerCube, eventField.get(), (Event) o -> {
                });
            }


            try {
                dockerCube.create();
                dockerCube.start();

                systemPropertiesCubeSetter.createCubeSystemProperties(new AfterStart(dockerCube.getId()), localCubeRegistry);

                // Run tests
                base.evaluate();

            } catch (Throwable t) {
                errors.add(t);
            } finally {
                // stop container
                dockerCube.stop();
                dockerCube.destroy();

                systemPropertiesCubeSetter.removeCubeSystemProperties(new AfterDestroy(dockerCube.getId()));
                systemPropertiesCubeSetter.removeDockerHostProperty(new AfterSuite());
            }

            MultipleFailureException.assertEmpty(errors);

        }
    };
}
 

import org.jboss.arquillian.core.api.Event; //导入依赖的package包/类
/**
 * Fire an arquillian {@link SectionEvent} that was set in previous step
 *
 * @param injectedSectionEvent A {@link Event<SectionEvent>} to be used for firing
 * @return The fired {@link SectionEvent} that was set in previous step
 */
SECTIONTYPE fire(Event<SectionEvent> injectedSectionEvent);