test-dynarray.cpp

#include <jsl/dynarray>
#include <boost/test/unit_test.hpp>
#include <memory>
#include <iostream>

//------------------------------------------------------------------------------
// Dynamically allocated box type. Just for memory leak checking.
template <class T>
class Box {
public:
    Box(const T &x = T())
        : xp_(new T(x)) {}
    const T &operator *() const
        { return *xp_; }
private:
    std::shared_ptr<T> xp_;
};

template <class T> bool operator==(const Box<T> &a, const Box<T> &b)
  { return *a == *b; }
template <class T> bool operator!=(const Box<T> &a, const Box<T> &b)
  { return *a != *b; }

typedef Box<int> IntBox;
typedef Box<float> FloatBox;

//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE(default_initialization)
{
    jsl::dynarray<int> v;
    BOOST_TEST(v.size() == 0);
    BOOST_TEST(v.empty());
}

BOOST_AUTO_TEST_CASE(sized_initialization)
{
    jsl::dynarray<int> v(3);
    BOOST_TEST(v.size() == 3);
    BOOST_TEST(!v.empty());
    BOOST_TEST(v[0] == 0);
    BOOST_TEST(v[1] == 0);
    BOOST_TEST(v[2] == 0);
}

BOOST_AUTO_TEST_CASE(repeated_initialization)
{
    jsl::dynarray<FloatBox> v(3, 7.0f);
    BOOST_TEST(v.size() == 3);
    BOOST_TEST(!v.empty());
    BOOST_TEST(*v[0] == 7.0f);
    BOOST_TEST(*v[1] == 7.0f);
    BOOST_TEST(*v[2] == 7.0f);
}

BOOST_AUTO_TEST_CASE(list_initialization)
{
    jsl::dynarray<IntBox> v {1,2,3};
    BOOST_TEST(v.size() == 3);
    BOOST_TEST(!v.empty());
    BOOST_TEST(*v[0] == 1);
    BOOST_TEST(*v[1] == 2);
    BOOST_TEST(*v[2] == 3);
}

BOOST_AUTO_TEST_CASE(range_initialization)
{
    std::vector<IntBox> w{7, 8, 9};
    jsl::dynarray<IntBox> v(w.begin(), w.end());
    BOOST_TEST(v.size() == 3);
    BOOST_TEST(!v.empty());
    BOOST_TEST(*v[0] == 7);
    BOOST_TEST(*v[1] == 8);
    BOOST_TEST(*v[2] == 9);
}

BOOST_AUTO_TEST_CASE(item_assignment)
{
    jsl::dynarray<IntBox> v(3);
    v[0] = 1;
    v[1] = 2;
    v[2] = 3;
    BOOST_TEST(*v[0] == 1);
    BOOST_TEST(*v[1] == 2);
    BOOST_TEST(*v[2] == 3);
}

BOOST_AUTO_TEST_CASE(fill)
{
    jsl::dynarray<IntBox> v(3);
    v.fill(7);
    BOOST_TEST(v.size() == 3);
    BOOST_TEST(*v[0] == 7);
    BOOST_TEST(*v[1] == 7);
    BOOST_TEST(*v[2] == 7);
}

BOOST_AUTO_TEST_CASE(clear)
{
    jsl::dynarray<IntBox> v(3);
    v.clear();
    BOOST_TEST(v.size() == 0);
    BOOST_TEST(v.empty());
}

BOOST_AUTO_TEST_CASE(reset)
{
    jsl::dynarray<IntBox> v(2);
    BOOST_TEST(v.size() == 2);
    v.reset(3);
    BOOST_TEST(v.size() == 3);
    BOOST_TEST(*v[0] == 0);
    BOOST_TEST(*v[1] == 0);
    BOOST_TEST(*v[2] == 0);
}

BOOST_AUTO_TEST_CASE(assign_repeated)
{
    jsl::dynarray<FloatBox> v;
    v.assign(3, 7.0f);
    BOOST_TEST(v.size() == 3);
    BOOST_TEST(*v[0] == 7.0f);
    BOOST_TEST(*v[1] == 7.0f);
    BOOST_TEST(*v[2] == 7.0f);
}

BOOST_AUTO_TEST_CASE(assign_list)
{
    jsl::dynarray<IntBox> v;
    v.assign({7, 8, 9});
    BOOST_TEST(v.size() == 3);
    BOOST_TEST(*v[0] == 7);
    BOOST_TEST(*v[1] == 8);
    BOOST_TEST(*v[2] == 9);
}

BOOST_AUTO_TEST_CASE(assign_range)
{
    jsl::dynarray<IntBox> v;
    std::vector<IntBox> w{7, 8, 9};
    v.assign(w.begin(), w.end());
    BOOST_TEST(v.size() == 3);
    BOOST_TEST(*v[0] == 7);
    BOOST_TEST(*v[1] == 8);
    BOOST_TEST(*v[2] == 9);
}

BOOST_AUTO_TEST_CASE(member_swap)
{
    jsl::dynarray<IntBox> v{1, 2};
    jsl::dynarray<IntBox> w{3, 4, 5};
    v.swap(w);
    BOOST_TEST(v.size() == 3);
    BOOST_TEST(*v[0] == 3);
    BOOST_TEST(*v[1] == 4);
    BOOST_TEST(*v[2] == 5);
    BOOST_TEST(w.size() == 2);
    BOOST_TEST(*w[0] == 1);
    BOOST_TEST(*w[1] == 2);
}

BOOST_AUTO_TEST_CASE(global_swap)
{
    jsl::dynarray<IntBox> v{1, 2};
    jsl::dynarray<IntBox> w{3, 4, 5};
    std::swap(v, w);
    BOOST_TEST(v.size() == 3);
    BOOST_TEST(*v[0] == 3);
    BOOST_TEST(*v[1] == 4);
    BOOST_TEST(*v[2] == 5);
    BOOST_TEST(w.size() == 2);
    BOOST_TEST(*w[0] == 1);
    BOOST_TEST(*w[1] == 2);
}

BOOST_AUTO_TEST_CASE(checked_access)
{
    jsl::dynarray<IntBox> v{1, 2};
    BOOST_TEST(v.size() == 2);
    BOOST_TEST(*v[0] == 1);
    BOOST_TEST(*v[1] == 2);
    BOOST_CHECK_THROW(v.at(2), std::out_of_range);
    BOOST_CHECK_THROW(v.at(3), std::out_of_range);
    v.at(0) = 3;
    v.at(1) = 4;
    BOOST_TEST(*v[0] == 3);
    BOOST_TEST(*v[1] == 4);
}

BOOST_AUTO_TEST_CASE(equality)
{
    jsl::dynarray<IntBox> v{1, 2, 3};
    jsl::dynarray<IntBox> w{1, 2, 3};
    jsl::dynarray<IntBox> x{1, 2, 4};
    jsl::dynarray<IntBox> y{1, 2};

    BOOST_TEST(v == v);
    BOOST_TEST(!(v != v));

    BOOST_TEST(v == w);
    BOOST_TEST(w == v);
    BOOST_TEST(!(v != w));
    BOOST_TEST(!(w != v));

    BOOST_TEST(!(v == x));
    BOOST_TEST(!(x == v));
    BOOST_TEST(v != x);
    BOOST_TEST(x != v);

    BOOST_TEST(!(v == y));
    BOOST_TEST(!(y == v));
    BOOST_TEST(v != y);
    BOOST_TEST(y != v);
}

BOOST_AUTO_TEST_CASE(front_back)
{
    jsl::dynarray<IntBox> v{1, 2, 3};
    BOOST_TEST(v.size() == 3);
    BOOST_TEST(*v.front() == 1);
    BOOST_TEST(*v.back() == 3);
    v.front() = 4;
    v.back() = 5;
    BOOST_TEST(*v.front() == 4);
    BOOST_TEST(*v.back() == 5);
}

BOOST_AUTO_TEST_CASE(bad_initialization)
{
    static unsigned instance_count = 0;

    struct InstanciableOnce {
        InstanciableOnce()
            { if (instance_count == 1) throw Error();
              p_.reset(new int); ++instance_count; }
        struct Error {};
        std::shared_ptr<int> p_;
    };

    jsl::dynarray<InstanciableOnce> v;
    BOOST_CHECK_THROW(v.reset(2), InstanciableOnce::Error);
    BOOST_TEST(v.empty());
}