private def getTestsuite()

in scala/support/JUnitXmlReporter.scala [109:217]
98 lines of code
56 McCabe index (conditional complexity)

  private def getTestsuite(endEvent: Event, suiteId: String): Testsuite = {
    require(endEvent.isInstanceOf[SuiteCompleted] ||
            endEvent.isInstanceOf[SuiteAborted])

    val orderedEvents = events.toList.filter { e =>
      e match {
        case e: TestStarting   => e.suiteId == suiteId
        case e: TestSucceeded  => e.suiteId == suiteId
        case e: TestIgnored    => e.suiteId == suiteId
        case e: TestFailed     => e.suiteId == suiteId
        case e: TestPending    => e.suiteId == suiteId
        case e: TestCanceled   => e.suiteId == suiteId
        case e: InfoProvided   =>
          e.nameInfo match {
            case Some(nameInfo) =>
              nameInfo.suiteId == suiteId
            case None => false
          }
        case e: AlertProvided   =>
          e.nameInfo match {
            case Some(nameInfo) =>
              nameInfo.suiteId == suiteId
            case None => false
          }
        case e: NoteProvided   =>
          e.nameInfo match {
            case Some(nameInfo) =>
              nameInfo.suiteId == suiteId
            case None => false
          }
        case e: MarkupProvided =>
          e.nameInfo match {
            case Some(nameInfo) =>
              nameInfo.suiteId == suiteId
            case None => false
          }
        case e: ScopeOpened    => e.nameInfo.suiteId == suiteId
        case e: ScopeClosed    => e.nameInfo.suiteId == suiteId
        case e: SuiteStarting  => e.suiteId == suiteId
        case e: SuiteAborted   => e.suiteId == suiteId
        case e: SuiteCompleted => e.suiteId == suiteId
        case _    => false
      }
    }.sortWith((a, b) => a < b).toArray

    val (startIndex, endIndex) = locateSuite(orderedEvents, endEvent)

    val startEvent = orderedEvents(startIndex).asInstanceOf[SuiteStarting]
    events -= startEvent

    val name =
      startEvent.suiteClassName match {
        case Some(className) => className
        case None            => startEvent.suiteName
      }

    val testsuite = Testsuite(name, startEvent.timeStamp)

    var idx = startIndex + 1
    while (idx <= endIndex) {
      val event = orderedEvents(idx)
      events -= event

      event match {
        case e: TestStarting =>
          val (testEndIndex, testcase) = processTest(orderedEvents, e, idx)
          testsuite.testcases += testcase
          if (testcase.failure != None) testsuite.failures += 1
          idx = testEndIndex + 1

        case e: SuiteAborted =>
          assert(endIndex == idx)
          testsuite.errors += 1
          testsuite.time = e.timeStamp - testsuite.timeStamp
          idx += 1

        case e: SuiteCompleted =>
          assert(endIndex == idx)
          testsuite.time = e.timeStamp - testsuite.timeStamp
          idx += 1

        case e: TestIgnored    =>
          val testcase = Testcase(e.testName, e.suiteClassName, e.timeStamp)
          testcase.ignored = true
          testsuite.testcases += testcase
          idx += 1

        case _: InfoProvided   => idx += 1
        case _: AlertProvided  => idx += 1
        case _: NoteProvided   => idx += 1
        case _: MarkupProvided => idx += 1
        case _: ScopeOpened    => idx += 1
        case _: ScopeClosed    => idx += 1
        case _: ScopePending   => idx += 1
        case e: TestPending    => unexpected(e)
        case e: TestCanceled   => unexpected(e)
        case e: RunStarting    => unexpected(e)
        case e: RunCompleted   => unexpected(e)
        case e: RunStopped     => unexpected(e)
        case e: RunAborted     => unexpected(e)
        case e: TestSucceeded  => unexpected(e)
        case e: TestFailed     => unexpected(e)
        case e: SuiteStarting  => unexpected(e)
        case e: DiscoveryStarting  => unexpected(e)
        case e: DiscoveryCompleted => unexpected(e)
      }
    }
    testsuite
  }