trackler 2.2.1.151 → 2.2.1.152

data/tracks/csharp/exercises/circular-buffer/Example.cs

@@ -4,13 +4,13 @@
 
 public class CircularBuffer<T>
 {
-    private readonly int size;
+    private readonly int capacity;
     private List<T> items;
 
-    public CircularBuffer(int size)
+    public CircularBuffer(int capacity)
     {
-        this.size = size;
-        items = new List<T>(size);
+        this.capacity = capacity;
+        items = new List<T>(capacity);
     }
 
     public T Read()
@@ -29,7 +29,7 @@ public T Read()
 
     public void Write(T value)
     {
-        if (items.Count == size)
+        if (items.Count == capacity)
         {
             throw new InvalidOperationException("Cannot write to full buffer");
         }
@@ -37,9 +37,9 @@ public void Write(T value)
         items.Add(value);
     }
 
-    public void ForceWrite(T value)
+    public void Overwrite(T value)
     {
-        if (items.Count == size)
+        if (items.Count == capacity)
         {
             DequeueHead();
         }

data/tracks/csharp/exercises/clock/ClockTest.cs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.1 of the canonical data.
+// This file was auto-generated based on version 2.2.1 of the canonical data.
 
 using Xunit;
 
@@ -197,56 +197,56 @@ public void Add_more_than_two_days()
     public void Subtract_minutes()
     {
         var sut = new Clock(10, 3);
-        Assert.Equal("10:00", sut.Add(-3).ToString());
+        Assert.Equal("10:00", sut.Subtract(3).ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Subtract_to_previous_hour()
     {
         var sut = new Clock(10, 3);
-        Assert.Equal("09:33", sut.Add(-30).ToString());
+        Assert.Equal("09:33", sut.Subtract(30).ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Subtract_more_than_an_hour()
     {
         var sut = new Clock(10, 3);
-        Assert.Equal("08:53", sut.Add(-70).ToString());
+        Assert.Equal("08:53", sut.Subtract(70).ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Subtract_across_midnight()
     {
         var sut = new Clock(0, 3);
-        Assert.Equal("23:59", sut.Add(-4).ToString());
+        Assert.Equal("23:59", sut.Subtract(4).ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Subtract_more_than_two_hours()
     {
         var sut = new Clock(0, 0);
-        Assert.Equal("21:20", sut.Add(-160).ToString());
+        Assert.Equal("21:20", sut.Subtract(160).ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Subtract_more_than_two_hours_with_borrow()
     {
         var sut = new Clock(6, 15);
-        Assert.Equal("03:35", sut.Add(-160).ToString());
+        Assert.Equal("03:35", sut.Subtract(160).ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Subtract_more_than_one_day_1500_min_25_hrs_()
     {
         var sut = new Clock(5, 32);
-        Assert.Equal("04:32", sut.Add(-1500).ToString());
+        Assert.Equal("04:32", sut.Subtract(1500).ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Subtract_more_than_two_days()
     {
         var sut = new Clock(2, 20);
-        Assert.Equal("00:20", sut.Add(-3000).ToString());
+        Assert.Equal("00:20", sut.Subtract(3000).ToString());
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -259,98 +259,98 @@ public void Clocks_with_same_time()
     [Fact(Skip = "Remove to run test")]
     public void Clocks_a_minute_apart()
     {
-        var sut = new Clock(15, 36);
-        Assert.NotEqual(new Clock(15, 37), sut);
+        var sut = new Clock(15, 37);
+        Assert.NotEqual(new Clock(15, 36), sut);
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Clocks_an_hour_apart()
     {
-        var sut = new Clock(14, 37);
-        Assert.NotEqual(new Clock(15, 37), sut);
+        var sut = new Clock(15, 37);
+        Assert.NotEqual(new Clock(14, 37), sut);
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Clocks_with_hour_overflow()
     {
-        var sut = new Clock(10, 37);
-        Assert.Equal(new Clock(34, 37), sut); 
+        var sut = new Clock(34, 37);
+        Assert.Equal(new Clock(10, 37), sut); 
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Clocks_with_hour_overflow_by_several_days()
     {
-        var sut = new Clock(3, 11);
-        Assert.Equal(new Clock(99, 11), sut); 
+        var sut = new Clock(99, 11);
+        Assert.Equal(new Clock(3, 11), sut); 
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Clocks_with_negative_hour()
     {
-        var sut = new Clock(22, 40);
-        Assert.Equal(new Clock(-2, 40), sut); 
+        var sut = new Clock(-2, 40);
+        Assert.Equal(new Clock(22, 40), sut); 
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Clocks_with_negative_hour_that_wraps()
     {
-        var sut = new Clock(17, 3);
-        Assert.Equal(new Clock(-31, 3), sut); 
+        var sut = new Clock(-31, 3);
+        Assert.Equal(new Clock(17, 3), sut); 
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Clocks_with_negative_hour_that_wraps_multiple_times()
     {
-        var sut = new Clock(13, 49);
-        Assert.Equal(new Clock(-83, 49), sut); 
+        var sut = new Clock(-83, 49);
+        Assert.Equal(new Clock(13, 49), sut); 
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Clocks_with_minute_overflow()
     {
-        var sut = new Clock(0, 1);
-        Assert.Equal(new Clock(0, 1441), sut); 
+        var sut = new Clock(0, 1441);
+        Assert.Equal(new Clock(0, 1), sut); 
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Clocks_with_minute_overflow_by_several_days()
     {
-        var sut = new Clock(2, 2);
-        Assert.Equal(new Clock(2, 4322), sut); 
+        var sut = new Clock(2, 4322);
+        Assert.Equal(new Clock(2, 2), sut); 
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Clocks_with_negative_minute()
     {
-        var sut = new Clock(2, 40);
-        Assert.Equal(new Clock(3, -20), sut); 
+        var sut = new Clock(3, -20);
+        Assert.Equal(new Clock(2, 40), sut); 
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Clocks_with_negative_minute_that_wraps()
     {
-        var sut = new Clock(4, 10);
-        Assert.Equal(new Clock(5, -1490), sut); 
+        var sut = new Clock(5, -1490);
+        Assert.Equal(new Clock(4, 10), sut); 
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Clocks_with_negative_minute_that_wraps_multiple_times()
     {
-        var sut = new Clock(6, 15);
-        Assert.Equal(new Clock(6, -4305), sut); 
+        var sut = new Clock(6, -4305);
+        Assert.Equal(new Clock(6, 15), sut); 
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Clocks_with_negative_hours_and_minutes()
     {
-        var sut = new Clock(7, 32);
-        Assert.Equal(new Clock(-12, -268), sut); 
+        var sut = new Clock(-12, -268);
+        Assert.Equal(new Clock(7, 32), sut); 
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Clocks_with_negative_hours_and_minutes_that_wrap()
     {
-        var sut = new Clock(18, 7);
-        Assert.Equal(new Clock(-54, -11513), sut); 
+        var sut = new Clock(-54, -11513);
+        Assert.Equal(new Clock(18, 7), sut); 
     }
 }

data/tracks/csharp/exercises/collatz-conjecture/CollatzConjectureTest.cs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.1.1 of the canonical data.
+// This file was auto-generated based on version 1.2.0 of the canonical data.
 
 using Xunit;
 using System;

data/tracks/csharp/exercises/complex-numbers/ComplexNumbersTest.cs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.0 of the canonical data.
+// This file was auto-generated based on version 1.3.0 of the canonical data.
 
 using Xunit;
 using System;
@@ -6,6 +6,15 @@
 public class ComplexNumbersTest
 {
     [Fact]
+    public void Imaginary_unit()
+    {
+        var sut = new ComplexNumber(0, 1);
+        var expected = new ComplexNumber(-1, 0);
+        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(0, 1)).Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(0, 1)).Imaginary(), precision: 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
     public void Real_part_of_a_purely_real_number()
     {
         var sut = new ComplexNumber(1, 0);
@@ -47,15 +56,6 @@ public void Imaginary_part_of_a_number_with_real_and_imaginary_part()
         Assert.Equal(2, sut.Imaginary());
     }
 
-    [Fact(Skip = "Remove to run test")]
-    public void Imaginary_unit()
-    {
-        var sut = new ComplexNumber(0, 1);
-        var expected = new ComplexNumber(-1, 0);
-        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(0, 1)).Real(), precision: 15);
-        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(0, 1)).Imaginary(), precision: 15);
-    }
-
     [Fact(Skip = "Remove to run test")]
     public void Add_purely_real_numbers()
     {
@@ -252,4 +252,13 @@ public void Exponential_of_a_purely_real_number()
         Assert.Equal(expected.Real(), sut.Exp().Real(), precision: 15);
         Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), precision: 15);
     }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Exponential_of_a_number_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(Math.Log(2.0), Math.PI);
+        var expected = new ComplexNumber(-2, 0);
+        Assert.Equal(expected.Real(), sut.Exp().Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), precision: 15);
+    }
 }

data/tracks/csharp/exercises/connect/ConnectTest.cs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.0 of the canonical data.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 using Xunit;
 

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

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 3.1.0 of the canonical data.
+// This file was auto-generated based on version 3.2.0 of the canonical data.
 
 using Xunit;
 

data/tracks/csharp/exercises/custom-set/.meta/hints.md

@@ -1,4 +1,4 @@
 ## Hints
-This exercise requires you to implements a type-specific method for determining equality of instances.
-For more information, see [this page]
-(https://docs.microsoft.com/en-us/dotnet/core/api/System.IEquatable-1) .
+
+This exercise requires you to create custom equality comparison logic.
+For more information, see [this page](https://docs.microsoft.com/en-us/dotnet/api/system.object.equals?view=netcore-2.0#System_Object_Equals_System_Object_).

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

@@ -1,88 +1,49 @@
 using System;
-using System.Collections;
-using System.Collections.Generic;
 
-public class CustomSet<T> : IEnumerable<T>, IEquatable<IEnumerable<T>>
+public class CustomSet
 {
-    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()
+    public CustomSet(params int[] values)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public bool Contains(T value)
+    public CustomSet Insert(int value)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public bool IsSubsetOf(CustomSet<T> right)
+    public bool Empty()
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public bool IsDisjointFrom(CustomSet<T> right)
+    public bool Contains(int value)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public CustomSet<T> Intersection(CustomSet<T> right)
+    public bool Subset(CustomSet right)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public CustomSet<T> Difference(CustomSet<T> right)
+    public bool Disjoint(CustomSet right)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public CustomSet<T> Union(CustomSet<T> right)
+    public CustomSet Intersection(CustomSet right)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public IEnumerator<T> GetEnumerator()
+    public CustomSet Difference(CustomSet right)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    IEnumerator IEnumerable.GetEnumerator()
+    public CustomSet Union(CustomSet right)
     {
         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/CustomSetTest.cs

@@ -1,312 +1,308 @@
-using Xunit;
+// This file was auto-generated based on version 1.3.0 of the canonical data.
+
+using Xunit;
 
 public class CustomSetTest
 {
     [Fact]
     public void Sets_with_no_elements_are_empty()
     {
-        var actual = new CustomSet<int>();
-        Assert.True(actual.IsEmpty());
+        var sut = new CustomSet();
+        Assert.True(sut.Empty());
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Sets_with_elements_are_not_empty()
     {
-        var actual = new CustomSet<int>(1);
-        Assert.False(actual.IsEmpty());
+        var sut = new CustomSet(new[] { 1 });
+        Assert.False(sut.Empty());
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Nothing_is_contained_in_an_empty_set()
     {
-        var actual = new CustomSet<int>();
-        Assert.False(actual.Contains(1));
+        var element = 1;
+        var sut = new CustomSet();
+        Assert.False(sut.Contains(element));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Detect_if_the_element_is_in_the_set()
+    public void When_the_element_is_in_the_set()
     {
-        var actual = new CustomSet<int>(new[] { 1, 2, 3 });
-        Assert.True(actual.Contains(1));
+        var element = 1;
+        var sut = new CustomSet(new[] { 1, 2, 3 });
+        Assert.True(sut.Contains(element));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Detect_if_the_element_is_not_in_the_set()
+    public void When_the_element_is_not_in_the_set()
     {
-        var actual = new CustomSet<int>(new[] { 1, 2, 3 });
-        Assert.False(actual.Contains(4));
+        var element = 4;
+        var sut = new CustomSet(new[] { 1, 2, 3 });
+        Assert.False(sut.Contains(element));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Add_to_empty_set()
+    public void Empty_set_is_a_subset_of_another_empty_set()
     {
-        var actual = new CustomSet<int>().Insert(3);
-
-        var expected = new CustomSet<int>(new[] { 3 });
-        Assert.True(expected.Equals(actual));
+        var set2 = new CustomSet();
+        var sut = new CustomSet();
+        Assert.True(sut.Subset(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Add_to_non_empty_set()
+    public void Empty_set_is_a_subset_of_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.True(expected.Equals(actual));
+        var set2 = new CustomSet(new[] { 1 });
+        var sut = new CustomSet();
+        Assert.True(sut.Subset(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Adding_an_existing_element_does_not_change_the_set()
+    public void Non_empty_set_is_not_a_subset_of_empty_set()
     {
-        var actual = new CustomSet<int>(new[] { 1, 2, 3 });
-        actual.Insert(3);
+        var set2 = new CustomSet();
+        var sut = new CustomSet(new[] { 1 });
+        Assert.False(sut.Subset(set2));
+    }
 
-        var expected = new CustomSet<int>(new[] { 1, 2, 3 });
-        Assert.True(expected.Equals(actual));
+    [Fact(Skip = "Remove to run test")]
+    public void Set_is_a_subset_of_set_with_exact_same_elements()
+    {
+        var set2 = new CustomSet(new[] { 1, 2, 3 });
+        var sut = new CustomSet(new[] { 1, 2, 3 });
+        Assert.True(sut.Subset(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Empty_set_is_a_subset_of_another_empty_set()
+    public void Set_is_a_subset_of_larger_set_with_same_elements()
     {
-        var left = new CustomSet<int>();
-        var right = new CustomSet<int>();
-        Assert.True(left.IsSubsetOf(right));
+        var set2 = new CustomSet(new[] { 4, 1, 2, 3 });
+        var sut = new CustomSet(new[] { 1, 2, 3 });
+        Assert.True(sut.Subset(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Empty_set_is_a_subset_of_non_empty_set()
+    public void Set_is_not_a_subset_of_set_that_does_not_contain_its_elements()
     {
-        var left = new CustomSet<int>();
-        var right = new CustomSet<int>(1);
-        Assert.True(left.IsSubsetOf(right));
+        var set2 = new CustomSet(new[] { 4, 1, 3 });
+        var sut = new CustomSet(new[] { 1, 2, 3 });
+        Assert.False(sut.Subset(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Non_empty_set_is_not_a_subset_of_empty_set()
+    public void The_empty_set_is_disjoint_with_itself()
     {
-        var left = new CustomSet<int>(1);
-        var right = new CustomSet<int>();
-        Assert.False(left.IsSubsetOf(right));
+        var set2 = new CustomSet();
+        var sut = new CustomSet();
+        Assert.True(sut.Disjoint(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Set_is_a_subset_of_set_with_exact_same_elements()
+    public void Empty_set_is_disjoint_with_non_empty_set()
     {
-        var left = new CustomSet<int>(new[] { 1, 2, 3 });
-        var right = new CustomSet<int>(new[] { 1, 2, 3 });
-        Assert.True(left.IsSubsetOf(right));
+        var set2 = new CustomSet(new[] { 1 });
+        var sut = new CustomSet();
+        Assert.True(sut.Disjoint(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Set_is_a_subset_of_larger_set_with_same_elements()
+    public void Non_empty_set_is_disjoint_with_empty_set()
     {
-        var left = new CustomSet<int>(new[] { 1, 2, 3 });
-        var right = new CustomSet<int>(new[] { 4, 1, 2, 3 });
-        Assert.True(left.IsSubsetOf(right));
+        var set2 = new CustomSet();
+        var sut = new CustomSet(new[] { 1 });
+        Assert.True(sut.Disjoint(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Set_is_not_a_subset_of_set_that_does_not_contain_its_elements()
+    public void Sets_are_not_disjoint_if_they_share_an_element()
     {
-        var left = new CustomSet<int>(new[] { 1, 2, 3 });
-        var right = new CustomSet<int>(new[] { 4, 1, 3 });
-        Assert.False(left.IsSubsetOf(right));
+        var set2 = new CustomSet(new[] { 2, 3 });
+        var sut = new CustomSet(new[] { 1, 2 });
+        Assert.False(sut.Disjoint(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void The_empty_set_is_disjoint_with_itself()
+    public void Sets_are_disjoint_if_they_share_no_elements()
     {
-        var left = new CustomSet<int>();
-        var right = new CustomSet<int>();
-        Assert.True(left.IsDisjointFrom(right));
+        var set2 = new CustomSet(new[] { 3, 4 });
+        var sut = new CustomSet(new[] { 1, 2 });
+        Assert.True(sut.Disjoint(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Empty_set_is_disjoint_with_non_empty_set()
+    public void Empty_sets_are_equal()
     {
-        var left = new CustomSet<int>();
-        var right = new CustomSet<int>(1);
-        Assert.True(left.IsDisjointFrom(right));
+        var set2 = new CustomSet();
+        var sut = new CustomSet();
+        Assert.True(sut.Equals(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Non_empty_set_is_disjoint_with_empty_set()
+    public void Empty_set_is_not_equal_to_non_empty_set()
     {
-        var left = new CustomSet<int>(1);
-        var right = new CustomSet<int>();
-        Assert.True(left.IsDisjointFrom(right));
+        var set2 = new CustomSet(new[] { 1, 2, 3 });
+        var sut = new CustomSet();
+        Assert.False(sut.Equals(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Sets_are_not_disjoint_if_they_share_an_element()
+    public void Non_empty_set_is_not_equal_to_empty_set()
     {
-        var left = new CustomSet<int>(new[] { 1, 2 });
-        var right = new CustomSet<int>(new[] { 2, 3 });
-        Assert.False(left.IsDisjointFrom(right));
+        var set2 = new CustomSet();
+        var sut = new CustomSet(new[] { 1, 2, 3 });
+        Assert.False(sut.Equals(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Sets_are_disjoint_if_they_share_no_elements()
+    public void Sets_with_the_same_elements_are_equal()
     {
-        var left = new CustomSet<int>(new[] { 1, 2 });
-        var right = new CustomSet<int>(new[] { 3, 4 });
-        Assert.True(left.IsDisjointFrom(right));
+        var set2 = new CustomSet(new[] { 2, 1 });
+        var sut = new CustomSet(new[] { 1, 2 });
+        Assert.True(sut.Equals(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Intersection_of_two_empty_sets_is_an_empty_set()
+    public void Sets_with_different_elements_are_not_equal()
     {
-        var left = new CustomSet<int>();
-        var right = new CustomSet<int>();
-        var expected = new CustomSet<int>();
-        Assert.True(left.Intersection(right).Equals(expected));
+        var set2 = new CustomSet(new[] { 1, 2, 4 });
+        var sut = new CustomSet(new[] { 1, 2, 3 });
+        Assert.False(sut.Equals(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Intersection_of_an_empty_set_and_non_empty_set_is_an_empty_set()
+    public void Set_is_not_equal_to_larger_set_with_same_elements()
     {
-        var left = new CustomSet<int>();
-        var right = new CustomSet<int>(new[] { 3, 2, 5 });
-        var expected = new CustomSet<int>();
-        Assert.True(left.Intersection(right).Equals(expected));
+        var set2 = new CustomSet(new[] { 1, 2, 3, 4 });
+        var sut = new CustomSet(new[] { 1, 2, 3 });
+        Assert.False(sut.Equals(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Intersection_of_a_non_empty_set_and_an_empty_set_is_an_empty_set()
+    public void Add_to_empty_set()
     {
-        var left = new CustomSet<int>(new[] { 1, 2, 3, 4 });
-        var right = new CustomSet<int>();
-        var expected = new CustomSet<int>();
-        Assert.True(left.Intersection(right).Equals(expected));
+        var element = 3;
+        var sut = new CustomSet();
+        Assert.Equal(new CustomSet(new[] { 3 }), sut.Add(element));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Intersection_of_two_sets_with_no_shared_elements_is_an_empty_set()
+    public void Add_to_non_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.True(left.Intersection(right).Equals(expected));
+        var element = 3;
+        var sut = new CustomSet(new[] { 1, 2, 4 });
+        Assert.Equal(new CustomSet(new[] { 1, 2, 3, 4 }), sut.Add(element));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Intersection_of_two_sets_with_shared_elements_is_a_set_of_the_shared_elements()
+    public void Adding_an_existing_element_does_not_change_the_set()
     {
-        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.True(left.Intersection(right).Equals(expected));
+        var element = 3;
+        var sut = new CustomSet(new[] { 1, 2, 3 });
+        Assert.Equal(new CustomSet(new[] { 1, 2, 3 }), sut.Add(element));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Difference_of_two_empty_sets_is_an_empty_set()
+    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.True(left.Difference(right).Equals(expected));
+        var set2 = new CustomSet();
+        var sut = new CustomSet();
+        Assert.Equal(new CustomSet(), sut.Intersection(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Difference_of_an_empty_set_and_non_empty_set_is_an_empty_set()
+    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.True(left.Difference(right).Equals(expected));
+        var set2 = new CustomSet(new[] { 3, 2, 5 });
+        var sut = new CustomSet();
+        Assert.Equal(new CustomSet(), sut.Intersection(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Difference_of_a_non_empty_set_and_an_empty_set_is_an_empty_set()
+    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>(new[] { 1, 2, 3, 4 });
-        Assert.True(left.Difference(right).Equals(expected));
+        var set2 = new CustomSet();
+        var sut = new CustomSet(new[] { 1, 2, 3, 4 });
+        Assert.Equal(new CustomSet(), sut.Intersection(set2));
     }
 
     [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()
+    public void Intersection_of_two_sets_with_no_shared_elements_is_an_empty_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.True(left.Difference(right).Equals(expected));
+        var set2 = new CustomSet(new[] { 4, 5, 6 });
+        var sut = new CustomSet(new[] { 1, 2, 3 });
+        Assert.Equal(new CustomSet(), sut.Intersection(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Union_of_two_empty_sets_is_an_empty_set()
+    public void Intersection_of_two_sets_with_shared_elements_is_a_set_of_the_shared_elements()
     {
-        var left = new CustomSet<int>();
-        var right = new CustomSet<int>();
-        var expected = new CustomSet<int>();
-        Assert.True(left.Union(right).Equals(expected));
+        var set2 = new CustomSet(new[] { 3, 2, 5 });
+        var sut = new CustomSet(new[] { 1, 2, 3, 4 });
+        Assert.Equal(new CustomSet(new[] { 2, 3 }), sut.Intersection(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Union_of_an_empty_set_and_non_empty_set_is_the_non_empty_set()
+    public void Difference_of_two_empty_sets_is_an_empty_set()
     {
-        var left = new CustomSet<int>();
-        var right = new CustomSet<int>(new[] { 2 });
-        var expected = new CustomSet<int>(new[] { 2 });
-        Assert.True(left.Union(right).Equals(expected));
+        var set2 = new CustomSet();
+        var sut = new CustomSet();
+        Assert.Equal(new CustomSet(), sut.Difference(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Union_of_a_non_empty_set_and_empty_set_is_the_non_empty_set()
+    public void Difference_of_empty_set_and_non_empty_set_is_an_empty_set()
     {
-        var left = new CustomSet<int>(new[] { 1, 3 });
-        var right = new CustomSet<int>();
-        var expected = new CustomSet<int>(new[] { 1, 3 });
-        Assert.True(left.Union(right).Equals(expected));
+        var set2 = new CustomSet(new[] { 3, 2, 5 });
+        var sut = new CustomSet();
+        Assert.Equal(new CustomSet(), sut.Difference(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Union_of_non_empty_sets_contains_all_unique_elements()
+    public void Difference_of_a_non_empty_set_and_an_empty_set_is_the_non_empty_set()
     {
-        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.True(left.Union(right).Equals(expected));
+        var set2 = new CustomSet();
+        var sut = new CustomSet(new[] { 1, 2, 3, 4 });
+        Assert.Equal(new CustomSet(new[] { 1, 2, 3, 4 }), sut.Difference(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Empty_sets_are_equal()
+    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>();
-        var right = new CustomSet<int>();
-        Assert.True(left.Equals(right));
+        var set2 = new CustomSet(new[] { 2, 4 });
+        var sut = new CustomSet(new[] { 3, 2, 1 });
+        Assert.Equal(new CustomSet(new[] { 1, 3 }), sut.Difference(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Empty_set_is_not_equal_to_non_empty_set()
+    public void Union_of_empty_sets_is_an_empty_set()
     {
-        var left = new CustomSet<int>();
-        var right = new CustomSet<int>(new[] { 1, 2, 3 });
-        Assert.False(left.Equals(right));
+        var set2 = new CustomSet();
+        var sut = new CustomSet();
+        Assert.Equal(new CustomSet(), sut.Union(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Non_empty_set_is_not_equal_to_empty_set()
+    public void Union_of_an_empty_set_and_non_empty_set_is_the_non_empty_set()
     {
-        var left = new CustomSet<int>(new[] { 1, 2, 3 });
-        var right = new CustomSet<int>();
-        Assert.False(left.Equals(right));
+        var set2 = new CustomSet(new[] { 2 });
+        var sut = new CustomSet();
+        Assert.Equal(new CustomSet(new[] { 2 }), sut.Union(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Sets_with_the_same_elements_are_equal()
+    public void Union_of_a_non_empty_set_and_empty_set_is_the_non_empty_set()
     {
-        var left = new CustomSet<int>(new[] { 1, 2 });
-        var right = new CustomSet<int>(new[] { 2, 1 });
-        Assert.True(left.Equals(right));
+        var set2 = new CustomSet();
+        var sut = new CustomSet(new[] { 1, 3 });
+        Assert.Equal(new CustomSet(new[] { 1, 3 }), sut.Union(set2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Sets_with_different_elements_are_not_equal()
+    public void Union_of_non_empty_sets_contains_all_unique_elements()
     {
-        var left = new CustomSet<int>(new[] { 1, 2, 3 });
-        var right = new CustomSet<int>(new[] { 1, 2, 4 });
-        Assert.False(left.Equals(right));
+        var set2 = new CustomSet(new[] { 2, 3 });
+        var sut = new CustomSet(new[] { 1, 3 });
+        Assert.Equal(new CustomSet(new[] { 3, 2, 1 }), sut.Union(set2));
     }
 }