}
	}
	return strings.ReplaceAll(d, "/", "_")
}

// NewSuite returns a new suite instance.
func NewSuite(m *testing.M) Suite {
	_, f, _, _ := goruntime.Caller(1)
	suiteName := deriveSuiteName(f)

	return newSuite(suiteName,
		func(_ *suiteContext) int {
			return m.Run()
		},
		os.Exit,
		getSettings)
}

            assert event.descriptor.displayName == 'some test suite in human readable form'
            assert event.descriptor.jvmTestKind == JvmTestKind.SUITE
            assert event.descriptor.suiteName == 'some suite'
            assert event.descriptor.className == 'some class'
            assert event.descriptor.methodName == 'some method'
            assert event.descriptor.parent == null
        }
    }

        and:
        def passingResults = new CUnitTestResults(cunit.dir.file("build/test-results/operatorsTest/passing/CUnitAutomated-Results.xml"))
        passingResults.suiteNames == ['operator tests']
        passingResults.suites['operator tests'].passingTests == ['test_plus', 'test_minus']
        passingResults.suites['operator tests'].failingTests == []
        passingResults.checkTestCases(2, 2, 0)

        and:
        def passingResults = new GoogleTestTestResults(googleTest.dir.file("build/test-results/operatorsTest/passing/test_detail.xml"))
        passingResults.suiteNames == ['OperatorTests']
        passingResults.suites['OperatorTests'].passingTests == ['test_minus', 'test_plus']
        passingResults.suites['OperatorTests'].failingTests == []
        passingResults.checkTestCases(2, 2, 0)

                ":linkHelloTestGoogleTestExe", ":helloTestGoogleTestExe", ":runHelloTestGoogleTestExe"

        def testResults = new GoogleTestTestResults(file("build/test-results/helloTest/test_detail.xml"))
        testResults.suiteNames == ['HelloTest']
        testResults.suites['HelloTest'].passingTests == ['test_sum']
        testResults.suites['HelloTest'].failingTests == []
        testResults.checkTestCases(1, 1, 0)
    }

  val minRsaBits: Int,
  val name: String,
  val npnProtocols: List<String>,
  val platform: String?,
  val requiresSha2: Boolean,
  val signatureAlgorithms: List<Int>,
  val suiteIds: List<Int>,
  val suiteNames: List<String>,
  val supportsCompression: Boolean,
  val supportsNpn: Boolean,
  val supportsRi: Boolean,
  val supportsSni: Boolean,
  val supportsStapling: Boolean,
  val supportsTickets: Boolean,

    }

    class Suite {
        final Node suiteNode

        Suite(Node suiteNode) {
            this.suiteNode = suiteNode
        }

        String getName() {
            return suiteNode.SUITE_NAME.text().trim()
        }

        List<String> getPassingTests() {
            suiteNode.CUNIT_RUN_TEST_RECORD.CUNIT_RUN_TEST_SUCCESS.TEST_NAME*.text()*.trim()
        }

        List<String> getFailingTests() {

    return sslLabsApi.clients().map { userAgent ->
      Client(
        userAgent = userAgent.name,
        version = userAgent.version,
        platform = userAgent.platform,
        enabled = userAgent.suiteNames.map { SuiteId(null, it) },
      )
    }
  }
}

suspend fun main() {
  val sslLabsClient =
    SslLabsClient(
      callFactory = OkHttpClient(),
    )

        file("build/test-results/helloTest/CUnitAutomated-Listing.xml").assertExists()

        def testResults = new CUnitTestResults(file("build/test-results/helloTest/CUnitAutomated-Results.xml"))
        testResults.suiteNames == ['hello test']
        testResults.suites['hello test'].passingTests == ['test_sum']
        testResults.suites['hello test'].failingTests == []
        testResults.checkTestCases(1, 1, 0)

	MaxILMExpiryRules int                             // maximum ILM expiry rules across sites
	Sites             map[string]madmin.PeerInfo      // deployment->sitename
	StatsSummary      map[string]madmin.SRSiteSummary // map of deployment id -> site stat
	// BucketStats map of bucket to slice of deployment IDs with stats. This is populated only if there are