trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/sieve/Sieve.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class Sieve
+{
+    public static int[] Primes(int limit)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/sieve/Sieve.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/sieve/SieveTest.cs

@@ -1,27 +1,23 @@
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class SieveTest
 {
-    [Test]
+    [Fact]
     public void Finds_first_prime()
     {
-        Assert.That(Sieve.Primes(2), Is.EqualTo(new[] { 2 }));
+        Assert.Equal(new[] { 2 }, Sieve.Primes(2));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Finds_primes_up_to_10()
     {
-        Assert.That(Sieve.Primes(10), Is.EqualTo(new[] { 2, 3, 5, 7 }));
+        Assert.Equal(new[] { 2, 3, 5, 7 }, Sieve.Primes(10));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Finds_primes_up_to_1000()
     {
-        Assert.That(Sieve.Primes(1000),
-            Is.EqualTo(new[]
+        Assert.Equal(new[]
                 {
                     2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101,
                     103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199,
@@ -32,6 +28,6 @@ public class SieveTest
                     709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839,
                     853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983,
                     991, 997
-                }));
+                }, Sieve.Primes(1000));
     }
 }

data/tracks/csharp/exercises/simple-cipher/SimpleCipher.cs

@@ -0,0 +1,32 @@
+using System;
+
+public class Cipher
+{
+    public Cipher()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public Cipher(string key)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+    
+    public string Key 
+    {
+        get
+        {
+            throw new NotImplementedException("You need to implement this function.");
+        }
+    }
+
+    public string Encode(string plaintext)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public string Decode(string ciphertext)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/simple-cipher/SimpleCipher.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/simple-cipher/SimpleCipherTest.cs

@@ -1,169 +1,138 @@
-using NUnit.Framework;
+using System;
+using Xunit;
 
-[TestFixture]
 public class RandomKeyCipherTest
 {
-    private Cipher cipher;
+    private readonly Cipher cipher = new Cipher();
 
-    [SetUp]
-    public void Setup()
-    {
-        cipher = new Cipher();
-    }
-
-    [Test]
+    [Fact]
     public void Cipher_key_is_made_of_letters()
     {
-        Assert.That(cipher.Key, Does.Match("[a-z]+"));
+        Assert.Matches("[a-z]+", cipher.Key);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Default_cipher_key_is_100_characters()
     {
-        Assert.That(cipher.Key, Has.Length.EqualTo(100));
+        Assert.Equal(100, cipher.Key.Length);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_keys_are_randomly_generated()
     {
-        Assert.That(cipher.Key, Is.Not.EqualTo(new Cipher().Key));
+        Assert.NotEqual(new Cipher().Key, cipher.Key);
     }
 
     // Here we take advantage of the fact that plaintext of "aaa..." doesn't output
     // the key. This is a critical problem with shift ciphers, some characters
     // will always output the key verbatim.
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_can_encode()
     {
-        Assert.That(cipher.Encode("aaaaaaaaaa"), Is.EqualTo(cipher.Key.Substring(0, 10)));
+        Assert.Equal(cipher.Key.Substring(0, 10), cipher.Encode("aaaaaaaaaa"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_can_decode()
     {
-        Assert.That(cipher.Decode(cipher.Key.Substring(0, 10)), Is.EqualTo("aaaaaaaaaa"));
+        Assert.Equal("aaaaaaaaaa", cipher.Decode(cipher.Key.Substring(0, 10)));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_is_reversible()
     {
         const string PLAINTEXT = "abcdefghij";
-        Assert.That(cipher.Decode(cipher.Encode(PLAINTEXT)), Is.EqualTo(PLAINTEXT));
+        Assert.Equal(PLAINTEXT, cipher.Decode(cipher.Encode(PLAINTEXT)));
     }
 }
 
-[TestFixture]
+
 public class IncorrectKeyCipherTest
 {
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact]
     public void Cipher_throws_with_an_all_caps_key()
     {
-        Assert.That(() => new Cipher("ABCDEF"), Throws.ArgumentException);
+        Assert.Throws<ArgumentException>(() => new Cipher("ABCDEF"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_throws_with_any_caps_key()
     {
-        Assert.That(() => new Cipher("abcdEFg"), Throws.ArgumentException);
+        Assert.Throws<ArgumentException>(() => new Cipher("abcdEFg"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_throws_with_numeric_key()
     {
-        Assert.That(() => new Cipher("12345"), Throws.ArgumentException);
+        Assert.Throws<ArgumentException>(() => new Cipher("12345"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_throws_with_any_numeric_key()
     {
-        Assert.That(() => new Cipher("abcd345ef"), Throws.ArgumentException);
+        Assert.Throws<ArgumentException>(() => new Cipher("abcd345ef"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_throws_with_empty_key()
     {
-        Assert.That(() => new Cipher(""), Throws.ArgumentException);
+        Assert.Throws<ArgumentException>(() => new Cipher(""));
     }
 }
 
-[TestFixture]
+
 public class SubstitutionCipherTest
 {
     private const string KEY = "abcdefghij";
-    private Cipher cipher;
-
-    [Ignore("Remove to run test")]
-    [SetUp]
-    public void Setup()
-    {
-        cipher = new Cipher(KEY);
-    }
+    private readonly Cipher cipher = new Cipher(KEY);
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_keeps_the_submitted_key()
     {
-        Assert.That(cipher.Key, Is.EqualTo(KEY));
+        Assert.Equal(KEY, cipher.Key);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_can_encode_with_given_key()
     {
-        Assert.That(cipher.Encode("aaaaaaaaaa"), Is.EqualTo("abcdefghij"));
+        Assert.Equal("abcdefghij", cipher.Encode("aaaaaaaaaa"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_can_decode_with_given_key()
     {
-        Assert.That(cipher.Decode("abcdefghij"), Is.EqualTo("aaaaaaaaaa"));
+        Assert.Equal("aaaaaaaaaa", cipher.Decode("abcdefghij"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_is_reversible_given_key()
     {
         const string PLAINTEXT = "abcdefghij";
-        Assert.That(cipher.Decode(cipher.Encode(PLAINTEXT)), Is.EqualTo(PLAINTEXT));
+        Assert.Equal(PLAINTEXT, cipher.Decode(cipher.Encode(PLAINTEXT)));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_can_double_shift_encode()
     {
         const string PLAINTEXT = "iamapandabear";
-        Assert.That(new Cipher(PLAINTEXT).Encode(PLAINTEXT), Is.EqualTo("qayaeaagaciai"));
+        Assert.Equal("qayaeaagaciai", new Cipher(PLAINTEXT).Encode(PLAINTEXT));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_can_wrap_encode()
     {
-        Assert.That(cipher.Encode("zzzzzzzzzz"), Is.EqualTo("zabcdefghi"));
+        Assert.Equal("zabcdefghi", cipher.Encode("zzzzzzzzzz"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_can_encode_a_message_that_is_shorter_than_the_key()
     {
-        Assert.That(cipher.Encode("aaaaa"), Is.EqualTo("abcde"));
+        Assert.Equal("abcde", cipher.Encode("aaaaa"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cipher_can_decode_a_message_that_is_shorter_than_the_key()
     {
-        Assert.That(cipher.Decode("abcde"), Is.EqualTo("aaaaa"));
+        Assert.Equal("aaaaa", cipher.Decode("abcde"));
     }
 }

data/tracks/csharp/exercises/simple-linked-list/SimpleLinkedList.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+public class SimpleLinkedList<T> : IEnumerable<T>
+{
+    public SimpleLinkedList(T value)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public SimpleLinkedList(IEnumerable<T> values)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public T Value 
+    { 
+        get
+        {
+            throw new NotImplementedException("You need to implement this function.");
+        } 
+    }
+
+    public SimpleLinkedList<T> Next
+    { 
+        get
+        {
+            throw new NotImplementedException("You need to implement this function.");
+        } 
+    }
+
+    public SimpleLinkedList<T> Add(T value)
+    {
+        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.");
+    }
+}

data/tracks/csharp/exercises/simple-linked-list/SimpleLinkedList.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/simple-linked-list/SimpleLinkedListTest.cs

@@ -1,87 +1,83 @@
 using System.Linq;
-using NUnit.Framework;
+using Xunit;
 
 public class SimpleLinkedListTest
 {
-    [Test]
+    [Fact]
     public void Single_item_list_value()
     {
         var list = new SimpleLinkedList<int>(1);
-        Assert.That(list.Value, Is.EqualTo(1));
+        Assert.Equal(1, list.Value);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Single_item_list_has_no_next_item()
     {
         var list = new SimpleLinkedList<int>(1);
-        Assert.That(list.Next, Is.Null);
+        Assert.Null(list.Next);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Two_item_list_first_value()
     {
         var list = new SimpleLinkedList<int>(2).Add(1);
-        Assert.That(list.Value, Is.EqualTo(2));
+        Assert.Equal(2, list.Value);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Two_item_list_second_value()
     {
         var list = new SimpleLinkedList<int>(2).Add(1);
-        Assert.That(list.Next.Value, Is.EqualTo(1));
+        Assert.Equal(1, list.Next.Value);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Two_item_list_second_item_has_no_next()
     {
         var list = new SimpleLinkedList<int>(2).Add(1);
-        Assert.That(list.Next.Next, Is.Null);
+        Assert.Null(list.Next.Next);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Implements_enumerable()
     {
         var values = new SimpleLinkedList<int>(2).Add(1);
-        Assert.That(values, Is.EqualTo(new[] { 2, 1 }));
+        Assert.Equal(new[] { 2, 1 }, values);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void From_enumerable()
     {
         var list = new SimpleLinkedList<int>(new[] { 11, 7, 5, 3, 2 });
-        Assert.That(list.Value, Is.EqualTo(11));
-        Assert.That(list.Next.Value, Is.EqualTo(7));
-        Assert.That(list.Next.Next.Value, Is.EqualTo(5));
-        Assert.That(list.Next.Next.Next.Value, Is.EqualTo(3));
-        Assert.That(list.Next.Next.Next.Next.Value, Is.EqualTo(2));
+        Assert.Equal(11, list.Value);
+        Assert.Equal(7, list.Next.Value);
+        Assert.Equal(5, list.Next.Next.Value);
+        Assert.Equal(3, list.Next.Next.Next.Value);
+        Assert.Equal(2, list.Next.Next.Next.Next.Value);
     }
 
-    [TestCase(1, Ignore = "Remove to run test case")]
-    [TestCase(2, Ignore = "Remove to run test case")]
-    [TestCase(10, Ignore = "Remove to run test case")]
-    [TestCase(100, Ignore = "Remove to run test case")]
+    [Theory(Skip = "Remove to run test")]
+    [InlineData(1)]
+    [InlineData(2)]
+    [InlineData(10)]
+    [InlineData(100)]
     public void Reverse(int length)
     {
         var values = Enumerable.Range(1, length).ToArray();
         var list = new SimpleLinkedList<int>(values);
         var reversed = list.Reverse();
-        Assert.That(reversed, Is.EqualTo(values.Reverse()));
+        Assert.Equal(values.Reverse(), reversed);
     }
 
-    [TestCase(1, Ignore = "Remove to run test case")]
-    [TestCase(2, Ignore = "Remove to run test case")]
-    [TestCase(10, Ignore = "Remove to run test case")]
-    [TestCase(100, Ignore = "Remove to run test case")]
+    [Theory(Skip = "Remove to run test")]
+    [InlineData(1)]
+    [InlineData(2)]
+    [InlineData(10)]
+    [InlineData(100)]
     public void Roundtrip(int length)
     {
         var values = Enumerable.Range(1, length);
         var listValues = new SimpleLinkedList<int>(values);
-        Assert.That(listValues, Is.EqualTo(values));
+        Assert.Equal(values, listValues);
     }
 }