llvm/unittests/DebugInfo/LogicalView/CodeViewReaderTest.cpp

   1 //===- llvm/unittest/DebugInfo/LogicalView/CodeViewReaderTest.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 "llvm/DebugInfo/LogicalView/Core/LVCompare.h"
  10 #include "llvm/DebugInfo/LogicalView/Core/LVLine.h"
  11 #include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
  12 #include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
  13 #include "llvm/DebugInfo/LogicalView/Core/LVType.h"
  14 #include "llvm/DebugInfo/LogicalView/LVReaderHandler.h"
  15 #include "llvm/MC/TargetRegistry.h"
  16 #include "llvm/Support/COM.h"
  17 #include "llvm/Support/InitLLVM.h"
  18 #include "llvm/Support/ScopedPrinter.h"
  19 #include "llvm/Support/TargetSelect.h"
  20 #include "llvm/Support/ToolOutputFile.h"
  21 #include "llvm/Testing/Support/Error.h"
  22
  23 #include "gtest/gtest.h"
  24
  25 using namespace llvm;
  26 using namespace llvm::logicalview;
  27
  28 extern const char *TestMainArgv0;
  29
  30 namespace {
  31
  32 const char *CodeViewClang = "test-codeview-clang.o";
  33 const char *CodeViewMsvc = "test-codeview-msvc.o";
  34 const char *CodeViewPdbMsvc = "test-codeview-pdb-msvc.o";
  35
  36 // Helper function to get the first scope child from the given parent.
  37 LVScope *getFirstScopeChild(LVScope *Parent) {
  38   EXPECT_NE(Parent, nullptr);
  39   const LVScopes *Scopes = Parent->getScopes();
  40   EXPECT_NE(Scopes, nullptr);
  41   EXPECT_EQ(Scopes->size(), 1u);
  42
  43   LVScopes::const_iterator Iter = Scopes->begin();
  44   LVScope *Child = *Iter;
  45   EXPECT_NE(Child, nullptr);
  46   return Child;
  47 }
  48
  49 // Helper function to create a reader.
  50 std::unique_ptr<LVReader> createReader(LVReaderHandler &ReaderHandler,
  51                                        SmallString<128> &InputsDir,
  52                                        StringRef Filename) {
  53   SmallString<128> ObjectName(InputsDir);
  54   llvm::sys::path::append(ObjectName, Filename);
  55
  56   Expected<std::unique_ptr<LVReader>> ReaderOrErr =
  57       ReaderHandler.createReader(std::string(ObjectName));
  58   EXPECT_THAT_EXPECTED(ReaderOrErr, Succeeded());
  59   std::unique_ptr<LVReader> Reader = std::move(*ReaderOrErr);
  60   EXPECT_NE(Reader, nullptr);
  61   return Reader;
  62 }
  63
  64 // Check the logical elements basic properties (Clang - Codeview).
  65 void checkElementPropertiesClangCodeview(LVReader *Reader) {
  66   LVScopeRoot *Root = Reader->getScopesRoot();
  67   LVScopeCompileUnit *CompileUnit =
  68       static_cast<LVScopeCompileUnit *>(getFirstScopeChild(Root));
  69   LVScopeFunction *Function =
  70       static_cast<LVScopeFunction *>(getFirstScopeChild(CompileUnit));
  71
  72   EXPECT_EQ(Root->getFileFormatName(), "COFF-x86-64");
  73   EXPECT_EQ(Root->getName(), CodeViewClang);
  74
  75   EXPECT_EQ(CompileUnit->getBaseAddress(), 0u);
  76   EXPECT_TRUE(CompileUnit->getProducer().startswith("clang"));
  77   EXPECT_EQ(CompileUnit->getName(), "test.cpp");
  78
  79   EXPECT_EQ(Function->lineCount(), 16u);
  80   EXPECT_EQ(Function->scopeCount(), 1u);
  81   EXPECT_EQ(Function->symbolCount(), 3u);
  82   EXPECT_EQ(Function->typeCount(), 1u);
  83   EXPECT_EQ(Function->rangeCount(), 1u);
  84
  85   const LVLocations *Ranges = Function->getRanges();
  86   ASSERT_NE(Ranges, nullptr);
  87   ASSERT_EQ(Ranges->size(), 1u);
  88   LVLocations::const_iterator IterLocation = Ranges->begin();
  89   LVLocation *Location = (*IterLocation);
  90   EXPECT_STREQ(Location->getIntervalInfo().c_str(),
  91                "{Range} Lines 2:9 [0x0000000000:0x0000000046]");
  92
  93   LVRange RangeList;
  94   Function->getRanges(RangeList);
  95
  96   const LVRangeEntries &RangeEntries = RangeList.getEntries();
  97   ASSERT_EQ(RangeEntries.size(), 2u);
  98   LVRangeEntries::const_iterator IterRanges = RangeEntries.cbegin();
  99   LVRangeEntry RangeEntry = *IterRanges;
 100   EXPECT_EQ(RangeEntry.lower(), 0u);
 101   EXPECT_EQ(RangeEntry.upper(), 0x46u);
 102   EXPECT_EQ(RangeEntry.scope()->getLineNumber(), 0u);
 103   EXPECT_EQ(RangeEntry.scope()->getName(), "foo");
 104   EXPECT_EQ(RangeEntry.scope()->getOffset(), 0u);
 105
 106   ++IterRanges;
 107   RangeEntry = *IterRanges;
 108   EXPECT_EQ(RangeEntry.lower(), 0x21u);
 109   EXPECT_EQ(RangeEntry.upper(), 0x35u);
 110   EXPECT_EQ(RangeEntry.scope()->getLineNumber(), 0u);
 111   EXPECT_EQ(RangeEntry.scope()->getName(), "foo::?");
 112   EXPECT_EQ(RangeEntry.scope()->getOffset(), 0u);
 113
 114   const LVPublicNames &PublicNames = CompileUnit->getPublicNames();
 115   ASSERT_EQ(PublicNames.size(), 1u);
 116   LVPublicNames::const_iterator IterNames = PublicNames.cbegin();
 117   LVScope *Foo = (*IterNames).first;
 118   EXPECT_EQ(Foo->getName(), "foo");
 119   EXPECT_EQ(Foo->getLineNumber(), 0u);
 120   LVNameInfo NameInfo = (*IterNames).second;
 121   EXPECT_EQ(NameInfo.first, 0u);
 122   EXPECT_EQ(NameInfo.second, 0x46u);
 123
 124   // Lines (debug and assembler) for 'foo'.
 125   const LVLines *Lines = Foo->getLines();
 126   ASSERT_NE(Lines, nullptr);
 127   EXPECT_EQ(Lines->size(), 0x10u);
 128 }
 129
 130 // Check the logical elements basic properties (MSVC - Codeview).
 131 void checkElementPropertiesMsvcCodeview(LVReader *Reader) {
 132   LVScopeRoot *Root = Reader->getScopesRoot();
 133   LVScopeCompileUnit *CompileUnit =
 134       static_cast<LVScopeCompileUnit *>(getFirstScopeChild(Root));
 135   LVScopeFunction *Function =
 136       static_cast<LVScopeFunction *>(getFirstScopeChild(CompileUnit));
 137
 138   EXPECT_EQ(Root->getFileFormatName(), "COFF-x86-64");
 139   EXPECT_EQ(Root->getName(), CodeViewMsvc);
 140
 141   EXPECT_EQ(CompileUnit->getBaseAddress(), 0u);
 142   EXPECT_TRUE(CompileUnit->getProducer().startswith("Microsoft"));
 143   EXPECT_EQ(CompileUnit->getName(), "test.cpp");
 144
 145   EXPECT_EQ(Function->lineCount(), 14u);
 146   EXPECT_EQ(Function->scopeCount(), 1u);
 147   EXPECT_EQ(Function->symbolCount(), 3u);
 148   EXPECT_EQ(Function->typeCount(), 0u);
 149   EXPECT_EQ(Function->rangeCount(), 1u);
 150
 151   const LVLocations *Ranges = Function->getRanges();
 152   ASSERT_NE(Ranges, nullptr);
 153   ASSERT_EQ(Ranges->size(), 1u);
 154   LVLocations::const_iterator IterLocation = Ranges->begin();
 155   LVLocation *Location = (*IterLocation);
 156   EXPECT_STREQ(Location->getIntervalInfo().c_str(),
 157                "{Range} Lines 2:9 [0x0000000000:0x0000000031]");
 158
 159   LVRange RangeList;
 160   Function->getRanges(RangeList);
 161
 162   const LVRangeEntries &RangeEntries = RangeList.getEntries();
 163   ASSERT_EQ(RangeEntries.size(), 2u);
 164   LVRangeEntries::const_iterator IterRanges = RangeEntries.cbegin();
 165   LVRangeEntry RangeEntry = *IterRanges;
 166   EXPECT_EQ(RangeEntry.lower(), 0u);
 167   EXPECT_EQ(RangeEntry.upper(), 0x31u);
 168   EXPECT_EQ(RangeEntry.scope()->getLineNumber(), 0u);
 169   EXPECT_EQ(RangeEntry.scope()->getName(), "foo");
 170   EXPECT_EQ(RangeEntry.scope()->getOffset(), 0u);
 171
 172   ++IterRanges;
 173   RangeEntry = *IterRanges;
 174   EXPECT_EQ(RangeEntry.lower(), 0x1bu);
 175   EXPECT_EQ(RangeEntry.upper(), 0x28u);
 176   EXPECT_EQ(RangeEntry.scope()->getLineNumber(), 0u);
 177   EXPECT_EQ(RangeEntry.scope()->getName(), "foo::?");
 178   EXPECT_EQ(RangeEntry.scope()->getOffset(), 0u);
 179
 180   const LVPublicNames &PublicNames = CompileUnit->getPublicNames();
 181   ASSERT_EQ(PublicNames.size(), 1u);
 182   LVPublicNames::const_iterator IterNames = PublicNames.cbegin();
 183   LVScope *Foo = (*IterNames).first;
 184   EXPECT_EQ(Foo->getName(), "foo");
 185   EXPECT_EQ(Foo->getLineNumber(), 0u);
 186   LVNameInfo NameInfo = (*IterNames).second;
 187   EXPECT_EQ(NameInfo.first, 0u);
 188   EXPECT_EQ(NameInfo.second, 0x31u);
 189
 190   // Lines (debug and assembler) for 'foo'.
 191   const LVLines *Lines = Foo->getLines();
 192   ASSERT_NE(Lines, nullptr);
 193   EXPECT_EQ(Lines->size(), 0x0eu);
 194 }
 195
 196 // Check the logical elements basic properties (MSVC - PDB).
 197 void checkElementPropertiesMsvcCodeviewPdb(LVReader *Reader) {
 198   LVScopeRoot *Root = Reader->getScopesRoot();
 199   LVScopeCompileUnit *CompileUnit =
 200       static_cast<LVScopeCompileUnit *>(getFirstScopeChild(Root));
 201   LVScopeFunction *Function =
 202       static_cast<LVScopeFunction *>(getFirstScopeChild(CompileUnit));
 203
 204   EXPECT_EQ(Root->getFileFormatName(), "COFF-x86-64");
 205   EXPECT_EQ(Root->getName(), CodeViewPdbMsvc);
 206
 207   EXPECT_EQ(CompileUnit->getBaseAddress(), 0u);
 208   EXPECT_TRUE(CompileUnit->getProducer().startswith("Microsoft"));
 209   EXPECT_EQ(CompileUnit->getName(), "test.cpp");
 210
 211   EXPECT_EQ(Function->lineCount(), 14u);
 212   EXPECT_EQ(Function->scopeCount(), 1u);
 213   EXPECT_EQ(Function->symbolCount(), 3u);
 214   EXPECT_EQ(Function->typeCount(), 0u);
 215   EXPECT_EQ(Function->rangeCount(), 1u);
 216
 217   const LVLocations *Ranges = Function->getRanges();
 218   ASSERT_NE(Ranges, nullptr);
 219   ASSERT_EQ(Ranges->size(), 1u);
 220   LVLocations::const_iterator IterLocation = Ranges->begin();
 221   LVLocation *Location = (*IterLocation);
 222   EXPECT_STREQ(Location->getIntervalInfo().c_str(),
 223                "{Range} Lines 2:9 [0x0000000000:0x0000000031]");
 224
 225   LVRange RangeList;
 226   Function->getRanges(RangeList);
 227
 228   const LVRangeEntries &RangeEntries = RangeList.getEntries();
 229   ASSERT_EQ(RangeEntries.size(), 2u);
 230   LVRangeEntries::const_iterator IterRanges = RangeEntries.cbegin();
 231   LVRangeEntry RangeEntry = *IterRanges;
 232   EXPECT_EQ(RangeEntry.lower(), 0u);
 233   EXPECT_EQ(RangeEntry.upper(), 0x31u);
 234   EXPECT_EQ(RangeEntry.scope()->getLineNumber(), 0u);
 235   EXPECT_EQ(RangeEntry.scope()->getName(), "foo");
 236   EXPECT_EQ(RangeEntry.scope()->getOffset(), 0u);
 237
 238   ++IterRanges;
 239   RangeEntry = *IterRanges;
 240   EXPECT_EQ(RangeEntry.lower(), 0x1bu);
 241   EXPECT_EQ(RangeEntry.upper(), 0x28u);
 242   EXPECT_EQ(RangeEntry.scope()->getLineNumber(), 0u);
 243   EXPECT_EQ(RangeEntry.scope()->getName(), "foo::?");
 244   EXPECT_EQ(RangeEntry.scope()->getOffset(), 0u);
 245
 246   const LVPublicNames &PublicNames = CompileUnit->getPublicNames();
 247   ASSERT_EQ(PublicNames.size(), 1u);
 248   LVPublicNames::const_iterator IterNames = PublicNames.cbegin();
 249   LVScope *Foo = (*IterNames).first;
 250   EXPECT_EQ(Foo->getName(), "foo");
 251   EXPECT_EQ(Foo->getLineNumber(), 0u);
 252   LVNameInfo NameInfo = (*IterNames).second;
 253   EXPECT_EQ(NameInfo.first, 0u);
 254   EXPECT_EQ(NameInfo.second, 0x31u);
 255
 256   // Lines (debug and assembler) for 'foo'.
 257   const LVLines *Lines = Foo->getLines();
 258   ASSERT_NE(Lines, nullptr);
 259   EXPECT_EQ(Lines->size(), 0x0eu);
 260 }
 261
 262 struct SelectionInfo {
 263   const char *Name;
 264   LVElementGetFunction Function;
 265 };
 266
 267 // Check the logical elements selection.
 268 void checkElementSelection(LVReader *Reader, std::vector<SelectionInfo> &Data,
 269                            size_t Size) {
 270   LVScopeRoot *Root = Reader->getScopesRoot();
 271   LVScopeCompileUnit *CompileUnit =
 272       static_cast<LVScopeCompileUnit *>(getFirstScopeChild(Root));
 273
 274   // Get the matched elements.
 275   LVElements MatchedElements = CompileUnit->getMatchedElements();
 276   std::map<StringRef, LVElement *> MapElements;
 277   for (LVElement *Element : MatchedElements)
 278     MapElements[Element->getName()] = Element;
 279   ASSERT_EQ(MapElements.size(), Size);
 280
 281   std::map<StringRef, LVElement *>::iterator Iter = MapElements.begin();
 282   for (const SelectionInfo &Entry : Data) {
 283     // Get matched element.
 284     EXPECT_NE(Iter, MapElements.end());
 285     LVElement *Element = Iter->second;
 286     ASSERT_NE(Element, nullptr);
 287     EXPECT_NE(Element->getName().find(Entry.Name), StringRef::npos);
 288     EXPECT_EQ((Element->*Entry.Function)(), 1u);
 289     ++Iter;
 290   }
 291
 292   // Get the parents for the matched elements.
 293   LVScopes MatchedScopes = CompileUnit->getMatchedScopes();
 294   std::set<StringRef> SetScopes;
 295   for (LVScope *Scope : MatchedScopes)
 296     SetScopes.insert(Scope->getName());
 297   ASSERT_EQ(SetScopes.size(), 3u);
 298
 299   // Parents of selected elements.
 300   std::set<StringRef>::iterator IterScope;
 301   IterScope = SetScopes.find("foo");
 302   EXPECT_NE(IterScope, SetScopes.end());
 303   IterScope = SetScopes.find("foo::?");
 304   EXPECT_NE(IterScope, SetScopes.end());
 305   IterScope = SetScopes.find("test.cpp");
 306   EXPECT_NE(IterScope, SetScopes.end());
 307 }
 308
 309 // Check the logical elements comparison.
 310 void checkElementComparison(LVReader *Reference, LVReader *Target) {
 311   LVCompare Compare(nulls());
 312   Error Err = Compare.execute(Reference, Target);
 313   ASSERT_THAT_ERROR(std::move(Err), Succeeded());
 314
 315   // Get comparison table.
 316   LVPassTable PassTable = Compare.getPassTable();
 317   ASSERT_EQ(PassTable.size(), 2u);
 318
 319   LVReader *Reader;
 320   LVElement *Element;
 321   LVComparePass Pass;
 322
 323   // Reference: Missing TypeDefinition 'INTEGER'
 324   std::tie(Reader, Element, Pass) = PassTable[0];
 325   ASSERT_NE(Reader, nullptr);
 326   ASSERT_NE(Element, nullptr);
 327   EXPECT_EQ(Reader, Reference);
 328   EXPECT_EQ(Element->getLevel(), 3u);
 329   EXPECT_EQ(Element->getLineNumber(), 0u);
 330   EXPECT_EQ(Element->getName(), "INTEGER");
 331   EXPECT_EQ(Pass, LVComparePass::Missing);
 332
 333   // Target: Added TypeDefinition 'INTEGER'
 334   std::tie(Reader, Element, Pass) = PassTable[1];
 335   ASSERT_NE(Reader, nullptr);
 336   ASSERT_NE(Element, nullptr);
 337   EXPECT_EQ(Reader, Target);
 338   EXPECT_EQ(Element->getLevel(), 4u);
 339   EXPECT_EQ(Element->getLineNumber(), 0u);
 340   EXPECT_EQ(Element->getName(), "INTEGER");
 341   EXPECT_EQ(Pass, LVComparePass::Added);
 342 }
 343
 344 // Logical elements properties.
 345 void elementProperties(SmallString<128> &InputsDir) {
 346   // Reader options.
 347   LVOptions ReaderOptions;
 348   ReaderOptions.setAttributeOffset();
 349   ReaderOptions.setAttributeFormat();
 350   ReaderOptions.setAttributeFilename();
 351   ReaderOptions.setAttributeProducer();
 352   ReaderOptions.setAttributePublics();
 353   ReaderOptions.setAttributeRange();
 354   ReaderOptions.setAttributeLocation();
 355   ReaderOptions.setPrintAll();
 356   ReaderOptions.resolveDependencies();
 357
 358   std::vector<std::string> Objects;
 359   ScopedPrinter W(outs());
 360   LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);
 361
 362   // Check logical elements properties.
 363   {
 364     std::unique_ptr<LVReader> Reader =
 365         createReader(ReaderHandler, InputsDir, CodeViewClang);
 366     checkElementPropertiesClangCodeview(Reader.get());
 367   }
 368   {
 369     std::unique_ptr<LVReader> Reader =
 370         createReader(ReaderHandler, InputsDir, CodeViewMsvc);
 371     checkElementPropertiesMsvcCodeview(Reader.get());
 372   }
 373   {
 374     std::unique_ptr<LVReader> Reader =
 375         createReader(ReaderHandler, InputsDir, CodeViewPdbMsvc);
 376     checkElementPropertiesMsvcCodeviewPdb(Reader.get());
 377   }
 378 }
 379
 380 // Logical elements selection.
 381 void elementSelection(SmallString<128> &InputsDir) {
 382   // Reader options.
 383   LVOptions ReaderOptions;
 384   ReaderOptions.setAttributeOffset();
 385   ReaderOptions.setPrintAll();
 386
 387   ReaderOptions.setSelectIgnoreCase();
 388   ReaderOptions.setSelectUseRegex();
 389
 390   ReaderOptions.setReportList(); // Matched elements.
 391   ReaderOptions.setReportView(); // Parents for matched elements.
 392
 393   // Add patterns.
 394   ReaderOptions.Select.Generic.insert("foo");
 395   ReaderOptions.Select.Generic.insert("movl[ \t]?%");
 396   ReaderOptions.Select.Generic.insert("INT[a-z]*");
 397   ReaderOptions.Select.Generic.insert("CONSTANT");
 398
 399   ReaderOptions.resolveDependencies();
 400
 401   std::vector<std::string> Objects;
 402   ScopedPrinter W(outs());
 403   LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);
 404
 405   // Check logical elements selection.
 406   {
 407     std::vector<SelectionInfo> DataClang = {
 408         {"* const int", &LVElement::getIsType},
 409         {"CONSTANT", &LVElement::getIsSymbol},
 410         {"INTEGER", &LVElement::getIsType},
 411         {"INTPTR", &LVElement::getIsType},
 412         {"ParamPtr", &LVElement::getIsSymbol},
 413         {"const int", &LVElement::getIsType},
 414         {"foo", &LVElement::getIsScope},
 415         {"foo::?", &LVElement::getIsScope},
 416         {"int", &LVElement::getIsType},
 417         {"movl", &LVElement::getIsLine},
 418         {"movl", &LVElement::getIsLine}};
 419     std::unique_ptr<LVReader> Reader =
 420         createReader(ReaderHandler, InputsDir, CodeViewClang);
 421     checkElementSelection(Reader.get(), DataClang, DataClang.size());
 422   }
 423   {
 424     std::vector<SelectionInfo> DataMsvc = {
 425         {"* const int", &LVElement::getIsType},
 426         {"CONSTANT", &LVElement::getIsSymbol},
 427         {"INTEGER", &LVElement::getIsType},
 428         {"INTPTR", &LVElement::getIsType},
 429         {"ParamPtr", &LVElement::getIsSymbol},
 430         {"const int", &LVElement::getIsType},
 431         {"foo", &LVElement::getIsScope},
 432         {"foo::?", &LVElement::getIsScope},
 433         {"int", &LVElement::getIsType},
 434         {"movl", &LVElement::getIsLine}};
 435     std::unique_ptr<LVReader> Reader =
 436         createReader(ReaderHandler, InputsDir, CodeViewMsvc);
 437     checkElementSelection(Reader.get(), DataMsvc, DataMsvc.size());
 438   }
 439 }
 440
 441 // Compare logical elements.
 442 void compareElements(SmallString<128> &InputsDir) {
 443   // Reader options.
 444   LVOptions ReaderOptions;
 445   ReaderOptions.setAttributeOffset();
 446   ReaderOptions.setPrintLines();
 447   ReaderOptions.setPrintSymbols();
 448   ReaderOptions.setPrintTypes();
 449   ReaderOptions.setCompareLines();
 450   ReaderOptions.setCompareSymbols();
 451   ReaderOptions.setCompareTypes();
 452
 453   ReaderOptions.resolveDependencies();
 454
 455   std::vector<std::string> Objects;
 456   ScopedPrinter W(outs());
 457   LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);
 458
 459   // Check logical comparison.
 460   std::unique_ptr<LVReader> Reference =
 461       createReader(ReaderHandler, InputsDir, CodeViewClang);
 462   std::unique_ptr<LVReader> Target =
 463       createReader(ReaderHandler, InputsDir, CodeViewMsvc);
 464   checkElementComparison(Reference.get(), Target.get());
 465 }
 466
 467 TEST(LogicalViewTest, CodeViewReader) {
 468   // Initialize targets and assembly printers/parsers.
 469   llvm::InitializeAllTargetInfos();
 470   llvm::InitializeAllTargetMCs();
 471   InitializeAllDisassemblers();
 472
 473   llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);
 474
 475   // This test requires a x86-registered-target.
 476   Triple TT;
 477   TT.setArch(Triple::x86_64);
 478   TT.setVendor(Triple::UnknownVendor);
 479   TT.setOS(Triple::UnknownOS);
 480
 481   std::string TargetLookupError;
 482   if (!TargetRegistry::lookupTarget(std::string(TT.str()), TargetLookupError))
 483     return;
 484
 485   SmallString<128> InputsDir = unittest::getInputFileDirectory(TestMainArgv0);
 486
 487   // Logical elements general properties and selection.
 488   elementProperties(InputsDir);
 489   elementSelection(InputsDir);
 490
 491   // Compare logical elements.
 492   compareElements(InputsDir);
 493 }
 494
 495 } // namespace