hoo2
/
utl
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Micro template library A library for building device drivers
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
39 Commits
3 Branches
5.6 MiB
 
 
 
 
Tree: 533a09625c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '533a09625c'
${ noResults }
utl/test/tests/Tmeta.cpp

394 lines
16 KiB
Raw Blame History 

  1. /*!

  2.  * \file Tmeta.cpp

  3.  *

  4.  * Copyright (C) 2018 Christos Choutouridis

  5.  *

  6.  * This program is free software: you can redistribute it and/or modify

  7.  * it under the terms of the GNU Lesser General Public License as

  8.  * published by the Free Software Foundation, either version 3

  9.  * of the License, or (at your option) any later version.

  10.  *

  11.  * This program is distributed in the hope that it will be useful,

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  14.  * GNU Lesser General Public License for more details.

  15.  *

  16.  * You should have received a copy of the GNU Lesser General Public License

  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.

  18.  *

  19.  */

  20. #include <utl/meta/meta.h>

  21. #include <gtest/gtest.h>

  22. #include <type_traits>

  23. 

  24. namespace test_meta {

  25.    using namespace utl;

  26.    using namespace meta;

  27. 

  28.    /*

  29.     * Types to behave like Fixtures

  30.     */

  31.    // Test type_of fixture

  32.    template<class T> struct TestTypeOf {

  33.       using type = T;

  34.    };

  35.    template<class T1, class T2> struct MfunBin {

  36.       using type = int;

  37.    };

  38.    template<int a, int b> struct MfunBin_i {

  39.       using type = int;

  40.    };

  41.    template<class T1> struct MfunUn1 {

  42.       using type = int;

  43.    };

  44.    template<class T1> struct MfunUn2 {

  45.       using type = int;

  46.    };

  47. 

  48.    template <typename T> struct Pred_isInt {

  49.       using type = std::is_integral<T>;

  50.    };

  51. 

  52.    template <typename T> struct Pred_isVoid {

  53.       using type = std::is_void<T>;

  54.    };

  55. 

  56.    /*

  57.     * Test integral constant

  58.     */

  59.    TEST(Tmeta_integral, Integreal_type_) {

  60.       EXPECT_EQ(true, (std::is_same<int, type_<TestTypeOf<int>>>::value));

  61.    }

  62.    TEST(Tmeta_integral, IntegrealConstant) {

  63.       EXPECT_EQ(true, (std::is_same<int, integral_constant<int, 42>::value_type>::value));

  64.       EXPECT_EQ(true, (std::is_same<int, integral_constant<int, 42>::type::value_type>::value));

  65.       EXPECT_EQ(42, (integral_constant<int, 0>::value_type(42)));

  66.       EXPECT_EQ(42, (integral_constant<int, 42>()));

  67.    }

  68.    TEST(Tmeta_integral, BasicTypes) {

  69.       EXPECT_EQ(true, (std::is_same<bool, bool_<false>::value_type>::value));

  70.       EXPECT_EQ(true, bool_<true>::value);

  71.       EXPECT_EQ(true, (std::is_same<bool, false_::value_type>::value));

  72.       EXPECT_EQ(false, false_::value);

  73.       EXPECT_EQ(true, (std::is_same<bool, true_::value_type>::value));

  74.       EXPECT_EQ(true, true_::value);

  75. 

  76.       EXPECT_EQ(true, (std::is_same<int8_t, int8_<0>::value_type>::value));

  77.       EXPECT_EQ(42, int8_<42>::value);

  78.       EXPECT_EQ(true, (std::is_same<uint8_t, uint8_<0>::value_type>::value));

  79.       EXPECT_EQ(42u, uint8_<42u>::value);

  80.       EXPECT_EQ(true, (std::is_same<int16_t, int16_<0>::value_type>::value));

  81.       EXPECT_EQ(42, int16_<42>::value);

  82.       EXPECT_EQ(true, (std::is_same<uint16_t, uint16_<0>::value_type>::value));

  83.       EXPECT_EQ(42u, uint16_<42u>::value);

  84.       EXPECT_EQ(true, (std::is_same<int32_t, int32_<0>::value_type>::value));

  85.       EXPECT_EQ(42, int32_<42>::value);

  86.       EXPECT_EQ(true, (std::is_same<uint32_t, uint32_<0>::value_type>::value));

  87.       EXPECT_EQ(42u, uint32_<42u>::value);

  88. 

  89.       EXPECT_EQ(true, (std::is_same<char, char_<0>::value_type>::value));

  90.       EXPECT_EQ(42, char_<42>::value);

  91.       EXPECT_EQ(true, (std::is_same<int, int_<0>::value_type>::value));

  92.       EXPECT_EQ(42, int_<42>::value);

  93.       EXPECT_EQ(true, (std::is_same<long, long_<0>::value_type>::value));

  94.       EXPECT_EQ(42, long_<42>::value);

  95. 

  96.       EXPECT_EQ(true, (std::is_same<index_t, index_t_<0>::value_type>::value));

  97.       EXPECT_EQ(42U, index_t_<42U>::value);

  98.       EXPECT_EQ(true, (std::is_same<size_t, size_t_<0>::value_type>::value));

  99.       EXPECT_EQ(42U, size_t_<42U>::value);

  100. 

  101.       EXPECT_EQ(sizeof(int), sizeof_<int>::value);

  102.       EXPECT_EQ(alignof(int), alignof_<int>::value);

  103.       EXPECT_EQ(static_cast<index_t>(-1), Npos::value);

  104.    }

  105.    /*

  106.     * Test integral constant arithmetic operations

  107.     */

  108.    TEST(Tmeta_integral, ArithmeticOperations) {

  109.       EXPECT_EQ (int_<42>(), inc<int_<41>>());

  110.       EXPECT_EQ (int_<42>(), dec<int_<43>>());

  111.       EXPECT_EQ (int_<42>(), (add<int_<23>, add<int_<17>, int_<2>>>()));

  112.       EXPECT_EQ (int_<42>(), (sub<int_<108>, int_<66>>()));

  113.       EXPECT_EQ (int_<42>(), (mult<int_<7>, mult<int_<3>, int_<2>>>()));

  114.       EXPECT_EQ (int_<42>(), (divide<int_<210>, int_<5>>()));

  115.       EXPECT_EQ (int_<42>(), negate<int_<-42>>());

  116.       EXPECT_EQ (int_< 1>(), (modulo<int_<43>, int_<42>>()));

  117.    }

  118. 

  119.    /*

  120.     * Test logical

  121.     */

  122.    TEST(Tmeta_logical, ComparisonOperations) {

  123.       EXPECT_EQ (true, (std::is_same<bool_<true>, not_c<false>>::value));

  124.       EXPECT_EQ (true, (comp_eq<int_<7>, int_<7>>()));

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

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

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

  128.       EXPECT_EQ (true, (comp_le<int_<42>, int_<42>>()));

  129.       EXPECT_EQ (true, (comp_ge<int_<42>, int_<42>>()));

  130.    }

  131. 

  132.    TEST(Tmeta_logical, BitOperations) {

  133.       EXPECT_EQ (0x00, (bitand_<uint8_<0x55>, uint8_<0xAA>>()));

  134.       EXPECT_EQ (0xFF, (bitor_ <uint8_<0x55>, uint8_<0xAA>>()));

  135.       EXPECT_EQ (0xFA, (bitxor_<uint8_<0x55>, uint8_<0xAF>>()));

  136.       EXPECT_EQ (0x00, (bitnot_<uint8_<-1>>()));

  137. 

  138.       EXPECT_EQ (0x04, (shift_left<uint8_<0x01>, uint8_<2>>()));

  139.       EXPECT_EQ (0x00, (shift_left<uint8_<0x80>, uint8_<1>>()));

  140.       EXPECT_EQ (0x02, (shift_right<uint8_<0x08>, uint8_<2>>()));

  141.       EXPECT_EQ (0x00, (shift_right<uint8_<0x01>, uint8_<1>>()));

  142.    }

  143. 

  144.    TEST(Tmeta_logical, TypeOperations) {

  145.       struct Foo {};

  146.       struct Bar {};

  147. 

  148.       EXPECT_EQ (true, (std::is_same<bool_<true>, not_<bool_<false>>>()));

  149.       EXPECT_EQ (true, (std::is_same<int_<42>, if_c<true, int_<42>, bool_<false>>>()));

  150.       EXPECT_EQ (true, (std::is_same<int_<42>, if_<bool_<true>, int_<42>, bool_<false>>>()));

  151. 

  152.       EXPECT_EQ (true, (std::is_same<true_,  or_<true_,  false_>>()));

  153.       EXPECT_EQ (true, (std::is_same<false_, or_<false_, false_>>()));

  154.       EXPECT_EQ (true, (std::is_same<false_, and_<true_,  false_>>()));

  155.       EXPECT_EQ (true, (std::is_same<true_,  and_<true_,  true_>>()));

  156. 

  157.       EXPECT_EQ (true, (same_<Foo, Foo>()));

  158.       EXPECT_EQ (false, (same_<Foo, Bar>()));

  159.       EXPECT_EQ (true, (not_same_<Foo, Bar>()));

  160.    }

  161. 

  162.    /*

  163.     * Test void

  164.     */

  165.    TEST(Tmeta_void, VoidType) {

  166.       struct Foo {};

  167.       struct Bar {};

  168.       EXPECT_EQ(true, (std::is_same<void, void_t<int, long, Foo, Bar>>()));

  169.    }

  170.    /*

  171.     * Test invoke

  172.     */

  173.    TEST(Tmeta_invoke, Invoke) {

  174.       using Q = quote<MfunBin>;

  175.       using Qi = quote_i<int, MfunBin_i>;

  176.       using Q1 = quote<MfunUn1>;

  177.       using Q2 = quote<MfunUn2>;

  178. 

  179.       EXPECT_EQ (true, (std::is_same<int, identity_t<int>>()));

  180. 

  181.       EXPECT_EQ (true,  (is_applicable_t<MfunBin, int, long>()));

  182.       EXPECT_EQ (false, (is_applicable_t<MfunBin, int>()));

  183.       EXPECT_EQ (true,  (is_applicable_qt<Q, int, long>()));

  184.       EXPECT_EQ (false, (is_applicable_qt<Q, int>()));

  185. 

  186.       EXPECT_EQ (true,  (is_applicable_it<int, MfunBin_i, 7, 42>()));

  187.       EXPECT_EQ (false, (is_applicable_it<int, MfunBin_i, 42>()));

  188. 

  189.       EXPECT_EQ (true, (std::is_same<defer<MfunBin, int, void>::type, MfunBin<int, void>>()));

  190.       EXPECT_EQ (true, (std::is_same<defer<MfunBin, void>::type, nil_>()));

  191.       EXPECT_EQ (true, (std::is_same<defer_i<int, MfunBin_i, 7, 42>::type, MfunBin_i<7, 42>>()));

  192.       EXPECT_EQ (true, (std::is_same<defer_i<int, MfunBin_i, 7>::type, nil_>()));

  193. 

  194.       EXPECT_EQ (true, (std::is_same<invoke<Q, int>, nil_>()));

  195.       EXPECT_EQ (true, (std::is_same<invoke<Q, int, void*>, MfunBin<int, void*>>()));

  196.       EXPECT_EQ (true, (std::is_same<invoke<Qi, int_<7>, int_<42>>, MfunBin_i<7, 42>>()));

  197.       EXPECT_EQ (true, (std::is_same<invoke<Qi, int_<42>>, nil_>()));

  198. 

  199.       EXPECT_EQ (true, (std::is_same<invoke<compose<Q1, Q2>, int>, MfunUn1<MfunUn2<int>>>()));

  200.       EXPECT_EQ (true, (std::is_same<

  201.                            invoke<compose<Q1, Q2, Qi>, int_<7>, int_<42>>,

  202.                            MfunUn1<MfunUn2<MfunBin_i<7, 42>>>

  203.                         >()));

  204.       EXPECT_EQ (true, (std::is_same<

  205.                            invoke<compose<Q1, Q2, Qi>, int_<42>>,

  206.                            MfunUn1<MfunUn2<nil_>>

  207.                         >()));

  208. 

  209.       EXPECT_EQ (true, (std::is_same<invoke<bind_front<Q, int>, long>, MfunBin<int, long>>()));

  210.       EXPECT_EQ (true, (std::is_same<invoke<bind_back<Q, int>, long>, MfunBin<long, int>>()));

  211. 

  212.    }

  213.    /*

  214.     * Test typelist

  215.     */

  216.    TEST(Tmeta_typelist, Basics) {

  217.       using l1 = typelist<int, int, int>;

  218.       using l2 = typelist<int, void*, int, void*>;

  219.       using l3 = typelist<>;

  220. 

  221.       EXPECT_EQ (true, (std::is_same<l1, typelist<int>::times<3>>()));

  222.       EXPECT_EQ (true, (std::is_same<l2, typelist<int, void*>::times<2>>()));

  223.       EXPECT_EQ (true, (std::is_same<l3, typelist<>::times<3>>()));

  224.       EXPECT_EQ (true, (std::is_same<l3, typelist<int>::times<0>>()));

  225.       EXPECT_EQ (true, (std::is_same<typelist<short, double>, pair<short, double>>()));

  226. 

  227.       EXPECT_EQ (true, (std::is_same<l1, repeat <int_<3>, int>>()));

  228.       EXPECT_EQ (true, (std::is_same<l2, repeat_c <2, int, void*>>()));

  229. 

  230. 

  231.       EXPECT_EQ (3,    size<l1>());

  232.       EXPECT_EQ (true, empty<l3>());

  233. 

  234.       // pass typelist to an invocable

  235.       EXPECT_EQ (true, (std::is_same<type_<

  236.                                         apply<quote<MfunBin>, typelist<int, long>>

  237.                                      >,

  238.                                      MfunBin<int, long>

  239.                         >()));

  240.    }

  241. 

  242.    TEST(Tmeta_typelist, Element_access) {

  243.       using l = typelist<char, void, long, double, short>;

  244. 

  245.       EXPECT_EQ (true, (std::is_same<char, at_c<l, 0>>()));

  246.       EXPECT_EQ (true, (std::is_same<long, at_c<l, 2>>()));

  247.       EXPECT_EQ (true, (std::is_same<nil_, at_c<l, 5>>()));

  248.       EXPECT_EQ (true, (std::is_same<void, at<l, int_<1>>>()));

  249. 

  250.       EXPECT_EQ (true, (std::is_same<char, front<l>>()));

  251.       EXPECT_EQ (true, (std::is_same<short, back<l>>()));

  252.    }

  253. 

  254.    TEST(Tmeta_typelist, Concat) {

  255.       using l1 = typelist<int, long, void>;

  256.       using l2 = typelist<void*, int*>;

  257.       using l3 = typelist<double, long double, short>;

  258.       using l4 = typelist<>;

  259.       using conc = typelist<int, long, void, void*, int*, double, long double, short>;

  260. 

  261.       EXPECT_EQ(true, (std::is_same<l4, cat<l4, l4>>()));

  262.       EXPECT_EQ(true, (std::is_same<conc, cat<l1, l2, l3, l4>>()));

  263.       EXPECT_EQ(true, (std::is_same<conc, cat<l1, l4, l2, l3>>()));

  264.       EXPECT_EQ(true, (std::is_same<conc, cat<l4, l1, l2, l3>>()));

  265.    }

  266. 

  267.    template<class T1, class T2> struct F {}; // binary invocable

  268.    TEST(Tmeta_typelist, Fold) {

  269.       struct X1 {};

  270.       struct X2 {};

  271.       struct X3 {};

  272.       struct X4 {};

  273.       using Q = quote<F>;

  274. 

  275.       EXPECT_EQ(true, (std::is_same<fold<typelist<>, void, Q>, void>()));

  276.       EXPECT_EQ(true, (std::is_same<fold<typelist<X1>, void, Q>, F<void, X1>>()));

  277.       EXPECT_EQ(true, (std::is_same<fold<typelist<X1, X2>, void, Q>, F<F<void, X1>, X2>>()));

  278.       EXPECT_EQ(true, (std::is_same<fold<typelist<X1, X2, X3>, void, Q>, F<F<F<void, X1>, X2>, X3>>()));

  279.       EXPECT_EQ(true, (std::is_same<fold<typelist<X1, X2, X3, X4>, void, Q>, F<F<F<F<void, X1>, X2>, X3>, X4>>()));

  280. 

  281.       EXPECT_EQ(true, (std::is_same<rev_fold<typelist<>, void, Q>, void>()));

  282.       EXPECT_EQ(true, (std::is_same<rev_fold<typelist<X1>, void, Q>, F<X1, void>>()));

  283.       EXPECT_EQ(true, (std::is_same<rev_fold<typelist<X1, X2>, void, Q>, F<X1, F<X2, void>>>()));

  284.       EXPECT_EQ(true, (std::is_same<rev_fold<typelist<X1, X2, X3>, void, Q>, F<X1, F<X2, F<X3, void>>>>()));

  285.       EXPECT_EQ(true, (std::is_same<rev_fold<typelist<X1, X2, X3, X4>, void, Q>, F<X1, F<X2, F<X3, F<X4, void>>>>>()));

  286.    }

  287. 

  288.    TEST(Tmeta_typelist, PushPopReverse) {

  289.       using list   = typelist            <int, long, void>;

  290.       using l_char = typelist            <int, long, void, char>;

  291.       using l_cc   = typelist            <int, long, void, char, char>;

  292.       using char_l = typelist      <char, int, long, void>;

  293.       using cc_l   = typelist<char, char, int, long, void>;

  294.       using rev    = typelist<void, long, int>;

  295. 

  296.       EXPECT_EQ (true, (std::is_same<char_l, push_front<list, char>>()));

  297.       EXPECT_EQ (true, (std::is_same<cc_l,   push_front<list, char, char>>()));

  298.       EXPECT_EQ (true, (std::is_same<list,   pop_front <char_l>>()));

  299.       EXPECT_EQ (true, (std::is_same<l_char, push_back <list, char>>()));

  300.       EXPECT_EQ (true, (std::is_same<l_cc,   push_back <list, char, char>>()));

  301.       EXPECT_EQ (true, (std::is_same<list,   pop_back  <l_char>>()));

  302. 

  303.       EXPECT_EQ (true, (std::is_same<rev, reverse <list>>()));

  304.    }

  305. 

  306.    TEST(Tmeta_typelist, Transform) {

  307.       using QBin = quote<MfunBin>;

  308.       using QUn = quote<MfunUn1>;

  309. 

  310.       using l1 = typelist<char, int, float>;

  311.       using l2 = typelist<void, void, void>;

  312.       using r  = typelist<int, int, int>;

  313.       using r_ulazy = typelist <MfunUn1<char>, MfunUn1<int>, MfunUn1<float>>;

  314.       using r_blazy = typelist <MfunBin<char, void>, MfunBin<int, void>, MfunBin<float, void>>;

  315. 

  316.       EXPECT_EQ (true, (std::is_same<r, transform<l1, QUn>>()));

  317.       EXPECT_EQ (true, (std::is_same<r, transform<l1, l2, QBin>>()));

  318. 

  319.       EXPECT_EQ (true, (std::is_same<r_ulazy, transform_lazy<l1, QUn>>()));

  320.       EXPECT_EQ (true, (std::is_same<r_blazy, transform_lazy<l1, l2, QBin>>()));

  321.    }

  322. 

  323. 

  324.    TEST(Tmeta_typelist, Find) {

  325.       using l1 = typelist <int, char, long, float>;

  326.       using l2 = typelist <char, long, float>;

  327.       using l3 = typelist <long, float>;

  328.       using empty = typelist<>;

  329. 

  330.       EXPECT_EQ(true, (std::is_same<index_t_<1>, find_if<l1, same_as<char>>>()));

  331.       EXPECT_EQ(true, (std::is_same<Npos, find_if<empty, same_as<char>>>()));

  332.       EXPECT_EQ(true, (std::is_same<Npos, find_if<l1, same_as<double>>>()));

  333. 

  334.       EXPECT_EQ(true, (std::is_same<index_t_<2>, find<l1, long>>()));

  335. 

  336.       EXPECT_EQ(true, (std::is_same<l2, seek_if<l1, same_as<char>>>()));

  337.       EXPECT_EQ(true, (std::is_same<empty, seek_if<empty, same_as<char>>>()));

  338.       EXPECT_EQ(true, (std::is_same<empty, seek_if<l1, same_as<double>>>()));

  339. 

  340.       EXPECT_EQ(true, (std::is_same<l3, seek<l1, long>>()));

  341.    }

  342. 

  343.    TEST(Tmeta_typelist, Count) {

  344.       using list = typelist<int, void*, char, int, long*, char, int, short>;

  345.       using empty = typelist<>;

  346. 

  347.       EXPECT_EQ (true, (std::is_same<size_t_<3>, count_if<list, same_as<int>>>()));

  348.       EXPECT_EQ (true, (std::is_same<size_t_<2>, count_if<list, same_as<char>>>()));

  349.       EXPECT_EQ (true, (std::is_same<size_t_<0>, count_if<list, same_as<double>>>()));

  350.       EXPECT_EQ (true, (std::is_same<size_t_<0>, count_if<empty, int>>()));

  351. 

  352.       EXPECT_EQ (true, (std::is_same<size_t_<1>, count<list, void*>>()));

  353.    }

  354. 

  355.    TEST(Tmeta_typelist, Filter) {

  356.       using Q1 = quote<Pred_isInt>;

  357.       using Q2 = quote<Pred_isVoid>;

  358.       using list     = typelist<int, float, char, long*, short, double, void*>;

  359.       using filtered = typelist<int, char, short>;

  360. 

  361.       EXPECT_EQ (true, (std::is_same<filtered,   filter<list, Q1>>()));

  362.       EXPECT_EQ (true, (std::is_same<typelist<>, filter<typelist<>, Q1>>()));

  363.       EXPECT_EQ (true, (std::is_same<typelist<>, filter<list, Q2>>()));

  364.    }

  365. 

  366.    TEST(Tmeta_typelist, Replace) {

  367.       using Q = quote<Pred_isInt>;

  368.       using list = typelist<int, float, char, long*, short, double, void*>;

  369.       using res  = typelist<void,float, void, long*, void,  double, void*>;

  370.       using repl = typelist<int, float, void, long*, short, double, void*>;

  371. 

  372.       EXPECT_EQ (true, (std::is_same<res, replace_if<list, Q, void>>()));

  373.       EXPECT_EQ (true, (std::is_same<typelist<>, replace_if<typelist<>, Q, void>>()));

  374.       EXPECT_EQ (true, (std::is_same<res, replace_if<res, Q, void>>()));

  375. 

  376.       EXPECT_EQ (true, (std::is_same<repl, replace<list, char, void>>()));

  377.    }

  378. 

  379.    TEST (Tmeta_typelist, AllAnyNone) {

  380.       using l1 = typelist<int, float, char, long*, short, double, void*>;

  381.       using l2 = typelist<int, char, long, short>;

  382. 

  383.       EXPECT_EQ (true, (std::is_same<false_, all_of<l1, quote<Pred_isInt>>>()));

  384.       EXPECT_EQ (true, (std::is_same<true_,  all_of<l2, quote<Pred_isInt>>>()));

  385. 

  386.       EXPECT_EQ (true, (std::is_same<true_,  any_of<l1, quote<Pred_isInt>>>()));

  387.       EXPECT_EQ (true, (std::is_same<false_, any_of<l2, quote<Pred_isVoid>>>()));

  388. 

  389.       EXPECT_EQ (true, (std::is_same<true_,  none_of<l1, quote<Pred_isVoid>>>()));

  390.       EXPECT_EQ (true, (std::is_same<false_, none_of<l1, quote<Pred_isInt>>>()));

  391.    }

  392. 

  393. }