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