1 //===-- clang-doc/MergeTest.cpp -------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "ClangDocTest.h" 10 #include "Representation.h" 11 #include "gtest/gtest.h" 12 13 namespace clang { 14 namespace doc { 15 16 TEST(MergeTest, mergeNamespaceInfos) { 17 NamespaceInfo One; 18 One.Name = "Namespace"; 19 One.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 20 21 One.ChildNamespaces.emplace_back(NonEmptySID, "ChildNamespace", 22 InfoType::IT_namespace); 23 One.ChildRecords.emplace_back(NonEmptySID, "ChildStruct", 24 InfoType::IT_record); 25 One.ChildFunctions.emplace_back(); 26 One.ChildFunctions.back().Name = "OneFunction"; 27 One.ChildFunctions.back().USR = NonEmptySID; 28 One.ChildEnums.emplace_back(); 29 One.ChildEnums.back().Name = "OneEnum"; 30 One.ChildEnums.back().USR = NonEmptySID; 31 32 NamespaceInfo Two; 33 Two.Name = "Namespace"; 34 Two.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 35 36 Two.ChildNamespaces.emplace_back(EmptySID, "OtherChildNamespace", 37 InfoType::IT_namespace); 38 Two.ChildRecords.emplace_back(EmptySID, "OtherChildStruct", 39 InfoType::IT_record); 40 Two.ChildFunctions.emplace_back(); 41 Two.ChildFunctions.back().Name = "TwoFunction"; 42 Two.ChildEnums.emplace_back(); 43 Two.ChildEnums.back().Name = "TwoEnum"; 44 45 std::vector<std::unique_ptr<Info>> Infos; 46 Infos.emplace_back(std::make_unique<NamespaceInfo>(std::move(One))); 47 Infos.emplace_back(std::make_unique<NamespaceInfo>(std::move(Two))); 48 49 auto Expected = std::make_unique<NamespaceInfo>(); 50 Expected->Name = "Namespace"; 51 Expected->Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 52 53 Expected->ChildNamespaces.emplace_back(NonEmptySID, "ChildNamespace", 54 InfoType::IT_namespace); 55 Expected->ChildRecords.emplace_back(NonEmptySID, "ChildStruct", 56 InfoType::IT_record); 57 Expected->ChildNamespaces.emplace_back(EmptySID, "OtherChildNamespace", 58 InfoType::IT_namespace); 59 Expected->ChildRecords.emplace_back(EmptySID, "OtherChildStruct", 60 InfoType::IT_record); 61 Expected->ChildFunctions.emplace_back(); 62 Expected->ChildFunctions.back().Name = "OneFunction"; 63 Expected->ChildFunctions.back().USR = NonEmptySID; 64 Expected->ChildFunctions.emplace_back(); 65 Expected->ChildFunctions.back().Name = "TwoFunction"; 66 Expected->ChildEnums.emplace_back(); 67 Expected->ChildEnums.back().Name = "OneEnum"; 68 Expected->ChildEnums.back().USR = NonEmptySID; 69 Expected->ChildEnums.emplace_back(); 70 Expected->ChildEnums.back().Name = "TwoEnum"; 71 72 auto Actual = mergeInfos(Infos); 73 assert(Actual); 74 CheckNamespaceInfo(InfoAsNamespace(Expected.get()), 75 InfoAsNamespace(Actual.get().get())); 76 } 77 78 TEST(MergeTest, mergeRecordInfos) { 79 RecordInfo One; 80 One.Name = "r"; 81 One.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 82 83 One.DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 84 85 One.Members.emplace_back("int", "X", AccessSpecifier::AS_private); 86 One.TagType = TagTypeKind::TTK_Class; 87 One.Parents.emplace_back(EmptySID, "F", InfoType::IT_record); 88 One.VirtualParents.emplace_back(EmptySID, "G", InfoType::IT_record); 89 90 One.ChildRecords.emplace_back(NonEmptySID, "SharedChildStruct", 91 InfoType::IT_record); 92 One.ChildFunctions.emplace_back(); 93 One.ChildFunctions.back().Name = "OneFunction"; 94 One.ChildFunctions.back().USR = NonEmptySID; 95 One.ChildEnums.emplace_back(); 96 One.ChildEnums.back().Name = "OneEnum"; 97 One.ChildEnums.back().USR = NonEmptySID; 98 99 RecordInfo Two; 100 Two.Name = "r"; 101 Two.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 102 103 Two.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 104 105 Two.TagType = TagTypeKind::TTK_Class; 106 107 Two.ChildRecords.emplace_back(NonEmptySID, "SharedChildStruct", 108 InfoType::IT_record, "path"); 109 Two.ChildFunctions.emplace_back(); 110 Two.ChildFunctions.back().Name = "TwoFunction"; 111 Two.ChildEnums.emplace_back(); 112 Two.ChildEnums.back().Name = "TwoEnum"; 113 114 std::vector<std::unique_ptr<Info>> Infos; 115 Infos.emplace_back(std::make_unique<RecordInfo>(std::move(One))); 116 Infos.emplace_back(std::make_unique<RecordInfo>(std::move(Two))); 117 118 auto Expected = std::make_unique<RecordInfo>(); 119 Expected->Name = "r"; 120 Expected->Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 121 122 Expected->DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 123 Expected->Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 124 125 Expected->Members.emplace_back("int", "X", AccessSpecifier::AS_private); 126 Expected->TagType = TagTypeKind::TTK_Class; 127 Expected->Parents.emplace_back(EmptySID, "F", InfoType::IT_record); 128 Expected->VirtualParents.emplace_back(EmptySID, "G", InfoType::IT_record); 129 130 Expected->ChildRecords.emplace_back(NonEmptySID, "SharedChildStruct", 131 InfoType::IT_record, "path"); 132 Expected->ChildFunctions.emplace_back(); 133 Expected->ChildFunctions.back().Name = "OneFunction"; 134 Expected->ChildFunctions.back().USR = NonEmptySID; 135 Expected->ChildFunctions.emplace_back(); 136 Expected->ChildFunctions.back().Name = "TwoFunction"; 137 Expected->ChildEnums.emplace_back(); 138 Expected->ChildEnums.back().Name = "OneEnum"; 139 Expected->ChildEnums.back().USR = NonEmptySID; 140 Expected->ChildEnums.emplace_back(); 141 Expected->ChildEnums.back().Name = "TwoEnum"; 142 143 auto Actual = mergeInfos(Infos); 144 assert(Actual); 145 CheckRecordInfo(InfoAsRecord(Expected.get()), 146 InfoAsRecord(Actual.get().get())); 147 } 148 149 TEST(MergeTest, mergeFunctionInfos) { 150 FunctionInfo One; 151 One.Name = "f"; 152 One.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 153 154 One.DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 155 One.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 156 157 One.IsMethod = true; 158 One.Parent = Reference(EmptySID, "Parent", InfoType::IT_namespace); 159 160 One.Description.emplace_back(); 161 auto OneFullComment = &One.Description.back(); 162 OneFullComment->Kind = "FullComment"; 163 auto OneParagraphComment = std::make_unique<CommentInfo>(); 164 OneParagraphComment->Kind = "ParagraphComment"; 165 auto OneTextComment = std::make_unique<CommentInfo>(); 166 OneTextComment->Kind = "TextComment"; 167 OneTextComment->Text = "This is a text comment."; 168 OneParagraphComment->Children.push_back(std::move(OneTextComment)); 169 OneFullComment->Children.push_back(std::move(OneParagraphComment)); 170 171 FunctionInfo Two; 172 Two.Name = "f"; 173 Two.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 174 175 Two.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 176 177 Two.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default); 178 Two.Params.emplace_back("int", "P"); 179 180 Two.Description.emplace_back(); 181 auto TwoFullComment = &Two.Description.back(); 182 TwoFullComment->Kind = "FullComment"; 183 auto TwoParagraphComment = std::make_unique<CommentInfo>(); 184 TwoParagraphComment->Kind = "ParagraphComment"; 185 auto TwoTextComment = std::make_unique<CommentInfo>(); 186 TwoTextComment->Kind = "TextComment"; 187 TwoTextComment->Text = "This is a text comment."; 188 TwoParagraphComment->Children.push_back(std::move(TwoTextComment)); 189 TwoFullComment->Children.push_back(std::move(TwoParagraphComment)); 190 191 std::vector<std::unique_ptr<Info>> Infos; 192 Infos.emplace_back(std::make_unique<FunctionInfo>(std::move(One))); 193 Infos.emplace_back(std::make_unique<FunctionInfo>(std::move(Two))); 194 195 auto Expected = std::make_unique<FunctionInfo>(); 196 Expected->Name = "f"; 197 Expected->Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 198 199 Expected->DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 200 Expected->Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 201 202 Expected->ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default); 203 Expected->Params.emplace_back("int", "P"); 204 Expected->IsMethod = true; 205 Expected->Parent = Reference(EmptySID, "Parent", InfoType::IT_namespace); 206 207 Expected->Description.emplace_back(); 208 auto ExpectedFullComment = &Expected->Description.back(); 209 ExpectedFullComment->Kind = "FullComment"; 210 auto ExpectedParagraphComment = std::make_unique<CommentInfo>(); 211 ExpectedParagraphComment->Kind = "ParagraphComment"; 212 auto ExpectedTextComment = std::make_unique<CommentInfo>(); 213 ExpectedTextComment->Kind = "TextComment"; 214 ExpectedTextComment->Text = "This is a text comment."; 215 ExpectedParagraphComment->Children.push_back(std::move(ExpectedTextComment)); 216 ExpectedFullComment->Children.push_back(std::move(ExpectedParagraphComment)); 217 218 auto Actual = mergeInfos(Infos); 219 assert(Actual); 220 CheckFunctionInfo(InfoAsFunction(Expected.get()), 221 InfoAsFunction(Actual.get().get())); 222 } 223 224 TEST(MergeTest, mergeEnumInfos) { 225 EnumInfo One; 226 One.Name = "e"; 227 One.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 228 229 One.DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 230 One.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 231 232 One.Scoped = true; 233 234 EnumInfo Two; 235 Two.Name = "e"; 236 Two.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 237 238 Two.Loc.emplace_back(20, llvm::SmallString<16>{"test.cpp"}); 239 240 Two.Members.emplace_back("X"); 241 Two.Members.emplace_back("Y"); 242 243 std::vector<std::unique_ptr<Info>> Infos; 244 Infos.emplace_back(std::make_unique<EnumInfo>(std::move(One))); 245 Infos.emplace_back(std::make_unique<EnumInfo>(std::move(Two))); 246 247 auto Expected = std::make_unique<EnumInfo>(); 248 Expected->Name = "e"; 249 Expected->Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 250 251 Expected->DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 252 Expected->Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 253 Expected->Loc.emplace_back(20, llvm::SmallString<16>{"test.cpp"}); 254 255 Expected->Members.emplace_back("X"); 256 Expected->Members.emplace_back("Y"); 257 Expected->Scoped = true; 258 259 auto Actual = mergeInfos(Infos); 260 assert(Actual); 261 CheckEnumInfo(InfoAsEnum(Expected.get()), InfoAsEnum(Actual.get().get())); 262 } 263 264 } // namespace doc 265 } // namespace clang 266