Home | History | Annotate | Download | only in base 
      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 
     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 
     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 
     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 
     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 
     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 
     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 
    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