// Test file stub for Assignment 0.5 in Comp 411 
  class SampleBoolExpTest extends junit.framework.TestCase {
  
  //  import BoolExp._ // Make members of BoolExp immediately available
  import BoolExp._
  import java.io._
  import junit.framework._
  import junit.framework.Assert._

  // Implicit conversions used for easier building of test cases
  // ! Since some variable "x" could be a Var or an IVar depending
  // ! on context, and likewise a boolean could be a Val or an IVal,
  // ! it's easier to use these implicit conversions when building tests.
  implicit def bool2Val(bool : Boolean) = Val(bool)
  implicit def bool2IVal(bool : Boolean) = IVal(bool)
  implicit def sym2Var(sym : Symbol) = Var(sym.name)
  implicit def sym2IVar(sym : Symbol) = IVar(sym.name)

  // Overloaded eval with 1 arg for convenience
  def eval(exp : IfExp) = BoolExp.eval(exp, Map.empty)

  // Convenience method for full BoolExp => IfExp => BoolExp conversion
  def rawReduce(exp : BoolExp) = convertToBool(eval(normalize(convertToIf(exp))))

  // Convenience declarations for tests
  val v = 'v
  val w = 'w
  val x = 'x
  val y = 'y
  val z = 'z
  val f1 = And(x,y)
  val if1 = IIf(x, y, false)
  val f2 = Or(x,y)
  val if2 = IIf(x, true, y)
  val f3 = Implies(x,y)
  val if3 = IIf(x, y, true)
  val f4 = Not(z)
  val if4 = IIf(z, false, true)
  val f5 = If(x, y, z)
  val if5 = IIf(x, y, z)
  val f6 = Or(And(x,y), Or(y,z))
  val if6 = IIf(IIf(x, y, false), true, IIf(y, true, z))
  val f7 = And(Or(x,y), And(y,z))
  val if7 = IIf(IIf(x, true, y), IIf(y, z, false), false)
  val f8 = Implies(Implies(x,y), And(y,z))
  val if8 = IIf(IIf(x, y, true), IIf(y, z, false), true)
  val nif8 = IIf(x, IIf(y, IIf(y, z, false), true), IIf(true, IIf(y, z, false), true))
  val enif8 = IIf(x, IIf(y, z, true), IIf(y, z, false))
  val if9 = IIf(if8, x, y)
  val nif9 = IIf(x, IIf(y, IIf(y, IIf(z, x, y), IIf(false, x, y)), IIf(true, x, y)),
               IIf(true, IIf(y, IIf(z, x, y), IIf(false, x, y)), IIf(true, x, y)))
  val enif9 = IIf(x, true, IIf(y, IIf(z, false, true), false))
  val nif10 = IIf(x, y, y)
  val enif10: IfExp = y
  val nif11 = IIf(x, true, false)
  val enif11: IfExp = x

  def testBoolExp() {
    // Tests

    // ArithExpr Defn tests
    assertEquals("Variable x not equals Variable y", true, x != y)
    assertEquals("Variable equals", Var("x"), Var("x"))
    assertFalse("Variable not equals", Var("x").equals(Var("y")))
    assertEquals("And equals", f1, And(x, y))
    assertEquals("Or equals", f2, Or(x, y))
    assertEquals("Implies equals", f3, Implies(x, y))
    assertEquals("Not equals", f4, Not(z))
    assertEquals("If equals", f5, If(x, y, z))
    
    // If-Conversion Tests
    assertEquals("Variable Conversion", IVar("x"), convertToIf(x));
    assertEquals("And Conversion", if1, convertToIf(f1));
    assertEquals("Or Conversion", if2, convertToIf(f2));
    assertEquals("Implies Conversion", if3, convertToIf(f3));
    assertEquals("Not Conversion", if4, convertToIf(f4));
    assertEquals("If Conversion", if5, convertToIf(f5));
    
    // Normalization Tests
    assertEquals("Normalize Variable", IVar("x"), normalize(x))
    assertEquals("Normalize true", True, normalize(true))
    assertEquals("Normalize false", False, normalize(false))
    assertEquals("Normalize Trivial If", if5, normalize(if5))

    // Symbolic Evaluation Tests"
    assertEquals("Eval Variable", IVar("x"), eval(x))
    assertEquals("Eval If Sub", IIf(x, y, IIf(y, false, z)), eval(IIf(x, IIf(x, y, z), IIf(y, x, z))))
    assertEquals("Eval Trivial If", if5, eval(if5))
    
    // Convert To Bool Tests
    assertEquals("Convert True", Val(true), convertToBool(true))
    assertEquals("Convert False", Val(false), convertToBool(false))
    assertEquals("Convert Not", Not(x), convertToBool(IIf(x, false, true)))
    assertEquals("Convert And", And(x, y), convertToBool(IIf(x, y, false)))
    assertEquals("Convert Or", Or(x, y), convertToBool(IIf(x, true, y)))
   
    // Full Tests
    assertEquals("Full 1", Val(true),
      rawReduce(Or(And(x, y), Or(And(x, Not(y)), Or(And(Not(x), y), And(Not(x), Not(y)))))))
    assertEquals("Full 2", Implies(x, Not(y)),
      rawReduce(Or(And(x, Not(y)), Or(And(Not(x), y), And(Not(x), Not(y))))))
    assertEquals("littleData1 exists", true, new File("littleData1.txt").isFile())
    assertEquals("littleData1", "T", new Parser(new File("littleData1.txt")).reduce)
  }
}