lldb/unittests/Utility/ReproducerTest.cpp

   1 //===-- ReproducerTest.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 "gmock/gmock.h"
  10 #include "gtest/gtest.h"
  11
  12 #include "lldb/Utility/FileSpec.h"
  13 #include "lldb/Utility/Reproducer.h"
  14 #include "lldb/Utility/ReproducerProvider.h"
  15 #include "llvm/ADT/ScopeExit.h"
  16 #include "llvm/Support/Error.h"
  17 #include "llvm/Testing/Support/Error.h"
  18
  19 using namespace llvm;
  20 using namespace lldb_private;
  21 using namespace lldb_private::repro;
  22
  23 class DummyProvider : public repro::Provider<DummyProvider> {
  24 public:
  25   struct Info {
  26     static const char *name;
  27     static const char *file;
  28   };
  29
  30   DummyProvider(const FileSpec &directory) : Provider(directory) {}
  31
  32   static char ID;
  33 };
  34
  35 class YamlMultiProvider
  36     : public MultiProvider<YamlRecorder, YamlMultiProvider> {
  37 public:
  38   struct Info {
  39     static const char *name;
  40     static const char *file;
  41   };
  42
  43   YamlMultiProvider(const FileSpec &directory) : MultiProvider(directory) {}
  44
  45   static char ID;
  46 };
  47
  48 const char *DummyProvider::Info::name = "dummy";
  49 const char *DummyProvider::Info::file = "dummy.yaml";
  50 const char *YamlMultiProvider::Info::name = "mutli";
  51 const char *YamlMultiProvider::Info::file = "mutli.yaml";
  52 char DummyProvider::ID = 0;
  53 char YamlMultiProvider::ID = 0;
  54
  55 class DummyReproducer : public Reproducer {
  56 public:
  57   DummyReproducer() : Reproducer(){};
  58
  59   using Reproducer::SetCapture;
  60 };
  61
  62 struct YamlData {
  63   YamlData() : i(-1) {}
  64   YamlData(int i) : i(i) {}
  65   int i;
  66 };
  67
  68 inline bool operator==(const YamlData &LHS, const YamlData &RHS) {
  69   return LHS.i == RHS.i;
  70 }
  71
  72 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(YamlData)
  73
  74 namespace llvm {
  75 namespace yaml {
  76 template <> struct MappingTraits<YamlData> {
  77   static void mapping(IO &io, YamlData &Y) { io.mapRequired("i", Y.i); };
  78 };
  79 } // namespace yaml
  80 } // namespace llvm
  81
  82 TEST(ReproducerTest, SetCapture) {
  83   DummyReproducer reproducer;
  84
  85   // Initially both generator and loader are unset.
  86   EXPECT_EQ(nullptr, reproducer.GetGenerator());
  87   EXPECT_EQ(nullptr, reproducer.GetLoader());
  88
  89   // Enable capture and check that means we have a generator.
  90   EXPECT_THAT_ERROR(
  91       reproducer.SetCapture(FileSpec("//bogus/path", FileSpec::Style::posix)),
  92       Succeeded());
  93   EXPECT_NE(nullptr, reproducer.GetGenerator());
  94   EXPECT_EQ(FileSpec("//bogus/path", FileSpec::Style::posix),
  95             reproducer.GetGenerator()->GetRoot());
  96   EXPECT_EQ(FileSpec("//bogus/path", FileSpec::Style::posix),
  97             reproducer.GetReproducerPath());
  98
  99   // Ensure that we cannot enable replay.
 100   EXPECT_EQ(nullptr, reproducer.GetLoader());
 101
 102   // Ensure we can disable the generator again.
 103   EXPECT_THAT_ERROR(reproducer.SetCapture(llvm::None), Succeeded());
 104   EXPECT_EQ(nullptr, reproducer.GetGenerator());
 105   EXPECT_EQ(nullptr, reproducer.GetLoader());
 106 }
 107
 108 TEST(GeneratorTest, Create) {
 109   DummyReproducer reproducer;
 110
 111   EXPECT_THAT_ERROR(
 112       reproducer.SetCapture(FileSpec("//bogus/path", FileSpec::Style::posix)),
 113       Succeeded());
 114   auto &generator = *reproducer.GetGenerator();
 115
 116   auto *provider = generator.Create<DummyProvider>();
 117   EXPECT_NE(nullptr, provider);
 118   EXPECT_EQ(FileSpec("//bogus/path", FileSpec::Style::posix),
 119             provider->GetRoot());
 120 }
 121
 122 TEST(GeneratorTest, Get) {
 123   DummyReproducer reproducer;
 124
 125   EXPECT_THAT_ERROR(
 126       reproducer.SetCapture(FileSpec("//bogus/path", FileSpec::Style::posix)),
 127       Succeeded());
 128   auto &generator = *reproducer.GetGenerator();
 129
 130   auto *provider = generator.Create<DummyProvider>();
 131   EXPECT_NE(nullptr, provider);
 132
 133   auto *provider_alt = generator.Get<DummyProvider>();
 134   EXPECT_EQ(provider, provider_alt);
 135 }
 136
 137 TEST(GeneratorTest, GetOrCreate) {
 138   DummyReproducer reproducer;
 139
 140   EXPECT_THAT_ERROR(
 141       reproducer.SetCapture(FileSpec("//bogus/path", FileSpec::Style::posix)),
 142       Succeeded());
 143   auto &generator = *reproducer.GetGenerator();
 144
 145   auto &provider = generator.GetOrCreate<DummyProvider>();
 146   EXPECT_EQ(FileSpec("//bogus/path", FileSpec::Style::posix),
 147             provider.GetRoot());
 148
 149   auto &provider_alt = generator.GetOrCreate<DummyProvider>();
 150   EXPECT_EQ(&provider, &provider_alt);
 151 }
 152
 153 TEST(GeneratorTest, YamlMultiProvider) {
 154   SmallString<128> root;
 155   std::error_code ec = llvm::sys::fs::createUniqueDirectory("reproducer", root);
 156   ASSERT_FALSE(static_cast<bool>(ec));
 157
 158   auto cleanup = llvm::make_scope_exit(
 159       [&] { EXPECT_FALSE(llvm::sys::fs::remove_directories(root.str())); });
 160
 161   YamlData data0(0);
 162   YamlData data1(1);
 163   YamlData data2(2);
 164   YamlData data3(3);
 165
 166   {
 167     DummyReproducer reproducer;
 168     EXPECT_THAT_ERROR(reproducer.SetCapture(FileSpec(root.str())), Succeeded());
 169
 170     auto &generator = *reproducer.GetGenerator();
 171     auto *provider = generator.Create<YamlMultiProvider>();
 172     ASSERT_NE(nullptr, provider);
 173
 174     auto *recorder = provider->GetNewRecorder();
 175     ASSERT_NE(nullptr, recorder);
 176     recorder->Record(data0);
 177     recorder->Record(data1);
 178
 179     recorder = provider->GetNewRecorder();
 180     ASSERT_NE(nullptr, recorder);
 181     recorder->Record(data2);
 182     recorder->Record(data3);
 183
 184     generator.Keep();
 185   }
 186 }