trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/crypto-square/CryptoSquare.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+
+public class Crypto
+{
+    public Crypto(string input)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public int Size
+    { 
+        get
+        {
+            throw new NotImplementedException("Please implement this function");
+        }
+    }
+
+    public string NormalizePlaintext 
+    { 
+        get
+        {
+            throw new NotImplementedException("Please implement this function");
+        }
+    }
+
+    public string NormalizeCiphertext()
+    {
+        throw new NotImplementedException("Please implement this function");
+    }
+
+    public string Ciphertext()
+    {
+        throw new NotImplementedException("Please implement this function");
+    }
+
+    public IEnumerable<string> PlaintextSegments()
+    {
+        throw new NotImplementedException("Please implement this function");
+    }
+}

data/tracks/csharp/exercises/crypto-square/CryptoSquare.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/crypto-square/CryptoSquareTest.cs

@@ -1,132 +1,116 @@
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class CryptoSquareTest
 {
-    [Test]
+    [Fact]
     public void Strange_characters_are_stripped_during_normalization()
     {
         var crypto = new Crypto("s#$%^&plunk");
-        Assert.That(crypto.NormalizePlaintext, Is.EqualTo("splunk"));
+        Assert.Equal("splunk", crypto.NormalizePlaintext);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Letters_are_lowercased_during_normalization()
     {
         var crypto = new Crypto("WHOA HEY!");
-        Assert.That(crypto.NormalizePlaintext, Is.EqualTo("whoahey"));
+        Assert.Equal("whoahey", crypto.NormalizePlaintext);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Numbers_are_kept_during_normalization()
     {
         var crypto = new Crypto("1, 2, 3, GO!");
-        Assert.That(crypto.NormalizePlaintext, Is.EqualTo("123go"));
+        Assert.Equal("123go", crypto.NormalizePlaintext);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Smallest_square_size_is_2()
     {
         var crypto = new Crypto("1234");
-        Assert.That(crypto.Size, Is.EqualTo(2));
+        Assert.Equal(2, crypto.Size);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Size_of_text_whose_length_is_a_perfect_square_is_its_square_root()
     {
         var crypto = new Crypto("123456789");
-        Assert.That(crypto.Size, Is.EqualTo(3));
+        Assert.Equal(3, crypto.Size);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Size_of_text_whose_length_is_not_a_perfect_square_is_next_biggest_square_root()
     {
         var crypto = new Crypto("123456789abc");
-        Assert.That(crypto.Size, Is.EqualTo(4));
+        Assert.Equal(4, crypto.Size);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Size_is_determined_by_normalized_text()
     {
         var crypto = new Crypto("Oh hey, this is nuts!");
-        Assert.That(crypto.Size, Is.EqualTo(4));
+        Assert.Equal(4, crypto.Size);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Segments_are_split_by_square_size()
     {
         var crypto = new Crypto("Never vex thine heart with idle woes");
-        Assert.That(crypto.PlaintextSegments(), Is.EqualTo(new[] { "neverv", "exthin", "eheart", "withid", "lewoes" }));
+        Assert.Equal(new[] { "neverv", "exthin", "eheart", "withid", "lewoes" }, crypto.PlaintextSegments());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Segments_are_split_by_square_size_until_text_runs_out()
     {
         var crypto = new Crypto("ZOMG! ZOMBIES!!!");
-        Assert.That(crypto.PlaintextSegments(), Is.EqualTo(new[] { "zomg", "zomb", "ies" }));
+        Assert.Equal(new[] { "zomg", "zomb", "ies" }, crypto.PlaintextSegments());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Ciphertext_combines_text_by_column()
     {
         var crypto = new Crypto("First, solve the problem. Then, write the code.");
-        Assert.That(crypto.Ciphertext(), Is.EqualTo("foeewhilpmrervrticseohtottbeedshlnte"));
+        Assert.Equal("foeewhilpmrervrticseohtottbeedshlnte", crypto.Ciphertext());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Ciphertext_skips_cells_with_no_text()
     {
         var crypto = new Crypto("Time is an illusion. Lunchtime doubly so.");
-        Assert.That(crypto.Ciphertext(), Is.EqualTo("tasneyinicdsmiohooelntuillibsuuml"));
+        Assert.Equal("tasneyinicdsmiohooelntuillibsuuml", crypto.Ciphertext());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Normalized_ciphertext_is_split_by_height_of_square()
     {
         var crypto = new Crypto("Vampires are people too!");
-        Assert.That(crypto.NormalizeCiphertext(), Is.EqualTo("vrel aepe mset paoo irpo"));
+        Assert.Equal("vrel aepe mset paoo irpo", crypto.NormalizeCiphertext());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Normalized_ciphertext_not_exactly_divisible_by_5_spills_into_a_smaller_segment()
     {
         var crypto = new Crypto("Madness, and then illumination.");
-        Assert.That(crypto.NormalizeCiphertext(), Is.EqualTo("msemo aanin dnin ndla etlt shui"));
+        Assert.Equal("msemo aanin dnin ndla etlt shui", crypto.NormalizeCiphertext());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Normalized_ciphertext_is_split_into_segements_of_correct_size()
     {
         var crypto = new Crypto("If man was meant to stay on the ground god would have given us roots");
-        Assert.That(crypto.NormalizeCiphertext(), Is.EqualTo("imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn sseoau"));
+        Assert.Equal("imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn sseoau", crypto.NormalizeCiphertext());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Normalized_ciphertext_is_split_into_segements_of_correct_size_with_punctuation()
     {
         var crypto = new Crypto("Have a nice day. Feed the dog & chill out!");
-        Assert.That(crypto.NormalizeCiphertext(), Is.EqualTo("hifei acedl veeol eddgo aatcu nyhht"));
+        Assert.Equal("hifei acedl veeol eddgo aatcu nyhht", crypto.NormalizeCiphertext());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Normalized_ciphertext_is_split_into_segements_of_correct_size_when_just_less_than_full_square()
     {
         var crypto = new Crypto("I am");
-        Assert.That(crypto.NormalizeCiphertext(), Is.EqualTo("im a"));
+        Assert.Equal("im a", crypto.NormalizeCiphertext());
     }
 }

data/tracks/csharp/exercises/custom-set/CustomSet.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+public class CustomSet<T> : IEnumerable<T>, IEquatable<IEnumerable<T>>
+{
+    public CustomSet()
+    {
+    }
+
+    public CustomSet(T value)
+    {
+    }
+
+    public CustomSet(IEnumerable<T> values)
+    {
+    }
+
+    public CustomSet<T> Insert(T value)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public bool IsEmpty()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public bool Contains(T value)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public bool IsSubsetOf(CustomSet<T> right)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public bool IsDisjointFrom(CustomSet<T> right)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public CustomSet<T> Intersection(CustomSet<T> right)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public CustomSet<T> Difference(CustomSet<T> right)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public CustomSet<T> Union(CustomSet<T> right)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public IEnumerator<T> GetEnumerator()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+    
+    public override bool Equals(object obj)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public override int GetHashCode() 
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool Equals(IEnumerable<T> other)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public int GetHashCode(IEnumerable<T> obj)
+    {
+        throw new NotImplementedException();
+    }
+}

data/tracks/csharp/exercises/custom-set/CustomSet.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/custom-set/CustomSetTest.cs

@@ -1,348 +1,312 @@
-using NUnit.Framework;
+using Xunit;
 
 public class CustomSetTest
 {
-    [Test]
+    [Fact]
     public void Sets_with_no_elements_are_empty()
     {
         var actual = new CustomSet<int>();
-        Assert.That(actual.IsEmpty(), Is.True);
+        Assert.True(actual.IsEmpty());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Sets_with_elements_are_not_empty()
     {
         var actual = new CustomSet<int>(1);
-        Assert.That(actual.IsEmpty(), Is.False);
+        Assert.False(actual.IsEmpty());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Nothing_is_contained_in_an_empty_set()
     {
         var actual = new CustomSet<int>();
-        Assert.That(actual.Contains(1), Is.False);
+        Assert.False(actual.Contains(1));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Detect_if_the_element_is_in_the_set()
     {
         var actual = new CustomSet<int>(new[] { 1, 2, 3 });
-        Assert.That(actual.Contains(1), Is.True);
+        Assert.True(actual.Contains(1));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Detect_if_the_element_is_not_in_the_set()
     {
         var actual = new CustomSet<int>(new[] { 1, 2, 3 });
-        Assert.That(actual.Contains(4), Is.False);
+        Assert.False(actual.Contains(4));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Add_to_empty_set()
     {
         var actual = new CustomSet<int>().Insert(3);
 
         var expected = new CustomSet<int>(new[] { 3 });
-        Assert.That(actual, Is.EquivalentTo(expected));
+        Assert.True(expected.Equals(actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Add_to_non_empty_set()
     {
         var actual = new CustomSet<int>(new[] { 1, 2, 4 }).Insert(3);
 
         var expected = new CustomSet<int>(new[] { 1, 2, 3, 4 });
-        Assert.That(actual, Is.EquivalentTo(expected));
+        Assert.True(expected.Equals(actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Adding_an_existing_element_does_not_change_the_set()
     {
         var actual = new CustomSet<int>(new[] { 1, 2, 3 });
         actual.Insert(3);
 
         var expected = new CustomSet<int>(new[] { 1, 2, 3 });
-        Assert.That(actual, Is.EquivalentTo(expected));
+        Assert.True(expected.Equals(actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Empty_set_is_a_subset_of_another_empty_set()
     {
         var left = new CustomSet<int>();
         var right = new CustomSet<int>();
-        Assert.That(left.IsSubsetOf(right), Is.True);
+        Assert.True(left.IsSubsetOf(right));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Empty_set_is_a_subset_of_non_empty_set()
     {
         var left = new CustomSet<int>();
         var right = new CustomSet<int>(1);
-        Assert.That(left.IsSubsetOf(right), Is.True);
+        Assert.True(left.IsSubsetOf(right));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Non_empty_set_is_not_a_subset_of_empty_set()
     {
         var left = new CustomSet<int>(1);
         var right = new CustomSet<int>();
-        Assert.That(left.IsSubsetOf(right), Is.False);
+        Assert.False(left.IsSubsetOf(right));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Set_is_a_subset_of_set_with_exact_same_elements()
     {
         var left = new CustomSet<int>(new[] { 1, 2, 3 });
         var right = new CustomSet<int>(new[] { 1, 2, 3 });
-        Assert.That(left.IsSubsetOf(right), Is.True);
+        Assert.True(left.IsSubsetOf(right));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Set_is_a_subset_of_larger_set_with_same_elements()
     {
         var left = new CustomSet<int>(new[] { 1, 2, 3 });
         var right = new CustomSet<int>(new[] { 4, 1, 2, 3 });
-        Assert.That(left.IsSubsetOf(right), Is.True);
+        Assert.True(left.IsSubsetOf(right));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Set_is_not_a_subset_of_set_that_does_not_contain_its_elements()
     {
         var left = new CustomSet<int>(new[] { 1, 2, 3 });
         var right = new CustomSet<int>(new[] { 4, 1, 3 });
-        Assert.That(left.IsSubsetOf(right), Is.False);
+        Assert.False(left.IsSubsetOf(right));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void The_empty_set_is_disjoint_with_itself()
     {
         var left = new CustomSet<int>();
         var right = new CustomSet<int>();
-        Assert.That(left.IsDisjointFrom(right), Is.True);
+        Assert.True(left.IsDisjointFrom(right));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Empty_set_is_disjoint_with_non_empty_set()
     {
         var left = new CustomSet<int>();
         var right = new CustomSet<int>(1);
-        Assert.That(left.IsDisjointFrom(right), Is.True);
+        Assert.True(left.IsDisjointFrom(right));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Non_empty_set_is_disjoint_with_empty_set()
     {
         var left = new CustomSet<int>(1);
         var right = new CustomSet<int>();
-        Assert.That(left.IsDisjointFrom(right), Is.True);
+        Assert.True(left.IsDisjointFrom(right));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Sets_are_not_disjoint_if_they_share_an_element()
     {
         var left = new CustomSet<int>(new[] { 1, 2 });
         var right = new CustomSet<int>(new[] { 2, 3 });
-        Assert.That(left.IsDisjointFrom(right), Is.False);
+        Assert.False(left.IsDisjointFrom(right));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Sets_are_disjoint_if_they_share_no_elements()
     {
         var left = new CustomSet<int>(new[] { 1, 2 });
         var right = new CustomSet<int>(new[] { 3, 4 });
-        Assert.That(left.IsDisjointFrom(right), Is.True);
+        Assert.True(left.IsDisjointFrom(right));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Intersection_of_two_empty_sets_is_an_empty_set()
     {
         var left = new CustomSet<int>();
         var right = new CustomSet<int>();
         var expected = new CustomSet<int>();
-        Assert.That(left.Intersection(right), Is.EquivalentTo(expected));
+        Assert.True(left.Intersection(right).Equals(expected));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Intersection_of_an_empty_set_and_non_empty_set_is_an_empty_set()
     {
         var left = new CustomSet<int>();
         var right = new CustomSet<int>(new[] { 3, 2, 5 });
         var expected = new CustomSet<int>();
-        Assert.That(left.Intersection(right), Is.EquivalentTo(expected));
+        Assert.True(left.Intersection(right).Equals(expected));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Intersection_of_a_non_empty_set_and_an_empty_set_is_an_empty_set()
     {
         var left = new CustomSet<int>(new[] { 1, 2, 3, 4 });
         var right = new CustomSet<int>();
         var expected = new CustomSet<int>();
-        Assert.That(left.Intersection(right), Is.EquivalentTo(expected));
+        Assert.True(left.Intersection(right).Equals(expected));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Intersection_of_two_sets_with_no_shared_elements_is_an_empty_set()
     {
         var left = new CustomSet<int>(new[] { 1, 2, 3 });
         var right = new CustomSet<int>(new[] { 4, 5, 6 });
         var expected = new CustomSet<int>();
-        Assert.That(left.Intersection(right), Is.EquivalentTo(expected));
+        Assert.True(left.Intersection(right).Equals(expected));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Intersection_of_two_sets_with_shared_elements_is_a_set_of_the_shared_elements()
     {
         var left = new CustomSet<int>(new[] { 1, 2, 3, 4 });
         var right = new CustomSet<int>(new[] { 3, 2, 5 });
         var expected = new CustomSet<int>(new[] { 2, 3 });
-        Assert.That(left.Intersection(right), Is.EquivalentTo(expected));
+        Assert.True(left.Intersection(right).Equals(expected));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Difference_of_two_empty_sets_is_an_empty_set()
     {
         var left = new CustomSet<int>();
         var right = new CustomSet<int>();
         var expected = new CustomSet<int>();
-        Assert.That(left.Difference(right), Is.EquivalentTo(expected));
+        Assert.True(left.Difference(right).Equals(expected));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Difference_of_an_empty_set_and_non_empty_set_is_an_empty_set()
     {
         var left = new CustomSet<int>();
         var right = new CustomSet<int>(new[] { 3, 2, 5 });
         var expected = new CustomSet<int>();
-        Assert.That(left.Difference(right), Is.EquivalentTo(expected));
+        Assert.True(left.Difference(right).Equals(expected));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Difference_of_a_non_empty_set_and_an_empty_set_is_an_empty_set()
     {
         var left = new CustomSet<int>(new[] { 1, 2, 3, 4 });
         var right = new CustomSet<int>();
         var expected = new CustomSet<int>(new[] { 1, 2, 3, 4 });
-        Assert.That(left.Difference(right), Is.EquivalentTo(expected));
+        Assert.True(left.Difference(right).Equals(expected));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Difference_of_two_non_empty_sets_is_a_set_of_elements_that_are_only_in_the_first_set()
     {
         var left = new CustomSet<int>(new[] { 3, 2, 1 });
         var right = new CustomSet<int>(new[] { 2, 4 });
         var expected = new CustomSet<int>(new[] { 1, 3 });
-        Assert.That(left.Difference(right), Is.EquivalentTo(expected));
+        Assert.True(left.Difference(right).Equals(expected));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Union_of_two_empty_sets_is_an_empty_set()
     {
         var left = new CustomSet<int>();
         var right = new CustomSet<int>();
         var expected = new CustomSet<int>();
-        Assert.That(left.Union(right), Is.EquivalentTo(expected));
+        Assert.True(left.Union(right).Equals(expected));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Union_of_an_empty_set_and_non_empty_set_is_the_non_empty_set()
     {
         var left = new CustomSet<int>();
         var right = new CustomSet<int>(new[] { 2 });
         var expected = new CustomSet<int>(new[] { 2 });
-        Assert.That(left.Union(right), Is.EquivalentTo(expected));
+        Assert.True(left.Union(right).Equals(expected));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Union_of_a_non_empty_set_and_empty_set_is_the_non_empty_set()
     {
         var left = new CustomSet<int>(new[] { 1, 3 });
         var right = new CustomSet<int>();
         var expected = new CustomSet<int>(new[] { 1, 3 });
-        Assert.That(left.Union(right), Is.EquivalentTo(expected));
+        Assert.True(left.Union(right).Equals(expected));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Union_of_non_empty_sets_contains_all_unique_elements()
     {
         var left = new CustomSet<int>(new[] { 1, 3 });
         var right = new CustomSet<int>(new[] { 2, 3 });
         var expected = new CustomSet<int>(new[] { 3, 2, 1 });
-        Assert.That(left.Union(right), Is.EquivalentTo(expected));
+        Assert.True(left.Union(right).Equals(expected));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Empty_sets_are_equal()
     {
         var left = new CustomSet<int>();
         var right = new CustomSet<int>();
-        Assert.That(left, Is.EquivalentTo(right));
+        Assert.True(left.Equals(right));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Empty_set_is_not_equal_to_non_empty_set()
     {
         var left = new CustomSet<int>();
         var right = new CustomSet<int>(new[] { 1, 2, 3 });
-        Assert.That(left, Is.Not.EquivalentTo(right));
+        Assert.False(left.Equals(right));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Non_empty_set_is_not_equal_to_empty_set()
     {
         var left = new CustomSet<int>(new[] { 1, 2, 3 });
         var right = new CustomSet<int>();
-        Assert.That(left, Is.Not.EquivalentTo(right));
+        Assert.False(left.Equals(right));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Sets_with_the_same_elements_are_equal()
     {
         var left = new CustomSet<int>(new[] { 1, 2 });
         var right = new CustomSet<int>(new[] { 2, 1 });
-        Assert.That(left, Is.EquivalentTo(right));
+        Assert.True(left.Equals(right));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Sets_with_different_elements_are_not_equal()
     {
         var left = new CustomSet<int>(new[] { 1, 2, 3 });
         var right = new CustomSet<int>(new[] { 1, 2, 4 });
-        Assert.That(left, Is.Not.EquivalentTo(right));
+        Assert.False(left.Equals(right));
     }
 }