SYS_SETFSUID                = 5120
	SYS_SETFSGID                = 5121
	SYS_GETSID                  = 5122
	SYS_CAPGET                  = 5123
	SYS_CAPSET                  = 5124
	SYS_RT_SIGPENDING           = 5125
	SYS_RT_SIGTIMEDWAIT         = 5126
	SYS_RT_SIGQUEUEINFO         = 5127
	SYS_RT_SIGSUSPEND           = 5128
	SYS_SIGALTSTACK             = 5129
	SYS_UTIME                   = 5130

	SYS_SETFSUID                = 5120
	SYS_SETFSGID                = 5121
	SYS_GETSID                  = 5122
	SYS_CAPGET                  = 5123
	SYS_CAPSET                  = 5124
	SYS_RT_SIGPENDING           = 5125
	SYS_RT_SIGTIMEDWAIT         = 5126
	SYS_RT_SIGQUEUEINFO         = 5127
	SYS_RT_SIGSUSPEND           = 5128
	SYS_SIGALTSTACK             = 5129
	SYS_UTIME                   = 5130

</suite>"""

        when: succeeds "test"

        then:
        if (VersionNumber.parse(version.toString()) > VersionNumber.parse('5.12.1')) {
            // Broken in 5.12.1, fixed in 5.13
            assert containsLinesThatMatch(result.output,
                "Gradle Test Executor \\d+ -> static out",
                "Gradle Test Executor \\d+ -> static err",

performanceTest.registerTestProject("ktsManyProjects", KtsProjectGeneratorTask) {
    projects = 100
    sourceFiles = 0
    daemonMemory = '512m'
}

performanceTest.registerTestProject("ktsSmall", KtsProjectGeneratorTask) {
    daemonMemory = '512m'
}

// === Native Software Model ===
performanceTest.registerTestProject("smallNative", NativeProjectGeneratorTask) {
    projects = 1

	Escape(p)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		*p = [256 / 4]uint32{}
	}
}

func BenchmarkClearFat512(b *testing.B) {
	p := new([512 / 4]uint32)
	Escape(p)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		*p = [512 / 4]uint32{}
	}
}

func BenchmarkClearFat1024(b *testing.B) {
	p := new([1024 / 4]uint32)
	Escape(p)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {

            CalibrationOptions::CALIBRATION_METHOD_HISTOGRAM_PERCENTILE);
        auto calibration_parameters =
            CalibrationOptions::CalibrationParameters();
        calibration_parameters.set_num_bins(512);
        calibration_parameters.set_min_percentile(0.001);
        calibration_parameters.set_max_percentile(99.999);
        calib_opts_.mutable_calibration_parameters()->CopyFrom(
            calibration_parameters);

	{"BETWEEN_64_MB_AND_128_MB", humanize.MiByte * 64, humanize.MiByte*128 - 1},
	{"BETWEEN_128_MB_AND_512_MB", humanize.MiByte * 128, humanize.MiByte*512 - 1},
	{"GREATER_THAN_512_MB", humanize.MiByte * 512, math.MaxInt64},
}

// ObjectsHistogramIntervals is the list of all intervals
// of object sizes to be included in objects histogram.

			return &testResponse{
				OrgNum:    req.Num,
				OrgString: req.String,
				Embedded:  *req,
			}, nil
		}))
		errFatal(err)
	}
	const payloadSize = 512
	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	payload := make([]byte, payloadSize)
	_, err = rng.Read(payload)
	errFatal(err)

	// Wait for all to connect
	// Parallel writes per server.

	{
		Port:        3128,
		HTTPVersion: forwardproxy.HTTP1,
		TLSEnabled:  false,
	},
	{
		Port:        4128,
		HTTPVersion: forwardproxy.HTTP1,
		TLSEnabled:  true,
	},
	{
		Port:        5128,
		HTTPVersion: forwardproxy.HTTP2,
		TLSEnabled:  false,
	},
	{
		Port:        6128,
		HTTPVersion: forwardproxy.HTTP2,
		TLSEnabled:  true,
	},
}

var requestsSpec = []testRequestSpec{
	{

  // Use a pointer for the static set, so the set is not destructed upon thread
  // end, which would not be thread safe.

  static auto* ops = [] {
    llvm::SmallDenseSet<mlir::TypeID, 512>* ops_set = new llvm::SmallDenseSet<
        mlir::TypeID, 512>{
        TypeID::get<TF::AcoshOp>(),
        TypeID::get<TF::AcosOp>(),
        TypeID::get<TF::AddNOp>(),
        TypeID::get<TF::AddV2Op>(),
        TypeID::get<TF::AngleOp>(),