trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/acronym/AcronymTest.cs

@@ -1,25 +1,22 @@
-namespace Exercism
-{
-    using NUnit.Framework;
+using Xunit;
 
-    [TestFixture]
-    public class AcronymTest
+public class AcronymTest
+{
+    [Fact]
+    public void Empty_string_abbreviated_to_empty_string()
     {
-        [Test]
-        public void Empty_string_abbreviated_to_empty_string()
-        {
-            Assert.That(Acronym.Abbreviate(string.Empty), Is.EqualTo(string.Empty));
-        }
+        Assert.Equal(string.Empty, Acronym.Abbreviate(string.Empty));
+    }
 
-        [TestCase("Portable Network Graphics", ExpectedResult = "PNG", Ignore = "Remove to run test case")]
-        [TestCase("Ruby on Rails", ExpectedResult = "ROR", Ignore = "Remove to run test case")]
-        [TestCase("HyperText Markup Language", ExpectedResult = "HTML", Ignore = "Remove to run test case")]
-        [TestCase("First In, First Out", ExpectedResult = "FIFO", Ignore = "Remove to run test case")]
-        [TestCase("PHP: Hypertext Preprocessor", ExpectedResult = "PHP", Ignore = "Remove to run test case")]
-        [TestCase("Complementary metal-oxide semiconductor", ExpectedResult = "CMOS", Ignore = "Remove to run test case")]
-        public string Phrase_abbreviated_to_acronym(string phrase)
-        {
-            return Acronym.Abbreviate(phrase);
-        }
+    [Theory(Skip = "Remove to run test")]
+    [InlineData("Portable Network Graphics", "PNG")]
+    [InlineData("Ruby on Rails", "ROR")]
+    [InlineData("HyperText Markup Language", "HTML")]
+    [InlineData("First In, First Out", "FIFO")]
+    [InlineData("PHP: Hypertext Preprocessor", "PHP")]
+    [InlineData("Complementary metal-oxide semiconductor", "CMOS")]
+    public void Phrase_abbreviated_to_acronym(string phrase, string expected)
+    {
+        Assert.Equal(expected, Acronym.Abbreviate(phrase));
     }
 }

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

@@ -1,19 +1,16 @@
-namespace Exercism
-{
-    using System.Collections.Generic;
-    using System.Linq;
-    using System.Text.RegularExpressions;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
 
-    public static class Acronym
+public static class Acronym
+{
+    public static string Abbreviate(string phrase)
     {
-        public static string Abbreviate(string phrase)
-        {
-            return Words(phrase).Aggregate("", (abbr, word) => abbr + char.ToUpperInvariant(word[0]));
-        }
+        return Words(phrase).Aggregate("", (abbr, word) => abbr + char.ToUpperInvariant(word[0]));
+    }
 
-        private static IEnumerable<string> Words(string phrase)
-        {
-            return Regex.Matches(phrase, "[A-Z]+[a-z]*|[a-z]+").Cast<Match>().Select(m => m.Value);
-        }
+    private static IEnumerable<string> Words(string phrase)
+    {
+        return Regex.Matches(phrase, "[A-Z]+[a-z]*|[a-z]+").Cast<Match>().Select(m => m.Value);
     }
 }

data/tracks/csharp/exercises/all-your-base/AllYourBase.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class Base
+{
+    public static int[] Rebase(int inputBase, int[] inputDigits, int outputBase)
+    {
+        throw new NotImplementedException("Please implement this function");
+    }
+}

data/tracks/csharp/exercises/all-your-base/AllYourBase.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/all-your-base/AllYourBaseTest.cs

@@ -1,98 +1,89 @@
 using System;
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class AllYourBaseTest
 {
-    [Test]
+    [Fact]
     public void Single_bit_one_to_decimal()
     {
         const int inputBase = 2;
         var inputDigits = new [] { 1 };
         const int outputBase = 10;
         var outputDigits = new [] { 1 };
-        Assert.That(Base.Rebase(inputBase, inputDigits, outputBase), Is.EqualTo(outputDigits));
+        Assert.Equal(outputDigits, Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Binary_to_single_decimal()
     {
         const int inputBase = 2;
         var inputDigits = new [] { 1, 0, 1 };
         const int outputBase = 10;
         var outputDigits = new [] { 5 };
-        Assert.That(Base.Rebase(inputBase, inputDigits, outputBase), Is.EqualTo(outputDigits));
+        Assert.Equal(outputDigits, Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Single_decimal_to_binary()
     {  
         const int inputBase = 10;
         var inputDigits = new [] { 5 };
         const int outputBase = 2;
         var outputDigits = new [] { 1, 0, 1 };
-        Assert.That(Base.Rebase(inputBase, inputDigits, outputBase), Is.EqualTo(outputDigits));
+        Assert.Equal(outputDigits, Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Binary_to_multiple_decimal()
     {
         const int inputBase = 2;
         var inputDigits = new [] { 1, 0, 1, 0, 1, 0 };
         const int outputBase = 10;
         var outputDigits = new [] { 4, 2 };
-        Assert.That(Base.Rebase(inputBase, inputDigits, outputBase), Is.EqualTo(outputDigits));
+        Assert.Equal(outputDigits, Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Decimal_to_binary()
     {
         const int inputBase = 10;
         var inputDigits = new [] { 4, 2 };
         const int outputBase = 2;
         var outputDigits = new [] { 1, 0, 1, 0, 1, 0 };
-        Assert.That(Base.Rebase(inputBase, inputDigits, outputBase), Is.EqualTo(outputDigits));
+        Assert.Equal(outputDigits, Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Trinary_to_hexadecimal()
     {
         const int inputBase = 3;
         var inputDigits = new [] { 1, 1, 2, 0 };
         const int outputBase = 16;
         var outputDigits = new [] { 2, 10 };
-        Assert.That(Base.Rebase(inputBase, inputDigits, outputBase), Is.EqualTo(outputDigits));
+        Assert.Equal(outputDigits, Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Hexadecimal_to_trinary()
     {
         const int inputBase = 16;
         var inputDigits = new [] { 2, 10 };
         const int outputBase = 3;
         var outputDigits = new [] { 1, 1, 2, 0 };
-        Assert.That(Base.Rebase(inputBase, inputDigits, outputBase), Is.EqualTo(outputDigits));
+        Assert.Equal(outputDigits, Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Using_15_bit_integer()
     {
         const int inputBase = 97;
         var inputDigits = new [] { 3, 46, 60 };
         const int outputBase = 73;
         var outputDigits = new [] { 6, 10, 45 };
-        Assert.That(Base.Rebase(inputBase, inputDigits, outputBase), Is.EqualTo(outputDigits));
+        Assert.Equal(outputDigits, Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Empty_array()
     {
         const int inputBase = 2;
@@ -101,8 +92,7 @@ public class AllYourBaseTest
         Assert.Throws<ArgumentException>(() => Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Single_zero()
     {
         const int inputBase = 10;
@@ -111,8 +101,7 @@ public class AllYourBaseTest
         Assert.Throws<ArgumentException>(() => Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Multiple_zeros()
     {
         const int inputBase = 10;
@@ -121,8 +110,7 @@ public class AllYourBaseTest
         Assert.Throws<ArgumentException>(() => Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Leading_zeros()
     {
         const int inputBase = 7;
@@ -131,8 +119,7 @@ public class AllYourBaseTest
         Assert.Throws<ArgumentException>(() => Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Negative_digit()
     {
         const int inputBase = 2;
@@ -141,8 +128,7 @@ public class AllYourBaseTest
         Assert.Throws<ArgumentException>(() => Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Invalid_positive_digit()
     {
         const int inputBase = 2;
@@ -151,8 +137,7 @@ public class AllYourBaseTest
         Assert.Throws<ArgumentException>(() => Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void First_base_is_one()
     {
         const int inputBase = 1;
@@ -161,8 +146,7 @@ public class AllYourBaseTest
         Assert.Throws<ArgumentException>(() => Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Second_base_is_one()
     {
         const int inputBase = 2;
@@ -171,8 +155,7 @@ public class AllYourBaseTest
         Assert.Throws<ArgumentException>(() => Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void First_base_is_zero()
     {
         const int inputBase = 0;
@@ -181,8 +164,7 @@ public class AllYourBaseTest
         Assert.Throws<ArgumentException>(() => Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Second_base_is_zero()
     {
         const int inputBase = 10;
@@ -191,8 +173,7 @@ public class AllYourBaseTest
         Assert.Throws<ArgumentException>(() => Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void First_base_is_negative()
     {
         const int inputBase = -2;
@@ -201,8 +182,7 @@ public class AllYourBaseTest
         Assert.Throws<ArgumentException>(() => Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Second_base_is_negative()
     {
         const int inputBase = 2;
@@ -211,8 +191,7 @@ public class AllYourBaseTest
         Assert.Throws<ArgumentException>(() => Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Both_bases_are_negative()
     {
         const int inputBase = -2;

data/tracks/csharp/exercises/allergies/Allergies.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+
+public class Allergies
+{
+    public Allergies(int mask)
+    {
+    }
+
+    public bool AllergicTo(string allergy)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public IList<string> List()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/allergies/Allergies.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/allergies/AllergiesTest.cs

@@ -1,84 +1,73 @@
 using System.Collections.Generic;
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class AllergiesTest
 {
-    [Test]
+    [Fact]
     public void No_allergies_means_not_allergic()
     {
         var allergies = new Allergies(0);
-        Assert.That(allergies.AllergicTo("peanuts"), Is.False);
-        Assert.That(allergies.AllergicTo("cats"), Is.False);
-        Assert.That(allergies.AllergicTo("strawberries"), Is.False);
+        Assert.False(allergies.AllergicTo("peanuts"));
+        Assert.False(allergies.AllergicTo("cats"));
+        Assert.False(allergies.AllergicTo("strawberries"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Allergic_to_eggs()
     {
         var allergies = new Allergies(1);
-        Assert.That(allergies.AllergicTo("eggs"), Is.True);
+        Assert.True(allergies.AllergicTo("eggs"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Allergic_to_eggs_in_addition_to_other_stuff()
     {
         var allergies = new Allergies(5);
-        Assert.That(allergies.AllergicTo("eggs"), Is.True);
-        Assert.That(allergies.AllergicTo("shellfish"), Is.True);
-        Assert.That(allergies.AllergicTo("strawberries"), Is.False);
+        Assert.True(allergies.AllergicTo("eggs"));
+        Assert.True(allergies.AllergicTo("shellfish"));
+        Assert.False(allergies.AllergicTo("strawberries"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void No_allergies_at_all()
     {
         var allergies = new Allergies(0);
-        Assert.That(allergies.List(), Is.Empty);
+        Assert.Empty(allergies.List());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Allergic_to_just_eggs()
     {
         var allergies = new Allergies(1);
-        Assert.That(allergies.List(), Is.EqualTo(new List<string> { "eggs" }));
+        Assert.Equal(new List<string> { "eggs" }, allergies.List());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Allergic_to_just_peanuts()
     {
         var allergies = new Allergies(2);
-        Assert.That(allergies.List(), Is.EqualTo(new List<string> { "peanuts" }));
+        Assert.Equal(new List<string> { "peanuts" }, allergies.List());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Allergic_to_eggs_and_peanuts()
     {
         var allergies = new Allergies(3);
-        Assert.That(allergies.List(), Is.EqualTo(new List<string> { "eggs", "peanuts" }));
+        Assert.Equal(new List<string> { "eggs", "peanuts" }, allergies.List());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Allergic_to_lots_of_stuff()
     {
         var allergies = new Allergies(248);
-        Assert.That(allergies.List(),
-            Is.EqualTo(new List<string> { "strawberries", "tomatoes", "chocolate", "pollen", "cats" }));
+        Assert.Equal(new List<string> { "strawberries", "tomatoes", "chocolate", "pollen", "cats" }, allergies.List());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Allergic_to_everything()
     {
         var allergies = new Allergies(255);
-        Assert.That(allergies.List(),
-            Is.EqualTo(new List<string>
+        Assert.Equal(new List<string>
                 {
                     "eggs",
                     "peanuts",
@@ -88,16 +77,15 @@ public class AllergiesTest
                     "chocolate",
                     "pollen",
                     "cats"
-                }));
+                },
+                allergies.List());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Ignore_non_allergen_score_parts()
     {
         var allergies = new Allergies(509);
-        Assert.That(allergies.List(),
-            Is.EqualTo(new List<string>
+        Assert.Equal(new List<string>
                 {
                     "eggs",
                     "shellfish",
@@ -106,6 +94,6 @@ public class AllergiesTest
                     "chocolate",
                     "pollen",
                     "cats"
-                }));
+                }, allergies.List());
     }
 }