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.Bases.emplace_back(EmptySID, "F", "path/to/F", true, 91 AccessSpecifier::AS_protected, true); 92 One.ChildRecords.emplace_back(NonEmptySID, "SharedChildStruct", 93 InfoType::IT_record); 94 One.ChildFunctions.emplace_back(); 95 One.ChildFunctions.back().Name = "OneFunction"; 96 One.ChildFunctions.back().USR = NonEmptySID; 97 One.ChildEnums.emplace_back(); 98 One.ChildEnums.back().Name = "OneEnum"; 99 One.ChildEnums.back().USR = NonEmptySID; 100 101 RecordInfo Two; 102 Two.Name = "r"; 103 Two.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 104 105 Two.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 106 107 Two.TagType = TagTypeKind::TTK_Class; 108 109 Two.ChildRecords.emplace_back(NonEmptySID, "SharedChildStruct", 110 InfoType::IT_record, "path"); 111 Two.ChildFunctions.emplace_back(); 112 Two.ChildFunctions.back().Name = "TwoFunction"; 113 Two.ChildEnums.emplace_back(); 114 Two.ChildEnums.back().Name = "TwoEnum"; 115 116 std::vector<std::unique_ptr<Info>> Infos; 117 Infos.emplace_back(std::make_unique<RecordInfo>(std::move(One))); 118 Infos.emplace_back(std::make_unique<RecordInfo>(std::move(Two))); 119 120 auto Expected = std::make_unique<RecordInfo>(); 121 Expected->Name = "r"; 122 Expected->Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 123 124 Expected->DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 125 Expected->Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 126 127 Expected->Members.emplace_back("int", "X", AccessSpecifier::AS_private); 128 Expected->TagType = TagTypeKind::TTK_Class; 129 Expected->Parents.emplace_back(EmptySID, "F", InfoType::IT_record); 130 Expected->VirtualParents.emplace_back(EmptySID, "G", InfoType::IT_record); 131 Expected->Bases.emplace_back(EmptySID, "F", "path/to/F", true, 132 AccessSpecifier::AS_protected, true); 133 134 Expected->ChildRecords.emplace_back(NonEmptySID, "SharedChildStruct", 135 InfoType::IT_record, "path"); 136 Expected->ChildFunctions.emplace_back(); 137 Expected->ChildFunctions.back().Name = "OneFunction"; 138 Expected->ChildFunctions.back().USR = NonEmptySID; 139 Expected->ChildFunctions.emplace_back(); 140 Expected->ChildFunctions.back().Name = "TwoFunction"; 141 Expected->ChildEnums.emplace_back(); 142 Expected->ChildEnums.back().Name = "OneEnum"; 143 Expected->ChildEnums.back().USR = NonEmptySID; 144 Expected->ChildEnums.emplace_back(); 145 Expected->ChildEnums.back().Name = "TwoEnum"; 146 147 auto Actual = mergeInfos(Infos); 148 assert(Actual); 149 CheckRecordInfo(InfoAsRecord(Expected.get()), 150 InfoAsRecord(Actual.get().get())); 151 } 152 153 TEST(MergeTest, mergeFunctionInfos) { 154 FunctionInfo One; 155 One.Name = "f"; 156 One.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 157 158 One.DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 159 One.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 160 161 One.IsMethod = true; 162 One.Parent = Reference(EmptySID, "Parent", InfoType::IT_namespace); 163 164 One.Description.emplace_back(); 165 auto OneFullComment = &One.Description.back(); 166 OneFullComment->Kind = "FullComment"; 167 auto OneParagraphComment = std::make_unique<CommentInfo>(); 168 OneParagraphComment->Kind = "ParagraphComment"; 169 auto OneTextComment = std::make_unique<CommentInfo>(); 170 OneTextComment->Kind = "TextComment"; 171 OneTextComment->Text = "This is a text comment."; 172 OneParagraphComment->Children.push_back(std::move(OneTextComment)); 173 OneFullComment->Children.push_back(std::move(OneParagraphComment)); 174 175 FunctionInfo Two; 176 Two.Name = "f"; 177 Two.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 178 179 Two.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 180 181 Two.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default); 182 Two.Params.emplace_back("int", "P"); 183 184 Two.Description.emplace_back(); 185 auto TwoFullComment = &Two.Description.back(); 186 TwoFullComment->Kind = "FullComment"; 187 auto TwoParagraphComment = std::make_unique<CommentInfo>(); 188 TwoParagraphComment->Kind = "ParagraphComment"; 189 auto TwoTextComment = std::make_unique<CommentInfo>(); 190 TwoTextComment->Kind = "TextComment"; 191 TwoTextComment->Text = "This is a text comment."; 192 TwoParagraphComment->Children.push_back(std::move(TwoTextComment)); 193 TwoFullComment->Children.push_back(std::move(TwoParagraphComment)); 194 195 std::vector<std::unique_ptr<Info>> Infos; 196 Infos.emplace_back(std::make_unique<FunctionInfo>(std::move(One))); 197 Infos.emplace_back(std::make_unique<FunctionInfo>(std::move(Two))); 198 199 auto Expected = std::make_unique<FunctionInfo>(); 200 Expected->Name = "f"; 201 Expected->Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 202 203 Expected->DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 204 Expected->Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 205 206 Expected->ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default); 207 Expected->Params.emplace_back("int", "P"); 208 Expected->IsMethod = true; 209 Expected->Parent = Reference(EmptySID, "Parent", InfoType::IT_namespace); 210 211 Expected->Description.emplace_back(); 212 auto ExpectedFullComment = &Expected->Description.back(); 213 ExpectedFullComment->Kind = "FullComment"; 214 auto ExpectedParagraphComment = std::make_unique<CommentInfo>(); 215 ExpectedParagraphComment->Kind = "ParagraphComment"; 216 auto ExpectedTextComment = std::make_unique<CommentInfo>(); 217 ExpectedTextComment->Kind = "TextComment"; 218 ExpectedTextComment->Text = "This is a text comment."; 219 ExpectedParagraphComment->Children.push_back(std::move(ExpectedTextComment)); 220 ExpectedFullComment->Children.push_back(std::move(ExpectedParagraphComment)); 221 222 auto Actual = mergeInfos(Infos); 223 assert(Actual); 224 CheckFunctionInfo(InfoAsFunction(Expected.get()), 225 InfoAsFunction(Actual.get().get())); 226 } 227 228 TEST(MergeTest, mergeEnumInfos) { 229 EnumInfo One; 230 One.Name = "e"; 231 One.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 232 233 One.DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 234 One.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 235 236 One.Scoped = true; 237 238 EnumInfo Two; 239 Two.Name = "e"; 240 Two.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 241 242 Two.Loc.emplace_back(20, llvm::SmallString<16>{"test.cpp"}); 243 244 Two.Members.emplace_back("X"); 245 Two.Members.emplace_back("Y"); 246 247 std::vector<std::unique_ptr<Info>> Infos; 248 Infos.emplace_back(std::make_unique<EnumInfo>(std::move(One))); 249 Infos.emplace_back(std::make_unique<EnumInfo>(std::move(Two))); 250 251 auto Expected = std::make_unique<EnumInfo>(); 252 Expected->Name = "e"; 253 Expected->Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 254 255 Expected->DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 256 Expected->Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 257 Expected->Loc.emplace_back(20, llvm::SmallString<16>{"test.cpp"}); 258 259 Expected->Members.emplace_back("X"); 260 Expected->Members.emplace_back("Y"); 261 Expected->Scoped = true; 262 263 auto Actual = mergeInfos(Infos); 264 assert(Actual); 265 CheckEnumInfo(InfoAsEnum(Expected.get()), InfoAsEnum(Actual.get().get())); 266 } 267 268 } // namespace doc 269 } // namespace clang 270