clang-tools-extra/unittests/clang-doc/MergeTest.cpp

   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::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::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::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