trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/rna-transcription/RnaTranscription.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class Complement
+{
+    public static string OfDna(string nucleotide)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/rna-transcription/RnaTranscription.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/rna-transcription/RnaTranscriptionTest.cs

@@ -0,0 +1,34 @@
+using Xunit;
+
+public class ComplementTest
+{
+    [Fact]
+    public void Rna_complement_of_cytosine_is_guanine()
+    {
+        Assert.Equal("G", Complement.OfDna("C"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Rna_complement_of_guanine_is_cytosine()
+    {
+        Assert.Equal("C", Complement.OfDna("G"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Rna_complement_of_thymine_is_adenine()
+    {
+        Assert.Equal("A", Complement.OfDna("T"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Rna_complement_of_adenine_is_uracil()
+    {
+        Assert.Equal("U", Complement.OfDna("A"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Rna_complement()
+    {
+        Assert.Equal("UGCACCAGAAUU", Complement.OfDna("ACGTGGTCTTAA"));
+    }
+}

data/tracks/csharp/exercises/robot-name/RobotName.cs

@@ -0,0 +1,17 @@
+using System;
+
+public class Robot
+{
+    public string Name
+    {
+        get
+        {
+            throw new NotImplementedException("You need to implement this function.");
+        }
+    }
+
+    public void Reset()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/robot-name/RobotName.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/robot-name/RobotNameTest.cs

@@ -1,43 +1,33 @@
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class RobotNameTest
 {
-    private Robot robot;
+    private readonly Robot robot = new Robot();
 
-    [SetUp]
-    public void Setup()
-    {
-        robot = new Robot();
-    }
-
-    [Test]
+    [Fact]
     public void Robot_has_a_name()
     {
-        StringAssert.IsMatch(@"[A-Z]{2}\d{3}", robot.Name);
+        Assert.Matches(@"[A-Z]{2}\d{3}", robot.Name);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Name_is_the_same_each_time()
     {
-        Assert.That(robot.Name, Is.EqualTo(robot.Name));
+        Assert.Equal(robot.Name, robot.Name);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Different_robots_have_different_names()
     {
         var robot2 = new Robot();
-        Assert.That(robot.Name, Is.Not.EqualTo(robot2.Name));
+        Assert.NotEqual(robot2.Name, robot.Name);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_reset_the_name()
     {
         var originalName = robot.Name;
         robot.Reset();
-        Assert.That(robot.Name, Is.Not.EqualTo(originalName));
+        Assert.NotEqual(originalName, robot.Name);
     }
 }

data/tracks/csharp/exercises/robot-simulator/RobotSimulator.cs

@@ -0,0 +1,64 @@
+using System;
+
+public enum Bearing
+{
+    North,
+    East,
+    South,
+    West
+}
+
+public struct Coordinate
+{
+    public Coordinate(int x, int y)
+    {
+        X = x;
+        Y = y;
+    }
+
+    public int X { get; }
+    public int Y { get; }
+}
+
+public class RobotSimulator
+{
+    public RobotSimulator(Bearing bearing, Coordinate coordinate)
+    {
+    }
+
+    public Bearing Bearing
+    {
+        get
+        {
+            throw new NotImplementedException("You need to implement this function.");
+        }
+    }
+
+    public Coordinate Coordinate
+    {
+        get
+        {
+            throw new NotImplementedException("You need to implement this function.");
+        }
+    }
+
+    public void TurnRight()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public void TurnLeft()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public void Advance()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public void Simulate(string instructions)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/robot-simulator/RobotSimulator.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/robot-simulator/RobotSimulatorTest.cs

@@ -1,64 +1,59 @@
-using NUnit.Framework;
+using Xunit;
 
 public class RobotSimulatorTest
 {
-    [Test]
+    [Fact]
     public void Turn_right_edge_case()
     {
         var robot = new RobotSimulator(Bearing.West, new Coordinate(0, 0));
         robot.TurnRight();
-        Assert.That(robot.Bearing, Is.EqualTo(Bearing.North));
+        Assert.Equal(Bearing.North, robot.Bearing);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Turn_left_edge_case()
     {
         var robot = new RobotSimulator(Bearing.North, new Coordinate(0, 0));
         robot.TurnLeft();
-        Assert.That(robot.Bearing, Is.EqualTo(Bearing.West));
+        Assert.Equal(Bearing.West, robot.Bearing);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Robbie()
     {
         var robbie = new RobotSimulator(Bearing.East, new Coordinate(-2, 1));
-        Assert.That(robbie.Bearing, Is.EqualTo(Bearing.East));
-        Assert.That(robbie.Coordinate, Is.EqualTo(new Coordinate(-2, 1)));
+        Assert.Equal(Bearing.East, robbie.Bearing);
+        Assert.Equal(new Coordinate(-2, 1), robbie.Coordinate);
 
         robbie.Simulate("RLAALAL");
-        Assert.That(robbie.Bearing, Is.EqualTo(Bearing.West));
-        Assert.That(robbie.Coordinate, Is.EqualTo(new Coordinate(0, 2)));
+        Assert.Equal(Bearing.West, robbie.Bearing);
+        Assert.Equal(new Coordinate(0, 2), robbie.Coordinate);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Clutz()
     {
         var clutz = new RobotSimulator(Bearing.North, new Coordinate(0, 0));
         clutz.Simulate("LAAARALA");
-        Assert.That(clutz.Bearing, Is.EqualTo(Bearing.West));
-        Assert.That(clutz.Coordinate, Is.EqualTo(new Coordinate(-4, 1)));
+        Assert.Equal(Bearing.West, clutz.Bearing);
+        Assert.Equal(new Coordinate(-4, 1), clutz.Coordinate);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Sphero()
     {
         var sphero = new RobotSimulator(Bearing.East, new Coordinate(2, -7));
         sphero.Simulate("RRAAAAALA");
-        Assert.That(sphero.Bearing, Is.EqualTo(Bearing.South));
-        Assert.That(sphero.Coordinate, Is.EqualTo(new Coordinate(-3, -8)));
+        Assert.Equal(Bearing.South, sphero.Bearing);
+        Assert.Equal(new Coordinate(-3, -8), sphero.Coordinate);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Roomba()
     {
         var roomba = new RobotSimulator(Bearing.South, new Coordinate(8, 4));
         roomba.Simulate("LAAARRRALLLL");
-        Assert.That(roomba.Bearing, Is.EqualTo(Bearing.North));
-        Assert.That(roomba.Coordinate, Is.EqualTo(new Coordinate(11, 5)));
+        Assert.Equal(Bearing.North, roomba.Bearing);
+        Assert.Equal(new Coordinate(11, 5), roomba.Coordinate);
     }
 }

data/tracks/csharp/exercises/roman-numerals/RomanNumerals.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class RomanNumeralExtension
+{
+    public static string ToRoman(this int value)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/roman-numerals/RomanNumerals.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/roman-numerals/RomanNumeralsTest.cs

@@ -1,29 +1,29 @@
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class RomanNumeralsTest
 {
-    [TestCase(0, ExpectedResult = "")]
-    [TestCase(1, ExpectedResult = "I", Ignore = "Remove to run test case")]
-    [TestCase(2, ExpectedResult = "II", Ignore = "Remove to run test case")]
-    [TestCase(3, ExpectedResult = "III", Ignore = "Remove to run test case")]
-    [TestCase(4, ExpectedResult = "IV", Ignore = "Remove to run test case")]
-    [TestCase(5, ExpectedResult = "V", Ignore = "Remove to run test case")]
-    [TestCase(6, ExpectedResult = "VI", Ignore = "Remove to run test case")]
-    [TestCase(9, ExpectedResult = "IX", Ignore = "Remove to run test case")]
-    [TestCase(27, ExpectedResult = "XXVII", Ignore = "Remove to run test case")]
-    [TestCase(48, ExpectedResult = "XLVIII", Ignore = "Remove to run test case")]
-    [TestCase(59, ExpectedResult = "LIX", Ignore = "Remove to run test case")]
-    [TestCase(93, ExpectedResult = "XCIII", Ignore = "Remove to run test case")]
-    [TestCase(141, ExpectedResult = "CXLI", Ignore = "Remove to run test case")]
-    [TestCase(163, ExpectedResult = "CLXIII", Ignore = "Remove to run test case")]
-    [TestCase(402, ExpectedResult = "CDII", Ignore = "Remove to run test case")]
-    [TestCase(575, ExpectedResult = "DLXXV", Ignore = "Remove to run test case")]
-    [TestCase(911, ExpectedResult = "CMXI", Ignore = "Remove to run test case")]
-    [TestCase(1024, ExpectedResult = "MXXIV", Ignore = "Remove to run test case")]
-    [TestCase(3000, ExpectedResult = "MMM", Ignore = "Remove to run test case")]
-    public string Convert_roman_to_arabic_numerals(int arabicNumeral)
+    [Theory]
+    [InlineData(0, "")]
+    [InlineData(1, "I")]
+    [InlineData(2, "II")]
+    [InlineData(3, "III")]
+    [InlineData(4, "IV")]
+    [InlineData(5, "V")]
+    [InlineData(6, "VI")]
+    [InlineData(9, "IX")]
+    [InlineData(27, "XXVII")]
+    [InlineData(48, "XLVIII")]
+    [InlineData(59, "LIX")]
+    [InlineData(93, "XCIII")]
+    [InlineData(141, "CXLI")]
+    [InlineData(163, "CLXIII")]
+    [InlineData(402, "CDII")]
+    [InlineData(575, "DLXXV")]
+    [InlineData(911, "CMXI")]
+    [InlineData(1024, "MXXIV")]
+    [InlineData(3000, "MMM")]
+    public void Convert_roman_to_arabic_numerals(int arabicNumeral, string expected)
     {
-        return arabicNumeral.ToRoman();
+        Assert.Equal(expected, arabicNumeral.ToRoman());
     }
 }

data/tracks/csharp/exercises/run-length-encoding/RunLengthEncoding.cs

@@ -0,0 +1,14 @@
+using System;
+
+public static class RunLengthEncoding
+{
+    public static string Encode(string input)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public static string Decode(string input)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/run-length-encoding/RunLengthEncoding.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/run-length-encoding/RunLengthEncodingTest.cs

@@ -1,66 +1,60 @@
-using NUnit.Framework;
+using Xunit;
 
 public class RunLengthEncodingTest
 {
-    [Test]
+    [Fact]
     public void Encode_simple()
     {
         const string input = "AABBBCCCC";
         const string expected = "2A3B4C";
-        Assert.That(RunLengthEncoding.Encode(input), Is.EqualTo(expected));
+        Assert.Equal(expected, RunLengthEncoding.Encode(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Decode_simple()
     {
         const string input = "2A3B4C";
         const string expected = "AABBBCCCC";
-        Assert.That(RunLengthEncoding.Decode(input), Is.EqualTo(expected));
+        Assert.Equal(expected, RunLengthEncoding.Decode(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Encode_with_single_values()
     {
         const string input = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB";
         const string expected = "12WB12W3B24WB";
-        Assert.That(RunLengthEncoding.Encode(input), Is.EqualTo(expected));
+        Assert.Equal(expected, RunLengthEncoding.Encode(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Decode_with_single_values()
     {
         const string input = "12WB12W3B24WB";
         const string expected = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB";
-        Assert.That(RunLengthEncoding.Decode(input), Is.EqualTo(expected));
+        Assert.Equal(expected, RunLengthEncoding.Decode(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Encode_and_then_decode()
     {
         const string input = "zzz ZZ  zZ";
         const string expected = "zzz ZZ  zZ";
-        Assert.That(RunLengthEncoding.Decode(RunLengthEncoding.Encode(input)), Is.EqualTo(expected));
+        Assert.Equal(expected, RunLengthEncoding.Decode(RunLengthEncoding.Encode(input)));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Encode_unicode()
     {
         const string input = "⏰⚽⚽⚽⭐⭐⏰";
         const string expected = "⏰3⚽2⭐⏰";
-        Assert.That(RunLengthEncoding.Encode(input), Is.EqualTo(expected));
+        Assert.Equal(expected, RunLengthEncoding.Encode(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Decode_unicode()
     {
         const string input = "⏰3⚽2⭐⏰";
         const string expected = "⏰⚽⚽⚽⭐⭐⏰";
-        Assert.That(RunLengthEncoding.Decode(input), Is.EqualTo(expected));
+        Assert.Equal(expected, RunLengthEncoding.Decode(input));
     }
 }