trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/circle.yml

@@ -1,16 +1,26 @@
 machine:
   environment:
     TERM: xterm-256color
+    DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
+    DOTNET_CLI_TELEMETRY_OPTOUT: 1
 dependencies:
   pre:
+    - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
     - sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF
     - echo "deb http://download.mono-project.com/repo/debian wheezy main" | sudo tee /etc/apt/sources.list.d/mono-xamarin.list
     - sudo apt-get update
     - sudo apt-get install mono-complete
+    - sudo apt-get install gettext
+    - sudo apt-get install libcurl4-openssl-dev
+    - sudo apt-get install libicu-dev
+    - sudo apt-get install libssl-dev
+    - sudo apt-get install libunwind8
+    - sudo apt-get install zlib1g
+    - sudo apt-get install libstdc++6
+    - curl https://download.microsoft.com/download/B/4/6/B4678511-01F4-4F97-902B-0E58A985932A/dotnet-dev-debian-x64.1.0.0-rc4-004771.tar.gz -o /tmp/dotnet.tar.gz
+    - sudo mkdir -p /opt/dotnet
+    - sudo tar zxf /tmp/dotnet.tar.gz -C /opt/dotnet
+    - sudo ln -s /opt/dotnet/dotnet /usr/local/bin
 test:
   override:
-    - ./build.sh
-  post:
-    - mkdir -p $CIRCLE_TEST_REPORTS/junit/
-    - sed -i '1 s/^\xef\xbb\xbf//' .*/junit-results.xml
-    - find . -type f -regex ".*/junit-results.xml" -exec cp {} $CIRCLE_TEST_REPORTS/junit/ \;
+    - ./build.sh

data/tracks/csharp/docs/INSTALLATION.md

@@ -1,185 +1,20 @@
-## Installing C#
+### Installing .NET Core
 
-* [Windows](#windows)
-* [Mac](#mac)
-* [Linux](#linux)
-
-### [Windows](#windows)
-There are a couple of different ways to get started using C#. The main way is to
-install Visual Studio, the IDE for C# and related projects.
-
-If you don't want to use the IDE, files can be compiled via command line using the
-compiler provided by the .NET framework.
-
-#### With Visual Studio
-
-Install [Visual Studio Express 2013 for Windows Desktop](http://www.visualstudio.com/downloads/download-visual-studio-vs#d-express-windows-desktop). This will include the IDE and compiler for C#.
-
-You can either start by creating your own project for working with the Exercism problems or you can download a Visual Studio solution that is already set up.
-
-#### Exercism.io Visual Studio Template
-
-This is a Visual Studio template that comes pre-configured to work on the problems in as many languages as Visual Studio supports.
-
-![Solution Explorer](http://x.exercism.io/v3/tracks/csharp/docs/img/SolutionExplorer.png)
-
-1. Download the [Exercism.io Visual Studio Template](https://github.com/rprouse/Exercism.VisualStudio) from GitHub by clicking the Download Zip button on the page.
-2. Unzip the template into your exercises directory, for example `C:\src\exercises`
-2. Install the [Exercism CLI](http://exercism.io/cli)
-3. Open a command prompt to your exercise directory
-4. Add your API key to exercism `exercism configure --key=YOUR_API_KEY`
-5. Configure your source directory in exercism `exercism configure --dir=C:\src\exercises`
-6. [Fetch your first exercise](http://exercism.io/how-it-works/newbie) `exercism fetch csharp`
-7. Open the Exercism solution in Visual Studio
-8. Expand the Exercism.csharp project
-9. Click on **Show All Files** in Solution Explorer (See below)
-10. The exercise you just fetched will appear greyed out. Right click on the folder and **Include In Project**
-11. Get coding...
-
-![Add files](http://x.exercism.io/v3/tracks/csharp/docs/img/AddFiles.png)
-
-The NUnit NuGet package is included in the project, so you will not need to install it.
-
-If you have a paid version of Visual Studio install the [NUnit Visual Studio Test Adapter](https://visualstudiogallery.msdn.microsoft.com/6ab922d0-21c0-4f06-ab5f-4ecd1fe7175d). This will allow you to run the tests from within Visual Studio. If you have ReSharper installed, you can also [run the tests using ReSharper](https://www.jetbrains.com/resharper/features/unit_testing.html).
-
-![Test Explorer](http://x.exercism.io/v3/tracks/csharp/docs/img/TestExplorer.png)
-
-If you are using Visual Studio Express, install [NUnit 3.x](http://www.nunit.org/) and run the tests from the command line (see below).
-
-#### Create a New Visual Studio Project
-
-Once installed and started, click on "Create New Project" (alternatively, you can go to File->New->New Project).
-
-![New Project](http://x.exercism.io/v3/tracks/csharp/docs/img/newProject.png)
-
-Choose what language and project type (Visual C# and Class Library). Also name your project to whatever you'd like.
-
-![Create Project](http://x.exercism.io/v3/tracks/csharp/docs/img/createNewProject.png)
-
-Once created, feel free to drag and drop the C# Exercism folders into the project.
-
-![Drag and Drop Folders](http://x.exercism.io/v3/tracks/csharp/docs/img/dragDropFolders.png)
-
-In order to compile, get the [NUnit](http://nunit.org/) assembly referenced for the unit tests. This can be done via [NuGet](http://www.nuget.org/) - a package manager for Visual Studio. The best packages is to get the base [NUnit]() and the [NUnit.Console](https://www.nuget.org/packages/NUnit.Console/)
-package since it includes the assemblies needed and a GUI test runner.
-
-![Nuget](http://x.exercism.io/v3/tracks/csharp/docs/img/nugetMenu.png)
-
-Two options to use Nuget - the NuGet manager or through the Package Manager Console.
-
-The manager is the easiest way to get started.
-
-![Nuget Manager](http://x.exercism.io/v3/tracks/csharp/docs/img/nugetManageNunitRunner.png)
-
-The project should now be able to compile.
-
-The next piece required is the NUnit Test Adapter for Visual Studio.  The major version of the Test Adapter must match the major version of the NUnit Framework that you installed above, or the Visual Studio Test Explorer window will not detect your unit tests.
-- [Adapter Version 3 for NUnit 3.x](https://visualstudiogallery.msdn.microsoft.com/0da0f6bd-9bb6-4ae3-87a8-537788622f2d)
-- [Adapter Version 2 for NUnit 2.x](https://visualstudiogallery.msdn.microsoft.com/6ab922d0-21c0-4f06-ab5f-4ecd1fe7175d)
-
-To start implementing the exercise, in Visual Studio, right click on where you want the file to go to and go to `Add` -> `Class`. Name it what you'd like.
-
-![New Item](http://x.exercism.io/v3/tracks/csharp/docs/img/addNewClass.png)
-
-Now you can start coding!
-
-#### With the command line compiler
-The .cs files can also be compiled without Visual Studio. Get the latest version of
-[.NET installed](http://msdn.microsoft.com/en-us/library/5a4x27ek(v=vs.110).aspx) and there will be an executable called csc.exe.
-
-The compiler executable is usually located in the Microsoft.NET\Framework\Version folder under the Windows directory.
-
-Refer to this [MSDN article](http://msdn.microsoft.com/en-us/library/78f4aasd.aspx) for more information on the command line compiler.
-
-### [Mac](#mac)
-
-Install [Xamarin Studio](http://xamarin.com/download).
-
-While Xamarin is most known for creating iOS and Android applications, it's still a perfect IDE to create C# console
-or library projects which is all that's needed for Exercism.
-
-Once installed and running, click on new solution and you'll find the C# library project to select.
-
-![Xamarin New Project](http://x.exercism.io/v3/tracks/csharp/docs/img/xamarin-csharp.jpg)
-
-### [Linux](#linux)
-
-.NET Core is available for Linux. Follow the [official installation guide](https://www.microsoft.com/net/core#linuxubuntu) to install the .NET Core development tools. 
-
-After installing .NET Core, fetch the first exercise of the csharp-track:
-
-```
-exercism fetch csharp
-```
-
-Move into the exercise directory:
-
-```
-cd ~/exercism/csharp/hello-world
-```
-
-Initialize a new dotnet project
-
-```
-dotnet new
-```
-
-Several new files are created, among them project.json. We have to add nunit as a dependency in order to run the tests provided in the exercise.
-
-Add the following lines to the dependency block:
+The C# track is built on top of the [.NET Core](https://www.microsoft.com/net/core/platform) platform, which runs on Windows, Linux and macOS. To build .NET Core projects, you can use the .NET Core Command Line Interface (CLI). This CLI is part of the .NET Core SDK, which you can install by following the [installation instructions](https://www.microsoft.com/net/download/core). After completing the installation, you can verify if the CLI was installed succesfully by running this command in a terminal:
 
-```
-"dependencies": {
-  "nunit": "3.6.0",
-  "dotnet-test-nunit": "3.4.0-*"
-}
+```bash
+dotnet --version
 ```
 
-We also have to specify the testrunner, add this line below the dependency block:
+It the output is a version greater than or equal to `1.0.0`, the .NET Core SDK has been installed succesfully.
 
-```
-"testRunner":"nunit"
-```
-
-The complete **project.json** file should look something like this:
+### Using an IDE
 
-```
-{
-  "version": "1.0.0-*",
-  "buildOptions": {
-    "debugType": "portable",
-    "emitEntryPoint": true
-  },
-  "dependencies": {
-    "nunit": "3.6.0",
-    "dotnet-test-nunit": "3.4.0-*"
-  },
-  "testRunner":"nunit",
-  "frameworks": {
-    "netcoreapp1.1": {
-      "dependencies": {
-        "Microsoft.NETCore.App": {
-          "type": "platform",
-          "version": "1.1.0"
-        }
-      },
-      "imports": "dnxcore50"
-    }
-  }
-}
-```
-
-Then we can restore the packages using:
-
-```
-dotnet restore
-```
-
-Compile the project and run the tests with this:
-
-```
-dotnet test
-```
+If you want a more full-featured editing experience, you probably want to to use an IDE. These are the most popular IDE's that support building .NET Core projects:
 
+* [Visual Studio 2017](https://www.visualstudio.com/downloads/)
+* [Visual Studio Code](https://code.visualstudio.com/download) with the [C# extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode.csharp)
+* [Visual Studio for Mac](https://www.visualstudio.com/vs/visual-studio-mac/) (still in beta)
+* [Project Rider](https://www.jetbrains.com/rider/download/) (still in EAP)
 
-[Mono Develop](http://www.mono-project.com/Mono_For_Linux_Developers) is available for Linux.
+Note: as the .NET Core project format differs significantly from earlier versions, older IDE's (like Visual Studio 2015 and Xamarin Studio) are not supported.

data/tracks/csharp/docs/TESTS.md

@@ -1,50 +1,33 @@
-### Windows
-All tests have been ignored except the first one for you to work on. To continue, just remove the ```[Ignore]``` attribute on the test to start working on it.
+## Running Tests
 
-Make sure [NUnit](http://nunit.org/?p=download) version 3.x is installed, if not already installed from the setup above.
+To run the tests, you first need to restore the project's dependencies using the following command:
 
-This installation should include the NUnit-Gui executable. Run this, and after compiling, open the assembly from the Gui and you are able to run the tests.
+```bash
+dotnet restore
+```
 
-**Note:** You may need to include the nunit-framework.dll in the same directory as the source code you're compiling if you get an error saying it can't find the ```nunit.framework.dll```.
+You can then run the tests by executing the following command:
 
-If you installed the NUnit runner through NuGet, the runner will be located in the ```\packages\NUnit.Console(version number)\tools``` folder where your project is.
+```bash
+dotnet test
+```
 
-If you installed NUnit manually the runner will be in the ```Program Files (x86)\NUnit(version number)\bin``` folder.
+## Solving the exercise
 
-![NUnit Runner](http://x.exercism.io/v3/tracks/csharp/docs/img/nUnitRunner.png)
+Solving an exercise means making all its tests pass. By default, only one test (the first one) is executed when you run the tests. This is intentional, as it allows you to focus on just making that one test pass. Once it passes, you can enable the next test by removing `Skip = "Remove to run test"` from the test's `[Fact]` or `[Theory]` attribute. When all tests have been enabled and your implementation makes them all pass, you'll have solved the exercise!
 
-Once you have been able to compile the code it will create a DLL in the ```\bin\Debug``` folder of your project. In the NUnit runner, select "Open Project" and select the DLL that was created from compiling. This will load all the tests and allow you to run them.
+To help you get started, each exercise comes with a stub implementation file. You can use this file as a starting point for building your solution. Feel free to remove or change this file if you think it is the right thing to do.
 
-![NUnit Runner Execute Tests](http://x.exercism.io/v3/tracks/csharp/docs/img/nUnitExecuteTests.png)
+## Using packages
 
-The NUnit runner will automatically reload the DLL if it has been updated.
+You should be able to solve most exercises without using any external packages. However, for the exercises where you do want to use an external package, you can add it to your project by running the following command:
 
-##### Visual Studio Integration
+```bash
+dotnet add package <package-name>
+```
 
-Another alternative to running the tests with NUnit-Gui is to run them directly in Visual Studio, which is very convenient if that's your IDE of choice. While the support is natively built in to Visual Studio 2015, for older versions you'll need to install the [NUnit Test Adapter](http://www.nunit.org/index.php?p=vsTestAdapter&r=2.6.2).
+Once the package has been added, you need to update the project's dependencies again to use it in your project:
 
-### Mac
-Xamarin Studio also ships with NUnit. To set the tests up you will have to add an NUnit library project to your solution, name it correctly and set a reference to your solution.
-
-This is the example setup for the "leap" exercise. We assume you created a solution called `LeapCalculator`.
-
-Right-click the solution and choose *Add* -> *Add New Project*.
-![Add Xamarin NUnit Test](http://x.exercism.io/v3/tracks/csharp/docs/img/xamarin-add-new-project.png)
-
-Then from the new project dialog, select an NUnit Library Project.
-![Xamarin NUnit](http://x.exercism.io/v3/tracks/csharp/docs/img/xamarin-nunit.jpg)
-
-For the project name append `.Tests` to the name of your solution. So in our case `LeapCalculator.Tests`
-![Xamarin NUnit](http://x.exercism.io/v3/tracks/csharp/docs/img/xamarin-naming.png)
-
-Set a reference to your solution with right-click on references in your test project. Then choose the Projects tab and tick the box to your solution and  click `ok`.
-
-![Xamarin NUnit](http://x.exercism.io/v3/tracks/csharp/docs/img/xamarin-edit-reference.png)
-
-![Xamarin NUnit](http://x.exercism.io/v3/tracks/csharp/docs/img/xamarin-add-reference.png)
-
-Add some of the tests from the exercise or write your own.
-
-To run the tests open the `Unit Tests` pad within Xamarin (View -> Pads -> Unit Tests) and click `Run All`.
-
-![Xamarin NUnit](http://x.exercism.io/v3/tracks/csharp/docs/img/xamarin-tests.png)
+```bash
+dotnet restore
+```

data/tracks/csharp/exercises/accumulate/Accumulate.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+
+public static class AccumulateExtensions
+{
+    public static IEnumerable<U> Accumulate<T, U>(this IEnumerable<T> collection, Func<T, U> func)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/accumulate/Accumulate.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/accumulate/AccumulateTest.cs

@@ -1,38 +1,32 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class AccumulateTest
 {
-    [Test]
+    [Fact]
     public void Empty_accumulation_produces_empty_accumulation()
     {
-        Assert.That(new int[0].Accumulate(x => x * x), Is.EqualTo(new int[0]));
+        Assert.Equal(new int[0], new int[0].Accumulate(x => x * x));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Accumulate_squares()
     {
-        Assert.That(new[] { 1, 2, 3 }.Accumulate(x => x * x), Is.EqualTo(new[] { 1, 4, 9 }));
+        Assert.Equal(new[] { 1, 4, 9 }, new[] { 1, 2, 3 }.Accumulate(x => x * x));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Accumulate_upcases()
     {
-        Assert.That(new List<string> { "hello", "world" }.Accumulate(x => x.ToUpper()),
-            Is.EqualTo(new List<string> { "HELLO", "WORLD" }));
+        Assert.Equal(new List<string> { "HELLO", "WORLD" }, new List<string> { "hello", "world" }.Accumulate(x => x.ToUpper()));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Accumulate_reversed_strings()
     {
-        Assert.That("the quick brown fox etc".Split(' ').Accumulate(Reverse),
-            Is.EqualTo("eht kciuq nworb xof cte".Split(' ')));
+        Assert.Equal("eht kciuq nworb xof cte".Split(' '), "the quick brown fox etc".Split(' ').Accumulate(Reverse));
     }
 
     private static string Reverse(string value)
@@ -42,33 +36,28 @@ public class AccumulateTest
         return new string(array);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Accumulate_within_accumulate()
     {
         var actual = new[] { "a", "b", "c" }.Accumulate(c =>
             string.Join(" ", new[] { "1", "2", "3" }.Accumulate(d => c + d)));
-        Assert.That(actual, Is.EqualTo(new[] { "a1 a2 a3", "b1 b2 b3", "c1 c2 c3" }));
+        Assert.Equal(new[] { "a1 a2 a3", "b1 b2 b3", "c1 c2 c3" }, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Accumulate_is_lazy()
     {
         var counter = 0;
         var accumulation = new[] { 1, 2, 3 }.Accumulate(x => x * counter++);
 
-        Assert.That(counter, Is.EqualTo(0));
+        Assert.Equal(0, counter);
         accumulation.ToList();
-        Assert.That(counter, Is.EqualTo(3));
+        Assert.Equal(3, counter);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Accumulate_allows_different_return_type()
     {
-        Assert.That(
-            new[] { 1, 2, 3 }.Accumulate(x => x.ToString()), 
-            Is.EqualTo(new[] { "1", "2", "3" }));
+        Assert.Equal(new[] { "1", "2", "3" }, new[] { 1, 2, 3 }.Accumulate(x => x.ToString()));
     }
 }

data/tracks/csharp/exercises/acronym/Acronym.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class Acronym
+{
+    public static string Abbreviate(string phrase)
+    {
+        throw new NotImplementedException("Please implement this function");
+    }
+}

data/tracks/csharp/exercises/acronym/Acronym.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>