trackler 2.0.8.15 → 2.0.8.16

data/tracks/ocaml/exercises/connect/test.ml

@@ -0,0 +1,121 @@
+open Core.Std
+open OUnit2
+open Connect
+
+let show_player = function
+| Some X -> "X"
+| Some O -> "O"
+| None -> "None"
+
+let ae exp got = assert_equal ~printer:show_player exp got
+
+let tests = [
+  "an empty board has no winner" >::(fun _ctxt ->
+    let board = [
+      ". . . . ."; 
+      " . . . . ."; 
+      "  . . . . ."; 
+      "   . . . . ."; 
+      "    . . . . ."
+      ] 
+    in
+    ae None (connect board)
+  );
+  "X can win on a 1x1 board" >::(fun _ctxt ->
+    let board = [
+      "X"
+      ] 
+    in
+    ae (Some X) (connect board)
+  );
+  "O can win on a 1x1 board" >::(fun _ctxt ->
+    let board = [
+      "O"
+      ] 
+    in
+    ae (Some O) (connect board)
+  );
+  "only edges does not make a winner" >::(fun _ctxt ->
+    let board = [
+      "O O O X"; 
+      " X . . X"; 
+      "  X . . X"; 
+      "   X O O O"
+      ] 
+    in
+    ae None (connect board)
+  );
+  "illegal diagonal does not make a winner" >::(fun _ctxt ->
+    let board = [
+      "X O . ."; 
+      " O X X X"; 
+      "  O X O ."; 
+      "   . O X ."; 
+      "    X X O O"
+      ] 
+    in
+    ae None (connect board)
+  );
+  "nobody wins crossing adjacent angles" >::(fun _ctxt ->
+    let board = [
+      "X . . ."; 
+      " . X O ."; 
+      "  O . X O"; 
+      "   . O . X"; 
+      "    . . O ."
+      ] 
+    in
+    ae None (connect board)
+  );
+  "X wins crossing from left to right" >::(fun _ctxt ->
+    let board = [
+      ". O . ."; 
+      " O X X X"; 
+      "  O X O ."; 
+      "   X X O X"; 
+      "    . O X ."
+      ] 
+    in
+    ae (Some X) (connect board)
+  );
+  "O wins crossing from top to bottom" >::(fun _ctxt ->
+    let board = [
+      ". O . ."; 
+      " O X X X"; 
+      "  O O O ."; 
+      "   X X O X"; 
+      "    . O X ."
+      ] 
+    in
+    ae (Some O) (connect board)
+  );
+  "X wins using a convoluted path" >::(fun _ctxt ->
+    let board = [
+      ". X X . ."; 
+      " X . X . X"; 
+      "  . X . X ."; 
+      "   . X X . ."; 
+      "    O O O O O"
+      ] 
+    in
+    ae (Some X) (connect board)
+  );
+  "X wins using a spiral path" >::(fun _ctxt ->
+    let board = [
+      "O X X X X X X X X"; 
+      " O X O O O O O O O"; 
+      "  O X O X X X X X O"; 
+      "   O X O X O O O X O"; 
+      "    O X O X X X O X O"; 
+      "     O X O O O X O X O"; 
+      "      O X X X X X O X O"; 
+      "       O O O O O O O X O"; 
+      "        X X X X X X X X O"
+      ] 
+    in
+    ae (Some X) (connect board)
+  );
+]
+
+let () =
+  run_test_tt_main ("connect tests" >::: tests)

data/tracks/ocaml/tools/test-generator/templates/connect/template.ml

@@ -0,0 +1,23 @@
+open Core.Std
+open OUnit2
+open Connect
+
+let show_player = function
+| Some X -> "X"
+| Some O -> "O"
+| None -> "None"
+
+let ae exp got = assert_equal ~printer:show_player exp got
+
+let tests = [
+(* TEST
+  "$description" >::(fun _ctxt ->
+    let board = $board 
+    in
+    ae $expected (connect board)
+  );
+END TEST *)
+]
+
+let () =
+  run_test_tt_main ("connect tests" >::: tests)

data/tracks/python/exercises/all-your-base/all_your_base_test.py

@@ -3,6 +3,8 @@ import unittest
 from all_your_base import rebase
 
 
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
 class AllYourBaseTests(unittest.TestCase):
 
     def test_single_bit_to_one_decimal(self):

data/tracks/python/exercises/luhn/example.py

@@ -1,11 +1,11 @@
 class Luhn(object):
-    def __init__(self, number):
-        self.number = number
+    def __init__(self, string):
+        self.string = string.replace(" ", "")
 
     def addends(self):
         def luhn_transform(n):
             return (2 * n - 9) if (n > 4) else (2 * n)
-        old_digits = [int(d) for d in str(self.number)]
+        old_digits = [int(d) for d in str(self.string)]
         return [(luhn_transform(n) if (i % 2 == 0) else n)
                 for i, n in enumerate(old_digits, start=len(old_digits) % 2)]
 
@@ -13,9 +13,6 @@ class Luhn(object):
         return sum(self.addends())
 
     def is_valid(self):
+        if len(self.string) <= 1 or not self.string.isdigit():
+            return False
         return self.checksum() % 10 == 0
-
-    @staticmethod
-    def create(n):
-        diff = (10 - Luhn(n * 10).checksum()) % 10
-        return 10 * n + diff

data/tracks/python/exercises/luhn/luhn_test.py

@@ -1,46 +1,56 @@
-from collections import Counter
+# -*- coding: utf-8 -*-
+
 import unittest
 
 from luhn import Luhn
 
 
 class LuhnTests(unittest.TestCase):
-    def test_addends(self):
-        # uses a Counter to avoid specifying order of return value
-        self.assertEqual(Counter([1, 4, 1, 4, 1]),
-                         Counter(Luhn(12121).addends()))
+    def test_single_digit_strings_can_not_be_valid(self):
+        self.assertFalse(Luhn("1").is_valid())
+
+    def test_a_single_zero_is_invalid(self):
+        self.assertFalse(Luhn("0").is_valid())
+
+    def test_a_simple_valid_SIN_that_remains_valid_if_reversed(self):
+        self.assertTrue(Luhn("059").is_valid())
+
+    def test_a_simple_valid_SIN_that_becomes_invalid_if_reversed(self):
+        self.assertTrue(Luhn("59").is_valid())
+
+    def test_a_valid_Canadian_SIN(self):
+        self.assertTrue(Luhn("055 444 285").is_valid())
 
-    def test_addends_large(self):
-        # uses a Counter to avoid specifying order of return value
-        self.assertEqual(Counter([7, 6, 6, 1]),
-                         Counter(Luhn(8631).addends()))
+    def test_invalid_Canadian_SIN(self):
+        self.assertFalse(Luhn("055 444 286").is_valid())
 
-    def test_checksum1(self):
-        self.assertEqual(22, Luhn(4913).checksum())
+    def test_invalid_credit_card(self):
+        self.assertFalse(Luhn("8273 1232 7352 0569").is_valid())
 
-    def test_ckecksum2(self):
-        self.assertEqual(21, Luhn(201773).checksum())
+    def test_valid_strings_with_a_non_digit_included_become_invalid(self):
+        self.assertFalse(Luhn("055a 444 285").is_valid())
 
-    def test_invalid_number(self):
-        self.assertFalse(Luhn(738).is_valid())
+    def test_valid_strings_with_punctuation_included_become_invalid(self):
+        self.assertFalse(Luhn("055-444-285").is_valid())
 
-    def test_valid_number(self):
-        self.assertTrue(Luhn(8739567).is_valid())
+    def test_valid_strings_with_symbols_included_become_invalid(self):
+        self.assertFalse(Luhn("055£ 444$ 285").is_valid())
 
-    def test_create_valid_number1(self):
-        self.assertEqual(1230, Luhn.create(123))
+    def test_single_zero_with_space_is_invalid(self):
+        self.assertFalse(Luhn("0").is_valid())
 
-    def test_create_valid_number2(self):
-        self.assertEqual(8739567, Luhn.create(873956))
+    def test_more_than_a_single_zero_is_valid(self):
+        self.assertTrue(Luhn("0000 0").is_valid())
 
-    def test_create_valid_number3(self):
-        self.assertEqual(8372637564, Luhn.create(837263756))
+    def test_input_digit_9_is_correctly_converted_to_output_digit_9(self):
+        self.assertTrue(Luhn("091").is_valid())
 
     def test_is_valid_can_be_called_repeatedly(self):
+        # Additional track specific test case
         # This test was added, because we saw many implementations
         # in which the first call to is_valid() worked, but the
         # second call failed().
-        number = Luhn(8739567)
+        number = Luhn("055 444 285")
         self.assertTrue(number.is_valid())
         self.assertTrue(number.is_valid())
 

data/tracks/ruby/README.md

@@ -65,11 +65,17 @@ Note that flags which have an attached value, like above, must take the form
 ### Generated Test Suites
 
 If you find an `example.tt` file in a problem directory, then the test suite is
-generated from shared data. In this case changing the test file itself will
-not be enough.
+generated from shared data, which can be found in the exercise definition in the [x-common][]
+repository.
 
-You will need to have cloned [the shared metadata](https://github.com/exercism/x-common)
-at the same level as the xruby repository. E.g.
+Typically you will want to do one of the following:
+
+* [Regenerate the test suite](#regenerating-an-exercise) based on updated canonical data
+* [Make changes to a generated exercise](#changing-a-generated-exercise)
+* [Implement a new generator](#implementing-a-generator)
+
+Generated exercises depend on the [the shared metadata][x-common], which must be
+cloned to the same directory that contains your clone of the xruby repository:
 
 ```
 tree -L 1 ~/code/exercism
@@ -77,38 +83,145 @@ tree -L 1 ~/code/exercism
 └── xruby
 ```
 
-1. `xruby/$PROBLEM/example.tt` - the Erb template for the test file, `$PROBLEM_test.rb`.
-1. `x-common/$PROBLEM.json` - the shared inputs and outputs for the problem.
-1. `lib/$PROBLEM.rb` - the logic for turning the data into tests.
-1. `xruby/bin/generate $PROBLEM` - the command to actually generate the test suite.
-1. `.version` - used to keep track of the version of the test files as the data changes.
+#### Regenerating an Exercise
+
+From within the xruby directory, run the following command, where $PROBLEM is the slug
+of the exercise, e.g. `clock` or `atbash-cipher`:
+
+```
+bin/generate $PROBLEM
+```
+
+#### Changing a Generated Exercise
+
+The `$PROBLEM/$PROBLEM_test.rb` will never be edited directly.
+
+There are two reasons why a test suite might change:
+
+1. the tests are wrong (an incorrect expectation, a missing edge case, etc)
+1. there might be issues with the style or boilerplate
+
+In the first case, the changes need to be made to the `canonical-data.json` file for
+the exercise, which lives in the x-common repository.
+
+```
+../x-common/exercises/$PROBLEM/
+├── canonical-data.json
+├── description.md
+└── metadata.yml
+```
+
+This change will need to be submitted as a pull request to the x-common repository. This pull
+request needs to be merged before you can regenerate the exercise.
 
-Additionally, there is some common generator logic in `lib/generator.rb`.
+Changes that don't have to do directly with the test inputs and outputs, will either need to be
+made to `exercises/$PROBLEM/example.tt` or `lib/$PROBLEM_cases.rb`. Then you can regenerate the
+exercise with `bin/generate $PROBLEM`.
 
-For example, take a look at the `hamming.json` file in the x-common repository, as well
-as the following files in the xruby repository:
+#### Implementing a Generator
 
-1. `hamming/example.tt`
-1. `bin/generate hamming`
-1. `lib/hamming.rb`
-1. `lib/generator.rb`
+You will need to implement three files to create a generator:
 
-The `hamming/hamming_test.rb` will never be edited directly. If there's a missing test case,
-then additional inputs/outputs should be submitted to the x-common repository.
+1. `exercises/$PROBLEM/example.tt` - the Erb template for the test file, `$PROBLEM_test.rb`.
+1. `exercises/$PROBLEM/.meta/.version` - used to keep track of the version of the test files as the data changes.
+1. `lib/$PROBLEM_cases.rb` - the logic for turning the data into tests.
 
-Changes to the test suite (style, boilerplate, etc) will probably have to be made to
-`example.tt`.
+You will not need to touch the top-level script, `bin/generate`.
 
-### Exercise Generators
+The `bin/generate` command relies on some common logic implemented in `lib/generator.rb`.
+You probably won't need to touch that, either.
 
-If you wish to create a new generator, or edit an existing one, the generators currently live in the lib directory and are named `$PROBLEM_cases.rb`.  For example, the hamming generator is `lib/hamming_cases.rb`.  
+The `lib/$PROBLEM_cases.rb` file should contain a small class that wraps the JSON for a single test case:
 
-All generators currently adhere to a common public interface, and must define the following three methods:
+```
+require 'exercise_cases'
+
+class ProblemNameCase < OpenStruct
+  def test_name
+    'test_%s' % description.gsub(/[ -]/, '_')
+  end
+
+  def workload
+    # implement main logic of test here
+  end
+
+  def skipped
+    index.zero? ? '# skip' : 'skip'
+  end
+end
+```
+
+Instead of `ProblemName` use the name of the actual problem. This is important, since
+the generator script will infer the name of the class from the argument that is passed.
+
+This class must implement the following methods:
 
 - `test_name` - Returns the name of the test (i.e `test_one_equals_one`)
 - `workload` - Returns the main syntax for the test.  This will vary depending on the test generator and its underlying implementation
 - `skipped` - Returns skip syntax (i.e. `skip` or `# skip`)
 
+Beyond that, you can implement any helper methods that you need.
+
+Below this class, implement a small loop that will generate all the test cases by reading the
+`canonical-data.json` file, and looping through the test cases.
+
+You will need to adjust the logic to match the structure of the canonical data.
+
+For example, if there is a single top-level key named "cases", then you can loop through
+them as follows:
+
+```
+ProblemNameCases = proc do |data|
+  JSON.parse(data)['cases'].map.with_index do |row, i|
+    ProblemNameCase.new(row.merge('index' => i))
+  end
+end
+```
+
+If there are multiple sections, then you will need to loop through the sections, and then
+loop through each of the cases in an inner loop:
+
+```
+ProblemNameCases = proc do |data|
+  i = 0
+  json = JSON.parse(data)
+  cases = []
+  %w(section1 section2 etc).each do |section|
+    json[section]['cases'].each do |row|
+      row = row.merge(row.merge('index' => i, 'section' => section))
+      cases << ProblemNameCase.new(row)
+      i += 1
+    end
+  end
+  cases
+end
+```
+
+Finally, you need to create a text template, `example.tt`, as the bases for the test suite.
+
+Start with the following boilerplate, and adjust as necessary:
+
+```
+#!/usr/bin/env ruby
+gem 'minitest', '>= 5.0.0'
+require 'minitest/autorun'
+require_relative '$PROBLEM'
+
+# Common test data version: <%= abbreviated_commit_hash %>
+class ProblemNameTest < Minitest::Test<% test_cases.each do |test_case| %>
+  def <%= test_case.name %>
+    <%= test_case.skipped %>
+    assert_equal <%= test_case.expected %>, <%= test_case.work_load %>
+  end
+<% end %>
+<%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
+  def test_bookkeeping
+    skip
+    assert_equal <%= version %>, BookKeeping::VERSION
+  end
+end
+```
+
 ## Pull Requests
 
 We welcome pull requests that provide fixes to existing test suites (missing
@@ -168,3 +281,5 @@ Copyright (c) 2014 Katrina Owen, _@kytrinyx.com
 
 ## Ruby icon
 The Ruby icon is the Vienna.rb logo, and is used with permission. Thanks Floor Dress :)
+
+[x-common]: https://github.com/exercism/x-common