SERVER-24508 BSONObj::ComparatorInterface

BSONObj instances should now be compared via the comparator
interface's evaluate() method. This preferred over using
BSONObj::woCompare() directly. If the comparison doesn't
require any database semantics (e.g. there is no collation),
there is a global instance of the SimpleBSONObjComparator
which should be used for BSONObj comparisons. If the
comparison requires special semantics, then callers must
instantiate their own comparator object.

1 files changed, 32 insertions, 32 deletions

diff --git a/src/mongo/db/keypattern_test.cpp b/src/mongo/db/keypattern_test.cpp
index 4b83648fa7d..b2d35b5aac4 100644
--- a/src/mongo/db/keypattern_test.cpp
+++ b/src/mongo/db/keypattern_test.cpp
@@ -57,46 +57,46 @@ TEST(KeyPattern, ExtendRangeBound) {
     {
         KeyPattern keyPat(BSON("a" << 1));
         BSONObj newB = keyPat.extendRangeBound(bound, false);
-        ASSERT_EQUALS(newB, BSON("a" << 55));
+        ASSERT_BSONOBJ_EQ(newB, BSON("a" << 55));
     }
     {
         KeyPattern keyPat(BSON("a" << 1));
         BSONObj newB = keyPat.extendRangeBound(bound, false);
-        ASSERT_EQUALS(newB, BSON("a" << 55));
+        ASSERT_BSONOBJ_EQ(newB, BSON("a" << 55));
     }
 
     // test keyPattern longer than bound, simple
     {
         KeyPattern keyPat(BSON("a" << 1 << "b" << 1));
         BSONObj newB = keyPat.extendRangeBound(bound, false);
-        ASSERT_EQUALS(newB, BSON("a" << 55 << "b" << MINKEY));
+        ASSERT_BSONOBJ_EQ(newB, BSON("a" << 55 << "b" << MINKEY));
     }
     {
         KeyPattern keyPat(BSON("a" << 1 << "b" << 1));
         BSONObj newB = keyPat.extendRangeBound(bound, true);
-        ASSERT_EQUALS(newB, BSON("a" << 55 << "b" << MAXKEY));
+        ASSERT_BSONOBJ_EQ(newB, BSON("a" << 55 << "b" << MAXKEY));
     }
 
     // test keyPattern longer than bound, more complex pattern directions
     {
         KeyPattern keyPat(BSON("a" << 1 << "b" << -1));
         BSONObj newB = keyPat.extendRangeBound(bound, false);
-        ASSERT_EQUALS(newB, BSON("a" << 55 << "b" << MAXKEY));
+        ASSERT_BSONOBJ_EQ(newB, BSON("a" << 55 << "b" << MAXKEY));
     }
     {
         KeyPattern keyPat(BSON("a" << 1 << "b" << -1));
         BSONObj newB = keyPat.extendRangeBound(bound, true);
-        ASSERT_EQUALS(newB, BSON("a" << 55 << "b" << MINKEY));
+        ASSERT_BSONOBJ_EQ(newB, BSON("a" << 55 << "b" << MINKEY));
     }
     {
         KeyPattern keyPat(BSON("a" << 1 << "b" << -1 << "c" << 1));
         BSONObj newB = keyPat.extendRangeBound(bound, false);
-        ASSERT_EQUALS(newB, BSON("a" << 55 << "b" << MAXKEY << "c" << MINKEY));
+        ASSERT_BSONOBJ_EQ(newB, BSON("a" << 55 << "b" << MAXKEY << "c" << MINKEY));
     }
     {
         KeyPattern keyPat(BSON("a" << 1 << "b" << -1 << "c" << 1));
         BSONObj newB = keyPat.extendRangeBound(bound, true);
-        ASSERT_EQUALS(newB, BSON("a" << 55 << "b" << MINKEY << "c" << MAXKEY));
+        ASSERT_BSONOBJ_EQ(newB, BSON("a" << 55 << "b" << MINKEY << "c" << MAXKEY));
     }
 }
 
@@ -105,39 +105,39 @@ TEST(KeyPattern, GlobalMinMax) {
     // Simple KeyPatterns
     //
 
-    ASSERT_EQUALS(KeyPattern(BSON("a" << 1)).globalMin(), BSON("a" << MINKEY));
-    ASSERT_EQUALS(KeyPattern(BSON("a" << 1)).globalMax(), BSON("a" << MAXKEY));
+    ASSERT_BSONOBJ_EQ(KeyPattern(BSON("a" << 1)).globalMin(), BSON("a" << MINKEY));
+    ASSERT_BSONOBJ_EQ(KeyPattern(BSON("a" << 1)).globalMax(), BSON("a" << MAXKEY));
 
-    ASSERT_EQUALS(KeyPattern(BSON("a" << -1)).globalMin(), BSON("a" << MAXKEY));
-    ASSERT_EQUALS(KeyPattern(BSON("a" << -1)).globalMax(), BSON("a" << MINKEY));
+    ASSERT_BSONOBJ_EQ(KeyPattern(BSON("a" << -1)).globalMin(), BSON("a" << MAXKEY));
+    ASSERT_BSONOBJ_EQ(KeyPattern(BSON("a" << -1)).globalMax(), BSON("a" << MINKEY));
 
-    ASSERT_EQUALS(KeyPattern(BSON("a" << 1 << "b" << 1.0)).globalMin(),
-                  BSON("a" << MINKEY << "b" << MINKEY));
-    ASSERT_EQUALS(KeyPattern(BSON("a" << 1 << "b" << 1.0)).globalMax(),
-                  BSON("a" << MAXKEY << "b" << MAXKEY));
+    ASSERT_BSONOBJ_EQ(KeyPattern(BSON("a" << 1 << "b" << 1.0)).globalMin(),
+                      BSON("a" << MINKEY << "b" << MINKEY));
+    ASSERT_BSONOBJ_EQ(KeyPattern(BSON("a" << 1 << "b" << 1.0)).globalMax(),
+                      BSON("a" << MAXKEY << "b" << MAXKEY));
 
-    ASSERT_EQUALS(KeyPattern(BSON("a" << 1 << "b" << -1.0f)).globalMin(),
-                  BSON("a" << MINKEY << "b" << MAXKEY));
-    ASSERT_EQUALS(KeyPattern(BSON("a" << 1 << "b" << -1.0f)).globalMax(),
-                  BSON("a" << MAXKEY << "b" << MINKEY));
+    ASSERT_BSONOBJ_EQ(KeyPattern(BSON("a" << 1 << "b" << -1.0f)).globalMin(),
+                      BSON("a" << MINKEY << "b" << MAXKEY));
+    ASSERT_BSONOBJ_EQ(KeyPattern(BSON("a" << 1 << "b" << -1.0f)).globalMax(),
+                      BSON("a" << MAXKEY << "b" << MINKEY));
 
-    ASSERT_EQUALS(KeyPattern(BSON("a"
-                                  << "hashed"))
-                      .globalMin(),
-                  BSON("a" << MINKEY));
-    ASSERT_EQUALS(KeyPattern(BSON("a"
-                                  << "hashed"))
-                      .globalMax(),
-                  BSON("a" << MAXKEY));
+    ASSERT_BSONOBJ_EQ(KeyPattern(BSON("a"
+                                      << "hashed"))
+                          .globalMin(),
+                      BSON("a" << MINKEY));
+    ASSERT_BSONOBJ_EQ(KeyPattern(BSON("a"
+                                      << "hashed"))
+                          .globalMax(),
+                      BSON("a" << MAXKEY));
 
     //
     // Nested KeyPatterns
     //
 
-    ASSERT_EQUALS(KeyPattern(BSON("a.b" << 1)).globalMin(), BSON("a.b" << MINKEY));
-    ASSERT_EQUALS(KeyPattern(BSON("a.b" << 1)).globalMax(), BSON("a.b" << MAXKEY));
+    ASSERT_BSONOBJ_EQ(KeyPattern(BSON("a.b" << 1)).globalMin(), BSON("a.b" << MINKEY));
+    ASSERT_BSONOBJ_EQ(KeyPattern(BSON("a.b" << 1)).globalMax(), BSON("a.b" << MAXKEY));
 
-    ASSERT_EQUALS(KeyPattern(BSON("a.b.c" << -1)).globalMin(), BSON("a.b.c" << MAXKEY));
-    ASSERT_EQUALS(KeyPattern(BSON("a.b.c" << -1)).globalMax(), BSON("a.b.c" << MINKEY));
+    ASSERT_BSONOBJ_EQ(KeyPattern(BSON("a.b.c" << -1)).globalMin(), BSON("a.b.c" << MAXKEY));
+    ASSERT_BSONOBJ_EQ(KeyPattern(BSON("a.b.c" << -1)).globalMax(), BSON("a.b.c" << MINKEY));
 }
 }