trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/saddle-points/SaddlePointTest.cs

@@ -1,9 +1,9 @@
 using System;
-using NUnit.Framework;
+using Xunit;
 
 public class SaddlePointTests
 {
-    [Test]
+    [Fact]
     public void Readme_example()
     {
         var values = new[,]
@@ -13,11 +13,10 @@ public class SaddlePointTests
             { 6, 6, 7 }
         };
         var actual = new SaddlePoints(values).Calculate();
-        Assert.That(actual, Is.EqualTo(new [] { Tuple.Create(1, 0)}));
+        Assert.Equal(new [] { Tuple.Create(1, 0)}, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void No_saddle_point()
     {
         var values = new[,] 
@@ -26,11 +25,10 @@ public class SaddlePointTests
             { 1, 2 }
         };
         var actual = new SaddlePoints(values).Calculate();
-        Assert.That(actual, Is.Empty);
+        Assert.Empty(actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Saddle_point()
     {
         var values = new[,] 
@@ -39,11 +37,10 @@ public class SaddlePointTests
             { 3, 4 }
         };
         var actual = new SaddlePoints(values).Calculate();
-        Assert.That(actual, Is.EqualTo(new[] { Tuple.Create(0, 1) }));
+        Assert.Equal(new[] { Tuple.Create(0, 1) }, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Another_saddle_point()
     {
         var values = new[,] 
@@ -53,11 +50,10 @@ public class SaddlePointTests
             {  3,  4,  8,  6,   7 }
         };
         var actual = new SaddlePoints(values).Calculate();
-        Assert.That(actual, Is.EqualTo(new[] { Tuple.Create(2, 2) }));
+        Assert.Equal(new[] { Tuple.Create(2, 2) }, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Multiple_saddle_points()
     {
         var values = new[,]
@@ -67,6 +63,6 @@ public class SaddlePointTests
             { 1, 5, 4 }
         };
         var actual = new SaddlePoints(values).Calculate();
-        Assert.That(actual, Is.EqualTo(new[] { Tuple.Create(0, 1), Tuple.Create(1, 1), Tuple.Create(2, 1) }));
+        Assert.Equal(new[] { Tuple.Create(0, 1), Tuple.Create(1, 1), Tuple.Create(2, 1) }, actual);
     }
 }

data/tracks/csharp/exercises/saddle-points/SaddlePoints.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public class SaddlePoints
+{
+    public SaddlePoints(int[,] values)
+    {
+    }
+
+    public IEnumerable<Tuple<int, int>> Calculate()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/saddle-points/SaddlePoints.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/say/Example.cs

@@ -8,7 +8,7 @@ public static class Say
     {
         if (number < 0L || number >= 1000000000000L)
         {
-            throw new ArgumentException("Number out of range.");
+            throw new ArgumentOutOfRangeException("Number out of range.");
         }
 
         if (number == 0L)

data/tracks/csharp/exercises/say/Say.cs

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

data/tracks/csharp/exercises/say/Say.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/say/SayTest.cs

@@ -1,115 +1,101 @@
-using NUnit.Framework;
+using System;
+using Xunit;
 
 public class SayTest
 {
-    [Test]
+    [Fact]
     public void Zero()
     {
-        Assert.That(Say.InEnglish(0L), Is.EqualTo("zero"));
+        Assert.Equal("zero", Say.InEnglish(0L));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void One()
     {
-        Assert.That(Say.InEnglish(1L), Is.EqualTo("one"));
+        Assert.Equal("one", Say.InEnglish(1L));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Fourteen()
     {
-        Assert.That(Say.InEnglish(14L), Is.EqualTo("fourteen"));
+        Assert.Equal("fourteen", Say.InEnglish(14L));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Twenty()
     {
-        Assert.That(Say.InEnglish(20L), Is.EqualTo("twenty"));
+        Assert.Equal("twenty", Say.InEnglish(20L));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Twenty_two()
     {
-        Assert.That(Say.InEnglish(22L), Is.EqualTo("twenty-two"));
+        Assert.Equal("twenty-two", Say.InEnglish(22L));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void One_hundred()
     {
-        Assert.That(Say.InEnglish(100L), Is.EqualTo("one hundred"));
+        Assert.Equal("one hundred", Say.InEnglish(100L));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void One_hundred_twenty_three()
     {
-        Assert.That(Say.InEnglish(123L), Is.EqualTo("one hundred twenty-three"));
+        Assert.Equal("one hundred twenty-three", Say.InEnglish(123L));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void One_thousand()
     {
-        Assert.That(Say.InEnglish(1000L), Is.EqualTo("one thousand"));
+        Assert.Equal("one thousand", Say.InEnglish(1000L));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void One_thousand_two_hundred_thirty_four()
     {
-        Assert.That(Say.InEnglish(1234L), Is.EqualTo("one thousand two hundred thirty-four"));
+        Assert.Equal("one thousand two hundred thirty-four", Say.InEnglish(1234L));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void One_million()
     {
-        Assert.That(Say.InEnglish(1000000L), Is.EqualTo("one million"));
+        Assert.Equal("one million", Say.InEnglish(1000000L));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void One_million_two()
     {
-        Assert.That(Say.InEnglish(1000002L), Is.EqualTo("one million two"));
+        Assert.Equal("one million two", Say.InEnglish(1000002L));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void One_million_two_thousand_three_hundred_forty_five()
     {
-        Assert.That(Say.InEnglish(1002345L), Is.EqualTo("one million two thousand three hundred forty-five"));
+        Assert.Equal("one million two thousand three hundred forty-five", Say.InEnglish(1002345L));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void One_billion()
     {
-        Assert.That(Say.InEnglish(1000000000L), Is.EqualTo("one billion"));
+        Assert.Equal("one billion", Say.InEnglish(1000000000L));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void A_big_number()
     {
-        Assert.That(Say.InEnglish(987654321123L), Is.EqualTo("nine hundred eighty-seven billion six hundred fifty-four million three hundred twenty-one thousand one hundred twenty-three"));
+        Assert.Equal("nine hundred eighty-seven billion six hundred fifty-four million three hundred twenty-one thousand one hundred twenty-three", Say.InEnglish(987654321123L));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Lower_bound()
     {
-        Assert.That(() => Say.InEnglish(-1L), Throws.Exception);
+        Assert.Throws<ArgumentOutOfRangeException>(() => Say.InEnglish(-1L));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Upper_bound()
     {
-        Assert.That(() => Say.InEnglish(1000000000000L), Throws.Exception);
+        Assert.Throws<ArgumentOutOfRangeException>(() => Say.InEnglish(1000000000000L));
     }
 }

data/tracks/csharp/exercises/scale-generator/Example.cs

@@ -17,7 +17,7 @@ public static class ScaleGenerator
     public static string[] Pitches(string tonic, string pattern)
     {
         var scale = Scale(tonic);
-        var index = Array.FindIndex(scale, pitch => string.Equals(pitch, tonic, StringComparison.InvariantCultureIgnoreCase));
+        var index = Array.FindIndex(scale, pitch => string.Equals(pitch, tonic, StringComparison.OrdinalIgnoreCase));
         var shiftedScale = Shift(index, scale);
 
         var pitches = new List<string>();

data/tracks/csharp/exercises/scale-generator/ScaleGenerator.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class ScaleGenerator
+{
+    public static string[] Pitches(string tonic, string pattern)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/scale-generator/ScaleGenerator.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/scale-generator/ScaleGeneratorTest.cs

@@ -1,129 +1,116 @@
-using NUnit.Framework;
+using Xunit;
 
 public class ScaleGeneratorTest
 {
-    [Test]
+    [Fact]
     public void Major_scale()
     {
         var major = ScaleGenerator.Pitches("C", "MMmMMMm");
         var expected = new[] {"C", "D", "E", "F", "G", "A", "B"};
-        Assert.That(major, Is.EqualTo(expected));
+        Assert.Equal(expected, major);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Another_major_scale()
     {
         var major = ScaleGenerator.Pitches("G", "MMmMMMm");
         var expected = new[] {"G", "A", "B", "C", "D", "E", "F#"};
-        Assert.That(major, Is.EqualTo(expected));
+        Assert.Equal(expected, major);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Minor_scale()
     {
         var minor = ScaleGenerator.Pitches("f#", "MmMMmMM");
         var expected = new[] {"F#", "G#", "A", "B", "C#", "D", "E"};
-        Assert.That(minor, Is.EqualTo(expected));
+        Assert.Equal(expected, minor);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Another_minor_scale()
     {
         var minor = ScaleGenerator.Pitches("bb", "MmMMmMM");
         var expected = new[] {"Bb", "C", "Db", "Eb", "F", "Gb", "Ab"};
-        Assert.That(minor, Is.EqualTo(expected));
+        Assert.Equal(expected, minor);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Dorian_mode()
     {
         var dorian = ScaleGenerator.Pitches("d", "MmMMMmM");
         var expected = new[] {"D", "E", "F", "G", "A", "B", "C"};
-        Assert.That(dorian, Is.EqualTo(expected));
+        Assert.Equal(expected, dorian);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Mixolydian_mode()
     {
         var mixolydian = ScaleGenerator.Pitches("Eb", "MMmMMmM");
         var expected = new[] {"Eb", "F", "G", "Ab", "Bb", "C", "Db"};
-        Assert.That(mixolydian, Is.EqualTo(expected));
+        Assert.Equal(expected, mixolydian);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Lydian_mode()
     {
         var lydian = ScaleGenerator.Pitches("a", "MMMmMMm");
         var expected = new[] {"A", "B", "C#", "D#", "E", "F#", "G#"};
-        Assert.That(lydian, Is.EqualTo(expected));
+        Assert.Equal(expected, lydian);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Phrygian_mode()
     {
         var phrygian = ScaleGenerator.Pitches("e", "mMMMmMM");
         var expected = new[] {"E", "F", "G", "A", "B", "C", "D"};
-        Assert.That(phrygian, Is.EqualTo(expected));
+        Assert.Equal(expected, phrygian);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Locrian_mode()
     {
         var locrian = ScaleGenerator.Pitches("g", "mMMmMMM");
         var expected = new[] {"G", "Ab", "Bb", "C", "Db", "Eb", "F"};
-        Assert.That(locrian, Is.EqualTo(expected));
+        Assert.Equal(expected, locrian);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Harmonic_minor()
     {
         var harmonicMinor = ScaleGenerator.Pitches("d", "MmMMmAm");
         var expected = new[] {"D", "E", "F", "G", "A", "Bb", "Db"};
-        Assert.That(harmonicMinor, Is.EqualTo(expected));
+        Assert.Equal(expected, harmonicMinor);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Octatonic()
     {
         var octatonic = ScaleGenerator.Pitches("C", "MmMmMmMm");
         var expected = new[] {"C", "D", "D#", "F", "F#", "G#", "A", "B"};
-        Assert.That(octatonic, Is.EqualTo(expected));
+        Assert.Equal(expected, octatonic);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Hexatonic()
     {
         var hexatonic = ScaleGenerator.Pitches("Db", "MMMMMM");
         var expected = new[] {"Db", "Eb", "F", "G", "A", "B"};
-        Assert.That(hexatonic, Is.EqualTo(expected));
+        Assert.Equal(expected, hexatonic);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Pentatonic()
     {
         var pentatonic = ScaleGenerator.Pitches("A", "MMAMA");
         var expected = new[] {"A", "B", "C#", "E", "F#"};
-        Assert.That(pentatonic, Is.EqualTo(expected));
+        Assert.Equal(expected, pentatonic);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Enigmatic()
     {
         var enigmatic = ScaleGenerator.Pitches("G", "mAMMMmm");
         var expected = new[] {"G", "G#", "B", "C#", "D#", "F", "F#"};
-        Assert.That(enigmatic, Is.EqualTo(expected));
+        Assert.Equal(expected, enigmatic);
     }
 }