public void TryBuildTest(string testFolder)
        {
            var packages = ReadPackages(testFolder);

            CollectionAssert.IsNotEmpty(packages, $"Packages collection must be not empty for {testFolder}");

            var handBuilder = new PPPHandBuilder();

            HandHistory actual = null;

            if (testFolder == NlheSngTest)
            {
                using (ShimsContext.Create())
                {
                    ShimDateTime.UtcNowGet = () => new DateTime(2018, 10, 11, 17, 07, 14);

                    Build(handBuilder, packages, out actual);
                }
            }
            else
            {
                Build(handBuilder, packages, out actual);
            }


            Assert.IsNotNull(actual, $"Actual HandHistory must be not null for {testFolder}");

            var expected = ReadExpectedHandHistory(testFolder);

            Assert.IsNotNull(expected, $"Expected HandHistory must be not null for {testFolder}");

            AssertionUtils.AssertHandHistory(actual, expected);
        }
        private void Build(PPPHandBuilder builder, IEnumerable <PPPokerPackage> packages, out HandHistory history)
        {
            history = null;

            foreach (var package in packages)
            {
                if (builder.TryBuild(package, out history))
                {
                    break;
                }
            }
        }
        public void MultipleTryBuildTest(string folder)
        {
            var testFolder = Path.Combine(TestDataFolder, folder);

            DirectoryAssert.Exists(testFolder);

            var logFiles = Directory.GetFiles(testFolder, "*.txt");

            var capturedPackets = new List <CapturedPacket>();

            foreach (var logFile in logFiles)
            {
                capturedPackets.AddRange(TcpImporterTestUtils.ReadCapturedPackets(logFile, null));
            }

            capturedPackets = capturedPackets.OrderBy(x => x.CreatedTimeStamp).ToList();

            var handHistories = new List <HandHistory>();

            var packetManager    = new PPPokerPacketManager();
            var handBuilder      = new PPPHandBuilder();
            var debugPPPImporter = new DebugPPPImporter();

            foreach (var capturedPacket in capturedPackets)
            {
                if (!packetManager.TryParse(capturedPacket, out IList <PPPokerPackage> packages))
                {
                    continue;
                }

                foreach (var package in packages)
                {
                    if (!PPPImporterStub.IsAllowedPackage(package))
                    {
                        continue;
                    }

                    package.Timestamp = capturedPacket.CreatedTimeStamp;

                    debugPPPImporter.LogPackage(capturedPacket, package);

                    if (handBuilder.TryBuild(package, out HandHistory handHistory))
                    {
                        handHistories.Add(handHistory);
                        LogProvider.Log.Info($"Hand #{handHistory.HandId} has been sent. [{package.ClientPort}]");
                    }
                }
            }

            WriteHandHistoriesToFile(handHistories);

            Assert.IsTrue(handHistories.Count > 0);
        }