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