Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Kitware
GitHub Repository: Kitware/CMake
 Path: blob/master/Tests/CMakeLib/testDebugger.h
3150 views
1
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying

2
   file LICENSE.rst or https://cmake.org/licensing for details.  */

3
#pragma once

4


5
#include <memory>

6
#include <vector>

7


8
#include "cmDebuggerAdapter.h"

9
#include "cmDebuggerProtocol.h"

10
#include "cmListFileCache.h"

11
#include "cmMessenger.h"

12
#include <cmcppdap/include/dap/io.h>

13
#include <cmcppdap/include/dap/session.h>

14
#include <cmcppdap/include/dap/types.h>

15


16
#include "testCommon.h"

17


18
#define ASSERT_VARIABLE(x, expectedName, expectedValue, expectedType)         \

19
  do {                                                                        \

20
    ASSERT_TRUE(x.name == expectedName);                                      \

21
    ASSERT_TRUE(x.value == expectedValue);                                    \

22
    if (expectedType == std::string()) {                                      \

23
      ASSERT_TRUE(x.type == dap::optional<dap::string>());                    \

24
    } else {                                                                  \

25
      ASSERT_TRUE(x.type == dap::optional<dap::string>(expectedType));        \

26
      if (std::string(expectedType) == "collection") {                        \

27
        ASSERT_TRUE(x.variablesReference != 0);                               \

28
      }                                                                       \

29
    }                                                                         \

30
    ASSERT_TRUE(x.evaluateName.has_value() == false);                         \

31
  } while (false)

32


33
#define ASSERT_VARIABLE_REFERENCE(x, expectedName, expectedValue,             \

34
                                  expectedType, expectedReference)            \

35
  do {                                                                        \

36
    ASSERT_VARIABLE(x, expectedName, expectedValue, expectedType);            \

37
    ASSERT_TRUE(x.variablesReference == (expectedReference));                 \

38
  } while (false)

39


40
#define ASSERT_VARIABLE_REFERENCE_NOT_ZERO(x, expectedName, expectedValue,    \

41
                                           expectedType)                      \

42
  do {                                                                        \

43
    ASSERT_VARIABLE(x, expectedName, expectedValue, expectedType);            \

44
    ASSERT_TRUE(x.variablesReference != 0);                                   \

45
  } while (false)

46


47
#define ASSERT_BREAKPOINT(x, expectedId, expectedLine, sourcePath,            \

48
                          isVerified)                                         \

49
  do {                                                                        \

50
    ASSERT_TRUE(x.id.has_value());                                            \

51
    ASSERT_TRUE(x.id.value() == expectedId);                                  \

52
    ASSERT_TRUE(x.line.has_value());                                          \

53
    ASSERT_TRUE(x.line.value() == expectedLine);                              \

54
    ASSERT_TRUE(x.source.has_value());                                        \

55
    ASSERT_TRUE(x.source.value().path.has_value());                           \

56
    ASSERT_TRUE(x.source.value().path.value() == sourcePath);                 \

57
    ASSERT_TRUE(x.verified == isVerified);                                    \

58
  } while (false)

59


60
class DebuggerTestHelper

61
{

62
  std::shared_ptr<dap::ReaderWriter> Client2Debugger = dap::pipe();

63
  std::shared_ptr<dap::ReaderWriter> Debugger2Client = dap::pipe();

64


65
public:

66
  std::unique_ptr<dap::Session> Client = dap::Session::create();

67
  std::unique_ptr<dap::Session> Debugger = dap::Session::create();

68
  void bind()

69
  {

70
    auto client2server = dap::pipe();

71
    auto server2client = dap::pipe();

72
    Client->bind(server2client, client2server);

73
    Debugger->bind(client2server, server2client);

74
  }

75
  std::vector<cmListFileFunction> CreateListFileFunctions(char const* str,

76
                                                          char const* filename)

77
  {

78
    cmMessenger messenger;

79
    cmListFileBacktrace backtrace;

80
    cmListFile listfile;

81
    listfile.ParseString(str, filename, &messenger, backtrace);

82
    return listfile.Functions;

83
  }

84
};

85


86
class ScopedThread

87
{

88
public:

89
  template <class... Args>

90
  explicit ScopedThread(Args&&... args)

91
    : Thread(std::forward<Args>(args)...)

92
  {

93
  }

94


95
  ~ScopedThread()

96
  {

97
    if (Thread.joinable())

98
      Thread.join();

99
  }

100


101
private:

102
  std::thread Thread;

103
};

104


105