spies.hpp

Go to the documentation of this file.

//
// Copyright (C) 2014, 2015 Ableton AG, Berlin. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//

#define BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES

#include <atria/meta/utils.hpp>

#include <ableton/build_system/Warnings.hpp>
ABL_DISABLE_WARNINGS
#include <boost/variant/static_visitor.hpp>
#include <boost/variant/apply_visitor.hpp>
#include <boost/optional.hpp>
ABL_RESTORE_WARNINGS
#include <unordered_set>
#include <typeindex>
#include <functional>
#include <memory>

namespace atria {
namespace testing {

class variant_spy : public boost::static_visitor<>
{
public:
  struct all_variants {};

  template <typename T>
  void operator()(const T&)
  {
    calls_.insert(typeid(T));
    calls_.insert(typeid(all_variants));
  }

  template <typename T = all_variants>
  std::size_t count() const
  {
    return calls_.count(typeid(T));
  }

  template<typename VariantT>
  auto visitor()
    -> ABL_DECLTYPE_RETURN(
      std::bind(
        static_cast<void (*) (variant_spy&, const VariantT&)>(
          &boost::apply_visitor<variant_spy, const VariantT>),
        std::ref(*this),
        std::placeholders::_1))

private:
  std::unordered_multiset<std::type_index> calls_;
};

namespace mocks {

template<typename T>
struct defaulting
{
  template <typename... Args>
  T operator() (Args&&...) { return T(); }
};

template<typename T>
struct returning
{
  returning() = default;

  template<typename Fn>
  returning(const Fn& mock)
    : mock_(mock)
  {}

  template <typename... Args>
  T operator() (Args&& ...) {
    return mock_();
  }

private:
  std::function<T()> mock_;
};

} // namespace mocks

namespace detail {

class spy_base
{
public:
  std::size_t count() const
  {
    return *count_;
  }

  void called()
  {
    ++ *count_;
  }

private:
  std::shared_ptr<std::size_t> count_ = std::make_shared<std::size_t>(0);
};

} // namespace detail


template<typename MockT = mocks::defaulting<void> >
class spy_fn : public detail::spy_base
{
  MockT mock_;

public:
  spy_fn() = default;

  template<typename MockT2>
  spy_fn(MockT2 mock)
    : mock_(std::move(mock))
  {}

  template<typename MockT2>
  spy_fn(MockT2 mock, const spy_base& spy)
    : spy_base(spy)
    , mock_(std::move(mock))
  {}

  template <typename... Args>
  auto operator() (Args&& ...args)
    -> ABL_DECLTYPE_RETURN(
      (called(),
       this->mock_(std::forward<Args>(args)...)))
};

template <typename Fn>
inline auto spy(const Fn& fn)
  -> spy_fn<Fn>
{
  return spy_fn<Fn>(fn);
}

inline auto spy()
  -> spy_fn<>
{
  return spy_fn<>();
}

namespace detail {

template <typename MockT>
class scoped_intruder
{
  boost::optional<MockT&> mock_;
  MockT original_;

public:
  scoped_intruder& operator=(const scoped_intruder&) = delete;
  scoped_intruder(const scoped_intruder&) = delete;

  scoped_intruder(scoped_intruder&& other)
  {
    swap(*this, other);
  }

  scoped_intruder& operator=(scoped_intruder&& other)
  {
    if (this != &other)
    {
      swap(*this, other);
    }
  }

  scoped_intruder(MockT& mock, MockT replacement)
    : mock_(mock)
    , original_(mock)
  {
    *mock_ = replacement;
  }

  ~scoped_intruder()
  {
    if (mock_)
    {
      *mock_ = original_;
    }
  }

  template <typename ...Args>
  auto operator() (Args&& ...args)
    -> decltype((*mock_)(std::forward<Args>(args)...))
  {
    assert(mock_ && "must not call intruder after having moved from it");
    return (*mock_)(std::forward<Args>(args)...);
  }

  friend void swap(scoped_intruder& a, scoped_intruder& b)
  {
    using std::swap;
    swap(a.mock_, b.mock_);
    swap(a.original_, b.original_);
  }
};

} // namespace detail

template <typename MockT>
inline auto spy_on(MockT& mock)
  -> spy_fn<detail::scoped_intruder<MockT> >
{
  auto s = spy(mock);
  return { detail::scoped_intruder<MockT>(mock, s), s };
}

template <typename MockT, typename FnT>
inline auto spy_on(MockT& mock, const FnT& replacement)
  -> spy_fn<detail::scoped_intruder<MockT> >
{
  auto s = spy(replacement);
  return { detail::scoped_intruder<MockT>(mock, s), s };
}

namespace detail {
struct default_copy_spy_base_t {};
} // namespace detail

template <typename BaseT = detail::default_copy_spy_base_t>
struct copy_spy : BaseT
{
  using base_t = BaseT;

  testing::spy_fn<> copied;

  copy_spy() = default;
  copy_spy(copy_spy&&) = default;
  copy_spy& operator=(copy_spy&&) = default;

  copy_spy(const copy_spy& x)
    : base_t(x)
    , copied(x.copied)
  {
    copied();
  }

  copy_spy& operator=(const copy_spy& x)
  {
    base_t::operator=(x);
    copied = x.copied;
    copied();
    return *this;
  }
};

} // namespace testing
} // namespace atria