org.scalatest.Assertions

# Equalizer

#### class Equalizer extends AnyRef

Class used via an implicit conversion to enable any two objects to be compared with `===` 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.

Attributes
  final

Linear Supertypes
AnyRef, Any
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. Hide All
2. Show all

1. Equalizer
2. AnyRef
3. Any

Visibility

1. Public
2. All

### Instance Constructors

1. #### new Equalizer (left: Any)

   left

     An object to convert to `Equalizer`, which represents the `left` value of an assertion.

### Value Members

1. #### def != (arg0: AnyRef): Boolean

   Attributes
     final
   Definition Classes
     AnyRef

2. #### def != (arg0: Any): Boolean

   Attributes
     final
   Definition Classes
     Any

3. #### def ## (): Int

   Attributes
     final
   Definition Classes
     AnyRef → Any

4. #### def == (arg0: AnyRef): Boolean

   Attributes
     final
   Definition Classes
     AnyRef

5. #### def == (arg0: Any): Boolean

   Attributes
     final
   Definition Classes
     Any

6. #### def === (right: Any): Option[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`.

   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.

   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.

7. #### def asInstanceOf [T0] : T0

   Attributes
     final
   Definition Classes
     Any

8. #### def clone (): AnyRef

   Attributes
     protected[lang]
   Definition Classes
     AnyRef
   Annotations
     @throws()

9. #### def eq (arg0: AnyRef): Boolean

   Attributes
     final
   Definition Classes
     AnyRef

10. #### def equals (arg0: Any): Boolean

    Definition Classes
      AnyRef → Any

11. #### def finalize (): Unit

    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws()

12. #### def getClass (): java.lang.Class[_]

    Attributes
      final
    Definition Classes
      AnyRef

13. #### def hashCode (): Int

    Definition Classes
      AnyRef → Any

14. #### def isInstanceOf [T0] : Boolean

    Attributes
      final
    Definition Classes
      Any

15. #### def ne (arg0: AnyRef): Boolean

    Attributes
      final
    Definition Classes
      AnyRef

16. #### def notify (): Unit

    Attributes
      final
    Definition Classes
      AnyRef

17. #### def notifyAll (): Unit

    Attributes
      final
    Definition Classes
      AnyRef

18. #### def synchronized [T0] (arg0: ⇒ T0): T0

    Attributes
      final
    Definition Classes
      AnyRef

19. #### def toString (): String

    Definition Classes
      AnyRef → Any

20. #### def wait (): Unit

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

21. #### def wait (arg0: Long, arg1: Int): Unit

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

22. #### def wait (arg0: Long): Unit

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

### Inherited from AnyRef

### Inherited from Any