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