Coverage Report - org.jbehave.core.embedder.Embedder
 
Classes in this File Line Coverage Branch Coverage Complexity
Embedder
87%
228/260
80%
77/96
1.923
Embedder$AnnotatedEmbedderRunFailed
100%
2/2
N/A
1.923
Embedder$EmbedderFailureStrategy
N/A
N/A
1.923
Embedder$RunningEmbeddablesFailed
100%
4/4
N/A
1.923
Embedder$RunningStoriesFailed
100%
4/4
N/A
1.923
Embedder$ThrowingRunningStoriesFailed
100%
3/3
N/A
1.923
Embedder$ViewGenerationFailed
50%
2/4
N/A
1.923
 
 1  
 package org.jbehave.core.embedder;
 2  
 
 3  
 import java.io.File;
 4  
 import java.util.ArrayList;
 5  
 import java.util.List;
 6  
 import java.util.Properties;
 7  
 import java.util.concurrent.ExecutorService;
 8  
 import java.util.concurrent.ThreadPoolExecutor;
 9  
 
 10  
 import org.apache.commons.lang.StringUtils;
 11  
 import org.apache.commons.lang.builder.ToStringBuilder;
 12  
 import org.apache.commons.lang.builder.ToStringStyle;
 13  
 import org.jbehave.core.ConfigurableEmbedder;
 14  
 import org.jbehave.core.Embeddable;
 15  
 import org.jbehave.core.configuration.Configuration;
 16  
 import org.jbehave.core.configuration.MostUsefulConfiguration;
 17  
 import org.jbehave.core.embedder.StoryTimeouts.TimeoutParser;
 18  
 import org.jbehave.core.embedder.executors.FixedThreadExecutors;
 19  
 import org.jbehave.core.failures.BatchFailures;
 20  
 import org.jbehave.core.failures.FailingUponPendingStep;
 21  
 import org.jbehave.core.junit.AnnotatedEmbedderRunner;
 22  
 import org.jbehave.core.junit.AnnotatedEmbedderUtils;
 23  
 import org.jbehave.core.model.Story;
 24  
 import org.jbehave.core.model.StoryMaps;
 25  
 import org.jbehave.core.reporters.ReportsCount;
 26  
 import org.jbehave.core.reporters.StepdocReporter;
 27  
 import org.jbehave.core.reporters.StoryReporterBuilder;
 28  
 import org.jbehave.core.reporters.ViewGenerator;
 29  
 import org.jbehave.core.steps.CandidateSteps;
 30  
 import org.jbehave.core.steps.InjectableStepsFactory;
 31  
 import org.jbehave.core.steps.ProvidedStepsFactory;
 32  
 import org.jbehave.core.steps.StepFinder;
 33  
 import org.jbehave.core.steps.Stepdoc;
 34  
 
 35  
 /**
 36  
  * The Embedder is a facade allowing all functionality to be embedded into other
 37  
  * run contexts, such as IDEs (e.g. via JUnit support) or CLIs (via Ant or
 38  
  * Maven).
 39  
  */
 40  
 public class Embedder {
 41  
 
 42  
         protected StoryMapper storyMapper;
 43  
         protected StoryRunner storyRunner;
 44  
         protected EmbedderMonitor embedderMonitor;
 45  
         protected EmbedderClassLoader classLoader;
 46  
         protected EmbedderControls embedderControls;
 47  
         protected EmbedderFailureStrategy embedderFailureStrategy;
 48  
     protected Configuration configuration;
 49  
     protected List<CandidateSteps> candidateSteps;
 50  
     protected InjectableStepsFactory stepsFactory;
 51  
     protected List<String> metaFilters;
 52  
     protected Properties systemProperties;
 53  
     protected ExecutorService executorService;
 54  
     protected boolean executorServiceCreated;
 55  
     protected PerformableTree performableTree;
 56  
     protected StoryManager storyManager;
 57  
     protected TimeoutParser[] timeoutParsers;
 58  
 
 59  
     public Embedder() {
 60  63
         this(new PrintStreamEmbedderMonitor());
 61  63
     }
 62  
 
 63  
     public Embedder(EmbedderMonitor embedderMonitor) {
 64  71
         this(new StoryMapper(), new PerformableTree(), embedderMonitor);
 65  71
     }
 66  
 
 67  100
     public Embedder(StoryMapper storyMapper, PerformableTree performableTree, EmbedderMonitor embedderMonitor) {
 68  100
         this.storyMapper = storyMapper;
 69  100
         this.performableTree = performableTree;
 70  100
         this.embedderMonitor = embedderMonitor;
 71  100
     }
 72  
 
 73  
     public void mapStoriesAsPaths(List<String> storyPaths) {
 74  1
         EmbedderControls embedderControls = embedderControls();
 75  1
         embedderMonitor.usingControls(embedderControls);
 76  
 
 77  1
         if (embedderControls.skip()) {
 78  0
             embedderMonitor.storiesSkipped(storyPaths);
 79  0
             return;
 80  
         }
 81  
 
 82  1
         processSystemProperties();
 83  
 
 84  1
         StoryManager storyManager = storyManager();
 85  1
         for (String storyPath : storyPaths) {
 86  2
             Story story = storyManager.storyOfPath(storyPath);
 87  2
             embedderMonitor.mappingStory(storyPath, metaFilters());
 88  2
             storyMapper.map(story, new MetaFilter(""));
 89  2
             for (String filter : metaFilters) {
 90  0
                 storyMapper.map(story, new MetaFilter(filter));
 91  0
             }
 92  2
         }
 93  
 
 94  1
         generateMapsView(storyMapper.getStoryMaps());
 95  
 
 96  1
     }
 97  
 
 98  
     private void generateMapsView(StoryMaps storyMaps) {
 99  1
         Configuration configuration = configuration();
 100  1
         StoryReporterBuilder builder = configuration.storyReporterBuilder();
 101  1
         File outputDirectory = builder.outputDirectory();
 102  1
         Properties viewResources = builder.viewResources();
 103  1
         ViewGenerator viewGenerator = configuration.viewGenerator();
 104  
         try {
 105  1
             embedderMonitor.generatingMapsView(outputDirectory, storyMaps, viewResources);
 106  1
             viewGenerator.generateMapsView(outputDirectory, storyMaps, viewResources);
 107  0
         } catch (RuntimeException e) {
 108  0
             embedderMonitor.mapsViewGenerationFailed(outputDirectory, storyMaps, viewResources, e);
 109  0
             throw new ViewGenerationFailed(outputDirectory, storyMaps, viewResources, e);
 110  1
         }
 111  1
     }
 112  
 
 113  
     public void runAsEmbeddables(List<String> classNames) {
 114  26
         EmbedderControls embedderControls = embedderControls();
 115  26
         embedderMonitor.usingControls(embedderControls);
 116  
 
 117  26
         if (embedderControls.skip()) {
 118  1
             embedderMonitor.embeddablesSkipped(classNames);
 119  1
             return;
 120  
         }
 121  
 
 122  25
         BatchFailures failures = new BatchFailures(embedderControls.verboseFailures());
 123  25
         for (Embeddable embeddable : embeddables(classNames, classLoader())) {
 124  31
             String name = embeddable.getClass().getName();
 125  
             try {
 126  31
                 embedderMonitor.runningEmbeddable(name);
 127  31
                 embeddable.useEmbedder(this);
 128  31
                 embeddable.run();
 129  13
             } catch (Throwable e) {
 130  13
                 if (embedderControls.batch()) {
 131  
                     // collect and postpone decision to throw exception
 132  2
                     failures.put(name, e);
 133  
                 } else {
 134  11
                     if (ignoreFailure(embedderControls)) {
 135  1
                         embedderMonitor.embeddableFailed(name, e);
 136  
                     } else {
 137  10
                         throw new RunningEmbeddablesFailed(name, e);
 138  
                     }
 139  
                 }
 140  18
             }
 141  21
         }
 142  
 
 143  15
         if (embedderControls.batch() && failures.size() > 0) {
 144  2
             if (ignoreFailure(embedderControls)) {
 145  1
                 embedderMonitor.batchFailed(failures);
 146  
             } else {
 147  1
                 throw new RunningEmbeddablesFailed(failures);
 148  
             }
 149  
         }
 150  
 
 151  14
     }
 152  
 
 153  
     private boolean ignoreFailure(EmbedderControls embedderControls) {
 154  13
         boolean ignore = embedderControls.ignoreFailureInStories();
 155  13
         if (embedderControls.generateViewAfterStories()) {
 156  13
             ignore = ignore && embedderControls.ignoreFailureInView();
 157  
         }
 158  13
         return ignore;
 159  
     }
 160  
 
 161  
     private List<Embeddable> embeddables(List<String> classNames, EmbedderClassLoader classLoader) {
 162  25
         List<Embeddable> embeddables = new ArrayList<Embeddable>();
 163  25
         for (String className : classNames) {
 164  33
             if (!classLoader.isAbstract(className)) {
 165  32
                 embeddables.add(classLoader.newInstance(Embeddable.class, className));
 166  
             }
 167  33
         }
 168  25
         return embeddables;
 169  
     }
 170  
 
 171  
     public void runStoriesWithAnnotatedEmbedderRunner(List<String> classNames) {
 172  4
         EmbedderClassLoader classLoader = classLoader();
 173  4
         for (String className : classNames) {
 174  4
             embedderMonitor.runningWithAnnotatedEmbedderRunner(className);
 175  4
             AnnotatedEmbedderRunner runner = AnnotatedEmbedderUtils.annotatedEmbedderRunner(className, classLoader);
 176  
             try {
 177  3
                 Object annotatedInstance = runner.createTest();
 178  3
                 if (annotatedInstance instanceof Embeddable) {
 179  2
                     ((Embeddable) annotatedInstance).run();
 180  
                 } else {
 181  1
                     embedderMonitor.annotatedInstanceNotOfType(annotatedInstance, Embeddable.class);
 182  
                 }
 183  1
             } catch (Throwable e) {
 184  1
                 throw new AnnotatedEmbedderRunFailed(runner, e);
 185  2
             }
 186  2
         }
 187  2
     }
 188  
 
 189  
     public void runStoriesAsPaths(List<String> storyPaths) {
 190  
 
 191  23
         processSystemProperties();
 192  
 
 193  23
         EmbedderControls embedderControls = embedderControls();
 194  
 
 195  23
         embedderMonitor.usingControls(embedderControls);
 196  
 
 197  23
         if (embedderControls.skip()) {
 198  1
             embedderMonitor.storiesSkipped(storyPaths);
 199  1
             return;
 200  
         }
 201  
 
 202  
         try {
 203  
 
 204  
             // set up run context
 205  22
             StoryManager storyManager = storyManager();
 206  22
             MetaFilter filter = metaFilter();
 207  22
             BatchFailures failures = new BatchFailures(embedderControls.verboseFailures());
 208  
 
 209  
             // run stories
 210  22
             storyManager.runStoriesAsPaths(storyPaths, filter, failures);
 211  
 
 212  
             // handle any failures
 213  16
             handleFailures(failures);
 214  
 
 215  
         } finally {
 216  
             // generate reports view regardless of failures in running stories
 217  
             // (if configured to do so)
 218  9
             try {
 219  22
                 if (embedderControls.generateViewAfterStories()) {
 220  21
                     generateReportsView();
 221  
                 }
 222  
             } finally {
 223  
                 // shutdown regardless of failures in reports view
 224  22
                 shutdownExecutorService();
 225  22
             }
 226  
 
 227  13
         }
 228  13
     }
 229  
 
 230  
     private void handleFailures(BatchFailures failures) {
 231  16
         if (failures.size() > 0) {
 232  3
             if (embedderControls().ignoreFailureInStories()) {
 233  0
                 embedderMonitor.batchFailed(failures);
 234  
             } else {
 235  3
                 embedderFailureStrategy().handleFailures(failures);
 236  
             }
 237  
         }
 238  13
     }
 239  
 
 240  
     public void generateReportsView() {
 241  21
         StoryReporterBuilder builder = configuration().storyReporterBuilder();
 242  21
         File outputDirectory = builder.outputDirectory();
 243  21
         List<String> formatNames = builder.formatNames(true);
 244  21
         generateReportsView(outputDirectory, formatNames, builder.viewResources());
 245  21
     }
 246  
 
 247  
     public void generateReportsView(File outputDirectory, List<String> formats, Properties viewResources) {
 248  
 
 249  30
         if (embedderControls().skip()) {
 250  1
             embedderMonitor.reportsViewNotGenerated();
 251  1
             return;
 252  
         }
 253  29
         ViewGenerator viewGenerator = configuration().viewGenerator();
 254  
         try {
 255  29
             embedderMonitor.generatingReportsView(outputDirectory, formats, viewResources);
 256  29
             viewGenerator.generateReportsView(outputDirectory, formats, viewResources);
 257  1
         } catch (RuntimeException e) {
 258  1
             embedderMonitor.reportsViewGenerationFailed(outputDirectory, formats, viewResources, e);
 259  1
             throw new ViewGenerationFailed(outputDirectory, formats, viewResources, e);
 260  28
         }
 261  28
         ReportsCount count = viewGenerator.getReportsCount();
 262  28
         embedderMonitor.reportsViewGenerated(count);
 263  28
         handleFailures(count);
 264  
 
 265  24
     }
 266  
 
 267  
     private void handleFailures(ReportsCount count) {
 268  28
         boolean failed = count.failed();
 269  28
         if (configuration().pendingStepStrategy() instanceof FailingUponPendingStep) {
 270  1
             failed = failed || count.pending();
 271  
         }
 272  28
         if (failed) {
 273  6
             if (embedderControls().ignoreFailureInView()) {
 274  1
                 embedderMonitor.reportsViewFailures(count);
 275  
             } else {
 276  5
                 embedderFailureStrategy().handleFailures(count);
 277  
             }
 278  
         }
 279  24
     }
 280  
 
 281  
     public void generateCrossReference() {
 282  18
         StoryReporterBuilder builder = configuration().storyReporterBuilder();
 283  18
         if (builder.hasCrossReference()) {
 284  17
             builder.crossReference().serialise(storyManager().performableRoot(), builder.outputDirectory());
 285  
         }
 286  18
     }
 287  
 
 288  
     public void reportStepdocs() {
 289  1
         reportStepdocs(configuration(), candidateSteps());
 290  1
     }
 291  
 
 292  
     public void reportStepdocsAsEmbeddables(List<String> classNames) {
 293  0
         EmbedderControls embedderControls = embedderControls();
 294  0
         if (embedderControls.skip()) {
 295  0
             embedderMonitor.embeddablesSkipped(classNames);
 296  0
             return;
 297  
         }
 298  
 
 299  0
         for (Embeddable embeddable : embeddables(classNames, classLoader())) {
 300  0
             if (embeddable instanceof ConfigurableEmbedder) {
 301  0
                 ConfigurableEmbedder configurableEmbedder = (ConfigurableEmbedder) embeddable;
 302  0
                                 Embedder configuredEmbedder = configurableEmbedder.configuredEmbedder();
 303  0
                                 List<CandidateSteps> steps = configuredEmbedder.candidateSteps();
 304  0
                 if (steps.isEmpty()) {
 305  0
                     steps = configuredEmbedder.stepsFactory().createCandidateSteps();
 306  
                 }
 307  0
                 reportStepdocs(configuredEmbedder.configuration(), steps);
 308  0
             } else {
 309  0
                 embedderMonitor.embeddableNotConfigurable(embeddable.getClass().getName());
 310  
             }
 311  0
         }
 312  0
     }
 313  
 
 314  
     public void reportStepdocs(Configuration configuration, List<CandidateSteps> candidateSteps) {
 315  1
         StepFinder finder = configuration.stepFinder();
 316  1
         StepdocReporter reporter = configuration.stepdocReporter();
 317  1
         List<Object> stepsInstances = finder.stepsInstances(candidateSteps);
 318  1
         reporter.stepdocs(finder.stepdocs(candidateSteps), stepsInstances);
 319  1
     }
 320  
 
 321  
     public void reportMatchingStepdocs(String stepAsString) {
 322  3
         Configuration configuration = configuration();
 323  3
         List<CandidateSteps> candidateSteps = candidateSteps();
 324  3
         StepFinder finder = configuration.stepFinder();
 325  3
         StepdocReporter reporter = configuration.stepdocReporter();
 326  3
         List<Stepdoc> matching = finder.findMatching(stepAsString, candidateSteps);
 327  3
         List<Object> stepsInstances = finder.stepsInstances(candidateSteps);
 328  3
         reporter.stepdocsMatching(stepAsString, matching, stepsInstances);
 329  3
     }
 330  
 
 331  
     public void processSystemProperties() {
 332  26
         Properties properties = systemProperties();
 333  26
         embedderMonitor.processingSystemProperties(properties);
 334  26
         if (!properties.isEmpty()) {
 335  1
             for (Object key : properties.keySet()) {
 336  2
                 String name = (String) key;
 337  2
                 String value = properties.getProperty(name);
 338  2
                 System.setProperty(name, value);
 339  2
                 embedderMonitor.systemPropertySet(name, value);
 340  2
             }
 341  
         }
 342  26
     }
 343  
 
 344  
     public EmbedderClassLoader classLoader() {
 345  29
         if (classLoader == null) {
 346  16
             this.classLoader = new EmbedderClassLoader(this.getClass().getClassLoader());
 347  
         }
 348  29
         return classLoader;
 349  
     }
 350  
 
 351  
     public Configuration configuration() {
 352  161
         if (configuration == null) {
 353  22
             this.configuration = new MostUsefulConfiguration();
 354  
         }
 355  161
         configureThreads(configuration, embedderControls().threads());
 356  161
         return configuration;
 357  
     }
 358  
 
 359  
     public List<CandidateSteps> candidateSteps() {
 360  18
         if (candidateSteps == null) {
 361  10
             candidateSteps = new ArrayList<CandidateSteps>();
 362  
         }
 363  18
         return candidateSteps;
 364  
     }
 365  
 
 366  
     public InjectableStepsFactory stepsFactory() {
 367  35
         if (stepsFactory == null) {
 368  10
             stepsFactory = new ProvidedStepsFactory(candidateSteps());
 369  
         }
 370  35
         return stepsFactory;
 371  
     }
 372  
 
 373  
     public EmbedderControls embedderControls() {
 374  325
         if (embedderControls == null) {
 375  32
             embedderControls = new EmbedderControls();
 376  
         }
 377  325
         return embedderControls;
 378  
     }
 379  
 
 380  
     public EmbedderMonitor embedderMonitor() {
 381  26
         return embedderMonitor;
 382  
     }
 383  
 
 384  
     public EmbedderFailureStrategy embedderFailureStrategy() {
 385  8
         if (embedderFailureStrategy == null) {
 386  7
             this.embedderFailureStrategy = new ThrowingRunningStoriesFailed();
 387  
         }
 388  8
         return embedderFailureStrategy;
 389  
     }
 390  
 
 391  
     public boolean hasExecutorService() {
 392  1
         return executorService != null;
 393  
     }
 394  
 
 395  
     public ExecutorService executorService() {
 396  24
         if (executorService == null) {
 397  24
             executorService = createExecutorService();
 398  24
             executorServiceCreated = true;
 399  
         }
 400  24
         return executorService;
 401  
     }
 402  
 
 403  
     /**
 404  
      * Creates a {@link ThreadPoolExecutor} using the number of threads defined
 405  
      * in the {@link EmbedderControls#threads()}
 406  
      * 
 407  
      * @return An ExecutorService
 408  
      */
 409  
     private ExecutorService createExecutorService() {
 410  24
         return new FixedThreadExecutors().create(embedderControls());
 411  
     }
 412  
 
 413  
     /**
 414  
      * Shuts down executor service, if it was created by Embedder.
 415  
      * ExecutorServices provided by the
 416  
      * {@link #useExecutorService(ExecutorService)} need to be managed by the
 417  
      * provider.
 418  
      */
 419  
     protected void shutdownExecutorService() {
 420  22
         if (executorServiceCreated) {
 421  22
             executorService.shutdownNow();
 422  22
             executorService = null;
 423  22
             executorServiceCreated = false;
 424  
         }
 425  22
     }
 426  
 
 427  
     public StoryManager storyManager() {
 428  40
         if (storyManager == null) {
 429  24
             storyManager = createStoryManager();
 430  
         }
 431  40
         return storyManager;
 432  
     }
 433  
 
 434  
     private StoryManager createStoryManager() {
 435  24
         return new StoryManager(configuration(), stepsFactory(), embedderControls(), embedderMonitor(),
 436  24
                 executorService(), performableTree(), timeoutParsers());
 437  
     }
 438  
 
 439  
     protected void configureThreads(Configuration configuration, int threads) {
 440  161
         StoryReporterBuilder reporterBuilder = configuration.storyReporterBuilder();
 441  161
         reporterBuilder.withMultiThreading(threads > 1);
 442  161
         configuration.useStoryReporterBuilder(reporterBuilder);
 443  161
     }
 444  
 
 445  
     public List<String> metaFilters() {
 446  34
         if (metaFilters == null) {
 447  24
             metaFilters = new ArrayList<String>();
 448  
         }
 449  34
         return metaFilters;
 450  
     }
 451  
 
 452  
     public MetaFilter metaFilter() {
 453  28
         return new MetaFilter(StringUtils.join(metaFilters(), " "), embedderMonitor);
 454  
     }
 455  
 
 456  
     public StoryRunner storyRunner() {
 457  0
         return storyRunner;
 458  
     }
 459  
 
 460  
     public PerformableTree performableTree() {
 461  26
         return performableTree;
 462  
     }
 463  
 
 464  
     public Properties systemProperties() {
 465  29
         if (systemProperties == null) {
 466  25
             systemProperties = new Properties();
 467  
         }
 468  29
         return systemProperties;
 469  
     }
 470  
     
 471  
     public TimeoutParser[] timeoutParsers(){
 472  24
             if (timeoutParsers == null){
 473  24
                     timeoutParsers = new TimeoutParser[]{};
 474  
             }
 475  24
             return timeoutParsers;
 476  
     }
 477  
 
 478  
     public void useClassLoader(EmbedderClassLoader classLoader) {
 479  14
         this.classLoader = classLoader;
 480  14
     }
 481  
 
 482  
     public void useConfiguration(Configuration configuration) {
 483  33
         this.configuration = configuration;
 484  33
     }
 485  
 
 486  
     public void useCandidateSteps(List<CandidateSteps> candidateSteps) {
 487  26
         this.candidateSteps = candidateSteps;
 488  26
     }
 489  
 
 490  
     public void useStepsFactory(InjectableStepsFactory stepsFactory) {
 491  26
                 this.stepsFactory = stepsFactory;
 492  26
     }
 493  
 
 494  
     public void useEmbedderControls(EmbedderControls embedderControls) {
 495  29
         this.embedderControls = embedderControls;
 496  29
     }
 497  
 
 498  
     public void useEmbedderFailureStrategy(EmbedderFailureStrategy failureStategy) {
 499  1
         this.embedderFailureStrategy = failureStategy;
 500  1
     }
 501  
 
 502  
     public void useEmbedderMonitor(EmbedderMonitor embedderMonitor) {
 503  1
         this.embedderMonitor = embedderMonitor;
 504  1
     }
 505  
 
 506  
     public void useExecutorService(ExecutorService executorService) {
 507  0
         this.executorService = executorService;
 508  0
         embedderMonitor.usingExecutorService(executorService);
 509  0
     }
 510  
 
 511  
     public void useMetaFilters(List<String> metaFilters) {
 512  4
         this.metaFilters = metaFilters;
 513  4
     }
 514  
 
 515  
     public void usePerformableTree(PerformableTree performableTree) {
 516  1
         this.performableTree = performableTree;
 517  1
     }
 518  
 
 519  
     public void useStoryRunner(StoryRunner storyRunner) {
 520  0
         this.storyRunner = storyRunner;
 521  0
     }
 522  
 
 523  
     public void useSystemProperties(Properties systemProperties) {
 524  2
         this.systemProperties = systemProperties;
 525  2
     }
 526  
 
 527  
     public void useTimeoutParsers(TimeoutParser... timeoutParsers){
 528  0
                 this.timeoutParsers = timeoutParsers;            
 529  0
     }
 530  
     
 531  
     @Override
 532  
     public String toString() {
 533  1
         return ToStringBuilder.reflectionToString(this, ToStringStyle.SHORT_PREFIX_STYLE);
 534  
     }
 535  
 
 536  
     public static interface EmbedderFailureStrategy {
 537  
 
 538  
         void handleFailures(BatchFailures failures);
 539  
 
 540  
         void handleFailures(ReportsCount count);
 541  
 
 542  
     }
 543  
 
 544  7
     public static class ThrowingRunningStoriesFailed implements EmbedderFailureStrategy {
 545  
 
 546  
         public void handleFailures(BatchFailures failures) {
 547  3
             throw new RunningStoriesFailed(failures);
 548  
         }
 549  
 
 550  
         public void handleFailures(ReportsCount count) {
 551  4
             throw new RunningStoriesFailed(count);
 552  
         }
 553  
 
 554  
     }
 555  
 
 556  
     @SuppressWarnings("serial")
 557  
     public static class AnnotatedEmbedderRunFailed extends RuntimeException {
 558  
 
 559  
         public AnnotatedEmbedderRunFailed(AnnotatedEmbedderRunner runner, Throwable cause) {
 560  1
             super("Annotated embedder run failed with runner " + runner.toString(), cause);
 561  1
         }
 562  
 
 563  
     }
 564  
 
 565  
     @SuppressWarnings("serial")
 566  
     public static class RunningEmbeddablesFailed extends RuntimeException {
 567  
 
 568  
         public RunningEmbeddablesFailed(String name, Throwable failure) {
 569  10
             super("Failure in running embeddable: " + name, failure);
 570  10
         }
 571  
 
 572  
         public RunningEmbeddablesFailed(BatchFailures failures) {
 573  1
             super("Failures in running embeddables: " + failures);
 574  1
         }
 575  
 
 576  
     }
 577  
 
 578  
     @SuppressWarnings("serial")
 579  
     public static class RunningStoriesFailed extends RuntimeException {
 580  
 
 581  
         public RunningStoriesFailed(ReportsCount reportsCount) {
 582  4
             super("Failures in running stories: " + reportsCount);
 583  4
         }
 584  
 
 585  
         public RunningStoriesFailed(BatchFailures failures) {
 586  3
             super("Failures in running stories: " + failures);
 587  3
         }
 588  
 
 589  
     }
 590  
 
 591  
     @SuppressWarnings("serial")
 592  
     public static class ViewGenerationFailed extends RuntimeException {
 593  
         public ViewGenerationFailed(File outputDirectory, List<String> formats, Properties viewResources,
 594  
                 RuntimeException cause) {
 595  1
             super("View generation failed to " + outputDirectory + " for formats " + formats + " and resources "
 596  
                     + viewResources, cause);
 597  1
         }
 598  
 
 599  
         public ViewGenerationFailed(File outputDirectory, StoryMaps storyMaps, Properties viewResources,
 600  
                 RuntimeException cause) {
 601  0
             super("View generation failed to " + outputDirectory + " for story maps " + storyMaps + " for resources "
 602  
                     + viewResources, cause);
 603  0
         }
 604  
     }
 605  
 
 606  
 
 607  
 }