trackler 2.0.8.4 → 2.0.8.5

data/tracks/delphi/config.json

@@ -151,7 +151,16 @@
     {
 	  "slug": "book-store",
 	  "difficulty": 6
-	}
+	},
+    {
+      "slug": "poker",
+      "difficulty": 7,
+      "topics": [
+        "Parsing",
+        "Sorting",
+        "Games"
+      ]
+    }
   ],
   "ignored": [
     "bin",

data/tracks/delphi/exercises/hello-world/uHelloWorldExample.pas

@@ -2,13 +2,13 @@ unit uHelloWorld;
 
 interface
 
-  function Hello(name: string='World'): string;
+  function Hello: string;
 
 implementation
 
-function Hello(name: string='World'): string;
+function Hello: string;
 begin
-  result := 'Hello, ' + name + '!';
+  result := 'Hello, World!';
 end;
 
 end.

data/tracks/delphi/exercises/hello-world/uTestHelloWorld.pas

@@ -36,33 +36,17 @@ type
   HelloWorldTest = class(TObject)
   public
     [Test]
-    procedure test_no_name;
-    [Test]
-    [Ignore('Comment this line to run this test')]
-    procedure test_sample_name;
-    [Test]
-    [Ignore('Comment this line to run this test')]
-    procedure test_other_sample_name;
+    procedure Say_hi;
   end;
 
 implementation
 uses uHelloWorld;
 
-procedure HelloWorldTest.test_no_name;
+procedure HelloWorldTest.Say_hi;
 begin
   assert.AreEqual('Hello, World!', Hello);
 end;
 
-procedure HelloWorldTest.test_sample_name;
-begin
-  assert.AreEqual('Hello, Alice!',Hello('Alice'));
-end;
-
-procedure HelloWorldTest.test_other_sample_name;
-begin
-  assert.AreEqual('Hello, Bob!', Hello('Bob'));
-end;
-
 initialization
   TDUnitX.RegisterTestFixture(HelloWorldTest);
 end.

data/tracks/delphi/exercises/poker/Poker.dpr

@@ -0,0 +1,60 @@
+program Poker;
+
+{$IFNDEF TESTINSIGHT}
+{$APPTYPE CONSOLE}
+{$ENDIF}{$STRONGLINKTYPES ON}
+uses
+  System.SysUtils,
+  {$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX,
+  {$ENDIF }
+  DUnitX.Loggers.Console,
+  DUnitX.Loggers.Xml.NUnit,
+  DUnitX.TestFramework,
+  uPokerTest in 'uPokerTest.pas',
+  uPoker in 'uPoker.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.

data/tracks/delphi/exercises/poker/uPokerExample.pas

@@ -0,0 +1,253 @@
+unit uPoker;
+
+interface
+uses Generics.Collections;
+
+type
+
+  Poker = class
+  private
+    type
+      Card = record
+               Rank,
+               Suit: integer;
+             end;
+      Hand = record
+               Input: string;
+               Score: integer;
+             end;
+    class function ParseHand(aHand: string): Hand; static;
+    class function ParseCards(aHand: string): TArray<Card>; static;
+    class function ParseCard(aCard: string): Card; static;
+    class function ParseRank(aCard: string): integer; static;
+    class function ParseSuit(aCard: string): integer; static;
+    class function ScoreHand(aCards: TArray<Card>): integer; static;
+  public
+    class function BestHands(aHands: TList<String>): TList<string>; static;
+  end;
+
+implementation
+uses SysUtils, Math, Generics.Defaults, Spring.Collections;
+
+class function Poker.BestHands(aHands: TList<String>): TList<string>;
+
+{$region 'BestHands workers'}
+  function MaxScore(aList: IList<Hand>): integer;
+  var lResult: integer;
+      aItem: Hand;
+  begin
+    lResult := 0;
+    for aItem in aList do
+      if aItem.Score > lResult then
+        lResult := aItem.score;
+    result := lResult;
+  end;
+
+  function ScoreHands(aList: TList<string>): IList<Hand>;
+  var aItem: string;
+  begin
+    Result := TCollections.CreateList<Hand>;
+    for aItem in aList do
+      result.Add(ParseHand(aItem));
+  end;
+
+  function ListOfWinningHands(const aTarget: integer; aList: IList<Hand>): IList<string>;
+  var aItem: Hand;
+  begin
+    result := TCollections.CreateList<string>;
+    for aItem in aList do
+      if aItem.Score = aTarget then
+        result.Add(aItem.Input);
+  end;
+{$endregion}
+
+var scoredHands: IList<Hand>;
+    lmaxScore: integer;
+begin
+  scoredHands := ScoreHands(aHands);
+  lMaxScore := MaxScore(scoredHands);
+
+  result := TList<string>.Create;
+  result.AddRange(ListOfWinningHands(lMaxScore, scoredHands).ToArray);
+end;
+
+class function Poker.ParseHand(aHand: string): Hand;
+begin
+  result.Input := aHand;
+  result.Score := ScoreHand(ParseCards(aHand));
+end;
+
+class function Poker.ParseCards(aHand: string): TArray<Card>;
+var lhand: TArray<string>;
+    lCardStr: string;
+    lParsedHand: IList<Card>;
+begin
+  lParsedHand := TCollections.CreateList<Card>(
+    function(const left, right: Card): integer
+    begin
+      result := TComparer<integer>.Default.Compare(left.Rank, right.Rank);
+    end);
+
+  lhand := aHand.Split([' ']);
+  for lCardStr in lhand do
+    lParsedHand.Add(ParseCard(lCardStr));
+  lParsedHand.Sort;
+  lParsedhand.Reverse;
+  result := lParsedHand.ToArray;
+end;
+
+class function Poker.ParseCard(aCard: string): Card;
+begin
+  result.Rank := ParseRank(aCard);
+  result.Suit := ParseSuit(aCard);
+end;
+
+class function Poker.ParseRank(aCard: string): integer;
+var lRanks: IList<char>;
+    lCard: TArray<char>;
+begin
+  lCard := aCard.ToCharArray;
+  lRanks := TCollections.CreateList<char>;
+  lRanks.AddRange(['.','.','2','3','4','5','6','7','8','9','T','J','K','Q','A']);
+  result := lRanks.IndexOf(lCard[low(lCard)]);
+end;
+
+class function Poker.ParseSuit(aCard: string): integer;
+var lSuits: IList<char>;
+    lCard: TArray<char>;
+begin
+  lCard := aCard.ToCharArray;
+  lSuits := TCollections.CreateList<char>;
+  lSuits.AddRange(['.','H','S','D','C']);
+  result := lSuits.IndexOf(lCard[high(lCard)]);
+end;
+
+class function Poker.ScoreHand(aCards: TArray<Card>): integer;
+
+{$region 'ScoreHand Workers'}
+    function CardsByRankOccurance: IList<integer>;
+    var rank: integer;
+        lRankOccurence: TArray<integer>;
+        aCard: Card;
+        currentOccurenceCount: integer;
+    begin
+      SetLength(lRankOccurence, 15);
+      for aCard in aCards do
+        inc(lRankOccurence[aCard.Rank]);
+      currentOccurenceCount := 0;
+      result := TCollections.CreateList<integer>;
+      result.Add(0);
+      for rank := High(lRankOccurence) downto Low(lRankOccurence) + 2 do
+      begin
+        if lRankOccurence[rank] >= currentOccurenceCount  then
+        begin
+          result.Insert(0,rank);
+          currentOccurenceCount := lRankOccurence[rank];
+        end;
+      end;
+    end;
+
+    function CountRanks: IList<integer>;
+    var rankCount: integer;
+        i: integer;
+    begin
+      result := TCollections.CreateList<integer>;
+      rankCount := 1;
+      for i := low(aCards) to high(aCards) - 1 do
+      begin
+        if aCards[i].Rank = aCards[i+1].Rank then
+          inc(rankCount)
+        else
+        begin
+          result.Add(rankCount);
+          rankCount := 1;
+        end;
+      end;
+      result.Add(rankCount);
+      result.Sort;
+      result.Reverse;
+    end;
+
+    procedure SelectRankAndSuits(out Suits, Ranks: IList<integer>);
+    var aCard: Card;
+    begin
+      Suits := TCollections.CreateList<integer>;
+      Ranks := TCollections.CreateList<integer>;
+
+      for aCard in aCards do
+      begin
+        Suits.Add(aCard.Suit);
+        Ranks.Add(aCard.Rank);
+      end;
+      Suits.Sort;
+      Suits.Reverse;
+      Ranks.Sort;
+      Ranks.Reverse;
+      if Ranks.EqualsTo([14,5,4,3,2]) then
+      begin //Ace is worth one when hand is straight to five
+        Ranks.Remove(14);
+        Ranks.Add(1);
+      end;
+    end;
+
+    function Distinct(aList: IList<integer>): integer;
+    var prevItem: integer;
+        ItemCount: integer;
+        item: integer;
+    begin
+      ItemCount := 0;
+      prevItem := 0;
+      for item in aList do
+        if item <> prevItem then
+        begin
+          inc(ItemCount);
+          prevItem := item;
+        end;
+      result := ItemCount;
+    end;
+{$endregion}
+
+var listOfCardsByRank: IList<integer>;
+    listOfRankCounts: IList<integer>;
+    Ranks: IList<integer>;
+    Suits: IList<integer>;
+    flush: boolean;
+    straight: boolean;
+begin
+  listOfCardsByRank := CardsByRankOccurance;
+  listOfRankCounts := CountRanks;
+
+  SelectRankAndSuits(Suits, Ranks);
+
+  flush := Distinct(Suits) = 1;
+  straight := (Distinct(Ranks) = 5) and ((Ranks[0] - Ranks[4]) = 4);
+
+  if straight and flush then
+    result := 800 + Ranks.First
+  else
+    if listOfRankCounts.EqualsTo([4,1]) then   // 4 of a kind
+      result := 700 + listOfCardsByRank[0]
+    else
+      if listOfRankCounts.EqualsTo([3,2]) then // full house
+        result := 600 + listOfCardsByRank[0]
+      else
+        if flush then
+          result := 500 + Ranks.First
+        else
+          if straight then
+            result := 400 + Ranks.First
+          else
+            if listOfRankCounts.EqualsTo([3,1,1]) then  //3 of a kind
+              result := 300 + listOfCardsByRank[0]
+            else
+              if listOfRankCounts.EqualsTo([2,2,1]) then  // 2 pair
+                result := 200 + Math.Max(listOfCardsByRank[0], listOfCardsByRank[1])
+              else
+                if listOfRankCounts.EqualsTo([2,1,1,1]) then // 1 pair
+                  result := 100 + listOfCardsByRank[0]
+                else
+                  result := Ranks.Max;  // high card
+
+end;
+
+end.

data/tracks/delphi/exercises/poker/uPokerTest.pas

@@ -0,0 +1,582 @@
+unit uPokerTest;
+
+interface
+uses
+  DUnitX.TestFramework;
+
+type
+
+  [TestFixture]
+  PokerTest = class(TObject)
+  public
+    [Test]
+    procedure One_hand;
+
+    [Test]
+    [Ignore]
+    procedure Nothing_vs_one_pair;
+
+    [Test]
+    [Ignore]
+    procedure Two_pairs;
+
+    [Test]
+    [Ignore]
+    procedure One_pair_vs_double_pair;
+
+    [Test]
+    [Ignore]
+    procedure Two_double_pairs;
+
+    [Test]
+    [Ignore]
+    procedure Double_pair_vs_three;
+
+    [Test]
+    [Ignore]
+    procedure Two_threes;
+
+    [Test]
+    [Ignore]
+    procedure Three_vs_straight;
+
+    [Test]
+    [Ignore]
+    procedure Two_straights;
+
+    [Test]
+    [Ignore]
+    procedure Straight_vs_flush;
+
+    [Test]
+    [Ignore]
+    procedure Two_flushes;
+
+    [Test]
+    [Ignore]
+    procedure Flush_vs_full;
+
+    [Test]
+    [Ignore]
+    procedure Two_fulls;
+
+    [Test]
+    [Ignore]
+    procedure Full_vs_square;
+
+    [Test]
+    [Ignore]
+    procedure Two_squares;
+
+    [Test]
+    [Ignore]
+    procedure Square_vs_straight_flush;
+
+    [Test]
+    [Ignore]
+    procedure Two_straight_flushes;
+
+    [Test]
+    [Ignore]
+    procedure Three_hand_with_tie;
+
+    [Test]
+    [Ignore]
+    procedure Straight_to_5_against_a_pair_of_jacks;
+  end;
+
+implementation
+uses Generics.Collections, uPoker;
+
+procedure PokerTest.One_hand;
+const hand: string = '5S 4S 7H 8D JC';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange(hand);
+  expectedHands := TList<string>.Create;
+  expectedHands.AddRange(hand);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Nothing_vs_one_pair;
+const nothing: string = '4S 5H 6S 8D JH';
+      pairOf4: string = '2S 4H 6S 4D JH';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([nothing, pairOf4]);
+  expectedHands := TList<string>.Create;
+  expectedHands.AddRange(pairOf4);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Two_pairs;
+const pairOf2: string = '4S 2H 6D 2D JD';
+      pairOf4: string = '2S 4H 6S 4D JH';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.create;
+  inputHands.AddRange([pairOf2, pairOf4]);
+  expectedHands := TList<string>.Create;
+  expectedHands.AddRange(pairOf4);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.One_pair_vs_double_pair;
+const pairOf8: string = '2S 8H 6S 8D JH';
+      doublePair: string = '4C 5C 4S 8D 5H';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([pairOf8, doublePair]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.Add(doublePair);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Two_double_pairs;
+const doublePair2And8: string = '2D 8H 2S 8D JH';
+      doublePair4And5: string = '4S 5C 4C 8D 5H';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([doublePair2And8, doublePair4And5]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.Add(doublePair2And8);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Double_pair_vs_three;
+const doublePair2And8: string = '2D 8H 2S 8D JH';
+      threeOf4: string = '4D 5H 4S 8D 4H';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([doublePair2And8, threeOf4]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.Add(threeOf4);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Two_threes;
+const threeOf2: string = '2S 2H 2S 8D JH';
+      threeOf1: string = '4S AH AS 8D AH';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([threeOf2, threeOf1]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.Add(threeOf1);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Three_vs_straight;
+const threeOf4: string = '4S 5D 4C 8D 4H';
+      straight: string = '3S 4D 2S 6D 5H';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([threeOf4, straight]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.Add(straight);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Two_straights;
+const straightTo8: string = '4S 6H 7S 8D 5H';
+      straightTo9: string = '5S 7H 8S 9D 6H';
+      straightTo1: string = 'AS QH KS TD JH';
+      straightTo5: string = '4S AH 3S 2D 5H';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([straightTo8, straightTo9]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.Add(straightTo9);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+
+  inputHands.Clear;
+  inputHands.AddRange([straightTo1, straightTo5]);
+
+  expectedHands.Clear;
+  expectedHands.Add(straightTo1);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Straight_vs_flush;
+const straightTo8: string = '4S 6H 7S 8D 5H';
+      flushTo7: string = '2S 4S 5S 6S 7S';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([straightTo8, flushTo7]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.Add(flushTo7);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Two_flushes;
+const flushTo8: string = '3H 6H 7H 8H 5H';
+      flushTo7: string = '2S 4S 5S 6S 7S';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([flushTo8, flushTo7]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.Add(flushTo8);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Flush_vs_full;
+const flushTo8: string = '3H 6H 7H 8H 5H';
+      full: string = '4S 5H 4S 5D 4H';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([flushTo8, full]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.Add(full);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Two_fulls;
+const fullOf4By9: string = '4H 4S 4D 9S 9D';
+      fullOf5By8: string = '5H 5S 5D 8S 8D';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([fullOf4By9, fullOf5By8]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.Add(fullOf5By8);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Full_vs_square;
+const full: string = '4S 5H 4S 5D 4H';
+      squareOf3: string = '3S 3H 2S 3D 3H';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([squareOf3,full]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.Add(squareOf3);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Two_squares;
+const squareOf2: string = '2S 2H 2S 8D 2H';
+      squareOf5: string = '4S 5H 5S 5D 5H';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([squareOf2, squareOf5]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.Add(squareOf5);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Square_vs_straight_flush;
+const squareOf5: string = '4S 5H 5S 5D 5H';
+      straightFlushTo9: string = '5S 7S 8S 9S 6S';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([squareOf5, straightFlushTo9]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.Add(straightFlushTo9);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Two_straight_flushes;
+const straightFlushTo8: string = '4H 6H 7H 8H 5H';
+      straightFlushTo9: string = '5S 7S 8S 9S 6S';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([straightFlushTo8, straightFlushTo9]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.Add(straightFlushTo9);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Three_hand_with_tie;
+const spadeStraightTo9: string = '9S 8S 7S 6S 5S';
+      diamondStraightTo9: string = '9D 8D 7D 6D 5D';
+      threeOf4: string = '4D 4S 4H QS KS';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([spadeStraightTo9, threeOf4, diamondStraightTo9]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.AddRange([spadeStraightTo9, diamondStraightTo9]);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+procedure PokerTest.Straight_to_5_against_a_pair_of_jacks;
+const straightTo5: string = '2S 4D 5C 3S AS';
+      twoJacks: string = 'JD 8D 7D JC 5D';
+var expectedHands,
+    inputHands: TList<string>;
+    ActualHands: TList<string>;
+    expectedHandsArray,
+    ActualHandsArray: TArray<string>;
+    i: integer;
+begin
+  inputHands := TList<string>.Create;
+  inputHands.AddRange([straightTo5, twoJacks]);
+
+  expectedHands := TList<string>.Create;
+  expectedHands.AddRange(straightTo5);
+
+  ActualHands := Poker.BestHands(inputHands);
+
+  expectedHandsArray := expectedHands.ToArray;
+  ActualHandsArray := ActualHands.ToArray;
+  Assert.AreEqual(expectedHands.Count,ActualHands.Count);
+  for i := Low(expectedHandsArray) to High(expectedHandsArray) do
+    Assert.AreEqual(expectedHandsArray[i], ActualHandsArray[i]);
+end;
+
+
+initialization
+  TDUnitX.RegisterTestFixture(PokerTest);
+end.