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