C++ (Cpp) start_memory_checking Examples

Example #1

File: test_rcl.cpp Project: younata/rcl

 void SetUp()
 {
   set_on_unexpected_malloc_callback([]() {ASSERT_FALSE(true) << "UNEXPECTED MALLOC";});
   set_on_unexpected_realloc_callback([]() {ASSERT_FALSE(true) << "UNEXPECTED REALLOC";});
   set_on_unexpected_free_callback([]() {ASSERT_FALSE(true) << "UNEXPECTED FREE";});
   start_memory_checking();
 }

Example #2

File: test_service.cpp Project: erlerobot/rcl

 void SetUp()
 {
   stop_memory_checking();
   rcl_ret_t ret;
   ret = rcl_init(0, nullptr, rcl_get_default_allocator());
   ASSERT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe();
   this->node_ptr = new rcl_node_t;
   *this->node_ptr = rcl_get_zero_initialized_node();
   const char * name = "node_name";
   rcl_node_options_t node_options = rcl_node_get_default_options();
   ret = rcl_node_init(this->node_ptr, name, &node_options);
   ASSERT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe();
   set_on_unexpected_malloc_callback([]() {ASSERT_FALSE(true) << "UNEXPECTED MALLOC";});
   set_on_unexpected_realloc_callback([]() {ASSERT_FALSE(true) << "UNEXPECTED REALLOC";});
   set_on_unexpected_free_callback([]() {ASSERT_FALSE(true) << "UNEXPECTED FREE";});
   start_memory_checking();
 }

Example #3

File: test_subscription.cpp Project: dhood/rcl

class CLASSNAME (TestSubscriptionFixture, RMW_IMPLEMENTATION) : public ::testing::Test
{
public:
  rcl_node_t * node_ptr;
  void SetUp()
  {
    stop_memory_checking();
    rcl_ret_t ret;
    ret = rcl_init(0, nullptr, rcl_get_default_allocator());
    ASSERT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe();
    this->node_ptr = new rcl_node_t;
    *this->node_ptr = rcl_get_zero_initialized_node();
    const char * name = "node_name";
    rcl_node_options_t node_options = rcl_node_get_default_options();
    ret = rcl_node_init(this->node_ptr, name, &node_options);
    ASSERT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe();
    set_on_unexpected_malloc_callback([]() {ASSERT_FALSE(true) << "UNEXPECTED MALLOC";});
    set_on_unexpected_realloc_callback([]() {ASSERT_FALSE(true) << "UNEXPECTED REALLOC";});
    set_on_unexpected_free_callback([]() {ASSERT_FALSE(true) << "UNEXPECTED FREE";});
    start_memory_checking();
  }

Example #4

File: test_memory_tools.cpp Project: dhood/rcl

/* Tests the allocatation checking tools.
 */
TEST(TestMemoryTools, test_allocation_checking_tools) {
  size_t unexpected_mallocs = 0;
  auto on_unexpected_malloc = ([&unexpected_mallocs]() {
    unexpected_mallocs++;
  });
  set_on_unexpected_malloc_callback(on_unexpected_malloc);
  size_t unexpected_reallocs = 0;
  auto on_unexpected_realloc = ([&unexpected_reallocs]() {
    unexpected_reallocs++;
  });
  set_on_unexpected_realloc_callback(on_unexpected_realloc);
  size_t unexpected_frees = 0;
  auto on_unexpected_free = ([&unexpected_frees]() {
    unexpected_frees++;
  });
  set_on_unexpected_free_callback(on_unexpected_free);
  void * mem = nullptr;
  void * remem = nullptr;
  // First try before enabling, should have no effect.
  mem = malloc(1024);
  ASSERT_NE(mem, nullptr);
  remem = realloc(mem, 2048);
  ASSERT_NE(remem, nullptr);
  if (!remem) {free(mem);}
  free(remem);
  EXPECT_EQ(unexpected_mallocs, 0u);
  EXPECT_EQ(unexpected_reallocs, 0u);
  EXPECT_EQ(unexpected_frees, 0u);
  // Enable checking, but no assert, should have no effect.
  start_memory_checking();
  mem = malloc(1024);
  ASSERT_NE(mem, nullptr);
  remem = realloc(mem, 2048);
  ASSERT_NE(remem, nullptr);
  if (!remem) {free(mem);}
  free(remem);
  EXPECT_EQ(unexpected_mallocs, 0u);
  EXPECT_EQ(unexpected_reallocs, 0u);
  EXPECT_EQ(unexpected_frees, 0u);
  // Enable no_* asserts, should increment all once.
  assert_no_malloc_begin();
  assert_no_realloc_begin();
  assert_no_free_begin();
  mem = malloc(1024);
  assert_no_malloc_end();
  ASSERT_NE(mem, nullptr);
  remem = realloc(mem, 2048);
  assert_no_realloc_end();
  ASSERT_NE(remem, nullptr);
  if (!remem) {free(mem);}
  free(remem);
  assert_no_free_end();
  EXPECT_EQ(unexpected_mallocs, 1u);
  EXPECT_EQ(unexpected_reallocs, 1u);
  EXPECT_EQ(unexpected_frees, 1u);
  // Enable on malloc assert, only malloc should increment.
  assert_no_malloc_begin();
  mem = malloc(1024);
  assert_no_malloc_end();
  ASSERT_NE(mem, nullptr);
  remem = realloc(mem, 2048);
  ASSERT_NE(remem, nullptr);
  if (!remem) {free(mem);}
  free(remem);
  EXPECT_EQ(unexpected_mallocs, 2u);
  EXPECT_EQ(unexpected_reallocs, 1u);
  EXPECT_EQ(unexpected_frees, 1u);
  // Enable on realloc assert, only realloc should increment.
  assert_no_realloc_begin();
  mem = malloc(1024);
  ASSERT_NE(mem, nullptr);
  remem = realloc(mem, 2048);
  assert_no_realloc_end();
  ASSERT_NE(remem, nullptr);
  if (!remem) {free(mem);}
  free(remem);
  EXPECT_EQ(unexpected_mallocs, 2u);
  EXPECT_EQ(unexpected_reallocs, 2u);
  EXPECT_EQ(unexpected_frees, 1u);
  // Enable on free assert, only free should increment.
  assert_no_free_begin();
  mem = malloc(1024);
  ASSERT_NE(mem, nullptr);
  remem = realloc(mem, 2048);
  ASSERT_NE(remem, nullptr);
  if (!remem) {free(mem);}
  free(remem);
  assert_no_free_end();
  EXPECT_EQ(unexpected_mallocs, 2u);
  EXPECT_EQ(unexpected_reallocs, 2u);
  EXPECT_EQ(unexpected_frees, 2u);
  // Go again, after disabling asserts, should have no effect.
  mem = malloc(1024);
  ASSERT_NE(mem, nullptr);
  remem = realloc(mem, 2048);
  ASSERT_NE(remem, nullptr);
  if (!remem) {free(mem);}
  free(remem);
  EXPECT_EQ(unexpected_mallocs, 2u);
  EXPECT_EQ(unexpected_reallocs, 2u);
  EXPECT_EQ(unexpected_frees, 2u);
  // Go once more after disabling everything, should have no effect.
  stop_memory_checking();
  mem = malloc(1024);
  ASSERT_NE(mem, nullptr);
  remem = realloc(mem, 2048);
  ASSERT_NE(remem, nullptr);
  if (!remem) {free(mem);}
  free(remem);
  EXPECT_EQ(unexpected_mallocs, 2u);
  EXPECT_EQ(unexpected_reallocs, 2u);
  EXPECT_EQ(unexpected_frees, 2u);
}

Example #5

File: test_allocator.cpp Project: shizhexu/rcl

 TestAllocatorFixture()
 {
   start_memory_checking();
   stop_memory_checking();
 }