trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/perfect-numbers/PerfectNumbers.cs

@@ -0,0 +1,16 @@
+using System;
+
+public enum NumberType
+{
+    Perfect,
+    Abundant,
+    Deficient
+}
+
+public static class PerfectNumbers
+{
+    public static NumberType Classify(int number)
+    {
+        throw new NotImplementedException();
+    }
+}

data/tracks/csharp/exercises/perfect-numbers/PerfectNumbers.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/perfect-numbers/PerfectNumbersTest.cs

@@ -1,29 +1,31 @@
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class PerfectNumbersTest
 {
-    [TestCase(3)]
-    [TestCase(7, Ignore = "Remove to run test case")]
-    [TestCase(13, Ignore = "Remove to run test case")]
+    [Theory]
+    [InlineData(3)]
+    [InlineData(7)]
+    [InlineData(13)]
     public void Can_classify_deficient_numbers(int number)
     {
-        Assert.That(PerfectNumbers.Classify(number), Is.EqualTo(NumberType.Deficient));
+        Assert.Equal(NumberType.Deficient, PerfectNumbers.Classify(number));
     }
     
-    [TestCase(6, Ignore = "Remove to run test case")]
-    [TestCase(28, Ignore = "Remove to run test case")]
-    [TestCase(496, Ignore = "Remove to run test case")]
+    [Theory(Skip = "Remove to run test")]
+    [InlineData(6)]
+    [InlineData(28)]
+    [InlineData(496)]
     public void Can_classify_perfect_numbers(int number)
     {
-        Assert.That(PerfectNumbers.Classify(number), Is.EqualTo(NumberType.Perfect));
+        Assert.Equal(NumberType.Perfect, PerfectNumbers.Classify(number));
     }
     
-    [TestCase(12, Ignore = "Remove to run test case")]
-    [TestCase(18, Ignore = "Remove to run test case")]
-    [TestCase(20, Ignore = "Remove to run test case")]
+    [Theory(Skip = "Remove to run test")]
+    [InlineData(12)]
+    [InlineData(18)]
+    [InlineData(20)]
     public void Can_classify_abundant_numbers(int number)
     {
-        Assert.That(PerfectNumbers.Classify(number), Is.EqualTo(NumberType.Abundant));
+        Assert.Equal(NumberType.Abundant, PerfectNumbers.Classify(number));
     }
 }

data/tracks/csharp/exercises/phone-number/PhoneNumber.cs

@@ -0,0 +1,24 @@
+using System;
+
+public class PhoneNumber
+{
+    public PhoneNumber(string phoneNumber)
+    {
+    }
+
+    public string Number
+    {
+        get
+        {
+            throw new NotImplementedException("You need to implement this function.");
+        }
+    }
+
+    public string AreaCode
+    {
+        get
+        {
+            throw new NotImplementedException("You need to implement this function.");
+        }
+    }
+}

data/tracks/csharp/exercises/phone-number/PhoneNumber.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/phone-number/PhoneNumberTest.cs

@@ -1,60 +1,53 @@
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class PhoneNumberTest
 {
-    [Test]
+    [Fact]
     public void Cleans_parens_spaces_and_dashes()
     {
         var phone = new PhoneNumber("(123) 456-7890");
-        Assert.That(phone.Number, Is.EqualTo("1234567890"));
+        Assert.Equal("1234567890", phone.Number);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cleans_numbers_with_dots()
     {
         var phone = new PhoneNumber("123.456.7890");
-        Assert.That(phone.Number, Is.EqualTo("1234567890"));
+        Assert.Equal("1234567890", phone.Number);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Allows_us_country_code()
     {
         var phone = new PhoneNumber("11234567890");
-        Assert.That(phone.Number, Is.EqualTo("1234567890"));
+        Assert.Equal("1234567890", phone.Number);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Invalid_when_11_digits()
     {
         var phone = new PhoneNumber("21234567890");
-        Assert.That(phone.Number, Is.EqualTo("0000000000"));
+        Assert.Equal("0000000000", phone.Number);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Invalid_when_9_digits()
     {
         var phone = new PhoneNumber("123456789");
-        Assert.That(phone.Number, Is.EqualTo("0000000000"));
+        Assert.Equal("0000000000", phone.Number);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Has_an_area_code()
     {
         var phone = new PhoneNumber("1234567890");
-        Assert.That(phone.AreaCode, Is.EqualTo("123"));
+        Assert.Equal("123", phone.AreaCode);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Formats_a_number()
     {
         var phone = new PhoneNumber("1234567890");
-        Assert.That(phone.ToString(), Is.EqualTo("(123) 456-7890"));
+        Assert.Equal("(123) 456-7890", phone.ToString());
     }
 }

data/tracks/csharp/exercises/pig-latin/PigLatin.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class PigLatin
+{
+    public static string Translate(string word)
+    {
+        throw new NotImplementedException();
+    }
+}

data/tracks/csharp/exercises/pig-latin/PigLatin.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/pig-latin/PigLatinTest.cs

@@ -1,88 +1,79 @@
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class PigLatinTest
 {
-    [TestCase("apple", ExpectedResult = "appleay")]
-    [TestCase("ear", ExpectedResult = "earay")]
-    [TestCase("igloo", ExpectedResult = "iglooay")]
-    [TestCase("object", ExpectedResult = "objectay")]
-    [TestCase("under", ExpectedResult = "underay")]
-    public string Ay_is_added_to_words_that_start_with_vowels(string word)
+    [Theory]
+    [InlineData("apple", "appleay")]
+    [InlineData("ear", "earay")]
+    [InlineData("igloo", "iglooay")]
+    [InlineData("object", "objectay")]
+    [InlineData("under", "underay")]
+    public void Ay_is_added_to_words_that_start_with_vowels(string word, string expected)
     {
-        return PigLatin.Translate(word);
+        Assert.Equal(expected, PigLatin.Translate(word));
     }
 
-    [Ignore("Remove to run test")]
-    [TestCase("pig", ExpectedResult = "igpay")]
-    [TestCase("koala", ExpectedResult = "oalakay")]
-    [TestCase("yellow", ExpectedResult = "ellowyay")]
-    [TestCase("xenon", ExpectedResult = "enonxay")]
-    public string First_letter_and_ay_are_moved_to_the_end_of_words_that_start_with_consonants(string word)
+    [Theory(Skip = "Remove to run test")]
+    [InlineData("pig", "igpay")]
+    [InlineData("koala", "oalakay")]
+    [InlineData("yellow", "ellowyay")]
+    [InlineData("xenon", "enonxay")]
+    public void First_letter_and_ay_are_moved_to_the_end_of_words_that_start_with_consonants(string word, string expected)
     {
-        return PigLatin.Translate(word);
+        Assert.Equal(expected, PigLatin.Translate(word));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Ch_is_treated_like_a_single_consonant()
     {
-        Assert.That(PigLatin.Translate("chair"), Is.EqualTo("airchay"));
+        Assert.Equal("airchay", PigLatin.Translate("chair"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Qu_is_treated_like_a_single_consonant()
     {
-        Assert.That(PigLatin.Translate("queen"), Is.EqualTo("eenquay"));
+        Assert.Equal("eenquay", PigLatin.Translate("queen"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Qu_and_a_single_preceding_consonant_are_treated_like_a_single_consonant()
     {
-        Assert.That(PigLatin.Translate("square"), Is.EqualTo("aresquay"));
+        Assert.Equal("aresquay", PigLatin.Translate("square"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Th_is_treated_like_a_single_consonant()
     {
-        Assert.That(PigLatin.Translate("therapy"), Is.EqualTo("erapythay"));
+        Assert.Equal("erapythay", PigLatin.Translate("therapy"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Thr_is_treated_like_a_single_consonant()
     {
-        Assert.That(PigLatin.Translate("thrush"), Is.EqualTo("ushthray"));
+        Assert.Equal("ushthray", PigLatin.Translate("thrush"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Sch_is_treated_like_a_single_consonant()
     {
-        Assert.That(PigLatin.Translate("school"), Is.EqualTo("oolschay"));
+        Assert.Equal("oolschay", PigLatin.Translate("school"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Yt_is_treated_like_a_single_vowel()
     {
-        Assert.That(PigLatin.Translate("yttria"), Is.EqualTo("yttriaay"));
+        Assert.Equal("yttriaay", PigLatin.Translate("yttria"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Xr_is_treated_like_a_single_vowel()
     {
-        Assert.That(PigLatin.Translate("xray"), Is.EqualTo("xrayay"));
+        Assert.Equal("xrayay", PigLatin.Translate("xray"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Phrases_are_translated()
     {
-        Assert.That(PigLatin.Translate("quick fast run"), Is.EqualTo("ickquay astfay unray"));
+        Assert.Equal("ickquay astfay unray", PigLatin.Translate("quick fast run"));
     }
 }

data/tracks/csharp/exercises/poker/Poker.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+
+public static class Poker
+{
+    public static IEnumerable<string> BestHands(IEnumerable<string> hands)
+    {
+        throw new NotImplementedException();
+    }
+}

data/tracks/csharp/exercises/poker/Poker.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/poker/PokerTest.cs

@@ -1,181 +1,160 @@
-using NUnit.Framework;
+using Xunit;
 
 public class PokerTest
 {
-    [Test]
+    [Fact]
     public void One_hand()
     {
         const string hand = "4S 5S 7H 8D JC";
-        Assert.That(Poker.BestHands(new[] { hand }), Is.EqualTo(new[] { hand }));
+        Assert.Equal(new[] { hand }, Poker.BestHands(new[] { hand }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Nothing_vs_one_pair()
     {
         const string nothing = "4S 5H 6S 8D JH";
         const string pairOf4 = "2S 4H 6S 4D JH";
-        Assert.That(Poker.BestHands(new[] { nothing, pairOf4 }), Is.EqualTo(new[] { pairOf4 }));
+        Assert.Equal(new[] { pairOf4 }, Poker.BestHands(new[] { nothing, pairOf4 }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Two_pairs()
     {
         const string pairOf2 = "4S 2H 6S 2D JH";
         const string pairOf4 = "2S 4H 6S 4D JH";
-        Assert.That(Poker.BestHands(new[] { pairOf2, pairOf4 }), Is.EqualTo(new[] { pairOf4 }));
+        Assert.Equal(new[] { pairOf4 }, Poker.BestHands(new[] { pairOf2, pairOf4 }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void One_pair_vs_double_pair()
     {
         const string pairOf8 = "2S 8H 6S 8D JH";
         const string doublePair = "4S 5H 4S 8D 5H";
-        Assert.That(Poker.BestHands(new[] { pairOf8, doublePair }), Is.EqualTo(new[] { doublePair }));
+        Assert.Equal(new[] { doublePair }, Poker.BestHands(new[] { pairOf8, doublePair }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Two_double_pairs()
     {
         const string doublePair2And8 = "2S 8H 2S 8D JH";
         const string doublePair4And5 = "4S 5H 4S 8D 5H";
-        Assert.That(Poker.BestHands(new[] { doublePair2And8, doublePair4And5 }), Is.EqualTo(new[] { doublePair2And8 }));
+        Assert.Equal(new[] { doublePair2And8 }, Poker.BestHands(new[] { doublePair2And8, doublePair4And5 }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Double_pair_vs_three()
     {
         const string doublePair2And8 = "2S 8H 2S 8D JH";
         const string threeOf4 = "4S 5H 4S 8D 4H";
-        Assert.That(Poker.BestHands(new[] { doublePair2And8, threeOf4 }), Is.EqualTo(new[] { threeOf4 }));
+        Assert.Equal(new[] { threeOf4 }, Poker.BestHands(new[] { doublePair2And8, threeOf4 }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Two_threes()
     {
         const string threeOf2 = "2S 2H 2S 8D JH";
         const string threeOf1 = "4S AH AS 8D AH";
-        Assert.That(Poker.BestHands(new[] { threeOf2, threeOf1 }), Is.EqualTo(new[] { threeOf1 }));
+        Assert.Equal(new[] { threeOf1 }, Poker.BestHands(new[] { threeOf2, threeOf1 }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Three_vs_straight()
     {
         const string threeOf4 = "4S 5H 4S 8D 4H";
         const string straight = "3S 4H 2S 6D 5H";
-        Assert.That(Poker.BestHands(new[] { threeOf4, straight }), Is.EqualTo(new[] { straight }));
+        Assert.Equal(new[] { straight }, Poker.BestHands(new[] { threeOf4, straight }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Two_straights()
     {
         const string straightTo8 = "4S 6H 7S 8D 5H";
         const string straightTo9 = "5S 7H 8S 9D 6H";
-        Assert.That(Poker.BestHands(new[] { straightTo8, straightTo9 }), Is.EqualTo(new[] { straightTo9 }));
+        Assert.Equal(new[] { straightTo9 }, Poker.BestHands(new[] { straightTo8, straightTo9 }));
         
         const string straightTo1 = "AS QH KS TD JH";
         const string straightTo5 = "4S AH 3S 2D 5H";
-        Assert.That(Poker.BestHands(new[] { straightTo1, straightTo5 }), Is.EqualTo(new[] { straightTo1 }));
+        Assert.Equal(new[] { straightTo1 }, Poker.BestHands(new[] { straightTo1, straightTo5 }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Straight_vs_flush()
     {
         const string straightTo8 = "4S 6H 7S 8D 5H";
         const string flushTo7 = "2S 4S 5S 6S 7S";
-        Assert.That(Poker.BestHands(new[] { straightTo8, flushTo7 }), Is.EqualTo(new[] { flushTo7 }));
+        Assert.Equal(new[] { flushTo7 }, Poker.BestHands(new[] { straightTo8, flushTo7 }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Two_flushes()
     {
         const string flushTo8 = "3H 6H 7H 8H 5H";
         const string flushTo7 = "2S 4S 5S 6S 7S";
-        Assert.That(Poker.BestHands(new[] { flushTo8, flushTo7 }), Is.EqualTo(new[] { flushTo8 }));
+        Assert.Equal(new[] { flushTo8 }, Poker.BestHands(new[] { flushTo8, flushTo7 }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Flush_vs_full()
     {
         const string flushTo8 = "3H 6H 7H 8H 5H";
         const string full = "4S 5H 4S 5D 4H";
-        Assert.That(Poker.BestHands(new[] { full, flushTo8 }), Is.EqualTo(new[] { full }));
+        Assert.Equal(new[] { full }, Poker.BestHands(new[] { full, flushTo8 }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Two_fulls()
     {
         const string fullOf4By9 = "4H 4S 4D 9S 9D";
         const string fullOf5By8 = "5H 5S 5D 8S 8D";
-        Assert.That(Poker.BestHands(new[] { fullOf4By9, fullOf5By8 }), Is.EqualTo(new[] { fullOf5By8 }));
+        Assert.Equal(new[] { fullOf5By8 }, Poker.BestHands(new[] { fullOf4By9, fullOf5By8 }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Full_vs_square()
     {
         const string full = "4S 5H 4S 5D 4H";
         const string squareOf3 = "3S 3H 2S 3D 3H";
-        Assert.That(Poker.BestHands(new[] { full, squareOf3 }), Is.EqualTo(new[] { squareOf3 }));
+        Assert.Equal(new[] { squareOf3 }, Poker.BestHands(new[] { full, squareOf3 }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Two_squares()
     {
         const string squareOf2 = "2S 2H 2S 8D 2H";
         const string squareOf5 = "4S 5H 5S 5D 5H";
-        Assert.That(Poker.BestHands(new[] { squareOf2, squareOf5 }), Is.EqualTo(new[] { squareOf5 }));
+        Assert.Equal(new[] { squareOf5 }, Poker.BestHands(new[] { squareOf2, squareOf5 }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Square_vs_straight_flush()
     {
         const string squareOf5 = "4S 5H 5S 5D 5H";
         const string straightFlushTo9 = "5S 7S 8S 9S 6S";
-        Assert.That(Poker.BestHands(new[] { squareOf5, straightFlushTo9 }), Is.EqualTo(new[] { straightFlushTo9 }));
+        Assert.Equal(new[] { straightFlushTo9 }, Poker.BestHands(new[] { squareOf5, straightFlushTo9 }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Two_straight_flushes()
     {
         const string straightFlushTo8 = "4H 6H 7H 8H 5H";
         const string straightFlushTo9 = "5S 7S 8S 9S 6S";
-        Assert.That(Poker.BestHands(new[] { straightFlushTo8, straightFlushTo9 }),
-            Is.EqualTo(new[] { straightFlushTo9 }));
+        Assert.Equal(new[] { straightFlushTo9 }, Poker.BestHands(new[] { straightFlushTo8, straightFlushTo9 }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Three_hand_with_tie()
     {
         const string spadeStraightTo9 = "9S 8S 7S 6S 5S";
         const string diamondStraightTo9 = "9D 8D 7D 6D 5D";
         const string threeOf4 = "4D 4S 4H QS KS";
-        Assert.That(Poker.BestHands(new[] { spadeStraightTo9, diamondStraightTo9, threeOf4 }),
-            Is.EqualTo(new[] { spadeStraightTo9, diamondStraightTo9 }));
+        Assert.Equal(new[] { spadeStraightTo9, diamondStraightTo9 }, Poker.BestHands(new[] { spadeStraightTo9, diamondStraightTo9, threeOf4 }));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Straight_to_5_against_a_pair_of_jacks()
     {
         const string straightTo5 = "2S 4D 5C 3S AS";
         const string twoJacks = "JD 8D 7D JC 5D";
-        Assert.That(Poker.BestHands(new[] { straightTo5, twoJacks }),
-            Is.EqualTo(new[] { straightTo5 }));
+        Assert.Equal(new[] { straightTo5 }, Poker.BestHands(new[] { straightTo5, twoJacks }));
     }
 }