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