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.
64 Révisions
3 Branches
5.6 MiB
 
 
 
 
Branche: master
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de 'master'
${ noResults }
utl/test/tests/sequencer.cpp

452 lignes
18 KiB
Brut Lien permanent Annotations Historique 

  1. /*!

  2.  * \file sequencer.cpp

  3.  *

  4.  * \copyright Copyright (C) 2020 Christos Choutouridis <christos@choutouridis.net>

  5.  *

  6.  * <dl class=\"section copyright\"><dt>License</dt><dd>

  7.  * The MIT License (MIT)

  8.  *

  9.  * Permission is hereby granted, free of charge, to any person obtaining a copy

  10.  * of this software and associated documentation files (the "Software"), to deal

  11.  * in the Software without restriction, including without limitation the rights

  12.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

  13.  * copies of the Software, and to permit persons to whom the Software is

  14.  * furnished to do so, subject to the following conditions:

  15.  *

  16.  * The above copyright notice and this permission notice shall be included in all

  17.  * copies or substantial portions of the Software.

  18.  *

  19.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  20.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  21.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  22.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  23.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  24.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  25.  * SOFTWARE.

  26.  * </dd></dl>

  27.  *

  28.  */

  29. #include <utl/dev/sequencer.h>

  30. #include <gtest/gtest.h>

  31. 

  32. #include <type_traits>

  33. #include <cstring>

  34. #include <ctime>

  35. 

  36. namespace test_sequencer {

  37.    using namespace utl;

  38. 

  39.    // test settings

  40.    using data_type        = char;

  41.    constexpr size_t size  = 64;

  42. 

  43.    // Sequencer implementer mock

  44.    class Seq : public sequencer<Seq, data_type, size> {

  45.        static constexpr int NrCommands =5;

  46.        static constexpr int NoCommand  =-1;

  47. 

  48.        std::array<const char*, NrCommands> command = {

  49.            "cmd1",

  50.            "cmd2\n",

  51.            "cmd3\r\n",

  52.            "cmd4\n\r",

  53.            "cmd5\n",

  54.        };

  55.        std::array<const char*, NrCommands> reply {

  56.            "reply1",

  57.            "reply2\n",

  58.            "reply3\n text \r text text\n",

  59.            "reply4\n text\n text \r text\r\n",

  60.            "reply5\n",

  61.        };

  62.        int cmd =NoCommand;

  63.        clock_t t =0;

  64. 

  65.        public:

  66.            size_t get(char* data) {

  67.                static int ans = 0;

  68.                if ((++ans % 3) == 0)

  69.                    return 0;

  70. 

  71.                if (cmd == NoCommand) {

  72.                    std::strcpy(data, "ERROR\n");

  73.                    return 6;

  74.                } else {

  75.                    std::strcpy(data, reply[cmd]);

  76.                    size_t s = std::strlen(reply[cmd]);

  77.                    cmd =NoCommand;

  78.                    return s;

  79.                }

  80.            }

  81.            size_t contents (char* data) {

  82.                if (cmd == NoCommand) {

  83.                    std::strcpy(data, "");

  84.                    return 0;

  85.                } else {

  86.                    std::strcpy(data, reply[cmd]);

  87.                    return std::strlen(reply[cmd]);

  88.                }

  89.            }

  90.            size_t put (const char* data, size_t n) {

  91.                for (size_t i =0 ; i<NrCommands ; ++i) {

  92.                    if (!std::strcmp(data, command[i])) {

  93.                        cmd =i;

  94.                        return n;

  95.                    }

  96.                }

  97.                cmd =NoCommand;

  98.                return n;

  99.            }

  100.            clock_t clock() { return ++t; }

  101.            void clear_clock() { t =0; }

  102.    };

  103. 

  104.    /*

  105.     * Test  sequencer object

  106.     */

  107.    TEST (Tsequencer, traits) {

  108.        EXPECT_EQ ( std::is_default_constructible<Seq>::value, true);

  109.        EXPECT_EQ ( std::is_nothrow_default_constructible<Seq>::value, true);

  110.        EXPECT_EQ (!std::is_copy_constructible<Seq>::value, true);

  111.        EXPECT_EQ (!std::is_copy_assignable<Seq>::value, true);

  112. 

  113.        EXPECT_EQ ((std::is_same_v<Seq::value_type, data_type>), true);

  114.        EXPECT_EQ ((std::is_same_v<Seq::pointer_type, data_type*>), true);

  115.        EXPECT_EQ ((std::is_same_v<Seq::size_type, size_t>), true);

  116.        EXPECT_EQ ((std::is_same_v<Seq::string_view, std::basic_string_view<data_type>>), true);

  117. 

  118.        Seq s;

  119.        EXPECT_EQ (s.size(), size);

  120.    }

  121. 

  122.    TEST (Tsequencer, predicates) {

  123.        EXPECT_EQ ((std::is_invocable_r<bool, decltype(Seq::equals), Seq::string_view, Seq::string_view>::value), true);

  124.        EXPECT_EQ ((std::is_invocable_r<bool, decltype(Seq::starts_with), Seq::string_view, Seq::string_view>::value), true);

  125.        EXPECT_EQ ((std::is_invocable_r<bool, decltype(Seq::ends_with), Seq::string_view, Seq::string_view>::value), true);

  126.        EXPECT_EQ ((std::is_invocable_r<bool, decltype(Seq::contains), Seq::string_view, Seq::string_view>::value), true);

  127.        EXPECT_EQ ((std::is_invocable_r<bool, decltype(Seq::always_true), Seq::string_view, Seq::string_view>::value), true);

  128.        EXPECT_EQ ((std::is_invocable_r<bool, decltype(Seq::always_false), Seq::string_view, Seq::string_view>::value), true);

  129. 

  130.        EXPECT_EQ (Seq::nil, nullptr);

  131.    }

  132. 

  133.    TEST (Tsequencer, actions) {

  134.        EXPECT_EQ ( std::is_default_constructible<Seq::action_t>::value, true);

  135.        EXPECT_EQ ( std::is_nothrow_default_constructible<Seq::action_t>::value, true);

  136.        EXPECT_EQ ( std::is_copy_constructible<Seq::action_t>::value, true);

  137.        EXPECT_EQ ( std::is_copy_assignable<Seq::action_t>::value, true);

  138. 

  139.        EXPECT_EQ ((std::is_same_v<const Seq::action_t, decltype(Seq::no_action)>), true);

  140.        EXPECT_EQ ((std::is_same_v<const Seq::action_t, decltype(Seq::next)>), true);

  141.        EXPECT_EQ ((std::is_same_v<const Seq::action_t, decltype(Seq::exit_ok)>), true);

  142.        EXPECT_EQ ((std::is_same_v<const Seq::action_t, decltype(Seq::exit_error)>), true);

  143. 

  144.        EXPECT_EQ ((std::is_same_v<const Seq::action_t, decltype(Seq::go_to<0>)>), true);

  145.        EXPECT_EQ ((std::is_same_v<const Seq::action_t, decltype(Seq::exit<0>)>), true);

  146.    }

  147. 

  148.    bool handler_flag = false;

  149.    const char* text = "abc";

  150. 

  151.    //static bool check_handle (const str_view_t buffer, const str_view_t token, match_ft match, handler_ft handle)

  152.    TEST(Tsequencer, check_handle) {

  153.        Seq s;

  154. //       foo (5);

  155. //       bar (5);

  156.        using str_t = Seq::string_view;

  157.        using val_t = Seq::value_type;

  158. 

  159.        auto match    = [](const str_t x, const str_t y) ->bool { (void)x; (void)y; return true; };

  160.        auto no_match = [](const str_t x, const str_t y) ->bool { (void)x; (void)y; return false; };

  161.        auto check_match = [] (const str_t x, const str_t y) ->bool {

  162.            return x == y;

  163.        };

  164.        auto handler    = [](const val_t* v, size_t s){ (void)*v; (void)s; handler_flag = true; };

  165.        auto set_if_abc = [](const val_t* v, size_t s){

  166.            (void)*v; (void)s;

  167.            handler_flag = (str_t(v, s) == "abc");

  168.        };

  169. 

  170.        EXPECT_EQ (s.check_handle("", "", nullptr, nullptr), false);

  171.        EXPECT_EQ (s.check_handle("", "", no_match, nullptr), false);

  172.        EXPECT_EQ (s.check_handle("", "", match, nullptr), false);

  173. 

  174.        handler_flag = false;

  175.        EXPECT_EQ (s.check_handle("", "", no_match, handler), false);

  176.        EXPECT_EQ (handler_flag, false);

  177. 

  178.        handler_flag = false;

  179.        EXPECT_EQ (s.check_handle("", "", match, handler), true);

  180.        EXPECT_EQ (handler_flag, true);

  181. 

  182.        handler_flag = false;

  183.        EXPECT_EQ (s.check_handle("abcd", "abc", check_match, set_if_abc), false);

  184.        EXPECT_EQ (handler_flag, false);

  185. 

  186.        handler_flag = false;

  187.        EXPECT_EQ (s.check_handle("abc", "abc", check_match, set_if_abc), true);

  188.        EXPECT_EQ (handler_flag, true);

  189. 

  190.        handler_flag = false;

  191.        EXPECT_EQ (s.check_handle("abc", "abcd", check_match, set_if_abc), false);

  192.        EXPECT_EQ (handler_flag, false);

  193. 

  194.    }

  195. 

  196.    TEST(Tsequencer, run_nop_and_exits) {

  197.        Seq s;

  198.        const Seq::script_t<1> script1 = {{

  199.            {Seq::control_t::NOP,  "", Seq::nil, Seq::nil, Seq::exit_ok, 1000}

  200.        }};

  201.        s.clear_clock();

  202.        EXPECT_EQ (s.run(script1), Seq::exit_ok.value);

  203.        EXPECT_GE (s.clock(), (clock_t)1000);

  204. 

  205.        const Seq::script_t<1> script2 = {{

  206.            {Seq::control_t::NOP,  "", Seq::nil, Seq::nil, Seq::exit_error, 1000}

  207.        }};

  208.        s.clear_clock();

  209.        EXPECT_EQ (s.run(script2), Seq::exit_error.value);

  210.        EXPECT_GE (s.clock(), (clock_t)1000);

  211. 

  212.        const Seq::script_t<3> script3 = {{

  213.            {Seq::control_t::NOP,  "", Seq::nil, Seq::nil, Seq::next, 1000},

  214.            {Seq::control_t::NOP,  "", Seq::nil, Seq::nil, Seq::next, 1000},

  215.            {Seq::control_t::NOP,  "", Seq::nil, Seq::nil, Seq::exit_ok, 1000}

  216.        }};

  217.        s.clear_clock();

  218.        EXPECT_EQ (s.run(script3), Seq::exit_ok.value);

  219.        EXPECT_GE (s.clock(), (clock_t)3000);

  220.    }

  221. 

  222.    TEST(Tsequencer, run_send) {

  223.        Seq s;

  224. 

  225.        auto send_wrapper  = [](const data_type* d, size_t s){

  226.            (void)*d; (void)s; handler_flag = true;

  227.        };

  228.        auto send_chk_text = [](const data_type* d, size_t s){

  229.            handler_flag = (Seq::string_view(d,s) == Seq::string_view(text));

  230.        };

  231. 

  232.        const Seq::script_t<2> script1 = {{

  233.            {Seq::control_t::SEND, "", Seq::nil, Seq::nil,     Seq::next, 0},

  234.            {Seq::control_t::SEND, "", Seq::nil, send_wrapper, Seq::exit_ok, 0}

  235.        }};

  236.        handler_flag =false;

  237.        EXPECT_EQ (s.run(script1), Seq::exit_ok.value);

  238.        EXPECT_EQ (handler_flag, true);

  239. 

  240. 

  241.        const Seq::script_t<1> script2 = {{

  242.            {Seq::control_t::SEND, "abcd", Seq::nil, send_chk_text, Seq::exit_ok, 0}

  243.        }};

  244.        handler_flag =false;

  245.        EXPECT_EQ (s.run(script2), Seq::exit_ok.value);

  246.        EXPECT_EQ (handler_flag, false);

  247. 

  248.        const Seq::script_t<2> script3 = {{

  249.            {Seq::control_t::SEND, text, Seq::nil, send_chk_text, Seq::exit_ok, 0}

  250.        }};

  251.        handler_flag =false;

  252.        EXPECT_EQ (s.run(script3), Seq::exit_ok.value);

  253.        EXPECT_EQ (handler_flag, true);

  254.    }

  255. 

  256.    TEST(Tsequencer, run_expect) {

  257.        Seq s;

  258. 

  259.        const Seq::script_t<7> script = {{

  260.            {Seq::control_t::EXPECT,    "reply1",   Seq::equals,      Seq::nil,  Seq::exit<1UL>,    1000},

  261.            {Seq::control_t::OR_EXPECT, "reply2",   Seq::starts_with, Seq::nil,  Seq::exit<2UL>,    0},

  262.            {Seq::control_t::OR_EXPECT, "reply3",   Seq::starts_with, Seq::nil,  Seq::exit<3UL>,    0},

  263.            {Seq::control_t::OR_EXPECT, "reply4\n", Seq::starts_with, Seq::nil,  Seq::exit<4UL>,    0},

  264.            {Seq::control_t::OR_EXPECT, "reply5",   Seq::starts_with, Seq::nil,  Seq::exit<5UL>,    0},

  265.            {Seq::control_t::OR_EXPECT, "ERROR",    Seq::contains,    Seq::nil,  Seq::exit<6UL>,    0},

  266.            {Seq::control_t::NOP,       "",         Seq::nil,         Seq::nil,  Seq::exit_error,   1000}

  267.        }};

  268. 

  269.        s.clear_clock();

  270.        s.put("cmd1", std::strlen("cmd1"));

  271.        EXPECT_EQ (s.run(script), 1UL);

  272.        EXPECT_LT (s.clock(), (clock_t)1000);

  273. 

  274.        s.clear_clock();

  275.        s.put("cmd2\n", std::strlen("cmd2\n"));

  276.        EXPECT_EQ (s.run(script), 2UL);

  277.        EXPECT_LT (s.clock(), (clock_t)1000);

  278. 

  279.        s.clear_clock();

  280.        s.put("cmd3\r\n", std::strlen("cmd3\r\n"));

  281.        EXPECT_EQ (s.run(script), 3UL);

  282.        EXPECT_LT (s.clock(), (clock_t)1000);

  283. 

  284.        s.clear_clock();

  285.        s.put("cmd4\n\r", std::strlen("cmd4\n\r"));

  286.        EXPECT_EQ (s.run(script), 4UL);

  287.        EXPECT_LT (s.clock(), (clock_t)1000);

  288. 

  289.        s.clear_clock();

  290.        s.put("cmd5\n", std::strlen("cmd5\n"));

  291.        EXPECT_EQ (s.run(script), 5UL);

  292.        EXPECT_LT (s.clock(), (clock_t)1000);

  293. 

  294.        s.clear_clock();

  295.        s.put("cmd", std::strlen("cmd"));

  296.        EXPECT_EQ (s.run(script), 6UL);

  297.        EXPECT_LT (s.clock(), (clock_t)1000);

  298.    }

  299. 

  300.    TEST(Tsequencer, run_detect) {

  301.        Seq s;

  302. 

  303.        const Seq::script_t<7> script = {{

  304.            {Seq::control_t::DETECT,    "reply1",   Seq::equals,      Seq::nil,  Seq::exit<1UL>,    1000},

  305.            {Seq::control_t::OR_DETECT, "reply2",   Seq::starts_with, Seq::nil,  Seq::exit<2UL>,    0},

  306.            {Seq::control_t::OR_DETECT, "reply3",   Seq::starts_with, Seq::nil,  Seq::exit<3UL>,    0},

  307.            {Seq::control_t::OR_DETECT, "reply4\n", Seq::starts_with, Seq::nil,  Seq::exit<4UL>,    0},

  308.            {Seq::control_t::OR_DETECT, "reply5",   Seq::starts_with, Seq::nil,  Seq::exit<5UL>,    0},

  309.            {Seq::control_t::OR_DETECT, "ERROR",    Seq::contains,    Seq::nil,  Seq::exit<6UL>,    0},

  310.            {Seq::control_t::NOP,       "",         Seq::nil,         Seq::nil,  Seq::exit_ok,      1000}

  311.        }};

  312. 

  313.        s.clear_clock();

  314.        s.put("cmd1", std::strlen("cmd1"));

  315.        EXPECT_EQ (s.run(script), 1UL);

  316.        EXPECT_LT (s.clock(), (clock_t)1000);

  317. 

  318.        s.clear_clock();

  319.        s.put("cmd2\n", std::strlen("cmd2\n"));

  320.        EXPECT_EQ (s.run(script), 2UL);

  321.        EXPECT_LT (s.clock(), (clock_t)1000);

  322. 

  323.        s.clear_clock();

  324.        s.put("cmd3\r\n", std::strlen("cmd3\r\n"));

  325.        EXPECT_EQ (s.run(script), 3UL);

  326.        EXPECT_LT (s.clock(), (clock_t)1000);

  327. 

  328.        s.clear_clock();

  329.        s.put("cmd4\n\r", std::strlen("cmd4\n\r"));

  330.        EXPECT_EQ (s.run(script), 4UL);

  331.        EXPECT_LT (s.clock(), (clock_t)1000);

  332. 

  333.        s.clear_clock();

  334.        s.put("cmd5\n", std::strlen("cmd5\n"));

  335.        EXPECT_EQ (s.run(script), 5UL);

  336.        EXPECT_LT (s.clock(), (clock_t)1000);

  337. 

  338.        s.clear_clock();

  339.        s.put("cmd", std::strlen("cmd"));

  340.        EXPECT_EQ (s.run(script), Seq::exit_error.value);

  341.        EXPECT_GT (s.clock(), (clock_t)1000);

  342.    }

  343. 

  344.    TEST(Tsequencer, run_script_blocks_n_gotos) {

  345.        Seq s;

  346.        const Seq::script_t<15> script = {{

  347.            /* 0 */{Seq::control_t::NOP,       "",         Seq::nil,         Seq::nil,   Seq::go_to<1>,   1000},

  348. 

  349.            /* 1 */{Seq::control_t::SEND,      "cmd1",     Seq::nil,         Seq::nil,   Seq::next,       0},

  350.            /* 2 */{Seq::control_t::EXPECT,    "reply1",   Seq::starts_with, Seq::nil,   Seq::next,       1000},

  351.            /* 3 */{Seq::control_t::OR_EXPECT, "ERROR",    Seq::contains,    Seq::nil,   Seq::exit_error, 0},

  352. 

  353.            /* 4 */{Seq::control_t::SEND,      "cmd2\n",   Seq::nil,         Seq::nil,   Seq::next,       0},

  354.            /* 5 */{Seq::control_t::DETECT,    "ERROR",    Seq::contains,    Seq::nil,   Seq::exit_error, 1000},

  355.            /* 6 */{Seq::control_t::OR_DETECT, "reply2",   Seq::contains,    Seq::nil,   Seq::go_to<11>,  0},

  356. 

  357.            /* 7 */{Seq::control_t::SEND,      "cmd3\r\n", Seq::nil,         Seq::nil,  Seq::next,        0},

  358.            /* 8 */{Seq::control_t::EXPECT,    "ERROR",    Seq::contains,    Seq::nil,  Seq::exit_error,  1000},

  359.            /* 9 */{Seq::control_t::OR_EXPECT, "lalala",   Seq::starts_with, Seq::nil,  Seq::exit_error,  0},

  360.            /*10 */{Seq::control_t::OR_EXPECT, "text\n",   Seq::ends_with,   Seq::nil,  Seq::go_to<14>,   0},

  361. 

  362.            /*11 */{Seq::control_t::SEND,      "cmd4\n\r", Seq::nil,         Seq::nil,  Seq::next,        0},

  363.            /*12 */{Seq::control_t::EXPECT,    "reply4\n", Seq::starts_with, Seq::nil,  Seq::go_to<7>,    1000},

  364.            /*13 */{Seq::control_t::OR_EXPECT, "ERROR",    Seq::contains,    Seq::nil,  Seq::exit_error,  0},

  365. 

  366.            /*14 */{Seq::control_t::NOP,       "",         Seq::nil,         Seq::nil,  Seq::exit_ok,     1000}

  367.        }};

  368.        s.clear_clock();

  369.        EXPECT_EQ (s.run(script), Seq::exit_ok.value);

  370.        EXPECT_GT (s.clock(), (clock_t)2000);

  371.    }

  372. 

  373.    TEST(Tsequencer, run_match_n_handler) {

  374.        Seq s;

  375. 

  376.        using str_t = Seq::string_view;

  377.        using val_t = Seq::value_type;

  378. 

  379.        auto match    = [](const str_t x, const str_t y) ->bool { (void)x; (void)y; return true; };

  380.        auto check_match = [] (const str_t x, const str_t y) ->bool {

  381.            return x == y;

  382.        };

  383.        auto handler     = [](const val_t* v, size_t s){ (void)*v; (void)s; handler_flag = true; };

  384.        auto set_if_rpl2 = [](const val_t* v, size_t s){

  385.            (void)*v; (void)s;

  386.            handler_flag = (str_t(v, s) == "reply2\n");

  387.        };

  388. 

  389.        const Seq::script_t<4> script1 = {{

  390.            {Seq::control_t::SEND,      "cmd1",   Seq::nil,        Seq::nil,   Seq::next,       0},

  391.            {Seq::control_t::EXPECT,    "",       match,           Seq::nil,   Seq::next,       1000},

  392.            {Seq::control_t::OR_EXPECT, "ERROR",  Seq::contains,   Seq::nil,   Seq::exit_error, 0},

  393. 

  394.            {Seq::control_t::SEND,      "cmd1",   Seq::nil,        handler,    Seq::exit_ok,    0}

  395.        }};

  396.        handler_flag = false;

  397.        s.clear_clock();

  398.        EXPECT_EQ (s.run(script1), Seq::exit_ok.value);

  399.        EXPECT_LT (s.clock(), (clock_t)1000);

  400.        EXPECT_EQ (handler_flag, true);

  401. 

  402.        const Seq::script_t<2> script2 = {{

  403.            {Seq::control_t::SEND,      "cmd1",   Seq::nil,        Seq::nil,    Seq::next,       0},

  404.            {Seq::control_t::EXPECT,    "reply1", check_match,     set_if_rpl2, Seq::exit_ok,    1000},

  405.        }};

  406.        handler_flag = false;

  407.        EXPECT_EQ (s.run(script2), Seq::exit_ok.value);

  408.        EXPECT_EQ (handler_flag, false);

  409. 

  410.        const Seq::script_t<2> script3 = {{

  411.            {Seq::control_t::SEND,      "cmd2\n",   Seq::nil,      Seq::nil,    Seq::next,       0},

  412.            {Seq::control_t::EXPECT,    "reply2\n", check_match,   set_if_rpl2, Seq::exit_ok,    1000},

  413.        }};

  414.        handler_flag = false;

  415.        EXPECT_EQ (s.run(script3), Seq::exit_ok.value);

  416.        EXPECT_EQ (handler_flag, true);

  417. 

  418.        const Seq::script_t<1> script4 = {{

  419.            {Seq::control_t::SEND, "cmd1", Seq::nil, handler, Seq::exit_ok, 0}

  420.        }};

  421.        handler_flag = false;

  422.        EXPECT_EQ (s.run(script4), Seq::exit_ok.value);

  423.        EXPECT_EQ (handler_flag, true);

  424.    }

  425. 

  426.    TEST(Tsequencer, run_boundaries) {

  427.        Seq s;

  428. 

  429.        const Seq::script_t<1> script1 = {{

  430.            {Seq::control_t::NOP,  "", Seq::nil, Seq::nil, Seq::next, 0},

  431.        }};

  432.        EXPECT_EQ (s.run(script1), Seq::exit_error.value);

  433. 

  434.        const Seq::script_t<1> script2 = {{

  435.            {Seq::control_t::NOP,  "", Seq::nil, Seq::nil, Seq::go_to<1>, 0},

  436.        }};

  437.        EXPECT_EQ (s.run(script2), Seq::exit_error.value);

  438. 

  439.        const Seq::script_t<1> script3 = {{

  440.            {Seq::control_t::NOP,  "", Seq::nil, Seq::nil, Seq::go_to<(size_t)-1>, 0},

  441.        }};

  442.        EXPECT_EQ (s.run(script3), Seq::exit_error.value);

  443. 

  444.        const Seq::script_t<1> script4 = {{

  445.            {Seq::control_t::EXPECT,  "abc", Seq::nil, Seq::nil, Seq::next, 1000},

  446.        }};

  447.        s.clear_clock();

  448.        EXPECT_EQ (s.run(script4), Seq::exit_error.value);

  449.        EXPECT_GT (s.clock(), (clock_t)1000);

  450.    }

  451. }