trackler 2.2.1.128 → 2.2.1.129

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95c12d366b56345b9290db24099586fded8bc53b
-  data.tar.gz: eb4abbb1e73967a3c856380828d56a5c44bdc015
+  metadata.gz: eb29fe65c3ecd5e8a634ddabb722ee8bf9853f3e
+  data.tar.gz: 3fe12ee29a4011a03cf539696880996e05b38148
 SHA512:
-  metadata.gz: 61b8a49b00c50f38498d9df569f49947aa0e3b05e868f97d076026bd90e0130463e1b02da0ffffa04a058899a8148384b06407601905cb8f9d9e179b3255208d
-  data.tar.gz: 2b76fb81be78ccac2532c7dc4e989ebea55d7f4ec807538e610011aa3454badbc199cfb0b2e5f2d7888d86c43c8bbcf8d701f1774d5466945cd341818200b406
+  metadata.gz: 741a5f089384c1fdfde42dd6d158d43ff503b306cca392668ebddb3eb05db9a4d0ef16ad78379594dbf7dc8be5a8316c7d4977e2c461ed0d3900bed1707520d3
+  data.tar.gz: cb32027c2fbe7646481eb4a19ea399b05183dd3b9d8f1ca1bbbe21c1f7ee5d42d2d0b8a5cc8b4c41d5479bc993bc0202b7d6f56504349314fe7717bc3e19f78c

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.128"
+  VERSION = "2.2.1.129"
 end

data/problem-specifications/exercises/bracket-push/canonical-data.json

@@ -1,6 +1,6 @@
 {
   "exercise": "bracket-push",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "cases": [
     {
       "description": "paired square brackets",
@@ -50,6 +50,14 @@
       },
       "expected": true
     },
+    {
+      "description": "partially paired brackets",
+      "property": "isPaired",
+      "input": {
+        "value": "{[])"
+      },
+      "expected": false
+    },
     {
       "description": "simple nested brackets",
       "property": "isPaired",

data/tracks/bash/config.json

@@ -33,7 +33,7 @@
         "strings",
         "text_formatting"
       ],
-      "unlocked_by": "null",
+      "unlocked_by": null,
       "uuid": "0cfac255-6871-4588-a16b-98f7692bfdbe"
     },
     {
@@ -91,7 +91,7 @@
         "stdout",
         "strings"
       ],
-      "unlocked_by": "null",
+      "unlocked_by": null,
       "uuid": "b2b4ee35-108f-45ce-b294-c10d332e5579"
     },
     {
@@ -113,7 +113,7 @@
         "control_flow_conditionals",
         "input_validation"
       ],
-      "unlocked_by": "null",
+      "unlocked_by": null,
       "uuid": "e24451fd-761d-4d20-81d9-e470486ec44a"
     },
     {

data/tracks/ceylon/exercises/bracket-push/source/bracketpush/BracketsTest.ceylon

@@ -2,7 +2,7 @@ import ceylon.test {
     ...
 }
 
-// Tests adapted from problem-specifications version 1.2.0
+// Tests adapted from problem-specifications version 1.3.0
 
 {[String, Boolean]*} cases => {
     // paired square brackets
@@ -17,6 +17,8 @@ import ceylon.test {
     ["{]", false],
     // paired with whitespace
     ["{ }", true],
+    // partially paired brackets
+    ["{[])", false],
     // simple nested brackets
     ["{[]}", true],
     // several paired brackets

data/tracks/crystal/exercises/difference-of-squares/spec/difference_of_squares_spec.cr

@@ -6,39 +6,39 @@ describe "DifferenceOfSquares" do
     Squares.square_of_sum(5).should eq(225)
   end
 
-  it "calculates square of sum 10 is 3025" do
+  pending "calculates square of sum 10 is 3025" do
     Squares.square_of_sum(10).should eq(3025)
   end
 
-  it "calculates square of sum 100 is 25502500" do
+  pending "calculates square of sum 100 is 25502500" do
     Squares.square_of_sum(100).should eq(25502500)
   end
 
-  it "calculates sum of squares 5 is 55" do
+  pending "calculates sum of squares 5 is 55" do
     Squares.sum_of_squares(5).should eq(55)
   end
 
-  it "calculates sum of squares 10 is 385" do
+  pending "calculates sum of squares 10 is 385" do
     Squares.sum_of_squares(10).should eq(385)
   end
 
-  it "calculates sum of squares 100 is 338350" do
+  pending "calculates sum of squares 100 is 338350" do
     Squares.sum_of_squares(100).should eq(338350)
   end
 
-  it "calculates difference of squares 0 is 0" do
+  pending "calculates difference of squares 0 is 0" do
     Squares.difference_of_squares(0).should eq(0)
   end
 
-  it "calculates difference of squares 5 is 170" do
+  pending "calculates difference of squares 5 is 170" do
     Squares.difference_of_squares(5).should eq(170)
   end
 
-  it "calculates difference of squares 10 is 2640" do
+  pending "calculates difference of squares 10 is 2640" do
     Squares.difference_of_squares(10).should eq(2640)
   end
 
-  it "calculates difference of squares 100 is 25164150" do
+  pending "calculates difference of squares 100 is 25164150" do
     Squares.difference_of_squares(100).should eq(25164150)
   end
 end

data/tracks/csharp/config.json

@@ -926,6 +926,18 @@
       "unlocked_by": "kindergarten-garden",
       "uuid": "bae1f3a4-b63d-4efd-921a-133b3d5e379c"
     },
+    {
+      "core": false,
+      "difficulty": 5,
+      "slug": "yacht",
+      "topics": [
+        "games",
+        "parsing",
+        "sorting"
+      ],
+      "unlocked_by": "bob",
+      "uuid": "f808e80a-8e76-4f3d-840e-31a840c560f2"
+    },
     {
       "core": false,
       "difficulty": 6,

data/tracks/csharp/exercises/Exercises.sln

@@ -1,6 +1,6 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
-VisualStudioVersion = 15.0.27004.2009
+VisualStudioVersion = 15.0.26730.12
 MinimumVisualStudioVersion = 15.0.26124.0
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Accumulate", "accumulate\Accumulate.csproj", "{F16C0EE1-6923-4328-B015-363CF24FF867}"
 EndProject
@@ -226,6 +226,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ReverseString", "reverse-st
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ArmstrongNumbers", "armstrong-numbers\ArmstrongNumbers.csproj", "{7015C2C4-4050-4631-9394-7EAF19AB0191}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Yacht", "yacht\Yacht.csproj", "{C029D4C6-3A10-459E-96D7-3E77170A5A10}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -680,6 +682,10 @@ Global
 		{7015C2C4-4050-4631-9394-7EAF19AB0191}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{7015C2C4-4050-4631-9394-7EAF19AB0191}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{7015C2C4-4050-4631-9394-7EAF19AB0191}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C029D4C6-3A10-459E-96D7-3E77170A5A10}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C029D4C6-3A10-459E-96D7-3E77170A5A10}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C029D4C6-3A10-459E-96D7-3E77170A5A10}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C029D4C6-3A10-459E-96D7-3E77170A5A10}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

data/tracks/csharp/exercises/yacht/Example.cs

@@ -0,0 +1,71 @@
+using System.Collections.Generic;
+using System.Linq;
+
+public enum YachtCategory
+{
+    Ones = 1,
+    Twos = 2,
+    Threes = 3,
+    Fours = 4,
+    Fives = 5,
+    Sixes = 6,
+    FullHouse = 7,
+    FourOfAKind = 8,
+    LittleStraight = 9,
+    BigStraight = 10,
+    Choice = 11,
+    Yacht = 12,
+}
+
+public static class YachtGame
+{
+    public static int Score(int[] dice, YachtCategory category)
+    {
+        switch (category)
+        {
+            //Ones: Any combination. The sum of dice with the number 1.
+            case YachtCategory.Ones: return dice.Where(x => x == 1).Sum();
+            //Twos: Any combination. The sum of dice with the number 2. 
+            case YachtCategory.Twos: return dice.Where(x => x == 2).Sum();
+            //Threes: Any combination. The sum of dice with the number 3.
+            case YachtCategory.Threes: return dice.Where(x => x == 3).Sum();
+            //Fours: Any combination The sum of dice with the number 4.
+            case YachtCategory.Fours: return dice.Where(x => x == 4).Sum();
+            //Fives: Any combination. The sum of dice with the number 5.
+            case YachtCategory.Fives: return dice.Where(x => x == 5).Sum();
+            //Sixes: Any combination. The sum of dice with the number 6.
+            case YachtCategory.Sixes: return dice.Where(x => x == 6).Sum();
+
+            //Full House:  Three of one number and two of another.  Sum of all dice.
+            case YachtCategory.FullHouse:
+                {
+                    var testHashSet = new HashSet<int>();
+                    dice.ToList().ForEach(x => testHashSet.Add(x));
+                    return (testHashSet.Count() == 2) ? dice.Sum() : 0;
+                }
+            //Four-Of-A-Kind:  At least four dice showing the same face.   Sum of those four dice.
+            case YachtCategory.FourOfAKind: 
+                var testDict = new Dictionary<int, int>();
+                dice.ToList().ForEach(x =>
+                {
+                    if (!testDict.ContainsKey(x)) testDict.Add(x, 1); else testDict[x]++;
+                });
+                if (testDict.Count > 2) return 0;
+                else if (testDict.Count == 1 || testDict.ElementAt(0).Value >= 4) return testDict.Keys.ElementAt(0) * 4;
+                else if (testDict.ElementAt(1).Value >= 4) return testDict.Keys.ElementAt(1) * 4;
+                else return 0;
+            //Little Straight: 1 - 2 - 3 - 4 - 5. Score varies. Often 30.
+            case YachtCategory.LittleStraight:
+                return dice.OrderBy(x => x).SequenceEqual(new[] { 1, 2, 3, 4, 5 }) ? 30 : 0;
+            //Big Straight:    2 - 3 - 4 - 5 - 6. Score varies. Often 30.
+            case YachtCategory.BigStraight: 
+                return dice.OrderBy(x => x).SequenceEqual(new[] { 2, 3, 4, 5, 6 }) ? 30 : 0;
+            //Choice: Any combination. Sum of all dice Dice.
+            case YachtCategory.Choice: return dice.Sum();
+            //Yacht: All five dice showing the same face - scores 50.
+            case YachtCategory.Yacht:
+                return dice.Distinct().Count() == 1 ? 50 : 0;
+            default: return 0;
+        }
+    }
+}

data/tracks/csharp/exercises/yacht/README.md

@@ -0,0 +1,34 @@
+# Score a single throw of dice in *Yacht*
+
+The dice game [Yacht](https://en.wikipedia.org/wiki/Yacht_(dice_game)) is from
+the same family as Poker Dice, Generala and particularly Yahtzee, of which it
+is a precursor. In the game, five dice are rolled and the result can be entered
+in any of twelve categories. The score of a throw of the dice depends on
+category chosen.
+
+## Scores in Yacht
+
+    Category    Score                   Example
+    Ones            1 × number of ones      1 1 1 4 5 scores 3
+    Twos            2 × number of twos      2 2 3 4 5 scores 4
+    Threes          3 × number of threes    3 3 3 3 3 scores 15
+    Fours           4 × number of fours     1 2 3 3 5 scores 0
+    Fives           5 × number of fives     5 1 5 2 5 scores 15
+    Sixes           6 × number of sixes     2 3 4 5 6 scores 6
+    Full House      Total of the dice       3 3 3 5 5 scores 19
+    Four of a Kind  Total of the four dice  4 4 4 4 6 scores 16
+    Little Straight 30 points               1 2 3 4 5 scores 30 
+    Big Straight    30 points               2 3 4 5 6 scores 30
+    Choice          Sum of the dice         2 3 3 4 6 scores 18
+    Yacht           50 points               4 4 4 4 4 scores 50
+
+If the dice do not satisfy the requirements of a category, the score is zero.
+If, for example, *Four Of A Kind* is entered in the *Yacht* category, zero
+points are scored. A *Yacht* scores zero if entered in the *Full House* category.
+
+## Task 
+Given a list of values for five dice and a category, your solution should return
+the score of the dice for that category. If the dice do not satisfy the requirements
+of the category your solution should return 0. You can assume that five values
+will always be presented, and the value of each will be between one and six
+inclusively. You should not assume that the dice are ordered.

data/tracks/csharp/exercises/yacht/Yacht.cs

@@ -0,0 +1,26 @@
+using System;
+
+public enum YachtCategory
+{
+    Ones = 1,
+    Twos = 2,
+    Threes = 3,
+    Fours = 4,
+    Fives = 5,
+    Sixes = 6,
+    FullHouse = 7,
+    FourOfAKind = 8,
+    LittleStraight = 9,
+    BigStraight = 10,
+    Choice = 11,
+    Yacht = 12,
+}
+
+public static class YachtGame
+{
+    public static int Score(int[] dice, YachtCategory category)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}
+

data/tracks/csharp/exercises/yacht/Yacht.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Example.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.6.2" />
+    <PackageReference Include="xunit" Version="2.3.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
+  </ItemGroup>
+
+</Project>

data/tracks/csharp/exercises/yacht/YachtTest.cs

@@ -0,0 +1,162 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
+using Xunit;
+
+public class YachtTest
+{
+    [Fact]
+    public void Yacht()
+    {
+        Assert.Equal(50, YachtGame.Score(new[] { 5, 5, 5, 5, 5 }, YachtCategory.Yacht));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Not_yacht()
+    {
+        Assert.Equal(0, YachtGame.Score(new[] { 1, 3, 3, 2, 5 }, YachtCategory.Yacht));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Ones()
+    {
+        Assert.Equal(3, YachtGame.Score(new[] { 1, 1, 1, 3, 5 }, YachtCategory.Ones));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Ones_out_of_order()
+    {
+        Assert.Equal(3, YachtGame.Score(new[] { 3, 1, 1, 5, 1 }, YachtCategory.Ones));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void No_ones()
+    {
+        Assert.Equal(0, YachtGame.Score(new[] { 4, 3, 6, 5, 5 }, YachtCategory.Ones));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Twos()
+    {
+        Assert.Equal(2, YachtGame.Score(new[] { 2, 3, 4, 5, 6 }, YachtCategory.Twos));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Fours()
+    {
+        Assert.Equal(8, YachtGame.Score(new[] { 1, 4, 1, 4, 1 }, YachtCategory.Fours));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Yacht_counted_as_threes()
+    {
+        Assert.Equal(15, YachtGame.Score(new[] { 3, 3, 3, 3, 3 }, YachtCategory.Threes));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Yacht_of_3s_counted_as_fives()
+    {
+        Assert.Equal(0, YachtGame.Score(new[] { 3, 3, 3, 3, 3 }, YachtCategory.Fives));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Sixes()
+    {
+        Assert.Equal(6, YachtGame.Score(new[] { 2, 3, 4, 5, 6 }, YachtCategory.Sixes));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Full_house_two_small_three_big()
+    {
+        Assert.Equal(16, YachtGame.Score(new[] { 2, 2, 4, 4, 4 }, YachtCategory.FullHouse));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Full_house_three_small_two_big()
+    {
+        Assert.Equal(19, YachtGame.Score(new[] { 5, 3, 3, 5, 3 }, YachtCategory.FullHouse));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Two_pair_is_not_a_full_house()
+    {
+        Assert.Equal(0, YachtGame.Score(new[] { 2, 2, 4, 4, 5 }, YachtCategory.FullHouse));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Yacht_is_not_a_full_house()
+    {
+        Assert.Equal(0, YachtGame.Score(new[] { 2, 2, 2, 2, 2 }, YachtCategory.FullHouse));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Four_of_a_kind()
+    {
+        Assert.Equal(24, YachtGame.Score(new[] { 6, 6, 4, 6, 6 }, YachtCategory.FourOfAKind));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Yacht_can_be_scored_as_four_of_a_kind()
+    {
+        Assert.Equal(12, YachtGame.Score(new[] { 3, 3, 3, 3, 3 }, YachtCategory.FourOfAKind));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Full_house_is_not_four_of_a_kind()
+    {
+        Assert.Equal(0, YachtGame.Score(new[] { 3, 3, 3, 5, 5 }, YachtCategory.FourOfAKind));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Little_straight()
+    {
+        Assert.Equal(30, YachtGame.Score(new[] { 3, 5, 4, 1, 2 }, YachtCategory.LittleStraight));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Little_straight_as_big_straight()
+    {
+        Assert.Equal(0, YachtGame.Score(new[] { 1, 2, 3, 4, 5 }, YachtCategory.BigStraight));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Four_in_order_but_not_a_little_straight()
+    {
+        Assert.Equal(0, YachtGame.Score(new[] { 1, 1, 2, 3, 4 }, YachtCategory.LittleStraight));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void No_pairs_but_not_a_little_straight()
+    {
+        Assert.Equal(0, YachtGame.Score(new[] { 1, 2, 3, 4, 6 }, YachtCategory.LittleStraight));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Minimum_is_1_maximum_is_5_but_not_a_little_straight()
+    {
+        Assert.Equal(0, YachtGame.Score(new[] { 1, 1, 3, 4, 5 }, YachtCategory.LittleStraight));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Big_straight()
+    {
+        Assert.Equal(30, YachtGame.Score(new[] { 4, 6, 2, 5, 3 }, YachtCategory.BigStraight));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Big_straight_as_little_straight()
+    {
+        Assert.Equal(0, YachtGame.Score(new[] { 6, 5, 4, 3, 2 }, YachtCategory.LittleStraight));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Choice()
+    {
+        Assert.Equal(23, YachtGame.Score(new[] { 3, 3, 5, 6, 6 }, YachtCategory.Choice));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Yacht_as_choice()
+    {
+        Assert.Equal(10, YachtGame.Score(new[] { 2, 2, 2, 2, 2 }, YachtCategory.Choice));
+    }
+}

data/tracks/csharp/generators/Exercises/Yacht.cs

@@ -0,0 +1,20 @@
+using System;
+using Generators.Input;
+using Generators.Output;
+using Humanizer;
+
+namespace Generators.Exercises
+{
+    public class Yacht: GeneratorExercise
+    {
+	protected override void UpdateCanonicalData(CanonicalData canonicalData)
+	{
+	   canonicalData.Exercise = "yacht-game";
+	   foreach (var canonicalDataCase in canonicalData.Cases)
+	   {				
+              var input = canonicalDataCase.Properties["input"] as System.Collections.Generic.Dictionary<string,object>;
+	      input["category"] = new UnescapedValue($"YachtCategory.{input["category"].ToString().Dehumanize()}");
+	   }
+	}
+    }
+}

data/tracks/dart/exercises/leap/lib/example.dart

@@ -1,13 +1,9 @@
-class Year {
-  int value;
-
-  Year(int this.value);
-
-  bool isLeap() {
-    if (value % 4 != 0) {
+class Leap {
+  bool leapYear(int year) {
+    if (year % 4 != 0) {
       return false;
     }
 
-    return value % 100 != 0 || value % 400 == 0;
+    return year % 100 != 0 || year % 400 == 0;
   }
 }

data/tracks/dart/exercises/leap/lib/leap.dart

@@ -1,3 +1,3 @@
-class Year {
+class Leap {
   // Put your code here
 }

data/tracks/dart/exercises/leap/test/leap_test.dart

@@ -1,30 +1,28 @@
-import "package:test/test.dart";
-import "package:leap/leap.dart";
+import 'package:test/test.dart';
+import 'package:leap/leap.dart';
 
 void main() {
-  group("Year", () {
-    test("is not very common", () {
-      final year = new Year(2015);
+  final Leap leap = new Leap();
 
-      expect(year.isLeap(), equals(false));
-    });
+  group('Leap', () {
+    test("year not divisible by 4: common year", () {
+      final bool result = leap.leapYear(2015);
+      expect(result, equals(false));
+    }, skip: false);
 
     test("is introduced every 4 years to adjust about a day", () {
-      final year = new Year(1996);
-
-      expect(year.isLeap(), equals(true));
+      final bool result = leap.leapYear(1996);
+      expect(result, equals(true));
     }, skip: true);
 
     test("is skipped every 100 years to remove an extra day", () {
-      final year = new Year(2100);
-
-      expect(year.isLeap(), equals(false));
+      final bool result = leap.leapYear(2100);
+      expect(result, equals(false));
     }, skip: true);
 
     test("is reintroduced every 400 years to adjust another day", () {
-      final year = new Year(2000);
-
-      expect(year.isLeap(), equals(true));
+      final bool result = leap.leapYear(2000);
+      expect(result, equals(true));
     }, skip: true);
   });
 }

data/tracks/delphi/config.json

@@ -292,6 +292,17 @@
       "unlocked_by": null,
       "uuid": "5ab52a90-8a72-42f8-b430-042436041348"
     },
+    {
+      "core": false,
+      "difficulty": 5,
+      "slug": "bracket-push",
+      "topics": [
+        "parsing",
+        "strings"
+      ],
+      "unlocked_by": "bob",
+      "uuid": "81e0a0f7-b97d-4ff0-90b2-a43eb933f68f"
+    },
     {
       "core": true,
       "difficulty": 5,

data/tracks/delphi/exercises/bracket-push/BracketPush.dpr

@@ -0,0 +1,60 @@
+program BracketPush;
+
+{$IFNDEF TESTINSIGHT}
+{$APPTYPE CONSOLE}
+{$ENDIF}{$STRONGLINKTYPES ON}
+uses
+  System.SysUtils,
+  {$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX,
+  {$ENDIF }
+  DUnitX.Loggers.Console,
+  DUnitX.Loggers.Xml.NUnit,
+  DUnitX.TestFramework,
+  uBracketPushTest in 'uBracketPushTest.pas',
+  uBracketPush in 'uBracketPush.pas';
+
+var
+  runner : ITestRunner;
+  results : IRunResults;
+  logger : ITestLogger;
+  nunitLogger : ITestLogger;
+begin
+{$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX.RunRegisteredTests;
+  exit;
+{$ENDIF}
+  try
+    //Check command line options, will exit if invalid
+    TDUnitX.CheckCommandLine;
+    //Create the test runner
+    runner := TDUnitX.CreateRunner;
+    //Tell the runner to use RTTI to find Fixtures
+    runner.UseRTTI := True;
+    //tell the runner how we will log things
+    //Log to the console window
+    logger := TDUnitXConsoleLogger.Create(true);
+    runner.AddLogger(logger);
+    //Generate an NUnit compatible XML File
+    nunitLogger := TDUnitXXMLNUnitFileLogger.Create(TDUnitX.Options.XMLOutputFile);
+    runner.AddLogger(nunitLogger);
+    runner.FailsOnNoAsserts := False; //When true, Assertions must be made during tests;
+
+    //Run tests
+    results := runner.Execute;
+    if not results.AllPassed then
+      System.ExitCode := EXIT_ERRORS;
+
+    {$IFNDEF CI}
+    //We don't want this happening when running under CI.
+    if TDUnitX.Options.ExitBehavior = TDUnitXExitBehavior.Pause then
+    begin
+      System.Write('Done.. press <Enter> key to quit.');
+      System.Readln;
+    end;
+    {$ENDIF}
+  except
+    on E: Exception do
+      System.Writeln(E.ClassName, ': ', E.Message);
+  end;
+end.