public void Client_v7_10_0()
        {
            const int slotId = 0;

            _dataAggregator.ClientName = "Client_v7_10";

            var fahLog = FahClientLog.Read("..\\..\\..\\TestFiles\\Client_v7_10\\log.txt");

            string message        = File.ReadAllText("..\\..\\..\\TestFiles\\Client_v7_10\\units.txt");
            var    unitCollection = new UnitCollection();

            unitCollection.Fill(JsonMessageConnection.GetNextJsonMessage(ref message));

            message = File.ReadAllText("..\\..\\..\\TestFiles\\Client_v7_10\\info.txt");
            var info = new Info();

            info.Fill(JsonMessageConnection.GetNextJsonMessage(ref message));

            message = File.ReadAllText("..\\..\\..\\TestFiles\\Client_v7_10\\options.txt");
            var options = new Options();

            options.Fill(JsonMessageConnection.GetNextJsonMessage(ref message));

            message = File.ReadAllText("..\\..\\..\\TestFiles\\Client_v7_10\\slot-options1.txt");
            var slotOptions = new SlotOptions();

            slotOptions.Fill(JsonMessageConnection.GetNextJsonMessage(ref message));

            var result = _dataAggregator.AggregateData(fahLog.ClientRuns.Last(), unitCollection, info, options, slotOptions, new UnitInfo(), slotId);

            Assert.AreEqual(1, result.UnitInfos.Count);
            Assert.IsFalse(result.UnitInfos.Any(x => x.Value == null));

            #region Check Data Aggregator

            Assert.IsNotNull(result.Queue);
            Assert.AreEqual(1, result.CurrentUnitIndex);
            Assert.AreEqual(new DateTime(2012, 1, 11, 3, 24, 22), result.StartTime);
            Assert.AreEqual(null, result.Arguments);
            Assert.AreEqual(null, result.ClientVersion);
            Assert.AreEqual(null, result.UserID);
            Assert.AreEqual(0, result.MachineID);
            Assert.AreEqual(SlotStatus.Unknown, result.Status);
            Assert.IsNotNull(result.CurrentLogLines);
            Assert.IsFalse(result.UnitInfos.Any(x => x.Value.LogLines == null));
            if (result.UnitInfos.ContainsKey(result.CurrentUnitIndex))
            {
                Assert.AreEqual(result.CurrentLogLines, result.UnitInfos[result.CurrentUnitIndex].LogLines);
            }

            #endregion

            var unitInfoData = result.UnitInfos[result.CurrentUnitIndex];

            #region Check Unit Info Data Values
            Assert.AreEqual(null, unitInfoData.OwningSlotName);
            Assert.AreEqual(null, unitInfoData.OwningClientName);
            Assert.AreEqual(null, unitInfoData.OwningClientPath);
            Assert.AreEqual(-1, unitInfoData.OwningSlotId);
            Assert.AreEqual(DateTime.MinValue, unitInfoData.UnitRetrievalTime);
            Assert.AreEqual("harlam357", unitInfoData.FoldingID);
            Assert.AreEqual(32, unitInfoData.Team);
            Assert.AreEqual(SlotType.CPU, unitInfoData.SlotType);
            Assert.AreEqual(new DateTime(2012, 1, 10, 23, 20, 27), unitInfoData.DownloadTime);
            Assert.AreEqual(new DateTime(2012, 1, 22, 16, 22, 51), unitInfoData.DueTime);
            Assert.AreEqual(new TimeSpan(3, 25, 32), unitInfoData.UnitStartTimeStamp);
            Assert.AreEqual(DateTime.MinValue, unitInfoData.FinishedTime);
            Assert.AreEqual(2.27f, unitInfoData.CoreVersion);
            Assert.AreEqual(7610, unitInfoData.ProjectID);
            Assert.AreEqual(630, unitInfoData.ProjectRun);
            Assert.AreEqual(0, unitInfoData.ProjectClone);
            Assert.AreEqual(59, unitInfoData.ProjectGen);
            Assert.AreEqual(String.Empty, unitInfoData.ProteinName);
            Assert.AreEqual(String.Empty, unitInfoData.ProteinTag);
            Assert.AreEqual(WorkUnitResult.Unknown, unitInfoData.UnitResult);
            Assert.AreEqual(10, unitInfoData.FramesObserved);
            Assert.AreEqual(33, unitInfoData.CurrentFrame.ID);
            Assert.AreEqual(660000, unitInfoData.CurrentFrame.RawFramesComplete);
            Assert.AreEqual(2000000, unitInfoData.CurrentFrame.RawFramesTotal);
            Assert.AreEqual(new TimeSpan(4, 46, 8), unitInfoData.CurrentFrame.TimeStamp);
            Assert.AreEqual(new TimeSpan(0, 8, 31), unitInfoData.CurrentFrame.Duration);
            Assert.AreEqual("A4", unitInfoData.CoreID);
            #endregion
        }
        private void Process()
        {
            var sw = Stopwatch.StartNew();

            // Set successful Last Retrieval Time
            LastRetrievalTime = DateTime.Now;

            var options = _messages.Options;
            var info    = _messages.Info;

            _slotsLock.EnterReadLock();
            try
            {
                foreach (var slotModel in _slots)
                {
                    // Re-Init Slot Level Members Before Processing
                    slotModel.Initialize();

                    // Run the Aggregator
                    var dataAggregator = new FahClientDataAggregator {
                        Logger = Logger
                    };
                    dataAggregator.ClientName = slotModel.Name;
                    DataAggregatorResult result = dataAggregator.AggregateData(_fahLog.ClientRuns.LastOrDefault(),
                                                                               _messages.UnitCollection,
                                                                               info,
                                                                               options,
                                                                               slotModel.SlotOptions,
                                                                               slotModel.UnitInfo,
                                                                               slotModel.SlotId);
                    PopulateRunLevelData(result, info, slotModel);

                    slotModel.Queue           = result.Queue;
                    slotModel.CurrentLogLines = result.CurrentLogLines;
                    //slotModel.UnitLogLines = result.UnitLogLines;

                    var parsedUnits = new Dictionary <int, UnitInfoModel>(result.UnitInfos.Count);
                    foreach (int key in result.UnitInfos.Keys)
                    {
                        if (result.UnitInfos[key] != null)
                        {
                            parsedUnits[key] = BuildUnitInfoLogic(slotModel, result.UnitInfos[key]);
                        }
                    }

                    // *** THIS HAS TO BE DONE BEFORE UPDATING SlotModel.UnitInfoLogic ***
                    UpdateBenchmarkData(slotModel.UnitInfoModel, parsedUnits.Values, result.CurrentUnitIndex);

                    // Update the UnitInfoLogic if we have a current unit index
                    if (result.CurrentUnitIndex != -1 && parsedUnits.ContainsKey(result.CurrentUnitIndex))
                    {
                        slotModel.UnitInfoModel = parsedUnits[result.CurrentUnitIndex];
                    }

                    SetSlotStatus(slotModel);

                    slotModel.UnitInfoModel.ShowProductionTrace(Logger, slotModel.Name, slotModel.Status,
                                                                Prefs.Get <PpdCalculationType>(Preference.PpdCalculation),
                                                                Prefs.Get <BonusCalculationType>(Preference.BonusCalculation));

                    string statusMessage = String.Format(CultureInfo.CurrentCulture, "Slot Status: {0}", slotModel.Status);
                    Logger.InfoFormat(Constants.ClientNameFormat, slotModel.Name, statusMessage);
                }
            }
            finally
            {
                _slotsLock.ExitReadLock();
            }

            string message = String.Format(CultureInfo.CurrentCulture, "Retrieval finished: {0}", sw.GetExecTime());

            Logger.InfoFormat(Constants.ClientNameFormat, Settings.Name, message);
        }