Class JournalSpec

  • All Implemented Interfaces:
    CapabilityFlags, JournalCapabilityFlags, MayVerb, OptionalTests, TestKitBase, java.io.Serializable, org.scalactic.Explicitly, org.scalactic.Tolerance, org.scalactic.TripleEquals, org.scalactic.TripleEqualsSupport, org.scalatest.Alerting, org.scalatest.Assertions, org.scalatest.BeforeAndAfterAll, org.scalatest.BeforeAndAfterEach, org.scalatest.Documenting, org.scalatest.Informing, org.scalatest.Matchers, org.scalatest.Notifying, org.scalatest.Suite, org.scalatest.SuiteMixin, org.scalatest.TestRegistration, org.scalatest.TestSuite, org.scalatest.words.CanVerb, org.scalatest.words.MatcherWords, org.scalatest.words.MustVerb, org.scalatest.words.ShouldVerb, org.scalatest.WordSpecLike, scala.Serializable
    Direct Known Subclasses:
    JavaJournalSpec, JournalPerfSpec

    public abstract class JournalSpec
    extends PluginSpec
    implements MayVerb, OptionalTests, JournalCapabilityFlags
    This spec aims to verify custom akka-persistence Journal implementations. Plugin authors are highly encouraged to include it in their plugin's test suites.

    In case your journal plugin needs some kind of setup or teardown, override the beforeAll or afterAll methods (don't forget to call super in your overridden methods).

    For a Java and JUnit consumable version of the TCK please refer to JavaJournalSpec.

    See Also:
    JournalPerfSpec, JavaJournalPerfSpec, Serialized Form
    • Constructor Detail

      • JournalSpec

        public JournalSpec​(com.typesafe.config.Config config)
    • Method Detail

      • config

        public static com.typesafe.config.Config config()
      • lastSender

        public static ActorRef lastSender()
      • testActorName

        protected static java.lang.String testActorName()
      • ignoreMsg

        public static void ignoreMsg​(scala.PartialFunction<java.lang.Object,​java.lang.Object> f)
      • ignoreNoMsg

        public static void ignoreNoMsg()
      • now

        public static scala.concurrent.duration.FiniteDuration now()
      • remainingOrDefault

        public static scala.concurrent.duration.FiniteDuration remainingOrDefault()
      • remaining

        public static scala.concurrent.duration.FiniteDuration remaining()
      • remainingOr

        public static scala.concurrent.duration.FiniteDuration remainingOr​(scala.concurrent.duration.FiniteDuration duration)
      • msgAvailable

        public static boolean msgAvailable()
      • awaitCond

        public static void awaitCond​(scala.Function0<java.lang.Object> p,
                                     scala.concurrent.duration.Duration max,
                                     scala.concurrent.duration.Duration interval,
                                     java.lang.String message)
      • awaitCond$default$2

        public static scala.concurrent.duration.Duration awaitCond$default$2()
      • awaitCond$default$3

        public static scala.concurrent.duration.Duration awaitCond$default$3()
      • awaitCond$default$4

        public static java.lang.String awaitCond$default$4()
      • awaitAssert

        public static <A> A awaitAssert​(scala.Function0<A> a,
                                        scala.concurrent.duration.Duration max,
                                        scala.concurrent.duration.Duration interval)
      • awaitAssert$default$2

        public static <A> scala.concurrent.duration.Duration awaitAssert$default$2()
      • awaitAssert$default$3

        public static <A> scala.concurrent.duration.Duration awaitAssert$default$3()
      • within

        public static <T> T within​(scala.concurrent.duration.FiniteDuration min,
                                   scala.concurrent.duration.FiniteDuration max,
                                   scala.Function0<T> f)
      • within

        public static <T> T within​(scala.concurrent.duration.FiniteDuration max,
                                   scala.Function0<T> f)
      • expectMsg

        public static <T> T expectMsg​(T obj)
      • expectMsg

        public static <T> T expectMsg​(scala.concurrent.duration.FiniteDuration max,
                                      T obj)
      • expectMsg

        public static <T> T expectMsg​(scala.concurrent.duration.FiniteDuration max,
                                      java.lang.String hint,
                                      T obj)
      • expectMsgPF

        public static <T> T expectMsgPF​(scala.concurrent.duration.Duration max,
                                        java.lang.String hint,
                                        scala.PartialFunction<java.lang.Object,​T> f)
      • expectMsgPF$default$1

        public static <T> scala.concurrent.duration.Duration expectMsgPF$default$1()
      • expectMsgPF$default$2

        public static <T> java.lang.String expectMsgPF$default$2()
      • expectTerminated

        public static Terminated expectTerminated​(ActorRef target,
                                                  scala.concurrent.duration.Duration max)
      • expectTerminated$default$2

        public static scala.concurrent.duration.Duration expectTerminated$default$2()
      • fishForMessage

        public static java.lang.Object fishForMessage​(scala.concurrent.duration.Duration max,
                                                      java.lang.String hint,
                                                      scala.PartialFunction<java.lang.Object,​java.lang.Object> f)
      • fishForMessage$default$1

        public static scala.concurrent.duration.Duration fishForMessage$default$1()
      • fishForMessage$default$2

        public static java.lang.String fishForMessage$default$2()
      • fishForSpecificMessage

        public static <T> T fishForSpecificMessage​(scala.concurrent.duration.Duration max,
                                                   java.lang.String hint,
                                                   scala.PartialFunction<java.lang.Object,​T> f)
      • fishForSpecificMessage$default$1

        public static <T> scala.concurrent.duration.Duration fishForSpecificMessage$default$1()
      • fishForSpecificMessage$default$2

        public static <T> java.lang.String fishForSpecificMessage$default$2()
      • expectMsgType

        public static <T> T expectMsgType​(scala.reflect.ClassTag<T> t)
      • expectMsgType

        public static <T> T expectMsgType​(scala.concurrent.duration.FiniteDuration max,
                                          scala.reflect.ClassTag<T> t)
      • expectMsgClass

        public static <C> C expectMsgClass​(java.lang.Class<C> c)
      • expectMsgClass

        public static <C> C expectMsgClass​(scala.concurrent.duration.FiniteDuration max,
                                           java.lang.Class<C> c)
      • expectMsgAnyOf

        public static <T> T expectMsgAnyOf​(scala.collection.Seq<T> obj)
      • expectMsgAnyOf

        public static <T> T expectMsgAnyOf​(scala.concurrent.duration.FiniteDuration max,
                                           scala.collection.Seq<T> obj)
      • expectMsgAnyClassOf

        public static <C> C expectMsgAnyClassOf​(scala.collection.Seq<java.lang.Class<? extends C>> obj)
      • expectMsgAnyClassOf

        public static <C> C expectMsgAnyClassOf​(scala.concurrent.duration.FiniteDuration max,
                                                scala.collection.Seq<java.lang.Class<? extends C>> obj)
      • expectMsgAllOf

        public static <T> scala.collection.immutable.Seq<T> expectMsgAllOf​(scala.collection.Seq<T> obj)
      • expectMsgAllOf

        public static <T> scala.collection.immutable.Seq<T> expectMsgAllOf​(scala.concurrent.duration.FiniteDuration max,
                                                                           scala.collection.Seq<T> obj)
      • expectMsgAllClassOf

        public static <T> scala.collection.immutable.Seq<T> expectMsgAllClassOf​(scala.collection.Seq<java.lang.Class<? extends T>> obj)
      • expectMsgAllClassOf

        public static <T> scala.collection.immutable.Seq<T> expectMsgAllClassOf​(scala.concurrent.duration.FiniteDuration max,
                                                                                scala.collection.Seq<java.lang.Class<? extends T>> obj)
      • expectMsgAllConformingOf

        public static <T> scala.collection.immutable.Seq<T> expectMsgAllConformingOf​(scala.collection.Seq<java.lang.Class<? extends T>> obj)
      • expectMsgAllConformingOf

        public static <T> scala.collection.immutable.Seq<T> expectMsgAllConformingOf​(scala.concurrent.duration.FiniteDuration max,
                                                                                     scala.collection.Seq<java.lang.Class<? extends T>> obj)
      • expectNoMsg

        public static void expectNoMsg()
      • expectNoMsg

        public static void expectNoMsg​(scala.concurrent.duration.FiniteDuration max)
      • expectNoMessage

        public static void expectNoMessage​(scala.concurrent.duration.FiniteDuration max)
      • expectNoMessage

        public static void expectNoMessage()
      • receiveWhile

        public static <T> scala.collection.immutable.Seq<T> receiveWhile​(scala.concurrent.duration.Duration max,
                                                                         scala.concurrent.duration.Duration idle,
                                                                         int messages,
                                                                         scala.PartialFunction<java.lang.Object,​T> f)
      • receiveWhile$default$1

        public static <T> scala.concurrent.duration.Duration receiveWhile$default$1()
      • receiveWhile$default$2

        public static <T> scala.concurrent.duration.Duration receiveWhile$default$2()
      • receiveWhile$default$3

        public static <T> int receiveWhile$default$3()
      • receiveN

        public static scala.collection.immutable.Seq<java.lang.Object> receiveN​(int n)
      • receiveN

        public static scala.collection.immutable.Seq<java.lang.Object> receiveN​(int n,
                                                                                scala.concurrent.duration.FiniteDuration max)
      • receiveOne

        public static java.lang.Object receiveOne​(scala.concurrent.duration.Duration max)
      • shutdown

        public static void shutdown​(ActorSystem actorSystem,
                                    scala.concurrent.duration.Duration duration,
                                    boolean verifySystemShutdown)
      • shutdown$default$1

        public static ActorSystem shutdown$default$1()
      • shutdown$default$2

        public static scala.concurrent.duration.Duration shutdown$default$2()
      • shutdown$default$3

        public static boolean shutdown$default$3()
      • childActorOf

        public static ActorRef childActorOf​(Props props,
                                            java.lang.String name)
      • childActorOf

        public static ActorRef childActorOf​(Props props)
      • defaultEquality

        public static <A> org.scalactic.Equality<A> defaultEquality()
      • $eq$eq$eq

        public static <T> org.scalactic.TripleEqualsSupport.TripleEqualsInvocation<T> $eq$eq$eq​(T right)
      • $bang$eq$eq

        public static <T> org.scalactic.TripleEqualsSupport.TripleEqualsInvocation<T> $bang$eq$eq​(T right)
      • $eq$eq$eq

        public static org.scalactic.TripleEqualsSupport.TripleEqualsInvocation<scala.runtime.Null$> $eq$eq$eq​(scala.runtime.Null$ right)
      • $bang$eq$eq

        public static org.scalactic.TripleEqualsSupport.TripleEqualsInvocation<scala.runtime.Null$> $bang$eq$eq​(scala.runtime.Null$ right)
      • $eq$eq$eq

        public static <T> org.scalactic.TripleEqualsSupport.TripleEqualsInvocationOnSpread<T> $eq$eq$eq​(org.scalactic.TripleEqualsSupport.Spread<T> right)
      • $bang$eq$eq

        public static <T> org.scalactic.TripleEqualsSupport.TripleEqualsInvocationOnSpread<T> $bang$eq$eq​(org.scalactic.TripleEqualsSupport.Spread<T> right)
      • convertToEqualizer

        public static <T> org.scalactic.TripleEqualsSupport.Equalizer<T> convertToEqualizer​(T left)
      • convertToCheckingEqualizer

        public static <T> org.scalactic.TripleEqualsSupport.CheckingEqualizer<T> convertToCheckingEqualizer​(T left)
      • unconstrainedEquality

        public static <A,​B> org.scalactic.CanEqual<A,​B> unconstrainedEquality​(org.scalactic.Equality<A> equalityOfA)
      • lowPriorityTypeCheckedConstraint

        public static <A,​B> org.scalactic.CanEqual<A,​B> lowPriorityTypeCheckedConstraint​(org.scalactic.Equivalence<B> equivalenceOfB,
                                                                                                     scala.Predef.$less$colon$less<A,​B> ev)
      • convertEquivalenceToAToBConstraint

        public static <A,​B> org.scalactic.CanEqual<A,​B> convertEquivalenceToAToBConstraint​(org.scalactic.Equivalence<B> equivalenceOfB,
                                                                                                       scala.Predef.$less$colon$less<A,​B> ev)
      • typeCheckedConstraint

        public static <A,​B> org.scalactic.CanEqual<A,​B> typeCheckedConstraint​(org.scalactic.Equivalence<A> equivalenceOfA,
                                                                                          scala.Predef.$less$colon$less<B,​A> ev)
      • convertEquivalenceToBToAConstraint

        public static <A,​B> org.scalactic.CanEqual<A,​B> convertEquivalenceToBToAConstraint​(org.scalactic.Equivalence<A> equivalenceOfA,
                                                                                                       scala.Predef.$less$colon$less<B,​A> ev)
      • lowPriorityConversionCheckedConstraint

        public static <A,​B> org.scalactic.CanEqual<A,​B> lowPriorityConversionCheckedConstraint​(org.scalactic.Equivalence<B> equivalenceOfB,
                                                                                                           scala.Function1<A,​B> cnv)
      • convertEquivalenceToAToBConversionConstraint

        public static <A,​B> org.scalactic.CanEqual<A,​B> convertEquivalenceToAToBConversionConstraint​(org.scalactic.Equivalence<B> equivalenceOfB,
                                                                                                                 scala.Function1<A,​B> ev)
      • conversionCheckedConstraint

        public static <A,​B> org.scalactic.CanEqual<A,​B> conversionCheckedConstraint​(org.scalactic.Equivalence<A> equivalenceOfA,
                                                                                                scala.Function1<B,​A> cnv)
      • convertEquivalenceToBToAConversionConstraint

        public static <A,​B> org.scalactic.CanEqual<A,​B> convertEquivalenceToBToAConversionConstraint​(org.scalactic.Equivalence<A> equivalenceOfA,
                                                                                                                 scala.Function1<B,​A> ev)
      • newAssertionFailedException

        public static java.lang.Throwable newAssertionFailedException​(scala.Option<java.lang.String> optionalMessage,
                                                                      scala.Option<java.lang.Throwable> optionalCause,
                                                                      org.scalactic.source.Position pos)
      • newTestCanceledException

        public static java.lang.Throwable newTestCanceledException​(scala.Option<java.lang.String> optionalMessage,
                                                                   scala.Option<java.lang.Throwable> optionalCause,
                                                                   org.scalactic.source.Position pos)
      • assume

        public static org.scalatest.compatible.Assertion assume​(boolean condition,
                                                                org.scalactic.Prettifier prettifier,
                                                                org.scalactic.source.Position pos)
      • assume

        public static org.scalatest.compatible.Assertion assume​(boolean condition,
                                                                java.lang.Object clue,
                                                                org.scalactic.Prettifier prettifier,
                                                                org.scalactic.source.Position pos)
      • assertTypeError

        public static org.scalatest.compatible.Assertion assertTypeError​(java.lang.String code,
                                                                         org.scalactic.source.Position pos)
      • assertDoesNotCompile

        public static org.scalatest.compatible.Assertion assertDoesNotCompile​(java.lang.String code,
                                                                              org.scalactic.source.Position pos)
      • assertCompiles

        public static org.scalatest.compatible.Assertion assertCompiles​(java.lang.String code,
                                                                        org.scalactic.source.Position pos)
      • intercept

        public static <T> T intercept​(scala.Function0<java.lang.Object> f,
                                      scala.reflect.ClassTag<T> classTag,
                                      org.scalactic.source.Position pos)
      • assertThrows

        public static <T> org.scalatest.compatible.Assertion assertThrows​(scala.Function0<java.lang.Object> f,
                                                                          scala.reflect.ClassTag<T> classTag,
                                                                          org.scalactic.source.Position pos)
      • trap

        public static <T> java.lang.Throwable trap​(scala.Function0<T> f)
      • assertResult

        public static org.scalatest.compatible.Assertion assertResult​(java.lang.Object expected,
                                                                      java.lang.Object clue,
                                                                      java.lang.Object actual,
                                                                      org.scalactic.Prettifier prettifier,
                                                                      org.scalactic.source.Position pos)
      • assertResult

        public static org.scalatest.compatible.Assertion assertResult​(java.lang.Object expected,
                                                                      java.lang.Object actual,
                                                                      org.scalactic.Prettifier prettifier,
                                                                      org.scalactic.source.Position pos)
      • fail

        public static scala.runtime.Nothing$ fail​(org.scalactic.source.Position pos)
      • fail

        public static scala.runtime.Nothing$ fail​(java.lang.String message,
                                                  org.scalactic.source.Position pos)
      • fail

        public static scala.runtime.Nothing$ fail​(java.lang.String message,
                                                  java.lang.Throwable cause,
                                                  org.scalactic.source.Position pos)
      • fail

        public static scala.runtime.Nothing$ fail​(java.lang.Throwable cause,
                                                  org.scalactic.source.Position pos)
      • cancel

        public static scala.runtime.Nothing$ cancel​(org.scalactic.source.Position pos)
      • cancel

        public static scala.runtime.Nothing$ cancel​(java.lang.String message,
                                                    org.scalactic.source.Position pos)
      • cancel

        public static scala.runtime.Nothing$ cancel​(java.lang.String message,
                                                    java.lang.Throwable cause,
                                                    org.scalactic.source.Position pos)
      • cancel

        public static scala.runtime.Nothing$ cancel​(java.lang.Throwable cause,
                                                    org.scalactic.source.Position pos)
      • withClue

        public static <T> T withClue​(java.lang.Object clue,
                                     scala.Function0<T> fun)
      • pending

        public static org.scalatest.compatible.Assertion pending()
      • pendingUntilFixed

        public static org.scalatest.compatible.Assertion pendingUntilFixed​(scala.Function0<scala.runtime.BoxedUnit> f,
                                                                           org.scalactic.source.Position pos)
      • nestedSuites

        public static scala.collection.immutable.IndexedSeq<org.scalatest.Suite> nestedSuites()
      • execute

        public static final void execute​(java.lang.String testName,
                                         org.scalatest.ConfigMap configMap,
                                         boolean color,
                                         boolean durations,
                                         boolean shortstacks,
                                         boolean fullstacks,
                                         boolean stats)
      • execute

        public static final void execute()
      • yeOldeTestNames

        public static scala.collection.immutable.Set<java.lang.String> yeOldeTestNames()
      • runNestedSuites

        protected static org.scalatest.Status runNestedSuites​(org.scalatest.Args args)
      • suiteName

        public static java.lang.String suiteName()
      • suiteId

        public static java.lang.String suiteId()
      • expectedTestCount

        public static int expectedTestCount​(org.scalatest.Filter filter)
      • createCatchReporter

        public static org.scalatest.Reporter createCatchReporter​(org.scalatest.Reporter reporter)
      • rerunner

        public static scala.Option<java.lang.String> rerunner()
      • execute$default$1

        public static final java.lang.String execute$default$1()
      • execute$default$2

        public static final org.scalatest.ConfigMap execute$default$2()
      • execute$default$3

        public static final boolean execute$default$3()
      • execute$default$4

        public static final boolean execute$default$4()
      • execute$default$5

        public static final boolean execute$default$5()
      • execute$default$6

        public static final boolean execute$default$6()
      • execute$default$7

        public static final boolean execute$default$7()
      • withFixture

        protected static org.scalatest.Outcome withFixture​(org.scalatest.TestSuite.NoArgTest test)
      • convertToStringShouldWrapperForVerb

        public static org.scalatest.words.ShouldVerb.StringShouldWrapperForVerb convertToStringShouldWrapperForVerb​(java.lang.String o,
                                                                                                                    org.scalactic.source.Position position)
      • convertToStringMustWrapperForVerb

        public static org.scalatest.words.MustVerb.StringMustWrapperForVerb convertToStringMustWrapperForVerb​(java.lang.String o,
                                                                                                              org.scalactic.source.Position position)
      • convertToStringCanWrapper

        public static org.scalatest.words.CanVerb.StringCanWrapperForVerb convertToStringCanWrapper​(java.lang.String o,
                                                                                                    org.scalactic.source.Position position)
      • info

        protected static org.scalatest.Informer info()
      • note

        protected static org.scalatest.Notifier note()
      • alert

        protected static org.scalatest.Alerter alert()
      • markup

        protected static org.scalatest.Documenter markup()
      • registerTest

        public static final void registerTest​(java.lang.String testText,
                                              scala.collection.Seq<org.scalatest.Tag> testTags,
                                              scala.Function0<java.lang.Object> testFun,
                                              org.scalactic.source.Position pos)
      • registerIgnoredTest

        public static final void registerIgnoredTest​(java.lang.String testText,
                                                     scala.collection.Seq<org.scalatest.Tag> testTags,
                                                     scala.Function0<java.lang.Object> testFun,
                                                     org.scalactic.source.Position pos)
      • afterWord

        protected static org.scalatest.WordSpecLike.AfterWord afterWord​(java.lang.String text)
      • convertToWordSpecStringWrapper

        protected static org.scalatest.WordSpecLike.WordSpecStringWrapper convertToWordSpecStringWrapper​(java.lang.String s)
      • tags

        public static scala.collection.immutable.Map<java.lang.String,​scala.collection.immutable.Set<java.lang.String>> tags()
      • runTest

        protected static org.scalatest.Status runTest​(java.lang.String testName,
                                                      org.scalatest.Args args)
      • runTests

        protected static org.scalatest.Status runTests​(scala.Option<java.lang.String> testName,
                                                       org.scalatest.Args args)
      • testNames

        public static scala.collection.immutable.Set<java.lang.String> testNames()
      • run

        public static org.scalatest.Status run​(scala.Option<java.lang.String> testName,
                                               org.scalatest.Args args)
      • testDataFor

        public static org.scalatest.TestData testDataFor​(java.lang.String testName,
                                                         org.scalatest.ConfigMap theConfigMap)
      • testDataFor$default$2

        public static org.scalatest.ConfigMap testDataFor$default$2()
      • convertNumericToPlusOrMinusWrapper

        public static <T> org.scalactic.Tolerance.PlusOrMinusWrapper<T> convertNumericToPlusOrMinusWrapper​(T pivot,
                                                                                                           scala.math.Numeric<T> evidence$2)
      • noException

        public static org.scalatest.words.NoExceptionWord noException​(org.scalactic.source.Position pos)
      • equal

        public static org.scalatest.matchers.MatcherFactory1<java.lang.Object,​org.scalactic.Equality> equal​(java.lang.Object right)
      • convertSymbolToHavePropertyMatcherGenerator

        public static org.scalatest.Matchers.HavePropertyMatcherGenerator convertSymbolToHavePropertyMatcherGenerator​(scala.Symbol symbol,
                                                                                                                      org.scalactic.Prettifier prettifier,
                                                                                                                      org.scalactic.source.Position pos)
      • equal

        public static <T> org.scalatest.matchers.Matcher<T> equal​(org.scalactic.TripleEqualsSupport.Spread<T> spread)
      • equal

        public static org.scalatest.matchers.Matcher<java.lang.Object> equal​(scala.runtime.Null$ o)
      • $less

        public static <T> org.scalatest.words.ResultOfLessThanComparison<T> $less​(T right,
                                                                                  scala.math.Ordering<T> evidence$1)
      • $greater

        public static <T> org.scalatest.words.ResultOfGreaterThanComparison<T> $greater​(T right,
                                                                                        scala.math.Ordering<T> evidence$2)
      • $less$eq

        public static <T> org.scalatest.words.ResultOfLessThanOrEqualToComparison<T> $less$eq​(T right,
                                                                                              scala.math.Ordering<T> evidence$3)
      • $greater$eq

        public static <T> org.scalatest.words.ResultOfGreaterThanOrEqualToComparison<T> $greater$eq​(T right,
                                                                                                    scala.math.Ordering<T> evidence$4)
      • definedAt

        public static <T> org.scalatest.words.ResultOfDefinedAt<T> definedAt​(T right)
      • oneOf

        public static org.scalatest.words.ResultOfOneOfApplication oneOf​(java.lang.Object firstEle,
                                                                         java.lang.Object secondEle,
                                                                         scala.collection.Seq<java.lang.Object> remainingEles,
                                                                         org.scalactic.source.Position pos)
      • oneElementOf

        public static org.scalatest.words.ResultOfOneElementOfApplication oneElementOf​(scala.collection.GenTraversable<java.lang.Object> elements)
      • atLeastOneOf

        public static org.scalatest.words.ResultOfAtLeastOneOfApplication atLeastOneOf​(java.lang.Object firstEle,
                                                                                       java.lang.Object secondEle,
                                                                                       scala.collection.Seq<java.lang.Object> remainingEles,
                                                                                       org.scalactic.source.Position pos)
      • atLeastOneElementOf

        public static org.scalatest.words.ResultOfAtLeastOneElementOfApplication atLeastOneElementOf​(scala.collection.GenTraversable<java.lang.Object> elements)
      • noneOf

        public static org.scalatest.words.ResultOfNoneOfApplication noneOf​(java.lang.Object firstEle,
                                                                           java.lang.Object secondEle,
                                                                           scala.collection.Seq<java.lang.Object> remainingEles,
                                                                           org.scalactic.source.Position pos)
      • noElementsOf

        public static org.scalatest.words.ResultOfNoElementsOfApplication noElementsOf​(scala.collection.GenTraversable<java.lang.Object> elements)
      • theSameElementsAs

        public static org.scalatest.words.ResultOfTheSameElementsAsApplication theSameElementsAs​(scala.collection.GenTraversable<?> xs)
      • theSameElementsInOrderAs

        public static org.scalatest.words.ResultOfTheSameElementsInOrderAsApplication theSameElementsInOrderAs​(scala.collection.GenTraversable<?> xs)
      • only

        public static org.scalatest.words.ResultOfOnlyApplication only​(scala.collection.Seq<java.lang.Object> xs,
                                                                       org.scalactic.source.Position pos)
      • inOrderOnly

        public static <T> org.scalatest.words.ResultOfInOrderOnlyApplication inOrderOnly​(java.lang.Object firstEle,
                                                                                         java.lang.Object secondEle,
                                                                                         scala.collection.Seq<java.lang.Object> remainingEles,
                                                                                         org.scalactic.source.Position pos)
      • allOf

        public static org.scalatest.words.ResultOfAllOfApplication allOf​(java.lang.Object firstEle,
                                                                         java.lang.Object secondEle,
                                                                         scala.collection.Seq<java.lang.Object> remainingEles,
                                                                         org.scalactic.source.Position pos)
      • allElementsOf

        public static <R> org.scalatest.words.ResultOfAllElementsOfApplication allElementsOf​(scala.collection.GenTraversable<R> elements)
      • inOrder

        public static org.scalatest.words.ResultOfInOrderApplication inOrder​(java.lang.Object firstEle,
                                                                             java.lang.Object secondEle,
                                                                             scala.collection.Seq<java.lang.Object> remainingEles,
                                                                             org.scalactic.source.Position pos)
      • inOrderElementsOf

        public static <R> org.scalatest.words.ResultOfInOrderElementsOfApplication inOrderElementsOf​(scala.collection.GenTraversable<R> elements)
      • atMostOneOf

        public static org.scalatest.words.ResultOfAtMostOneOfApplication atMostOneOf​(java.lang.Object firstEle,
                                                                                     java.lang.Object secondEle,
                                                                                     scala.collection.Seq<java.lang.Object> remainingEles,
                                                                                     org.scalactic.source.Position pos)
      • atMostOneElementOf

        public static <R> org.scalatest.words.ResultOfAtMostOneElementOfApplication atMostOneElementOf​(scala.collection.GenTraversable<R> elements)
      • thrownBy

        public static org.scalatest.words.ResultOfThrownByApplication thrownBy​(scala.Function0<java.lang.Object> fun)
      • message

        public static org.scalatest.words.ResultOfMessageWordApplication message​(java.lang.String expectedMessage)
      • doCollected

        public static <T> org.scalatest.compatible.Assertion doCollected​(org.scalatest.Matchers.Collected collected,
                                                                         scala.collection.GenTraversable<T> xs,
                                                                         java.lang.Object original,
                                                                         org.scalactic.Prettifier prettifier,
                                                                         org.scalactic.source.Position pos,
                                                                         scala.Function1<T,​org.scalatest.compatible.Assertion> fun)
      • all

        public static <E,​C> org.scalatest.Matchers.ResultOfCollectedAny<E> all​(C xs,
                                                                                     org.scalatest.enablers.Collecting<E,​C> collecting,
                                                                                     org.scalactic.Prettifier prettifier,
                                                                                     org.scalactic.source.Position pos)
      • all

        public static <K,​V,​MAP extends scala.collection.GenMap<java.lang.Object,​java.lang.Object>> org.scalatest.Matchers.ResultOfCollectedAny<scala.Tuple2<K,​V>> all​(MAP xs,
                                                                                                                                                                                              org.scalatest.enablers.Collecting<scala.Tuple2<K,​V>,​scala.collection.GenTraversable<scala.Tuple2<K,​V>>> collecting,
                                                                                                                                                                                              org.scalactic.Prettifier prettifier,
                                                                                                                                                                                              org.scalactic.source.Position pos)
      • all

        public static <K,​V,​JMAP extends java.util.Map<java.lang.Object,​java.lang.Object>> org.scalatest.Matchers.ResultOfCollectedAny<org.scalatest.Entry<K,​V>> all​(JMAP xs,
                                                                                                                                                                                            org.scalatest.enablers.Collecting<org.scalatest.Entry<K,​V>,​JMAP> collecting,
                                                                                                                                                                                            org.scalactic.Prettifier prettifier,
                                                                                                                                                                                            org.scalactic.source.Position pos)
      • all

        public static org.scalatest.Matchers.ResultOfCollectedAny<java.lang.Object> all​(java.lang.String xs,
                                                                                        org.scalatest.enablers.Collecting<java.lang.Object,​java.lang.String> collecting,
                                                                                        org.scalactic.Prettifier prettifier,
                                                                                        org.scalactic.source.Position pos)
      • atLeast

        public static <E,​C> org.scalatest.Matchers.ResultOfCollectedAny<E> atLeast​(int num,
                                                                                         C xs,
                                                                                         org.scalatest.enablers.Collecting<E,​C> collecting,
                                                                                         org.scalactic.Prettifier prettifier,
                                                                                         org.scalactic.source.Position pos)
      • atLeast

        public static <K,​V,​MAP extends scala.collection.GenMap<java.lang.Object,​java.lang.Object>> org.scalatest.Matchers.ResultOfCollectedAny<scala.Tuple2<K,​V>> atLeast​(int num,
                                                                                                                                                                                                  MAP xs,
                                                                                                                                                                                                  org.scalatest.enablers.Collecting<scala.Tuple2<K,​V>,​scala.collection.GenTraversable<scala.Tuple2<K,​V>>> collecting,
                                                                                                                                                                                                  org.scalactic.Prettifier prettifier,
                                                                                                                                                                                                  org.scalactic.source.Position pos)
      • atLeast

        public static <K,​V,​JMAP extends java.util.Map<java.lang.Object,​java.lang.Object>> org.scalatest.Matchers.ResultOfCollectedAny<org.scalatest.Entry<K,​V>> atLeast​(int num,
                                                                                                                                                                                                JMAP xs,
                                                                                                                                                                                                org.scalatest.enablers.Collecting<org.scalatest.Entry<K,​V>,​JMAP> collecting,
                                                                                                                                                                                                org.scalactic.Prettifier prettifier,
                                                                                                                                                                                                org.scalactic.source.Position pos)
      • atLeast

        public static org.scalatest.Matchers.ResultOfCollectedAny<java.lang.Object> atLeast​(int num,
                                                                                            java.lang.String xs,
                                                                                            org.scalatest.enablers.Collecting<java.lang.Object,​java.lang.String> collecting,
                                                                                            org.scalactic.Prettifier prettifier,
                                                                                            org.scalactic.source.Position pos)
      • every

        public static <E,​C> org.scalatest.Matchers.ResultOfCollectedAny<E> every​(C xs,
                                                                                       org.scalatest.enablers.Collecting<E,​C> collecting,
                                                                                       org.scalactic.Prettifier prettifier,
                                                                                       org.scalactic.source.Position pos)
      • every

        public static <K,​V,​MAP extends scala.collection.Map<java.lang.Object,​java.lang.Object>> org.scalatest.Matchers.ResultOfCollectedAny<scala.Tuple2<K,​V>> every​(MAP xs,
                                                                                                                                                                                             org.scalatest.enablers.Collecting<scala.Tuple2<K,​V>,​scala.collection.GenTraversable<scala.Tuple2<K,​V>>> collecting,
                                                                                                                                                                                             org.scalactic.Prettifier prettifier,
                                                                                                                                                                                             org.scalactic.source.Position pos)
      • every

        public static <K,​V,​JMAP extends java.util.Map<java.lang.Object,​java.lang.Object>> org.scalatest.Matchers.ResultOfCollectedAny<org.scalatest.Entry<K,​V>> every​(JMAP xs,
                                                                                                                                                                                              org.scalatest.enablers.Collecting<org.scalatest.Entry<K,​V>,​JMAP> collecting,
                                                                                                                                                                                              org.scalactic.Prettifier prettifier,
                                                                                                                                                                                              org.scalactic.source.Position pos)
      • every

        public static org.scalatest.Matchers.ResultOfCollectedAny<java.lang.Object> every​(java.lang.String xs,
                                                                                          org.scalatest.enablers.Collecting<java.lang.Object,​java.lang.String> collecting,
                                                                                          org.scalactic.Prettifier prettifier,
                                                                                          org.scalactic.source.Position pos)
      • exactly

        public static <E,​C> org.scalatest.Matchers.ResultOfCollectedAny<E> exactly​(int num,
                                                                                         C xs,
                                                                                         org.scalatest.enablers.Collecting<E,​C> collecting,
                                                                                         org.scalactic.Prettifier prettifier,
                                                                                         org.scalactic.source.Position pos)
      • exactly

        public static <K,​V,​MAP extends scala.collection.GenMap<java.lang.Object,​java.lang.Object>> org.scalatest.Matchers.ResultOfCollectedAny<scala.Tuple2<K,​V>> exactly​(int num,
                                                                                                                                                                                                  MAP xs,
                                                                                                                                                                                                  org.scalatest.enablers.Collecting<scala.Tuple2<K,​V>,​scala.collection.GenTraversable<scala.Tuple2<K,​V>>> collecting,
                                                                                                                                                                                                  org.scalactic.Prettifier prettifier,
                                                                                                                                                                                                  org.scalactic.source.Position pos)
      • exactly

        public static <K,​V,​JMAP extends java.util.Map<java.lang.Object,​java.lang.Object>> org.scalatest.Matchers.ResultOfCollectedAny<org.scalatest.Entry<K,​V>> exactly​(int num,
                                                                                                                                                                                                JMAP xs,
                                                                                                                                                                                                org.scalatest.enablers.Collecting<org.scalatest.Entry<K,​V>,​JMAP> collecting,
                                                                                                                                                                                                org.scalactic.Prettifier prettifier,
                                                                                                                                                                                                org.scalactic.source.Position pos)
      • exactly

        public static org.scalatest.Matchers.ResultOfCollectedAny<java.lang.Object> exactly​(int num,
                                                                                            java.lang.String xs,
                                                                                            org.scalatest.enablers.Collecting<java.lang.Object,​java.lang.String> collecting,
                                                                                            org.scalactic.Prettifier prettifier,
                                                                                            org.scalactic.source.Position pos)
      • no

        public static <E,​C> org.scalatest.Matchers.ResultOfCollectedAny<E> no​(C xs,
                                                                                    org.scalatest.enablers.Collecting<E,​C> collecting,
                                                                                    org.scalactic.Prettifier prettifier,
                                                                                    org.scalactic.source.Position pos)
      • no

        public static <K,​V,​JMAP extends java.util.Map<java.lang.Object,​java.lang.Object>> org.scalatest.Matchers.ResultOfCollectedAny<org.scalatest.Entry<K,​V>> no​(JMAP xs,
                                                                                                                                                                                           org.scalatest.enablers.Collecting<org.scalatest.Entry<K,​V>,​JMAP> collecting,
                                                                                                                                                                                           org.scalactic.Prettifier prettifier,
                                                                                                                                                                                           org.scalactic.source.Position pos)
      • no

        public static org.scalatest.Matchers.ResultOfCollectedAny<java.lang.Object> no​(java.lang.String xs,
                                                                                       org.scalatest.enablers.Collecting<java.lang.Object,​java.lang.String> collecting,
                                                                                       org.scalactic.Prettifier prettifier,
                                                                                       org.scalactic.source.Position pos)
      • between

        public static <E,​C> org.scalatest.Matchers.ResultOfCollectedAny<E> between​(int from,
                                                                                         int upTo,
                                                                                         C xs,
                                                                                         org.scalatest.enablers.Collecting<E,​C> collecting,
                                                                                         org.scalactic.Prettifier prettifier,
                                                                                         org.scalactic.source.Position pos)
      • between

        public static <K,​V,​JMAP extends java.util.Map<java.lang.Object,​java.lang.Object>> org.scalatest.Matchers.ResultOfCollectedAny<org.scalatest.Entry<K,​V>> between​(int from,
                                                                                                                                                                                                int upTo,
                                                                                                                                                                                                JMAP xs,
                                                                                                                                                                                                org.scalatest.enablers.Collecting<org.scalatest.Entry<K,​V>,​JMAP> collecting,
                                                                                                                                                                                                org.scalactic.Prettifier prettifier,
                                                                                                                                                                                                org.scalactic.source.Position pos)
      • between

        public static org.scalatest.Matchers.ResultOfCollectedAny<java.lang.Object> between​(int from,
                                                                                            int upTo,
                                                                                            java.lang.String xs,
                                                                                            org.scalatest.enablers.Collecting<java.lang.Object,​java.lang.String> collecting,
                                                                                            org.scalactic.Prettifier prettifier,
                                                                                            org.scalactic.source.Position pos)
      • atMost

        public static <E,​C> org.scalatest.Matchers.ResultOfCollectedAny<E> atMost​(int num,
                                                                                        C xs,
                                                                                        org.scalatest.enablers.Collecting<E,​C> collecting,
                                                                                        org.scalactic.Prettifier prettifier,
                                                                                        org.scalactic.source.Position pos)
      • atMost

        public static <K,​V,​MAP extends scala.collection.GenMap<java.lang.Object,​java.lang.Object>> org.scalatest.Matchers.ResultOfCollectedAny<scala.Tuple2<K,​V>> atMost​(int num,
                                                                                                                                                                                                 MAP xs,
                                                                                                                                                                                                 org.scalatest.enablers.Collecting<scala.Tuple2<K,​V>,​scala.collection.GenTraversable<scala.Tuple2<K,​V>>> collecting,
                                                                                                                                                                                                 org.scalactic.Prettifier prettifier,
                                                                                                                                                                                                 org.scalactic.source.Position pos)
      • atMost

        public static <K,​V,​JMAP extends java.util.Map<java.lang.Object,​java.lang.Object>> org.scalatest.Matchers.ResultOfCollectedAny<org.scalatest.Entry<K,​V>> atMost​(int num,
                                                                                                                                                                                               JMAP xs,
                                                                                                                                                                                               org.scalatest.enablers.Collecting<org.scalatest.Entry<K,​V>,​JMAP> collecting,
                                                                                                                                                                                               org.scalactic.Prettifier prettifier,
                                                                                                                                                                                               org.scalactic.source.Position pos)
      • atMost

        public static org.scalatest.Matchers.ResultOfCollectedAny<java.lang.Object> atMost​(int num,
                                                                                           java.lang.String xs,
                                                                                           org.scalatest.enablers.Collecting<java.lang.Object,​java.lang.String> collecting,
                                                                                           org.scalactic.Prettifier prettifier,
                                                                                           org.scalactic.source.Position pos)
      • a

        public static <T> org.scalatest.words.ResultOfATypeInvocation<T> a​(scala.reflect.ClassTag<T> evidence$5)
      • an

        public static <T> org.scalatest.words.ResultOfAnTypeInvocation<T> an​(scala.reflect.ClassTag<T> evidence$6)
      • the

        public static <T> org.scalatest.words.ResultOfTheTypeInvocation<T> the​(scala.reflect.ClassTag<T> evidence$7,
                                                                               org.scalactic.source.Position pos)
      • convertToAnyShouldWrapper

        public static <T> org.scalatest.Matchers.AnyShouldWrapper<T> convertToAnyShouldWrapper​(T o,
                                                                                               org.scalactic.source.Position pos,
                                                                                               org.scalactic.Prettifier prettifier)
      • convertToStringShouldWrapper

        public static org.scalatest.Matchers.StringShouldWrapper convertToStringShouldWrapper​(java.lang.String o,
                                                                                              org.scalactic.source.Position pos,
                                                                                              org.scalactic.Prettifier prettifier)
      • convertToRegexWrapper

        public static org.scalatest.Matchers.RegexWrapper convertToRegexWrapper​(scala.util.matching.Regex o)
      • of

        public static <T> org.scalatest.words.ResultOfOfTypeInvocation<T> of​(scala.reflect.ClassTag<T> ev)
      • afterEach

        protected static void afterEach()
      • actorInstanceId

        protected static int actorInstanceId()
      • beforeAll

        protected static void beforeAll()
      • afterAll

        protected static void afterAll()
      • pid

        public static java.lang.String pid()
      • writerUuid

        public static java.lang.String writerUuid()
      • subscribe

        public static <T> boolean subscribe​(ActorRef subscriber,
                                            scala.reflect.ClassTag<T> evidence$1)
      • invokeBeforeAllAndAfterAllEvenIfNoTestsAreExpected

        public static boolean invokeBeforeAllAndAfterAllEvenIfNoTestsAreExpected()
      • org$scalatest$BeforeAndAfterAll$_setter_$invokeBeforeAllAndAfterAllEvenIfNoTestsAreExpected_$eq

        protected static void org$scalatest$BeforeAndAfterAll$_setter_$invokeBeforeAllAndAfterAllEvenIfNoTestsAreExpected_$eq​(boolean x$1)
      • key

        public static org.scalatest.Matchers.KeyWord key()
      • value

        public static org.scalatest.Matchers.ValueWord value()
      • a

        public static org.scalatest.Matchers.AWord a()
      • an

        public static org.scalatest.Matchers.AnWord an()
      • theSameInstanceAs

        public static org.scalatest.Matchers.TheSameInstanceAsPhrase theSameInstanceAs()
      • regex

        public static org.scalatest.Matchers.RegexWord regex()
      • org$scalatest$Matchers$$AllCollected

        public static org.scalatest.Matchers.AllCollected$ org$scalatest$Matchers$$AllCollected()
      • org$scalatest$Matchers$$EveryCollected

        public static org.scalatest.Matchers.EveryCollected$ org$scalatest$Matchers$$EveryCollected()
      • org$scalatest$Matchers$$BetweenCollected

        public static org.scalatest.Matchers.BetweenCollected$ org$scalatest$Matchers$$BetweenCollected()
      • org$scalatest$Matchers$$AtLeastCollected

        public static org.scalatest.Matchers.AtLeastCollected$ org$scalatest$Matchers$$AtLeastCollected()
      • org$scalatest$Matchers$$AtMostCollected

        public static org.scalatest.Matchers.AtMostCollected$ org$scalatest$Matchers$$AtMostCollected()
      • org$scalatest$Matchers$$NoCollected

        public static org.scalatest.Matchers.NoCollected$ org$scalatest$Matchers$$NoCollected()
      • org$scalatest$Matchers$$ExactlyCollected

        public static org.scalatest.Matchers.ExactlyCollected$ org$scalatest$Matchers$$ExactlyCollected()
      • org$scalatest$Matchers$$ShouldMethodHelper

        public static org.scalatest.Matchers.ShouldMethodHelper$ org$scalatest$Matchers$$ShouldMethodHelper()
      • org$scalatest$Matchers$_setter_$key_$eq

        protected static void org$scalatest$Matchers$_setter_$key_$eq​(org.scalatest.Matchers.KeyWord x$1)
      • org$scalatest$Matchers$_setter_$value_$eq

        protected static void org$scalatest$Matchers$_setter_$value_$eq​(org.scalatest.Matchers.ValueWord x$1)
      • org$scalatest$Matchers$_setter_$a_$eq

        protected static void org$scalatest$Matchers$_setter_$a_$eq​(org.scalatest.Matchers.AWord x$1)
      • org$scalatest$Matchers$_setter_$an_$eq

        protected static void org$scalatest$Matchers$_setter_$an_$eq​(org.scalatest.Matchers.AnWord x$1)
      • org$scalatest$Matchers$_setter_$theSameInstanceAs_$eq

        protected static void org$scalatest$Matchers$_setter_$theSameInstanceAs_$eq​(org.scalatest.Matchers.TheSameInstanceAsPhrase x$1)
      • org$scalatest$Matchers$_setter_$regex_$eq

        protected static void org$scalatest$Matchers$_setter_$regex_$eq​(org.scalatest.Matchers.RegexWord x$1)
      • decided

        public static org.scalactic.Explicitly.DecidedWord decided()
      • determined

        public static org.scalactic.Explicitly.DeterminedWord determined()
      • after

        public static org.scalactic.Explicitly.TheAfterWord after()
      • org$scalactic$Explicitly$_setter_$decided_$eq

        protected static void org$scalactic$Explicitly$_setter_$decided_$eq​(org.scalactic.Explicitly.DecidedWord x$1)
      • org$scalactic$Explicitly$_setter_$determined_$eq

        protected static void org$scalactic$Explicitly$_setter_$determined_$eq​(org.scalactic.Explicitly.DeterminedWord x$1)
      • org$scalactic$Explicitly$_setter_$after_$eq

        protected static void org$scalactic$Explicitly$_setter_$after_$eq​(org.scalactic.Explicitly.TheAfterWord x$1)
      • fullyMatch

        public static org.scalatest.words.FullyMatchWord fullyMatch()
      • startWith

        public static org.scalatest.words.StartWithWord startWith()
      • endWith

        public static org.scalatest.words.EndWithWord endWith()
      • include

        public static org.scalatest.words.IncludeWord include()
      • have

        public static org.scalatest.words.HaveWord have()
      • be

        public static org.scalatest.words.BeWord be()
      • contain

        public static org.scalatest.words.ContainWord contain()
      • not

        public static org.scalatest.words.NotWord not()
      • length

        public static org.scalatest.words.LengthWord length()
      • size

        public static org.scalatest.words.SizeWord size()
      • sorted

        public static org.scalatest.words.SortedWord sorted()
      • defined

        public static org.scalatest.words.DefinedWord defined()
      • exist

        public static org.scalatest.words.ExistWord exist()
      • readable

        public static org.scalatest.words.ReadableWord readable()
      • writable

        public static org.scalatest.words.WritableWord writable()
      • empty

        public static org.scalatest.words.EmptyWord empty()
      • compile

        public static org.scalatest.words.CompileWord compile()
      • typeCheck

        public static org.scalatest.words.TypeCheckWord typeCheck()
      • matchPattern

        public static org.scalatest.words.MatchPatternWord matchPattern()
      • org$scalatest$words$MatcherWords$_setter_$fullyMatch_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$fullyMatch_$eq​(org.scalatest.words.FullyMatchWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$startWith_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$startWith_$eq​(org.scalatest.words.StartWithWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$endWith_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$endWith_$eq​(org.scalatest.words.EndWithWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$include_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$include_$eq​(org.scalatest.words.IncludeWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$have_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$have_$eq​(org.scalatest.words.HaveWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$be_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$be_$eq​(org.scalatest.words.BeWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$contain_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$contain_$eq​(org.scalatest.words.ContainWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$not_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$not_$eq​(org.scalatest.words.NotWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$length_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$length_$eq​(org.scalatest.words.LengthWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$size_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$size_$eq​(org.scalatest.words.SizeWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$sorted_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$sorted_$eq​(org.scalatest.words.SortedWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$defined_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$defined_$eq​(org.scalatest.words.DefinedWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$exist_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$exist_$eq​(org.scalatest.words.ExistWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$readable_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$readable_$eq​(org.scalatest.words.ReadableWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$writable_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$writable_$eq​(org.scalatest.words.WritableWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$empty_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$empty_$eq​(org.scalatest.words.EmptyWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$compile_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$compile_$eq​(org.scalatest.words.CompileWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$typeCheck_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$typeCheck_$eq​(org.scalatest.words.TypeCheckWord x$1)
      • org$scalatest$words$MatcherWords$_setter_$matchPattern_$eq

        protected static void org$scalatest$words$MatcherWords$_setter_$matchPattern_$eq​(org.scalatest.words.MatchPatternWord x$1)
      • org$scalatest$WordSpecLike$$engine

        public static final org.scalatest.Engine org$scalatest$WordSpecLike$$engine()
      • stackDepth

        public static int stackDepth()
      • it

        protected static org.scalatest.WordSpecLike.ItWord it()
      • they

        protected static org.scalatest.WordSpecLike.TheyWord they()
      • subjectRegistrationFunction

        protected static org.scalatest.words.StringVerbBlockRegistration subjectRegistrationFunction()
      • subjectWithAfterWordRegistrationFunction

        protected static org.scalatest.words.SubjectWithAfterWordRegistration subjectWithAfterWordRegistrationFunction()
      • behave

        protected static org.scalatest.words.BehaveWord behave()
      • styleName

        public static final java.lang.String styleName()
      • org$scalatest$WordSpecLike$_setter_$org$scalatest$WordSpecLike$$engine_$eq

        protected static final void org$scalatest$WordSpecLike$_setter_$org$scalatest$WordSpecLike$$engine_$eq​(org.scalatest.Engine x$1)
      • org$scalatest$WordSpecLike$_setter_$stackDepth_$eq

        protected static void org$scalatest$WordSpecLike$_setter_$stackDepth_$eq​(int x$1)
      • org$scalatest$WordSpecLike$_setter_$it_$eq

        protected static void org$scalatest$WordSpecLike$_setter_$it_$eq​(org.scalatest.WordSpecLike.ItWord x$1)
      • org$scalatest$WordSpecLike$_setter_$they_$eq

        protected static void org$scalatest$WordSpecLike$_setter_$they_$eq​(org.scalatest.WordSpecLike.TheyWord x$1)
      • org$scalatest$WordSpecLike$_setter_$subjectRegistrationFunction_$eq

        protected static void org$scalatest$WordSpecLike$_setter_$subjectRegistrationFunction_$eq​(org.scalatest.words.StringVerbBlockRegistration x$1)
      • org$scalatest$WordSpecLike$_setter_$subjectWithAfterWordRegistrationFunction_$eq

        protected static void org$scalatest$WordSpecLike$_setter_$subjectWithAfterWordRegistrationFunction_$eq​(org.scalatest.words.SubjectWithAfterWordRegistration x$1)
      • org$scalatest$WordSpecLike$_setter_$behave_$eq

        protected static void org$scalatest$WordSpecLike$_setter_$behave_$eq​(org.scalatest.words.BehaveWord x$1)
      • org$scalatest$WordSpecLike$_setter_$styleName_$eq

        protected static final void org$scalatest$WordSpecLike$_setter_$styleName_$eq​(java.lang.String x$1)
      • NoArgTest

        public static org.scalatest.TestSuite.NoArgTest$ NoArgTest()
      • org$scalatest$Suite$_setter_$styleName_$eq

        protected static void org$scalatest$Suite$_setter_$styleName_$eq​(java.lang.String x$1)
      • assertionsHelper

        public static org.scalatest.Assertions.AssertionsHelper assertionsHelper()
      • succeed

        public static final org.scalatest.compatible.Assertion succeed()
      • org$scalatest$Assertions$_setter_$assertionsHelper_$eq

        protected static void org$scalatest$Assertions$_setter_$assertionsHelper_$eq​(org.scalatest.Assertions.AssertionsHelper x$1)
      • org$scalatest$Assertions$_setter_$succeed_$eq

        protected static final void org$scalatest$Assertions$_setter_$succeed_$eq​(org.scalatest.compatible.Assertion x$1)
      • akka$testkit$TestKitBase$$queue

        public static java.util.concurrent.LinkedBlockingDeque<TestActor.Message> akka$testkit$TestKitBase$$queue()
      • testActor

        public static ActorRef testActor()
      • akka$testkit$TestKitBase$$end

        public static scala.concurrent.duration.Duration akka$testkit$TestKitBase$$end()
      • akka$testkit$TestKitBase$$end_$eq

        public static void akka$testkit$TestKitBase$$end_$eq​(scala.concurrent.duration.Duration x$1)
      • akka$testkit$TestKitBase$$lastWasNoMsg

        public static boolean akka$testkit$TestKitBase$$lastWasNoMsg()
      • akka$testkit$TestKitBase$$lastWasNoMsg_$eq

        public static void akka$testkit$TestKitBase$$lastWasNoMsg_$eq​(boolean x$1)
      • akka$testkit$TestKitBase$_setter_$testKitSettings_$eq

        protected static void akka$testkit$TestKitBase$_setter_$testKitSettings_$eq​(TestKitSettings x$1)
      • akka$testkit$TestKitBase$_setter_$akka$testkit$TestKitBase$$queue_$eq

        protected static final void akka$testkit$TestKitBase$_setter_$akka$testkit$TestKitBase$$queue_$eq​(java.util.concurrent.LinkedBlockingDeque<TestActor.Message> x$1)
      • akka$testkit$TestKitBase$_setter_$testActor_$eq

        protected static void akka$testkit$TestKitBase$_setter_$testActor_$eq​(ActorRef x$1)
      • mayVerbStacktraceContextFrames

        public static int mayVerbStacktraceContextFrames()
      • optional

        public static void optional​(java.lang.String whenSkippedMessage,
                                    scala.Function0<scala.runtime.BoxedUnit> body)
      • optional

        public static void optional​(CapabilityFlag flag,
                                    scala.Function0<scala.runtime.BoxedUnit> test)
      • supportsRejectingNonSerializableObjects

        protected abstract static CapabilityFlag supportsRejectingNonSerializableObjects()
      • beforeEach

        protected void beforeEach()
        Specified by:
        beforeEach in interface org.scalatest.BeforeAndAfterEach
        Overrides:
        beforeEach in class PluginSpec
      • preparePersistenceId

        public void preparePersistenceId​(java.lang.String pid)
        Overridable hook that is called before populating the journal for the next test case. pid is the persistenceId that will be used in the test. This method may be needed to clean pre-existing events from the log.
        Parameters:
        pid - (undocumented)
      • supportsAtomicPersistAllOfSeveralEvents

        public boolean supportsAtomicPersistAllOfSeveralEvents()
        Implementation may override and return false if it does not support atomic writes of several events, as emitted by persistAll.
        Returns:
        (undocumented)
      • replayedMessage

        public JournalProtocol.ReplayedMessage replayedMessage​(long snr,
                                                               boolean deleted,
                                                               scala.collection.immutable.Seq<java.lang.String> confirms)
      • replayedMessage$default$2

        public boolean replayedMessage$default$2()
      • replayedMessage$default$3

        public scala.collection.immutable.Seq<java.lang.String> replayedMessage$default$3()
      • writeMessages

        public void writeMessages​(int fromSnr,
                                  int toSnr,
                                  java.lang.String pid,
                                  ActorRef sender,
                                  java.lang.String writerUuid)