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
10typedef PlatformTest EnvironmentTest;
11
12namespace base {
13
14TEST_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
22TEST_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
50TEST_F(EnvironmentTest, HasVar) {
51  // Every setup should have PATH...
52  scoped_ptr<Environment> env(Environment::Create());
53  EXPECT_TRUE(env->HasVar("PATH"));
54}
55
56TEST_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
71TEST_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
91TEST_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
126TEST_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