LCOV - code coverage report
Current view: top level - src/libs/tools/tests - testtool_backendparser.cpp (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 173 179 96.6 %
Date: 2019-09-12 12:28:41 Functions: 22 32 68.8 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief Tests for the Backend parser class
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  *
       8             :  */
       9             : 
      10             : #define ELEKTRA_PLUGINSPEC_WITH_COMPARE
      11             : 
      12             : #include <backendparser.hpp>
      13             : 
      14             : #include <backendbuilder.hpp>
      15             : 
      16             : #include <string>
      17             : 
      18             : #include <toolexcept.hpp>
      19             : 
      20             : #include <gtest/gtest.h>
      21             : 
      22             : 
      23          20 : TEST (MountBackendBuilder, parsePluginArguments)
      24             : {
      25             :         using namespace kdb;
      26             :         using namespace kdb::tools;
      27          26 :         EXPECT_EQ (KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), KS_END), parsePluginArguments ("a=5"));
      28          26 :         EXPECT_EQ (KeySet (5, *Key ("user", KEY_END), KS_END), parsePluginArguments ("="));
      29          34 :         EXPECT_EQ (KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), *Key ("user/ax", KEY_VALUE, "a", KEY_END),
      30             :                            *Key ("user/ax/bx", KEY_VALUE, "8", KEY_END), KS_END),
      31           0 :                    parsePluginArguments ("a=5,ax=a,ax/bx=8"));
      32          34 :         EXPECT_EQ (KeySet (5, *Key ("user", KEY_VALUE, "5", KEY_END), *Key ("user/ax", KEY_END, KEY_END),
      33             :                            *Key ("user/ax/bx", KEY_VALUE, "8", KEY_END), KS_END),
      34           0 :                    parsePluginArguments ("=5,ax=,ax/bx=8"));
      35          34 :         EXPECT_EQ (KeySet (5, *Key ("user", KEY_VALUE, "5", KEY_END), *Key ("user/ ax", KEY_END, KEY_END),
      36             :                            *Key ("user/ ax/ bx", KEY_VALUE, "8", KEY_END), KS_END),
      37           0 :                    parsePluginArguments ("=5, ax=, ax/ bx=8"));
      38          34 :         EXPECT_EQ (KeySet (5, *Key ("user", KEY_VALUE, "5", KEY_END), *Key ("user/     ax", KEY_END, KEY_END),
      39             :                            *Key ("user/    ax/     bx", KEY_VALUE, "8", KEY_END), KS_END),
      40           0 :                    parsePluginArguments ("=5,      ax=,    ax/     bx=8"));
      41          34 :         EXPECT_EQ (KeySet (5, *Key ("user", KEY_VALUE, "5", KEY_END), *Key ("user/ax", KEY_END, KEY_END),
      42             :                            *Key ("user/ax\\/bx", KEY_VALUE, "8", KEY_END), KS_END),
      43           0 :                    parsePluginArguments ("=5,ax=,ax\\/bx=8"));
      44          34 :         EXPECT_EQ (KeySet (5, *Key ("user", KEY_END), *Key ("user/ax", KEY_END, KEY_END), *Key ("user/ax\\/bx", KEY_VALUE, "8", KEY_END),
      45             :                            KS_END),
      46           0 :                    parsePluginArguments ("=,ax=,ax\\/bx=8"));
      47           2 : }
      48             : 
      49             : 
      50             : #define CMP_PSV(psv1, psv2)                                                                                                                \
      51             :         do                                                                                                                                 \
      52             :         {                                                                                                                                  \
      53             :                 EXPECT_EQ (psv1.size (), psv2.size ());                                                                                    \
      54             :                 if (psv1.size () != psv2.size ()) break;                                                                                   \
      55             :                 for (size_t i = 0; i < psv1.size (); ++i)                                                                                  \
      56             :                 {                                                                                                                          \
      57             :                         EXPECT_EQ (psv1[i], psv2[i]) << "element " << i << " differs";                                                     \
      58             :                         if (!(psv1[i] == psv2[i])) break;                                                                                  \
      59             :                 }                                                                                                                          \
      60             :         } while (false)
      61             : 
      62          20 : TEST (MountBackendBuilder, parseArguments)
      63             : {
      64             :         using namespace kdb;
      65             :         using namespace kdb::tools;
      66           4 :         PluginSpecVector psv1;
      67          16 :         psv1.push_back (PluginSpec ("a", KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), KS_END)));
      68          12 :         psv1.push_back (PluginSpec ("b"));
      69          12 :         psv1.push_back (PluginSpec ("c"));
      70          10 :         PluginSpecVector psv2 = parseArguments ("a a=5 b c");
      71          58 :         CMP_PSV (psv1, psv2);
      72          10 :         psv2 = parseArguments ("  a  a=5  b c   ");
      73          58 :         CMP_PSV (psv1, psv2);
      74          10 :         psv2 = parseArguments ("  a         a=5      b c ,  ");
      75          58 :         CMP_PSV (psv1, psv2);
      76           6 :         EXPECT_THROW (parseArguments ("a=5 a b c"), ParseException);
      77           6 :         EXPECT_THROW (parseArguments ("a#a b c a#a"), ParseException);
      78           2 : }
      79             : 
      80          20 : TEST (MountBackendBuilder, parseVectorArguments)
      81             : {
      82             :         using namespace kdb;
      83             :         using namespace kdb::tools;
      84           4 :         PluginSpecVector psv1;
      85             :         psv1.push_back (
      86          20 :                 PluginSpec ("a", KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), *Key ("user/b", KEY_VALUE, "3", KEY_END), KS_END)));
      87          12 :         psv1.push_back (PluginSpec ("b"));
      88             :         psv1.push_back (
      89          20 :                 PluginSpec ("c", KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), *Key ("user/b", KEY_VALUE, "3", KEY_END), KS_END)));
      90          26 :         PluginSpecVector psv2 = parseArguments ({ "a", "a=5,b=3", "b", "c", "a=5,b=3" });
      91          58 :         CMP_PSV (psv1, psv2);
      92          26 :         psv2 = parseArguments ({ "a", "a=5,b=3", "b", "c", "a=5,b=3" });
      93          58 :         CMP_PSV (psv1, psv2);
      94          10 :         psv2 = parseArguments ("  a         b=3,a=5          b c ,  a=5,b=3 ");
      95          58 :         CMP_PSV (psv1, psv2);
      96          10 :         psv2 = parseArguments ("  a  a=5,b=3  b c  a=5, b=3 ");
      97          58 :         CMP_PSV (psv1, psv2);
      98          10 :         psv2 = parseArguments ("  a         b=3,a=5          b ,  c  ,  a=5,b=3 ");
      99          58 :         CMP_PSV (psv1, psv2);
     100           6 :         EXPECT_THROW (parseArguments ("a=5 a b c"), ParseException);
     101           6 :         EXPECT_THROW (parseArguments ("a#a b c a#a"), ParseException);
     102           2 : }
     103             : 
     104          20 : TEST (MountBackendBuilder, parseArgumentsIdentical)
     105             : {
     106             :         using namespace kdb;
     107             :         using namespace kdb::tools;
     108           6 :         EXPECT_THROW (parseArguments ("a#a a#a"), ParseException);
     109           6 :         EXPECT_THROW (parseArguments ("a#a b#a"), ParseException);
     110           6 :         EXPECT_THROW (parseArguments ("a#a a#0"), BadPluginName);
     111           6 :         EXPECT_THROW (parseArguments ("a#b b#b"), ParseException);
     112           6 :         EXPECT_THROW (parseArguments ("a#same b#same"), ParseException);
     113           6 :         EXPECT_THROW (parseArguments ("a#same b c#same"), ParseException);
     114           6 :         EXPECT_THROW (parseArguments ("a#same b c d#same"), ParseException);
     115           6 :         EXPECT_THROW (parseArguments ("a#same b c d e#same"), ParseException);
     116           6 :         EXPECT_THROW (parseArguments ("a#same b c d e#same f g h"), ParseException);
     117           6 :         EXPECT_THROW (parseArguments ("augeas#same1 logging#same2 code#same3 escape=% code#same1 escape=- "), ParseException);
     118           6 :         EXPECT_THROW (parseArguments ("augeas#same1 logging#same2 code#same3 escape=% code#same3 escape=- "), ParseException);
     119           6 :         EXPECT_THROW (parseArguments ("augeas#same1 logging#same2 code#same3 escape=% code#same3 escape=- "), ParseException);
     120           6 :         EXPECT_THROW (parseArguments ("augeas#same logging#same2 code#same3 escape=% code#same escape=- "), ParseException);
     121           6 :         EXPECT_THROW (parseArguments ("augeas#same1 logging#same code#same3 escape=% code#same escape=- "), ParseException);
     122           6 :         EXPECT_THROW (parseArguments ("augeas#same1 logging#same2 code#same escape=% code#same escape=- "), ParseException);
     123           2 : }
     124             : 
     125          20 : TEST (MountBackendBuilder, parseArgumentsNearlyIdentical)
     126             : {
     127             :         using namespace kdb;
     128             :         using namespace kdb::tools;
     129           4 :         PluginSpecVector psv1;
     130          18 :         psv1.push_back (PluginSpec ("a", "a"));
     131          10 :         psv1.push_back (PluginSpec ("a", 0));
     132          10 :         PluginSpecVector psv2 = parseArguments ("a#a a");
     133          44 :         CMP_PSV (psv1, psv2);
     134           2 : }
     135             : 
     136          20 : TEST (MountBackendBuilder, parseArgumentsDoubleOccur)
     137             : {
     138             :         using namespace kdb;
     139             :         using namespace kdb::tools;
     140           4 :         PluginSpecVector psv1;
     141          16 :         psv1.push_back (PluginSpec ("a", 0, KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), KS_END)));
     142          12 :         psv1.push_back (PluginSpec ("b"));
     143          12 :         psv1.push_back (PluginSpec ("c"));
     144          16 :         psv1.push_back (PluginSpec ("a", 1, KeySet (5, *Key ("user/b", KEY_VALUE, "c", KEY_END), KS_END)));
     145          10 :         PluginSpecVector psv2 = parseArguments ("a a=5 b c a b=c");
     146          72 :         CMP_PSV (psv1, psv2);
     147          10 :         psv2 = parseArguments ("  a  a=5  b c a b=c   ");
     148          72 :         CMP_PSV (psv1, psv2);
     149          10 :         psv2 = parseArguments ("  a         a=5      b c , a b=c  ");
     150          72 :         CMP_PSV (psv1, psv2);
     151           6 :         EXPECT_THROW (parseArguments ("a=5 a b c a b=c"), ParseException);
     152           6 :         EXPECT_THROW (parseArguments ("a a=5 b c a#0 b=c"), BadPluginName);
     153           6 :         EXPECT_THROW (parseArguments ("a a=5 b c # b=c"), BadPluginName);
     154           6 :         EXPECT_THROW (parseArguments ("a a=5 b c #a b=c"), BadPluginName);
     155           2 : }
     156             : 
     157          20 : TEST (MountBackendBuilder, parseArgumentsRef)
     158             : {
     159             :         using namespace kdb;
     160             :         using namespace kdb::tools;
     161           4 :         PluginSpecVector psv1;
     162          22 :         psv1.push_back (PluginSpec ("a", "mya", KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), KS_END)));
     163          18 :         psv1.push_back (PluginSpec ("b", "myb"));
     164          18 :         psv1.push_back (PluginSpec ("c", "myc"));
     165          22 :         psv1.push_back (PluginSpec ("a", "othera", KeySet (5, *Key ("user/b", KEY_VALUE, "c", KEY_END), KS_END)));
     166          10 :         PluginSpecVector psv2 = parseArguments ("a#mya a=5 b#myb c#myc a#othera b=c");
     167          72 :         CMP_PSV (psv1, psv2);
     168          10 :         psv2 = parseArguments ("  a#mya  a=5  b#myb c#myc a#othera b=c   ");
     169          72 :         CMP_PSV (psv1, psv2);
     170          10 :         psv2 = parseArguments ("  a#mya     a=5      b#myb c#myc , a#othera b=c  ");
     171          72 :         CMP_PSV (psv1, psv2);
     172           2 : }
     173             : 
     174             : 
     175          20 : TEST (MountBackendBuilder, parseArgumentsProvider)
     176             : {
     177             :         using namespace kdb;
     178             :         using namespace kdb::tools;
     179           4 :         PluginSpecVector psv1;
     180          22 :         psv1.push_back (PluginSpec ("augeas", "aaa", KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), KS_END)));
     181          18 :         psv1.push_back (PluginSpec ("logging", "logg"));
     182          24 :         psv1.push_back (PluginSpec ("code", "nee", KeySet (5, *Key ("user/escape", KEY_VALUE, "-", KEY_END), KS_END))),
     183          22 :                 psv1.push_back (PluginSpec ("hexcode", "hexcode", KeySet (5, *Key ("user/escape", KEY_VALUE, "%", KEY_END), KS_END)));
     184          10 :         PluginSpecVector psv2 = parseArguments ("augeas#aaa a=5 logging#logg code#nee escape=% hexcode escape=-");
     185          72 :         CMP_PSV (psv1, psv2);
     186             : 
     187             : 
     188           2 :         std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
     189          24 :         mpd->data[PluginSpec ("ccode")]["provides"] = "code";
     190          24 :         mpd->data[PluginSpec ("syslog")]["provides"] = "logging";
     191          22 :         mpd->data[PluginSpec ("augeas")][""];
     192          22 :         mpd->data[PluginSpec ("hexcode")][""];
     193           6 :         BackendBuilderInit bbi (mpd);
     194           4 :         BackendBuilder bb (bbi);
     195          16 :         for (auto const & p : psv2)
     196             :         {
     197           8 :                 bb.addPlugin (p);
     198             :         }
     199           4 :         PluginSpecVector psv3;
     200          22 :         psv3.push_back (PluginSpec ("augeas", "aaa", KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), KS_END)));
     201          18 :         psv3.push_back (PluginSpec ("syslog", "logg"));
     202          22 :         psv3.push_back (PluginSpec ("ccode", "nee", KeySet (5, *Key ("user/escape", KEY_VALUE, "-", KEY_END), KS_END)));
     203          22 :         psv3.push_back (PluginSpec ("hexcode", "hexcode", KeySet (5, *Key ("user/escape", KEY_VALUE, "%", KEY_END), KS_END)));
     204          10 :         PluginSpecVector psv4 (bb.begin (), bb.end ());
     205          72 :         CMP_PSV (psv3, psv4);
     206           2 : }
     207             : 
     208          20 : TEST (MountBackendBuilder, parseArgumentsSameProvider)
     209             : {
     210             :         using namespace kdb;
     211             :         using namespace kdb::tools;
     212           4 :         PluginSpecVector psv1;
     213          18 :         psv1.push_back (PluginSpec ("augeas", "a1"));
     214          18 :         psv1.push_back (PluginSpec ("logging", "a2"));
     215          22 :         psv1.push_back (PluginSpec ("code", "a3", KeySet (5, *Key ("user/escape", KEY_VALUE, "%", KEY_END), KS_END)));
     216          22 :         psv1.push_back (PluginSpec ("code", "a4", KeySet (5, *Key ("user/escape", KEY_VALUE, "-", KEY_END), KS_END)));
     217          18 :         psv1.push_back (PluginSpec ("code", "a5"));
     218          10 :         PluginSpecVector psv2 = parseArguments ("augeas#a1 logging#a2 code#a3 escape=% code#a4 escape=- code#a5");
     219          86 :         CMP_PSV (psv1, psv2);
     220             : 
     221             : 
     222           2 :         std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
     223          24 :         mpd->data[PluginSpec ("ccode")]["provides"] = "code";
     224          24 :         mpd->data[PluginSpec ("syslog")]["provides"] = "logging";
     225          22 :         mpd->data[PluginSpec ("augeas")][""];
     226          22 :         mpd->data[PluginSpec ("hexcode")][""];
     227           6 :         BackendBuilderInit bbi (mpd);
     228           4 :         BackendBuilder bb (bbi);
     229          18 :         for (auto const & p : psv2)
     230             :         {
     231          10 :                 bb.addPlugin (p);
     232             :         }
     233           4 :         PluginSpecVector psv3;
     234          10 :         PluginSpecVector psv4 (bb.begin (), bb.end ());
     235          18 :         psv3.push_back (PluginSpec ("augeas", "a1"));
     236          18 :         psv3.push_back (PluginSpec ("syslog", "a2"));
     237          22 :         psv3.push_back (PluginSpec ("ccode", "a3", KeySet (5, *Key ("user/escape", KEY_VALUE, "%", KEY_END), KS_END)));
     238          22 :         psv3.push_back (PluginSpec ("ccode", "a4", KeySet (5, *Key ("user/escape", KEY_VALUE, "-", KEY_END), KS_END)));
     239          18 :         psv3.push_back (PluginSpec ("ccode", "a5"));
     240          86 :         CMP_PSV (psv3, psv4);
     241           2 : }
     242             : 
     243             : 
     244          20 : TEST (MountBackendBuilder, parseArgumentsSameProviderAgain)
     245             : {
     246             :         using namespace kdb;
     247             :         using namespace kdb::tools;
     248           4 :         PluginSpecVector psv1;
     249          18 :         psv1.push_back (PluginSpec ("augeas", "same1"));
     250          18 :         psv1.push_back (PluginSpec ("logging", "same2"));
     251          22 :         psv1.push_back (PluginSpec ("code", "same3", KeySet (5, *Key ("user/escape", KEY_VALUE, "%", KEY_END), KS_END)));
     252          22 :         psv1.push_back (PluginSpec ("code", "same4", KeySet (5, *Key ("user/escape", KEY_VALUE, "-", KEY_END), KS_END)));
     253          10 :         PluginSpecVector psv2 = parseArguments ("augeas#same1 logging#same2 code#same3 escape=% code#same4 escape=- ");
     254          72 :         CMP_PSV (psv1, psv2);
     255             : 
     256             : 
     257           2 :         std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
     258          24 :         mpd->data[PluginSpec ("ccode")]["provides"] = "code";
     259          24 :         mpd->data[PluginSpec ("syslog")]["provides"] = "logging";
     260          22 :         mpd->data[PluginSpec ("augeas")][""];
     261          22 :         mpd->data[PluginSpec ("hexcode")][""];
     262           6 :         BackendBuilderInit bbi (mpd);
     263           4 :         BackendBuilder bb (bbi);
     264          16 :         for (auto const & p : psv2)
     265             :         {
     266           8 :                 bb.addPlugin (p);
     267             :         }
     268           4 :         PluginSpecVector psv3;
     269          10 :         PluginSpecVector psv4 (bb.begin (), bb.end ());
     270          18 :         psv3.push_back (PluginSpec ("augeas", "same1"));
     271          18 :         psv3.push_back (PluginSpec ("syslog", "same2"));
     272          22 :         psv3.push_back (PluginSpec ("ccode", "same3", KeySet (5, *Key ("user/escape", KEY_VALUE, "%", KEY_END), KS_END)));
     273          22 :         psv3.push_back (PluginSpec ("ccode", "same4", KeySet (5, *Key ("user/escape", KEY_VALUE, "-", KEY_END), KS_END)));
     274          72 :         CMP_PSV (psv3, psv4);
     275           8 : }

Generated by: LCOV version 1.13