yap/test/operators_unary.cpp

// Copyright (C) 2016-2018 T. Zachary Laine
//
// 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)
#include <boost/yap/expression.hpp>

#include <gtest/gtest.h>

#include <sstream>


template<typename T>
using term = boost::yap::terminal<boost::yap::expression, T>;

template<typename T>
using term_ref = boost::yap::expression_ref<boost::yap::expression, term<T> &>;

template<typename T>
using term_cref =
    boost::yap::expression_ref<boost::yap::expression, term<T> const &>;

namespace yap = boost::yap;
namespace bh = boost::hana;


TEST(numeric, operators_unary_test)
{
    term<uint32_t> x{{2u}};
    term<uint32_t> const cx{{3u}};

    {
        yap::expression<yap::expr_kind::unary_plus, bh::tuple<term<uint32_t>>>
            term_expr = +term<uint32_t>{{1u}};
        yap::expression<
            yap::expr_kind::unary_plus,
            bh::tuple<term_ref<uint32_t>>>
            term_ref_expr = +x;
        yap::expression<
            yap::expr_kind::unary_plus,
            bh::tuple<term_cref<uint32_t>>>
            term_const_ref_expr = +cx;

        EXPECT_EQ(evaluate(term_expr), 1u);
        EXPECT_EQ(evaluate(term_ref_expr), 2u);
        EXPECT_EQ(evaluate(term_const_ref_expr), 3u);
    }

    {
        yap::expression<yap::expr_kind::negate, bh::tuple<term<uint32_t>>>
            term_expr = -term<uint32_t>{{1u}};
        yap::expression<yap::expr_kind::negate, bh::tuple<term_ref<uint32_t>>>
            term_ref_expr = -x;
        yap::expression<yap::expr_kind::negate, bh::tuple<term_cref<uint32_t>>>
            term_const_ref_expr = -cx;

        EXPECT_EQ(evaluate(term_expr), 0u - 1u);
        EXPECT_EQ(evaluate(term_ref_expr), 0u - 2u);
        EXPECT_EQ(evaluate(term_const_ref_expr), 0u - 3u);
    }

    {
        yap::expression<yap::expr_kind::complement, bh::tuple<term<uint32_t>>>
            term_expr = ~term<uint32_t>{{1u}};
        yap::expression<
            yap::expr_kind::complement,
            bh::tuple<term_ref<uint32_t>>>
            term_ref_expr = ~x;
        yap::expression<
            yap::expr_kind::complement,
            bh::tuple<term_cref<uint32_t>>>
            term_const_ref_expr = ~cx;

        EXPECT_EQ(evaluate(term_expr), 0xfffffffe);
        EXPECT_EQ(evaluate(term_ref_expr), 0xfffffffd);
        EXPECT_EQ(evaluate(term_const_ref_expr), 0xfffffffc);
    }

    {
        yap::expression<yap::expr_kind::logical_not, bh::tuple<term<uint32_t>>>
            term_expr = !term<uint32_t>{{1u}};
        yap::expression<
            yap::expr_kind::logical_not,
            bh::tuple<term_ref<uint32_t>>>
            term_ref_expr = !x;
        yap::expression<
            yap::expr_kind::logical_not,
            bh::tuple<term_cref<uint32_t>>>
            term_const_ref_expr = !cx;

        EXPECT_EQ(evaluate(term_expr), false);
        EXPECT_EQ(evaluate(term_ref_expr), false);
        EXPECT_EQ(evaluate(term_const_ref_expr), false);
    }

    {
        yap::expression<yap::expr_kind::pre_inc, bh::tuple<term<uint32_t>>>
            term_expr = ++term<uint32_t>{{1u}};
        yap::expression<yap::expr_kind::pre_inc, bh::tuple<term_ref<uint32_t>>>
            term_ref_expr = ++x;
        yap::expression<yap::expr_kind::pre_inc, bh::tuple<term_cref<uint32_t>>>
            term_const_ref_expr = ++cx;
        (void)term_const_ref_expr;

        EXPECT_EQ(evaluate(term_expr), 2u);
        EXPECT_EQ(evaluate(term_ref_expr), 3u);
    }
}

TEST(address_dereference, operators_unary_test)
{
    {
        uint32_t i = 1, j = 2, k = 3;
        term<uint32_t &> x{{j}};
        term<uint32_t &> const cx{{k}};

        yap::expression<yap::expr_kind::address_of, bh::tuple<term<uint32_t &>>>
            term_expr = &term<uint32_t &>{{i}};
        yap::expression<
            yap::expr_kind::address_of,
            bh::tuple<term_ref<uint32_t &>>>
            term_ref_expr = &x;
        yap::expression<
            yap::expr_kind::address_of,
            bh::tuple<term_cref<uint32_t &>>>
            term_const_ref_expr = &cx;

        EXPECT_EQ(evaluate(term_expr), &i);
        EXPECT_EQ(evaluate(term_ref_expr), &j);
        EXPECT_EQ(evaluate(term_const_ref_expr), &k);
    }

    {
        uint32_t i = 1, j = 2, k = 3;
        term<uint32_t *> x{{&j}};
        term<uint32_t *> const cx{{&k}};

        yap::
            expression<yap::expr_kind::dereference, bh::tuple<term<uint32_t *>>>
                term_expr = *term<uint32_t *>{{&i}};
        yap::expression<
            yap::expr_kind::dereference,
            bh::tuple<term_ref<uint32_t *>>>
            term_ref_expr = *x;
        yap::expression<
            yap::expr_kind::dereference,
            bh::tuple<term_cref<uint32_t *>>>
            term_const_ref_expr = *cx;

        EXPECT_EQ(evaluate(term_expr), i);
        EXPECT_EQ(evaluate(term_ref_expr), j);
        EXPECT_EQ(evaluate(term_const_ref_expr), k);
    }
}