public void GetSolvesCompleted()
        {
            var calc   = new SolveCalculator();
            var solves = Enumerable.Range(1, 5).Select(n => new Solve {
                Number = n, Result = ""
            }).ToArray();

            var count = solves.Count();

            Assert.Equal(count, calc.GetRemainingSolvesCount(solves));
            for (int i = 0; i < count; i++)
            {
                var remaining = count - 1 - i;
                solves[i].Result = $"9.0";

                Assert.Equal(remaining, calc.GetRemainingSolvesCount(solves));
            }


            solves = Enumerable.Range(1, 3).Select(n => new Solve {
                Number = n, Result = ""
            }).ToArray();
            count = solves.Count();
            Assert.Equal(count, calc.GetRemainingSolvesCount(solves));
            for (int i = 0; i < count; i++)
            {
                var remaining = count - 1 - i;
                solves[i].Result = $"9.0";

                Assert.Equal(remaining, calc.GetRemainingSolvesCount(solves));
            }
        }
        public void GetIncludedSolves(string s1, string s2, string s3, string s4, string s5, params int[] results)
        {
            Solve[] solves =
            {
                new Solve {
                    Number = 1, Result = s1
                },
                new Solve {
                    Number = 2, Result = s2
                },
                new Solve {
                    Number = 3, Result = s3
                },
                new Solve {
                    Number = 4, Result = s4
                },
                new Solve {
                    Number = 5, Result = s5
                }
            };

            var calc           = new SolveCalculator();
            var orderedResults = calc.GetIncludedSolves(solves)
                                 .OrderBy(s => s.Item1)
                                 .Select(s => s.Item1).ToArray();

            Assert.Equal(results, orderedResults);
        }
        public void GetCalculations(string s1, string s2, string s3, string s4, string s5, string pb,
                                    string avg, string needed, params int[] results)
        {
            Solve[] solves =
            {
                new Solve {
                    Number = 1, Result = s1
                },
                new Solve {
                    Number = 2, Result = s2
                },
                new Solve {
                    Number = 3, Result = s3
                },
                new Solve {
                    Number = 4, Result = s4
                },
                new Solve {
                    Number = 5, Result = s5
                }
            };

            var calc         = new SolveCalculator();
            var calculations = calc.GetCalculations(solves, pb);

            Assert.Equal(avg, calculations.CurrentAverage);
            Assert.Equal(needed, calculations.NeededForNewPB);

            var orderedResults = calc.GetIncludedSolves(solves)
                                 .OrderBy(s => s.Item1)
                                 .Select(s => s.Item1).ToArray();

            Assert.Equal(results, orderedResults);
        }
        public void ConvertResultToSeconds(string input, float result)
        {
            var calc = new SolveCalculator();

            Assert.Equal(result, calc.ConvertResultToSeconds(input));
        }
        public void GetNeededForNewPb(string result, string pb, params float[] times)
        {
            var calc = new SolveCalculator();

            Assert.Equal(result, calc.GetNeededForNewPb(times, pb));
        }
        public void GetBestPossibleAverage(string result, params float[] times)
        {
            var calc = new SolveCalculator();

            Assert.Equal(result, calc.GetBestPossibleAverage(times));
        }
        public void ConvertSecondsToResult(float input, string result)
        {
            var calc = new SolveCalculator();

            Assert.Equal(result, calc.ConvertSecondsToResult(input));
        }