americium/com.sageserpent.americium/TrialsSkeletalImplementation

TrialsSkeletalImplementation

trait TrialsSkeletalImplementation[Case] extends Trials[Case]
trait Trials[Case]
trait TrialsScaffolding[Case]
trait TrialsFactoring[Case]
class Object
trait Matchable
class Any

Type members

Inherited classlikes

abstract class TrialException(cause: Throwable) extends RuntimeException
Inherited from:
TrialsFactoring

Inherited types

override type SupplySyntaxType <: SupplyToSyntax[Case]
Inherited from:
Trials

Value members

Abstract methods

override def lotsOfSize[Collection](size: Int)(implicit factory: Factory[Case, Collection]): TrialsSkeletalImplementation[Collection]
Definition Classes
override def several[Container](implicit factory: Factory[Case, Container]): TrialsSkeletalImplementation[Container]
Definition Classes

Concrete methods

override def and[Case2](secondTrials: Trials[Case2]): Tuple2Trials[Case, Case2]
Definition Classes
override def filter(predicate: Case => Boolean): TrialsImplementation[Case]
Definition Classes
override def flatMap[TransformedCase](step: Case => Trials[TransformedCase]): TrialsImplementation[TransformedCase]
Definition Classes
override def lists: TrialsSkeletalImplementation[List[Case]]
Definition Classes
override def listsOfSize(size: Int): TrialsSkeletalImplementation[List[Case]]
Definition Classes
override def map[TransformedCase](transform: Case => TransformedCase): TrialsImplementation[TransformedCase]
Definition Classes
override def mapFilter[TransformedCase](filteringTransform: Case => Option[TransformedCase]): TrialsImplementation[TransformedCase]
Definition Classes
override def maps[Value](values: Trials[Value]): TrialsSkeletalImplementation[Map[Case, Value]]
Definition Classes
override def sets: TrialsSkeletalImplementation[Set[_ <: Case]]
Definition Classes
override def sortedMaps[Value](values: Trials[Value])(implicit ordering: Ordering[_ >: Case]): TrialsSkeletalImplementation[SortedMap[Case, Value]]
Definition Classes
override def sortedSets(implicit ordering: Ordering[_ >: Case]): TrialsSkeletalImplementation[SortedSet[_ <: Case]]
Definition Classes

Inherited methods

def javaTrials: Trials[_ <: Case]

This is mostly just for implementation purposes, as the Java incarnation com.sageserpent.americium.java.Trials is effectively a wrapper around the Scala incarnation Trials. However, if you want to pull cases via an iterator, this is handy as currently the iterator access is via the Java incarnation.

This is mostly just for implementation purposes, as the Java incarnation com.sageserpent.americium.java.Trials is effectively a wrapper around the Scala incarnation Trials. However, if you want to pull cases via an iterator, this is handy as currently the iterator access is via the Java incarnation.

Returns:

The Java incarnation com.sageserpent.americium.java.Trials of this instance

Inherited from:
Trials
def options: Trials[Option[Case]]
Returns:

A lifted trials that wraps the underlying cases from this in an Option; the resulting trials also supplies a special case of Option.empty.

Inherited from:
Trials
def or[Case2](alternativeTrials: Trials[Case2]): Trials[Either[Case, Case2]]

Fluent syntax to allow trials of dissimilar types to be supplied as alternatives to the same test. In contrast to the TrialsApi.alternate, the alternatives do not have to conform to the same type; instead here we can switch in the test between unrelated types using an Either instance to hold cases supplied from either this trials instance or from alternativeTrials.

Fluent syntax to allow trials of dissimilar types to be supplied as alternatives to the same test. In contrast to the TrialsApi.alternate, the alternatives do not have to conform to the same type; instead here we can switch in the test between unrelated types using an Either instance to hold cases supplied from either this trials instance or from alternativeTrials.

Returns:

[[Either]] that is populated with either a Case or with a Case2.

Inherited from:
Trials
def reproduce(recipe: String): Case

Reproduce a specific case in a repeatable fashion, based on a recipe.

Reproduce a specific case in a repeatable fashion, based on a recipe.

Value parameters:
recipe

This encodes a specific case and will only be understood by the same value of trials instance that was used to obtain it.

Returns:

The specific Case denoted by the recipe.

Throws:
RuntimeException

if the recipe does not correspond to the receiver, either due to it being created by a different flavour of trials instance or subsequent code changes.

Inherited from:
TrialsFactoring
def trials: Trials[Case]

Use this to lose any specialised supply syntax and go back to the regular Trials API. The motivation for this is when the and combinator is used to glue together several trials instances, but we want to treat the result as a plain trials of tuples, rather than calling Trials.withLimits etc there and then.

Use this to lose any specialised supply syntax and go back to the regular Trials API. The motivation for this is when the and combinator is used to glue together several trials instances, but we want to treat the result as a plain trials of tuples, rather than calling Trials.withLimits etc there and then.

Returns:

The equivalent Trials instance.

Inherited from:
TrialsScaffolding
def withLimit(limit: Int): SupplySyntaxType

Fluent syntax for configuring a limit to the number of cases supplied to a consumer.

Fluent syntax for configuring a limit to the number of cases supplied to a consumer.

Value parameters:
limit

The maximum number of cases that can be supplied - note that this is no guarantee that so many cases will be supplied, it is simply a limit.

Returns:

An instance of SupplyToSyntax with the limit configured.

Inherited from:
TrialsScaffolding
def withStrategy(casesLimitStrategyFactory: CaseSupplyCycle => CasesLimitStrategy, complexityLimit: Int, shrinkageAttemptsLimit: Int, shrinkageStop: () => Case): SupplySyntaxType

Fluent syntax for configuring a limit strategy for the number of cases supplied to a consumer.

Fluent syntax for configuring a limit strategy for the number of cases supplied to a consumer.

Value parameters:
casesLimitStrategyFactory

A factory method that should produce a fresh instance of a CasesLimitStrategy on each call.

Returns:

An instance of SupplyToSyntax with the strategy configured.

Note:

The factory casesLimitStrategyFactory takes an argument of CaseSupplyCycle; this can be used to dynamically configure the strategy depending on which cycle the strategy is intended for, or simply disregarded if a one-size-fits-all approach is desired.

Inherited from:
TrialsScaffolding

Deprecated and Inherited methods

@deprecated("Use `withLimit` followed by calls to `withComplexityLimit`, `withShrinkageAttemptsLimit` and `withShrinkageStop`.")
def withLimits(casesLimit: Int, complexityLimit: Int, shrinkageAttemptsLimit: Int, shrinkageStop: () => Case): SupplySyntaxType
Deprecated
Inherited from:
TrialsScaffolding
@deprecated("Use the JVM system property JavaPropertyNames.recipeHashJavaProperty() - `trials.recipeHash` instead to force existing tests written using `withLimit` or `withStrategy` to pick up the recipe. This has the advantage of being a temporary measure for debugging that doesn\'t require test code changes.")
def withRecipe(recipe: String): SupplySyntaxType
Deprecated
Inherited from:
TrialsScaffolding

Inherited fields

val generation: Free[GenerationOperation, _ <: Case]
Inherited from:
GenerationSupport