Coverage Report - org.jbehave.core.embedder.EmbedderMonitorDecorator
 
Classes in this File Line Coverage Branch Coverage Complexity
EmbedderMonitorDecorator
77%
55/71
N/A
1
 
 1  
 package org.jbehave.core.embedder;
 2  
 
 3  
 import java.io.File;
 4  
 import java.util.List;
 5  
 import java.util.Properties;
 6  
 import java.util.concurrent.ExecutorService;
 7  
 
 8  
 import org.jbehave.core.failures.BatchFailures;
 9  
 import org.jbehave.core.model.Meta;
 10  
 import org.jbehave.core.model.Scenario;
 11  
 import org.jbehave.core.model.Story;
 12  
 import org.jbehave.core.model.StoryDuration;
 13  
 import org.jbehave.core.model.StoryMaps;
 14  
 import org.jbehave.core.reporters.ReportsCount;
 15  
 
 16  
 /**
 17  
  * Decorator of EmbedderMonitor that delegates to an injected instance and
 18  
  * allows classes extending it to override only the methods that are needed.
 19  
  */
 20  
 public class EmbedderMonitorDecorator implements EmbedderMonitor {
 21  
 
 22  
     private final EmbedderMonitor delegate;
 23  
 
 24  1
     public EmbedderMonitorDecorator(EmbedderMonitor delegate) {
 25  1
         this.delegate = delegate;
 26  1
     }
 27  
 
 28  
     public void runningEmbeddable(String name) {
 29  1
         delegate.runningEmbeddable(name);
 30  1
     }
 31  
 
 32  
     public void embeddableFailed(String name, Throwable cause) {
 33  1
         delegate.embeddableFailed(name, cause);
 34  1
     }
 35  
 
 36  
     public void embeddableNotConfigurable(String name) {
 37  1
         delegate.embeddableNotConfigurable(name);
 38  1
     }
 39  
 
 40  
     public void embeddablesSkipped(List<String> classNames) {
 41  1
         delegate.embeddablesSkipped(classNames);
 42  1
     }
 43  
 
 44  
     public void metaNotAllowed(Meta meta, MetaFilter filter) {
 45  1
         delegate.metaNotAllowed(meta, filter);
 46  1
     }
 47  
 
 48  
     public void runningStory(String path) {
 49  1
         delegate.runningStory(path);
 50  1
     }
 51  
 
 52  
     public void storyFailed(String path, Throwable cause) {
 53  1
         delegate.storyFailed(path, cause);
 54  1
     }
 55  
 
 56  
     public void storiesSkipped(List<String> storyPaths) {
 57  1
         delegate.storiesSkipped(storyPaths);
 58  1
     }
 59  
 
 60  
     public void storiesNotAllowed(List<Story> notAllowed, MetaFilter filter) {
 61  0
         delegate.storiesNotAllowed(notAllowed, filter);
 62  0
     }
 63  
 
 64  
     public void storiesNotAllowed(List<Story> stories, MetaFilter filter, boolean verbose) {
 65  0
         delegate.storiesNotAllowed(stories, filter, verbose);
 66  0
      }
 67  
 
 68  
         public void scenarioNotAllowed(Scenario scenario, MetaFilter filter) {
 69  0
                 delegate.scenarioNotAllowed(scenario, filter);
 70  0
         }
 71  
 
 72  
     public void batchFailed(BatchFailures failures) {
 73  1
         delegate.batchFailed(failures);
 74  1
     }
 75  
     
 76  
     public void beforeOrAfterStoriesFailed() {
 77  1
         delegate.beforeOrAfterStoriesFailed();
 78  1
     }
 79  
 
 80  
     public void generatingReportsView(File outputDirectory, List<String> formats, Properties viewProperties) {
 81  1
         delegate.generatingReportsView(outputDirectory, formats, viewProperties);
 82  1
     }
 83  
 
 84  
     public void reportsViewGenerationFailed(File outputDirectory, List<String> formats, Properties viewProperties,
 85  
             Throwable cause) {
 86  1
         delegate.reportsViewGenerationFailed(outputDirectory, formats, viewProperties, cause);
 87  1
     }
 88  
 
 89  
     public void reportsViewGenerated(ReportsCount count) {
 90  1
         delegate.reportsViewGenerated(count);
 91  1
     }
 92  
 
 93  
     public void reportsViewFailures(ReportsCount count) {
 94  0
         delegate.reportsViewFailures(count);
 95  0
     }
 96  
 
 97  
     public void reportsViewNotGenerated() {
 98  1
         delegate.reportsViewNotGenerated();
 99  1
     }
 100  
     
 101  
     public void runningWithAnnotatedEmbedderRunner(String className) {
 102  1
         delegate.runningWithAnnotatedEmbedderRunner(className);
 103  1
     }
 104  
 
 105  
     public void annotatedInstanceNotOfType(Object annotatedInstance, Class<?> type) {
 106  1
         delegate.annotatedInstanceNotOfType(annotatedInstance, type);
 107  1
     }
 108  
 
 109  
     public void mappingStory(String storyPath, List<String> metaFilters) {
 110  1
         delegate.mappingStory(storyPath, metaFilters);
 111  1
     }
 112  
 
 113  
     public void generatingMapsView(File outputDirectory, StoryMaps storyMaps, Properties viewProperties) {
 114  1
         delegate.generatingMapsView(outputDirectory, storyMaps, viewProperties);
 115  1
     }
 116  
 
 117  
     public void mapsViewGenerationFailed(File outputDirectory, StoryMaps storyMaps, Properties viewProperties,
 118  
             Throwable cause) {
 119  1
         delegate.mapsViewGenerationFailed(outputDirectory, storyMaps, viewProperties, cause);
 120  1
     }
 121  
 
 122  
     public void generatingNavigatorView(File outputDirectory, Properties viewResources) {
 123  1
         delegate.generatingNavigatorView(outputDirectory, viewResources);
 124  1
     }
 125  
 
 126  
     public void navigatorViewGenerationFailed(File outputDirectory, Properties viewResources, Throwable cause) {
 127  1
         delegate.navigatorViewGenerationFailed(outputDirectory, viewResources, cause);
 128  1
     }
 129  
 
 130  
     public void navigatorViewNotGenerated() {
 131  1
         delegate.navigatorViewNotGenerated();        
 132  1
     }
 133  
 
 134  
     public void processingSystemProperties(Properties properties) {
 135  1
         delegate.processingSystemProperties(properties);
 136  1
     }
 137  
 
 138  
     public void systemPropertySet(String name, String value) {
 139  1
         delegate.systemPropertySet(name, value);
 140  1
     }
 141  
     
 142  
     public void storyTimeout(Story story, StoryDuration storyDuration) {
 143  1
         delegate.storyTimeout(story, storyDuration);
 144  1
     }
 145  
 
 146  
     public void usingThreads(int threads) {
 147  1
         delegate.usingThreads(threads);
 148  1
     }
 149  
 
 150  
     public void usingExecutorService(ExecutorService executorService) {
 151  0
         delegate.usingExecutorService(executorService);
 152  0
     }
 153  
 
 154  
     public void usingControls(EmbedderControls embedderControls) {
 155  0
         delegate.usingControls(embedderControls);        
 156  0
     }
 157  
 
 158  
         public void invalidTimeoutFormat(String path) {
 159  0
                 delegate.invalidTimeoutFormat(path);
 160  0
         }
 161  
 
 162  
         public void usingTimeout(String path, long timeout) {
 163  0
                 delegate.usingTimeout(path, timeout);
 164  0
         }
 165  
 
 166  
 }