boost_unordered 0.1.0

// Copyright 2006-2009 Daniel James.
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#if !defined(BOOST_UNORDERED_TEST_MEMORY_HEADER)
#define BOOST_UNORDERED_TEST_MEMORY_HEADER

#include "../helpers/test.hpp"
#include <boost/assert.hpp>
#include <boost/unordered/detail/implementation.hpp>
#include <map>
#include <memory>

namespace test {
  namespace detail {
    struct memory_area
    {
      void const* start;
      void const* end;

      memory_area(void const* s, void const* e) : start(s), end(e)
      {
        BOOST_ASSERT(start != end);
      }
    };

    struct memory_track
    {
      explicit memory_track(int tag = -1) : constructed_(0), tag_(tag) {}

      int constructed_;
      int tag_;
    };

    // This is a bit dodgy as it defines overlapping
    // areas as 'equal', so this isn't a total ordering.
    // But it is for non-overlapping memory regions - which
    // is what'll be stored.
    //
    // All searches will be for areas entirely contained by
    // a member of the set - so it should find the area that contains
    // the region that is searched for.

    struct memory_area_compare
    {
      bool operator()(memory_area const& x, memory_area const& y) const
      {
        return x.end <= y.start;
      }
    };

    struct memory_tracker
    {
      typedef std::map<memory_area, memory_track, memory_area_compare,
        std::allocator<std::pair<memory_area const, memory_track> > >
        allocated_memory_type;

      allocated_memory_type allocated_memory;
      unsigned int count_allocators;
      unsigned int count_allocations;
      unsigned int count_constructions;
      bool tracking_constructions;

      memory_tracker()
          : count_allocators(0), count_allocations(0), count_constructions(0),
            tracking_constructions(true)
      {
      }

      ~memory_tracker() { BOOST_ASSERT(count_allocators == 0); }

      void allocator_ref()
      {
        if (count_allocators == 0) {
          count_allocations = 0;
          count_constructions = 0;
          allocated_memory.clear();
        }
        ++count_allocators;
      }

      void allocator_unref()
      {
        BOOST_TEST(count_allocators > 0);
        if (count_allocators > 0) {
          --count_allocators;
          if (count_allocators == 0) {
            bool no_allocations_left = (count_allocations == 0);
            bool no_constructions_left = (count_constructions == 0);
            bool allocated_memory_empty = allocated_memory.empty();

            // Clearing the data before the checks terminate the
            // tests.
            count_allocations = 0;
            count_constructions = 0;
            allocated_memory.clear();

            BOOST_TEST(no_allocations_left);
            BOOST_TEST(no_constructions_left);
            BOOST_TEST(allocated_memory_empty);
          }
        }
      }

      void track_allocate(void* ptr, std::size_t n, std::size_t size, int tag)
      {
        if (n == 0) {
          BOOST_ERROR("Allocating 0 length array.");
        } else {
          ++count_allocations;
          allocated_memory.insert(std::pair<memory_area const, memory_track>(
            memory_area(ptr, (char*)ptr + n * size), memory_track(tag)));
        }
      }

      void track_deallocate(void* ptr, std::size_t n, std::size_t size, int tag,
        bool check_tag_ = true)
      {
        allocated_memory_type::iterator pos =
          allocated_memory.find(memory_area(ptr, (char*)ptr + n * size));
        if (pos == allocated_memory.end()) {
          BOOST_ERROR("Deallocating unknown pointer.");
        } else {
          BOOST_TEST(pos->first.start == ptr);
          BOOST_TEST(pos->first.end == (char*)ptr + n * size);
          if (check_tag_)
            BOOST_TEST(pos->second.tag_ == tag);
          allocated_memory.erase(pos);
        }
        BOOST_TEST(count_allocations > 0);
        if (count_allocations > 0)
          --count_allocations;
      }

      void track_construct(void* /*ptr*/, std::size_t /*size*/, int /*tag*/)
      {
        if (tracking_constructions) {
          ++count_constructions;
        }
      }

      void track_destroy(void* /*ptr*/, std::size_t /*size*/, int /*tag*/)
      {
        if (tracking_constructions) {
          BOOST_TEST(count_constructions > 0);
          if (count_constructions > 0)
            --count_constructions;
        }
      }
    };
  }

  namespace detail {
    // This won't be a problem as I'm only using a single compile unit
    // in each test (this is actually required by the minimal test
    // framework).
    //
    // boostinspect:nounnamed
    namespace {
      test::detail::memory_tracker tracker;
    }
  }

  namespace detail {
    struct disable_construction_tracking
    {
      bool old_value;

      disable_construction_tracking()
          : old_value(detail::tracker.tracking_constructions)
      {
        test::detail::tracker.tracking_constructions = false;
      }

      ~disable_construction_tracking()
      {
        test::detail::tracker.tracking_constructions = old_value;
      }

    private:
      disable_construction_tracking(disable_construction_tracking const&);
      disable_construction_tracking& operator=(
        disable_construction_tracking const&);
    };
  }
}

#endif