Temporary workaround to get tests that reference singletons either directly o...

chrome_frame/test/util_unittests.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/file_path.h"
 #include "base/file_version_info.h"
 #include "base/file_version_info_win.h"
 #include "base/win/registry.h"
+#include "chrome_frame/test/chrome_frame_test_utils.h"
 #include "chrome_frame/utils.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using base::win::RegKey;
+using chrome_frame_test::TempRegKeyOverride;
 
 const wchar_t kChannelName[] = L"-dev";
 const wchar_t kSuffix[] = L"-fix";
 
-TEST(UtilTests, GetModuleVersionTest) {
+class UtilTests : public testing::Test {
+ protected:
+  void SetUp() {
+    TempRegKeyOverride::DeleteAllTempKeys();
+    DeleteAllSingletons();
+
+    hklm_pol_.reset(new TempRegKeyOverride(HKEY_LOCAL_MACHINE, L"hklm_fake"));
+    hkcu_pol_.reset(new TempRegKeyOverride(HKEY_CURRENT_USER, L"hkcu_fake"));
+  }
+
+  void TearDown() {
+    hkcu_pol_.reset(NULL);
+    hklm_pol_.reset(NULL);
+    TempRegKeyOverride::DeleteAllTempKeys();
+  }
+
+  // This is used to manage life cycle of PolicySettings singleton.
+  // base::ShadowingAtExitManager at_exit_manager_;
+  scoped_ptr<TempRegKeyOverride> hklm_pol_;
+  scoped_ptr<TempRegKeyOverride> hkcu_pol_;
+};
+
+TEST_F(UtilTests, GetModuleVersionTest) {
   HMODULE mod = GetModuleHandle(L"kernel32.dll");
   EXPECT_NE(mod, static_cast<HMODULE>(NULL));
   wchar_t path[MAX_PATH] = {0};
   GetModuleFileName(mod, path, arraysize(path));
 
   // Use the method that goes to disk
   scoped_ptr<FileVersionInfo> base_info(
       FileVersionInfo::CreateFileVersionInfo(path));
   EXPECT_TRUE(base_info.get() != NULL);
 
   // Use the method that doesn't go to disk
   uint32 low = 0, high = 0;
   EXPECT_TRUE(GetModuleVersion(mod, &high, &low));
   EXPECT_NE(high, 0u);
   EXPECT_NE(low, 0u);
 
   // Make sure they give the same results.
   FileVersionInfoWin* base_info_win =
       static_cast<FileVersionInfoWin*>(base_info.get());
   VS_FIXEDFILEINFO* fixed_info = base_info_win->fixed_file_info();
   EXPECT_TRUE(fixed_info != NULL);
 
   EXPECT_EQ(fixed_info->dwFileVersionMS, static_cast<DWORD>(high));
   EXPECT_EQ(fixed_info->dwFileVersionLS, static_cast<DWORD>(low));
 }
 
-TEST(UtilTests, HaveSameOrigin) {
+TEST_F(UtilTests, HaveSameOrigin) {
   struct OriginCompare {
     const char* a;
     const char* b;
     bool same_origin;
   } test_cases[] = {
     { "", "", true },
     { "*", "*", true },
     { "*", "+", false },
     { "http://www.google.com/", "http://www.google.com/", true },
     { "http://www.google.com", "http://www.google.com/", true },
     { "http://www.google.com:80/", "http://www.google.com/", true },
     { "http://www.google.com:8080/", "http://www.google.com/", false },
     { "https://www.google.com/", "http://www.google.com/", false },
     { "http://docs.google.com/", "http://www.google.com/", false },
     { "https://www.google.com/", "https://www.google.com:443/", true },
     { "https://www.google.com/", "https://www.google.com:443", true },
   };
 
   for (int i = 0; i < arraysize(test_cases); ++i) {
     const OriginCompare& test = test_cases[i];
     EXPECT_EQ(test.same_origin, HaveSameOrigin(test.a, test.b));
   }
 }
 
-TEST(UtilTests, IsValidUrlScheme) {
+TEST_F(UtilTests, IsValidUrlScheme) {
   struct Cases {
     const wchar_t* url;
     bool is_privileged;
     bool expected;
   } test_cases[] = {
     // non-privileged test cases
     { L"http://www.google.ca", false, true },
     { L"https://www.google.ca", false, true },
     { L"about:config", false, true },
     { L"view-source:http://www.google.ca", false, true },
@@ skipping 13 matching lines @@
     { L"file://C:\boot.ini", true, false },
   };
 
   for (int i = 0; i < arraysize(test_cases); ++i) {
     const Cases& test = test_cases[i];
     EXPECT_EQ(test.expected, IsValidUrlScheme(GURL(test.url),
                                               test.is_privileged));
   }
 }
 
-TEST(UtilTests, GuidToString) {
+TEST_F(UtilTests, GuidToString) {
   // {3C5E2125-35BA-48df-A841-5F669B9D69FC}
   const GUID test_guid = { 0x3c5e2125, 0x35ba, 0x48df,
       { 0xa8, 0x41, 0x5f, 0x66, 0x9b, 0x9d, 0x69, 0xfc } };
 
   wchar_t compare[64] = {0};
   ::StringFromGUID2(test_guid, compare, arraysize(compare));
 
   std::wstring str_guid(GuidToString(test_guid));
   EXPECT_EQ(0, str_guid.compare(compare));
   EXPECT_EQ(static_cast<size_t>(lstrlenW(compare)), str_guid.length());
 }
 
-TEST(UtilTests, GetTempInternetFiles) {
+TEST_F(UtilTests, GetTempInternetFiles) {
   FilePath path = GetIETemporaryFilesFolder();
   EXPECT_FALSE(path.empty());
 }
 
-TEST(UtilTests, ParseAttachTabUrlTest) {
+TEST_F(UtilTests, ParseAttachTabUrlTest) {
   ChromeFrameUrl cf_url;
 
   static const std::string kProfileName("iexplore");
 
   EXPECT_TRUE(cf_url.Parse(
       L"http://f/?attach_external_tab&10&1&2&3&123&321&iexplore"));
 
   EXPECT_TRUE(cf_url.attach_to_external_tab());
   EXPECT_FALSE(cf_url.is_chrome_protocol());
   EXPECT_EQ(10, cf_url.cookie());
@@ skipping 61 matching lines @@
               DWORD reserved));
   MOCK_METHOD7_WITH_CALLTYPE(__stdcall, QueryCustomPolicy,
       HRESULT(LPCWSTR url, REFGUID guid, BYTE** policy, DWORD* cb_policy,
               BYTE* context, DWORD cb_context, DWORD reserved));
   MOCK_METHOD3_WITH_CALLTYPE(__stdcall, SetZoneMapping,
       HRESULT(DWORD zone, LPCWSTR pattern, DWORD flags));
   MOCK_METHOD3_WITH_CALLTYPE(__stdcall, GetZoneMappings,
       HRESULT(DWORD zone, IEnumString** enum_string, DWORD flags));
 };
 
-TEST(UtilTests, CanNavigateTest) {
+TEST_F(UtilTests, CanNavigateTest) {
   MockIInternetSecurityManager mock;
 
   struct Zones {
     const wchar_t* url_prefix;
     URLZONE zone;
   } test_zones[] = {
     { L"http://blah", URLZONE_INTERNET },
     { L"http://untrusted", URLZONE_UNTRUSTED },
     { L"about:", URLZONE_TRUSTED },
     { L"view-source:", URLZONE_TRUSTED },
@@ skipping 70 matching lines @@
 
   for (int i = 0; i < arraysize(test_cases); ++i) {
     const Cases& test = test_cases[i];
     bool actual = CanNavigate(GURL(test.url), &mock, test.is_privileged);
     EXPECT_EQ(test.unsafe_expected, actual) << "Failure url: " << test.url;
   }
 
   SetConfigBool(kAllowUnsafeURLs, enable_gcf);
 }
 
-TEST(UtilTests, IsDefaultRendererTest) {
+TEST_F(UtilTests, IsDefaultRendererTest) {
   RegKey config_key(HKEY_CURRENT_USER, kChromeFrameConfigKey, KEY_ALL_ACCESS);
   EXPECT_TRUE(config_key.Valid());
 
   DWORD saved_default_renderer = 0;  // NOLINT
   config_key.ReadValueDW(kEnableGCFRendererByDefault, &saved_default_renderer);
 
   config_key.DeleteValue(kEnableGCFRendererByDefault);
   EXPECT_FALSE(IsGcfDefaultRenderer());
 
   config_key.WriteValue(kEnableGCFRendererByDefault, static_cast<DWORD>(0));
   EXPECT_FALSE(IsGcfDefaultRenderer());
 
   config_key.WriteValue(kEnableGCFRendererByDefault, static_cast<DWORD>(1));
   EXPECT_TRUE(IsGcfDefaultRenderer());
 
   config_key.WriteValue(kEnableGCFRendererByDefault, saved_default_renderer);
 }
 
-TEST(UtilTests, RendererTypeForUrlTest) {
+TEST_F(UtilTests, RendererTypeForUrlTest) {
   // Open all the keys we need.
   RegKey config_key(HKEY_CURRENT_USER, kChromeFrameConfigKey, KEY_ALL_ACCESS);
   EXPECT_TRUE(config_key.Valid());
   RegKey opt_for_gcf(config_key.Handle(), kRenderInGCFUrlList, KEY_ALL_ACCESS);
   EXPECT_TRUE(opt_for_gcf.Valid());
   RegKey opt_for_host(config_key.Handle(), kRenderInHostUrlList,
                       KEY_ALL_ACCESS);
   EXPECT_TRUE(opt_for_host.Valid());
   if (!config_key.Valid() || !opt_for_gcf.Valid() || !opt_for_host.Valid())
     return;
@@ skipping 23 matching lines @@
             RendererTypeForUrl(kTestUrl));
   opt_for_host.WriteValue(kTestFilter, L"");
   EXPECT_EQ(RENDERER_TYPE_UNDETERMINED, RendererTypeForUrl(kTestUrl));
 
   // Cleanup.
   opt_for_gcf.DeleteValue(kTestFilter);
   opt_for_host.DeleteValue(kTestFilter);
   config_key.WriteValue(kEnableGCFRendererByDefault, saved_default_renderer);
 }
 
-TEST(UtilTests, XUaCompatibleDirectiveTest) {
+TEST_F(UtilTests, XUaCompatibleDirectiveTest) {
   int all_versions[] = {0, 1, 2, 5, 6, 7, 8, 9, 10, 11, 99, 100, 101, 1000};
 
   struct Cases {
     const char* header_value;
     int max_version;
   } test_cases[] = {
     // Negative cases
     { "", -1 },
     { "chrome=", -1 },
     { "chrome", -1 },
@@ skipping 44 matching lines @@
 
       ASSERT_EQ(expect_match,
                 CheckXUaCompatibleDirective(test.header_value,
                                             all_versions[version_index]))
           << "Expect '" << test.header_value << "' to "
           << (expect_match ? "match" : "not match") << " IE major version "
           << all_versions[version_index];
     }
   }
 }