info/labs/lab04/test/resources/typer/passing/IfWithError.grading.amy

+object If
+  val a: Int(32) = if (true) { error("") } else { error("") };
+  val x: Int(32) = if (true) { 1 } else { 2 };
+  x
+end If

info/labs/lab04/test/resources/typer/passing/LetWithError.grading.amy

+object LetWithError
+  val y: Int(32) = (val x: Int(32) = 1; error("this is fine"));
+  y
+end LetWithError
\ No newline at end of file

info/labs/lab04/test/resources/typer/passing/Logical.grading.amy

+object Logical
+  true || false && !false
+end Logical

info/labs/lab04/test/resources/typer/passing/Match1.grading.amy

+object Match1
+  1 match {
+    case _ => ()
+  }
+end Match1

info/labs/lab04/test/resources/typer/passing/Match2.grading.amy

+object Match2
+  1 match {
+    case x => x + 1
+  }
+end Match2

info/labs/lab04/test/resources/typer/passing/Match3.grading.amy

+object Constructors
+  abstract class Foo 
+  case class Bar(i: Int(32)) extends Foo
+  case class Baz(b: Boolean, f: Foo) extends Foo
+
+  abstract class Foo2
+  case class Bar2(i: Int(32)) extends Foo2
+  case class Baz2(b: Boolean, f: Foo2) extends Foo2
+
+  val x: Boolean = Bar(1) match {
+    case Bar(1) => true
+    case Baz(x, Baz(y, Bar(z))) =>
+      x || y && z < 0
+    case Baz(_, Bar(_)) => false
+  };
+  x
+end Constructors

info/labs/lab04/test/resources/typer/passing/MatchWithError.grading.amy

+object Match2
+  val a: Int(32) = 1 match {
+    case x => error("")
+  };
+  a
+end Match2

info/labs/lab04/test/resources/typer/passing/Misc.grading.amy

+object Misc
+  error("a" ++ "b")
+end Misc

info/labs/lab04/test/resources/typer/passing/Seq.grading.amy

+object Seq
+  val x: Boolean = (2; true); x
+end Seq

info/labs/lab04/test/resources/typer/passing/SeqWithError.grading.amy

+object SeqWithError
+  val x: Int(32) = (1 + 2; error("this is fine"));
+  x
+end SeqWithError

info/labs/lab04/test/scala/amyc/test/CompilerTest.scala

+package amyc.test
+
+import amyc.utils._
+import java.io.File
+
+import org.junit.Assert.fail
+
+abstract class CompilerTest extends TestUtils {
+  private def runPipeline(pipeline: Pipeline[List[File], Unit], fileNames: List[String]) = {
+    val ctx = Context(new Reporter, fileNames)
+    val files = ctx.files.map(new File(_))
+    pipeline.run(ctx)(files)
+    ctx.reporter.terminateIfErrors()
+  }
+
+  private def runPipelineRedirected(
+    pipeline: Pipeline[List[File], Unit],
+    compiledFiles: List[String],
+    input: String
+  ): String = {
+    testWithRedirectedIO(runPipeline(pipeline, compiledFiles), input)
+  }
+
+  private def assertEqual(output: String, expected: String) = {
+    val rejectLine = (s: String) =>
+      s.isEmpty ||
+        s.startsWith("[ Info  ]") ||
+        s.startsWith("[Warning]") ||
+        s.startsWith("[ Error ]") ||
+        s.startsWith("[ Fatal ]")
+    def filtered(s: String) = s.linesIterator.filterNot(rejectLine).mkString("\n")
+    val filteredOutput = filtered(output)
+    val filteredExpected = filtered(expected)
+    if (filteredOutput != filteredExpected) {
+      val sb = new StringBuffer()
+      sb.append("\nOutput is different:\n")
+      sb.append("\nOutput: \n")
+      sb.append(filteredOutput)
+      sb.append("\n\nExpected output: \n")
+      sb.append(filteredExpected)
+      sb.append("\n")
+      fail(sb.toString)
+    }
+  }
+
+  protected def compareOutputs(
+    pipeline: Pipeline[List[File], Unit],
+    compiledFiles: List[String],
+    expectedFile: String,
+    input: String = ""
+  ) = {
+    try {
+      val output = runPipelineRedirected(pipeline, compiledFiles, input)
+      val expected = scala.io.Source.fromFile(new File(expectedFile)).mkString
+      assertEqual(output, expected)
+    } catch {
+      // We only want to catch AmyFatalError gracefully, the rest can propagate
+      case AmycFatalError(msg) =>
+        fail(s"\n  $msg\n")
+    }
+  }
+
+  protected def demandPass(
+    pipeline: Pipeline[List[File], Unit],
+    compiledFiles: List[String],
+    input: String = ""
+  ) = {
+    try {
+      runPipelineRedirected(pipeline, compiledFiles, input)
+    } catch {
+      case AmycFatalError(msg) =>
+        fail(s"\n  $msg\n")
+    }
+  }
+
+  protected def demandFailure(
+    pipeline: Pipeline[List[File], Unit],
+    compiledFiles: List[String],
+    input: String = ""
+  ) = {
+    try {
+      runPipelineRedirected(pipeline, compiledFiles, input)
+      fail("Test should fail but it passed!")
+    } catch {
+      case AmycFatalError(_) =>
+      // Ok, this is what we wanted. Other exceptions should propagate though
+    }
+
+  }
+
+
+}

info/labs/lab04/test/scala/amyc/test/LexerTests.scala

+package amyc.test
+
+import amyc.parsing._
+import org.junit.Test
+
+class LexerTests extends TestSuite {
+  val pipeline = AmyLexer.andThen(DisplayTokens)
+
+  val baseDir = "lexer"
+
+  val outputExt = "txt"
+
+  @Test def testKeywords = shouldOutput("Keywords")
+
+  @Test def testIdentifiers = shouldOutput("Identifiers")
+
+  @Test def testOperators = shouldOutput("Operators")
+
+  @Test def testDelimiters = shouldOutput("Delimiters")
+
+  @Test def testCombinations = shouldOutput("Combinations")
+
+  @Test def testComments = shouldOutput("Comments")
+
+  @Test def testIntLiterals = shouldOutput("IntLiterals")
+
+  @Test def testStringLiterals = shouldOutput("StringLiterals")
+
+  @Test def testTwoFiles = shouldOutput(List("Keywords", "Operators"), "TwoFiles")
+
+  @Test def testSingleAmp = shouldFail("SingleAmp")
+
+  @Test def testSingleBar = shouldFail("SingleBar")
+
+  @Test def testUnclosedComment = shouldFail("UnclosedComment")
+
+  @Test def testUnclosedComment2 = shouldFail("UnclosedComment2")
+
+  @Test def testUnclosedComment3 = shouldFail("UnclosedComment3")
+
+  @Test def testCommentClosedTwice = shouldOutput("CommentClosedTwice")
+
+  @Test def testUnclosedString1 = shouldFail("UnclosedString1")
+
+  @Test def testUnclosedString2 = shouldFail("UnclosedString2")
+
+  @Test def testInvalid = shouldFail("Invalid")
+
+  @Test def testTooBigInt = shouldFail("TooBigInt")
+
+  @Test def testWhitespace = shouldOutput("Whitespace")
+
+}

info/labs/lab04/test/scala/amyc/test/NameAnalyzerTests.scala

+package amyc.test
+
+import amyc.parsing._
+import amyc.ast.{Identifier, SymbolicPrinter}
+import amyc.ast.SymbolicTreeModule.Program
+import amyc.analyzer.{NameAnalyzer, SymbolTable}
+import amyc.utils._
+import org.junit.Test
+import scala.language.implicitConversions
+
+class NameAnalyzerTests extends TestSuite {
+  // A little hackery to overcome that Identifier names do not refresh over pipeline runs...
+  private class TestUniquePrinter extends SymbolicPrinter {
+    private val counter = new UniqueCounter[String]
+    private val map = scala.collection.mutable.Map[Identifier, Int]()
+    override implicit def printName(name: Identifier)(implicit printUniqueIds: Boolean): Document = {
+      if (printUniqueIds) {
+        val id = map.getOrElseUpdate(name, counter.next(name.name))
+        s"${name.name}_$id"
+      } else {
+        name.name
+      }
+    }
+  }
+
+  private val treePrinterS: Pipeline[(Program, SymbolTable), Unit] = {
+    new Pipeline[(Program, SymbolTable), Unit] {
+      def run(ctx: Context)(v: (Program, SymbolTable)) = {
+        println((new TestUniquePrinter)(v._1)(true))
+      }
+    }
+  }
+
+  val pipeline = AmyLexer.andThen(Parser).andThen(NameAnalyzer).andThen(treePrinterS)
+
+  val baseDir = "nameAnalyzer"
+
+  val outputExt = "scala"
+
+  @Test def testClasses = shouldOutput("Classes")
+  @Test def testConstructorVsIdPattern = shouldOutput("ConstructorVsIdPattern")
+  @Test def testDefOrder = shouldOutput("DefOrder")
+  @Test def testDuplicateClassParams = shouldOutput("DuplicateClassParams")
+  @Test def testNotDuplicateLocals1 = shouldOutput("NotDuplicateLocals1")
+  @Test def testNotDuplicateLocals2 = shouldOutput("NotDuplicateLocals2")
+  @Test def testParamAndLocal = shouldOutput("ParamAndLocal")
+  @Test def testRecursive = shouldOutput("Recursive")
+  @Test def testList = shouldOutput(List("List", "Std", "Option"), "List")
+  @Test def matchShadowParameter = shouldOutput("MatchShadowParameter")
+
+  @Test def testArgumentNumberFunction = shouldFail("ArgumentNumberFunction")
+  @Test def testArgumentNumberConstructor = shouldFail("ArgumentNumberConstructor")
+  @Test def testArgumentNumberPattern = shouldFail("ArgumentNumberPattern")
+  @Test def testDuplicateDefs1 = shouldFail("DuplicateDefs1")
+  @Test def testDuplicateDefs2 = shouldFail("DuplicateDefs2")
+  @Test def testDuplicateLocals = shouldFail("DuplicateLocals")
+  @Test def testDuplicatMatchLocals1 = shouldFail("DuplicateMatchLocals1")
+  @Test def testDuplicatMatchLocals2 = shouldFail("DuplicateMatchLocals2")
+  @Test def testDuplicateModules = shouldFail(List("DuplicateModulesA", "DuplicateModulesB"))
+  @Test def testDuplicateParams = shouldFail("DuplicateParams")
+  @Test def testLocalScope = shouldFail("LocalScope")
+  @Test def testUndefinedConstructor1 = shouldFail("UndefinedConstructor1")
+  @Test def testUndefinedConstructor2 = shouldFail("UndefinedConstructor2")
+  @Test def testUndefinedFunction = shouldFail("UndefinedFunction")
+  @Test def testUndefinedModule = shouldFail("UndefinedModule")
+  @Test def testUndefinedTypeInModule = shouldFail(List("UndefinedTypeInModuleA", "UndefinedTypeInModuleB"))
+  @Test def testUndefinedType = shouldFail("UndefinedType")
+  @Test def testUndefinedVariable = shouldFail("UndefinedVariable")
+  @Test def testUnknownParent = shouldFail("UnknownParent")
+}

info/labs/lab04/test/scala/amyc/test/ParserTests.scala

+package amyc.test
+
+import amyc.utils._
+import amyc.ast._
+import amyc.parsing._
+import org.junit.Test
+
+class ParserTests extends TestSuite {
+
+  import NominalTreeModule.{Program => NP}
+
+  def treePrinterN(title: String): Pipeline[NP, Unit] = {
+    new Pipeline[NP, Unit] {
+      def run(ctx: Context)(v: NP) = {
+        println(title)
+        println(NominalPrinter(v))
+      }
+    }
+  }
+  val pipeline = AmyLexer.andThen(Parser).andThen(treePrinterN(""))
+
+  val baseDir = "parser"
+
+  val outputExt = "amy"
+
+  @Test def testLL1 = {
+    assert(Parser.program.isLL1)
+  }
+
+  
+  @Test def testEmpty = shouldOutput("Empty")
+
+  @Test def testErrorToken1 = shouldOutput("ErrorToken1")
+
+  @Test def testErrorToken2 = shouldOutput("ErrorToken2")
+
+  @Test def testLiterals = shouldOutput("Literals")
+
+  @Test def testPrecedence = shouldOutput("Precedence")
+
+  @Test def testAssoc = shouldOutput("Assoc")
+
+  @Test def testAssocSemicolon = shouldOutput("AssocSemicolon")
+
+  @Test def testFunDefs = shouldOutput("FunDefs")
+
+  @Test def testFunCalls = shouldOutput("FunCalls")
+
+  @Test def testClassDefs = shouldOutput("ClassDefs")
+
+  @Test def testPatterns = shouldOutput("Patterns")
+
+  @Test def testNestedMatch = shouldOutput("NestedMatch")
+
+  @Test def testParens = shouldOutput("Parens")
+
+  @Test def testQualifiedNames = shouldOutput("QualifiedNames")
+
+  @Test def testList = shouldOutput("List")
+
+  @Test def testIfCondition = shouldOutput("IfCondition")
+  @Test def testMatchScrutinee = shouldOutput("MatchScrutinee")
+  @Test def testChainedMatch = shouldOutput("ChainedMatch")
+
+  @Test def testArgsError1 = shouldFail("ArgsError1")
+  @Test def testArgsError2 = shouldFail("ArgsError2")
+  @Test def testClassDefError1 = shouldFail("ClassDefError1")
+  @Test def testClassDefError2 = shouldFail("ClassDefError2")
+  @Test def testClassDefError3 = shouldFail("ClassDefError3")
+  @Test def testClassDefError4 = shouldFail("ClassDefError4")
+  @Test def testCommentClosedTwice = shouldFail("CommentClosedTwice")
+  @Test def testEmptyFile = shouldFail("EmptyFile")
+  @Test def testFunDefError1 = shouldFail("FunDefError1")
+  @Test def testFunDefError2 = shouldFail("FunDefError2")
+  @Test def testFunDefError3 = shouldFail("FunDefError3")
+  @Test def testFunDefError4 = shouldFail("FunDefError4")
+  @Test def testFunDefError5 = shouldFail("FunDefError5")
+  @Test def testFunDefError6 = shouldFail("FunDefError6")
+  @Test def testIfPrecedence = shouldFail("IfPrecedence")
+  @Test def testIntError1 = shouldFail("IntError1")
+  @Test def testIntError2 = shouldFail("IntError2")
+  @Test def testIntError3 = shouldFail("IntError3")
+  @Test def testTypeWidth = shouldFail("TypeWidth")
+  @Test def testMatchAsOperand = shouldFail("MatchAsOperand")
+  @Test def testMissingOperand = shouldFail("MissingOperand")
+  @Test def testUnaryWithinUnary = shouldFail("UnaryWithinUnary")
+  @Test def testUnmatchedModule = shouldFail("UnmatchedModule")
+  @Test def testUnmatchedModuleName = shouldFail("UnmatchedModuleName")
+  @Test def testUnmatchedParen = shouldFail("UnmatchedParen")
+  @Test def testValAsOperand = shouldFail("ValAsOperand")
+  @Test def testValError = shouldFail("ValError")
+  @Test def testValInVal = shouldFail("ValInVal")
+  @Test def testWrongQName1 = shouldFail("WrongQName1")
+  @Test def testWrongQName2 = shouldFail("WrongQName2")
+  @Test def testWrongQName3 = shouldFail("WrongQName3")
+  @Test def testWrongQName4 = shouldFail("WrongQName4")
+
+}

info/labs/lab04/test/scala/amyc/test/TestSuite.scala

+package amyc.test
+
+import amyc.utils.Pipeline
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.StandardCopyOption
+
+abstract class TestSuite extends CompilerTest {
+  val pipeline: Pipeline[List[File], Unit]
+
+  val baseDir: String
+  lazy val effectiveBaseDir: String =
+    // getClass.getResource(s"/$baseDir").getPath
+    s"test/resources/$baseDir"
+
+  val passing = "passing"
+  val failing = "failing"
+  val outputs = "outputs"
+
+  val tmpDir = Files.createTempDirectory("amyc");
+
+  val outputExt: String
+
+  def getResourcePath(relativePath: String, otherPath: Option[String] = None): String =
+    val firstPath = Path.of(effectiveBaseDir, relativePath)
+
+    val (stream, path) = 
+      if Files.exists(firstPath) then
+        (Files.newInputStream(firstPath), relativePath)
+      else
+        otherPath match
+          case Some(p) =>
+            val secondPath = Path.of(effectiveBaseDir, p)
+            (Files.newInputStream(secondPath), p)
+          case None =>
+            assert(false, s"can not read $effectiveBaseDir/$relativePath")
+            (null, "")
+
+    val targetPath = tmpDir.resolve(path)
+    Files.createDirectories(targetPath.getParent())
+    Files.copy(stream, targetPath, StandardCopyOption.REPLACE_EXISTING)
+    targetPath.toAbsolutePath().toString()
+
+  def shouldOutput(inputFiles: List[String], outputFile: String, input: String = ""): Unit = {
+    compareOutputs(
+      pipeline,
+      inputFiles map (f => getResourcePath(s"$passing/$f.amy", Some(s"$passing/$f.grading.amy"))),
+      getResourcePath(s"$outputs/$outputFile.$outputExt", Some(s"$outputs/$outputFile.grading.$outputExt")),
+      input
+    )
+  }
+
+  def shouldOutput(inputFile: String): Unit = {
+    shouldOutput(List(inputFile), inputFile)
+  }
+
+  def shouldFail(inputFiles: List[String], input: String = ""): Unit = {
+    demandFailure(
+      pipeline,
+      inputFiles map (f => getResourcePath(s"$failing/$f.amy", Some(s"$failing/$f.grading.amy"))),
+      input
+    )
+  }
+
+  def shouldFail(inputFile: String): Unit = {
+    shouldFail(List(inputFile))
+  }
+
+  def shouldPass(inputFiles: List[String], input: String = ""): Unit = {
+    demandPass(pipeline, inputFiles map (f => getResourcePath(s"$passing/$f.amy", Some(s"$passing/$f.grading.amy"))), input)
+  }
+
+  def shouldPass(inputFile: String): Unit = {
+    shouldPass(List(inputFile))
+  }
+
+}

info/labs/lab04/test/scala/amyc/test/TestUtils.scala

+package amyc.test
+
+import java.io._
+
+/** Some utilities for running tests */
+trait TestUtils {
+  /** Run test,
+    * with input also redirected from a String,
+    * and output is redirected to a local StringBuilder.
+    */
+  def testWithRedirectedIO[T](test: => T, input: String): String = {
+    import scala.Console._
+    val inputS  = new StringReader(input)
+    val outputS = new ByteArrayOutputStream()
+    withOut(outputS) {
+      withErr(outputS) {
+        withIn(inputS) {
+          test
+        }
+      }
+    }
+    outputS.toString()
+  }
+}

info/labs/lab04/test/scala/amyc/test/TypeTests.scala

+package amyc.test
+
+import amyc.parsing._
+import amyc.ast.{Identifier, SymbolicPrinter}
+import amyc.ast.SymbolicTreeModule.Program
+import amyc.analyzer.{NameAnalyzer, TypeChecker}
+import amyc.utils._
+import org.junit.Test
+
+class TyperTests extends TestSuite {
+  // We need a unit pipeline
+  private def unit[A]: Pipeline[A, Unit] = {
+    new Pipeline[A, Unit] {
+      def run(ctx: Context)(v: A) = ()
+    }
+  }
+
+  val pipeline = AmyLexer.andThen(Parser).andThen(NameAnalyzer).andThen(TypeChecker).andThen(unit)
+
+  val baseDir = "typer"
+
+  val outputExt = "" // No output files for typechecking
+
+  @Test def testArithError1 = shouldFail("ArithError1")
+  @Test def testOperatorError1 = shouldFail("OperatorError1")
+  @Test def testConstructorError1 = shouldFail("ConstructorError1")
+  @Test def testFunctionCalls1 = shouldFail("FunctionCalls1")
+  @Test def testIfError1 = shouldFail("IfError1")
+  @Test def testLogicalError1 = shouldFail("LogicalError1")
+  @Test def testMatchError1 = shouldFail("MatchError1")
+  @Test def testSeqError1 = shouldFail("SeqError1")
+
+  @Test def testArithError2 = shouldFail("ArithError2")
+  @Test def testArithError3 = shouldFail("ArithError3")
+  @Test def testArithError4 = shouldFail("ArithError4")
+  @Test def testArithError5 = shouldFail("ArithError5")
+  @Test def testComparisonError = shouldFail("ComparisonError")
+  @Test def testOperatorError2 = shouldFail("OperatorError2")
+  @Test def testOperatorError3 = shouldFail("OperatorError3")
+  @Test def testConstructorError2 = shouldFail("ConstructorError2")
+  @Test def testConstructorError3 = shouldFail("ConstructorError3")
+  @Test def testConstructorError4 = shouldFail("ConstructorError4")
+  @Test def testEqualityError = shouldFail("EqualityError")
+  @Test def testFunctionCalls2 = shouldFail("FunctionCalls2")
+  @Test def testFunctionCalls3 = shouldFail("FunctionCalls3")
+  @Test def testIfAndErrorWrong = shouldFail("IfAndErrorWrong")
+  @Test def testIfError2 = shouldFail("IfError2")
+  @Test def testIfError3 = shouldFail("IfError3")
+  @Test def testLetError1 = shouldFail("LetError1")
+  @Test def testLetError2 = shouldFail("LetError2")
+  @Test def testLogicalError2 = shouldFail("LogicalError2")
+  @Test def testLogicalError3 = shouldFail("LogicalError3")
+  @Test def testMatchError2 = shouldFail("MatchError2")
+  @Test def testMatchError3 = shouldFail("MatchError3")
+  @Test def testMatchError4 = shouldFail("MatchError4")
+  @Test def testMatchError5 = shouldFail("MatchError5")
+  @Test def testMatchError6 = shouldFail("MatchError6")
+  @Test def testSeqError2 = shouldFail("SeqError2")
+  @Test def testSeqError3 = shouldFail("SeqError3")
+  @Test def testConcatError = shouldFail("ConcatError")
+  @Test def testErrorError = shouldFail("ErrorError")
+
+  @Test def testArithmetic = shouldPass("Arithmetic")
+  @Test def testComparison = shouldPass("Comparison")
+  @Test def testConstructors = shouldPass("Constructors")
+  @Test def testFunctionCalls = shouldPass("FunctionCalls")
+  @Test def testIf = shouldPass("If")
+  @Test def testIfWithError = shouldPass("IfWithError")
+  @Test def testLogical = shouldPass("Logical")
+  @Test def testMatch1 = shouldPass("Match1")
+  @Test def testMatch2 = shouldPass("Match2")
+  @Test def testMatch3 = shouldPass("Match3")
+  @Test def testMatchWithError = shouldPass("MatchWithError")
+  @Test def testMisc = shouldPass("Misc")
+  @Test def testSeq = shouldPass("Seq")
+  @Test def testSeqWithError = shouldPass("SeqWithError")
+  @Test def testLetWithError = shouldPass("LetWithError")
+  @Test def testError = shouldPass("Error")
+
+}