1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/environment.h"
#include <memory>
#include "build/build_config.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"
typedef PlatformTest EnvironmentTest;
namespace base {
namespace {
constexpr char kValidEnvironmentVariable[] = "PATH";
} // namespace
TEST_F(EnvironmentTest, GetVar) {
std::unique_ptr<Environment> env(Environment::Create());
std::string env_value;
EXPECT_TRUE(env->GetVar(kValidEnvironmentVariable, &env_value));
EXPECT_NE(env_value, "");
}
TEST_F(EnvironmentTest, GetVarReverse) {
std::unique_ptr<Environment> env(Environment::Create());
const char kFooUpper[] = "FOO";
const char kFooLower[] = "foo";
// Set a variable in UPPER case.
EXPECT_TRUE(env->SetVar(kFooUpper, kFooLower));
// And then try to get this variable passing the lower case.
std::string env_value;
EXPECT_TRUE(env->GetVar(kFooLower, &env_value));
EXPECT_STREQ(env_value.c_str(), kFooLower);
EXPECT_TRUE(env->UnSetVar(kFooUpper));
const char kBar[] = "bar";
// Now do the opposite, set the variable in the lower case.
EXPECT_TRUE(env->SetVar(kFooLower, kBar));
// And then try to get this variable passing the UPPER case.
EXPECT_TRUE(env->GetVar(kFooUpper, &env_value));
EXPECT_STREQ(env_value.c_str(), kBar);
EXPECT_TRUE(env->UnSetVar(kFooLower));
}
TEST_F(EnvironmentTest, HasVar) {
std::unique_ptr<Environment> env(Environment::Create());
EXPECT_TRUE(env->HasVar(kValidEnvironmentVariable));
}
TEST_F(EnvironmentTest, SetVar) {
std::unique_ptr<Environment> env(Environment::Create());
const char kFooUpper[] = "FOO";
const char kFooLower[] = "foo";
EXPECT_TRUE(env->SetVar(kFooUpper, kFooLower));
// Now verify that the environment has the new variable.
EXPECT_TRUE(env->HasVar(kFooUpper));
std::string var_value;
EXPECT_TRUE(env->GetVar(kFooUpper, &var_value));
EXPECT_EQ(var_value, kFooLower);
}
TEST_F(EnvironmentTest, UnSetVar) {
std::unique_ptr<Environment> env(Environment::Create());
const char kFooUpper[] = "FOO";
const char kFooLower[] = "foo";
// First set some environment variable.
EXPECT_TRUE(env->SetVar(kFooUpper, kFooLower));
// Now verify that the environment has the new variable.
EXPECT_TRUE(env->HasVar(kFooUpper));
// Finally verify that the environment variable was erased.
EXPECT_TRUE(env->UnSetVar(kFooUpper));
// And check that the variable has been unset.
EXPECT_FALSE(env->HasVar(kFooUpper));
}
#if defined(OS_WIN)
TEST_F(EnvironmentTest, AlterEnvironment) {
const wchar_t empty[] = L"\0";
const wchar_t a2[] = L"A=2\0";
EnvironmentMap changes;
string16 e;
e = AlterEnvironment(empty, changes);
EXPECT_EQ(0, e[0]);
changes[L"A"] = L"1";
e = AlterEnvironment(empty, changes);
EXPECT_EQ(string16(L"A=1\0\0", 5), e);
changes.clear();
changes[L"A"] = string16();
e = AlterEnvironment(empty, changes);
EXPECT_EQ(string16(L"\0\0", 2), e);
changes.clear();
e = AlterEnvironment(a2, changes);
EXPECT_EQ(string16(L"A=2\0\0", 5), e);
changes.clear();
changes[L"A"] = L"1";
e = AlterEnvironment(a2, changes);
EXPECT_EQ(string16(L"A=1\0\0", 5), e);
changes.clear();
changes[L"A"] = string16();
e = AlterEnvironment(a2, changes);
EXPECT_EQ(string16(L"\0\0", 2), e);
}
#else
TEST_F(EnvironmentTest, AlterEnvironment) {
const char* const empty[] = {nullptr};
const char* const a2[] = {"A=2", nullptr};
EnvironmentMap changes;
std::unique_ptr<char* []> e;
e = AlterEnvironment(empty, changes);
EXPECT_TRUE(e[0] == nullptr);
changes["A"] = "1";
e = AlterEnvironment(empty, changes);
EXPECT_EQ(std::string("A=1"), e[0]);
EXPECT_TRUE(e[1] == nullptr);
changes.clear();
changes["A"] = std::string();
e = AlterEnvironment(empty, changes);
EXPECT_TRUE(e[0] == nullptr);
changes.clear();
e = AlterEnvironment(a2, changes);
EXPECT_EQ(std::string("A=2"), e[0]);
EXPECT_TRUE(e[1] == nullptr);
changes.clear();
changes["A"] = "1";
e = AlterEnvironment(a2, changes);
EXPECT_EQ(std::string("A=1"), e[0]);
EXPECT_TRUE(e[1] == nullptr);
changes.clear();
changes["A"] = std::string();
e = AlterEnvironment(a2, changes);
EXPECT_TRUE(e[0] == nullptr);
}
#endif
} // namespace base
|
