.. _program_listing_file__tmp_ws_src_apex_test_tools_apex_test_tools_include_apex_test_tools_apex_test_tools.hpp:

Program Listing for File apex_test_tools.hpp
============================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_apex_test_tools_apex_test_tools_include_apex_test_tools_apex_test_tools.hpp>` (``/tmp/ws/src/apex_test_tools/apex_test_tools/include/apex_test_tools/apex_test_tools.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   // Copyright 2017-2020 Apex.AI, Inc.
   //
   // Licensed under the Apache License, Version 2.0 (the "License");
   // you may not use this file except in compliance with the License.
   // You may obtain a copy of the License at
   //
   //     http://www.apache.org/licenses/LICENSE-2.0
   //
   // Unless required by applicable law or agreed to in writing, software
   // distributed under the License is distributed on an "AS IS" BASIS,
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   // See the License for the specific language governing permissions and
   // limitations under the License.
   #ifndef APEX_TEST_TOOLS__APEX_TEST_TOOLS_HPP_
   #define APEX_TEST_TOOLS__APEX_TEST_TOOLS_HPP_
   
   #include <gtest/gtest.h>
   #include <gtest/gtest-spi.h>
   #include <osrf_testing_tools_cpp/memory_tools/testing_helpers.hpp>
   #include <osrf_testing_tools_cpp/memory_tools/memory_tools.hpp>
   #include <osrf_testing_tools_cpp/scope_exit.hpp>
   #include <string>
   #include <tuple>
   
   namespace apex_test_tools
   {
   namespace memory_test
   {
   
   static std::tuple<const char *, const char *> whitelist_function_names[] = {
     std::tuple<const char *, const char *>{"testing::Message", "src/gtest.cc"},
   };
   
   inline bool is_whitelist_stacktrace(const osrf_testing_tools_cpp::memory_tools::StackTrace * st)
   {
     for (const auto & trace : st->get_traces()) {
       for (const auto & whitelist_name : whitelist_function_names) {
         const auto & fn_name = trace.object_function();
         const auto & src_name = trace.source_location().filename();
   
         if ((fn_name.find(std::get<0>(whitelist_name)) != std::string::npos) &&
           (src_name.find(std::get<1>(whitelist_name)) != std::string::npos))
         {
           return true;
         }
       }
     }
     return false;
   }
   
   inline void resume(void)
   {
     osrf_testing_tools_cpp::memory_tools::expect_no_malloc_begin();
     osrf_testing_tools_cpp::memory_tools::expect_no_realloc_begin();
     osrf_testing_tools_cpp::memory_tools::expect_no_calloc_begin();
     osrf_testing_tools_cpp::memory_tools::expect_no_free_begin();
   }
   
   inline void pause(void)
   {
     osrf_testing_tools_cpp::memory_tools::expect_no_malloc_end();
     osrf_testing_tools_cpp::memory_tools::expect_no_realloc_end();
     osrf_testing_tools_cpp::memory_tools::expect_no_calloc_end();
     osrf_testing_tools_cpp::memory_tools::expect_no_free_end();
   }
   
   inline void start(void)
   {
     osrf_testing_tools_cpp::memory_tools::initialize();
     // create a callback for "unexpected" mallocs that does a non-fatal gtest
     // failure and then register it with memory tools
     auto on_unexpected_malloc =
       [](osrf_testing_tools_cpp::memory_tools::MemoryToolsService & service) {
         // First, walk the stack trace to make sure we're not blowing up because of something
         // in googletest.  See gitlab issue #2489 for some history
         if (is_whitelist_stacktrace(service.get_stack_trace())) {
           service.ignore();
           return;
         }
   
         ADD_FAILURE() << "apex_test_tools::memory_test: Unexpected malloc";
         // this will cause a bracktrace to be printed for each unexpected malloc
         service.print_backtrace();
       };
     osrf_testing_tools_cpp::memory_tools::on_unexpected_malloc(on_unexpected_malloc);
   
     auto on_unexpected_realloc =
       [](osrf_testing_tools_cpp::memory_tools::MemoryToolsService & service) {
         ADD_FAILURE() << "apex_test_tools::memory_test: Unexpected realloc";
         // this will cause a bracktrace to be printed for each unexpected realloc
         service.print_backtrace();
       };
     osrf_testing_tools_cpp::memory_tools::on_unexpected_realloc(on_unexpected_realloc);
   
     auto on_unexpected_calloc =
       [](osrf_testing_tools_cpp::memory_tools::MemoryToolsService & service) {
         ADD_FAILURE() << "apex_test_tools::memory_test: Unexpected calloc";
         // this will cause a bracktrace to be printed for each unexpected calloc
         service.print_backtrace();
       };
     osrf_testing_tools_cpp::memory_tools::on_unexpected_calloc(on_unexpected_calloc);
   
     auto on_unexpected_free =
       [](osrf_testing_tools_cpp::memory_tools::MemoryToolsService & service) {
         if (is_whitelist_stacktrace(service.get_stack_trace())) {
           service.ignore();
           return;
         }
   
         ADD_FAILURE() << "apex_test_tools::memory_test: Unexpected free";
         // this will cause a bracktrace to be printed for each unexpected free
         service.print_backtrace();
       };
     osrf_testing_tools_cpp::memory_tools::on_unexpected_free(on_unexpected_free);
   
     osrf_testing_tools_cpp::memory_tools::enable_monitoring();
     apex_test_tools::memory_test::resume();
   }
   
   inline void start_paused(void)
   {
     apex_test_tools::memory_test::start();
     apex_test_tools::memory_test::pause();
   }
   
   inline void stop(void)
   {
     apex_test_tools::memory_test::pause();
     (void)osrf_testing_tools_cpp::memory_tools::disable_monitoring_in_all_threads();
     (void)osrf_testing_tools_cpp::memory_tools::uninitialize();
   }
   
   }  // namespace memory_test
   }  // namespace apex_test_tools
   
   #endif  // APEX_TEST_TOOLS__APEX_TEST_TOOLS_HPP_