trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/space-age/Example.cs

@@ -8,67 +8,67 @@ public class SpaceAge
         Earth, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune
     }
 
-    public long Seconds { get; private set; }
+    private readonly long seconds;
 
-    private readonly Dictionary<Planet, decimal> earthYearToPlanetPeriod = new Dictionary<Planet, decimal>
+    private readonly Dictionary<Planet, double> earthYearToPlanetPeriod = new Dictionary<Planet, double>
         {
             { Planet.Earth, 1 },
-            { Planet.Mercury, 0.2408467m },
-            { Planet.Venus, 0.61519726m },
-            { Planet.Mars, 1.8808158m },
-            { Planet.Jupiter, 11.862615m },
-            { Planet.Saturn, 29.447498m },
-            { Planet.Uranus, 84.016846m },
-            { Planet.Neptune, 164.79132m },
+            { Planet.Mercury, 0.2408467 },
+            { Planet.Venus, 0.61519726 },
+            { Planet.Mars, 1.8808158 },
+            { Planet.Jupiter, 11.862615 },
+            { Planet.Saturn, 29.447498 },
+            { Planet.Uranus, 84.016846 },
+            { Planet.Neptune, 164.79132 },
         };
 
     public SpaceAge(long seconds)
     {
-        Seconds = seconds;
+        this.seconds = seconds;
     }
 
-    private decimal CalculateAge(decimal periodInEarthYears)
+    private double CalculateAge(double periodInEarthYears)
     {
-        const decimal EARTH_ORBIT_IN_SECONDS = 31557600;
-        return Math.Round(Seconds / (EARTH_ORBIT_IN_SECONDS * periodInEarthYears), 2);
+        const double EARTH_ORBIT_IN_SECONDS = 31557600;
+        return Math.Round(seconds / (EARTH_ORBIT_IN_SECONDS * periodInEarthYears), 2);
     }
 
-    public decimal OnEarth()
+    public double OnEarth()
     {
         return CalculateAge(earthYearToPlanetPeriod[Planet.Earth]);
     }
 
-    public decimal OnMercury()
+    public double OnMercury()
     {
         return CalculateAge(earthYearToPlanetPeriod[Planet.Mercury]);
     }
 
-    public decimal OnVenus()
+    public double OnVenus()
     {
         return CalculateAge(earthYearToPlanetPeriod[Planet.Venus]);
     }
 
-    public decimal OnMars()
+    public double OnMars()
     {
         return CalculateAge(earthYearToPlanetPeriod[Planet.Mars]);
     }
 
-    public decimal OnJupiter()
+    public double OnJupiter()
     {
         return CalculateAge(earthYearToPlanetPeriod[Planet.Jupiter]);
     }
 
-    public decimal OnSaturn()
+    public double OnSaturn()
     {
         return CalculateAge(earthYearToPlanetPeriod[Planet.Saturn]);
     }
 
-    public decimal OnUranus()
+    public double OnUranus()
     {
         return CalculateAge(earthYearToPlanetPeriod[Planet.Uranus]);
     }
 
-    public decimal OnNeptune()
+    public double OnNeptune()
     {
         return CalculateAge(earthYearToPlanetPeriod[Planet.Neptune]);
     }

data/tracks/csharp/exercises/space-age/SpaceAge.cs

@@ -0,0 +1,48 @@
+using System;
+
+public class SpaceAge
+{
+    public SpaceAge(long seconds)
+    {
+    }
+
+    public double OnEarth()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public double OnMercury()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public double OnVenus()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public double OnMars()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public double OnJupiter()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public double OnSaturn()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public double OnUranus()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public double OnNeptune()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/space-age/SpaceAge.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/space-age/SpaceAgeTest.cs

@@ -1,84 +1,67 @@
+using Xunit;
 
-using NUnit.Framework;
-
-[TestFixture]
 public class SpaceAgeTest
 {
-    [Test]
-    public void Age_in_seconds()
-    {
-        var age = new SpaceAge(1000000);
-        Assert.That(age.Seconds, Is.EqualTo(1000000));
-    }
-
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Age_on_earth()
     {
         var age = new SpaceAge(1000000000);
-        Assert.That(age.OnEarth(), Is.EqualTo(31.69).Within(1E-02));
+        Assert.Equal(31.69, age.OnEarth());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Age_on_mercury()
     {
         var age = new SpaceAge(2134835688);
-        Assert.That(age.OnEarth(), Is.EqualTo(67.65).Within(1E-02));
-        Assert.That(age.OnMercury(), Is.EqualTo(280.88).Within(1E-02));
+        Assert.Equal(67.65, age.OnEarth());
+        Assert.Equal(280.88, age.OnMercury());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Age_on_venus()
     {
         var age = new SpaceAge(189839836);
-        Assert.That(age.OnEarth(), Is.EqualTo(6.02).Within(1E-02));
-        Assert.That(age.OnVenus(), Is.EqualTo(9.78).Within(1E-02));
+        Assert.Equal(6.02, age.OnEarth());
+        Assert.Equal(9.78, age.OnVenus());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Age_on_mars()
     {
         var age = new SpaceAge(2329871239);
-        Assert.That(age.OnEarth(), Is.EqualTo(73.83).Within(1E-02));
-        Assert.That(age.OnMars(), Is.EqualTo(39.25).Within(1E-02));
+        Assert.Equal(73.83, age.OnEarth());
+        Assert.Equal(39.25, age.OnMars());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Age_on_jupiter()
     {
         var age = new SpaceAge(901876382);
-        Assert.That(age.OnEarth(), Is.EqualTo(28.58).Within(1E-02));
-        Assert.That(age.OnJupiter(), Is.EqualTo(2.41).Within(1E-02));
+        Assert.Equal(28.58, age.OnEarth());
+        Assert.Equal(2.41, age.OnJupiter());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Age_on_saturn()
     {
         var age = new SpaceAge(3000000000);
-        Assert.That(age.OnEarth(), Is.EqualTo(95.06).Within(1E-02));
-        Assert.That(age.OnSaturn(), Is.EqualTo(3.23).Within(1E-02));
+        Assert.Equal(95.06, age.OnEarth());
+        Assert.Equal(3.23, age.OnSaturn());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Age_on_uranus()
     {
         var age = new SpaceAge(3210123456);
-        Assert.That(age.OnEarth(), Is.EqualTo(101.72).Within(1E-02));
-        Assert.That(age.OnUranus(), Is.EqualTo(1.21).Within(1E-02));
+        Assert.Equal(101.72, age.OnEarth());
+        Assert.Equal(1.21, age.OnUranus());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Age_on_neptune()
     {
         var age = new SpaceAge(8210123456);
-        Assert.That(age.OnEarth(), Is.EqualTo(260.16).Within(1E-02));
-        Assert.That(age.OnNeptune(), Is.EqualTo(1.58).Within(1E-02));
+        Assert.Equal(260.16, age.OnEarth());
+        Assert.Equal(1.58, age.OnNeptune());
     }
 }

data/tracks/csharp/exercises/strain/Strain.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+
+public static class Strain
+{
+    public static IEnumerable<T> Keep<T>(this IEnumerable<T> collection, Func<T, bool> predicate)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public static IEnumerable<T> Discard<T>(this IEnumerable<T> collection, Func<T, bool> predicate)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/strain/Strain.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/strain/StrainTest.cs

@@ -1,47 +1,41 @@
 using System.Collections.Generic;
 using System.Linq;
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class StrainTest
 {
-    [Test]
+    [Fact]
     public void Empty_keep()
     {
-        Assert.That(new LinkedList<int>().Keep(x => x < 10), Is.EqualTo(new LinkedList<int>()));
+        Assert.Equal(new LinkedList<int>(), new LinkedList<int>().Keep(x => x < 10));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Keep_everything()
     {
-        Assert.That(new HashSet<int> { 1, 2, 3 }.Keep(x => x < 10), Is.EqualTo(new HashSet<int> { 1, 2, 3 }));
+        Assert.Equal(new HashSet<int> { 1, 2, 3 }, new HashSet<int> { 1, 2, 3 }.Keep(x => x < 10));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Keep_first_and_last()
     {
-        Assert.That(new[] { 1, 2, 3 }.Keep(x => x % 2 != 0), Is.EqualTo(new[] { 1, 3 }));
+        Assert.Equal(new[] { 1, 3 }, new[] { 1, 2, 3 }.Keep(x => x % 2 != 0));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Keep_neither_first_nor_last()
     {
-        Assert.That(new List<int> { 1, 2, 3, 4, 5 }.Keep(x => x % 2 == 0), Is.EqualTo(new List<int> { 2, 4 }));
+        Assert.Equal(new List<int> { 2, 4 }, new List<int> { 1, 2, 3, 4, 5 }.Keep(x => x % 2 == 0));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Keep_strings()
     {
         var words = "apple zebra banana zombies cherimoya zelot".Split(' ');
-        Assert.That(words.Keep(x => x.StartsWith("z")), Is.EqualTo("zebra zombies zelot".Split(' ')));
+        Assert.Equal("zebra zombies zelot".Split(' '), words.Keep(x => x.StartsWith("z")));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Keep_arrays()
     {
         var actual = new[]
@@ -55,47 +49,41 @@ public class StrainTest
                 new[] { 1, 2, 5 }
             };
         var expected = new[] { new[] { 5, 5, 5 }, new[] { 5, 1, 2 }, new[] { 1, 5, 2 }, new[] { 1, 2, 5 } };
-        Assert.That(actual.Keep(x => x.Contains(5)), Is.EqualTo(expected));
+        Assert.Equal(expected, actual.Keep(x => x.Contains(5)));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Empty_discard()
     {
-        Assert.That(new LinkedList<int>().Discard(x => x < 10), Is.EqualTo(new LinkedList<int>()));
+        Assert.Equal(new LinkedList<int>(), new LinkedList<int>().Discard(x => x < 10));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Discard_nothing()
     {
-        Assert.That(new HashSet<int> { 1, 2, 3 }.Discard(x => x > 10), Is.EqualTo(new HashSet<int> { 1, 2, 3 }));
+        Assert.Equal(new HashSet<int> { 1, 2, 3 }, new HashSet<int> { 1, 2, 3 }.Discard(x => x > 10));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Discard_first_and_last()
     {
-        Assert.That(new[] { 1, 2, 3 }.Discard(x => x % 2 != 0), Is.EqualTo(new[] { 2 }));
+        Assert.Equal(new[] { 2 }, new[] { 1, 2, 3 }.Discard(x => x % 2 != 0));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Discard_neither_first_nor_last()
     {
-        Assert.That(new List<int> { 1, 2, 3, 4, 5 }.Discard(x => x % 2 == 0), Is.EqualTo(new List<int> { 1, 3, 5 }));
+        Assert.Equal(new List<int> { 1, 3, 5 }, new List<int> { 1, 2, 3, 4, 5 }.Discard(x => x % 2 == 0));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Discard_strings()
     {
         var words = "apple zebra banana zombies cherimoya zelot".Split(' ');
-        Assert.That(words.Discard(x => x.StartsWith("z")), Is.EqualTo("apple banana cherimoya".Split(' ')));
+        Assert.Equal("apple banana cherimoya".Split(' '), words.Discard(x => x.StartsWith("z")));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Discard_arrays()
     {
         var actual = new[]
@@ -109,6 +97,6 @@ public class StrainTest
                 new[] { 1, 2, 5 }
             };
         var expected = new[] { new[] { 1, 2, 3 }, new[] { 2, 1, 2 }, new[] { 2, 2, 1 } };
-        Assert.That(actual.Discard(x => x.Contains(5)), Is.EqualTo(expected));
+        Assert.Equal(expected, actual.Discard(x => x.Contains(5)));
     }
 }

data/tracks/csharp/exercises/sublist/Sublist.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+
+public enum SublistType
+{
+    Equal,
+    Unequal,
+    Superlist,
+    Sublist
+}
+
+public static class Sublist
+{
+    public static SublistType Classify<T>(List<T> list1, List<T> list2)
+        where T : IComparable
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}