All Classes and Interfaces
Class
Description
PathCalculator that returns the path providedRepresents the possible step results:
Failed
NotPerformed
Pending
Successful
Ignorable
Skipped
An abstract implementation of
InjectableStepsFactory that is provided
by concrete subclasses Object instances which contain the candidate steps
methods.A JUnit
Runner that uses the AnnotationBuilder to
create an embeddable test instance.A JUnit
Runner that uses a UsingPaths annotation to specify
which story paths to run and uses the RunNotifier to provide a
Description for each.Helper class to find and retrieve annotated values
Thrown when an annotation is required and not found.
Story reporter that outputs as ANSI-coded text to System.out.
Thrown when methods, annotated with before or after annotations (story or scenario),
fail.
A BeforeOrAfterStep is associated to a Java method annotated with
BeforeStory, AfterStory, BeforeScenario or
AfterScenario in a CandidateSteps instance class.
Resolves story paths while preserving the Java class case, e.g.:
"org.jbehave.core.ICanLogin.java" -> "org/jbehave/core/ICanLogin.story".
Implementation of Row that chains delegate Rows in resolving requests for
values.
Collection of utility methods to create code location URLs
Represents a composite step, which can be declared both programmatically, via the
@Composite annotation, or via a textual representation.
Parses the composite steps from their textual representation.
An
InjectableStepsFactory that composes CandidateSteps
created from other factories.When running a multithreading mode, reports cannot be written concurrently but should
be delayed and invoked only at the end of a story, ensuring synchronization on the delegate
responsible for the reporting.
Indicates that the step should be performed only if the specified condition is met.
Abstract implementation of
Embeddable which extends InjectableEmbedder
to allow the configuration using the Configuration and
the InjectableStepsFactory specified.
Provides the configuration used by the
Embedder and the in the
Embeddable implementations to customise its runtime properties.
Story reporter that outputs as TXT to System.out.
Holds context-related information
Decorator of
StepMonitor which shows the current context via the
ContextView.ContextView allows the viewing of context-related messages.
Implementation of Parameters that uses
ParameterConverters to convert
values.Monitor which collects other
EmbedderMonitors and delegates all invocations to the collected monitors.Monitor which collects other
StepMonitors and delegates all invocations to the collected monitors.Reporter which collects other
StoryReporters and delegates all
invocations to the collected reporters.Monitor which collects other
TableTransformerMonitor-s and delegates all
invocations to the collected monitors.Creates instances of
MoreExecutors.newDirectExecutorService().
Represents a runnable facade to the
Embedder.The Embedder is a facade allowing all functionality to be embedded into other
run contexts, such as IDEs (e.g.
EmbedderClassLoader is a URLClassLoader with a specified list of classpath
elements.
Holds values used by the Embedder to control execution flow.
Deprecated.
Represents a tabular structure that holds rows of example data for parameters named via the column headers:
Factory that creates instances of ExamplesTable from different type of
inputs:
table text input, i.e.
FailureStrategy allows to define failure handling strategies.
Creates
PrintStream instances that write to a file identified by the
StoryLocation.Resolves directory from code location parent file.
Configuration class for file print streams.
Resolves story location path to java packaged name, replacing '/' with '.'
Resolves story location path to simple name, considering portion after last '/'.
Creates instances of
Executors.newFixedThreadPool(int).A Format is a
StoryReporter factory, allowing named-based pre-defined
story reporters to be configured via the
StoryReporterBuilder.withFormats(Format...) method.Freemarker-based
ViewGenerator, which uses the configured FTL templates for the views.
Story reporter that outputs to a PrintStream, as HTML.
A templateable output that generates HTML.
Outputs to the console only if running in an IDE.
Runtime exception thrown to indicate that the current and following steps should be ignored
Abstract implementation of
Embeddable which allows to inject
the Embedder used to run the story or stories.Interface abstracting the creation of
CandidateSteps.An
InjectableStepsFactory that is provided Object instances.Thrown when a story resource is not valid
Find all matching file entries in a jar.
Story reporter that outputs to a PrintStream, as JSON.
A templateable output that generates JSON.
JUnit-runnable entry-point to run multiple stories specified by
JupiterStories.storyPaths().
JUnit-runnable entry-point to run a single story using the configured
StoryPathResolver
to resolve the story path from the instance class name.
JUnit-runnable entry-point to map stories specified by
JupiterStories.storyPaths(),
using the meta filters specified by JUnitStoryMaps.metaFilters().
Jupiter-runnable entry-point to run multiple stories specified by
JupiterStories.storyPaths().Provides the keywords which allow parsers to find steps in stories and match
those steps with candidates through the annotations.
Runtime exception thrown to indicate the occurrence of a known failure.
Loads story resources from classpath
Loads story resources from relative file paths that are traversal to a given location.
For use the the varargs constructor of
LoadFromRelativeFile, to
allow a range of possibilities for locating Story file pathsLoads story resources from URL
Adds i18n support to Keywords, allowing to read the keywords from resource
bundles for a given locale.
StepCollector that marks unmatched steps as
AbstractStepResult.Pending.
Allows filtering on meta info.
The configuration that works for most situations that users are likely to encounter.
Null Object
Pattern implementation of
AnnotationMonitor.Null Object
Pattern implementation of
EmbedderMonitor.Null Object Pattern
implementation of
ExpressionResolverMonitor.Null Object Pattern implementation of
StepMonitor.
Null-object implementation of
StoryReporter.Null Object Pattern implementation of
TableTransformerMonitor.Represents a tabular structure that holds
OutcomesTable.Outcomes to be verified by invoking method OutcomesTable.verify().
Facade responsible for converting parameter values to Java objects.
Parses value to a
Date using an injectable DateFormat
(defaults to new SimpleDateFormat("dd/MM/yyyy"))Parses value to any
EnumParses value to list of the same
Enum, using an injectable value
separator (defaults to ",") and trimming each element of the list.Converts value to
ExamplesTable using a
ExamplesTableFactory.Converts ExamplesTable to list of parameters, mapped to annotated custom
types.
An
ParameterConverters.EnumConverter allowing stories prose to be more natural.Invokes method on instance to return value.
Converts values to numbers, supporting any subclass of
Number (including generic Number type), and it
unboxed counterpart, using a NumberFormat to parse to a Number and to convert it to a specific
number type:
Byte, byte: Number.byteValue()
Short, short: Number.shortValue()
Integer, int: Number.intValue()
Float, float: Number.floatValue()
Long, long: Number.longValue()
Double, double: Number.doubleValue()
BigInteger: BigInteger.valueOf(long)
BigDecimal: BigDecimal.valueOf(double)
If no number format is provided, it defaults to NumberFormat.getInstance().Converts value to list of numbers.
A parameter converter for generic type of source input and target output.
Converts value to list of String.
Provides parameter values as given types
The configuration that uses:
Paranamer: CachingParanamer
Calculates the paths to given stories.
Builds a set of pattern variants of given pattern input, supporting a custom
directives.
Thrown when a pending step is found
Thrown when a pending step is found
PendingStepStrategy allows to define how pending steps are handled.
Creates a tree of
PerformableTree.Performable objects for a set of stories, grouping
sets of performable steps for each story and scenario, and adding before and
after stories steps.The context for running a story.
Reporter that collects statistics and writes them as properties to output
stream after each story
Abstract monitor that reports to output which should be defined in child implementations.
Abstract monitor that reports to output which should be defined in child implementations.
Abstract
StepMonitor that prints to output which should be defined in child implementations.Monitor that reports to a
PrintStream, defaulting to System.outMonitor that reports to a
PrintStream, defaulting to System.outMonitor that reports to a
PrintStream, defaulting to System.outCreates
PrintStream instances.
Abstract story reporter that outputs to a PrintStream.
StepMonitor that prints to a
PrintStream, defaulting to System.out.PropertyBasedConfiguration is backed by MostUsefulConfiguration as default,
but has different behaviour if certain system properties are set:
PropertyBasedConfiguration.FAIL_ON_PENDING: uses FailingUponPendingStep
PropertyBasedConfiguration.SILENT_SUCCESS: uses SilentSuccessFilter decorator
An
InjectableStepsFactory that is provided with the
CandidateSteps instances.Pattern-based composite parser, which uses the keywords provided to parse the
textual composite steps into a list of
Composite.A step pattern parser that provides a step matcher which will capture
parameters starting with the given prefix in any matching step.
Pattern-based story parser, which uses the keywords provided to parse the
textual story into a
Story.PathCalculator that finds given stories relative to the current story.Monitor that reports to
PrintStream only failure eventsRuntime exception thrown to indicate that the scenario should be restarted.
Runtime exception thrown to indicate that the story should be restarted.
Represents a row in an
ExamplesTable.An
InjectableStepsFactory that scans for classes in the classpath.
Manages
SGRCodes.SGRCodes used by ANSIConsoleOutputMonitor that reports nothing
StepMonitor that prints nothings.
Filters out the reports from all stories that pass, The delegate receives
output only for failing or pending stories.
A Step represents a runnable portion of a Scenario, which matches methods annotated in
CandidateSteps
instances.Represents the strategy for the collection of executable
Steps from a story or scenario matching a list of
StepCandidates.This is a different class, because the @Inject jar may not be in the
classpath.
A Stepdoc represents the documentation on a single
StepCandidate,
which includes:
the step type
the pattern to match the step candidate that is configured in the
annotation
the method in the steps instance class
the steps instance class
Thrown when a step execution has failed
When a step fails, the
Throwable that caused the failure is wrapped
in a StepFailed together with the step during which the failure
occurred.
StepFinder is reponsible for finding and prioritising step candidates or
finding steps instances from
CandidateSteps, which are created using
an InjectableStepsFactory.Strategy to priorise candidate steps by Levenshtein Distance
Strategy to priorise step candidates by the
StepCandidate.getPriority() field which is settable in the
Given, When, Then annotations.Defines the priorising strategy of step candidates
A step matcher is responsible for matching steps against a given step pattern
and extracting the parameters for the step
Interface to monitor step events
Represents a step pattern, as provided in the method annotations.
Parses a step pattern, as provided in the method annotations, creating a
StepMatcher which will in turn match textual steps conforming to the pattern.
Default implementation of
CandidateSteps which provides the step
candidates that match the steps being run.Holds runtime context-related objects.
Enum representing the step types
Holds flags used to control story execution flow.
Finds stories by scanning source paths, which can be either filesystem
directories or jars.
Abstraction of a story location, handling cases in which story path is defined
as a resource in classpath or as a URL.
Manages the execution and outcomes of running stories.
Groups a set of
Storys by meta filter.Maps
Storys by a MetaFilter.Provides an view of a list of
StoryMaps, indexed by meta filters.
Resolves story names from their paths.
Parses the stories contained in a story from a textual representation.
Resolves story paths converting the Java
Embeddable class to a resource
path.Allows the runner to report the state of running stories
A Builder for
StoryReporters.A Format that wraps a StoryReporter instance provided.
Thrown when a story resource is not found
Splits story into the list of stories basing on Lifecycle ExamplesTable and the provided story index format.
A digit parser for timeouts
A simple parser for timeouts of format: 1d 2h 30m 15s.
A breadcrumb-based naming strategy: [story path with breadcrumbs].[story name].[scenario title]
A simple naming strategy: [story name].[scenario title]
Interface to monitor table transformer events
Facade responsible for transforming table string representations.
Decorates console output to allow TeamCity build script interaction: *
https://confluence.jetbrains.com/display/TCD9/Build+Script+Interaction+with+TeamCity
Story reporter that outputs to a template.
ViewGenerator, which uses the configured TemplateProcessor to generate the views from templates.
Story reporter that outputs to a PrintStream, as TXT.
Resolves story paths converting the camel-cased Java core class to
lower-case underscore-separated paths e.g.:
"org.jbehave.core.ICanLogin.java" -> "org/jbehave/core/i_can_login.story".
Decorator of Configuration that disables modification of configuration
elements.
Wraps an exception by adding an
UUID.Represents a text content that needs to rendered verbatim, ie as it is laid out in the original textual
representation.
A view generator is responsible for creating a collective views of stories,
either story maps or file-based reports of stories run.
Story reporter that outputs to a PrintStream, as XML.
A templateable output that generates XML.
DelegatingEmbedderMonitor