1 //===-- clang-doc/MergeTest.cpp -------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "ClangDocTest.h" 11 #include "Representation.h" 12 #include "gtest/gtest.h" 13 14 namespace clang { 15 namespace doc { 16 17 TEST(MergeTest, mergeNamespaceInfos) { 18 NamespaceInfo One; 19 One.Name = "Namespace"; 20 One.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 21 22 One.ChildNamespaces.emplace_back(NonEmptySID, "ChildNamespace", 23 InfoType::IT_namespace); 24 One.ChildRecords.emplace_back(NonEmptySID, "ChildStruct", 25 InfoType::IT_record); 26 One.ChildFunctions.emplace_back(); 27 One.ChildFunctions.back().Name = "OneFunction"; 28 One.ChildFunctions.back().USR = NonEmptySID; 29 One.ChildEnums.emplace_back(); 30 One.ChildEnums.back().Name = "OneEnum"; 31 One.ChildEnums.back().USR = NonEmptySID; 32 33 NamespaceInfo Two; 34 Two.Name = "Namespace"; 35 Two.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 36 37 Two.ChildNamespaces.emplace_back(EmptySID, "OtherChildNamespace", 38 InfoType::IT_namespace); 39 Two.ChildRecords.emplace_back(EmptySID, "OtherChildStruct", 40 InfoType::IT_record); 41 Two.ChildFunctions.emplace_back(); 42 Two.ChildFunctions.back().Name = "TwoFunction"; 43 Two.ChildEnums.emplace_back(); 44 Two.ChildEnums.back().Name = "TwoEnum"; 45 46 std::vector<std::unique_ptr<Info>> Infos; 47 Infos.emplace_back(llvm::make_unique<NamespaceInfo>(std::move(One))); 48 Infos.emplace_back(llvm::make_unique<NamespaceInfo>(std::move(Two))); 49 50 auto Expected = llvm::make_unique<NamespaceInfo>(); 51 Expected->Name = "Namespace"; 52 Expected->Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 53 54 Expected->ChildNamespaces.emplace_back(NonEmptySID, "ChildNamespace", 55 InfoType::IT_namespace); 56 Expected->ChildRecords.emplace_back(NonEmptySID, "ChildStruct", 57 InfoType::IT_record); 58 Expected->ChildNamespaces.emplace_back(EmptySID, "OtherChildNamespace", 59 InfoType::IT_namespace); 60 Expected->ChildRecords.emplace_back(EmptySID, "OtherChildStruct", 61 InfoType::IT_record); 62 Expected->ChildFunctions.emplace_back(); 63 Expected->ChildFunctions.back().Name = "OneFunction"; 64 Expected->ChildFunctions.back().USR = NonEmptySID; 65 Expected->ChildFunctions.emplace_back(); 66 Expected->ChildFunctions.back().Name = "TwoFunction"; 67 Expected->ChildEnums.emplace_back(); 68 Expected->ChildEnums.back().Name = "OneEnum"; 69 Expected->ChildEnums.back().USR = NonEmptySID; 70 Expected->ChildEnums.emplace_back(); 71 Expected->ChildEnums.back().Name = "TwoEnum"; 72 73 auto Actual = mergeInfos(Infos); 74 assert(Actual); 75 CheckNamespaceInfo(InfoAsNamespace(Expected.get()), 76 InfoAsNamespace(Actual.get().get())); 77 } 78 79 TEST(MergeTest, mergeRecordInfos) { 80 RecordInfo One; 81 One.Name = "r"; 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("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.ChildRecords.emplace_back(NonEmptySID, "ChildStruct", 92 InfoType::IT_record); 93 One.ChildFunctions.emplace_back(); 94 One.ChildFunctions.back().Name = "OneFunction"; 95 One.ChildFunctions.back().USR = NonEmptySID; 96 One.ChildEnums.emplace_back(); 97 One.ChildEnums.back().Name = "OneEnum"; 98 One.ChildEnums.back().USR = NonEmptySID; 99 100 RecordInfo Two; 101 Two.Name = "r"; 102 Two.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 103 104 Two.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 105 106 Two.TagType = TagTypeKind::TTK_Class; 107 108 Two.ChildRecords.emplace_back(EmptySID, "OtherChildStruct", 109 InfoType::IT_record); 110 Two.ChildFunctions.emplace_back(); 111 Two.ChildFunctions.back().Name = "TwoFunction"; 112 Two.ChildEnums.emplace_back(); 113 Two.ChildEnums.back().Name = "TwoEnum"; 114 115 std::vector<std::unique_ptr<Info>> Infos; 116 Infos.emplace_back(llvm::make_unique<RecordInfo>(std::move(One))); 117 Infos.emplace_back(llvm::make_unique<RecordInfo>(std::move(Two))); 118 119 auto Expected = llvm::make_unique<RecordInfo>(); 120 Expected->Name = "r"; 121 Expected->Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 122 123 Expected->DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 124 Expected->Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 125 126 Expected->Members.emplace_back("int", "X", AccessSpecifier::AS_private); 127 Expected->TagType = TagTypeKind::TTK_Class; 128 Expected->Parents.emplace_back(EmptySID, "F", InfoType::IT_record); 129 Expected->VirtualParents.emplace_back(EmptySID, "G", InfoType::IT_record); 130 131 Expected->ChildRecords.emplace_back(NonEmptySID, "ChildStruct", 132 InfoType::IT_record); 133 Expected->ChildRecords.emplace_back(EmptySID, "OtherChildStruct", 134 InfoType::IT_record); 135 Expected->ChildFunctions.emplace_back(); 136 Expected->ChildFunctions.back().Name = "OneFunction"; 137 Expected->ChildFunctions.back().USR = NonEmptySID; 138 Expected->ChildFunctions.emplace_back(); 139 Expected->ChildFunctions.back().Name = "TwoFunction"; 140 Expected->ChildEnums.emplace_back(); 141 Expected->ChildEnums.back().Name = "OneEnum"; 142 Expected->ChildEnums.back().USR = NonEmptySID; 143 Expected->ChildEnums.emplace_back(); 144 Expected->ChildEnums.back().Name = "TwoEnum"; 145 146 auto Actual = mergeInfos(Infos); 147 assert(Actual); 148 CheckRecordInfo(InfoAsRecord(Expected.get()), 149 InfoAsRecord(Actual.get().get())); 150 } 151 152 TEST(MergeTest, mergeFunctionInfos) { 153 FunctionInfo One; 154 One.Name = "f"; 155 One.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 156 157 One.DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 158 One.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 159 160 One.IsMethod = true; 161 One.Parent = Reference(EmptySID, "Parent", InfoType::IT_namespace); 162 163 FunctionInfo Two; 164 Two.Name = "f"; 165 Two.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 166 167 Two.Loc.emplace_back(20, llvm::SmallString<16>{"test.cpp"}); 168 169 Two.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default); 170 Two.Params.emplace_back("int", "P"); 171 172 std::vector<std::unique_ptr<Info>> Infos; 173 Infos.emplace_back(llvm::make_unique<FunctionInfo>(std::move(One))); 174 Infos.emplace_back(llvm::make_unique<FunctionInfo>(std::move(Two))); 175 176 auto Expected = llvm::make_unique<FunctionInfo>(); 177 Expected->Name = "f"; 178 Expected->Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 179 180 Expected->DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 181 Expected->Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 182 Expected->Loc.emplace_back(20, llvm::SmallString<16>{"test.cpp"}); 183 184 Expected->ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default); 185 Expected->Params.emplace_back("int", "P"); 186 Expected->IsMethod = true; 187 Expected->Parent = Reference(EmptySID, "Parent", InfoType::IT_namespace); 188 189 auto Actual = mergeInfos(Infos); 190 assert(Actual); 191 CheckFunctionInfo(InfoAsFunction(Expected.get()), 192 InfoAsFunction(Actual.get().get())); 193 } 194 195 TEST(MergeTest, mergeEnumInfos) { 196 EnumInfo One; 197 One.Name = "e"; 198 One.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 199 200 One.DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 201 One.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 202 203 One.Scoped = true; 204 205 EnumInfo Two; 206 Two.Name = "e"; 207 Two.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 208 209 Two.Loc.emplace_back(20, llvm::SmallString<16>{"test.cpp"}); 210 211 Two.Members.emplace_back("X"); 212 Two.Members.emplace_back("Y"); 213 214 std::vector<std::unique_ptr<Info>> Infos; 215 Infos.emplace_back(llvm::make_unique<EnumInfo>(std::move(One))); 216 Infos.emplace_back(llvm::make_unique<EnumInfo>(std::move(Two))); 217 218 auto Expected = llvm::make_unique<EnumInfo>(); 219 Expected->Name = "e"; 220 Expected->Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace); 221 222 Expected->DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"}); 223 Expected->Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"}); 224 Expected->Loc.emplace_back(20, llvm::SmallString<16>{"test.cpp"}); 225 226 Expected->Members.emplace_back("X"); 227 Expected->Members.emplace_back("Y"); 228 Expected->Scoped = true; 229 230 auto Actual = mergeInfos(Infos); 231 assert(Actual); 232 CheckEnumInfo(InfoAsEnum(Expected.get()), InfoAsEnum(Actual.get().get())); 233 } 234 235 } // namespace doc 236 } // namespace clang 237