trackler 2.2.1.162 → 2.2.1.163

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b0f3914ed0507205511f5d2b4c3cf1216af589b
-  data.tar.gz: dc3375041de356a74a5c00d445b4206c948aba60
+  metadata.gz: 76612316f315c3fe85ebb27ebc85f29488a65b74
+  data.tar.gz: c97049c73a649f2216b10ba50f56003b6b64deda
 SHA512:
-  metadata.gz: 563678d4ddf4f37de1d3103ce49c59744bfe20ae6a11ae45db829df3fff8586315f51912edea14dcd468f0cf6933f468eec555d3521f8036e1a297309f36236c
-  data.tar.gz: 879532e919e270cc49831f1c225f981c68067a866d8b5ad5d22ca3bbcf9a3a702f3e6a2db6c34dba00b320215f1d37d9cc9df6209c4935d905ddcaddc1834a60
+  metadata.gz: 1f4fc4a223296db0466472ad905734207eff98965acfbc43db71ee8e6572bd566ebea8d70c799a70aad6bedbe6e66693229fd0dfb57886084096a50b28ef2a35
+  data.tar.gz: 8f862eda68d3bb98bb2bd362b76f650a6f6d4597134b6d2aed7110e60b6015147f2afeee7a00677c4b71a3c762494bfab67106463becf051552f2395b36801c5

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.162"
+  VERSION = "2.2.1.163"
 end

data/tracks/bash/config.json

@@ -13,7 +13,8 @@
       "topics": [
         "stdout",
         "strings"
-      ]
+      ],
+      "auto_approve": true
     },
     {
       "slug": "reverse-string",

data/tracks/c/docs/ABOUT.md

@@ -1,5 +1,5 @@
-C is a general-purpose, imperative computer programming language, supporting structured programming, lexical variable scope and recursion, while a static type system prevents many unintended operations. By design, C provides constructs that map efficiently to typical machine instructions, and therefore it has found lasting use in applications that had formerly been coded in assembly language, including operating systems, as well as various application software for computers ranging from supercomputers to embedded systems.
+C is a general purpose language, used for a wide range of applications, from embedded computers to high-performance computing clusters. 
 
-C was originally developed by Dennis Ritchie between 1969 and 1973 at Bell Labs, and used to re-implement the Unix operating system. It has since become one of the most widely used programming languages of all time, with C compilers from various vendors available for the majority of existing computer architectures and operating systems. C has been standardized by the American National Standards Institute (ANSI) since 1989 (see ANSI C) and subsequently by the International Organization for Standardization (ISO).
+C is commonly found in low level applications as it's a good alternative to harder-to-read assembly languages. It can be compiled to assembly to keep the same level of performance, while increasing readability, and providing a small level of safety with static types!
 
-Taken from https://en.wikipedia.org/wiki/C_(programming_language)
+C was created by Dennis Ritchie at Bell Labs, and used to re-implement the Unix operating system. Now, it's one of the most used programming languages, with many compilers supporting providing support for most available hardware and platforms - there's plenty of resources and support available to help you get started!

data/tracks/c/docs/SNIPPET.txt

@@ -1,6 +1,5 @@
-#include "hello_world.h"
+#include <stdio.h>
 
-const char *hello(void)
-{
-   return "Hello, World!";
+int main(int argc, char* argv[]) {
+	printf("Hello, World!\n");
 }

data/tracks/common-lisp/docs/RESOURCES.md

@@ -24,7 +24,7 @@ most popularly linked introductory works.
   by David S. Touretzky
 * [Common Lisp: An Interactive Approach](http://www.cse.buffalo.edu/~shapiro/Commonlisp/) (PDF),
   by Stuart C. Shapiro
-* [Successful Lisp: How to Understand and Use Common Lisp](http://psg.com/~dlamkins/sl/cover.html),
+* [Successful Lisp: How to Understand and Use Common Lisp](http://successful-lisp.blogspot.com/),
   by David B. Lamkins
 
 Following these are two more advanced books, but beginners shouldn't

data/tracks/cpp/config.json

@@ -10,6 +10,7 @@
       "slug": "hello-world",
       "uuid": "3eeadff6-82b6-43be-8834-d9ef258e454d",
       "core": false,
+      "auto_approve": true,
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [

data/tracks/csharp/exercises/pov/Example.cs

@@ -2,75 +2,72 @@
 using System.Collections.Generic;
 using System.Linq;
 
-public class Graph<T> : IEquatable<Graph<T>>
+public class Tree : IEquatable<Tree>
 {
-    public Graph(T value, IEnumerable<Graph<T>> children)
-    {
-        Value = value;
-        Children = children;
-    }
+    public Tree(string value, params Tree[] children)
+        => (Value, Children) = (value, children);
 
-    public T Value { get; }
-    public IEnumerable<Graph<T>> Children { get; }
+    public string Value { get; }
+    public Tree[] Children { get; }
 
-    public bool Equals(Graph<T> other) =>
-        Value.Equals(other.Value) && Children.SequenceEqual(other.Children);
+    public bool Equals(Tree other) 
+        => Value.Equals(other.Value) && 
+            Children.OrderBy(child => child.Value).SequenceEqual(other.Children.OrderBy(child => child.Value));
 }
 
-public class GraphCrumb<T>
+public class TreeCrumb
 {
-    public GraphCrumb(T value, IEnumerable<Graph<T>> left, IEnumerable<Graph<T>> right)
-    {
-        Value = value;
-        Left = left;
-        Right = right;
-    }
+    public TreeCrumb(string value, IEnumerable<Tree> left, IEnumerable<Tree> right)
+        => (Value, Left, Right) = (value, left, right);
 
-    public T Value { get; }
-    public IEnumerable<Graph<T>> Left { get; }
-    public IEnumerable<Graph<T>> Right { get; }
+    public string Value { get; }
+    public IEnumerable<Tree> Left { get; }
+    public IEnumerable<Tree> Right { get; }
 }
 
-public class GraphZipper<T>
+public class TreeZipper
 {
-    public GraphZipper(Graph<T> focus, IEnumerable<GraphCrumb<T>> crumbs)
-    {
-        Focus = focus;
-        Crumbs = crumbs;
-    }
+    public TreeZipper(Tree focus, IEnumerable<TreeCrumb> crumbs)
+        => (Focus, Crumbs) = (focus, crumbs);
 
-    public Graph<T> Focus { get; }
-    public IEnumerable<GraphCrumb<T>> Crumbs { get; }
+    public Tree Focus { get; }
+    public IEnumerable<TreeCrumb> Crumbs { get; }
 }
 
 public static class Pov
 {
-    public static Graph<T> CreateGraph<T>(T value, IEnumerable<Graph<T>> children) 
-        => new Graph<T>(value, children);
+    public static Tree FromPov(Tree graph, string value)
+    {
+        var zipper = FindNode(value, GraphToZipper(graph));
+        if (zipper == null)
+            throw new ArgumentException();
+        
+        return ChangeParent(zipper);
+    }
 
-    public static Graph<T> FromPOV<T>(T value, Graph<T> graph) where T : IComparable 
-        => ChangeParent(FindNode(value, GraphToZipper(graph)));
+    public static IEnumerable<string> PathTo(string value1, string value2, Tree graph)
+    {
+        var zipper = FindNode(value2, GraphToZipper(FromPov(graph, value1)));
+        if (zipper == null)
+            throw new ArgumentException();
 
-    public static IEnumerable<T> TracePathBetween<T>(T value1, T value2, Graph<T> graph) where T : IComparable
-        => ZipperToPath(FindNode(value2, GraphToZipper(FromPOV(value1, graph))));
+        return ZipperToPath(zipper);
+    }
 
-    private static GraphZipper<T> GraphToZipper<T>(Graph<T> graph)
+    private static TreeZipper GraphToZipper(Tree graph)
     {
         if (graph == null)
             return null;
 
-        return new GraphZipper<T>(graph, Enumerable.Empty<GraphCrumb<T>>());
+        return new TreeZipper(graph, Enumerable.Empty<TreeCrumb>());
     }
 
-    private static IEnumerable<T> ZipperToPath<T>(GraphZipper<T> zipper)
+    private static IEnumerable<string> ZipperToPath(TreeZipper zipper)
     {
-        if (zipper == null)
-            return null;
-
-        return zipper.Crumbs.Select(c => c.Value).Reverse().Concat(new[] { zipper.Focus.Value });
+        return zipper?.Crumbs.Select(c => c.Value).Reverse().Concat(new[] { zipper.Focus.Value });
     }
 
-    private static GraphZipper<T> GoDown<T>(GraphZipper<T> zipper)
+    private static TreeZipper GoDown(TreeZipper zipper)
     {        
         if (zipper == null || !zipper.Focus.Children.Any())
             return null;
@@ -78,12 +75,12 @@ public static class Pov
         var focus = zipper.Focus;
         var children = focus.Children;
 
-        var newCrumb = new GraphCrumb<T>(focus.Value, Enumerable.Empty<Graph<T>>(), children.Skip(1));
+        var newCrumb = new TreeCrumb(focus.Value, Array.Empty<Tree>(), children.Skip(1).ToArray());
 
-        return new GraphZipper<T>(children.First(), new[] { newCrumb }.Concat(zipper.Crumbs));
+        return new TreeZipper(children.First(), new[] { newCrumb }.Concat(zipper.Crumbs));
     }
 
-    private static GraphZipper<T> GoRight<T>(GraphZipper<T> zipper)
+    private static TreeZipper GoRight(TreeZipper zipper)
     {        
         if (zipper == null || !zipper.Crumbs.Any() || !zipper.Crumbs.First().Right.Any())
             return null;
@@ -91,13 +88,12 @@ public static class Pov
         var crumbs = zipper.Crumbs;
         var firstCrumb = crumbs.First();
 
-        var newCrumb = new GraphCrumb<T>(firstCrumb.Value, firstCrumb.Left.Concat(new[] { zipper.Focus }), firstCrumb.Right.Skip(1));
+        var newCrumb = new TreeCrumb(firstCrumb.Value, firstCrumb.Left.Concat(new[] { zipper.Focus }).ToArray(), firstCrumb.Right.Skip(1).ToArray());
 
-        return new GraphZipper<T>(firstCrumb.Right.First(), new[] { newCrumb }.Concat(crumbs.Skip(1)));
+        return new TreeZipper(firstCrumb.Right.First(), new[] { newCrumb }.Concat(crumbs.Skip(1)));
     }
 
-    private static GraphZipper<T> FindNode<T>(T value, GraphZipper<T> zipper)
-        where T : IComparable
+    private static TreeZipper FindNode(string value, TreeZipper zipper)
     {
         if (zipper == null || zipper.Focus.Value.CompareTo(value) == 0)
             return zipper;
@@ -105,7 +101,7 @@ public static class Pov
         return FindNode(value, GoDown(zipper)) ?? FindNode(value, GoRight(zipper));
     }
 
-    private static Graph<T> ChangeParent<T>(GraphZipper<T> zipper)
+    private static Tree ChangeParent(TreeZipper zipper)
     {
         if (zipper == null)
             return null;
@@ -116,10 +112,10 @@ public static class Pov
         var firstCrumb = zipper.Crumbs.First();
         var focus = zipper.Focus;
 
-        var newZipper = new GraphZipper<T>(CreateGraph(firstCrumb.Value, firstCrumb.Left.Concat(firstCrumb.Right)), zipper.Crumbs.Skip(1));
+        var newZipper = new TreeZipper(new Tree(firstCrumb.Value, firstCrumb.Left.Concat(firstCrumb.Right).ToArray()), zipper.Crumbs.Skip(1));
         var parentGraph = ChangeParent(newZipper);
 
-        var ys = focus.Children.Concat(new[] { parentGraph });
-        return CreateGraph(focus.Value, ys);
+        var ys = focus.Children.Concat(new[] { parentGraph }).ToArray();
+        return new Tree(focus.Value, ys);
     }
 }

data/tracks/csharp/exercises/pov/Pov.cs

@@ -1,42 +1,22 @@
 using System;
 using System.Collections.Generic;
 
-public class Graph<T>
+public class Tree
 {
-    public Graph(T value, IEnumerable<Graph<T>> children)
+    public Tree(string value, params Tree[] children)
     {
-    }
-
-    public T Value
-    {
-        get
-        {
-            throw new NotImplementedException("You need to implement this function.");
-        }
-    }
-
-    public IEnumerable<Graph<T>> Children
-    {
-        get
-        {
-            throw new NotImplementedException("You need to implement this function.");
-        }
+        throw new NotImplementedException("You need to implement this function.");
     }
 }
 
 public static class Pov
 {
-    public static Graph<T> CreateGraph<T>(T value, IEnumerable<Graph<T>> children) 
-    {
-        throw new NotImplementedException("You need to implement this function.");
-    }
-
-    public static Graph<T> FromPOV<T>(T value, Graph<T> graph) where T : IComparable
+    public static Tree FromPov(Tree tree, string from)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public static IEnumerable<T> TracePathBetween<T>(T value1, T value2, Graph<T> graph) where T : IComparable
+    public static IEnumerable<string> PathTo(string from, string to, Tree tree)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/pov/PovTest.cs

@@ -1,154 +1,171 @@
-using Xunit;
-using System.Linq;
+// This file was auto-generated based on version 1.3.0 of the canonical data.
+
+using Xunit;
+using System;
 
 public class PovTest
 {
-    private const string x = "x";
-
-    private static Graph<T> leaf<T>(T v) => Pov.CreateGraph(v, new Graph<T>[0]);
-
-    private static readonly Graph<string> singleton = Pov.CreateGraph(x, new Graph<string>[0]);
-
-    private static readonly Graph<string> flat = Pov.CreateGraph("root", new[] { "a", "b", x, "c" }.Select(leaf));
-
-    private static readonly Graph<string> nested =
-        Pov.CreateGraph("level-0", new[] {
-            Pov.CreateGraph("level-1", new[] {
-                Pov.CreateGraph("level-2", new[] {
-                    Pov.CreateGraph("level-3", new[] {
-                        Pov.CreateGraph(x, new Graph<string>[0])
-                    })
-                })
-            })
-        });
-
-    private static readonly Graph<string> kids =
-        Pov.CreateGraph("root", new[] {
-            Pov.CreateGraph(x, new[] {
-                Pov.CreateGraph("kid-0", new Graph<string>[0]),
-                Pov.CreateGraph("kid-1", new Graph<string>[0])
-            })
-        });
-
-    private static readonly Graph<string> cousins =
-        Pov.CreateGraph("grandparent", new[] {
-            Pov.CreateGraph("parent", new [] {
-                Pov.CreateGraph(x, new [] {
-                    leaf("kid-a"),
-                    leaf("kid-b")
-                }),
-                leaf("sibling-0"),
-                leaf("sibling-1")
-            }),
-            Pov.CreateGraph("uncle", new [] {
-                leaf("cousin-0"),
-                leaf("cousin-1")
-            })
-        });
-
-    private static readonly Graph<string> singleton_ = singleton;
-
-    private static readonly Graph<string> flat_ = 
-        Pov.CreateGraph(x, new[] {
-            Pov.CreateGraph("root", new [] { "a", "b", "c" }.Select(leaf))
-        });
-
-    private static readonly Graph<string> nested_ = 
-        Pov.CreateGraph(x, new[] {
-            Pov.CreateGraph("level-3", new [] {
-                Pov.CreateGraph("level-2", new [] {
-                    Pov.CreateGraph("level-1", new [] {
-                        Pov.CreateGraph("level-0", new Graph<string>[0])
-                    })
-                })
-            })
-        });
-
-    private static readonly Graph<string> kids_ = 
-        Pov.CreateGraph(x, new[] {
-            Pov.CreateGraph("kid-0", new Graph<string>[0]),
-            Pov.CreateGraph("kid-1", new Graph<string>[0]),
-            Pov.CreateGraph("root", new Graph<string>[0])
-        });
-
-    private static readonly Graph<string> cousins_ = 
-        Pov.CreateGraph(x, new[] {
-            leaf("kid-a"),
-            leaf("kid-b"),
-            Pov.CreateGraph("parent", new [] {
-                Pov.CreateGraph("sibling-0", new Graph<string>[0]),
-                Pov.CreateGraph("sibling-1", new Graph<string>[0]),
-                Pov.CreateGraph("grandparent", new [] {
-                    Pov.CreateGraph("uncle", new [] {
-                        Pov.CreateGraph("cousin-0", new Graph<string>[0]),
-                        Pov.CreateGraph("cousin-1", new Graph<string>[0])
-                    })
-                })
-            })
-        });
-
     [Fact]
-    public void Reparent_singleton()
+    public void Results_in_the_same_tree_if_the_input_tree_is_a_singleton()
+    {
+        var tree = new Tree("x");
+        var from = "x";
+        var expected = new Tree("x");
+        Assert.Equal(expected, Pov.FromPov(tree, from));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Can_reroot_a_tree_with_a_parent_and_one_sibling()
+    {
+        var tree = new Tree("parent", new Tree("x"), new Tree("sibling"));
+        var from = "x";
+        var expected = new Tree("x", new Tree("parent", new Tree("sibling")));
+        Assert.Equal(expected, Pov.FromPov(tree, from));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Can_reroot_a_tree_with_a_parent_and_many_siblings()
+    {
+        var tree = new Tree("parent", new Tree("a"), new Tree("x"), new Tree("b"), new Tree("c"));
+        var from = "x";
+        var expected = new Tree("x", new Tree("parent", new Tree("a"), new Tree("b"), new Tree("c")));
+        Assert.Equal(expected, Pov.FromPov(tree, from));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Can_reroot_a_tree_with_new_root_deeply_nested_in_tree()
     {
-        Assert.Equal(singleton_, Pov.FromPOV(x, singleton));
+        var tree = new Tree("level-0", new Tree("level-1", new Tree("level-2", new Tree("level-3", new Tree("x")))));
+        var from = "x";
+        var expected = new Tree("x", new Tree("level-3", new Tree("level-2", new Tree("level-1", new Tree("level-0")))));
+        Assert.Equal(expected, Pov.FromPov(tree, from));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Reparent_flat()
+    public void Moves_children_of_the_new_root_to_same_level_as_former_parent()
     {
-        Assert.Equal(flat_, Pov.FromPOV(x, flat));
+        var tree = new Tree("parent", new Tree("x", new Tree("kid-0"), new Tree("kid-1")));
+        var from = "x";
+        var expected = new Tree("x", new Tree("kid-0"), new Tree("kid-1"), new Tree("parent"));
+        Assert.Equal(expected, Pov.FromPov(tree, from));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Reparent_nested()
+    public void Can_reroot_a_complex_tree_with_cousins()
     {
-        Assert.Equal(nested_, Pov.FromPOV(x, nested));
+        var tree = new Tree("grandparent", new Tree("parent", new Tree("x", new Tree("kid-0"), new Tree("kid-1")), new Tree("sibling-0"), new Tree("sibling-1")), new Tree("uncle", new Tree("cousin-0"), new Tree("cousin-1")));
+        var from = "x";
+        var expected = new Tree("x", new Tree("kid-1"), new Tree("kid-0"), new Tree("parent", new Tree("sibling-0"), new Tree("sibling-1"), new Tree("grandparent", new Tree("uncle", new Tree("cousin-0"), new Tree("cousin-1")))));
+        Assert.Equal(expected, Pov.FromPov(tree, from));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Reparent_kids()
+    public void Errors_if_target_does_not_exist_in_a_singleton_tree()
     {
-        Assert.Equal(kids_, Pov.FromPOV(x, kids));
+        var tree = new Tree("x");
+        var from = "nonexistent";
+        Assert.Throws<ArgumentException>(() => Pov.FromPov(tree, from));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Reparent_cousins()
+    public void Errors_if_target_does_not_exist_in_a_large_tree()
     {
-        Assert.Equal(cousins_, Pov.FromPOV(x, cousins));
+        var tree = new Tree("parent", new Tree("x", new Tree("kid-0"), new Tree("kid-1")), new Tree("sibling-0"), new Tree("sibling-1"));
+        var from = "nonexistent";
+        Assert.Throws<ArgumentException>(() => Pov.FromPov(tree, from));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Reparent_from_POV_of_non_existent_node()
+    public void Can_find_path_to_parent()
     {
-        Assert.Null(Pov.FromPOV(x, leaf("foo")));
+        var from = "x";
+        var to = "parent";
+        var tree = new Tree("parent", new Tree("x"), new Tree("sibling"));
+        var expected = new[]
+        {
+            "x",
+            "parent"
+        };
+        Assert.Equal(expected, Pov.PathTo(from, to, tree));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Can_find_path_to_sibling()
+    {
+        var from = "x";
+        var to = "b";
+        var tree = new Tree("parent", new Tree("a"), new Tree("x"), new Tree("b"), new Tree("c"));
+        var expected = new[]
+        {
+            "x",
+            "parent",
+            "b"
+        };
+        Assert.Equal(expected, Pov.PathTo(from, to, tree));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Should_not_be_able_to_find_a_missing_node()
+    public void Can_find_path_to_cousin()
     {
-        var nodes = new[] { singleton, flat, kids, nested, cousins }.Select(graph => Pov.FromPOV("NOT THERE", graph));
-    
-        Assert.All(nodes, node =>
+        var from = "x";
+        var to = "cousin-1";
+        var tree = new Tree("grandparent", new Tree("parent", new Tree("x", new Tree("kid-0"), new Tree("kid-1")), new Tree("sibling-0"), new Tree("sibling-1")), new Tree("uncle", new Tree("cousin-0"), new Tree("cousin-1")));
+        var expected = new[]
         {
-            Assert.Null(node);
-        });
+            "x",
+            "parent",
+            "grandparent",
+            "uncle",
+            "cousin-1"
+        };
+        Assert.Equal(expected, Pov.PathTo(from, to, tree));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Cannot_trace_between_unconnected_nodes()
+    public void Can_find_path_not_involving_root()
     {
-        Assert.Null(Pov.TracePathBetween(x, "NOT THERE", cousins));
+        var from = "x";
+        var to = "sibling-1";
+        var tree = new Tree("grandparent", new Tree("parent", new Tree("x"), new Tree("sibling-0"), new Tree("sibling-1")));
+        var expected = new[]
+        {
+            "x",
+            "parent",
+            "sibling-1"
+        };
+        Assert.Equal(expected, Pov.PathTo(from, to, tree));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Can_find_path_from_nodes_other_than_x()
+    {
+        var from = "a";
+        var to = "c";
+        var tree = new Tree("parent", new Tree("a"), new Tree("x"), new Tree("b"), new Tree("c"));
+        var expected = new[]
+        {
+            "a",
+            "parent",
+            "c"
+        };
+        Assert.Equal(expected, Pov.PathTo(from, to, tree));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_trace_a_path_from_x_to_cousin()
+    public void Errors_if_destination_does_not_exist()
     {
-        Assert.Equal(new[] { "x", "parent", "grandparent", "uncle", "cousin-1" }, Pov.TracePathBetween(x, "cousin-1", cousins));
+        var from = "x";
+        var to = "nonexistent";
+        var tree = new Tree("parent", new Tree("x", new Tree("kid-0"), new Tree("kid-1")), new Tree("sibling-0"), new Tree("sibling-1"));
+        Assert.Throws<ArgumentException>(() => Pov.PathTo(from, to, tree));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_trace_from_a_leaf_to_a_leaf()
+    public void Errors_if_source_does_not_exist()
     {
-        Assert.Equal(new[] { "kid-a", "x", "parent", "grandparent", "uncle", "cousin-0" }, Pov.TracePathBetween("kid-a", "cousin-0", cousins));
+        var from = "nonexistent";
+        var to = "x";
+        var tree = new Tree("parent", new Tree("x", new Tree("kid-0"), new Tree("kid-1")), new Tree("sibling-0"), new Tree("sibling-1"));
+        Assert.Throws<ArgumentException>(() => Pov.PathTo(from, to, tree));
     }
 }

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

@@ -3,8 +3,6 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
-public delegate void ChangedEventHandler(object sender, int value);
-
 public class Reactor
 {
     private readonly Dictionary<int, Cell> cells = new Dictionary<int, Cell>();
@@ -61,7 +59,7 @@ public abstract class Cell
     public List<Cell> Consumers { get; }
     
     public abstract int Value { get; set; }
-    public abstract event ChangedEventHandler Changed;
+    public abstract event EventHandler<int> Changed;
 }
 
 public class InputCell : Cell
@@ -73,7 +71,7 @@ public class InputCell : Cell
         _value = value;
     }
 
-    public override event ChangedEventHandler Changed;
+    public override event EventHandler<int> Changed;
 
     public override int Value
     {
@@ -109,7 +107,7 @@ public class ComputeCell : Cell
     }
 
     public override int Value { get; set; }
-    public override event ChangedEventHandler Changed;
+    public override event EventHandler<int> Changed;
 
     public void Recompute()
     {

data/tracks/csharp/exercises/react/React.csproj

@@ -12,6 +12,7 @@
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
     <PackageReference Include="xunit" Version="2.3.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
+    <PackageReference Include="FakeItEasy" Version="4.6.0" />
   </ItemGroup>
 
 </Project>