@Override public Configuration buildConfiguration() throws AnnotationRequired { AnnotationFinder finder = annotationFinder(); if (finder.isAnnotationPresent(UsingWeld.class)) { if (configuration == null) { return super.buildConfiguration(); } return configuration; } else { annotationMonitor().annotationNotFound(UsingWeld.class, annotatedClass()); } return super.buildConfiguration(); }
@Override public Configuration configuration() { return new MostUsefulConfiguration() .useStoryPathResolver(new StoryPathResolver() { @Override public String resolve(Class<? extends Embeddable> embeddableClass) { return "_stories/_my_Story.story"; } }) }
public GuiceAnnotationBuilder(Class<?> annotatedClass) { this(annotatedClass, new PrintStreamAnnotationMonitor()); }
@SuppressWarnings("unchecked") @Override public Configuration buildConfiguration() throws AnnotationRequired { if (annotationFinder().isAnnotationPresent(UsingGroovy.class)) { Class<GroovyClassLoader> classLoaderClass = annotationFinder().getAnnotatedValue(UsingGroovy.class, Class.class, "classLoader"); Class<GroovyResourceFinder> resourceFinderClass = annotationFinder().getAnnotatedValue(UsingGroovy.class, Class.class, "resourceFinder"); try { GroovyClassLoader classLoader = super.instanceOf(classLoaderClass, classLoaderClass); GroovyResourceFinder resourceFinder = super.instanceOf(resourceFinderClass, resourceFinderClass); context = createGroovyContext(classLoader, resourceFinder); } catch (Exception e) { annotationMonitor().elementCreationFailed(GroovyContext.class, e); } } else { annotationMonitor().annotationNotFound(UsingGroovy.class, annotatedClass()); } return super.buildConfiguration(); }
@Override public Configuration configuration() { return new MostUsefulConfiguration().useStoryLoader(new LoadFromClasspath(this.getClass())) .useFailureStrategy(new RethrowingFailure()).useStoryReporterBuilder(new StoryReporterBuilder() .withFormats(Format.HTML, Format.ANSI_CONSOLE).withFailureTrace(true)); }
private boolean isStep(String stepAsString) { Keywords keywords = configuration.keywords(); for (String stepStartingWord : keywords.startingWordsByType().values()) { if (keywords.stepStartsWithWord(stepAsString, stepStartingWord)) { return true; } } return false; }
private void addNonExistingStep(Description description, String stringStepOneLine, String stepAsString) { Keywords keywords = configuration.keywords(); if (keywords.isIgnorableStep(stepAsString)) { if (isStep(keywords.stepWithoutStartingWord(stepAsString, StepType.IGNORABLE))) { addIgnorableStep(description, stringStepOneLine); } } else { addPendingStep(description, stringStepOneLine); } }
private void createCandidateStepsWith(StepMonitor stepMonitor) { // reset step monitor and recreate candidate steps configuration.useStepMonitor(stepMonitor); getCandidateSteps(); for (CandidateSteps step : candidateSteps) { step.configuration().useStepMonitor(stepMonitor); } }
private void addNonExistingStep(Description description, String stringStepOneLine, String stringStep) { try { StepType stepType = configuration.keywords() .stepTypeFor(stringStep); if (stepType == StepType.IGNORABLE) { addIgnorableStep(description, stringStepOneLine); } else { addPendingStep(description, stringStepOneLine); } } catch (StartingWordNotFound e) { // WHAT NOW? } }
@Override protected <T, V extends T> T instanceOf(Class<T> type, Class<V> ofClass) { if (context != null) { try { return context.getInstanceOfType(type); } catch (Exception e) { // default to super class } } return super.instanceOf(type, ofClass); }
@Override public InjectableStepsFactory buildStepsFactory(Configuration configuration) { InjectableStepsFactory factoryUsingSteps = super.buildStepsFactory(configuration); if (stepsFactory != null) { return new CompositeStepsFactory(stepsFactory, factoryUsingSteps); } return factoryUsingSteps; } }
@Override protected <T, V extends T> T instanceOf(final Class<T> type, final Class<V> ofClass) { if (container != null) { T instance = null; try { instance = container.getComponent(type); } catch (AmbiguousComponentResolutionException e) { instance = container.getComponent(ofClass); } if ( instance != null ){ return instance; } } return super.instanceOf(type, ofClass); }
protected Configuration configuration() { return new MostUsefulConfiguration(); }
public WeldAnnotationBuilder(Class<?> annotatedClass) { this(annotatedClass, new PrintStreamAnnotationMonitor()); }
protected Configuration configuration() { return new MostUsefulConfiguration(); }
public class TraderStories extends JUnitStories { public TraderStories() { // configure as TraderStory except for Configuration configuration = new MostUsefulConfiguration() .useStoryLoader(new LoadFromURL()) } @Override protected List<String> storyPaths() { String codeLocation = codeLocationFromClass(this.getClass()).getFile(); return new StoryFinder().findPaths(codeLocation, asList("**/trader*.story"), asList(""), "file:"+codeLocation); }
public class Myclass extends JUnitStories { public Myclass(){ configuredEmbedder().useMetaFilters(Arrays.asList("-skip")); } @Override public Configuration configuration(){ return new MostUsefulConfiguration()... } }
new MostUsefulConfiguration() .useParameterControls(new ParameterControls().useDelimiterNamedParameters(true));