}

data class JsonBasedGradleSubprojectProvider(private val jsonFile: File) : GradleSubprojectProvider {
    @Suppress("UNCHECKED_CAST")
    override val subprojects = JSON.parseArray(jsonFile.readText()).map { toSubproject(it as Map<String, Any>) }

    private val nameToSubproject = subprojects.map { it.name to it }.toMap()
    override fun getSubprojectsForFunctionalTest(testConfig: TestCoverage) =

                    jsonParser.nextToken();

                    if (jsonParser.getCurrentToken() == JsonToken.START_ARRAY) {
                        // Handle array type
                        attributes.put(name, parseArray(jsonParser));
                    } else if (jsonParser.getCurrentToken() == JsonToken.START_OBJECT) {
                        // Handle nested object type
                        attributes.put(name, parseObject(jsonParser));

    private val buckets: Map<TestCoverage, List<BuildTypeBucket>> by lazy {
        val uuidToTestCoverage = model.stages.flatMap { it.functionalTests }.associateBy { it.uuid }
        val testCoverageAndBuckets = JSON.parseArray(testBucketsJson.readText()) as JSONArray
        testCoverageAndBuckets.associate { testCoverageAndBucket ->
            testCoverageAndBucket as JSONObject

        if (Collection.class.isAssignableFrom(rawType)) {
            return parseCollection(parser, TypeArguments.get(toType.getSupertype(Collection.class), 0));
        }
        if (rawType.isArray()) {
            return parseArray(parser, TypeArguments.get(toType, 0));
        }
        return parseBean(parser, toType, rawType);
    }

    /**

        }
    }

    private
    fun readPerformanceTestDurations(performanceTestDurationsJson: File): OperatingSystemToTestProjectPerformanceTestDurations {
        val durations = JSON.parseArray(performanceTestDurationsJson.readText(StandardCharsets.UTF_8))
        val pairs = durations.flatMap { it ->
            val scenarioDurations = it as JSONObject

func (h *headerUSTAR) prefix() []byte    { return h[345:][:155] }

type sparseArray []byte

func (s sparseArray) entry(i int) sparseElem { return sparseElem(s[i*24:]) }
func (s sparseArray) isExtended() []byte     { return s[24*s.maxEntries():][:1] }
func (s sparseArray) maxEntries() int        { return len(s) / 24 }

type sparseElem []byte

			sph = alignSparseEntries(sph, hdr.Size)
			spd = invertSparseEntries(sph, hdr.Size)

			// Format the sparse map.
			formatSPD := func(sp sparseDatas, sa sparseArray) sparseDatas {
				for i := 0; len(sp) > 0 && i < sa.MaxEntries(); i++ {
					f.formatNumeric(sa.Entry(i).Offset(), sp[0].Offset)
					f.formatNumeric(sa.Entry(i).Length(), sp[0].Length)
					sp = sp[1:]
				}

		}
		if ok := err == nil; ok != v.ok {
			t.Errorf("test %d, parsePAX(): got %v, want %v", i, ok, v.ok)
		}
	}
}

func TestReadOldGNUSparseMap(t *testing.T) {
	populateSparseMap := func(sa sparseArray, sps []string) []string {
		for i := 0; len(sps) > 0 && i < sa.maxEntries(); i++ {
			copy(sa.entry(i), sps[0])
			sps = sps[1:]
		}
		if len(sps) > 0 {
			copy(sa.isExtended(), "\x80")
		}

romISO","l","allowTime","dateFormat","timeFormat","tzFormat","string","exec","configFromStringAndFormat","extractFromRFC2822Strings","yearStr","monthStr","dayStr","hourStr","minuteStr","secondStr","result","untruncateYear","configFromRFC2822","parsedArray","weekdayStr","parsedInput","getDay","obsOffset","militaryOffset","numOffset","hm","calculateOffset","setUTCMinutes","getUTCMinutes","defaults","c","configFromArray","currentDate","expectedWeekday","yearToUse","nowValue","now","_useUTC","getUTC...