| //===- JSONFormatTest.cpp -------------------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // Shared normalization helpers for SSAF JSON serialization format unit tests. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "JSONFormatTest.h" |
| |
| #include "clang/ScalableStaticAnalysisFramework/Core/Serialization/JSONFormat.h" |
| #include "llvm/ADT/STLExtras.h" |
| #include "llvm/Support/FormatVariadic.h" |
| #include "llvm/Support/Registry.h" |
| #include "llvm/Testing/Support/Error.h" |
| #ifndef _WIN32 |
| #include <unistd.h> |
| #endif |
| |
| using namespace clang::ssaf; |
| using namespace llvm; |
| using PathString = JSONFormatTest::PathString; |
| |
| // ============================================================================ |
| // Test Fixture |
| // ============================================================================ |
| |
| void JSONFormatTest::SetUp() { |
| std::error_code EC = |
| llvm::sys::fs::createUniqueDirectory("json-format-test", TestDir); |
| ASSERT_FALSE(EC) << "Failed to create temp directory: " << EC.message(); |
| } |
| |
| void JSONFormatTest::TearDown() { llvm::sys::fs::remove_directories(TestDir); } |
| |
| JSONFormatTest::PathString |
| JSONFormatTest::makePath(llvm::StringRef FileOrDirectoryName) const { |
| PathString FullPath = TestDir; |
| llvm::sys::path::append(FullPath, FileOrDirectoryName); |
| |
| return FullPath; |
| } |
| |
| PathString JSONFormatTest::makePath(llvm::StringRef Dir, |
| llvm::StringRef FileName) const { |
| PathString FullPath = TestDir; |
| llvm::sys::path::append(FullPath, Dir, FileName); |
| |
| return FullPath; |
| } |
| |
| llvm::Expected<PathString> |
| JSONFormatTest::makeDirectory(llvm::StringRef DirectoryName) const { |
| PathString DirPath = makePath(DirectoryName); |
| |
| std::error_code EC = llvm::sys::fs::create_directory(DirPath); |
| if (EC) { |
| return llvm::createStringError(EC, "Failed to create directory '%s': %s", |
| DirPath.c_str(), EC.message().c_str()); |
| } |
| |
| return DirPath; |
| } |
| |
| llvm::Expected<PathString> |
| JSONFormatTest::makeSymlink(llvm::StringRef TargetFileName, |
| llvm::StringRef SymlinkFileName) const { |
| PathString TargetPath = makePath(TargetFileName); |
| PathString SymlinkPath = makePath(SymlinkFileName); |
| |
| std::error_code EC = llvm::sys::fs::create_link(TargetPath, SymlinkPath); |
| if (EC) { |
| return llvm::createStringError( |
| EC, "Failed to create symlink '%s' -> '%s': %s", SymlinkPath.c_str(), |
| TargetPath.c_str(), EC.message().c_str()); |
| } |
| |
| return SymlinkPath; |
| } |
| |
| llvm::Error JSONFormatTest::setPermission(llvm::StringRef FileName, |
| llvm::sys::fs::perms Perms) const { |
| PathString Path = makePath(FileName); |
| |
| std::error_code EC = llvm::sys::fs::setPermissions(Path, Perms); |
| if (EC) { |
| return llvm::createStringError(EC, "Failed to set permissions on '%s': %s", |
| Path.c_str(), EC.message().c_str()); |
| } |
| |
| return llvm::Error::success(); |
| } |
| |
| bool JSONFormatTest::permissionsAreEnforced() const { |
| #ifdef _WIN32 |
| return false; |
| #else |
| if (getuid() == 0) { |
| return false; |
| } |
| |
| // Write a probe file, remove read permission, and try to open it. |
| PathString ProbePath = makePath("perm-probe.json"); |
| |
| { |
| std::error_code EC; |
| llvm::raw_fd_ostream OS(ProbePath, EC); |
| if (EC) { |
| return true; // Probe setup failed; assume enforced to avoid |
| // silently suppressing the test. |
| } |
| OS << "{}"; |
| } |
| |
| std::error_code PermEC = llvm::sys::fs::setPermissions( |
| ProbePath, llvm::sys::fs::perms::owner_write); |
| if (PermEC) { |
| return true; // Probe setup failed; assume enforced to avoid |
| // silently suppressing the test. |
| } |
| |
| auto Buffer = llvm::MemoryBuffer::getFile(ProbePath); |
| bool Enforced = !Buffer; // If open failed, permissions are enforced. |
| |
| // Restore permissions so TearDown can clean up the temp directory. |
| llvm::sys::fs::setPermissions(ProbePath, llvm::sys::fs::perms::all_all); |
| |
| return Enforced; |
| #endif |
| } |
| |
| llvm::Expected<llvm::json::Value> |
| JSONFormatTest::readJSONFromFile(llvm::StringRef FileName) const { |
| PathString FilePath = makePath(FileName); |
| |
| auto BufferOrError = llvm::MemoryBuffer::getFile(FilePath); |
| if (!BufferOrError) { |
| return llvm::createStringError(BufferOrError.getError(), |
| "Failed to read file: %s", FilePath.c_str()); |
| } |
| |
| llvm::Expected<llvm::json::Value> ExpectedValue = |
| llvm::json::parse(BufferOrError.get()->getBuffer()); |
| if (!ExpectedValue) { |
| return ExpectedValue.takeError(); |
| } |
| |
| return *ExpectedValue; |
| } |
| |
| llvm::Expected<PathString> |
| JSONFormatTest::writeJSON(llvm::StringRef JSON, |
| llvm::StringRef FileName) const { |
| PathString FilePath = makePath(FileName); |
| |
| std::error_code EC; |
| llvm::raw_fd_ostream OS(FilePath, EC); |
| if (EC) { |
| return llvm::createStringError(EC, "Failed to create file '%s': %s", |
| FilePath.c_str(), EC.message().c_str()); |
| } |
| |
| OS << JSON; |
| OS.close(); |
| |
| if (OS.has_error()) { |
| return llvm::createStringError( |
| OS.error(), "Failed to write to file '%s': %s", FilePath.c_str(), |
| OS.error().message().c_str()); |
| } |
| |
| return FilePath; |
| } |
| |
| // ============================================================================ |
| // Summary JSON Normalization Helpers |
| // ============================================================================ |
| |
| namespace { |
| |
| llvm::Error normalizeIDTable(json::Array &IDTable, |
| llvm::StringRef SummaryClassName) { |
| for (const auto &[Index, Entry] : llvm::enumerate(IDTable)) { |
| const auto *EntryObj = Entry.getAsObject(); |
| if (!EntryObj) { |
| return createStringError( |
| inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: id_table entry at index %zu " |
| "is not an object", |
| SummaryClassName.data(), Index); |
| } |
| |
| const auto *IDValue = EntryObj->get("id"); |
| if (!IDValue) { |
| return createStringError( |
| inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: id_table entry at index %zu " |
| "does not contain an 'id' field", |
| SummaryClassName.data(), Index); |
| } |
| |
| if (!IDValue->getAsUINT64()) { |
| return createStringError( |
| inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: id_table entry at index %zu " |
| "'id' field is not a valid entity id integer", |
| SummaryClassName.data(), Index); |
| } |
| } |
| |
| // Safe to dereference: all entries were validated above. |
| llvm::sort(IDTable, [](const json::Value &A, const json::Value &B) { |
| return *A.getAsObject()->get("id")->getAsUINT64() < |
| *B.getAsObject()->get("id")->getAsUINT64(); |
| }); |
| |
| return llvm::Error::success(); |
| } |
| |
| llvm::Error normalizeLinkageTable(json::Array &LinkageTable, |
| llvm::StringRef SummaryClassName) { |
| for (const auto &[Index, Entry] : llvm::enumerate(LinkageTable)) { |
| const auto *EntryObj = Entry.getAsObject(); |
| if (!EntryObj) { |
| return createStringError( |
| inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: linkage_table entry at index " |
| "%zu is not an object", |
| SummaryClassName.data(), Index); |
| } |
| |
| const auto *IDValue = EntryObj->get("id"); |
| if (!IDValue) { |
| return createStringError( |
| inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: linkage_table entry at index " |
| "%zu does not contain an 'id' field", |
| SummaryClassName.data(), Index); |
| } |
| |
| if (!IDValue->getAsUINT64()) { |
| return createStringError( |
| inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: linkage_table entry at index " |
| "%zu 'id' field is not a valid entity id integer", |
| SummaryClassName.data(), Index); |
| } |
| } |
| |
| // Safe to dereference: all entries were validated above. |
| llvm::sort(LinkageTable, [](const json::Value &A, const json::Value &B) { |
| return *A.getAsObject()->get("id")->getAsUINT64() < |
| *B.getAsObject()->get("id")->getAsUINT64(); |
| }); |
| |
| return llvm::Error::success(); |
| } |
| |
| llvm::Error normalizeSummaryData(json::Array &SummaryData, size_t DataIndex, |
| llvm::StringRef SummaryClassName) { |
| for (const auto &[SummaryIndex, SummaryEntry] : |
| llvm::enumerate(SummaryData)) { |
| const auto *SummaryEntryObj = SummaryEntry.getAsObject(); |
| if (!SummaryEntryObj) { |
| return createStringError( |
| inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: data entry at index %zu, " |
| "summary_data entry at index %zu is not an object", |
| SummaryClassName.data(), DataIndex, SummaryIndex); |
| } |
| |
| const auto *EntityIDValue = SummaryEntryObj->get("entity_id"); |
| if (!EntityIDValue) { |
| return createStringError( |
| inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: data entry at index %zu, " |
| "summary_data entry at index %zu does not contain an " |
| "'entity_id' field", |
| SummaryClassName.data(), DataIndex, SummaryIndex); |
| } |
| |
| if (!EntityIDValue->getAsUINT64()) { |
| return createStringError( |
| inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: data entry at index %zu, " |
| "summary_data entry at index %zu 'entity_id' field is not " |
| "a valid entity id integer", |
| SummaryClassName.data(), DataIndex, SummaryIndex); |
| } |
| } |
| |
| // Safe to dereference: all entries were validated above. |
| llvm::sort(SummaryData, [](const json::Value &A, const json::Value &B) { |
| return *A.getAsObject()->get("entity_id")->getAsUINT64() < |
| *B.getAsObject()->get("entity_id")->getAsUINT64(); |
| }); |
| |
| return llvm::Error::success(); |
| } |
| |
| llvm::Error normalizeData(json::Array &Data, llvm::StringRef SummaryClassName) { |
| for (const auto &[DataIndex, DataEntry] : llvm::enumerate(Data)) { |
| auto *DataEntryObj = DataEntry.getAsObject(); |
| if (!DataEntryObj) { |
| return createStringError( |
| inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: data entry at index %zu " |
| "is not an object", |
| SummaryClassName.data(), DataIndex); |
| } |
| |
| if (!DataEntryObj->getString("summary_name")) { |
| return createStringError( |
| inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: data entry at index %zu " |
| "does not contain a 'summary_name' string field", |
| SummaryClassName.data(), DataIndex); |
| } |
| |
| auto *SummaryData = DataEntryObj->getArray("summary_data"); |
| if (!SummaryData) { |
| return createStringError( |
| inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: data entry at index %zu " |
| "does not contain a 'summary_data' array field", |
| SummaryClassName.data(), DataIndex); |
| } |
| |
| if (auto Err = |
| normalizeSummaryData(*SummaryData, DataIndex, SummaryClassName)) { |
| return Err; |
| } |
| } |
| |
| // Safe to dereference: all entries were validated above. |
| llvm::sort(Data, [](const json::Value &A, const json::Value &B) { |
| return *A.getAsObject()->getString("summary_name") < |
| *B.getAsObject()->getString("summary_name"); |
| }); |
| |
| return llvm::Error::success(); |
| } |
| |
| Expected<json::Value> normalizeSummaryJSON(json::Value Val, |
| llvm::StringRef SummaryClassName) { |
| auto *Obj = Val.getAsObject(); |
| if (!Obj) { |
| return createStringError(inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: expected an object", |
| SummaryClassName.data()); |
| } |
| |
| auto *IDTable = Obj->getArray("id_table"); |
| if (!IDTable) { |
| return createStringError(inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: 'id_table' " |
| "field is either missing or has the wrong type", |
| SummaryClassName.data()); |
| } |
| if (auto Err = normalizeIDTable(*IDTable, SummaryClassName)) { |
| return std::move(Err); |
| } |
| |
| auto *LinkageTable = Obj->getArray("linkage_table"); |
| if (!LinkageTable) { |
| return createStringError(inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: 'linkage_table' " |
| "field is either missing or has the wrong type", |
| SummaryClassName.data()); |
| } |
| if (auto Err = normalizeLinkageTable(*LinkageTable, SummaryClassName)) { |
| return std::move(Err); |
| } |
| |
| auto *Data = Obj->getArray("data"); |
| if (!Data) { |
| return createStringError(inconvertibleErrorCode(), |
| "Cannot normalize %s JSON: 'data' " |
| "field is either missing or has the wrong type", |
| SummaryClassName.data()); |
| } |
| if (auto Err = normalizeData(*Data, SummaryClassName)) { |
| return std::move(Err); |
| } |
| |
| return Val; |
| } |
| |
| } // namespace |
| |
| // ============================================================================ |
| // SummaryTest Fixture Implementation |
| // ============================================================================ |
| |
| llvm::Error SummaryTest::readFromString(StringRef JSON, |
| StringRef FileName) const { |
| auto ExpectedFilePath = writeJSON(JSON, FileName); |
| if (!ExpectedFilePath) { |
| return ExpectedFilePath.takeError(); |
| } |
| return GetParam().ReadFromFile(*ExpectedFilePath); |
| } |
| |
| llvm::Error SummaryTest::readFromFile(StringRef FileName) const { |
| return GetParam().ReadFromFile(makePath(FileName)); |
| } |
| |
| llvm::Error SummaryTest::writeEmpty(StringRef FileName) const { |
| return GetParam().WriteEmpty(makePath(FileName)); |
| } |
| |
| llvm::Error SummaryTest::readWriteRoundTrip(StringRef InputFileName, |
| StringRef OutputFileName) const { |
| return GetParam().ReadWriteRoundTrip(makePath(InputFileName), |
| makePath(OutputFileName)); |
| } |
| |
| void SummaryTest::readWriteCompare(StringRef JSON) const { |
| const PathString InputFileName("input.json"); |
| const PathString OutputFileName("output.json"); |
| |
| auto ExpectedInputFilePath = writeJSON(JSON, InputFileName); |
| ASSERT_THAT_EXPECTED(ExpectedInputFilePath, Succeeded()); |
| |
| ASSERT_THAT_ERROR(readWriteRoundTrip(InputFileName, OutputFileName), |
| Succeeded()); |
| |
| auto ExpectedInputJSON = readJSONFromFile(InputFileName); |
| ASSERT_THAT_EXPECTED(ExpectedInputJSON, Succeeded()); |
| |
| auto ExpectedOutputJSON = readJSONFromFile(OutputFileName); |
| ASSERT_THAT_EXPECTED(ExpectedOutputJSON, Succeeded()); |
| |
| auto ExpectedNormalizedInputJSON = |
| normalizeSummaryJSON(*ExpectedInputJSON, GetParam().SummaryClassName); |
| ASSERT_THAT_EXPECTED(ExpectedNormalizedInputJSON, Succeeded()); |
| |
| auto ExpectedNormalizedOutputJSON = |
| normalizeSummaryJSON(*ExpectedOutputJSON, GetParam().SummaryClassName); |
| ASSERT_THAT_EXPECTED(ExpectedNormalizedOutputJSON, Succeeded()); |
| |
| ASSERT_EQ(*ExpectedNormalizedInputJSON, *ExpectedNormalizedOutputJSON) |
| << "Serialization is broken: input is different from output\n" |
| << "Input: " |
| << llvm::formatv("{0:2}", *ExpectedNormalizedInputJSON).str() << "\n" |
| << "Output: " |
| << llvm::formatv("{0:2}", *ExpectedNormalizedOutputJSON).str(); |
| } |
| |
| namespace { |
| |
| // ============================================================================ |
| // First Test Analysis - Simple analysis for testing JSON serialization. |
| // ============================================================================ |
| |
| json::Object serializePairsEntitySummaryForJSONFormatTest( |
| const EntitySummary &Summary, JSONFormat::EntityIdToJSONFn ToJSON) { |
| const auto &TA = |
| static_cast<const PairsEntitySummaryForJSONFormatTest &>(Summary); |
| json::Array PairsArray; |
| for (const auto &[First, Second] : TA.Pairs) { |
| PairsArray.push_back(json::Object{ |
| {"first", ToJSON(First)}, |
| {"second", ToJSON(Second)}, |
| }); |
| } |
| return json::Object{{"pairs", std::move(PairsArray)}}; |
| } |
| |
| Expected<std::unique_ptr<EntitySummary>> |
| deserializePairsEntitySummaryForJSONFormatTest( |
| const json::Object &Obj, EntityIdTable &IdTable, |
| JSONFormat::EntityIdFromJSONFn FromJSON) { |
| auto Result = std::make_unique<PairsEntitySummaryForJSONFormatTest>(); |
| const json::Array *PairsArray = Obj.getArray("pairs"); |
| if (!PairsArray) { |
| return createStringError(inconvertibleErrorCode(), |
| "missing or invalid field 'pairs'"); |
| } |
| for (const auto &[Index, Value] : llvm::enumerate(*PairsArray)) { |
| const json::Object *Pair = Value.getAsObject(); |
| if (!Pair) { |
| return createStringError( |
| inconvertibleErrorCode(), |
| "pairs element at index %zu is not a JSON object", Index); |
| } |
| const json::Object *FirstObj = Pair->getObject("first"); |
| if (!FirstObj) { |
| return createStringError( |
| inconvertibleErrorCode(), |
| "missing or invalid 'first' field at index '%zu'", Index); |
| } |
| const json::Object *SecondObj = Pair->getObject("second"); |
| if (!SecondObj) { |
| return createStringError( |
| inconvertibleErrorCode(), |
| "missing or invalid 'second' field at index '%zu'", Index); |
| } |
| auto ExpectedFirst = FromJSON(*FirstObj); |
| if (!ExpectedFirst) { |
| return createStringError(inconvertibleErrorCode(), |
| "invalid 'first' entity id at index '%zu': %s", |
| Index, |
| toString(ExpectedFirst.takeError()).c_str()); |
| } |
| auto ExpectedSecond = FromJSON(*SecondObj); |
| if (!ExpectedSecond) { |
| return createStringError(inconvertibleErrorCode(), |
| "invalid 'second' entity id at index '%zu': %s", |
| Index, |
| toString(ExpectedSecond.takeError()).c_str()); |
| } |
| Result->Pairs.emplace_back(*ExpectedFirst, *ExpectedSecond); |
| } |
| return std::move(Result); |
| } |
| |
| struct PairsEntitySummaryForJSONFormatTestFormatInfo final |
| : JSONFormat::FormatInfo { |
| PairsEntitySummaryForJSONFormatTestFormatInfo() |
| : JSONFormat::FormatInfo( |
| SummaryName("PairsEntitySummaryForJSONFormatTest"), |
| serializePairsEntitySummaryForJSONFormatTest, |
| deserializePairsEntitySummaryForJSONFormatTest) {} |
| }; |
| |
| llvm::Registry<JSONFormat::FormatInfo>::Add< |
| PairsEntitySummaryForJSONFormatTestFormatInfo> |
| RegisterPairsEntitySummaryForJSONFormatTest( |
| "PairsEntitySummaryForJSONFormatTest", |
| "Format info for PairsArrayEntitySummary"); |
| |
| // ============================================================================ |
| // Second Test Analysis - Simple analysis for multi-summary round-trip tests. |
| // ============================================================================ |
| |
| json::Object |
| serializeTagsEntitySummaryForJSONFormatTest(const EntitySummary &Summary, |
| JSONFormat::EntityIdToJSONFn) { |
| const auto &TA = |
| static_cast<const TagsEntitySummaryForJSONFormatTest &>(Summary); |
| json::Array TagsArray; |
| for (const auto &Tag : TA.Tags) { |
| TagsArray.push_back(Tag); |
| } |
| return json::Object{{"tags", std::move(TagsArray)}}; |
| } |
| |
| Expected<std::unique_ptr<EntitySummary>> |
| deserializeTagsEntitySummaryForJSONFormatTest(const json::Object &Obj, |
| EntityIdTable &, |
| JSONFormat::EntityIdFromJSONFn) { |
| auto Result = std::make_unique<TagsEntitySummaryForJSONFormatTest>(); |
| const json::Array *TagsArray = Obj.getArray("tags"); |
| if (!TagsArray) { |
| return createStringError(inconvertibleErrorCode(), |
| "missing or invalid field 'tags'"); |
| } |
| for (const auto &[Index, Value] : llvm::enumerate(*TagsArray)) { |
| auto Tag = Value.getAsString(); |
| if (!Tag) { |
| return createStringError(inconvertibleErrorCode(), |
| "tags element at index %zu is not a string", |
| Index); |
| } |
| Result->Tags.push_back(Tag->str()); |
| } |
| return std::move(Result); |
| } |
| |
| struct TagsEntitySummaryForJSONFormatTestFormatInfo final |
| : JSONFormat::FormatInfo { |
| TagsEntitySummaryForJSONFormatTestFormatInfo() |
| : JSONFormat::FormatInfo( |
| SummaryName("TagsEntitySummaryForJSONFormatTest"), |
| serializeTagsEntitySummaryForJSONFormatTest, |
| deserializeTagsEntitySummaryForJSONFormatTest) {} |
| }; |
| |
| llvm::Registry<JSONFormat::FormatInfo>::Add< |
| TagsEntitySummaryForJSONFormatTestFormatInfo> |
| RegisterTagsEntitySummaryForJSONFormatTest( |
| "TagsEntitySummaryForJSONFormatTest", |
| "Format info for TagsEntitySummary"); |
| |
| // ============================================================================ |
| // NullEntitySummaryForJSONFormatTest - For null data checks |
| // ============================================================================ |
| |
| struct NullEntitySummaryForJSONFormatTestFormatInfo final |
| : JSONFormat::FormatInfo { |
| NullEntitySummaryForJSONFormatTestFormatInfo() |
| : JSONFormat::FormatInfo( |
| SummaryName("NullEntitySummaryForJSONFormatTest"), |
| [](const EntitySummary &, JSONFormat::EntityIdToJSONFn) |
| -> json::Object { return json::Object{}; }, |
| [](const json::Object &, EntityIdTable &, |
| JSONFormat::EntityIdFromJSONFn) |
| -> llvm::Expected<std::unique_ptr<EntitySummary>> { |
| return nullptr; |
| }) {} |
| }; |
| |
| llvm::Registry<JSONFormat::FormatInfo>::Add< |
| NullEntitySummaryForJSONFormatTestFormatInfo> |
| RegisterNullEntitySummaryForJSONFormatTest( |
| "NullEntitySummaryForJSONFormatTest", |
| "Format info for NullEntitySummary"); |
| |
| // ============================================================================ |
| // MismatchedEntitySummaryForJSONFormatTest - For mismatched SummaryName checks |
| // ============================================================================ |
| |
| struct MismatchedEntitySummaryForJSONFormatTestFormatInfo final |
| : JSONFormat::FormatInfo { |
| MismatchedEntitySummaryForJSONFormatTestFormatInfo() |
| : JSONFormat::FormatInfo( |
| SummaryName("MismatchedEntitySummaryForJSONFormatTest"), |
| [](const EntitySummary &, JSONFormat::EntityIdToJSONFn) |
| -> json::Object { return json::Object{}; }, |
| [](const json::Object &, EntityIdTable &, |
| JSONFormat::EntityIdFromJSONFn) |
| -> llvm::Expected<std::unique_ptr<EntitySummary>> { |
| return std::make_unique< |
| MismatchedEntitySummaryForJSONFormatTest>(); |
| }) {} |
| }; |
| |
| llvm::Registry<JSONFormat::FormatInfo>::Add< |
| MismatchedEntitySummaryForJSONFormatTestFormatInfo> |
| RegisterMismatchedEntitySummaryForJSONFormatTest( |
| "MismatchedEntitySummaryForJSONFormatTest", |
| "Format info for MismatchedEntitySummary"); |
| |
| } // namespace |
