#include <ring.h>

#include <cassert>
#include <cstdio>

#define LOG    \
  if (false) { \
  } else       \
    puts(__PRETTY_FUNCTION__)

/// A helper sruct to count instances, copy- and move constructions.
struct m {
  m() {
    LOG;
    ++cnt;
  }
  ~m() {
    LOG;
    --cnt;
  }
  m(const m&) {
    LOG;
    ++cnt;
    ++cpy;
  }
  m(m&&) noexcept {
    LOG;
    ++cnt;
    ++mov;
  }
  m& operator=(const m&) = delete;
  m& operator=(m&&) = delete;

  static std::size_t cnt;
  static std::size_t mov;
  static std::size_t cpy;
};

std::size_t m::cnt = 0;
std::size_t m::mov = 0;
std::size_t m::cpy = 0;

int main() {
  {
    ring<m, 8> r;

    assert(r.size() == 0);
    assert(r.is_empty());
    assert(!r.is_full());

    for (int i = 0; i < 10; ++i) {
      bool ok = r.emplace();
      i < 8 ? assert(ok) : assert(!ok);
    }

    assert(r.size() == 8);
    assert(!r.is_empty());
    assert(r.is_full());

    auto v = r.take();
#if __cplusplus >= 201703L
    assert(v.has_value());
#endif

    assert(r.size() == 7);
    assert(!r.is_empty());
    assert(!r.is_full());

    assert(m::cnt == 8);
  }

  assert(m::cnt == 0);

  m::mov = 0;
  m::cpy = 0;
  {
    ring<m, 8> r;

    // Move construct m from an m rvalue reference.
    assert(m::mov == 0);
    r.push(m{});
    assert(m::mov == 1);

    // Copy construct m from an m lvalue reference.
    m m;
    assert(m::cpy == 0);
    r.push(m);
    assert(m::cpy == 1);

    assert(m::cnt == 3);
  }

  assert(m::cnt == 0);
}