Comparison and streaming operators for base::Version

base/version_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 "base/version.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 TEST(VersionTest, DefaultConstructor) {
   Version v;
   EXPECT_FALSE(v.IsValid());
 }
 
 TEST(VersionTest, ValueSemantics) {
   Version v1("1.2.3.4");
   EXPECT_TRUE(v1.IsValid());
   Version v3;
   EXPECT_FALSE(v3.IsValid());
   {
     Version v2(v1);
     v3 = v2;
     EXPECT_TRUE(v2.IsValid());
-    EXPECT_TRUE(v1.Equals(v2));
+    EXPECT_EQ(v1, v2);
   }
-  EXPECT_TRUE(v3.Equals(v1));
+  EXPECT_EQ(v3, v1);
 }
 
 TEST(VersionTest, GetVersionFromString) {
   static const struct version_string {
     const char* input;
     size_t parts;
     uint32_t firstpart;
     bool success;
   } cases[] = {
     {"", 0, 0, false},
@@ skipping 52 matching lines @@
     {"1.0.3", "1.0.20", -1},
     {"11.0.10", "15.007.20011", -1},
     {"11.0.10", "15.5.28.130162", -1},
   };
   for (size_t i = 0; i < arraysize(cases); ++i) {
     Version lhs(cases[i].lhs);
     Version rhs(cases[i].rhs);
     EXPECT_EQ(lhs.CompareTo(rhs), cases[i].expected) <<
         cases[i].lhs << " ? " << cases[i].rhs;
 
-    EXPECT_EQ(lhs.IsOlderThan(cases[i].rhs), (cases[i].expected == -1));
+    // Test comparison operators
+    switch (cases[i].expected) {
+    case -1:
+      EXPECT_LT(lhs, rhs);
+      EXPECT_LE(lhs, rhs);
+      EXPECT_NE(lhs, rhs);
+      EXPECT_FALSE(lhs == rhs);
+      EXPECT_FALSE(lhs >= rhs);
+      EXPECT_FALSE(lhs > rhs);
+      break;
+    case 0:
+      EXPECT_FALSE(lhs < rhs);
+      EXPECT_LE(lhs, rhs);
+      EXPECT_FALSE(lhs != rhs);
+      EXPECT_EQ(lhs, rhs);
+      EXPECT_GE(lhs, rhs);
+      EXPECT_FALSE(lhs > rhs);
+      break;
+    case 1:
+      EXPECT_FALSE(lhs < rhs);
+      EXPECT_FALSE(lhs <= rhs);
+      EXPECT_NE(lhs, rhs);
+      EXPECT_FALSE(lhs == rhs);
+      EXPECT_GE(lhs, rhs);
+      EXPECT_GT(lhs, rhs);
+      break;
+    }
   }
 }
 
 TEST(VersionTest, CompareToWildcardString) {
   static const struct version_compare {
     const char* lhs;
     const char* rhs;
     int expected;
   } cases[] = {
     {"1.0", "1.*", 0},
@@ skipping 34 matching lines @@
     {"*", false},
     {"*.2", false},
   };
   for (size_t i = 0; i < arraysize(cases); ++i) {
     EXPECT_EQ(Version::IsValidWildcardString(cases[i].version),
         cases[i].expected) << cases[i].version << "?" << cases[i].expected;
   }
 }
 
 }  // namespace