trackler 2.0.8.54 → 2.0.8.55

data/tracks/elixir/exercises/simple-cipher/simple_cipher_test.exs

@@ -0,0 +1,89 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("simple_cipher.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure trace: true, exclude: :pending
+
+defmodule SimpleCipherTest do
+  use ExUnit.Case
+
+  #@tag :pending
+  test "encoding with 'a' returns the original text" do
+    assert SimpleCipher.encode("a", "a") == "a"
+    assert SimpleCipher.encode("b", "a") == "b"
+    assert SimpleCipher.encode("c", "a") == "c"
+  end
+
+  @tag :pending
+  test "encoding with another key returns shifted text" do
+    assert SimpleCipher.encode("a", "d") == "d"
+    assert SimpleCipher.encode("b", "d") == "e"
+    assert SimpleCipher.encode("c", "d") == "f"
+  end
+
+  @tag :pending
+  test "decoding with 'a' returns the original text" do
+    assert SimpleCipher.decode("a", "a") == "a"
+    assert SimpleCipher.decode("b", "a") == "b"
+    assert SimpleCipher.decode("c", "a") == "c"
+  end
+
+  @tag :pending
+  test "decoding with another key returns unshifted text" do
+    assert SimpleCipher.decode("d", "d") == "a"
+    assert SimpleCipher.decode("e", "d") == "b"
+    assert SimpleCipher.decode("f", "d") == "c"
+  end
+
+  @tag :pending
+  test "key uses per-letter translation for encoding" do
+    key = "abc"
+
+    assert SimpleCipher.encode("abc", key) == "ace"
+    assert SimpleCipher.encode("bcd", key) == "bdf"
+    assert SimpleCipher.encode("cde", key) == "ceg"
+    assert SimpleCipher.encode("iamapandabear", "dddddddddddddd") == "ldpdsdqgdehdu"
+  end
+
+  @tag :pending
+  test "key uses per-letter translation for decoding" do
+    key = "abc"
+
+    assert SimpleCipher.decode("ace", key) == "abc"
+    assert SimpleCipher.decode("bdf", key) == "bcd"
+    assert SimpleCipher.decode("ceg", key) == "cde"
+    assert SimpleCipher.decode("ldpdsdqgdehdu", "dddddddddddddd") == "iamapandabear"
+  end
+
+  @tag :pending
+  test "only lowercase a-z are translated, rest are passed through" do
+    assert SimpleCipher.encode("this is a test!", "d") == "wklv lv d whvw!"
+    assert SimpleCipher.decode("wklv lv d whvw!", "d") == "this is a test!"
+  end
+
+  @tag :pending
+  test "if key is shorter than text, repeat key" do
+    assert SimpleCipher.encode("abc", "a") == "abc"
+    assert SimpleCipher.encode("abcdefghi", "abc") == "acedfhgik"
+  end
+
+  @tag :pending
+  test "if key is longer than text, only use as much as needed" do
+    key = "somewhatlongkey"
+
+    assert SimpleCipher.encode("abc", key) == "spo"
+    assert SimpleCipher.decode("abc", key) == "inq"
+  end
+
+  @tag :pending
+  test "if you know both the encoded and decoded text, you can figure out the key" do
+    key = "supersecretkey"
+
+    plaintext = "attackxatxdawn"
+    ciphertext = SimpleCipher.encode(plaintext, key)
+
+    assert SimpleCipher.decode(ciphertext, plaintext) == key
+  end
+end
+

data/tracks/elixir/exercises/tournament/HINTS.md

@@ -0,0 +1,3 @@
+Formatting the output is easy with `String`'s padding functions. All number
+columns can be left-padded with spaces to a width of 2 characters, while the
+team name column can be right-padded with spaces to a width of 30.

data/tracks/elixir/exercises/tournament/example.exs

@@ -0,0 +1,81 @@
+defmodule Tournament do
+  @stats_header { "Team", "MP", "W", "D", "L", "P" }
+  @initial_stats { 0, 0, 0, 0, 0 }
+
+  @doc """
+  Given `input` lines representing two teams and whether the first of them won,
+  lost, or reached a draw, separated by semicolons, calculate the statistics
+  for each team's number of games played, won, drawn, lost, and total points
+  for the season, and return a nicely-formatted string table.
+
+  A win earns a team 3 points, a draw earns 1 point, and a loss earns nothing.
+
+  Order the outcome by most total points for the season, and settle ties by
+  listing the teams in alphabetical order.
+  """
+  @spec tally(input :: list(String.t())) :: String.t()
+  def tally(input) do
+    %{}
+    |> do_tally(input)
+    |> Enum.into([], fn {k, v} -> Tuple.insert_at(v, 0, k) end)
+    |> Enum.sort(&sort_results/2)
+    |> List.insert_at(0, @stats_header)
+    |> Enum.map_join("\n", &format_results/1)
+  end
+
+  defp do_tally(results, []), do: results
+  defp do_tally(results, [line | rest]) do
+    results
+    |> parse_line(line |> String.split(";", trim: true))
+    |> do_tally(rest)
+  end
+
+  defp parse_line(results, [first, second, "win"]) do
+    results |> mark_win(first) |> mark_loss(second)
+  end
+
+  defp parse_line(results, [first, second, "draw"]) do
+    results |> mark_draw(first) |> mark_draw(second)
+  end
+
+  defp parse_line(results, [first, second, "loss"]) do
+    results |> mark_loss(first) |> mark_win(second)
+  end
+
+  defp parse_line(results, _), do: results
+
+  defp mark_win(results, team) do
+    { played, wins, draws, lost, points } = Map.get(results, team, @initial_stats)
+
+    Map.put(results, team, { played + 1, wins + 1, draws, lost, points + 3 })
+  end
+
+  defp mark_draw(results, team) do
+    { played, wins, draws, lost, points } = Map.get(results, team, @initial_stats)
+
+    Map.put(results, team, { played + 1, wins, draws + 1, lost, points + 1})
+  end
+
+  defp mark_loss(results, team) do
+    { played, wins, draws, lost, points } = Map.get(results, team, @initial_stats)
+
+    Map.put(results, team, { played + 1, wins, draws, lost + 1, points})
+  end
+
+  defp sort_results({_, _, _, _, _, points_a}, {_, _, _, _, _, points_b}) when points_a > points_b, do: true
+  defp sort_results({_, _, _, _, _, points_a}, {_, _, _, _, _, points_b}) when points_a < points_b, do: false
+  defp sort_results({name_a, _, _, _, _, _}, {name_b, _, _, _, _, _}) when name_a <= name_b, do: true
+  defp sort_results(_, _), do: false
+
+  defp format_results({name, played, wins, draws, lost, points}) do
+    [
+      name |> String.pad_trailing(30),
+      played |> to_string |> String.pad_leading(2),
+      wins |> to_string |> String.pad_leading(2),
+      draws |> to_string |> String.pad_leading(2),
+      lost |> to_string |> String.pad_leading(2),
+      points |> to_string |> String.pad_leading(2)
+    ] |> Enum.join(" | ")
+  end
+end
+

data/tracks/elixir/exercises/tournament/tournament.exs

@@ -0,0 +1,17 @@
+defmodule Tournament do
+  @doc """
+  Given `input` lines representing two teams and whether the first of them won,
+  lost, or reached a draw, separated by semicolons, calculate the statistics
+  for each team's number of games played, won, drawn, lost, and total points
+  for the season, and return a nicely-formatted string table.
+
+  A win earns a team 3 points, a draw earns 1 point, and a loss earns nothing.
+
+  Order the outcome by most total points for the season, and settle ties by
+  listing the teams in alphabetical order.
+  """
+  @spec tally(input :: list(String.t())) :: String.t()
+  def tally(input) do
+  end
+end
+

data/tracks/elixir/exercises/tournament/tournament_test.exs

@@ -0,0 +1,96 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("tournament.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure trace: true, exclude: :pending
+
+defmodule TournamentTest do
+  use ExUnit.Case
+
+  #@tag :pending
+  test "typical input" do
+    input = [
+      "Allegoric Alaskans;Blithering Badgers;win",
+      "Devastating Donkeys;Courageous Californians;draw",
+      "Devastating Donkeys;Allegoric Alaskans;win",
+      "Courageous Californians;Blithering Badgers;loss",
+      "Blithering Badgers;Devastating Donkeys;loss",
+      "Allegoric Alaskans;Courageous Californians;win"
+    ]
+
+    expected = """
+    Team                           | MP |  W |  D |  L |  P
+    Devastating Donkeys            |  3 |  2 |  1 |  0 |  7
+    Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6
+    Blithering Badgers             |  3 |  1 |  0 |  2 |  3
+    Courageous Californians        |  3 |  0 |  1 |  2 |  1
+    """ |> String.trim
+
+    assert Tournament.tally(input) == expected
+  end
+
+  @tag :pending
+  test "incomplete competition (not all pairs have played)" do
+    input = [
+      "Allegoric Alaskans;Blithering Badgers;loss",
+      "Devastating Donkeys;Allegoric Alaskans;loss",
+      "Courageous Californians;Blithering Badgers;draw",
+      "Allegoric Alaskans;Courageous Californians;win"
+    ]
+
+    expected = """
+    Team                           | MP |  W |  D |  L |  P
+    Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6
+    Blithering Badgers             |  2 |  1 |  1 |  0 |  4
+    Courageous Californians        |  2 |  0 |  1 |  1 |  1
+    Devastating Donkeys            |  1 |  0 |  0 |  1 |  0
+    """ |> String.trim
+
+    assert Tournament.tally(input) == expected
+  end
+
+  @tag :pending
+  test "ties broken alphabetically" do
+    input = [
+      "Courageous Californians;Devastating Donkeys;win",
+      "Allegoric Alaskans;Blithering Badgers;win",
+      "Devastating Donkeys;Allegoric Alaskans;loss",
+      "Courageous Californians;Blithering Badgers;win",
+      "Blithering Badgers;Devastating Donkeys;draw",
+      "Allegoric Alaskans;Courageous Californians;draw"
+    ]
+
+    expected = """
+    Team                           | MP |  W |  D |  L |  P
+    Allegoric Alaskans             |  3 |  2 |  1 |  0 |  7
+    Courageous Californians        |  3 |  2 |  1 |  0 |  7
+    Blithering Badgers             |  3 |  0 |  1 |  2 |  1
+    Devastating Donkeys            |  3 |  0 |  1 |  2 |  1
+    """ |> String.trim
+
+    assert Tournament.tally(input) == expected
+  end
+
+  @tag :pending
+  test "mostly invalid lines" do
+    # Invalid input lines in an otherwise-valid game still results in valid
+    # output.
+    input = [
+      "",
+      "Allegoric Alaskans@Blithering Badgers;draw",
+      "Blithering Badgers;Devastating Donkeys;loss",
+      "Devastating Donkeys;Courageous Californians;win;5",
+      "Courageous Californians;Allegoric Alaskans;los"
+    ]
+
+    expected = """
+    Team                           | MP |  W |  D |  L |  P
+    Devastating Donkeys            |  1 |  1 |  0 |  0 |  3
+    Blithering Badgers             |  1 |  0 |  0 |  1 |  0
+    """ |> String.trim
+
+    assert Tournament.tally(input) == expected
+  end
+end
+

data/tracks/go/exercises/bob/bob.go

@@ -1,3 +1,3 @@
-package bob // package name must match the package name in bob_test.go
+package bob
 
-const testVersion = 2 // same as targetTestVersion
+const testVersion = 2

data/tracks/go/exercises/clock/clock.go

@@ -1,15 +1,8 @@
-// Clock stub file
-
-// To use the right term, this is the package *clause*.
-// You can document general stuff about the package here if you like.
 package clock
 
-// The value of testVersion here must match `targetTestVersion` in the file
-// clock_test.go.
 const testVersion = 4
 
-// Clock API as stub definitions.  No, it doesn't compile yet.
-// More details and hints are in clock_test.go.
+// You can find more details and hints in the test file.
 
 type Clock // Complete the type definition.  Pick a suitable data type.
 

data/tracks/go/exercises/gigasecond/gigasecond.go

@@ -1,10 +1,8 @@
-// Package clause.
 package gigasecond
 
-// Constant declaration.
-const testVersion = ? // find the value in gigasecond_test.go
+// import path for the time package from the standard library
+import "time"
 
-// API function.  It uses a type from the Go standard library.
-func AddGigasecond(time.Time) time.Time
+const testVersion = 4
 
-// Reviewers don't think much of stub comments.  Replace or remove.
+func AddGigasecond(time.Time) time.Time

data/tracks/go/exercises/hamming/hamming.go

@@ -3,5 +3,4 @@ package hamming
 const testVersion = 5
 
 func Distance(a, b string) (int, error) {
-	// your code here!
 }

data/tracks/go/exercises/raindrops/raindrops.go

@@ -4,4 +4,5 @@ const testVersion = 2
 
 func Convert(int) string
 
-// The test program has a benchmark too.  How fast does your Convert convert?
+// Don't forget the test program has a benchmark too.
+// How fast does your Convert convert?

data/tracks/go/exercises/triangle/triangle.go

@@ -2,10 +2,9 @@ package triangle
 
 const testVersion = 3
 
-// Code this function.
 func KindFromSides(a, b, c float64) Kind
 
-// Notice it returns this type.  Pick something suitable.
+// Notice KindFromSides() returns this type. Pick a suitable data type.
 type Kind
 
 // Pick values for the following identifiers used by the test program.

data/tracks/java/bin/journey-test.sh

@@ -143,6 +143,11 @@ make_local_trackler() {
 
   local xjava=$( pwd )
   pushd ${trackler}
+
+  # Get the version of Trackler x-api is currently using
+  local version=$( grep -m 1 'trackler' ${xapi_home}/Gemfile.lock | sed 's/.*(//' | sed 's/)//' )
+
+  git checkout v${version}
   git submodule init -- common
   git submodule update
 
@@ -152,10 +157,6 @@ make_local_trackler() {
   cp ${xjava}/config.json tracks/java
   cp -r ${xjava}/exercises tracks/java
 
-  # Set the version to that expected by x-api
-  version=$( grep -m 1 'trackler' ${xapi_home}/Gemfile.lock | sed 's/.*(//' | sed 's/)//' )
-  echo "module Trackler VERSION = \"${version}\" end" > lib/trackler/version.rb
-
   gem install bundler
   bundle install
   gem build trackler.gemspec
@@ -229,7 +230,7 @@ solve_all_exercises() {
     gradle compileTestJava
     # Ensure we run all the tests (as delivered, all but the first is @Ignore'd)
     for testfile in `find . -name "*Test.java"`; do
-      sed 's/@Ignore//' ${testfile} > "${tempfile}" && mv "${tempfile}" "${testfile}"
+      sed 's/@Ignore\(.*\)//' ${testfile} > "${tempfile}" && mv "${tempfile}" "${testfile}"
     done
     gradle test
     popd

data/tracks/java/exercises/nth-prime/src/example/java/PrimeCalculator.java

@@ -33,10 +33,6 @@ public final class PrimeCalculator {
                 .rangeClosed(2, (int) Math.ceil(Math.sqrt(n)))
                 .anyMatch((int i) -> n % i == 0);
 
-        if (divisible) {
-            return false;
-        }
-
-        return true;
+        return !divisible;
     }
 }

data/tracks/java/exercises/rna-transcription/src/test/java/RnaTranscriptionTest.java

@@ -17,31 +17,31 @@ public class RnaTranscriptionTest {
         Assert.assertEquals("", rnaTranscription.ofDna(""));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testRnaTranscriptionOfCytosineIsGuanine() {
         Assert.assertEquals("G", rnaTranscription.ofDna("C"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testRnaTranscriptionOfGuanineIsCytosine() {
         Assert.assertEquals("C", rnaTranscription.ofDna("G"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testRnaTranscriptionOfThymineIsAdenine() {
         Assert.assertEquals("A", rnaTranscription.ofDna("T"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testRnaTranscriptionOfAdenineIsUracil() {
         Assert.assertEquals("U", rnaTranscription.ofDna("A"));
     }
 
-    @Ignore
+    @Ignore("Remove to run test")
     @Test
     public void testRnaTranscription() {
         Assert.assertEquals("UGCACCAGAAUU", rnaTranscription.ofDna("ACGTGGTCTTAA"));

data/tracks/pony/.travis.yml

@@ -1,15 +1,8 @@
----
 language: c
-
-sudo: true
+dist: trusty
+sudo: required
 
 install:
-  - sudo apt-get update -q
-  - sudo apt-get install -y python-software-properties
-  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
-  - sudo apt-get update -q
-  - sudo apt-get install -y wget git apt-transport-https g++-5 build-essential zlib1g-dev libncurses5-dev libssl-dev
-
   - sudo bash bin/install-deps
 
 script:

data/tracks/pony/bin/install-deps

@@ -1,12 +1,19 @@
 #!/bin/bash
 
-# Install pcre2
-wget ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre2-10.21.tar.bz2
-tar -xjvf pcre2-10.21.tar.bz2
-cd pcre2-10.21 && ./configure --prefix=/usr && make && sudo make install && cd -
-rm -r pcre2-10.21
+sudo apt-get update -q
+sudo apt-get install -y python-software-properties
+sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+sudo apt-get update -q
+sudo apt-get install -y \
+	wget git apt-transport-https g++-5 build-essential \
+	zlib1g-dev libncurses5-dev libssl-dev llvm-3.8
+
+# Install pcre2 (uncomment if regex package is ever used)
+# wget ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre2-10.21.tar.bz2
+# tar -xjvf pcre2-10.21.tar.bz2
+# cd pcre2-10.21 && ./configure --prefix=/usr && make && sudo make install && cd -
+# rm -r pcre2-10.21
 
 # Insall ponyc
-echo "deb https://dl.bintray.com/pony-language/ponyc-debian pony-language main" | sudo tee -a /etc/apt/sources.list
-sudo apt-get update -q
-sudo apt-get install -y --force-yes ponyc-release
+git clone "https://github.com/ponylang/ponyc"
+cd ponyc && make && sudo make install && cd -

data/tracks/pony/bin/test-exercises

@@ -1,5 +1,7 @@
 #!/bin/bash
 
+# TODO run tests in parallel (like Pony stdlib)
+
 set -eu
 
 run_tests() {

data/tracks/pony/config.json

@@ -6,7 +6,8 @@
   "ignored": [
     "bin",
     "docs",
-    "img"
+    "img",
+    "ponyc"
   ],
   "exercises": [
     {

data/tracks/pony/exercises/anagram/example.pony

@@ -11,7 +11,7 @@ primitive Anagram
         let lower': String = s.lower()
         (lower != lower') and (sorted == Anagram._strsort(lower'))
       })
-      .collect[Array[String] iso](recover Array[String] end)
+      .collect(Array[String])
 
   fun _strsort(s: String): String =>
     String.from_array(recover Sort[Array[U8], U8](s.array().clone()) end)

data/tracks/pony/exercises/anagram/test.pony

@@ -11,7 +11,7 @@ class iso _AnagramTest is UnitTest
   fun name(): String => "anagram/Anagram"
 
   fun apply(h: TestHelper) =>
-    let anagrams =  ["banana", "bob", "sent", "sale", "ales"]
+    let anagrams =  ["banana"; "bob"; "sent"; "sale"; "ales"]
     let empty = Array[String]
 
     // Anagram should return an empty array if there are no anagrams
@@ -25,4 +25,4 @@ class iso _AnagramTest is UnitTest
     // Anagram should be case insensitive
     h.assert_array_eq[String](["sent"], Anagram("nETs", anagrams))
     // Anagram should return multiple anagrams
-    h.assert_array_eq[String](["sale", "ales"], Anagram("seal", anagrams))
+    h.assert_array_eq[String](["sale"; "ales"], Anagram("seal", anagrams))

data/tracks/pony/exercises/atbash-cipher/example.pony

@@ -34,7 +34,9 @@ primitive Atbash
     end
 
   fun decode(input: String): String iso^ =>
-    Iter[U8](input.values())
-      .filter({(c: U8): Bool => c != ' '})
-      .map[U8](this~_transpose())
-      .collect[String iso](recover String end)
+    recover
+      Iter[U8](input.values())
+        .filter({(c: U8): Bool => c != ' '})
+        .map[U8](this~_transpose())
+        .collect[String ref](String)
+    end

data/tracks/pony/exercises/atbash-cipher/test.pony

@@ -13,31 +13,22 @@ class iso _TestAtbashEncode is UnitTest
 
   fun apply(h: TestHelper) =>
     let tests = [
-      (
-        "yes",
-        "bvh"
-      ),(
-        "no",
-        "ml"
-      ),(
-        "OMG",
-        "lnt"
-      ),(
-        "O M G",
-        "lnt"
-      ),(
-        "mindblowingly",
-        "nrmwy oldrm tob"
-      ),(
-        "Testing,1 2 3, testing.",
-        "gvhgr mt123 gvhgr mt"
-      ),(
-        "Truth is fiction.",
-        "gifgs rhurx grlm"
-      ),(
-        "The quick brown fox jumps over the lazy dog.",
-        "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
-      )
+      ("yes",
+        "bvh")
+      ("no",
+        "ml")
+      ("OMG",
+        "lnt")
+      ("O M G",
+        "lnt")
+      ("mindblowingly",
+        "nrmwy oldrm tob")
+      ("Testing,1 2 3, testing.",
+        "gvhgr mt123 gvhgr mt")
+      ("Truth is fiction.",
+        "gifgs rhurx grlm")
+      ("The quick brown fox jumps over the lazy dog.",
+        "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt")
     ]
     for (input, expected) in tests.values() do
       h.assert_eq[String](Atbash.encode(input), expected)
@@ -48,19 +39,14 @@ class iso _TestAtbashDecode is UnitTest
 
   fun apply(h: TestHelper) =>
     let tests = [
-      (
-        "vcvix rhn",
-        "exercism"
-      ),(
-        "zmlyh gzxov rhlug vmzhg vkkrm thglm v",
-        "anobstacleisoftenasteppingstone"
-      ),(
-        "gvhgr mt123 gvhgr mt",
-        "testing123testing"
-      ),(
-        "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt",
-        "thequickbrownfoxjumpsoverthelazydog"
-      )
+      ("vcvix rhn",
+        "exercism")
+      ("zmlyh gzxov rhlug vmzhg vkkrm thglm v",
+        "anobstacleisoftenasteppingstone")
+      ("gvhgr mt123 gvhgr mt",
+        "testing123testing")
+      ("gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt",
+        "thequickbrownfoxjumpsoverthelazydog")
     ]
     for (input, expected) in tests.values() do
       h.assert_eq[String](Atbash.decode(input), expected)

data/tracks/pony/exercises/pascals-triangle/test.pony

@@ -14,9 +14,9 @@ class iso _TestPascalsTriangle is UnitTest
   fun apply(h: TestHelper) ? =>
     assert_rows_eq(h, 0, Array[Array[USize]])
     assert_rows_eq(h, 1, [[1]])
-    assert_rows_eq(h, 2, [[1], [1, 1]])
-    assert_rows_eq(h, 3, [[1], [1, 1], [1, 2, 1]])
-    assert_rows_eq(h, 4, [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1]])
+    assert_rows_eq(h, 2, [[1]; [1; 1]])
+    assert_rows_eq(h, 3, [[1]; [1; 1]; [1; 2; 1]])
+    assert_rows_eq(h, 4, [[1]; [1; 1]; [1; 2; 1]; [1; 3; 3; 1]])
 
   fun assert_rows_eq(
     h: TestHelper,

data/tracks/pony/exercises/rna-transcription/test.pony

@@ -13,13 +13,13 @@ class iso _TestRNATrancription is UnitTest
   fun apply(h: TestHelper) ? =>
     let tests = [
       // rna complement of cytosine is guanine
-      ("C", "G"),
+      ("C", "G")
       // rna complement of guanine is cytosine
-      ("G", "C"),
+      ("G", "C")
       // rna complement of thymine is adenine
-      ("T", "A"),
+      ("T", "A")
       // rna complement of adenine is uracil
-      ("A", "U"),
+      ("A", "U")
       // rna complement
       ("ACGTGGTCTTAA", "UGCACCAGAAUU")
     ]