GoogleTestAdapter.Scheduling.DurationBasedTestsSplitter.SplitTestcases C# (CSharp) Method

        public List<List<TestCase>> SplitTestcases()
        {
            List<TestCase> sortedTestcases = _testcaseDurations.Keys.OrderByDescending(tc => _testcaseDurations[tc]).ToList();
            int nrOfThreadsToUse = _testEnvironment.Options.MaxNrOfThreads;
            int targetDuration = _overallDuration / nrOfThreadsToUse;

            var splitTestcases = new List<List<TestCase>>();
            var currentList = new List<TestCase>();
            int currentDuration = 0;
            while (sortedTestcases.Count > 0 && splitTestcases.Count < nrOfThreadsToUse)
            {
                do
                {
                    TestCase testcase = sortedTestcases[0];

                    sortedTestcases.RemoveAt(0);
                    currentList.Add(testcase);
                    currentDuration += _testcaseDurations[testcase];
                } while (sortedTestcases.Count > 0 && currentDuration + _testcaseDurations[sortedTestcases[0]] <= targetDuration);

                splitTestcases.Add(currentList);
                currentList = new List<TestCase>();
                currentDuration = 0;
            }

            while (sortedTestcases.Count > 0)
            {
                // TODO performance
                int index = GetIndexOfListWithShortestDuration(splitTestcases);
                splitTestcases[index].Add(sortedTestcases[0]);
                sortedTestcases.RemoveAt(0);
            }

            return splitTestcases;
        }

        private void ExecuteRandomDurationsTest(int nrOfTests, int maxRandomDuration, int nrOfThreads)
        {
            IDictionary <Model.TestCase, int> durations = CreateRandomTestResults(nrOfTests, maxRandomDuration);

            MockOptions.Setup(o => o.MaxNrOfThreads).Returns(nrOfThreads);

            ITestsSplitter splitter = new DurationBasedTestsSplitter(durations, TestEnvironment.Options);
            List <List <Model.TestCase> > result = splitter.SplitTestcases();

            result.Count.Should().Be(nrOfThreads);
            result.Select(l => l.Count).Sum().Should().Be(nrOfTests);

            int sumOfAllDurations = durations.Select(kvp => kvp.Value).Sum();
            int maxDuration       = durations.Select(kvp => kvp.Value).Max();

            int targetDuration = sumOfAllDurations / nrOfThreads;

            HashSet <Model.TestCase> foundTestcases = new HashSet <Model.TestCase>();

            foreach (List <Model.TestCase> testcases in result)
            {
                int sum = testcases.Select(tc => durations[tc]).Sum();
                sum.Should().BeLessThan(targetDuration + maxDuration / 2);
                sum.Should().BeGreaterThan(targetDuration - maxDuration / 2);

                foundTestcases.UnionWith(testcases);
            }

            foundTestcases.Count.Should().Be(nrOfTests);
        }