Packages

  • package root
    Definition Classes
    root
  • package org
    Definition Classes
    root
  • package scalatest

    ScalaTest's main traits, classes, and other members, including members supporting ScalaTest's DSL for the Scala interpreter.

    ScalaTest's main traits, classes, and other members, including members supporting ScalaTest's DSL for the Scala interpreter.

    Definition Classes
    org
  • package matchers

    Classes and traits for matchers.

    Classes and traits for matchers.

    This package is released as part of the scalatest-matchers-core module.

    Definition Classes
    scalatest
  • package dsl

    Classes and traits supporting ScalaTest's matchers DSL.

    Classes and traits supporting ScalaTest's matchers DSL.

    This package is released as part of the scalatest-matchers-core module.

    Definition Classes
    matchers
  • abstract class MatcherFactory6[-SC, TC1[_], TC2[_], TC3[_], TC4[_], TC5[_], TC6[_]] extends AnyRef

    A matcher factory that can produce a matcher given six typeclass instances.

    A matcher factory that can produce a matcher given six typeclass instances.

    In the type parameters for this class, "SC" means superclass; "TC" (in TC1, TC2, etc.) means typeclass. This class's matcher factory method will produce a Matcher[T], where T is a subtype of (or the same type as) SC, given a typeclass instance for each TCn implicit parameter (for example, a TC1[T], TC2[T], etc.).

    Definition Classes
    dsl
  • AndBeWord
  • AndContainWord
  • AndEndWithWord
  • AndFullyMatchWord
  • AndHaveWord
  • AndIncludeWord
  • AndNotWord
  • AndStartWithWord
  • OrBeWord
  • OrContainWord
  • OrEndWithWord
  • OrFullyMatchWord
  • OrHaveWord
  • OrIncludeWord
  • OrNotWord
  • OrStartWithWord
ScalaTest is brought to you by:

final class OrNotWord extends AnyRef

This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Source
MatcherFactory6.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. OrNotWord
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new OrNotWord(prettifier: Prettifier, pos: Position)

Value Members

  1. def be(definedWord: DefinedWord): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, [-T]Definition[T]]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcherFactory or not be defined
                           ^
    

  2. def be(emptyWord: EmptyWord): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, [-T]Emptiness[T]]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcherFactory or not be empty
                           ^
    

  3. def be(writableWord: WritableWord): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, [-T]Writability[T]]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcherFactory or not be writable
                           ^
    

  4. def be(readableWord: ReadableWord): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, [-T]Readability[T]]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcherFactory or not be readable
                           ^
    

  5. def be(sortedWord: SortedWord): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, [-S]Sortable[S]]

    This method enables the following syntax, where fraction is a PartialFunction:

    This method enables the following syntax, where fraction is a PartialFunction:

    aMatcherFactory or not be sorted
                           ^
    

  6. def be[A, U <: PartialFunction[A, _]](resultOfDefinedAt: ResultOfDefinedAt[A]): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax, where fraction is a PartialFunction:

    This method enables the following syntax, where fraction is a PartialFunction:

    aMatcherFactory or not be definedAt (8)
                           ^
    

  7. def be[U](spread: Spread[U]): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax for the "primitive" numeric types:

    This method enables the following syntax for the "primitive" numeric types:

    aMatcherFactory or not be (17.0 +- 0.2)
                           ^
    

  8. def be(resultOfTheSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication): MatcherFactory6[SC, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be theSameInstanceAs (string)
                           ^
    

  9. macro def be(anType: ResultOfAnTypeInvocation[_]): MatcherFactory6[SC, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be an [Apple]
                           ^
    

  10. macro def be(aType: ResultOfATypeInvocation[_]): MatcherFactory6[SC, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be a [Book]
                           ^
    

  11. def be[U](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[U]): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6, where invalidMarks is an AnMatcher:

    This method enables the following syntax given a MatcherFactory6, where invalidMarks is an AnMatcher:

    aMatcherFactory and not be an (invalidMarks)
                            ^
    

  12. def be[U <: AnyRef](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[U]): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6, where apple is a BePropertyMatcher:

    This method enables the following syntax given a MatcherFactory6, where apple is a BePropertyMatcher:

    aMatcherFactory or not be an (apple)
                           ^
    

  13. def be[U <: AnyRef](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U]): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6, where file is a BePropertyMatcher:

    This method enables the following syntax given a MatcherFactory6, where file is a BePropertyMatcher:

    aMatcherFactory or not be a (file)
                           ^
    

  14. def be[U](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[U]): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6, where validMarks is an AMatcher:

    This method enables the following syntax given a MatcherFactory6, where validMarks is an AMatcher:

    aMatcherFactory or not be a (validMarks)
                           ^
    

  15. def be[U](bePropertyMatcher: BePropertyMatcher[U]): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6, where file is a BePropertyMatcher:

    This method enables the following syntax given a MatcherFactory6, where file is a BePropertyMatcher:

    aMatcherFactory or not be (file)
                           ^
    

  16. def be[U](beMatcher: BeMatcher[U]): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6, where odd is a BeMatcher:

    This method enables the following syntax given a MatcherFactory6, where odd is a BeMatcher:

    aMatcherFactory or not be (odd)
                           ^
    

  17. def be(tripleEqualsInvocation: TripleEqualsInvocation[_]): MatcherFactory6[SC, TC1, TC2, TC3, TC4, TC5, TC6]

    The deprecation period for the "be ===" syntax has expired, and the syntax will now throw NotAllowedException. Please use should equal, should ===, shouldEqual, should be, or shouldBe instead.

    The deprecation period for the "be ===" syntax has expired, and the syntax will now throw NotAllowedException. Please use should equal, should ===, shouldEqual, should be, or shouldBe instead.

    Note: usually syntax will be removed after its deprecation period. This was left in because otherwise the syntax could in some cases still compile, but silently wouldn't work.

  18. def be[U](resultOfGreaterThanOrEqualToComparison: ResultOfGreaterThanOrEqualToComparison[U]): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be >= (6)
                           ^
    

  19. def be[U](resultOfLessThanOrEqualToComparison: ResultOfLessThanOrEqualToComparison[U]): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be <= (2)
                           ^
    

  20. def be[U](resultOfGreaterThanComparison: ResultOfGreaterThanComparison[U]): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be > (6)
                           ^
    

  21. def be[U](resultOfLessThanComparison: ResultOfLessThanComparison[U]): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be < (8)
                           ^
    

  22. def be(o: Null): MatcherFactory6[SC, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be (null)
                           ^
    

  23. def be(any: Any): MatcherFactory6[SC, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not be (2)
                           ^
    

  24. def contain(right: ResultOfAtMostOneElementOfApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Aggregating]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain atMostOneElementOf (List(8, 1, 2))
                           ^
    

  25. def contain(right: ResultOfAtMostOneOfApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Aggregating]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain atMostOneOf (8, 1, 2)
                           ^
    

  26. def contain(right: ResultOfInOrderElementsOfApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Sequencing]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain inOrderElementsOf (8, 1, 2)
                           ^
    

  27. def contain(right: ResultOfInOrderApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Sequencing]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain inOrder (8, 1, 2)
                           ^
    

  28. def contain(right: ResultOfAllElementsOfApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Aggregating]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain allOf (8, 1, 2)
                           ^
    

  29. def contain(right: ResultOfAllOfApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Aggregating]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain allOf (8, 1, 2)
                           ^
    

  30. def contain(right: ResultOfInOrderOnlyApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Sequencing]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain inOrderOnly (8, 1, 2))
                           ^
    

  31. def contain(right: ResultOfOnlyApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Aggregating]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain only (8, 1, 2)
                           ^
    

  32. def contain(right: ResultOfTheSameElementsInOrderAsApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Sequencing]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain theSameElementsInOrderAs (List(8, 1, 2))
                           ^
    

  33. def contain(right: ResultOfTheSameElementsAsApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Aggregating]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain theSameElementsAs (List(8, 1, 2))
                           ^
    

  34. def contain(right: ResultOfNoElementsOfApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Containing]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain noElementsOf (8, 1, 2)
                           ^
    

  35. def contain(right: ResultOfNoneOfApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Containing]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain noneOf (8, 1, 2)
                           ^
    

  36. def contain(right: ResultOfAtLeastOneElementOfApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Aggregating]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain atLeastOneElementOf (8, 1, 2)
                           ^
    

  37. def contain(right: ResultOfAtLeastOneOfApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Aggregating]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain atLeastOneOf (8, 1, 2)
                           ^
    

  38. def contain(right: ResultOfOneElementOfApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Containing]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain oneOf (8, 1, 2)
                           ^
    

  39. def contain(right: ResultOfOneOfApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Containing]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain oneOf (8, 1, 2)
                           ^
    

  40. def contain(resultOfValueWordApplication: ResultOfValueWordApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, ValueMapping]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain value (3)
                           ^
    

  41. def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, KeyMapping]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain key ("three")
                           ^
    

  42. def contain[U](expectedElement: U): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Containing]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not contain (3)
                           ^
    

  43. def endWith(expectedSubstring: String): MatcherFactory6[SC with String, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not endWith ("1.7")
                           ^
    

  44. def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory6[SC with String, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not endWith regex (decimal)
                           ^
    

  45. def equal(o: Null): MatcherFactory6[SC, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not equal (null)
                           ^
    

  46. def equal[U](spread: Spread[U]): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax for the "primitive" numeric types:

    This method enables the following syntax for the "primitive" numeric types:

    aMatcherFactory or not equal (17.0 +- 0.2)
                           ^
    

  47. def equal(any: Any): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Equality]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not equal (3 - 1)
                           ^
    

  48. def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory6[SC with String, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not fullyMatch regex (decimal)
                           ^
    

  49. def have[U](firstPropertyMatcher: HavePropertyMatcher[U, _], propertyMatchers: HavePropertyMatcher[U, _]*): MatcherFactory6[SC with U, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not have (author ("Melville"))
                           ^
    

  50. def have(resultOfMessageWordApplication: ResultOfMessageWordApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Messaging]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not have message ("Message from Mars!")
                           ^
    

  51. def have(resultOfSizeWordApplication: ResultOfSizeWordApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Size]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not have size (3)
                           ^
    

  52. def have(resultOfLengthWordApplication: ResultOfLengthWordApplication): MatcherFactory7[SC, TC1, TC2, TC3, TC4, TC5, TC6, Length]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not have length (3)
                           ^
    

  53. def include(expectedSubstring: String): MatcherFactory6[SC with String, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not include ("1.7")
                           ^
    

  54. def include(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory6[SC with String, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not include regex (decimal)
                           ^
    

  55. macro def matchPattern(right: PartialFunction[Any, _]): Matcher[Any]

    This method enables the following syntax:

    This method enables the following syntax:

    aMatcherFactory or not matchPattern { case Person("Bob", _) =>}
                           ^
    

  56. val owner: MatcherFactory6[SC, TC1, TC2, TC3, TC4, TC5, TC6]

    Get the MatcherFactory instance, currently used by macro.

  57. def startWith(expectedSubstring: String): MatcherFactory6[SC with String, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not startWith ("1.7")
                           ^
    

  58. def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): MatcherFactory6[SC with String, TC1, TC2, TC3, TC4, TC5, TC6]

    This method enables the following syntax given a MatcherFactory6:

    This method enables the following syntax given a MatcherFactory6:

    aMatcherFactory or not startWith regex (decimal)
                           ^