utl/test/tests/TmetaBasic.cpp

/*!
 * \file TmetaBasic.cpp
 *
 * Copyright (C) 2018 Christos Choutouridis
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
#include <utl/meta/meta.h>
#include <gtest/gtest.h>
#include <type_traits>

namespace TmetaBasic {
   using namespace utl;
   using namespace meta;

   /*
    * Types to behave like Fixtures
    */
   // Test type_of fixture
   template<class T> struct Identity {
      using type = T;
   };

   /*
    * Test integral constant
    */
   TEST(TmetaBasic, IntegrealType) {
      EXPECT_EQ(true, (std::is_same<int, eval<Identity<int>>>::value));
      EXPECT_EQ(true, (std::is_same<nil_, eval<nil_>>::value));
      EXPECT_EQ(true, (std::is_same<nil_, eval<eval<nil_>>>::value));
      EXPECT_EQ(true, (std::is_same<nil_, eval<eval<eval<nil_>>>>::value));
   }
   TEST(TmetaBasic, IntegrealConstant) {
      EXPECT_EQ(true, (std::is_same<int, integral_<int, 42>::value_type>::value));
      EXPECT_EQ(true, (std::is_same<int, integral_<int, 42>::type::value_type>::value));
      EXPECT_EQ(42, (integral_<int, 0>::value_type(42)));
      EXPECT_EQ(42, (integral_<int, 42>()));
   }
   TEST(TmetaBasic, BasicTypes) {
      EXPECT_EQ(true, (std::is_same<bool, bool_<false>::value_type>::value));
      EXPECT_EQ(true, bool_<true>::value);
      EXPECT_EQ(true, (std::is_same<bool, false_::value_type>::value));
      EXPECT_EQ(false, false_::value);
      EXPECT_EQ(true, (std::is_same<bool, true_::value_type>::value));
      EXPECT_EQ(true, true_::value);

      EXPECT_EQ(true, (std::is_same<int8_t, int8_<0>::value_type>::value));
      EXPECT_EQ(42, int8_<42>::value);
      EXPECT_EQ(true, (std::is_same<uint8_t, uint8_<0>::value_type>::value));
      EXPECT_EQ(42u, uint8_<42u>::value);
      EXPECT_EQ(true, (std::is_same<int16_t, int16_<0>::value_type>::value));
      EXPECT_EQ(42, int16_<42>::value);
      EXPECT_EQ(true, (std::is_same<uint16_t, uint16_<0>::value_type>::value));
      EXPECT_EQ(42u, uint16_<42u>::value);
      EXPECT_EQ(true, (std::is_same<int32_t, int32_<0>::value_type>::value));
      EXPECT_EQ(42, int32_<42>::value);
      EXPECT_EQ(true, (std::is_same<uint32_t, uint32_<0>::value_type>::value));
      EXPECT_EQ(42u, uint32_<42u>::value);

      EXPECT_EQ(true, (std::is_same<char, char_<0>::value_type>::value));
      EXPECT_EQ(42, char_<42>::value);
      EXPECT_EQ(true, (std::is_same<int, int_<0>::value_type>::value));
      EXPECT_EQ(42, int_<42>::value);
      EXPECT_EQ(true, (std::is_same<long, long_<0>::value_type>::value));
      EXPECT_EQ(42, long_<42>::value);

      EXPECT_EQ(true, (std::is_same<index_t, index_<0>::value_type>::value));
      EXPECT_EQ(42U, index_<42U>::value);
      EXPECT_EQ(true, (std::is_same<size_t, size_<0>::value_type>::value));
      EXPECT_EQ(42U, size_<42U>::value);

      EXPECT_EQ(sizeof(int), sizeof_<int>::value);
      EXPECT_EQ(alignof(int), alignof_<int>::value);
      EXPECT_EQ(static_cast<index_t>(-1), Npos::value);
   }

   /*
    * Test integral constant selection operations
    */
   TEST(TmetaBasic, Selection) {
      struct Foo {};
      struct Bar {};

      EXPECT_EQ (true, (std::is_same<int_<42>, if_c<true, int_<42>, false_>>()));
      EXPECT_EQ (true, (std::is_same<Foo,      if_c<false, int_<42>, Foo>>()));
      EXPECT_EQ (true, (std::is_same<Foo,      if_c<42, Foo, Bar>>()));

      EXPECT_EQ (true, (std::is_same<int_<42>, if_<true_, int_<42>, Bar>>()));
      EXPECT_EQ (true, (std::is_same<Bar,      if_<false_, int_<42>, Bar>>()));
      EXPECT_EQ (true, (std::is_same<int_<42>, if_<int_<1>, int_<42>, Bar>>()));
      EXPECT_EQ (true, (std::is_same<Foo,      if_<int_<0>, int_<42>, Foo>>()));

      EXPECT_EQ (true, (std::is_same<true_,  first_of<true_, false_>>()));
      EXPECT_EQ (false,(std::is_same<true_,  first_of<false_, true_>>()));
      EXPECT_EQ (false,(std::is_same<true_,  second_of<true_, false_>>()));
      EXPECT_EQ (true, (std::is_same<true_,  second_of<false_, true_>>()));

   }

   TEST(TmetaBasic, LogicalOperations) {
      struct Foo {};
      struct Bar {};

      EXPECT_EQ (true, (std::is_same<true_,  not_c<false>>::value));
      EXPECT_EQ (true, (std::is_same<false_, not_c<true>>::value));
      EXPECT_EQ (true, (std::is_same<false_, not_c<1>>::value));
      EXPECT_EQ (true, (std::is_same<true_,  not_c<0>>::value));

      EXPECT_EQ (true, (std::is_same<true_,  not_<false_>>()));
      EXPECT_EQ (true, (std::is_same<false_, not_<true_>>()));
      EXPECT_EQ (true, (std::is_same<true_,  not_<int_<0>>>()));
      EXPECT_EQ (true, (std::is_same<false_, not_<int_<1>>>()));

      EXPECT_EQ (true, (std::is_same<false_, or_<false_, false_, not_c<true>, int_<0>, not_<true_>>>()));
      EXPECT_EQ (true, (std::is_same<false_, or_<>>()));
      EXPECT_EQ (true, (std::is_same<int_<1>,or_<int_<1>>>()));
      EXPECT_EQ (true, (std::is_same<true_,  or_<true_>>()));
      EXPECT_EQ (true, (std::is_same<true_,  or_<false_, true_>>()));
      EXPECT_EQ (true, (std::is_same<true_,  or_<false_, false_, true_>>()));
      EXPECT_EQ (true, (std::is_same<int_<1>,or_<int_<0>, false_, not_<true_>, not_c<true>, int_<1>>>()));

      EXPECT_EQ (true, (std::is_same<true_,  and_<true_, true_, int_<1>, not_<false_>, not_c<false>>>()));
      EXPECT_EQ (true, (std::is_same<true_,  and_<>>()));
      EXPECT_EQ (true, (std::is_same<true_,  and_<true_>>()));
      EXPECT_EQ (true, (std::is_same<false_, and_<false_>>()));
      EXPECT_EQ (true, (std::is_same<true_,  and_<true_, true_>>()));
      EXPECT_EQ (true, (std::is_same<false_, and_<true_, false_>>()));
      EXPECT_EQ (true, (std::is_same<true_,  and_<true_, true_, true_>>()));
      EXPECT_EQ (true, (std::is_same<false_, and_<true_, true_, false_>>()));

      EXPECT_EQ (true,  (same_<Foo, Foo>()));
      EXPECT_EQ (false, (same_<Foo, Bar>()));
      EXPECT_EQ (true,  (not_same_<Foo, Bar>()));

   }

   /*
    * Test integral constant arithmetic operations
    */
   TEST(TmetaBasic, ArithmeticOperations) {
      EXPECT_EQ (int_<42>(), inc<int_<41>>());
      EXPECT_EQ (int_<42>(), dec<int_<43>>());
      EXPECT_EQ (int_<42>(), (add<int_<23>, add<int_<17>, int_<2>>>()));
      EXPECT_EQ (int_<42>(), (sub<int_<108>, int_<66>>()));
      EXPECT_EQ (int_<42>(), (mult<int_<7>, mult<int_<3>, int_<2>>>()));
      EXPECT_EQ (int_<42>(), (divide<int_<210>, int_<5>>()));
      EXPECT_EQ (int_<42>(), negate<int_<-42>>());
      EXPECT_EQ (int_< 1>(), (modulo<int_<43>, int_<42>>()));
   }

   /*
    * Test integral constant comparison operations
    */
   TEST(TmetaBasic, ComparisonOperations) {
      EXPECT_EQ (true,  (comp_eq<int_<7>, int_<7>>()));
      EXPECT_EQ (false, (comp_eq<int_<42>, int_<7>>()));

      EXPECT_EQ (true,  (comp_ne<int_<42>, int_<7>>()));
      EXPECT_EQ (false, (comp_ne<int_<42>, int_<42>>()));

      EXPECT_EQ (true,  (comp_lt<int_<42>, int_<43>>()));
      EXPECT_EQ (false, (comp_lt<int_<43>, int_<42>>()));

      EXPECT_EQ (true,  (comp_gt<int_<43>, int_<42>>()));
      EXPECT_EQ (false, (comp_gt<int_<42>, int_<43>>()));

      EXPECT_EQ (true,  (comp_le<int_<42>, int_<43>>()));
      EXPECT_EQ (true,  (comp_le<int_<42>, int_<42>>()));
      EXPECT_EQ (false, (comp_le<int_<43>, int_<42>>()));

      EXPECT_EQ (true,  (comp_ge<int_<43>, int_<42>>()));
      EXPECT_EQ (true,  (comp_ge<int_<42>, int_<42>>()));
      EXPECT_EQ (false, (comp_ge<int_<42>, int_<43>>()));
   }

   /*
    * Test integral constant bit operations
    */
   TEST(TmetaBasic, BitOperations) {
      EXPECT_EQ (0x00, (bitand_<uint8_<0x55>, uint8_<0xAA>>()));
      EXPECT_EQ (0xFF, (bitor_ <uint8_<0x55>, uint8_<0xAA>>()));
      EXPECT_EQ (0xFA, (bitxor_<uint8_<0x55>, uint8_<0xAF>>()));
      EXPECT_EQ (0x00, (bitnot_<uint8_<-1>>()));

      EXPECT_EQ (0x04, (shift_left<uint8_<0x01>, uint8_<2>>()));
      EXPECT_EQ (0x00, (shift_left<uint8_<0x80>, uint8_<1>>()));
      EXPECT_EQ (0x02, (shift_right<uint8_<0x08>, uint8_<2>>()));
      EXPECT_EQ (0x00, (shift_right<uint8_<0x01>, uint8_<1>>()));
   }

   /*
    * SFINAE
    */
   template <typename T, typename =when<same_<T, int>::type::value>>
   int check (T x) { return x; }
   int check (...) { return 0; }

   TEST(TmetaBasic, Sfinae) {
      EXPECT_EQ (42, check(42));
      EXPECT_EQ (0,  check(42.0));
      EXPECT_EQ (0,  check());

      // enable_if is imported so we trust stl and skip testing it
   }

}