Equalizer

I wrote a cool Equalizer class in Scala that allows me to do assertions that are more readable than traditional assertions.

Quick side note: (Equalizer is really an idea shamelessly stolen from Bill Venners Equalizer in ScalaTest. Hopefully we'll add my methods in as well.)

My Equalizer lets me do things like:

val x = 5
x mustBe 5

This replaces the more common assertEquals( x, 5 ), and I think it does so nicely.

You can also do a few more sophisticated things with it, like so:

val x = 5
x mustBe ( 3 or 4 or 5 )

I probably could have used "in" here, such as x mustBe in( 3, 4, 5 ) ... what do you think?

Additionally:

val x = 5
x cantBe 6

For whatever this one is worth (I've actually found use cases for it):

val x = false
x canBeNullOr false

val y = 6
y canBeNullOr ( 5 or 6 )

This works by implicitly converting Any to Equalizer, which contains the methods above. The code can be found below.

import org.testng.Assert._

case object Equalizer {
  implicit def anyToCompare(a: Any) = new Equalizer(a)
}

class Equalizer(a: Any) {

  def mustBe(bs: Any*): Unit = {
    bs(0) match {
      case x:MyTuple => x mustBe a
      case _ => {
        val message = "In Equalizer: expecting one of=" + bs + "\nIn Equalizer: actual  =" + a
        println(message)
        bs size match {
          case 1 => assertEquals(a, bs(0), message)
          case _ => assertTrue(bs.contains(a), message)
        }
      }
    }
  }

  def canBeNullOr(bs: Any*) = {
    if (a != null) mustBe(bs: _*)
    else println("In Equalizer: expecting one of=" + bs + " or null\nIn Equalizer: actual  =" + a)
  }

  def cantBe(b: Any) = assertFalse(a == b)

  def is(b: Any) = a equals b

  def or(b: Any) = {
    a match {
      case x:MyTuple => x + b
      case _ => MyTuple2(a, b)
    }
  }

  import Equalizer._

  trait MyTuple{
    def +(b: Any): MyTuple
    def mustBe(a: Any): Unit
  }
  case class MyTuple2(y: Any, z: Any) extends MyTuple{
    def +(b: Any): MyTuple = MyTuple3(y, z, b)
    def mustBe(a: Any): Unit = a mustBe (y,z)
  }
  case class MyTuple3(x: Any, y: Any, z: Any) extends MyTuple{
    def +(b: Any): MyTuple = MyTuple4(x, y, z, b)
    def mustBe(a: Any): Unit = a mustBe (x,y,z)
  }
  case class MyTuple4(w: Any, x: Any, y: Any, z: Any) extends MyTuple{
    def +(b: Any): MyTuple = MyTuple5(w, x, y, z, b)
    def mustBe(a: Any): Unit = a mustBe (w,x,y,z)
  }
  case class MyTuple5(v: Any, w: Any, x: Any, y: Any, z: Any) extends MyTuple{
    def +(b: Any): MyTuple = MyTuple6(v, w, x, y, z, b)
    def mustBe(a: Any): Unit = a mustBe (v,w,x,y,z)
  }
  case class MyTuple6(u: Any, v: Any, w: Any, x: Any, y: Any, z: Any) extends MyTuple{
    def +(b: Any): MyTuple = throw new IllegalArgumentException("too many ors")
    def mustBe(a: Any): Unit = a mustBe (u,v,w,x,y,z)
  }
}

Sorry about MyTuple...I wanted people to be able to use Tuples as arguments in their mustBe statements, so I had to make sure I didn't pass in a Tuple into mustBe, via the "or" method. Anyway, Tuples don't even appear to be working so....ugh... If anyone can help me clean this up, that would be awesome.

Regardless, what do you think? I really like using the code in tests, even if the Equalizer class itself is a bit hairy.