ScalaTest 1.0
|
|
org/scalatest/Assertions.scala
]
final
class
Equalizer(left : Any)
extends
AnyRef===
in assertions in tests. For example:
assert(a === b)
The benefit of using assert(a === b)
rather than assert(a == b)
is
that a TestFailedException
produced by the former will include the values of a
and b
in its detail message.
The implicit method that performs the conversion from Any
to Equalizer
is
convertToEqualizer
in trait Assertions
.
In case you're not familiar with how implicit conversions work in Scala, here's a quick explanation.
The convertToEqualizer
method in Assertions
is defined as an "implicit" method that takes an
Any
, which means you can pass in any object, and it will convert it to an Equalizer
.
The Equalizer
has ===
defined. Most objects don't have ===
defined as a method
on them. Take two Strings, for example:
assert("hello" === "world")
Given this code, the Scala compiler looks for an ===
method on class String
, because that's the class of
"hello"
. String
doesn't define ===
, so the compiler looks for an implicit conversion from
String
to something that does have an ===
method, and it finds the convertToEqualizer
method. It
then rewrites the code to this:
assert(convertToEqualizer("hello").===("world"))
So inside a Suite
(which mixes in Assertions
, ===
will work on anything. The only
situation in which the implicit conversion wouldn't
happen is on types that have an ===
method already defined.
The primary constructor takes one object, left
, whose type is being converted to Equalizer
. The left
value may be a null
reference, because this is allowed by Scala's ==
operator.
left -
An object to convert to Equalizer
, which represents the left
value of an assertion.Method Summary | |
def
|
===
(right : Any) : scala.Option[java.lang.String]
The
=== operation compares this Equalizer 's left value (passed
to the constructor, usually via an implicit conversion) with the passed right value
for equality as determined by the expression left == right .
If true , === returns None . Else, === returns
a Some whose String value indicates the left and right values. |
Methods inherited from AnyRef | |
getClass, hashCode, equals, clone, toString, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized |
Methods inherited from Any | |
==, !=, isInstanceOf, asInstanceOf |
Method Details |
def
===(right : Any) : scala.Option[java.lang.String]
===
operation compares this Equalizer
's left
value (passed
to the constructor, usually via an implicit conversion) with the passed right
value
for equality as determined by the expression left == right
.
If true
, ===
returns None
. Else, ===
returns
a Some
whose String
value indicates the left
and right
values.
In its typical usage, the Option[String]
returned by ===
will be passed to one of two
of trait Assertion
' overloaded assert
methods. If None
,
which indicates the assertion succeeded, assert
will return normally. But if Some
is passed,
which indicates the assertion failed, assert
will throw a TestFailedException
whose detail
message will include the String
contained inside the Some
, which in turn includes the
left
and right
values. This TestFailedException
is typically embedded in a
Report
and passed to a Reporter
, which can present the left
and right
values to the user.
ScalaTest 1.0
|
|