trackler 2.2.1.162 → 2.2.1.163

data/tracks/csharp/exercises/react/ReactTest.cs

@@ -1,115 +1,204 @@
-using Xunit;
-using System.Collections.Generic;
+// This file was auto-generated based on version 2.0.0 of the canonical data.
+
+using Xunit;
+using System;
+using FakeItEasy;
 
 public class ReactTest
 {
     [Fact]
-    public void Setting_the_value_of_an_input_cell_changes_the_observable_value()
+    public void Input_cells_have_a_value()
     {
-        var reactor = new Reactor();
-        var inputCell1 = reactor.CreateInputCell(1);
-
-        Assert.Equal(1, inputCell1.Value);
-        inputCell1.Value = 2;
-        Assert.Equal(2, inputCell1.Value);
+        var sut = new Reactor();
+        var input = sut.CreateInputCell(10);
+        Assert.Equal(10, input.Value);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void The_value_of_a_compute_is_determined_by_the_value_of_the_dependencies()
+    public void An_input_cells_value_can_be_set()
     {
-        var reactor = new Reactor();
-        var inputCell1 = reactor.CreateInputCell(1);
-        var computeCell1 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] + 1);
-
-        Assert.Equal(2, computeCell1.Value);
-        inputCell1.Value = 2;
-        Assert.Equal(3, computeCell1.Value);
+        var sut = new Reactor();
+        var input = sut.CreateInputCell(4);
+        input.Value = 20;
+        Assert.Equal(20, input.Value);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Compute_cells_can_depend_on_other_compute_cells()
+    public void Compute_cells_calculate_initial_value()
     {
-        var reactor = new Reactor();
-        var inputCell1 = reactor.CreateInputCell(1);
-        var computeCell1 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] + 1);
-        var computeCell2 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] - 1);
-        var computeCell3 = reactor.CreateComputeCell(new[] { computeCell1, computeCell2 }, (values) => values[0] * values[1]);
-
-        Assert.Equal(0, computeCell3.Value);
-        inputCell1.Value = 3;
-        Assert.Equal(8, computeCell3.Value);
+        var sut = new Reactor();
+        var input = sut.CreateInputCell(1);
+        var output = sut.CreateComputeCell(new[] { input }, inputs => inputs[0] + 1);
+        Assert.Equal(2, output.Value);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Compute_cells_can_have_callbacks()
+    public void Compute_cells_take_inputs_in_the_right_order()
     {
-        var reactor = new Reactor();
-        var inputCell1 = reactor.CreateInputCell(1);
-        var computeCell1 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] + 1);
-        var observed = new List<int>();
-        computeCell1.Changed += (sender, value) => observed.Add(value);
-
-        Assert.Empty(observed);
-        inputCell1.Value = 2;
-        Assert.Equal(new[] { 3 }, observed);
+        var sut = new Reactor();
+        var one = sut.CreateInputCell(1);
+        var two = sut.CreateInputCell(2);
+        var output = sut.CreateComputeCell(new[] { one, two }, inputs => inputs[0] + inputs[1] * 10);
+        Assert.Equal(21, output.Value);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Callbacks_only_trigger_on_change()
+    public void Compute_cells_update_value_when_dependencies_are_changed()
     {
-        var reactor = new Reactor();
-        var inputCell1 = reactor.CreateInputCell(1);
-        var computecell1 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] > 2 ? values[0] + 1 : 2);
-        var observerCalled = 0;
-        computecell1.Changed += (sender, value) => observerCalled++;
+        var sut = new Reactor();
+        var input = sut.CreateInputCell(1);
+        var output = sut.CreateComputeCell(new[] { input }, inputs => inputs[0] + 1);
+        input.Value = 3;
+        Assert.Equal(4, output.Value);
+    }
 
-        inputCell1.Value = 1;
-        Assert.Equal(0, observerCalled);
-        inputCell1.Value = 2;
-        Assert.Equal(0, observerCalled);
-        inputCell1.Value = 3;
-        Assert.Equal(1, observerCalled);
+    [Fact(Skip = "Remove to run test")]
+    public void Compute_cells_can_depend_on_other_compute_cells()
+    {
+        var sut = new Reactor();
+        var input = sut.CreateInputCell(1);
+        var timesTwo = sut.CreateComputeCell(new[] { input }, inputs => inputs[0] * 2);
+        var timesThirty = sut.CreateComputeCell(new[] { input }, inputs => inputs[0] * 30);
+        var output = sut.CreateComputeCell(new[] { timesTwo, timesThirty }, inputs => inputs[0] + inputs[1]);
+        Assert.Equal(32, output.Value);
+        input.Value = 3;
+        Assert.Equal(96, output.Value);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Callbacks_can_be_removed()
+    public void Compute_cells_fire_callbacks()
     {
-        var reactor = new Reactor();
-        var inputCell1 = reactor.CreateInputCell(1);
-        var computeCell1 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] + 1);
-        var observed1 = new List<int>();
-        var observed2 = new List<int>();
+        var sut = new Reactor();
+        var input = sut.CreateInputCell(1);
+        var output = sut.CreateComputeCell(new[] { input }, inputs => inputs[0] + 1);
+        var callback1 = A.Fake<EventHandler<int>>();
+        output.Changed += callback1;
+        input.Value = 3;
+        A.CallTo(() => callback1.Invoke(A<object>._, 4)).MustHaveHappenedOnceExactly();
+        Fake.ClearRecordedCalls(callback1);
+    }
 
-        ChangedEventHandler changedHandler1 = (object sender, int value) => observed1.Add(value);
-        ChangedEventHandler changedHandler2 = (object sender, int value) => observed2.Add(value);
+    [Fact(Skip = "Remove to run test")]
+    public void Callback_cells_only_fire_on_change()
+    {
+        var sut = new Reactor();
+        var input = sut.CreateInputCell(1);
+        var output = sut.CreateComputeCell(new[] { input }, inputs => inputs[0] < 3 ? 111 : 222);
+        var callback1 = A.Fake<EventHandler<int>>();
+        output.Changed += callback1;
+        input.Value = 2;
+        A.CallTo(() => callback1.Invoke(A<object>._, A<int>._)).MustNotHaveHappened();
+        input.Value = 4;
+        A.CallTo(() => callback1.Invoke(A<object>._, 222)).MustHaveHappenedOnceExactly();
+        Fake.ClearRecordedCalls(callback1);
+    }
 
-        computeCell1.Changed += changedHandler1;
-        computeCell1.Changed += changedHandler2;
+    [Fact(Skip = "Remove to run test")]
+    public void Callbacks_do_not_report_already_reported_values()
+    {
+        var sut = new Reactor();
+        var input = sut.CreateInputCell(1);
+        var output = sut.CreateComputeCell(new[] { input }, inputs => inputs[0] + 1);
+        var callback1 = A.Fake<EventHandler<int>>();
+        output.Changed += callback1;
+        input.Value = 2;
+        A.CallTo(() => callback1.Invoke(A<object>._, 3)).MustHaveHappenedOnceExactly();
+        Fake.ClearRecordedCalls(callback1);
+        input.Value = 3;
+        A.CallTo(() => callback1.Invoke(A<object>._, 4)).MustHaveHappenedOnceExactly();
+        Fake.ClearRecordedCalls(callback1);
+    }
 
-        inputCell1.Value = 2;
-        Assert.Equal(new[] { 3 }, observed1);
-        Assert.Equal(new[] { 3 }, observed2);
+    [Fact(Skip = "Remove to run test")]
+    public void Callbacks_can_fire_from_multiple_cells()
+    {
+        var sut = new Reactor();
+        var input = sut.CreateInputCell(1);
+        var plusOne = sut.CreateComputeCell(new[] { input }, inputs => inputs[0] + 1);
+        var minusOne = sut.CreateComputeCell(new[] { input }, inputs => inputs[0] - 1);
+        var callback1 = A.Fake<EventHandler<int>>();
+        plusOne.Changed += callback1;
+        var callback2 = A.Fake<EventHandler<int>>();
+        minusOne.Changed += callback2;
+        input.Value = 10;
+        A.CallTo(() => callback1.Invoke(A<object>._, 11)).MustHaveHappenedOnceExactly();
+        Fake.ClearRecordedCalls(callback1);
+        A.CallTo(() => callback2.Invoke(A<object>._, 9)).MustHaveHappenedOnceExactly();
+        Fake.ClearRecordedCalls(callback2);
+    }
 
-        computeCell1.Changed -= changedHandler1;
-        inputCell1.Value = 3;
-        Assert.Equal(new[] { 3 }, observed1);
-        Assert.Equal(new[] { 3, 4 }, observed2);
+    [Fact(Skip = "Remove to run test")]
+    public void Callbacks_can_be_added_and_removed()
+    {
+        var sut = new Reactor();
+        var input = sut.CreateInputCell(11);
+        var output = sut.CreateComputeCell(new[] { input }, inputs => inputs[0] + 1);
+        var callback1 = A.Fake<EventHandler<int>>();
+        output.Changed += callback1;
+        var callback2 = A.Fake<EventHandler<int>>();
+        output.Changed += callback2;
+        input.Value = 31;
+        A.CallTo(() => callback1.Invoke(A<object>._, 32)).MustHaveHappenedOnceExactly();
+        Fake.ClearRecordedCalls(callback1);
+        A.CallTo(() => callback2.Invoke(A<object>._, 32)).MustHaveHappenedOnceExactly();
+        Fake.ClearRecordedCalls(callback2);
+        output.Changed -= callback1;
+        var callback3 = A.Fake<EventHandler<int>>();
+        output.Changed += callback3;
+        input.Value = 41;
+        A.CallTo(() => callback1.Invoke(A<object>._, A<int>._)).MustNotHaveHappened();
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Callbacks_should_only_be_called_once_even_if_multiple_dependencies_have_changed()
+    public void Removing_a_callback_multiple_times_doesnt_interfere_with_other_callbacks()
     {
-        var reactor = new Reactor();
-        var inputCell1 = reactor.CreateInputCell(1);
-        var computeCell1 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] + 1);
-        var computeCell2 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] - 1);
-        var computeCell3 = reactor.CreateComputeCell(new[] { computeCell2 }, (values) => values[0] - 1);
-        var computeCell4 = reactor.CreateComputeCell(new[] { computeCell1, computeCell3 }, (values) => values[0] * values[1]);
+        var sut = new Reactor();
+        var input = sut.CreateInputCell(1);
+        var output = sut.CreateComputeCell(new[] { input }, inputs => inputs[0] + 1);
+        var callback1 = A.Fake<EventHandler<int>>();
+        output.Changed += callback1;
+        var callback2 = A.Fake<EventHandler<int>>();
+        output.Changed += callback2;
+        output.Changed -= callback1;
+        output.Changed -= callback1;
+        output.Changed -= callback1;
+        input.Value = 2;
+        A.CallTo(() => callback1.Invoke(A<object>._, A<int>._)).MustNotHaveHappened();
+    }
 
-        var changed4 = 0;
-        computeCell4.Changed += (sender, value) => changed4++;
+    [Fact(Skip = "Remove to run test")]
+    public void Callbacks_should_only_be_called_once_even_if_multiple_dependencies_change()
+    {
+        var sut = new Reactor();
+        var input = sut.CreateInputCell(1);
+        var plusOne = sut.CreateComputeCell(new[] { input }, inputs => inputs[0] + 1);
+        var minusOne1 = sut.CreateComputeCell(new[] { input }, inputs => inputs[0] - 1);
+        var minusOne2 = sut.CreateComputeCell(new[] { minusOne1 }, inputs => inputs[0] - 1);
+        var output = sut.CreateComputeCell(new[] { plusOne, minusOne2 }, inputs => inputs[0] * inputs[1]);
+        var callback1 = A.Fake<EventHandler<int>>();
+        output.Changed += callback1;
+        input.Value = 4;
+        A.CallTo(() => callback1.Invoke(A<object>._, 10)).MustHaveHappenedOnceExactly();
+        Fake.ClearRecordedCalls(callback1);
+    }
 
-        inputCell1.Value = 3;
-        Assert.Equal(1, changed4);
+    [Fact(Skip = "Remove to run test")]
+    public void Callbacks_should_not_be_called_if_dependencies_change_but_output_value_doesnt_change()
+    {
+        var sut = new Reactor();
+        var input = sut.CreateInputCell(1);
+        var plusOne = sut.CreateComputeCell(new[] { input }, inputs => inputs[0] + 1);
+        var minusOne = sut.CreateComputeCell(new[] { input }, inputs => inputs[0] - 1);
+        var alwaysTwo = sut.CreateComputeCell(new[] { plusOne, minusOne }, inputs => inputs[0] - inputs[1]);
+        var callback1 = A.Fake<EventHandler<int>>();
+        alwaysTwo.Changed += callback1;
+        input.Value = 2;
+        A.CallTo(() => callback1.Invoke(A<object>._, A<int>._)).MustNotHaveHappened();
+        input.Value = 3;
+        A.CallTo(() => callback1.Invoke(A<object>._, A<int>._)).MustNotHaveHappened();
+        input.Value = 4;
+        A.CallTo(() => callback1.Invoke(A<object>._, A<int>._)).MustNotHaveHappened();
+        input.Value = 5;
+        A.CallTo(() => callback1.Invoke(A<object>._, A<int>._)).MustNotHaveHappened();
     }
-}
+}

data/tracks/csharp/exercises/simple-cipher/Example.cs

@@ -3,34 +3,31 @@ using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
 
-public class Cipher
+public class SimpleCipher
 {
-    private const string ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+    private const string Alphabet = "abcdefghijklmnopqrstuvwxyz";
+
     private static readonly Random Rand = new Random();
 
-    public string Key { get; private set; }
+    public string Key { get; }
 
-    public Cipher()
+    public SimpleCipher()
     {
-        Key = new string(Enumerable.Range(0, 100).Select(x => ALPHABET[Rand.Next(ALPHABET.Length)]).ToArray());
+        Key = new string(Enumerable.Range(0, 100).Select(x => Alphabet[Rand.Next(Alphabet.Length)]).ToArray());
     }
 
-    public Cipher(string key)
+    public SimpleCipher(string key)
     {
-        if (!IsValidKey(key)) throw new ArgumentException("Invalid key");
-        Key = key;
+        Key = IsValidKey(key) ? key : throw new ArgumentException("Invalid key");
     }
 
-    private static bool IsValidKey(string key)
-    {
-        return Regex.IsMatch(key, "^[a-z]+$");
-    }
+    private static bool IsValidKey(string key) => Regex.IsMatch(key, "^[a-z]+$");
 
     public string Encode(string plaintext)
     {
         var ciphertext = new StringBuilder(plaintext.Length);
 
-        for (int i = 0; i < Math.Min(plaintext.Length, Key.Length); i++)
+        for (var i = 0; i < plaintext.Length; i++)
             ciphertext.Append(EncodeCharacter(plaintext, i));
 
         return ciphertext.ToString();
@@ -38,17 +35,17 @@ public class Cipher
 
     private char EncodeCharacter(string plaintext, int idx)
     {
-        var alphabetIdx = ALPHABET.IndexOf(plaintext[idx]) + ALPHABET.IndexOf(Key[idx]);
-        if (alphabetIdx >= ALPHABET.Length)
-            alphabetIdx -= ALPHABET.Length;
-        return ALPHABET[alphabetIdx];
+        var alphabetIdx = Alphabet.IndexOf(plaintext[idx]) + Alphabet.IndexOf(Key[idx % Key.Length]);
+        if (alphabetIdx >= Alphabet.Length)
+            alphabetIdx -= Alphabet.Length;
+        return Alphabet[alphabetIdx];
     }
 
     public string Decode(string ciphertext)
     {
         var plaintext = new StringBuilder(ciphertext.Length);
 
-        for (int i = 0; i < ciphertext.Length; i++)
+        for (var i = 0; i < ciphertext.Length; i++)
             plaintext.Append(DecodeCharacter(ciphertext, i));
 
         return plaintext.ToString();
@@ -56,9 +53,9 @@ public class Cipher
 
     private char DecodeCharacter(string ciphertext, int idx)
     {
-        var alphabetIdx = ALPHABET.IndexOf(ciphertext[idx]) - ALPHABET.IndexOf(Key[idx]);
+        var alphabetIdx = Alphabet.IndexOf(ciphertext[idx]) - Alphabet.IndexOf(Key[idx % Key.Length]);
         if (alphabetIdx < 0)
-            alphabetIdx += ALPHABET.Length;
-        return ALPHABET[alphabetIdx];
+            alphabetIdx += Alphabet.Length;
+        return Alphabet[alphabetIdx];
     }
 }

data/tracks/csharp/exercises/simple-cipher/SimpleCipher.cs

@@ -1,13 +1,13 @@
 using System;
 
-public class Cipher
+public class SimpleCipher
 {
-    public Cipher()
+    public SimpleCipher()
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public Cipher(string key)
+    public SimpleCipher(string key)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/simple-cipher/SimpleCipherTest.cs

@@ -1,138 +1,102 @@
-using System;
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 using Xunit;
+using System;
 
-public class RandomKeyCipherTest
+public class SimpleCipherTest
 {
-    private readonly Cipher cipher = new Cipher();
-
     [Fact]
-    public void Cipher_key_is_made_of_letters()
+    public void Random_key_cipher_can_encode()
     {
-        Assert.Matches("[a-z]+", cipher.Key);
+        var sut = new SimpleCipher();
+        Assert.Equal(sut.Key.Substring(0, 10), sut.Encode("aaaaaaaaaa"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Default_cipher_key_is_100_characters()
+    public void Random_key_cipher_can_decode()
     {
-        Assert.Equal(100, cipher.Key.Length);
+        var sut = new SimpleCipher();
+        Assert.Equal("aaaaaaaaaa", sut.Decode(sut.Key.Substring(0, 10)));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Cipher_keys_are_randomly_generated()
+    public void Random_key_cipher_is_reversible_i_e_if_you_apply_decode_in_a_encoded_result_you_must_see_the_same_plaintext_encode_parameter_as_a_result_of_the_decode_method()
     {
-        Assert.NotEqual(new Cipher().Key, cipher.Key);
+        var sut = new SimpleCipher();
+        Assert.Equal("abcdefghij", sut.Decode(sut.Encode("abcdefghij")));
     }
 
-    // Here we take advantage of the fact that plaintext of "aaa..." doesn't output
-    // the key. This is a critical problem with shift ciphers, some characters
-    // will always output the key verbatim.
     [Fact(Skip = "Remove to run test")]
-    public void Cipher_can_encode()
+    public void Random_key_cipher_key_is_made_only_of_lowercase_letters()
     {
-        Assert.Equal(cipher.Key.Substring(0, 10), cipher.Encode("aaaaaaaaaa"));
+        var sut = new SimpleCipher();
+        Assert.Matches("^[a-z]+$", sut.Key);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Cipher_can_decode()
+    public void Substitution_cipher_can_encode()
     {
-        Assert.Equal("aaaaaaaaaa", cipher.Decode(cipher.Key.Substring(0, 10)));
+        var sut = new SimpleCipher("abcdefghij");
+        Assert.Equal("abcdefghij", sut.Encode("aaaaaaaaaa"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Cipher_is_reversible()
+    public void Substitution_cipher_can_decode()
     {
-        const string PLAINTEXT = "abcdefghij";
-        Assert.Equal(PLAINTEXT, cipher.Decode(cipher.Encode(PLAINTEXT)));
+        var sut = new SimpleCipher("abcdefghij");
+        Assert.Equal("aaaaaaaaaa", sut.Decode("abcdefghij"));
     }
-}
-
-
-public class IncorrectKeyCipherTest
-{
-    [Fact]
-    public void Cipher_throws_with_an_all_caps_key()
-    {
-        Assert.Throws<ArgumentException>(() => new Cipher("ABCDEF"));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Cipher_throws_with_any_caps_key()
-    {
-        Assert.Throws<ArgumentException>(() => new Cipher("abcdEFg"));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Cipher_throws_with_numeric_key()
-    {
-        Assert.Throws<ArgumentException>(() => new Cipher("12345"));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Cipher_throws_with_any_numeric_key()
-    {
-        Assert.Throws<ArgumentException>(() => new Cipher("abcd345ef"));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Cipher_throws_with_empty_key()
-    {
-        Assert.Throws<ArgumentException>(() => new Cipher(""));
-    }
-}
-
-
-public class SubstitutionCipherTest
-{
-    private const string KEY = "abcdefghij";
-    private readonly Cipher cipher = new Cipher(KEY);
 
     [Fact(Skip = "Remove to run test")]
-    public void Cipher_keeps_the_submitted_key()
+    public void Substitution_cipher_is_reversible_i_e_if_you_apply_decode_in_a_encoded_result_you_must_see_the_same_plaintext_encode_parameter_as_a_result_of_the_decode_method()
     {
-        Assert.Equal(KEY, cipher.Key);
+        var sut = new SimpleCipher("abcdefghij");
+        Assert.Equal("abcdefghij", sut.Decode(sut.Encode("abcdefghij")));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Cipher_can_encode_with_given_key()
+    public void Substitution_cipher_can_double_shift_encode()
     {
-        Assert.Equal("abcdefghij", cipher.Encode("aaaaaaaaaa"));
+        var sut = new SimpleCipher("iamapandabear");
+        Assert.Equal("qayaeaagaciai", sut.Encode("iamapandabear"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Cipher_can_decode_with_given_key()
+    public void Substitution_cipher_can_wrap_on_encode()
     {
-        Assert.Equal("aaaaaaaaaa", cipher.Decode("abcdefghij"));
+        var sut = new SimpleCipher("abcdefghij");
+        Assert.Equal("zabcdefghi", sut.Encode("zzzzzzzzzz"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Cipher_is_reversible_given_key()
+    public void Substitution_cipher_can_wrap_on_decode()
     {
-        const string PLAINTEXT = "abcdefghij";
-        Assert.Equal(PLAINTEXT, cipher.Decode(cipher.Encode(PLAINTEXT)));
+        var sut = new SimpleCipher("abcdefghij");
+        Assert.Equal("zzzzzzzzzz", sut.Decode("zabcdefghi"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Cipher_can_double_shift_encode()
+    public void Substitution_cipher_can_handle_messages_longer_than_the_key()
     {
-        const string PLAINTEXT = "iamapandabear";
-        Assert.Equal("qayaeaagaciai", new Cipher(PLAINTEXT).Encode(PLAINTEXT));
+        var sut = new SimpleCipher("abc");
+        Assert.Equal("iboaqcnecbfcr", sut.Encode("iamapandabear"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Cipher_can_wrap_encode()
+    public void Incorrect_key_cipher_throws_an_error_with_an_all_uppercase_key()
     {
-        Assert.Equal("zabcdefghi", cipher.Encode("zzzzzzzzzz"));
+        Assert.Throws<ArgumentException>(() => new SimpleCipher("ABCDEF"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Cipher_can_encode_a_message_that_is_shorter_than_the_key()
+    public void Incorrect_key_cipher_throws_an_error_with_a_numeric_key()
     {
-        Assert.Equal("abcde", cipher.Encode("aaaaa"));
+        Assert.Throws<ArgumentException>(() => new SimpleCipher("12345"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Cipher_can_decode_a_message_that_is_shorter_than_the_key()
+    public void Incorrect_key_cipher_throws_an_error_with_empty_key()
     {
-        Assert.Equal("aaaaa", cipher.Decode("abcde"));
+        Assert.Throws<ArgumentException>(() => new SimpleCipher(""));
     }
 }

data/tracks/csharp/generators/Exercises/Pov.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Linq;
+using System.Text;
+using Generators.Input;
+using Generators.Output;
+using Humanizer;
+using Newtonsoft.Json.Linq;
+
+namespace Generators.Exercises
+{
+    public class Pov : GeneratorExercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.UseVariablesForInput = true;
+                canonicalDataCase.UseVariableForExpected = true;
+                canonicalDataCase.ExceptionThrown = canonicalDataCase.Expected is null ? typeof(ArgumentException) : null;
+
+                canonicalDataCase.Input["tree"] = RenderTree(canonicalDataCase.Input["tree"]);
+
+                if (canonicalDataCase.Property == "fromPov")
+                {
+                    canonicalDataCase.Expected = RenderTree(canonicalDataCase.Expected);
+                }
+            }
+        }
+
+        private static UnescapedValue RenderTree(dynamic tree)
+        {
+            if (tree == null)
+            {
+                return null;
+            }
+
+            var sb = new StringBuilder();
+
+            var label = ValueFormatter.Format(tree["label"]);
+
+            if (tree.ContainsKey("children"))
+            {
+                var children = string.Join(", ", ((object[])tree["children"]).Select(RenderTree));
+                sb.Append($"new Tree({label}, {children})");
+            }
+            else
+            {
+                sb.Append($"new Tree({label})");
+            }
+
+            return new UnescapedValue(sb.ToString());
+        }
+    }
+}