base/path_service_unittest.cc

   1 // Copyright (c) 2012 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/path_service.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/files/file_path.h"
   9 #include "base/files/file_util.h"
  10 #include "base/files/scoped_temp_dir.h"
  11 #include "base/strings/string_util.h"
  12 #include "build/build_config.h"
  13 #include "testing/gtest/include/gtest/gtest-spi.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "testing/platform_test.h"
  16
  17 #if defined(OS_WIN)
  18 #include "base/win/windows_version.h"
  19 #endif
  20
  21 namespace {
  22
  23 // Returns true if PathService::Get returns true and sets the path parameter
  24 // to non-empty for the given PathService::DirType enumeration value.
  25 bool ReturnsValidPath(int dir_type) {
  26   base::FilePath path;
  27   bool result = PathService::Get(dir_type, &path);
  28
  29   // Some paths might not exist on some platforms in which case confirming
  30   // |result| is true and !path.empty() is the best we can do.
  31   bool check_path_exists = true;
  32 #if defined(OS_POSIX)
  33   // If chromium has never been started on this account, the cache path may not
  34   // exist.
  35   if (dir_type == base::DIR_CACHE)
  36     check_path_exists = false;
  37 #endif
  38 #if defined(OS_LINUX)
  39   // On the linux try-bots: a path is returned (e.g. /home/chrome-bot/Desktop),
  40   // but it doesn't exist.
  41   if (dir_type == base::DIR_USER_DESKTOP)
  42     check_path_exists = false;
  43 #endif
  44 #if defined(OS_WIN)
  45   if (dir_type == base::DIR_TASKBAR_PINS) {
  46     // There is no pinned-to-taskbar shortcuts prior to Win7.
  47     if (base::win::GetVersion() < base::win::VERSION_WIN7)
  48       check_path_exists = false;
  49   }
  50 #endif
  51 #if defined(OS_MACOSX)
  52   if (dir_type != base::DIR_EXE && dir_type != base::DIR_MODULE &&
  53       dir_type != base::FILE_EXE && dir_type != base::FILE_MODULE) {
  54     if (path.ReferencesParent())
  55       return false;
  56   }
  57 #else
  58   if (path.ReferencesParent())
  59     return false;
  60 #endif
  61   return result && !path.empty() && (!check_path_exists ||
  62                                      base::PathExists(path));
  63 }
  64
  65 #if defined(OS_WIN)
  66 // Function to test any directory keys that are not supported on some versions
  67 // of Windows. Checks that the function fails and that the returned path is
  68 // empty.
  69 bool ReturnsInvalidPath(int dir_type) {
  70   base::FilePath path;
  71   bool result = PathService::Get(dir_type, &path);
  72   return !result && path.empty();
  73 }
  74 #endif
  75
  76 }  // namespace
  77
  78 // On the Mac this winds up using some autoreleased objects, so we need to
  79 // be a PlatformTest.
  80 typedef PlatformTest PathServiceTest;
  81
  82 // Test that all PathService::Get calls return a value and a true result
  83 // in the development environment.  (This test was created because a few
  84 // later changes to Get broke the semantics of the function and yielded the
  85 // correct value while returning false.)
  86 TEST_F(PathServiceTest, Get) {
  87   for (int key = base::PATH_START + 1; key < base::PATH_END; ++key) {
  88 #if defined(OS_ANDROID)
  89     if (key == base::FILE_MODULE || key == base::DIR_USER_DESKTOP ||
  90         key == base::DIR_HOME)
  91       continue;  // Android doesn't implement these.
  92 #elif defined(OS_IOS)
  93     if (key == base::DIR_USER_DESKTOP)
  94       continue;  // iOS doesn't implement DIR_USER_DESKTOP;
  95 #endif
  96     EXPECT_PRED1(ReturnsValidPath, key);
  97   }
  98 #if defined(OS_WIN)
  99   for (int key = base::PATH_WIN_START + 1; key < base::PATH_WIN_END; ++key) {
 100     bool valid = true;
 101     if (key == base::DIR_APP_SHORTCUTS)
 102       valid = base::win::GetVersion() >= base::win::VERSION_WIN8;
 103
 104     if (valid)
 105       EXPECT_TRUE(ReturnsValidPath(key)) << key;
 106     else
 107       EXPECT_TRUE(ReturnsInvalidPath(key)) << key;
 108   }
 109 #elif defined(OS_MACOSX)
 110   for (int key = base::PATH_MAC_START + 1; key < base::PATH_MAC_END; ++key) {
 111     EXPECT_PRED1(ReturnsValidPath, key);
 112   }
 113 #elif defined(OS_ANDROID)
 114   for (int key = base::PATH_ANDROID_START + 1; key < base::PATH_ANDROID_END;
 115        ++key) {
 116     EXPECT_PRED1(ReturnsValidPath, key);
 117   }
 118 #elif defined(OS_POSIX)
 119   for (int key = base::PATH_POSIX_START + 1; key < base::PATH_POSIX_END;
 120        ++key) {
 121     EXPECT_PRED1(ReturnsValidPath, key);
 122   }
 123 #endif
 124 }
 125
 126 // Test that all versions of the Override function of PathService do what they
 127 // are supposed to do.
 128 TEST_F(PathServiceTest, Override) {
 129   int my_special_key = 666;
 130   base::ScopedTempDir temp_dir;
 131   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 132   base::FilePath fake_cache_dir(temp_dir.path().AppendASCII("cache"));
 133   // PathService::Override should always create the path provided if it doesn't
 134   // exist.
 135   EXPECT_TRUE(PathService::Override(my_special_key, fake_cache_dir));
 136   EXPECT_TRUE(base::PathExists(fake_cache_dir));
 137
 138   base::FilePath fake_cache_dir2(temp_dir.path().AppendASCII("cache2"));
 139   // PathService::OverrideAndCreateIfNeeded should obey the |create| parameter.
 140   PathService::OverrideAndCreateIfNeeded(my_special_key,
 141                                          fake_cache_dir2,
 142                                          false,
 143                                          false);
 144   EXPECT_FALSE(base::PathExists(fake_cache_dir2));
 145   EXPECT_TRUE(PathService::OverrideAndCreateIfNeeded(my_special_key,
 146                                                      fake_cache_dir2,
 147                                                      false,
 148                                                      true));
 149   EXPECT_TRUE(base::PathExists(fake_cache_dir2));
 150
 151 #if defined(OS_POSIX)
 152   base::FilePath non_existent(
 153       base::MakeAbsoluteFilePath(temp_dir.path()).AppendASCII("non_existent"));
 154   EXPECT_TRUE(non_existent.IsAbsolute());
 155   EXPECT_FALSE(base::PathExists(non_existent));
 156 #if !defined(OS_ANDROID)
 157   // This fails because MakeAbsoluteFilePath fails for non-existent files.
 158   // Earlier versions of Bionic libc don't fail for non-existent files, so
 159   // skip this check on Android.
 160   EXPECT_FALSE(PathService::OverrideAndCreateIfNeeded(my_special_key,
 161                                                       non_existent,
 162                                                       false,
 163                                                       false));
 164 #endif
 165   // This works because indicating that |non_existent| is absolute skips the
 166   // internal MakeAbsoluteFilePath call.
 167   EXPECT_TRUE(PathService::OverrideAndCreateIfNeeded(my_special_key,
 168                                                      non_existent,
 169                                                      true,
 170                                                      false));
 171   // Check that the path has been overridden and no directory was created.
 172   EXPECT_FALSE(base::PathExists(non_existent));
 173   base::FilePath path;
 174   EXPECT_TRUE(PathService::Get(my_special_key, &path));
 175   EXPECT_EQ(non_existent, path);
 176 #endif
 177 }
 178
 179 // Check if multiple overrides can co-exist.
 180 TEST_F(PathServiceTest, OverrideMultiple) {
 181   int my_special_key = 666;
 182   base::ScopedTempDir temp_dir;
 183   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 184   base::FilePath fake_cache_dir1(temp_dir.path().AppendASCII("1"));
 185   EXPECT_TRUE(PathService::Override(my_special_key, fake_cache_dir1));
 186   EXPECT_TRUE(base::PathExists(fake_cache_dir1));
 187   ASSERT_EQ(1, base::WriteFile(fake_cache_dir1.AppendASCII("t1"), ".", 1));
 188
 189   base::FilePath fake_cache_dir2(temp_dir.path().AppendASCII("2"));
 190   EXPECT_TRUE(PathService::Override(my_special_key + 1, fake_cache_dir2));
 191   EXPECT_TRUE(base::PathExists(fake_cache_dir2));
 192   ASSERT_EQ(1, base::WriteFile(fake_cache_dir2.AppendASCII("t2"), ".", 1));
 193
 194   base::FilePath result;
 195   EXPECT_TRUE(PathService::Get(my_special_key, &result));
 196   // Override might have changed the path representation but our test file
 197   // should be still there.
 198   EXPECT_TRUE(base::PathExists(result.AppendASCII("t1")));
 199   EXPECT_TRUE(PathService::Get(my_special_key + 1, &result));
 200   EXPECT_TRUE(base::PathExists(result.AppendASCII("t2")));
 201 }
 202
 203 TEST_F(PathServiceTest, RemoveOverride) {
 204   // Before we start the test we have to call RemoveOverride at least once to
 205   // clear any overrides that might have been left from other tests.
 206   PathService::RemoveOverride(base::DIR_TEMP);
 207
 208   base::FilePath original_user_data_dir;
 209   EXPECT_TRUE(PathService::Get(base::DIR_TEMP, &original_user_data_dir));
 210   EXPECT_FALSE(PathService::RemoveOverride(base::DIR_TEMP));
 211
 212   base::ScopedTempDir temp_dir;
 213   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 214   EXPECT_TRUE(PathService::Override(base::DIR_TEMP, temp_dir.path()));
 215   base::FilePath new_user_data_dir;
 216   EXPECT_TRUE(PathService::Get(base::DIR_TEMP, &new_user_data_dir));
 217   EXPECT_NE(original_user_data_dir, new_user_data_dir);
 218
 219   EXPECT_TRUE(PathService::RemoveOverride(base::DIR_TEMP));
 220   EXPECT_TRUE(PathService::Get(base::DIR_TEMP, &new_user_data_dir));
 221   EXPECT_EQ(original_user_data_dir, new_user_data_dir);
 222 }