text: ﻿namespace Poker.Tests.PokerHandsChecker
  {
      using System;
      using System.Collections.Generic;
      using Microsoft.VisualStudio.TestTools.UnitTesting;
      using Poker.Models;
      using Poker.Models.Enums;
      using Poker.Models.Interfaces;
      using Poker.Models.Utils;
  
      [TestClass]
      public class CompareHandsMethod
      {
          private readonly IPokerHandsChecker pokerHandsChecker = new PokerHandsChecker();
  
          private const int LeftIsBigger = 1;
          private const int RightIsBigger = -1;
  
          #region [Some type of hands - examples]
          
          private readonly IHand handWithNoCards = new Hand(new List<ICard>());
  
          private readonly IHand handWithHighCard = new Hand(new List<ICard>()
          {
              new Card(CardFace.Ace, CardSuit.Spades),
              new Card(CardFace.King, CardSuit.Diamonds),
              new Card(CardFace.Queen, CardSuit.Clubs),
              new Card(CardFace.Ten, CardSuit.Spades),
              new Card(CardFace.Two, CardSuit.Spades),
          });
  
          private readonly IHand handWithOnePair = new Hand(new List<ICard>()
          {
              new Card(CardFace.Two, CardSuit.Clubs),
              new Card(CardFace.Two, CardSuit.Diamonds),
              new Card(CardFace.Seven, CardSuit.Spades),
              new Card(CardFace.Nine, CardSuit.Clubs),
              new Card(CardFace.Ten, CardSuit.Clubs),
          });
  
          private readonly IHand handWithTwoPair = new Hand(new List<ICard>()
          {
              new Card(CardFace.King, CardSuit.Diamonds),
              new Card(CardFace.King, CardSuit.Clubs),
              new Card(CardFace.Nine, CardSuit.Hearts),
              new Card(CardFace.Nine, CardSuit.Diamonds),
              new Card(CardFace.Ace, CardSuit.Spades),
          });
  
          private readonly IHand handWithThreeOfAKind = new Hand(new List<ICard>()
          {
              new Card(CardFace.Three, CardSuit.Clubs),
              new Card(CardFace.Three, CardSuit.Spades),
              new Card(CardFace.Three, CardSuit.Hearts),
              new Card(CardFace.Seven, CardSuit.Clubs),
              new Card(CardFace.Ace, CardSuit.Clubs),
          });
  
          private readonly IHand handWithStraight = new Hand(new List<ICard>()
          {
              new Card(CardFace.Five, CardSuit.Clubs),
              new Card(CardFace.Six, CardSuit.Spades),
              new Card(CardFace.Seven, CardSuit.Diamonds),
              new Card(CardFace.Eight, CardSuit.Spades),
              new Card(CardFace.Nine, CardSuit.Clubs)
          });
  
          private readonly IHand handWithFlush = new Hand(new List<ICard>()
          {
              new Card(CardFace.Ten, CardSuit.Hearts),
              new Card(CardFace.Seven, CardSuit.Hearts),
              new Card(CardFace.Ace, CardSuit.Hearts),
              new Card(CardFace.Two, CardSuit.Hearts),
              new Card(CardFace.Eight, CardSuit.Hearts)
          });
  
          private readonly IHand handWithFullHouse = new Hand(new List<ICard>()
          {
              new Card(CardFace.Four, CardSuit.Clubs),
              new Card(CardFace.Four, CardSuit.Diamonds),
              new Card(CardFace.Four, CardSuit.Hearts),
              new Card(CardFace.King, CardSuit.Hearts),
              new Card(CardFace.King, CardSuit.Spades),
          });
  
          private readonly IHand handWithFourOfAKind = new Hand(new List<ICard>()
          {
              new Card(CardFace.Jack, CardSuit.Clubs),
              new Card(CardFace.Jack, CardSuit.Diamonds),
              new Card(CardFace.Jack, CardSuit.Hearts),
              new Card(CardFace.Jack, CardSuit.Spades),
              new Card(CardFace.Ace, CardSuit.Diamonds),
          });
  
          private readonly IHand handWithStraightFlush = new Hand(new List<ICard>()
          {
              new Card(CardFace.Five, CardSuit.Clubs),
              new Card(CardFace.Six, CardSuit.Clubs),
              new Card(CardFace.Seven, CardSuit.Clubs),
              new Card(CardFace.Eight, CardSuit.Clubs),
              new Card(CardFace.Nine, CardSuit.Clubs)
          });
  
          #endregion 
          
          #region [Tests -> High card vs. other types]
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          [ExpectedException(typeof(InvalidPokerHandException))]
          public void TestOnHighCardАgainstNoCards()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithHighCard, this.handWithNoCards);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnHighCardАgainstOnePair()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithHighCard, this.handWithOnePair);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnHighCardАgainstTwoPair()
          {
              var handWithTwoPair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.King, CardSuit.Spades),
                  new Card(CardFace.King, CardSuit.Clubs),
                  new Card(CardFace.Nine, CardSuit.Hearts),
                  new Card(CardFace.Nine, CardSuit.Diamonds),
                  new Card(CardFace.Ace, CardSuit.Hearts),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithHighCard, handWithTwoPair);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnHighCardАgainstThreeOfAKind()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithHighCard, this.handWithThreeOfAKind);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnHighCardАgainstStraight()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithHighCard, this.handWithStraight);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnHighCardАgainstFlush()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithHighCard, this.handWithFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnHighCardАgainstFullHouse()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithHighCard, this.handWithFullHouse);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnHighCardАgainstFourOfAKind()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithHighCard, this.handWithFourOfAKind);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnHighCardАgainstStraightFlush()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithHighCard, this.handWithStraightFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnHighCardАgainstUpperHighCard_1()
          {
              var handWithUpperHighCard = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Ace, CardSuit.Diamonds),
                  new Card(CardFace.King, CardSuit.Spades),
                  new Card(CardFace.Queen, CardSuit.Spades),
                  new Card(CardFace.Jack, CardSuit.Diamonds),
                  new Card(CardFace.Three, CardSuit.Spades),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithHighCard, handWithUpperHighCard);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnHighCardАgainstUpperHighCard_2()
          {
              var handWithUpperHighCard = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Ace, CardSuit.Diamonds),
                  new Card(CardFace.Ten, CardSuit.Diamonds),
                  new Card(CardFace.Nine, CardSuit.Spades),
                  new Card(CardFace.Five, CardSuit.Clubs),
                  new Card(CardFace.Four, CardSuit.Clubs),
              });
  
              var handWithLowerHighCard = new Hand(new List<ICard>()
              {
                  new Card(CardFace.King, CardSuit.Clubs),
                  new Card(CardFace.Queen, CardSuit.Diamonds),
                  new Card(CardFace.Jack, CardSuit.Clubs),
                  new Card(CardFace.Eight, CardSuit.Hearts),
                  new Card(CardFace.Seven, CardSuit.Hearts),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithLowerHighCard, handWithUpperHighCard);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnHighCardАgainstUpperHighCard_3()
          {
              var handWithUpperHighCard = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Ace, CardSuit.Clubs),
                  new Card(CardFace.Queen, CardSuit.Clubs),
                  new Card(CardFace.Seven, CardSuit.Diamonds),
                  new Card(CardFace.Five, CardSuit.Hearts),
                  new Card(CardFace.Two, CardSuit.Clubs),
              });
  
              var handWithLowerHighCard = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Ace, CardSuit.Diamonds),
                  new Card(CardFace.Ten, CardSuit.Diamonds),
                  new Card(CardFace.Nine, CardSuit.Spades),
                  new Card(CardFace.Five, CardSuit.Clubs),
                  new Card(CardFace.Four, CardSuit.Clubs),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithUpperHighCard, handWithLowerHighCard);
              Assert.AreEqual(LeftIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnHighCardАgainstLowerHighCard()
          {
              var handWithLowerHighCard = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Three, CardSuit.Hearts),
                  new Card(CardFace.King, CardSuit.Spades),
                  new Card(CardFace.Queen, CardSuit.Hearts),
                  new Card(CardFace.Ten, CardSuit.Hearts),
                  new Card(CardFace.Eight, CardSuit.Spades),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithHighCard, handWithLowerHighCard);
              Assert.AreEqual(LeftIsBigger, actual);
          }
  
          #endregion
  
          #region [Tests -> One pair vs. other types]
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          [ExpectedException(typeof(InvalidPokerHandException))]
          public void TestOnOnePairАgainstNoCards()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithOnePair, this.handWithNoCards);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnOnePairAgainstHighCard()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithOnePair, this.handWithHighCard);
              Assert.AreEqual(LeftIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnOnePairАgainstTwoPair()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithOnePair, this.handWithTwoPair);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnOnePairАgainstThreeOfAKind()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithOnePair, this.handWithThreeOfAKind);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnOnePairАgainstStraight()
          {
              var handWithOnePair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Two, CardSuit.Clubs),
                  new Card(CardFace.Two, CardSuit.Diamonds),
                  new Card(CardFace.Seven, CardSuit.Spades),
                  new Card(CardFace.Nine, CardSuit.Diamonds),
                  new Card(CardFace.Ten, CardSuit.Clubs),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithOnePair, this.handWithStraight);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnOnePairАgainstFlush()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithOnePair, this.handWithFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnOnePairАgainstFullHouse()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithOnePair, this.handWithFullHouse);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnOnePairАgainstFourOfAKind()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithOnePair, this.handWithFourOfAKind);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnOnePairАgainstStraightFlush()
          {
              var handWithOnePair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Two, CardSuit.Clubs),
                  new Card(CardFace.Two, CardSuit.Diamonds),
                  new Card(CardFace.Seven, CardSuit.Spades),
                  new Card(CardFace.Nine, CardSuit.Diamonds),
                  new Card(CardFace.Ten, CardSuit.Clubs),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithOnePair, this.handWithStraightFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnOnePairАgainstUpperOnePair_1()
          {
              var handWithUpperOnePair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.King, CardSuit.Spades),
                  new Card(CardFace.King, CardSuit.Hearts),
                  new Card(CardFace.Seven, CardSuit.Hearts),
                  new Card(CardFace.Nine, CardSuit.Diamonds),
                  new Card(CardFace.Queen, CardSuit.Clubs),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithOnePair, handWithUpperOnePair);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnOnePairАgainstUpperOnePair_2()
          {
              var handWithUpperOnePair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Ten, CardSuit.Clubs),
                  new Card(CardFace.Ten, CardSuit.Spades),
                  new Card(CardFace.Six, CardSuit.Spades),
                  new Card(CardFace.Four, CardSuit.Hearts),
                  new Card(CardFace.Two, CardSuit.Hearts),
              });
  
              var handWithLowerOnePair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Nine, CardSuit.Hearts),
                  new Card(CardFace.Nine, CardSuit.Clubs),
                  new Card(CardFace.Ace, CardSuit.Hearts),
                  new Card(CardFace.Queen, CardSuit.Diamonds),
                  new Card(CardFace.Ten, CardSuit.Diamonds),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithLowerOnePair, handWithUpperOnePair);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnOnePairАgainstUpperOnePair_3()
          {
              var handWithUpperOnePair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Two, CardSuit.Diamonds),
                  new Card(CardFace.Two, CardSuit.Hearts),
                  new Card(CardFace.Eight, CardSuit.Spades),
                  new Card(CardFace.Five, CardSuit.Clubs),
                  new Card(CardFace.Four, CardSuit.Clubs),
              });
  
              var handWithLowerOnePair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Two, CardSuit.Clubs),
                  new Card(CardFace.Two, CardSuit.Spades),
                  new Card(CardFace.Eight, CardSuit.Clubs),
                  new Card(CardFace.Five, CardSuit.Hearts),
                  new Card(CardFace.Three, CardSuit.Hearts),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithUpperOnePair, handWithLowerOnePair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnOnePairАgainstLowerOnePair()
          {
              var handWithUpperOnePair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.King, CardSuit.Hearts),
                  new Card(CardFace.King, CardSuit.Spades),
                  new Card(CardFace.Seven, CardSuit.Hearts),
                  new Card(CardFace.Nine, CardSuit.Diamonds),
                  new Card(CardFace.Ten, CardSuit.Clubs)
              });
  
              var handWithLowerOnePair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.King, CardSuit.Clubs),
                  new Card(CardFace.King, CardSuit.Diamonds),
                  new Card(CardFace.Six, CardSuit.Hearts),
                  new Card(CardFace.Nine, CardSuit.Spades),
                  new Card(CardFace.Ten, CardSuit.Hearts)
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithUpperOnePair, handWithLowerOnePair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
  
          #endregion
  
          #region [Tests -> Two pair vs. other types]
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          [ExpectedException(typeof(InvalidPokerHandException))]
          public void TestOnTwoPairАgainstNoCards()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithTwoPair, this.handWithNoCards);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnTwoPairAgainstHighCard()
          {
              var handWithTwoPair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.King, CardSuit.Spades),
                  new Card(CardFace.King, CardSuit.Clubs),
                  new Card(CardFace.Nine, CardSuit.Hearts),
                  new Card(CardFace.Nine, CardSuit.Diamonds),
                  new Card(CardFace.Ace, CardSuit.Hearts),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithTwoPair, this.handWithHighCard);
              Assert.AreEqual(LeftIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnTwoPairAgainstOnePair()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithTwoPair, this.handWithOnePair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnTwoPairАgainstThreeOfAKind()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithTwoPair, this.handWithThreeOfAKind);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnTwoPairАgainstStraight()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithTwoPair, this.handWithStraight);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnTwoPairАgainstFlush()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithTwoPair, this.handWithFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnTwoPairАgainstFullHouse()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithTwoPair, this.handWithFullHouse);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnTwoPairАgainstFourOfAKind()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithTwoPair, this.handWithFourOfAKind);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnTwoPairАgainstStraightFlush()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithTwoPair, this.handWithStraightFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnTwoPairАgainstUpperTwoPair_1()
          {
              var handWithUpperTwoPair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Ace, CardSuit.Diamonds),
                  new Card(CardFace.Ace, CardSuit.Clubs),
                  new Card(CardFace.Nine, CardSuit.Spades),
                  new Card(CardFace.Nine, CardSuit.Clubs),
                  new Card(CardFace.Seven, CardSuit.Spades),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithTwoPair, handWithUpperTwoPair);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnTwoPairАgainstUpperTwoPair_2()
          {
              var handWithUpperTwoPair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.King, CardSuit.Hearts),
                  new Card(CardFace.King, CardSuit.Diamonds),
                  new Card(CardFace.Two, CardSuit.Clubs),
                  new Card(CardFace.Two, CardSuit.Diamonds),
                  new Card(CardFace.Jack, CardSuit.Hearts),
              });
  
              var handWithLowerTwoPair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Jack, CardSuit.Diamonds),
                  new Card(CardFace.Jack, CardSuit.Spades),
                  new Card(CardFace.Ten, CardSuit.Spades),
                  new Card(CardFace.Ten, CardSuit.Clubs),
                  new Card(CardFace.Nine, CardSuit.Spades),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithLowerTwoPair, handWithUpperTwoPair);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnTwoPairАgainstUpperTwoPair_3()
          {
              var handWithUpperTwoPair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Nine, CardSuit.Clubs),
                  new Card(CardFace.Nine, CardSuit.Diamonds),
                  new Card(CardFace.Five, CardSuit.Diamonds),
                  new Card(CardFace.Five, CardSuit.Spades),
                  new Card(CardFace.King, CardSuit.Hearts),
              });
  
              var handWithLowerTwoPair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Four, CardSuit.Hearts),
                  new Card(CardFace.Four, CardSuit.Spades),
                  new Card(CardFace.Three, CardSuit.Hearts),
                  new Card(CardFace.Three, CardSuit.Diamonds),
                  new Card(CardFace.King, CardSuit.Clubs),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithUpperTwoPair, handWithLowerTwoPair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnTwoPairАgainstUpperTwoPair_4()
          {
              var handWithUpperTwoPair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Five, CardSuit.Diamonds),
                  new Card(CardFace.Five, CardSuit.Spades),
                  new Card(CardFace.Nine, CardSuit.Clubs),
                  new Card(CardFace.Nine, CardSuit.Diamonds),
                  new Card(CardFace.King, CardSuit.Hearts),
              });
  
              var handWithLowerTwoPair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Six, CardSuit.Hearts),
                  new Card(CardFace.Six, CardSuit.Spades),
                  new Card(CardFace.Three, CardSuit.Hearts),
                  new Card(CardFace.Three, CardSuit.Diamonds),
                  new Card(CardFace.King, CardSuit.Clubs),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithUpperTwoPair, handWithLowerTwoPair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnTwoPairАgainstLowerTwoPair()
          {
              var handWithUpperTwoPair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Four, CardSuit.Spades),
                  new Card(CardFace.Four, CardSuit.Clubs),
                  new Card(CardFace.Three, CardSuit.Spades),
                  new Card(CardFace.Three, CardSuit.Hearts),
                  new Card(CardFace.King, CardSuit.Diamonds)
              });
  
              var handWithLowerTwoPair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Four, CardSuit.Hearts),
                  new Card(CardFace.Four, CardSuit.Diamonds),
                  new Card(CardFace.Three, CardSuit.Diamonds),
                  new Card(CardFace.Three, CardSuit.Clubs),
                  new Card(CardFace.Ten, CardSuit.Spades)
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithUpperTwoPair, handWithLowerTwoPair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          #endregion
  
          #region [Tests -> Three of a kind vs. other types]
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          [ExpectedException(typeof(InvalidPokerHandException))]
          public void TestOnThreeOfAKindАgainstNoCards()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithThreeOfAKind, this.handWithNoCards);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnThreeOfAKindAgainstHighCard()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithThreeOfAKind, this.handWithHighCard);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnThreeOfAKindAgainstOnePair()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithThreeOfAKind, this.handWithOnePair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnThreeOfAKindАgainstTwoPair()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithThreeOfAKind, this.handWithTwoPair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnThreeOfAKindАgainstStraight()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithThreeOfAKind, this.handWithStraight);
              Assert.AreEqual(RightIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnThreeOfAKindАgainstFlush()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithThreeOfAKind, this.handWithFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnThreeOfAKindАgainstFullHouse()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithThreeOfAKind, this.handWithFullHouse);
              Assert.AreEqual(RightIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnThreeOfAKindАgainstFourOfAKind()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithThreeOfAKind, this.handWithFourOfAKind);
              Assert.AreEqual(RightIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnThreeOfAKindАgainstStraightFlush()
          {
              var handWithThreeOfAKind = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Seven, CardSuit.Spades),
                  new Card(CardFace.Seven, CardSuit.Diamonds),
                  new Card(CardFace.Seven, CardSuit.Hearts),
                  new Card(CardFace.Eight, CardSuit.Diamonds),
                  new Card(CardFace.Ace, CardSuit.Spades),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithThreeOfAKind, this.handWithStraightFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnThreeOfAKindАgainstUpperThreeOfAKind()
          {
              var handWithUpperThreeOfAKind = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Seven, CardSuit.Spades),
                  new Card(CardFace.Seven, CardSuit.Diamonds),
                  new Card(CardFace.Seven, CardSuit.Hearts),
                  new Card(CardFace.Eight, CardSuit.Diamonds),
                  new Card(CardFace.Ace, CardSuit.Spades),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithThreeOfAKind, handWithUpperThreeOfAKind);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnThreeOfAKindАgainstLowerThreeOfAKind()
          {
              var handWithLowerThreeOfAKind = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Two, CardSuit.Clubs),
                  new Card(CardFace.Two, CardSuit.Diamonds),
                  new Card(CardFace.Two, CardSuit.Hearts),
                  new Card(CardFace.Seven, CardSuit.Diamonds),
                  new Card(CardFace.Ace, CardSuit.Spades),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithThreeOfAKind, handWithLowerThreeOfAKind);
              Assert.AreEqual(LeftIsBigger, actual);
          }
  
          #endregion
          
          #region [Tests -> Straight vs. other types]
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          [ExpectedException(typeof(InvalidPokerHandException))]
          public void TestOnStraightАgainstNoCards()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraight, this.handWithNoCards);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightAgainstHighCard()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraight, this.handWithHighCard);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightAgainstOnePair()
          {
              var handWithStraight = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Five, CardSuit.Diamonds),
                  new Card(CardFace.Six, CardSuit.Spades),
                  new Card(CardFace.Seven, CardSuit.Diamonds),
                  new Card(CardFace.Eight, CardSuit.Spades),
                  new Card(CardFace.Nine, CardSuit.Hearts)
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithStraight, this.handWithOnePair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightАgainstTwoPair()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraight, this.handWithTwoPair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightАgainstThreeOfAKind()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraight, this.handWithThreeOfAKind);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightАgainstFlush()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraight, this.handWithFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightАgainstFullHouse()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraight, this.handWithFullHouse);
              Assert.AreEqual(RightIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightАgainstFourOfAKind()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraight, this.handWithFourOfAKind);
              Assert.AreEqual(RightIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightАgainstStraightFlush()
          {
              var handWithStraight = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Five, CardSuit.Diamonds),
                  new Card(CardFace.Six, CardSuit.Spades),
                  new Card(CardFace.Seven, CardSuit.Diamonds),
                  new Card(CardFace.Eight, CardSuit.Spades),
                  new Card(CardFace.Nine, CardSuit.Hearts)
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithStraight, this.handWithStraightFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightАgainstUpperStraight()
          {
              var handWithUpperStraight = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Six, CardSuit.Diamonds),
                  new Card(CardFace.Seven, CardSuit.Hearts),
                  new Card(CardFace.Eight, CardSuit.Diamonds),
                  new Card(CardFace.Nine, CardSuit.Spades),
                  new Card(CardFace.Ten, CardSuit.Clubs)
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraight, handWithUpperStraight);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightАgainstLowerStraight()
          {
              var handWithLowerStraight = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Four, CardSuit.Diamonds),
                  new Card(CardFace.Five, CardSuit.Hearts),
                  new Card(CardFace.Six, CardSuit.Diamonds),
                  new Card(CardFace.Seven, CardSuit.Clubs),
                  new Card(CardFace.Eight, CardSuit.Clubs)
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraight, handWithLowerStraight);
              Assert.AreEqual(LeftIsBigger, actual);
          }
  
          #endregion
          
          #region [Tests -> Flush vs. other types]
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          [ExpectedException(typeof(InvalidPokerHandException))]
          public void TestOnFlushАgainstNoCards()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFlush, this.handWithNoCards);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFlushAgainstHighCard()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFlush, this.handWithHighCard);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFlushAgainstOnePair()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFlush, this.handWithOnePair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFlushАgainstTwoPair()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFlush, this.handWithTwoPair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFlushАgainstThreeOfAKind()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFlush, this.handWithThreeOfAKind);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFlushАgainstStraight()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFlush, this.handWithStraight);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFlushАgainstFullHouse()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFlush, this.handWithFullHouse);
              Assert.AreEqual(RightIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFlushАgainstFourOfAKind()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFlush, this.handWithFourOfAKind);
              Assert.AreEqual(RightIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFlushАgainstStraightFlush()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFlush, this.handWithStraightFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFlushАgainstUpperFlush_1()
          {
              var handWithUpperFlush = new Hand(new List<ICard>()
              {
                  new Card(CardFace.King, CardSuit.Spades),
                  new Card(CardFace.Seven, CardSuit.Spades),
                  new Card(CardFace.Ace, CardSuit.Spades),
                  new Card(CardFace.Two, CardSuit.Spades),
                  new Card(CardFace.Eight, CardSuit.Spades)
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFlush, handWithUpperFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFlushАgainstUpperFlush_2()
          {
              var handWithUpperFlush = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Ace, CardSuit.Hearts),
                  new Card(CardFace.Queen, CardSuit.Hearts),
                  new Card(CardFace.Ten, CardSuit.Hearts),
                  new Card(CardFace.Five, CardSuit.Hearts),
                  new Card(CardFace.Three, CardSuit.Hearts)
              });
  
              var handWithLowerFlush = new Hand(new List<ICard>()
              {
                  new Card(CardFace.King, CardSuit.Spades),
                  new Card(CardFace.Queen, CardSuit.Spades),
                  new Card(CardFace.Jack, CardSuit.Spades),
                  new Card(CardFace.Nine, CardSuit.Spades),
                  new Card(CardFace.Six, CardSuit.Spades)
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithLowerFlush, handWithUpperFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFlushАgainstUpperFlush_3()
          {
              var handWithUpperFlush = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Ace, CardSuit.Diamonds),
                  new Card(CardFace.King, CardSuit.Diamonds),
                  new Card(CardFace.Seven, CardSuit.Diamonds),
                  new Card(CardFace.Six, CardSuit.Diamonds),
                  new Card(CardFace.Two, CardSuit.Diamonds)
              });
  
              var handWithLowerFlush = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Ace, CardSuit.Hearts),
                  new Card(CardFace.Queen, CardSuit.Hearts),
                  new Card(CardFace.Ten, CardSuit.Hearts),
                  new Card(CardFace.Five, CardSuit.Hearts),
                  new Card(CardFace.Three, CardSuit.Hearts)
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithUpperFlush, handWithLowerFlush);
              Assert.AreEqual(LeftIsBigger, actual);
          }
  
          #endregion
          
          #region [Tests -> Full House vs. other types]
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          [ExpectedException(typeof(InvalidPokerHandException))]
          public void TestOnFullHouseАgainstNoCards()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFullHouse, this.handWithNoCards);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFullHouseAgainstHighCard()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFullHouse, this.handWithHighCard);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFullHouseAgainstOnePair()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFullHouse, this.handWithOnePair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFullHouseАgainstTwoPair()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFullHouse, this.handWithTwoPair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFullHouseАgainstThreeOfAKind()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFullHouse, this.handWithThreeOfAKind);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFullHouseАgainstStraight()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFullHouse, this.handWithStraight);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFullHouseАgainstFlush()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFullHouse, this.handWithFlush);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFullHouseАgainstFourOfAKind()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFullHouse, this.handWithFourOfAKind);
              Assert.AreEqual(RightIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFullHouseАgainstStraightFlush()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFullHouse, this.handWithStraightFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFullHouseАgainstUpperFullHouse()
          {
              var handWithUpperFullHouse = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Seven, CardSuit.Clubs),
                  new Card(CardFace.Seven, CardSuit.Diamonds),
                  new Card(CardFace.Seven, CardSuit.Hearts),
                  new Card(CardFace.King, CardSuit.Diamonds),
                  new Card(CardFace.King, CardSuit.Clubs),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFullHouse, handWithUpperFullHouse);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFullHouseАgainstLowerFullHouse()
          {
              var handWithUpperFullHouse = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Three, CardSuit.Clubs),
                  new Card(CardFace.Three, CardSuit.Diamonds),
                  new Card(CardFace.Three, CardSuit.Hearts),
                  new Card(CardFace.King, CardSuit.Diamonds),
                  new Card(CardFace.King, CardSuit.Clubs),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFullHouse, handWithUpperFullHouse);
              Assert.AreEqual(LeftIsBigger, actual);
          }
  
          #endregion
          
          #region [Tests -> Four of a kind vs. other types]
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          [ExpectedException(typeof(InvalidPokerHandException))]
          public void TestOnFourOfAKindАgainstNoCards()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFourOfAKind, this.handWithNoCards);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFourOfAKindAgainstHighCard()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFourOfAKind, this.handWithHighCard);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFourOfAKindAgainstOnePair()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFourOfAKind, this.handWithOnePair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFourOfAKindАgainstTwoPair()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFourOfAKind, this.handWithTwoPair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFourOfAKindАgainstThreeOfAKind()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFourOfAKind, this.handWithThreeOfAKind);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFourOfAKindАgainstStraight()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFourOfAKind, this.handWithStraight);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFourOfAKindАgainstFlush()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFourOfAKind, this.handWithFlush);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFourOfAKindАgainstFullHouse()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFourOfAKind, this.handWithFullHouse);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFourOfAKindАgainstStraightFlush()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFourOfAKind, this.handWithStraightFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFourOfAKindАgainstUpperFourOfAKind()
          {
              var handWithUpperFourOfAKind = new Hand(new List<ICard>()
              {
                  new Card(CardFace.King, CardSuit.Clubs),
                  new Card(CardFace.King, CardSuit.Diamonds),
                  new Card(CardFace.King, CardSuit.Hearts),
                  new Card(CardFace.King, CardSuit.Spades),
                  new Card(CardFace.Ace, CardSuit.Clubs),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFourOfAKind, handWithUpperFourOfAKind);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnFourOfAKindАgainstLowerFourOfAKind()
          {
              var handWithLowerFourOfAKind = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Five, CardSuit.Clubs),
                  new Card(CardFace.Five, CardSuit.Diamonds),
                  new Card(CardFace.Five, CardSuit.Hearts),
                  new Card(CardFace.Five, CardSuit.Spades),
                  new Card(CardFace.Ace, CardSuit.Clubs),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithFourOfAKind, handWithLowerFourOfAKind);
              Assert.AreEqual(LeftIsBigger, actual);
          }
  
          #endregion
          
          #region [Tests -> Straight Flush vs. other types]
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          [ExpectedException(typeof(InvalidPokerHandException))]
          public void TestOnStraightFlushАgainstNoCards()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraightFlush, this.handWithNoCards);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightFlushAgainstHighCard()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraightFlush, this.handWithHighCard);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightFlushAgainstOnePair()
          {
              var handWithOnePair = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Two, CardSuit.Diamonds),
                  new Card(CardFace.Two, CardSuit.Hearts),
                  new Card(CardFace.Seven, CardSuit.Hearts),
                  new Card(CardFace.Nine, CardSuit.Hearts),
                  new Card(CardFace.Ten, CardSuit.Hearts),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraightFlush, handWithOnePair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightFlushАgainstTwoPair()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraightFlush, this.handWithTwoPair);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightFlushАgainstThreeOfAKind()
          {
              var handWithStraightFlush = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Six, CardSuit.Spades),
                  new Card(CardFace.Seven, CardSuit.Spades),
                  new Card(CardFace.Eight, CardSuit.Spades),
                  new Card(CardFace.Nine, CardSuit.Spades),
                  new Card(CardFace.Ten, CardSuit.Spades)
              });
  
              var actual = this.pokerHandsChecker.CompareHands(handWithStraightFlush, this.handWithThreeOfAKind);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightFlushАgainstStraight()
          {
              var handWithStraight = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Five, CardSuit.Diamonds),
                  new Card(CardFace.Six, CardSuit.Spades),
                  new Card(CardFace.Seven, CardSuit.Diamonds),
                  new Card(CardFace.Eight, CardSuit.Spades),
                  new Card(CardFace.Nine, CardSuit.Spades)
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraightFlush, handWithStraight);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightFlushАgainstFlush()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraightFlush, this.handWithFlush);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightFlushАgainstFullHouse()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraightFlush, this.handWithFullHouse);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightFlushАgainstFourOfAKind()
          {
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraightFlush, this.handWithFourOfAKind);
              Assert.AreEqual(LeftIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightFlushАgainstUpperStraightFlush()
          {
              var handWithUpperStraightFlush = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Six, CardSuit.Spades),
                  new Card(CardFace.Seven, CardSuit.Spades),
                  new Card(CardFace.Eight, CardSuit.Spades),
                  new Card(CardFace.Nine, CardSuit.Spades),
                  new Card(CardFace.Ten, CardSuit.Spades)
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraightFlush, handWithUpperStraightFlush);
              Assert.AreEqual(RightIsBigger, actual);
          }
  
          [TestMethod]
          [Description("Test on PokerHandsChecker.cs")]
          public void TestOnStraightFlushАgainstLowerStraightFlush()
          {
              var handWithLowerStraightFlush = new Hand(new List<ICard>()
              {
                  new Card(CardFace.Four, CardSuit.Diamonds),
                  new Card(CardFace.Five, CardSuit.Diamonds),
                  new Card(CardFace.Six, CardSuit.Diamonds),
                  new Card(CardFace.Seven, CardSuit.Diamonds),
                  new Card(CardFace.Eight, CardSuit.Diamonds),
              });
  
              var actual = this.pokerHandsChecker.CompareHands(this.handWithStraightFlush, handWithLowerStraightFlush);
              Assert.AreEqual(LeftIsBigger, actual);
          }
          
          #endregion
      }
  }