trackler 2.0.8.14 → 2.0.8.15

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

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+
+public class Graph<T>
+{
+    public Graph(T value, IEnumerable<Graph<T>> 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.");
+        }
+    }
+}
+
+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
+    {
+        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
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

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

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp1.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Example.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
+    <PackageReference Include="xunit" Version="2.2.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
+  </ItemGroup>
+
+</Project>

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

@@ -1,4 +1,4 @@
-using NUnit.Framework;
+using Xunit;
 using System.Linq;
 
 public class PovTest
@@ -87,74 +87,68 @@ public class PovTest
             })
         });
 
-    [Test]
+    [Fact]
     public void Reparent_singleton()
     {
-        Assert.That(Pov.FromPOV(x, singleton), Is.EqualTo(singleton_));
+        Assert.Equal(singleton_, Pov.FromPOV(x, singleton));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Reparent_flat()
     {
-        Assert.That(Pov.FromPOV(x, flat), Is.EqualTo(flat_));
+        Assert.Equal(flat_, Pov.FromPOV(x, flat));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Reparent_nested()
     {
-        Assert.That(Pov.FromPOV(x, nested), Is.EqualTo(nested_));
+        Assert.Equal(nested_, Pov.FromPOV(x, nested));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Reparent_kids()
     {
-        Assert.That(Pov.FromPOV(x, kids), Is.EqualTo(kids_));
+        Assert.Equal(kids_, Pov.FromPOV(x, kids));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Reparent_cousins()
     {
-        Assert.That(Pov.FromPOV(x, cousins), Is.EqualTo(cousins_));
+        Assert.Equal(cousins_, Pov.FromPOV(x, cousins));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Reparent_from_POV_of_non_existent_node()
     {
-        Assert.That(Pov.FromPOV(x, leaf("foo")), Is.Null);
+        Assert.Null(Pov.FromPOV(x, leaf("foo")));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Should_not_be_able_to_find_a_missing_node()
     {
         var nodes = new[] { singleton, flat, kids, nested, cousins }.Select(graph => Pov.FromPOV("NOT THERE", graph));
     
-        Assert.That(nodes, Is.All.Null);
+        Assert.All(nodes, node =>
+        {
+            Assert.Null(node);
+        });
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cannot_trace_between_unconnected_nodes()
     {
-        Assert.That(Pov.TracePathBetween(x, "NOT THERE", cousins), Is.Null);
+        Assert.Null(Pov.TracePathBetween(x, "NOT THERE", cousins));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_trace_a_path_from_x_to_cousin()
     {
-        Assert.That(Pov.TracePathBetween(x, "cousin-1", cousins), Is.EquivalentTo(new[] { "x", "parent", "grandparent", "uncle", "cousin-1" }));
+        Assert.Equal(new[] { "x", "parent", "grandparent", "uncle", "cousin-1" }, Pov.TracePathBetween(x, "cousin-1", cousins));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_trace_from_a_leaf_to_a_leaf()
     {
-        Assert.That(Pov.TracePathBetween("kid-a", "cousin-0", cousins), Is.EquivalentTo(new[] { "kid-a", "x", "parent", "grandparent", "uncle", "cousin-0" }));
+        Assert.Equal(new[] { "kid-a", "x", "parent", "grandparent", "uncle", "cousin-0" }, Pov.TracePathBetween("kid-a", "cousin-0", cousins));
     }
 }

data/tracks/csharp/exercises/prime-factors/PrimeFactors.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class PrimeFactors
+{
+    public static int[] For(long number)
+    {
+        throw new NotImplementedException();
+    }
+}

data/tracks/csharp/exercises/prime-factors/PrimeFactors.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp1.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Example.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
+    <PackageReference Include="xunit" Version="2.2.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/csharp/exercises/prime-factors/PrimeFactorsTest.cs

@@ -1,81 +1,70 @@
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class PrimeFactorsTest
 {
-    [Test]
+    [Fact]
     public void Test_1()
     {
-        Assert.That(PrimeFactors.For(1), Is.EqualTo(new int[0]));
+        Assert.Equal(new int[0], PrimeFactors.For(1));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_2()
     {
-        Assert.That(PrimeFactors.For(2), Is.EqualTo(new[] { 2 }));
+        Assert.Equal(new[] { 2 }, PrimeFactors.For(2));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_3()
     {
-        Assert.That(PrimeFactors.For(3), Is.EqualTo(new[] { 3 }));
+        Assert.Equal(new[] { 3 }, PrimeFactors.For(3));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_4()
     {
-        Assert.That(PrimeFactors.For(4), Is.EqualTo(new[] { 2, 2 }));
+        Assert.Equal(new[] { 2, 2 }, PrimeFactors.For(4));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_6()
     {
-        Assert.That(PrimeFactors.For(6), Is.EqualTo(new[] { 2, 3 }));
+        Assert.Equal(new[] { 2, 3 }, PrimeFactors.For(6));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_8()
     {
-        Assert.That(PrimeFactors.For(8), Is.EqualTo(new[] { 2, 2, 2 }));
+        Assert.Equal(new[] { 2, 2, 2 }, PrimeFactors.For(8));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_9()
     {
-        Assert.That(PrimeFactors.For(9), Is.EqualTo(new[] { 3, 3 }));
+        Assert.Equal(new[] { 3, 3 }, PrimeFactors.For(9));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_27()
     {
-        Assert.That(PrimeFactors.For(27), Is.EqualTo(new[] { 3, 3, 3 }));
+        Assert.Equal(new[] { 3, 3, 3 }, PrimeFactors.For(27));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_625()
     {
-        Assert.That(PrimeFactors.For(625), Is.EqualTo(new[] { 5, 5, 5, 5 }));
+        Assert.Equal(new[] { 5, 5, 5, 5 }, PrimeFactors.For(625));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_901255()
     {
-        Assert.That(PrimeFactors.For(901255), Is.EqualTo(new[] { 5, 17, 23, 461 }));
+        Assert.Equal(new[] { 5, 17, 23, 461 }, PrimeFactors.For(901255));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_93819012551()
     {
-        Assert.That(PrimeFactors.For(93819012551), Is.EqualTo(new[] { 11, 9539, 894119 }));
+        Assert.Equal(new[] { 11, 9539, 894119 }, PrimeFactors.For(93819012551));
     }
 }

data/tracks/csharp/exercises/protein-translation/ProteinTranslation.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class ProteinTranslation
+{
+    public static string[] Translate(string codon)
+    {
+        throw new NotImplementedException();
+    }
+}

data/tracks/csharp/exercises/protein-translation/ProteinTranslation.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp1.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Example.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
+    <PackageReference Include="xunit" Version="2.2.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/csharp/exercises/protein-translation/ProteinTranslationTest.cs

@@ -1,83 +1,85 @@
 using System;
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class ProteinTranslationTest
 {
-    [TestCase("AUG")]
+    [Theory]
+    [InlineData("AUG")]
     public void Identifies_methionine_codons(string codon)
     {
-        Assert.That(ProteinTranslation.Translate(codon), Is.EquivalentTo(new[] { "Methionine" }));
+        Assert.Equal(new[] { "Methionine" }, ProteinTranslation.Translate(codon));
     }
 
-    [TestCase("UUU", Ignore = "Remove to run test case")]
-    [TestCase("UUC", Ignore = "Remove to run test case")]
+    [Theory(Skip = "Remove to run test")]
+    [InlineData("UUU")]
+    [InlineData("UUC")]
     public void Identifies_phenylalanine_codons(string codon)
     {
-        Assert.That(ProteinTranslation.Translate(codon), Is.EquivalentTo(new[] { "Phenylalanine" }));
+        Assert.Equal(new[] { "Phenylalanine" }, ProteinTranslation.Translate(codon));
     }
 
-    [TestCase("UUA", Ignore = "Remove to run test case")]
-    [TestCase("UUG", Ignore = "Remove to run test case")]
+    [Theory(Skip = "Remove to run test")]
+    [InlineData("UUA")]
+    [InlineData("UUG")]
     public void Identifies_leucine_codons(string codon)
     {
-        Assert.That(ProteinTranslation.Translate(codon), Is.EquivalentTo(new[] { "Leucine" }));
+        Assert.Equal(new[] { "Leucine" }, ProteinTranslation.Translate(codon));
     }
 
-    [TestCase("UCU", Ignore = "Remove to run test case")]
-    [TestCase("UCC", Ignore = "Remove to run test case")]
-    [TestCase("UCA", Ignore = "Remove to run test case")]
-    [TestCase("UCG", Ignore = "Remove to run test case")]
+    [Theory(Skip = "Remove to run test")]
+    [InlineData("UCU")]
+    [InlineData("UCC")]
+    [InlineData("UCA")]
+    [InlineData("UCG")]
     public void Identifies_serine_codons(string codon)
     {
-        Assert.That(ProteinTranslation.Translate(codon), Is.EquivalentTo(new[] { "Serine" }));
+        Assert.Equal(new[] { "Serine" }, ProteinTranslation.Translate(codon));
     }
 
-    [TestCase("UAU", Ignore = "Remove to run test case")]
-    [TestCase("UAC", Ignore = "Remove to run test case")]
+    [Theory(Skip = "Remove to run test")]
+    [InlineData("UAU")]
+    [InlineData("UAC")]
     public void Identifies_tyrosine_codons(string codon)
     {
-        Assert.That(ProteinTranslation.Translate(codon), Is.EquivalentTo(new[] { "Tyrosine" }));
+        Assert.Equal(new[] { "Tyrosine" }, ProteinTranslation.Translate(codon));
     }
 
-    [TestCase("UGU", Ignore = "Remove to run test case")]
-    [TestCase("UGC", Ignore = "Remove to run test case")]
+    [Theory(Skip = "Remove to run test")]
+    [InlineData("UGU")]
+    [InlineData("UGC")]
     public void Identifies_cysteine_codons(string codon)
     {
-        Assert.That(ProteinTranslation.Translate(codon), Is.EquivalentTo(new[] { "Cysteine" }));
+        Assert.Equal(new[] { "Cysteine" }, ProteinTranslation.Translate(codon));
     }
 
-    [TestCase("UGG", Ignore = "Remove to run test case")]
+    [Theory(Skip = "Remove to run test")]
+    [InlineData("UGG")]
     public void Identifies_tryptophan_codons(string codon)
     {
-        Assert.That(ProteinTranslation.Translate(codon), Is.EquivalentTo(new[] { "Tryptophan" }));
+        Assert.Equal(new[] { "Tryptophan" }, ProteinTranslation.Translate(codon));
     }
 
-    [Test]
-    [Ignore("Remove to run test")]
+    [Fact(Skip = "Remove to run test")]
     public void Translates_rna_strand_into_correct_protein()
     {
-        Assert.That(ProteinTranslation.Translate("AUGUUUUGG"), Is.EquivalentTo(new[] { "Methionine", "Phenylalanine", "Tryptophan" }));
+        Assert.Equal(new[] { "Methionine", "Phenylalanine", "Tryptophan" }, ProteinTranslation.Translate("AUGUUUUGG"));
     }
 
-    [Test]
-    [Ignore("Remove to run test")]
+    [Fact(Skip = "Remove to run test")]
     public void Stops_translation_if_stop_codon_present()
     {
-        Assert.That(ProteinTranslation.Translate("AUGUUUUAA"), Is.EquivalentTo(new[] { "Methionine", "Phenylalanine" }));
+        Assert.Equal(new[] { "Methionine", "Phenylalanine" }, ProteinTranslation.Translate("AUGUUUUAA"));
     }
 
-    [Test]
-    [Ignore("Remove to run test")]
+    [Fact(Skip = "Remove to run test")]
     public void Stops_translation_of_longer_strand()
     {
-        Assert.That(ProteinTranslation.Translate("UGGUGUUAUUAAUGGUUU"), Is.EquivalentTo(new[] { "Tryptophan", "Cysteine", "Tyrosine" }));
+        Assert.Equal(new[] { "Tryptophan", "Cysteine", "Tyrosine" }, ProteinTranslation.Translate("UGGUGUUAUUAAUGGUUU"));
     }
 
-    [Test]
-    [Ignore("Remove to run test")]
+    [Fact(Skip = "Remove to run test")]
     public void Throws_for_invalid_codons()
     {
-        Assert.That(() => ProteinTranslation.Translate("CARROT"), Throws.Exception);
+        Assert.Throws<Exception>(() => ProteinTranslation.Translate("CARROT"));
     }
 }