LCOV - code coverage report
Current view: top level - src/bindings/intercept/env/tests - test_getenv.cpp (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 110 115 95.7 %
Date: 2019-09-12 12:28:41 Functions: 26 54 48.1 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief Tests for the getenv library
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  *
       8             :  */
       9             : 
      10             : #include <gtest/gtest.h>
      11             : #include <kdbgetenv.h>
      12             : 
      13          20 : TEST (GetEnv, NonExist)
      14             : {
      15           6 :         EXPECT_EQ (getenv ("du4Maiwi/does-not-exist"), static_cast<char *> (nullptr));
      16           2 : }
      17             : 
      18          20 : TEST (GetEnv, ExistOverride)
      19             : {
      20             :         using namespace ckdb;
      21           2 :         elektraOpen (nullptr, nullptr);
      22           2 :         ksAppendKey (elektraConfig, keyNew ("user/elektra/intercept/getenv/override/does-exist", KEY_VALUE, "hello", KEY_END));
      23           4 :         ASSERT_NE (getenv ("does-exist"), static_cast<char *> (nullptr));
      24          12 :         EXPECT_EQ (getenv ("does-exist"), std::string ("hello"));
      25           2 :         elektraClose ();
      26             : }
      27             : 
      28          20 : TEST (GetEnv, ExistOverrideFallback)
      29             : {
      30             :         using namespace ckdb;
      31           2 :         elektraOpen (nullptr, nullptr);
      32           2 :         ksAppendKey (elektraConfig, keyNew ("user/env/override/does-exist-fb", KEY_VALUE, "hello", KEY_END));
      33           4 :         ASSERT_NE (getenv ("does-exist-fb"), static_cast<char *> (nullptr));
      34          12 :         EXPECT_EQ (getenv ("does-exist-fb"), std::string ("hello"));
      35           2 :         elektraClose ();
      36             : }
      37             : 
      38          20 : TEST (GetEnv, ExistEnv)
      39             : {
      40             :         using namespace ckdb;
      41           2 :         elektraOpen (nullptr, nullptr);
      42           2 :         setenv ("does-exist", "hello", 1);
      43           4 :         ASSERT_NE (getenv ("does-exist"), static_cast<char *> (nullptr));
      44          12 :         EXPECT_EQ (getenv ("does-exist"), std::string ("hello"));
      45           2 :         elektraClose ();
      46             : }
      47             : 
      48          20 : TEST (GetEnv, ExistEnvFallback)
      49             : {
      50             :         using namespace ckdb;
      51           2 :         elektraOpen (nullptr, nullptr);
      52           2 :         setenv ("does-exist-fb", "hello", 1);
      53           4 :         ASSERT_NE (getenv ("does-exist-fb"), static_cast<char *> (nullptr));
      54          12 :         EXPECT_EQ (getenv ("does-exist-fb"), std::string ("hello"));
      55           2 :         elektraClose ();
      56             : }
      57             : 
      58          20 : TEST (GetEnv, ExistFallback)
      59             : {
      60             :         using namespace ckdb;
      61           2 :         elektraOpen (nullptr, nullptr);
      62           2 :         ksAppendKey (elektraConfig, keyNew ("user/elektra/intercept/getenv/fallback/does-exist", KEY_VALUE, "hello", KEY_END));
      63           4 :         ASSERT_NE (getenv ("does-exist"), static_cast<char *> (nullptr));
      64          12 :         EXPECT_EQ (getenv ("does-exist"), std::string ("hello"));
      65           2 :         elektraClose ();
      66             : }
      67             : 
      68          20 : TEST (GetEnv, ExistFallbackFallback)
      69             : {
      70             :         using namespace ckdb;
      71           2 :         elektraOpen (nullptr, nullptr);
      72           2 :         ksAppendKey (elektraConfig, keyNew ("user/env/fallback/does-exist-fb", KEY_VALUE, "hello", KEY_END));
      73           4 :         ASSERT_NE (getenv ("does-exist-fb"), static_cast<char *> (nullptr));
      74          12 :         EXPECT_EQ (getenv ("does-exist-fb"), std::string ("hello"));
      75           2 :         elektraClose ();
      76             : }
      77             : 
      78          20 : TEST (GetEnv, OpenClose)
      79             : {
      80             :         using namespace ckdb;
      81             :         // KeySet *oldElektraConfig = elektraConfig;
      82           2 :         elektraOpen (nullptr, nullptr);
      83             :         // EXPECT_NE(elektraConfig, oldElektraConfig); // even its a new object, it might point to same address
      84           6 :         EXPECT_EQ (getenv ("du4Maiwi/does-not-exist"), static_cast<char *> (nullptr));
      85           2 :         ksAppendKey (elektraConfig, keyNew ("user/elektra/intercept/getenv/override/does-exist", KEY_VALUE, "hello", KEY_END));
      86             : 
      87           4 :         ASSERT_NE (getenv ("does-exist"), static_cast<char *> (nullptr));
      88          12 :         EXPECT_EQ (getenv ("does-exist"), std::string ("hello"));
      89           6 :         EXPECT_EQ (getenv ("du4Maiwi/does-not-exist"), static_cast<char *> (nullptr));
      90           2 :         elektraClose ();
      91             : }
      92             : 
      93          20 : TEST (GetEnv, OpenCloseFallback)
      94             : {
      95             :         using namespace ckdb;
      96             :         // KeySet *oldElektraConfig = elektraConfig;
      97           2 :         elektraOpen (nullptr, nullptr);
      98             :         // EXPECT_NE(elektraConfig, oldElektraConfig); // even its a new object, it might point to same address
      99           6 :         EXPECT_EQ (getenv ("du4Maiwi/does-not-exist-fb"), static_cast<char *> (nullptr));
     100           2 :         ksAppendKey (elektraConfig, keyNew ("user/env/override/does-exist-fb", KEY_VALUE, "hello", KEY_END));
     101             : 
     102           4 :         ASSERT_NE (getenv ("does-exist-fb"), static_cast<char *> (nullptr));
     103          12 :         EXPECT_EQ (getenv ("does-exist-fb"), std::string ("hello"));
     104           6 :         EXPECT_EQ (getenv ("du4Maiwi/does-not-exist-fb"), static_cast<char *> (nullptr));
     105           2 :         elektraClose ();
     106             : }
     107             : 
     108           0 : void elektraPrintConfig ()
     109             : {
     110             :         using namespace ckdb;
     111             :         Key * c;
     112           0 :         ksRewind (elektraConfig);
     113           0 :         while ((c = ksNext (elektraConfig)))
     114             :         {
     115           0 :                 printf ("%s - %s\n", keyName (c), keyString (c));
     116             :         }
     117           0 : }
     118             : 
     119          20 : TEST (GetEnv, ArgvParam)
     120             : {
     121           2 :         const char * cargv[] = { "name", "--elektra:does-exist=hello", nullptr };
     122           2 :         char ** argv = const_cast<char **> (cargv);
     123           2 :         int argc = 2;
     124             :         using namespace ckdb;
     125           2 :         elektraOpen (&argc, argv);
     126           6 :         EXPECT_EQ (argc, 1) << "elektra proc not consumed";
     127          12 :         EXPECT_EQ (argv[0], std::string ("name"));
     128           6 :         EXPECT_EQ (argv[1], static_cast<char *> (nullptr));
     129             : 
     130           2 :         ckdb::Key * k = ksLookupByName (elektraConfig, "proc/elektra/intercept/getenv/override/does-exist", 0);
     131             : 
     132           4 :         ASSERT_NE (k, static_cast<ckdb::Key *> (nullptr));
     133          12 :         EXPECT_EQ (keyString (k), std::string ("hello"));
     134             : 
     135           4 :         ASSERT_NE (getenv ("does-exist"), static_cast<char *> (nullptr));
     136          12 :         EXPECT_EQ (getenv ("does-exist"), std::string ("hello"));
     137           2 :         elektraClose ();
     138             : }
     139             : 
     140          20 : TEST (GetEnv, ArgvParamUninvolved)
     141             : {
     142             :         const char * cargv[] = { "name",       "--uninvolved", "--not-used", "-L",   "--elektra:does-exist=hello",
     143           2 :                                  "--uninvolved", "--not-used",   "-L",     nullptr };
     144           2 :         char ** argv = const_cast<char **> (cargv);
     145           2 :         int argc = 8;
     146             :         using namespace ckdb;
     147           2 :         elektraOpen (&argc, argv);
     148           6 :         EXPECT_EQ (argc, 7) << "elektra proc not consumed";
     149          12 :         EXPECT_EQ (argv[0], std::string ("name"));
     150          12 :         EXPECT_EQ (argv[1], std::string ("--uninvolved"));
     151          12 :         EXPECT_EQ (argv[2], std::string ("--not-used"));
     152          12 :         EXPECT_EQ (argv[3], std::string ("-L"));
     153          12 :         EXPECT_EQ (argv[4], std::string ("--uninvolved"));
     154          12 :         EXPECT_EQ (argv[5], std::string ("--not-used"));
     155          12 :         EXPECT_EQ (argv[6], std::string ("-L"));
     156           6 :         EXPECT_EQ (argv[7], static_cast<char *> (nullptr));
     157             : 
     158           2 :         ckdb::Key * k = ksLookupByName (elektraConfig, "proc/elektra/intercept/getenv/override/does-exist", 0);
     159             : 
     160           4 :         ASSERT_NE (k, static_cast<ckdb::Key *> (nullptr));
     161          12 :         EXPECT_EQ (keyString (k), std::string ("hello"));
     162             : 
     163           4 :         ASSERT_NE (getenv ("does-exist"), static_cast<char *> (nullptr));
     164          12 :         EXPECT_EQ (getenv ("does-exist"), std::string ("hello"));
     165           2 :         elektraClose ();
     166             : }
     167             : 
     168          20 : TEST (GetEnv, NameArgv0)
     169             : {
     170             :         using namespace ckdb;
     171           2 :         int argc = 1;
     172           2 :         const char * cargv[] = { "path/to/any-name", nullptr };
     173           2 :         char ** argv = const_cast<char **> (cargv);
     174             : 
     175           2 :         elektraOpen (&argc, argv);
     176           2 :         ckdb::Key * k = ksLookupByName (elektraConfig, "proc/elektra/intercept/getenv/layer/name", 0);
     177           4 :         ASSERT_NE (k, static_cast<ckdb::Key *> (nullptr));
     178          12 :         EXPECT_EQ (keyString (k), std::string ("path/to/any-name"));
     179             : 
     180           2 :         k = ksLookupByName (elektraConfig, "proc/elektra/intercept/getenv/layer/basename", 0);
     181           4 :         ASSERT_NE (k, static_cast<ckdb::Key *> (nullptr));
     182          12 :         EXPECT_EQ (keyString (k), std::string ("any-name"));
     183           2 :         elektraClose ();
     184             : }
     185             : 
     186             : 
     187          20 : TEST (GetEnv, NameExplicit)
     188             : {
     189             :         using namespace ckdb;
     190           2 :         int argc = 2;
     191           2 :         const char * cargv[] = { "any-name", "--elektra%name%=other-name" };
     192           2 :         char ** argv = const_cast<char **> (cargv);
     193             : 
     194           2 :         elektraOpen (&argc, argv);
     195           2 :         ckdb::Key * k = ksLookupByName (elektraConfig, "proc/elektra/intercept/getenv/layer/name", 0);
     196           4 :         ASSERT_NE (k, static_cast<ckdb::Key *> (nullptr));
     197          12 :         EXPECT_EQ (keyString (k), std::string ("other-name"));
     198           2 :         elektraClose ();
     199             : }
     200             : 
     201             : #include "main.cpp"

Generated by: LCOV version 1.13