hoo2
/
utl
1
0
Bifurcation 0
Code Tickets 0 Demandes d'ajout 0 Versions 0 Wiki Activité
Micro template library A library for building device drivers
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
41 Révisions
3 Branches
5.6 MiB
 
 
 
 
Aborescence: e974b9d43d
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de 'e974b9d43d'
${ noResults }
utl/test/tests/Tmeta.cpp

395 lignes
16 KiB
Brut Annotations Historique 

  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 Identity {

  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, IntegrealType) {

  60.       EXPECT_EQ(true, (std::is_same<int, eval<Identity<int>>>::value));

  61.    }

  62.    TEST(Tmeta, IntegrealConstant) {

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

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

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

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

  67.    }

  68.    TEST(Tmeta, 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_<0>::value_type>::value));

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

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

  99.       EXPECT_EQ(42U, size_<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, 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, 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, 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, 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_t

  164.     */

  165.    TEST(Tmeta, VoidType) {

  166.       struct Foo {};

  167.       struct Bar {};

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

  169.    }

  170. 

  171.    /*

  172.     * Test invoke

  173.     */

  174.    TEST(Tmeta, Invoke) {

  175.       using Q = quote<MfunBin>;

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

  177.       using Q1 = quote<MfunUn1>;

  178.       using Q2 = quote<MfunUn2>;

  179. 

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

  181. 

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

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

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

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

  186. 

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

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

  189. 

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

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

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

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

  194. 

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

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

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

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

  199. 

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

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

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

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

  204.                         >()));

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

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

  207.                            MfunUn1<MfunUn2<nil_>>

  208.                         >()));

  209. 

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

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

  212. 

  213.    }

  214.    /*

  215.     * Test typelist

  216.     */

  217.    TEST(Tmeta_typelist, Basics) {

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

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

  220.       using l3 = typelist<>;

  221. 

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

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

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

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

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

  227. 

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

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

  230. 

  231. 

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

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

  234. 

  235.       // pass typelist to an invocable

  236.       EXPECT_EQ (true, (std::is_same<eval<

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

  238.                                      >,

  239.                                      MfunBin<int, long>

  240.                         >()));

  241.    }

  242. 

  243.    TEST(Tmeta_typelist, Element_access) {

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

  245. 

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

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

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

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

  250. 

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

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

  253.    }

  254. 

  255.    TEST(Tmeta_typelist, Concat) {

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

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

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

  259.       using l4 = typelist<>;

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

  261. 

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

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

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

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

  266.    }

  267. 

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

  269.    TEST(Tmeta_typelist, Fold) {

  270.       struct X1 {};

  271.       struct X2 {};

  272.       struct X3 {};

  273.       struct X4 {};

  274.       using Q = quote<F>;

  275. 

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

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

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

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

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

  281. 

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

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

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

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

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

  287.    }

  288. 

  289.    TEST(Tmeta_typelist, PushPopReverse) {

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

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

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

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

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

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

  296. 

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

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

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

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

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

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

  303. 

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

  305.    }

  306. 

  307.    TEST(Tmeta_typelist, Transform) {

  308.       using QBin = quote<MfunBin>;

  309.       using QUn = quote<MfunUn1>;

  310. 

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

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

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

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

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

  316. 

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

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

  319. 

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

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

  322.    }

  323. 

  324. 

  325.    TEST(Tmeta_typelist, Find) {

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

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

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

  329.       using empty = typelist<>;

  330. 

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

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

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

  334. 

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

  336. 

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

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

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

  340. 

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

  342.    }

  343. 

  344.    TEST(Tmeta_typelist, Count) {

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

  346.       using empty = typelist<>;

  347. 

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

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

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

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

  352. 

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

  354.    }

  355. 

  356.    TEST(Tmeta_typelist, Filter) {

  357.       using Q1 = quote<Pred_isInt>;

  358.       using Q2 = quote<Pred_isVoid>;

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

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

  361. 

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

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

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

  365.    }

  366. 

  367.    TEST(Tmeta_typelist, Replace) {

  368.       using Q = quote<Pred_isInt>;

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

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

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

  372. 

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

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

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

  376. 

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

  378.    }

  379. 

  380.    TEST (Tmeta_typelist, AllAnyNone) {

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

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

  383. 

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

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

  386. 

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

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

  389. 

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

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

  392.    }

  393. 

  394. }