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 24namespace { 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. 28bool 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. 83bool 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. 94typedef 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.) 100TEST_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. 151TEST_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. 174TEST_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 197TEST_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