import java.io._
import junit.framework._
import junit.framework.Assert._

class Assign3Test extends TestCase {
  
  /** The following 9 check methods create an interpreter object with the
    * specified String as the program, invoke the respective evaluation
    * method (valueValue, valueName, valueNeed, etc.), and check that the 
    * result matches the (given) expected output.  
    */
  
  private def valueValueCheck(name: String, answer: String, program: String) {
    val interp = new Interpreter(new StringReader(program)) 
    assertEquals("by-value-value " + name, answer, interp.valueValue.toString) 
  }
  
  private def valueNameCheck(name: String, answer: String, program: String) {
    val interp = new Interpreter(new StringReader(program)) 
    assertEquals("by-value-name " + name, answer, interp.valueName.toString) 
  }
  
  private def valueNeedCheck(name: String, answer: String, program: String) {
    val interp = new Interpreter(new StringReader(program)) 
    assertEquals("by-value-need " + name, answer, interp.valueNeed.toString) 
  }
  
  private def nameValueCheck(name: String, answer: String, program: String) {
    val interp = new Interpreter(new StringReader(program)) 
    assertEquals("by-value " + name, answer, interp.nameValue.toString)
  }
  
  private def nameNameCheck(name: String, answer: String, program: String) {
    val interp = new Interpreter(new StringReader(program)) 
    assertEquals("by-name " + name, answer, interp.nameName.toString) 
  }
  
  private def nameNeedCheck(name: String, answer: String, program: String) {
    val interp = new Interpreter(new StringReader(program)) 
    assertEquals("by-need " + name, answer, interp.nameNeed.toString) 
  }
  
  private def needValueCheck(name: String, answer: String, program: String) {
    val interp = new Interpreter(new StringReader(program)) 
    assertEquals("by-value " + name, answer, interp.needValue.toString) 
  }
  
  private def needNameCheck(name: String, answer: String, program: String) {
    val  interp = new Interpreter(new StringReader(program)) 
    assertEquals("by-name " + name, answer, interp.needName.toString) 
  }
   
  private def needNeedCheck(name: String, answer: String, program: String) {
      val  interp = new Interpreter(new StringReader(program)) 
      assertEquals("by-need " + name, answer, interp.needNeed.toString) 
  }

  private def allCheck(name: String, answer: String, program: String) {
    valueValueCheck(name, answer, program) 
    valueNameCheck(name, answer, program) 
    valueNeedCheck(name, answer, program) 
    nameValueCheck(name, answer, program) 
    nameNameCheck(name, answer, program) 
    nameNeedCheck(name, answer, program) 
    needValueCheck(name, answer, program) 
    needNameCheck(name, answer, program) 
    needNeedCheck(name, answer, program) 
  }

  private def noNameCheck(name: String, answer: String, program: String) {
    valueValueCheck(name, answer, program) 
    valueNameCheck(name, answer, program) 
    valueNeedCheck(name, answer, program) 
    needValueCheck(name, answer, program) 
    needNameCheck(name, answer, program) 
    needNeedCheck(name, answer, program) 
  }

  private def needCheck(name: String, answer: String, program: String) {
    needValueCheck(name, answer, program) 
    needNeedCheck(name, answer, program) 
  }

  private def lazyCheck(name: String, answer: String, program: String) {
    valueNameCheck(name, answer, program) 
    valueNeedCheck(name, answer, program) 
    nameNameCheck(name, answer, program) 
    nameNeedCheck(name, answer, program) 
    needNameCheck(name, answer, program) 
    needNeedCheck(name, answer, program) 
  }

  def testNumberP() {
    try {
      val output = "number?" 
      val input = "number?" 
      allCheck("numberP", output, input ) 

    } catch {
      case e:Exception => 
        e.printStackTrace() 
        fail("numberP threw " + e) 
    }
  } //end of method
  

  def testMathOp() {
    try {
      val output = "30" 
      val input = "2 * (3 + 12)" 
      allCheck("mathOp", output, input ) 

    } catch {
      case e:Exception =>
        e.printStackTrace() 
        fail("mathOp threw " + e) 
    }
  } //end of method
  

  def testParseException() {
    try {
      val output = "haha" 
      val input = " 1 +" 
      allCheck("parseException", output, input ) 
      
      fail("parseException did not throw ParseException exception") 
    } catch {
      case p: ParseException => /* do nothing */
        //p.printStackTrace();     
      case e: Exception => 
        e.printStackTrace() 
        fail("parseException threw " + e) 
    }
  } //end of method
  

  def testEvalException() {
    try {
      val output = "mojo" 
      val input = "1 + number?" 
      allCheck("evalException", output, input ) 

         fail("evalException did not throw EvalException exception") 
    } catch {
      case e: EvalException => /* do nothing */   
//        e.printStackTrace();
      case e: Exception =>
        e.printStackTrace() 
        fail("evalException threw " + e) 
    }
  } //end of method
  
  def testAppend() {
    try {
      val output = "(1 2 3 1 2 3)" 
      val input = "let Y    := map f to              let g := map x to f(map z1,z2 to (x(x))(z1,z2));     in g(g);  APPEND := map ap to            map x,y to               if x = empty then y else cons(first(x), ap(rest(x), y)); l      := cons(1,cons(2,cons(3,empty))); in (Y(APPEND))(l,l)" 
      allCheck("append", output, input ) 

    } catch {
      case e: Exception =>
        e.printStackTrace() 
        fail("append threw " + e) 
    }
  } //end of method
  

  def testLetRec() {
    try {
      val output = "(1 2 3 1 2 3)" 
      val input = "let append :=       map x,y to          if x = empty then y else cons(first(x), append(rest(x), y));    l      := cons(1,cons(2,cons(3,empty))); in append(l,l)" 
      allCheck("letRec", output, input ) 

    } catch {
      case e:Exception =>
        e.printStackTrace() 
        fail("letRec threw " + e) 
    }
  } //end of method
}