public virtual bool SubmitRun(
            IRun run,
            string username, string password, 
            Func<Image> screenShotFunction = null,
            bool attachSplits = false,
            TimingMethod method = TimingMethod.RealTime,
            string gameId = "", string categoryId = "",
            string version = "", string comment = "",
            string video = "",
            params string[] additionalParams)
        {
            try
            {
                if (attachSplits)
                    comment += " " + SplitsIO.Instance.Share(run, screenShotFunction);
                if (gameId == string.Empty)
                    gameId = GetGameIdByName(run.GameName);
                if (categoryId == string.Empty)
                    categoryId = GetCategoryIdByName(gameId, run.CategoryName);
                var json = ASUP.SubmitRun(run, username, password, gameId, categoryId, version, comment, video, additionalParams);
                return json.result == "success";
            }
            catch (Exception e)
            {
                Log.Error(e);

                return false;
            }
        }

        public void Save(IRun run, Stream stream)
        {
            var regularTimeFormatter = new RegularTimeFormatter(TimeAccuracy.Hundredths);
            var shortTimeFormatter = new ShortTimeFormatter();

            var writer = new StreamWriter(stream);

            if (!string.IsNullOrEmpty(run.GameName))
            {
                writer.Write(Escape(run.GameName));

                if (!string.IsNullOrEmpty(run.CategoryName))
                    writer.Write(" - ");
            }

            writer.Write(Escape(run.CategoryName));
            writer.Write(',');
            writer.WriteLine(Escape(run.AttemptCount.ToString()));

            foreach (var segment in run)
            {
                writer.Write(Escape(segment.Name));
                writer.Write(',');
                writer.Write(Escape(regularTimeFormatter.Format(segment.PersonalBestSplitTime.RealTime)));
                writer.Write(',');
                writer.WriteLine(Escape(shortTimeFormatter.Format(segment.BestSegmentTime.RealTime)));
            }

            writer.Flush();
        }

 private static void ParseAttemptHistory(Version version, XmlElement parent, IRun run)
 {
     if (version >= new Version(1, 5, 0))
     {
         var attemptHistory = parent["AttemptHistory"];
         foreach (var attemptNode in attemptHistory.GetElementsByTagName("Attempt"))
         {
             var attempt = Attempt.ParseXml(attemptNode as XmlElement);
             run.AttemptHistory.Add(attempt);
         }
     }
     else if (version >= new Version(1, 4, 1))
     {
         var runHistory = parent["RunHistory"];
         foreach (var runHistoryNode in runHistory.GetElementsByTagName("Time"))
         {
             var indexedTime = IndexedTimeHelper.ParseXml(runHistoryNode as XmlElement);
             var attempt = new Attempt(indexedTime.Index, indexedTime.Time, null, null);
             run.AttemptHistory.Add(attempt);
         }
     }
     else
     {
         var runHistory = parent["RunHistory"];
         foreach (var runHistoryNode in runHistory.GetElementsByTagName("Time"))
         {
             var indexedTime = IndexedTimeHelper.ParseXmlOld(runHistoryNode as XmlElement);
             var attempt = new Attempt(indexedTime.Index, indexedTime.Time, null, null);
             run.AttemptHistory.Add(attempt);
         }
     }
 }

 /// <summary>
 /// Gets or sets the RunVertex associated with the given IRun
 /// </summary>
 /// <param name="key">
 /// The IRun whose value to get or set.
 /// </param>
 public RunVertex this[IRun key]
 {
     get
     {
         return (RunVertex) this.Dictionary[key];
     }
 }

 public FailedLoadingRunInvoker(IRun generator, Exception exception)
     : base(generator)
 {
     if (exception == null)
         throw new ArgumentNullException("exception");
     this.exception = exception;
 }

 public ChocolateyService(IRun powerShell, ISourceService sourceService)
 {
     _powershell = new RunSync();
     _sourceService = sourceService;
     _powershell.OutputChanged += OutPutChangedHandler;
     _powershell.RunFinished += RunFinishedHandler;
 }

 public ChocolateyService(IRunSync powerShell, ISourceService sourceService)
 {
     _powershell = powerShell;
     _sourceService = sourceService;
     _powershell.OutputChanged += InvokeOutputChanged;
     _powershell.RunFinished += OnRunFinished;
 }

 public MethodFailedLoadingRunInvoker(IRun generator, Exception exception, MethodInfo method)
     :base(generator,exception)
 {
     if (method == null)
         throw new ArgumentNullException("method");
     this.method = method;
 }

 private static void PopulatePredictions(IRun run, TimeSpan? currentTime, int segmentIndex, IList<TimeSpan?> predictions, bool simpleCalculation, bool useCurrentRun, TimingMethod method)
 {
     if (currentTime != null)
     {
         PopulatePrediction(predictions, currentTime + run[segmentIndex].BestSegmentTime[method], segmentIndex + 1);
         if (!simpleCalculation)
         {
             foreach (var nullSegment in run[segmentIndex].SegmentHistory.Where(x => !x.Value[method].HasValue))
             {
                 Time segmentTime;
                 if (segmentIndex == 0 
                     || !run[segmentIndex - 1].SegmentHistory.TryGetValue(nullSegment.Key, out segmentTime)
                     || segmentTime[method] != null)
                 {
                     var prediction = TrackBranch(run, currentTime, segmentIndex + 1, nullSegment.Key, method);
                     PopulatePrediction(predictions, prediction.Time[method], prediction.Index);
                 }
             }
         }
         if (useCurrentRun)
         {
             var currentRunPrediction = TrackCurrentRun(run, currentTime, segmentIndex, method);
             PopulatePrediction(predictions, currentRunPrediction.Time[method], currentRunPrediction.Index);
         }
         var personalBestRunPrediction = TrackPersonalBestRun(run, currentTime, segmentIndex, method);
         PopulatePrediction(predictions, personalBestRunPrediction.Time[method], personalBestRunPrediction.Index);
     }
 }

        public string ImportAsComparison(IRun run, Form form = null)
        {
            var splitDialog = new OpenFileDialog();

            var result = splitDialog.ShowDialog();
            if (result == DialogResult.OK)
            {
                var filePath = splitDialog.FileName;

                using (var stream = File.OpenRead(filePath))
                {
                    var runFactory = new StandardFormatsRunFactory();
                    var comparisonGeneratorsFactory = new StandardComparisonGeneratorsFactory();

                    runFactory.Stream = stream;
                    runFactory.FilePath = filePath;

                    var imported = runFactory.Create(comparisonGeneratorsFactory);

                    var comparisonName = Path.GetFileNameWithoutExtension(splitDialog.FileName);
                    result = InputBox.Show(form, "Enter Comparison Name", "Name:", ref comparisonName);
                    if (result != DialogResult.Cancel)
                        return run.AddComparisonWithNameInput(imported, comparisonName, form);
                }
            }
            return null;
        }

 public PackageVersionService(IRunAsync powershell, ISourceService sourceService)
 {
     _powershellAsync = powershell;
     _sourceService = sourceService;
     _powershellAsync.OutputChanged += VersionHandler;
     _powershellAsync.RunFinished += RunFinished;
 }

 private static void PopulatePredictions(IRun run, TimeSpan? currentTime, int segmentIndex, IList<TimeSpan?> predictions, bool simpleCalculation, bool useCurrentRun, TimingMethod method)
 {
     if (currentTime != null)
     {
         PopulatePrediction(predictions, currentTime + run[segmentIndex].BestSegmentTime[method], segmentIndex + 1);
         if (!simpleCalculation)
         {
             foreach (var nullSegment in run[segmentIndex].SegmentHistory.Where(x => !x.Time[method].HasValue))
             {
                 var segmentTime = segmentIndex > 0 ? run[segmentIndex - 1].SegmentHistory.FirstOrDefault(x => x.Index == nullSegment.Index) : null;
                 if (segmentTime == null || segmentTime.Time[method] != null)
                 {
                     var prediction = SumOfSegmentsHelper.TrackBranch(run, currentTime, segmentIndex + 1, nullSegment.Index, method);
                     PopulatePrediction(predictions, prediction.Time[method], prediction.Index);
                 }
             }
         }
         if (useCurrentRun)
         {
             var currentRunPrediction = SumOfSegmentsHelper.TrackCurrentRun(run, currentTime, segmentIndex, method);
             PopulatePrediction(predictions, currentRunPrediction.Time[method], currentRunPrediction.Index);
         }
         var personalBestRunPrediction = SumOfSegmentsHelper.TrackPersonalBestRun(run, currentTime, segmentIndex, method);
         PopulatePrediction(predictions, personalBestRunPrediction.Time[method], personalBestRunPrediction.Index);
     }
 }

 private static void PopulatePredictions(IRun run, TimeSpan? currentTime, int segmentIndex, IList<TimeSpan?> predictions, bool useCurrentRun, TimingMethod method)
 {
     if (currentTime != null)
     {
         PopulatePrediction(predictions, currentTime + run[segmentIndex].BestSegmentTime[method], segmentIndex + 1);
         foreach (var segment in run[segmentIndex].SegmentHistory)
         {
             Time segmentTime;
             if (segmentIndex == 0 
                 || !run[segmentIndex - 1].SegmentHistory.TryGetValue(segment.Key, out segmentTime) 
                 || segmentTime[method] != null)
             {
                 var prediction = SumOfSegmentsHelper.TrackBranch(run, currentTime, segmentIndex, segment.Key, method);
                 PopulatePrediction(predictions, prediction.Time[method], prediction.Index);
             }
         }
         if (useCurrentRun)
         {
             var currentRunPrediction = SumOfSegmentsHelper.TrackCurrentRun(run, currentTime, segmentIndex, method);
             PopulatePrediction(predictions, currentRunPrediction.Time[method], currentRunPrediction.Index);
         }
         var personalBestRunPrediction = SumOfSegmentsHelper.TrackPersonalBestRun(run, currentTime, segmentIndex, method);
         PopulatePrediction(predictions, personalBestRunPrediction.Time[method], personalBestRunPrediction.Index);
     }
 }

 public PackageService(IRun powershell, ISourceService sourceService)
 {
     _powershellAsync = new RunAsync();
     _sourceService = sourceService;
     _powershellAsync.OutputChanged += OutputChanged;
     _powershellAsync.RunFinished += RunFinished;
 }

 public AvailablePackagesService(IRunAsync powershell, ISourceService sourceService)
 {
     _lines = new List<string>();
     _sourceService = sourceService;
     _powershellAsync = powershell;
     _powershellAsync.OutputChanged += OutputChanged;
     _powershellAsync.RunFinished += RunFinished;
 }

		/// <summary>
		/// Default constructor - initializes all fields to default values
		/// </summary>
		public MethodRunInvoker(IRun generator, MethodInfo method)
			:base(generator)
		{
			if (method==null)
				throw new ArgumentNullException("method");
			
			this.method = method;
		}

 public DelegateRunInvoker(IRun generator, Delegate test, Object[] parameters)
     :base(generator)
 {
     if (test == null)
         throw new ArgumentNullException("test");
     this.test = test;
     this.parameters = parameters;
 }

 /// <summary>
 /// Adds an element with the specified key and value to this RunVertexDictionary.
 /// </summary>
 /// <param name="key">
 /// The IRun key of the element to add.
 /// </param>
 /// <param name="value">
 /// The RunVertex value of the element to add.
 /// </param>
 public void Add(IRun key, RunVertex value)
 {
     if (key == null)
         throw new ArgumentNullException("key");
     if (value == null)
         throw new ArgumentNullException("value");
     this.Dictionary.Add(key, value);
 }

 public PackageService(IRunAsync powershell, ISourceService sourceService, ICommandExecuter commandExecuter)
 {
     _powershellAsync = powershell;
     _sourceService = sourceService;
     _commandExecuter = commandExecuter;
     _powershellAsync.OutputChanged += OnLineChanged;
     _powershellAsync.RunFinished += OnRunFinished;
 }

 private static string GetStringValue(string name, IRun r) {
   IItem item;
   r.Results.TryGetValue(name, out item);
   if (item != null)
     return item.ToString();
   r.Parameters.TryGetValue(name, out item);
   return item != null ? item.ToString() : "<none>";
 }