Comparison and streaming operators for base::Version

chrome/installer/util/installer_state_unittest.cc

 // Copyright (c) 2012 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 "chrome/installer/util/installer_state.h"
 
 #include <windows.h>
 #include <stddef.h>
 
 #include <fstream>
@@ skipping 360 matching lines @@
     EXPECT_TRUE(chrome_key.Valid());
     if (chrome_key.Valid()) {
       chrome_key.WriteValue(google_update::kRegVersionField,
                             base::UTF8ToWide(
                                 current_version.GetString()).c_str());
       machine_state.Initialize();
       // TODO(tommi): Also test for when there exists a new_chrome.exe.
       Version found_version(*installer_state.GetCurrentVersion(machine_state));
       EXPECT_TRUE(found_version.IsValid());
       if (found_version.IsValid())
-        EXPECT_TRUE(current_version.Equals(found_version));
+        EXPECT_EQ(current_version, found_version);
     }
   }
 }
 
 TEST_F(InstallerStateTest, InstallerResult) {
   const bool system_level = true;
   HKEY root = system_level ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 
   RegKey key;
   std::wstring launch_cmd = L"hey diddle diddle";
@@ skipping 346 matching lines @@
 Version* InstallerStateCriticalVersionTest::opv_version_ = NULL;
 Version* InstallerStateCriticalVersionTest::middle_version_ = NULL;
 Version* InstallerStateCriticalVersionTest::pv_version_ = NULL;
 Version* InstallerStateCriticalVersionTest::high_version_ = NULL;
 
 // Test the case where the critical version is less than the currently-running
 // Chrome.  The critical version is ignored since it doesn't apply.
 TEST_F(InstallerStateCriticalVersionTest, CriticalBeforeOpv) {
   MockInstallerState& installer_state(Initialize(low_version_));
 
-  EXPECT_TRUE(installer_state.critical_update_version().Equals(*low_version_));
+  EXPECT_EQ(installer_state.critical_update_version(), *low_version_);
   // Unable to determine the installed version, so assume critical update.
   EXPECT_TRUE(
       installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid());
   // Installed version is past the critical update.
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(opv_version_, *pv_version_)
           .IsValid());
   // Installed version is past the critical update.
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(pv_version_, *pv_version_)
           .IsValid());
 }
 
 // Test the case where the critical version is equal to the currently-running
 // Chrome.  The critical version is ignored since it doesn't apply.
 TEST_F(InstallerStateCriticalVersionTest, CriticalEqualsOpv) {
   MockInstallerState& installer_state(Initialize(opv_version_));
 
-  EXPECT_TRUE(installer_state.critical_update_version().Equals(*opv_version_));
+  EXPECT_EQ(installer_state.critical_update_version(), *opv_version_);
   // Unable to determine the installed version, so assume critical update.
   EXPECT_TRUE(
       installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid());
   // Installed version equals the critical update.
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(opv_version_, *pv_version_)
           .IsValid());
   // Installed version equals the critical update.
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(pv_version_, *pv_version_)
           .IsValid());
 }
 
 // Test the case where the critical version is between the currently-running
 // Chrome and the to-be-installed Chrome.
 TEST_F(InstallerStateCriticalVersionTest, CriticalBetweenOpvAndPv) {
   MockInstallerState& installer_state(Initialize(middle_version_));
 
-  EXPECT_TRUE(installer_state.critical_update_version().Equals(
-      *middle_version_));
+  EXPECT_EQ(installer_state.critical_update_version(), *middle_version_);
   // Unable to determine the installed version, so assume critical update.
   EXPECT_TRUE(
       installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid());
   // Installed version before the critical update.
   EXPECT_TRUE(
       installer_state.DetermineCriticalVersion(opv_version_, *pv_version_)
           .IsValid());
   // Installed version is past the critical update.
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(pv_version_, *pv_version_)
           .IsValid());
 }
 
 // Test the case where the critical version is the same as the to-be-installed
 // Chrome.
 TEST_F(InstallerStateCriticalVersionTest, CriticalEqualsPv) {
   MockInstallerState& installer_state(Initialize(pv_version_));
 
-  EXPECT_TRUE(installer_state.critical_update_version().Equals(
-      *pv_version_));
+  EXPECT_EQ(installer_state.critical_update_version(), *pv_version_);
   // Unable to determine the installed version, so assume critical update.
   EXPECT_TRUE(
       installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid());
   // Installed version before the critical update.
   EXPECT_TRUE(
       installer_state.DetermineCriticalVersion(opv_version_, *pv_version_)
           .IsValid());
   // Installed version equals the critical update.
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(pv_version_, *pv_version_)
           .IsValid());
 }
 
 // Test the case where the critical version is greater than the to-be-installed
 // Chrome.
 TEST_F(InstallerStateCriticalVersionTest, CriticalAfterPv) {
   MockInstallerState& installer_state(Initialize(high_version_));
 
-  EXPECT_TRUE(installer_state.critical_update_version().Equals(
-      *high_version_));
+  EXPECT_EQ(installer_state.critical_update_version(), *high_version_);
   // Critical update newer than the new version.
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid());
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(opv_version_, *pv_version_)
           .IsValid());
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(pv_version_, *pv_version_)
           .IsValid());
 }