Import patmat handout

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+  "dotty": {
+    "trace": {
+      "remoteTracingUrl": "wss://lamppc36.epfl.ch/dotty-remote-tracer/upload/lsp.log",
+      "server": { "format": "JSON", "verbosity": "verbose" }
+    }
+  }
+}

build.sbt

@@ -0,0 +1,12 @@
+course := "progfun1"
+assignment := "patmat"
+name := course.value + "-" + assignment.value
+testSuite := "patmat.HuffmanSuite"
+
+scalaVersion := "0.19.0-bin-20190918-dd68eb8-NIGHTLY"
+
+scalacOptions ++= Seq("-language:implicitConversions", "-deprecation")
+
+libraryDependencies += "com.novocode" % "junit-interface" % "0.11" % Test
+
+testOptions in Test += Tests.Argument(TestFrameworks.JUnit, "-a", "-v", "-s")

project/MOOCSettings.scala

@@ -0,0 +1,23 @@
+package ch.epfl.lamp
+
+import sbt._
+import sbt.Keys._
+
+/**
+  * Settings shared by all assignments, reused in various tasks.
+  */
+object MOOCSettings extends AutoPlugin {
+
+  object autoImport {
+    val course = SettingKey[String]("course")
+    val assignment = SettingKey[String]("assignment")
+    val testSuite = SettingKey[String]("testSuite")
+    val options = SettingKey[Map[String, Map[String, String]]]("options")
+  }
+
+  override def trigger = allRequirements
+
+  override val projectSettings: Seq[Def.Setting[_]] = Seq(
+    parallelExecution in Test := false
+  )
+}

project/StudentTasks.scala

@@ -0,0 +1,323 @@
+package ch.epfl.lamp
+
+import sbt._
+import Keys._
+
+// import scalaj.http._
+import java.io.{File, FileInputStream, IOException}
+import java.nio.file.FileSystems
+import org.apache.commons.codec.binary.Base64
+// import play.api.libs.json.{Json, JsObject, JsPath}
+import scala.util.{Failure, Success, Try}
+
+import MOOCSettings.autoImport._
+
+case class AssignmentInfo(
+  key: String,
+  itemId: String,
+  premiumItemId: Option[String],
+  partId: String
+)
+
+/**
+  * Provides tasks for submitting the assignment
+  */
+object StudentTasks extends AutoPlugin {
+
+  object autoImport {
+    val assignmentInfo = SettingKey[AssignmentInfo]("assignmentInfo")
+
+    val packageSourcesOnly = TaskKey[File]("packageSourcesOnly", "Package the sources of the project")
+    val packageBinWithoutResources = TaskKey[File]("packageBinWithoutResources", "Like packageBin, but without the resources")
+    val packageSubmissionZip = TaskKey[File]("packageSubmissionZip")
+    val packageSubmission = inputKey[Unit]("package solution as an archive file")
+    val runGradingTests = taskKey[Unit]("run black-box tests used for final grading")
+  }
+
+
+  import autoImport._
+
+  override lazy val projectSettings = Seq(
+    packageSubmissionSetting,
+    // submitSetting, // FIXME: restore assignmentInfo setting on assignments
+    runGradingTestsSettings,
+
+    fork := true,
+    connectInput in run := true,
+    outputStrategy := Some(StdoutOutput)
+  ) ++ packageSubmissionZipSettings
+
+  lazy val runGradingTestsSettings = runGradingTests := {
+    val testSuiteJar = "grading-tests.jar"
+    if (!new File(testSuiteJar).exists) {
+      throw new MessageOnlyException(s"Could not find tests JarFile: $testSuiteJar")
+    }
+
+    val classPath = s"${(Test / dependencyClasspath).value.map(_.data).mkString(File.pathSeparator)}${File.pathSeparator}$testSuiteJar"
+    val junitProcess =
+      Fork.java.fork(
+        ForkOptions(),
+        "-cp" :: classPath ::
+        "org.junit.runner.JUnitCore" ::
+        (Test / testSuite).value ::
+        Nil
+      )
+
+    // Wait for tests to complete.
+    junitProcess.exitValue()
+  }
+
+
+  /** **********************************************************
+    * SUBMITTING A SOLUTION TO COURSERA
+    */
+
+  val packageSubmissionZipSettings = Seq(
+    packageSubmissionZip := {
+      val submission = crossTarget.value / "submission.zip"
+      val sources = (packageSourcesOnly in Compile).value
+      val binaries = (packageBinWithoutResources in Compile).value
+      IO.zip(Seq(sources -> "sources.zip", binaries -> "binaries.jar"), submission)
+      submission
+    },
+    artifactClassifier in packageSourcesOnly := Some("sources"),
+    artifact in (Compile, packageBinWithoutResources) ~= (art => art.withName(art.name + "-without-resources"))
+  ) ++
+  inConfig(Compile)(
+    Defaults.packageTaskSettings(packageSourcesOnly, Defaults.sourceMappings) ++
+    Defaults.packageTaskSettings(packageBinWithoutResources, Def.task {
+      val relativePaths =
+        (unmanagedResources in Compile).value.flatMap(Path.relativeTo((unmanagedResourceDirectories in Compile).value)(_))
+      (mappings in (Compile, packageBin)).value.filterNot { case (_, path) => relativePaths.contains(path) }
+    })
+  )
+
+  val maxSubmitFileSize = {
+    val mb = 1024 * 1024
+    10 * mb
+  }
+
+  /** Check that the jar exists, isn't empty, isn't crazy big, and can be read
+    * If so, encode jar as base64 so we can send it to Coursera
+    */
+  def prepareJar(jar: File, s: TaskStreams): String = {
+    val errPrefix = "Error submitting assignment jar: "
+    val fileLength = jar.length()
+    if (!jar.exists()) {
+      s.log.error(errPrefix + "jar archive does not exist\n" + jar.getAbsolutePath)
+      failSubmit()
+    } else if (fileLength == 0L) {
+      s.log.error(errPrefix + "jar archive is empty\n" + jar.getAbsolutePath)
+      failSubmit()
+    } else if (fileLength > maxSubmitFileSize) {
+      s.log.error(errPrefix + "jar archive is too big. Allowed size: " +
+        maxSubmitFileSize + " bytes, found " + fileLength + " bytes.\n" +
+        jar.getAbsolutePath)
+      failSubmit()
+    } else {
+      val bytes = new Array[Byte](fileLength.toInt)
+      val sizeRead = try {
+        val is = new FileInputStream(jar)
+        val read = is.read(bytes)
+        is.close()
+        read
+      } catch {
+        case ex: IOException =>
+          s.log.error(errPrefix + "failed to read sources jar archive\n" + ex.toString)
+          failSubmit()
+      }
+      if (sizeRead != bytes.length) {
+        s.log.error(errPrefix + "failed to read the sources jar archive, size read: " + sizeRead)
+        failSubmit()
+      } else encodeBase64(bytes)
+    }
+  }
+
+  /** Task to package solution to a given file path */
+  lazy val packageSubmissionSetting = packageSubmission := {
+    val args: Seq[String] = Def.spaceDelimited("[path]").parsed
+    val s: TaskStreams = streams.value // for logging
+    val jar = (packageSubmissionZip in Compile).value
+
+    val base64Jar = prepareJar(jar, s)
+
+    val path = args.headOption.getOrElse((baseDirectory.value / "submission.jar").absolutePath)
+    scala.tools.nsc.io.File(path).writeAll(base64Jar)
+  }
+
+/*
+  /** Task to submit a solution to coursera */
+  val submit = inputKey[Unit]("submit solution to Coursera")
+  lazy val submitSetting = submit := {
+    val args: Seq[String] = Def.spaceDelimited("<arg>").parsed
+    val s: TaskStreams = streams.value // for logging
+    val jar = (packageSubmissionZip in Compile).value
+
+    val assignmentDetails = assignmentInfo.value
+    val assignmentKey = assignmentDetails.key
+    val courseName =
+      course.value match {
+        case "capstone" => "scala-capstone"
+        case "bigdata"  => "scala-spark-big-data"
+        case other      => other
+      }
+
+    val partId = assignmentDetails.partId
+    val itemId = assignmentDetails.itemId
+    val premiumItemId = assignmentDetails.premiumItemId
+
+    val (email, secret) = args match {
+      case email :: secret :: Nil =>
+        (email, secret)
+      case _ =>
+        val inputErr =
+          s"""|Invalid input to `submit`. The required syntax for `submit` is:
+              |submit <email-address> <submit-token>
+              |
+              |The submit token is NOT YOUR LOGIN PASSWORD.
+              |It can be obtained from the assignment page:
+              |https://www.coursera.org/learn/$courseName/programming/$itemId
+              |${
+                premiumItemId.fold("") { id =>
+                  s"""or (for premium learners):
+                     |https://www.coursera.org/learn/$courseName/programming/$id
+                   """.stripMargin
+                }
+              }
+          """.stripMargin
+        s.log.error(inputErr)
+        failSubmit()
+    }
+
+    val base64Jar = prepareJar(jar, s)
+    val json =
+      s"""|{
+          |   "assignmentKey":"$assignmentKey",
+          |   "submitterEmail":"$email",
+          |   "secret":"$secret",
+          |   "parts":{
+          |      "$partId":{
+          |         "output":"$base64Jar"
+          |      }
+          |   }
+          |}""".stripMargin
+
+    def postSubmission[T](data: String): Try[HttpResponse[String]] = {
+      val http = Http("https://www.coursera.org/api/onDemandProgrammingScriptSubmissions.v1")
+      val hs = List(
+        ("Cache-Control", "no-cache"),
+        ("Content-Type", "application/json")
+      )
+      s.log.info("Connecting to Coursera...")
+      val response = Try(http.postData(data)
+                         .headers(hs)
+                         .option(HttpOptions.connTimeout(10000)) // scalaj default timeout is only 100ms, changing that to 10s
+                         .asString) // kick off HTTP POST
+      response
+    }
+
+    val connectMsg =
+      s"""|Attempting to submit "${assignment.value}" assignment in "$courseName" course
+          |Using:
+          |- email: $email
+          |- submit token: $secret""".stripMargin
+    s.log.info(connectMsg)
+
+    def reportCourseraResponse(response: HttpResponse[String]): Unit = {
+      val code = response.code
+      val respBody = response.body
+
+       /* Sample JSON response from Coursera
+      {
+        "message": "Invalid email or token.",
+        "details": {
+          "learnerMessage": "Invalid email or token."
+        }
+      }
+      */
+
+      // Success, Coursera responds with 2xx HTTP status code
+      if (response.is2xx) {
+        val successfulSubmitMsg =
+          s"""|Successfully connected to Coursera. (Status $code)
+              |
+                |Assignment submitted successfully!
+              |
+                |You can see how you scored by going to:
+              |https://www.coursera.org/learn/$courseName/programming/$itemId/
+              |${
+            premiumItemId.fold("") { id =>
+              s"""or (for premium learners):
+                 |https://www.coursera.org/learn/$courseName/programming/$id
+                       """.stripMargin
+            }
+          }
+              |and clicking on "My Submission".""".stripMargin
+        s.log.info(successfulSubmitMsg)
+      }
+
+      // Failure, Coursera responds with 4xx HTTP status code (client-side failure)
+      else if (response.is4xx) {
+        val result = Try(Json.parse(respBody)).toOption
+        val learnerMsg = result match {
+          case Some(resp: JsObject) =>
+            (JsPath \ "details" \ "learnerMessage").read[String].reads(resp).get
+          case Some(x) => // shouldn't happen
+            "Could not parse Coursera's response:\n" + x
+          case None =>
+            "Could not parse Coursera's response:\n" + respBody
+        }
+        val failedSubmitMsg =
+          s"""|Submission failed.
+              |There was something wrong while attempting to submit.
+              |Coursera says:
+              |$learnerMsg (Status $code)""".stripMargin
+        s.log.error(failedSubmitMsg)
+      }
+
+      // Failure, Coursera responds with 5xx HTTP status code (server-side failure)
+      else if (response.is5xx) {
+        val failedSubmitMsg =
+          s"""|Submission failed.
+              |Coursera seems to be unavailable at the moment (Status $code)
+              |Check https://status.coursera.org/ and try again in a few minutes.
+           """.stripMargin
+        s.log.error(failedSubmitMsg)
+      }
+
+      // Failure, Coursera repsonds with an unexpected status code
+      else {
+        val failedSubmitMsg =
+          s"""|Submission failed.
+              |Coursera replied with an unexpected code (Status $code)
+           """.stripMargin
+        s.log.error(failedSubmitMsg)
+      }
+    }
+
+    // kick it all off, actually make request
+    postSubmission(json) match {
+      case Success(resp) => reportCourseraResponse(resp)
+      case Failure(e) =>
+        val failedConnectMsg =
+          s"""|Connection to Coursera failed.
+              |There was something wrong while attempting to connect to Coursera.
+              |Check your internet connection.
+              |${e.toString}""".stripMargin
+        s.log.error(failedConnectMsg)
+    }
+
+   }
+*/
+
+  def failSubmit(): Nothing = {
+    sys.error("Submission failed")
+  }
+
+  /**
+    * *****************
+    * DEALING WITH JARS
+    */
+  def encodeBase64(bytes: Array[Byte]): String =
+    new String(Base64.encodeBase64(bytes))
+}

project/build.properties

@@ -0,0 +1 @@
+sbt.version=1.2.8

project/buildSettings.sbt

@@ -0,0 +1,8 @@
+libraryDependencies += "com.novocode" % "junit-interface" % "0.11" % Test
+// Used for base64 encoding
+libraryDependencies += "commons-codec" % "commons-codec" % "1.10"
+
+// Used for Coursera submussion
+// libraryDependencies += "org.scalaj" %% "scalaj-http" % "2.3.0"
+// libraryDependencies += "com.typesafe.play" %% "play-json" % "2.6.9"
+

project/plugins.sbt

@@ -0,0 +1,2 @@
+addSbtPlugin("io.get-coursier" % "sbt-coursier" % "2.0.0-RC3-5")
+addSbtPlugin("ch.epfl.lamp" % "sbt-dotty" % "0.3.4")

src/main/scala/patmat/Huffman.scala

@@ -0,0 +1,192 @@
+package patmat
+
+/**
+ * A huffman code is represented by a binary tree.
+ *
+ * Every `Leaf` node of the tree represents one character of the alphabet that the tree can encode.
+ * The weight of a `Leaf` is the frequency of appearance of the character.
+ *
+ * The branches of the huffman tree, the `Fork` nodes, represent a set containing all the characters
+ * present in the leaves below it. The weight of a `Fork` node is the sum of the weights of these
+ * leaves.
+ */
+abstract class CodeTree
+case class Fork(left: CodeTree, right: CodeTree, chars: List[Char], weight: Int) extends CodeTree
+case class Leaf(char: Char, weight: Int) extends CodeTree
+
+/**
+ * Assignment 4: Huffman coding
+ *
+ */
+trait Huffman extends HuffmanInterface {
+
+  // Part 1: Basics
+  def weight(tree: CodeTree): Int = ??? // tree match ...
+
+  def chars(tree: CodeTree): List[Char] = ??? // tree match ...
+
+  def makeCodeTree(left: CodeTree, right: CodeTree) =
+    Fork(left, right, chars(left) ::: chars(right), weight(left) + weight(right))
+
+  // Part 2: Generating Huffman trees
+
+  /**
+   * In this assignment, we are working with lists of characters. This function allows
+   * you to easily create a character list from a given string.
+   */
+  def string2Chars(str: String): List[Char] = str.toList
+
+  /**
+   * This function computes for each unique character in the list `chars` the number of
+   * times it occurs. For example, the invocation
+   *
+   *   times(List('a', 'b', 'a'))
+   *
+   * should return the following (the order of the resulting list is not important):
+   *
+   *   List(('a', 2), ('b', 1))
+   *
+   * The type `List[(Char, Int)]` denotes a list of pairs, where each pair consists of a
+   * character and an integer. Pairs can be constructed easily using parentheses:
+   *
+   *   val pair: (Char, Int) = ('c', 1)
+   *
+   * In order to access the two elements of a pair, you can use the accessors `_1` and `_2`:
+   *
+   *   val theChar = pair._1
+   *   val theInt  = pair._2
+   *
+   * Another way to deconstruct a pair is using pattern matching:
+   *
+   *   pair match {
+   *     case (theChar, theInt) =>
+   *       println("character is: "+ theChar)
+   *       println("integer is  : "+ theInt)
+   *   }
+   */
+  def times(chars: List[Char]): List[(Char, Int)] = ???
+
+  /**
+   * Returns a list of `Leaf` nodes for a given frequency table `freqs`.
+   *
+   * The returned list should be ordered by ascending weights (i.e. the
+   * head of the list should have the smallest weight), where the weight
+   * of a leaf is the frequency of the character.
+   */
+  def makeOrderedLeafList(freqs: List[(Char, Int)]): List[Leaf] = ???
+
+  /**
+   * Checks whether the list `trees` contains only one single code tree.
+   */
+  def singleton(trees: List[CodeTree]): Boolean = ???
+
+  /**
+   * The parameter `trees` of this function is a list of code trees ordered
+   * by ascending weights.
+   *
+   * This function takes the first two elements of the list `trees` and combines
+   * them into a single `Fork` node. This node is then added back into the
+   * remaining elements of `trees` at a position such that the ordering by weights
+   * is preserved.
+   *
+   * If `trees` is a list of less than two elements, that list should be returned
+   * unchanged.
+   */
+  def combine(trees: List[CodeTree]): List[CodeTree] = ???
+
+  /**
+   * This function will be called in the following way:
+   *
+   *   until(singleton, combine)(trees)
+   *
+   * where `trees` is of type `List[CodeTree]`, `singleton` and `combine` refer to
+   * the two functions defined above.
+   *
+   * In such an invocation, `until` should call the two functions until the list of
+   * code trees contains only one single tree, and then return that singleton list.
+   */
+  def until(done: List[CodeTree] => Boolean, merge: List[CodeTree] => List[CodeTree])(trees: List[CodeTree]): List[CodeTree] = ???
+
+  /**
+   * This function creates a code tree which is optimal to encode the text `chars`.
+   *
+   * The parameter `chars` is an arbitrary text. This function extracts the character
+   * frequencies from that text and creates a code tree based on them.
+   */
+  def createCodeTree(chars: List[Char]): CodeTree = ???
+
+
+  // Part 3: Decoding
+
+  type Bit = Int
+
+  /**
+   * This function decodes the bit sequence `bits` using the code tree `tree` and returns
+   * the resulting list of characters.
+   */
+  def decode(tree: CodeTree, bits: List[Bit]): List[Char] = ???
+
+  /**
+   * A Huffman coding tree for the French language.
+   * Generated from the data given at
+   *   http://fr.wikipedia.org/wiki/Fr%C3%A9quence_d%27apparition_des_lettres_en_fran%C3%A7ais
+   */
+  val frenchCode: CodeTree = Fork(Fork(Fork(Leaf('s',121895),Fork(Leaf('d',56269),Fork(Fork(Fork(Leaf('x',5928),Leaf('j',8351),List('x','j'),14279),Leaf('f',16351),List('x','j','f'),30630),Fork(Fork(Fork(Fork(Leaf('z',2093),Fork(Leaf('k',745),Leaf('w',1747),List('k','w'),2492),List('z','k','w'),4585),Leaf('y',4725),List('z','k','w','y'),9310),Leaf('h',11298),List('z','k','w','y','h'),20608),Leaf('q',20889),List('z','k','w','y','h','q'),41497),List('x','j','f','z','k','w','y','h','q'),72127),List('d','x','j','f','z','k','w','y','h','q'),128396),List('s','d','x','j','f','z','k','w','y','h','q'),250291),Fork(Fork(Leaf('o',82762),Leaf('l',83668),List('o','l'),166430),Fork(Fork(Leaf('m',45521),Leaf('p',46335),List('m','p'),91856),Leaf('u',96785),List('m','p','u'),188641),List('o','l','m','p','u'),355071),List('s','d','x','j','f','z','k','w','y','h','q','o','l','m','p','u'),605362),Fork(Fork(Fork(Leaf('r',100500),Fork(Leaf('c',50003),Fork(Leaf('v',24975),Fork(Leaf('g',13288),Leaf('b',13822),List('g','b'),27110),List('v','g','b'),52085),List('c','v','g','b'),102088),List('r','c','v','g','b'),202588),Fork(Leaf('n',108812),Leaf('t',111103),List('n','t'),219915),List('r','c','v','g','b','n','t'),422503),Fork(Leaf('e',225947),Fork(Leaf('i',115465),Leaf('a',117110),List('i','a'),232575),List('e','i','a'),458522),List('r','c','v','g','b','n','t','e','i','a'),881025),List('s','d','x','j','f','z','k','w','y','h','q','o','l','m','p','u','r','c','v','g','b','n','t','e','i','a'),1486387)
+
+  /**
+   * What does the secret message say? Can you decode it?
+   * For the decoding use the `frenchCode' Huffman tree defined above.
+   */
+  val secret: List[Bit] = List(0,0,1,1,1,0,1,0,1,1,1,0,0,1,1,0,1,0,0,1,1,0,1,0,1,1,0,0,1,1,1,1,1,0,1,0,1,1,0,0,0,0,1,0,1,1,1,0,0,1,0,0,1,0,0,0,1,0,0,0,1,0,1)
+
+  /**
+   * Write a function that returns the decoded secret
+   */
+  def decodedSecret: List[Char] = ???
+
+
+  // Part 4a: Encoding using Huffman tree
+
+  /**
+   * This function encodes `text` using the code tree `tree`
+   * into a sequence of bits.
+   */
+  def encode(tree: CodeTree)(text: List[Char]): List[Bit] = ???
+
+  // Part 4b: Encoding using code table
+
+  type CodeTable = List[(Char, List[Bit])]
+
+  /**
+   * This function returns the bit sequence that represents the character `char` in
+   * the code table `table`.
+   */
+  def codeBits(table: CodeTable)(char: Char): List[Bit] = ???
+
+  /**
+   * Given a code tree, create a code table which contains, for every character in the
+   * code tree, the sequence of bits representing that character.
+   *
+   * Hint: think of a recursive solution: every sub-tree of the code tree `tree` is itself
+   * a valid code tree that can be represented as a code table. Using the code tables of the
+   * sub-trees, think of how to build the code table for the entire tree.
+   */
+  def convert(tree: CodeTree): CodeTable = ???
+
+  /**
+   * This function takes two code tables and merges them into one. Depending on how you
+   * use it in the `convert` method above, this merge method might also do some transformations
+   * on the two parameter code tables.
+   */
+  def mergeCodeTables(a: CodeTable, b: CodeTable): CodeTable = ???
+
+  /**
+   * This function encodes `text` according to the code tree `tree`.
+   *
+   * To speed up the encoding process, it first converts the code tree to a code table
+   * and then uses it to perform the actual encoding.
+   */
+  def quickEncode(tree: CodeTree)(text: List[Char]): List[Bit] = ???
+}
+
+object Huffman extends Huffman

src/main/scala/patmat/HuffmanInterface.scala

@@ -0,0 +1,23 @@
+package patmat
+
+/**
+ * The interface used by the grading infrastructure. Do not change signatures
+ * or your submission will fail with a NoSuchMethodError.
+ */
+trait HuffmanInterface {
+  def weight(tree: CodeTree): Int
+  def chars(tree: CodeTree): List[Char]
+  def times(chars: List[Char]): List[(Char, Int)]
+  def makeOrderedLeafList(freqs: List[(Char, Int)]): List[Leaf]
+  def singleton(trees: List[CodeTree]): Boolean
+  def combine(trees: List[CodeTree]): List[CodeTree]
+  def until(done: List[CodeTree] => Boolean, merge: List[CodeTree] => List[CodeTree])(trees: List[CodeTree]): List[CodeTree]
+  def createCodeTree(chars: List[Char]): CodeTree
+  def decode(tree: CodeTree, bits: List[Int]): List[Char]
+  def decodedSecret: List[Char]
+  def encode(tree: CodeTree)(text: List[Char]): List[Int]
+  def convert(tree: CodeTree): List[(Char, List[Int])]
+  def quickEncode(tree: CodeTree)(text: List[Char]): List[Int]
+  def frenchCode: CodeTree
+  def secret: List[Int]
+}

src/test/scala/patmat/HuffmanSuite.scala

@@ -0,0 +1,46 @@
+package patmat
+
+import org.junit._
+import org.junit.Assert.assertEquals
+
+class HuffmanSuite {
+  import Huffman._
+
+  trait TestTrees {
+    val t1 = Fork(Leaf('a',2), Leaf('b',3), List('a','b'), 5)
+    val t2 = Fork(Fork(Leaf('a',2), Leaf('b',3), List('a','b'), 5), Leaf('d',4), List('a','b','d'), 9)
+  }
+
+
+  @Test def `weight of a larger tree (10pts)`: Unit =
+    new TestTrees {
+      assertEquals(5, weight(t1))
+    }
+
+
+  @Test def `chars of a larger tree (10pts)`: Unit =
+    new TestTrees {
+      assertEquals(List('a','b','d'), chars(t2))
+    }
+
+  @Test def `string2chars hello world`: Unit =
+    assertEquals(List('h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd'), string2Chars("hello, world"))
+
+
+  @Test def `make ordered leaf list for some frequency table (15pts)`: Unit =
+    assertEquals(List(Leaf('e',1), Leaf('t',2), Leaf('x',3)), makeOrderedLeafList(List(('t', 2), ('e', 1), ('x', 3))))
+
+
+  @Test def `combine of some leaf list (15pts)`: Unit =
+    val leaflist = List(Leaf('e', 1), Leaf('t', 2), Leaf('x', 4))
+    assertEquals(List(Fork(Leaf('e',1),Leaf('t',2),List('e', 't'),3), Leaf('x',4)), combine(leaflist))
+
+
+  @Test def `decode and encode a very short text should be identity (10pts)`: Unit =
+    new TestTrees {
+      assertEquals("ab".toList, decode(t1, encode(t1)("ab".toList)))
+    }
+
+
+  @Rule def individualTestTimeout = new org.junit.rules.Timeout(10 * 1000)
+}

student.sbt

@@ -0,0 +1,9 @@
+// Used for base64 encoding
+libraryDependencies += "commons-codec" % "commons-codec" % "1.10"
+
+// Used for Coursera submussion
+// libraryDependencies += "org.scalaj" %% "scalaj-http" % "2.4.2"
+// libraryDependencies += "com.typesafe.play" %% "play-json" % "2.7.4"
+
+// Student tasks (i.e. packageSubmission)
+enablePlugins(StudentTasks)