Function deserializeTestCases

tsn/src/test262/shared/Test262Serialization.cpp:58–126

}

Result<map<string, TestCaseData>> deserializeTestCases(const fs::path& inputFile) {
    auto testCasesResult = DiskUtils::load(Path(inputFile.string()));
    if (!testCasesResult) {
        return TEST262_ERROR("Failed to save file {} with error {}", inputFile, testCasesResult.error().getMessage());
    }
    const auto testCasesData = testCasesResult.moveValue();
    auto testCasesValueResult = jsonToValue(testCasesData.data(), testCasesResult.value().size());
    if (!testCasesValueResult) {
        return TEST262_ERROR(
            "Failed to parse file {} with error {}", inputFile, testCasesValueResult.error().getMessage());
    }
    const auto testCasesValue = testCasesValueResult.moveValue();
    if (!testCasesValue.isMap()) {
        return TEST262_ERROR("Parsed file {} expected top level map", inputFile);
    }

    map<string, TestCaseData> retval;
    for (const auto& testCase : *testCasesValue.getMapRef()) {
        TestCaseData data;
        if (!testCase.second.isMap()) {
            return TEST262_ERROR("Test case data for {} is not a map", testCase.first);
        }

        const auto isNegativeValue = testCase.second.getMapValue(kIsNegative);
        const auto negativePhaseValue = testCase.second.getMapValue(kNegativePhase);
        const auto negativeTypeValue = testCase.second.getMapValue(kNegativeType);
        const auto onlyStrictValue = testCase.second.getMapValue(kOnlyStrict);
        const auto noStrictValue = testCase.second.getMapValue(kNoStrict);
        const auto moduleValue = testCase.second.getMapValue(kModule);
        const auto rawValue = testCase.second.getMapValue(kRaw);
        const auto asyncValue = testCase.second.getMapValue(kAsync);
        const auto includesValue = testCase.second.getMapValue(kIncludes);

        bool boolValueCheck = isNegativeValue.isBool() && onlyStrictValue.isBool() && noStrictValue.isBool() &&
                              moduleValue.isBool() && rawValue.isBool() && asyncValue.isBool();
        if (!boolValueCheck) {
            return TEST262_ERROR("Test case data for {} expected bool type", testCase.first);
        }
        bool stringValueCheck = negativePhaseValue.isString() && negativeTypeValue.isString();
        if (!stringValueCheck) {
            return TEST262_ERROR("Test case data for {} expected string type", testCase.first);
        }
        bool arrayValueCheck = includesValue.isArray();
        if (!arrayValueCheck) {
            return TEST262_ERROR("Test case data for {} expected array type", testCase.first);
        }

        data.isNegative = isNegativeValue.toBool();
        data.onlyStrict = onlyStrictValue.toBool();
        data.noStrict = noStrictValue.toBool();
        data.module = moduleValue.toBool();
        data.async = asyncValue.toBool();

        data.negativePhase = negativePhaseValue.toString();
        data.negativeType = negativeTypeValue.toString();

        data.includes.reserve(includesValue.getArrayRef()->size());
        for (const auto& element : *includesValue.getArrayRef()) {