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"
|