ResultOfCollectedAny

Value Members

1. final def !=(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

2. final def ##(): Int

   

   Definition Classes

   AnyRef → Any

3. final def ==(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

4. final def asInstanceOf[T0]: T0

   

   Definition Classes

   Any

5. def clone(): AnyRef

   

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @throws( ... )

6. final def eq(arg0: AnyRef): Boolean

   

   Definition Classes

   AnyRef

7. def equals(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

8. def finalize(): Unit

   

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @throws( classOf[java.lang.Throwable] )

9. final def getClass(): Class[_]

   

   Definition Classes

   AnyRef → Any

10. def hashCode(): Int

    

    Definition Classes

    AnyRef → Any

11. final def isInstanceOf[T0]: Boolean

    

    Definition Classes

    Any

12. final def ne(arg0: AnyRef): Boolean

    

    Definition Classes

    AnyRef

13. final def notify(): Unit

    

    Definition Classes

    AnyRef

14. final def notifyAll(): Unit

    

    Definition Classes

    AnyRef

15. def should(fullyMatchWord: FullyMatchWord)(implicit ev: <:<[T, String]): ResultOfFullyMatchWordForCollectedString

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(string) should fullyMatch regex ("""(-)?(\d+)(\.\d*)?""")
                ^
    

16. def should(includeWord: IncludeWord)(implicit ev: <:<[T, String]): ResultOfIncludeWordForCollectedString

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(string) should include regex ("wo.ld")
                ^
    

17. def should(endWithWord: EndWithWord)(implicit ev: <:<[T, String]): ResultOfEndWithWordForCollectedString

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(string) should endWith regex ("wo.ld")
                ^
    

18. def should(startWithWord: StartWithWord)(implicit ev: <:<[T, String]): ResultOfStartWithWordForCollectedString

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(string) should startWith regex ("Hel*o")
                ^
    

19. def should(notExist: ResultOfNotExist)(implicit existence: Existence[T]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(xs) should not (exist)
            ^
    

20. def should(existWord: ExistWord)(implicit existence: Existence[T]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(xs) should exist
            ^
    

21. def should(containWord: ContainWord): ResultOfContainWordForCollectedAny[T]

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all (xs) should contain oneOf (1, 2, 3)
             ^
    

22. def should(inv: TripleEqualsInvocationOnSpread[T])(implicit ev: Numeric[T]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all (xs) should === (100 +- 1)
             ^
    

23. def should[U](inv: TripleEqualsInvocation[U])(implicit constraint: CanEqual[T, U]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all (xs) should === (b)
             ^
    

24. def should(haveWord: HaveWord): ResultOfHaveWordForCollectedExtent[T]

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all (results) should have length (3)
           ^
    all (results) should have size (3)
           ^
    

25. def should(notWord: NotWord): ResultOfNotWordForCollectedAny[T]

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(xs) should not equal (3)
            ^
    

26. def should(beWord: BeWord): ResultOfBeWordForCollectedAny[T]

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(xs) should be theSameInstanceAs anotherObject
            ^
    

27. def should[TYPECLASS1[_], TYPECLASS2[_]](rightMatcherFactory2: MatcherFactory2[T, TYPECLASS1, TYPECLASS2])(implicit typeClass1: TYPECLASS1[T], typeClass2: TYPECLASS2[T]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(xs) should (equal (expected) and have length 12)
            ^
    

28. def should[TYPECLASS1[_]](rightMatcherFactory1: MatcherFactory1[T, TYPECLASS1])(implicit typeClass1: TYPECLASS1[T]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(xs) should equal (3)
            ^
    

29. def should(rightMatcher: Matcher[T]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(xs) should be (3)
            ^
    

30. def shouldBe[U <: T](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[U])(implicit ev: <:<[T, AnyRef]): Assertion

    

    This method enables the following syntax, where excellentRead refers to a BePropertyMatcher[Book]:

    This method enables the following syntax, where excellentRead refers to a BePropertyMatcher[Book]:

    all(xs) shouldBe an (excellentRead)
            ^
    

31. def shouldBe[U <: T](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U])(implicit ev: <:<[T, AnyRef]): Assertion

    

    This method enables the following syntax, where goodRead refers to a BePropertyMatcher[Book]:

    This method enables the following syntax, where goodRead refers to a BePropertyMatcher[Book]:

    all(xs) shouldBe a (goodRead)
            ^
    

32. def shouldBe[U <: T](bePropertyMatcher: BePropertyMatcher[U])(implicit ev: <:<[T, AnyRef]): Assertion

    

    This method enables the following syntax, where excellentRead refers to a BePropertyMatcher[Book]:

    This method enables the following syntax, where excellentRead refers to a BePropertyMatcher[Book]:

    all(xs) shouldBe excellentRead
            ^
    

33. def shouldBe(o: Null)(implicit ev: <:<[T, AnyRef]): Assertion

    

    This method enables the following syntax:

    This method enables the following syntax:

    all(xs) shouldBe null
            ^
    

34. def shouldBe(resultOfAnWordApplication: ResultOfAnWordToSymbolApplication)(implicit toAnyRef: <:<[T, AnyRef]): Assertion

    

    This method enables the following syntax:

    This method enables the following syntax:

    all(xs) shouldBe an ('empty)
            ^
    

35. def shouldBe(resultOfAWordApplication: ResultOfAWordToSymbolApplication)(implicit toAnyRef: <:<[T, AnyRef]): Assertion

    

    This method enables the following syntax:

    This method enables the following syntax:

    all(xs) shouldBe a ('empty)
            ^
    

36. def shouldBe(symbol: Symbol)(implicit toAnyRef: <:<[T, AnyRef]): Assertion

    

    This method enables the following syntax:

    This method enables the following syntax:

    all(xs) shouldBe 'empty
            ^
    

37. def shouldBe(resultOfSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication)(implicit toAnyRef: <:<[T, AnyRef]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(xs) shouldBe theSameInstanceAs (anotherObject)
            ^
    

38. def shouldBe(spread: Spread[T]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(xs) shouldBe 7.1 +- 0.2
            ^
    

39. def shouldBe(beMatcher: BeMatcher[T]): Assertion

    

    This method enables the following syntax, where odd refers to a BeMatcher[Int]:

    This method enables the following syntax, where odd refers to a BeMatcher[Int]:

    testing
    all(xs) shouldBe odd
            ^
    

40. def shouldBe(comparison: ResultOfGreaterThanOrEqualToComparison[T]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(8, 9, 10) shouldBe >= (7)
                  ^
    

41. def shouldBe(comparison: ResultOfGreaterThanComparison[T]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(8, 9, 10) shouldBe > (7)
                  ^
    

42. def shouldBe(comparison: ResultOfLessThanOrEqualToComparison[T]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(4, 5, 6) shouldBe <= (7)
                 ^
    

43. def shouldBe(comparison: ResultOfLessThanComparison[T]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(4, 5, 6) shouldBe < (7)
                 ^
    

44. def shouldBe(right: Any): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all (xs) shouldBe 7
             ^
    

45. def shouldBe(anType: ResultOfAnTypeInvocation[_]): Assertion

    

    This method enables the following syntax:

    This method enables the following syntax:

    all(xs) shouldBe an [Type]
            ^
    

46. def shouldBe(aType: ResultOfATypeInvocation[_]): Assertion

    

    This method enables the following syntax:

    This method enables the following syntax:

    all(xs) shouldBe a [Type]
            ^
    

47. def shouldBe(definedWord: DefinedWord)(implicit definition: Definition[T]): Assertion

    

    This method enables the following syntax:

    This method enables the following syntax:

    all(xs) shouldBe defined
            ^
    

48. def shouldBe(emptyWord: EmptyWord)(implicit emptiness: Emptiness[T]): Assertion

    

    This method enables the following syntax:

    This method enables the following syntax:

    all(xs) shouldBe empty
            ^
    

49. def shouldBe(writableWord: WritableWord)(implicit writability: Writability[T]): Assertion

    

    This method enables the following syntax:

    This method enables the following syntax:

    all(xs) shouldBe writable
            ^
    

50. def shouldBe(readableWord: ReadableWord)(implicit readability: Readability[T]): Assertion

    

    This method enables the following syntax:

    This method enables the following syntax:

    all(xs) shouldBe readable
            ^
    

51. def shouldBe(sortedWord: SortedWord)(implicit sortable: Sortable[T]): Assertion

    

    This method enables the following syntax:

    This method enables the following syntax:

    all(xs) shouldBe sorted
            ^
    

52. def shouldEqual(right: Null)(implicit ev: <:<[T, AnyRef]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    result shouldEqual null
           ^
    

53. def shouldEqual(spread: Spread[T]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    result shouldEqual 7.1 +- 0.2
           ^doCollected
    

54. def shouldEqual(right: Any)(implicit equality: Equality[T]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all (xs) shouldEqual 7
             ^
    

55. def shouldNot(includeWord: IncludeWord)(implicit ev: <:<[T, String]): ResultOfIncludeWordForCollectedString

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(string) shouldNot include regex ("wo.ld")
                ^
    

56. def shouldNot(endWithWord: EndWithWord)(implicit ev: <:<[T, String]): ResultOfEndWithWordForCollectedString

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(string) shouldNot endWith regex ("wo.ld")
                ^
    

57. def shouldNot(startWithWord: StartWithWord)(implicit ev: <:<[T, String]): ResultOfStartWithWordForCollectedString

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(string) shouldNot startWith regex ("Hel*o")
                ^
    

58. def shouldNot(fullyMatchWord: FullyMatchWord)(implicit ev: <:<[T, String]): ResultOfFullyMatchWordForCollectedString

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(string) shouldNot fullyMatch regex ("""(-)?(\d+)(\.\d*)?""")
                ^
    

59. def shouldNot(existWord: ExistWord)(implicit existence: Existence[T]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(xs) shouldNot exist
            ^
    

60. def shouldNot(containWord: ContainWord): ResultOfContainWordForCollectedAny[T]

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all (xs) shouldNot contain (oneOf (1, 2, 3))
             ^
    

61. def shouldNot(beWord: BeWord): ResultOfBeWordForCollectedAny[T]

    

    This method enables the following syntax:

    This method enables the following syntax:

    all(xs) shouldNot be theSameInstanceAs anotherInstance
            ^
    

62. def shouldNot[TYPECLASS1[_]](rightMatcherFactory1: MatcherFactory1[T, TYPECLASS1])(implicit typeClass1: TYPECLASS1[T]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(xs) shouldNot (equal (3))
            ^
    

63. def shouldNot[U <: T](rightMatcherX1: Matcher[U]): Assertion

    

    This method enables syntax such as the following:

    This method enables syntax such as the following:

    all(xs) shouldNot (be (3))
            ^
    

64. final def synchronized[T0](arg0: ⇒ T0): T0

    

    Definition Classes

    AnyRef

65. def toString(): String

    

    Overrides to return pretty toString.

    Overrides to return pretty toString.

    returns

    "ResultOfCollectedAny([collected], [xs])"

    Definition Classes

    ResultOfCollectedAny → AnyRef → Any

66. final def wait(): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

67. final def wait(arg0: Long, arg1: Int): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

68. final def wait(arg0: Long): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )