diff --git a/groups/bsl/bslstl/bslstl_multimap_test.t.cpp b/groups/bsl/bslstl/bslstl_multimap_test.t.cpp
index d112ff0f82..ae963da550 100644
--- a/groups/bsl/bslstl/bslstl_multimap_test.t.cpp
+++ b/groups/bsl/bslstl/bslstl_multimap_test.t.cpp
@@ -895,6 +895,9 @@ struct TransparentComparator
 
 class TransparentlyComparable {
     // DATA
+#if BSLS_COMPILERFEATURES_CPLUSPLUS < 201103L
+    mutable
+#endif
     int d_conversionCount;  // number of times `operator int` has been called
     int d_value;            // the value
 
@@ -916,11 +919,21 @@ class TransparentlyComparable {
 
     /// Return the current value of this object.
     operator int()
+#if BSLS_COMPILERFEATURES_CPLUSPLUS < 201103L
+    const
+#endif
     {
         ++d_conversionCount;
         return d_value;
     }
 
+    /// return a count of the number of times this object has been converted to
+    /// an int.
+    void resetConversionCount()
+    {
+        d_conversionCount = 0;
+    }
+
     // ACCESSORS
 
     /// Return the number of times `operator int` has been called.
@@ -965,108 +978,135 @@ void testTransparentComparator(Container& container,
     typedef typename Container::const_iterator Iterator;
     typedef typename Container::size_type      Count;
 
-    int expectedConversionCount = 0;
+    const int expectedConversionCount = isTransparent ? 0 : 1;
 
     TransparentlyComparable existingKey(initKeyValue);
     TransparentlyComparable nonExistingKey(initKeyValue ? -initKeyValue
                                                         : -100);
 
-    ASSERT(existingKey.conversionCount() == expectedConversionCount);
+    {
+        // Testing `find`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    // Testing `find`.
+        const Iterator EXISTING_F = container.find(existingKey);
+        ASSERT(container.end()               != EXISTING_F);
+        ASSERT(existingKey.value()           == EXISTING_F->first);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    const Iterator EXISTING_F = container.find(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        const Iterator NON_EXISTING_F = container.find(nonExistingKey);
+        ASSERT(container.end()                  == NON_EXISTING_F);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERT(container.end()               != EXISTING_F);
-    ASSERT(existingKey.value()           == EXISTING_F->first);
-    ASSERT(existingKey.conversionCount() == expectedConversionCount);
+    {
+        // Testing `contains`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    const Iterator NON_EXISTING_F = container.find(nonExistingKey);
-    ASSERT(container.end()                  == NON_EXISTING_F);
-    ASSERT(nonExistingKey.conversionCount() == expectedConversionCount);
+        const bool EXISTING_CONTAINS = container.contains(existingKey);
 
-    // Testing `contains`.
+        ASSERT(true == EXISTING_CONTAINS);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    const bool EXISTING_CONTAINS = container.contains(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        const bool NON_EXISTING_CONTAINS = container.contains(nonExistingKey);
+        ASSERT(false == NON_EXISTING_CONTAINS);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERT(true == EXISTING_CONTAINS);
-    ASSERT(existingKey.conversionCount() == expectedConversionCount);
-
-    const bool NON_EXISTING_CONTAINS = container.contains(nonExistingKey);
-    ASSERT(false == NON_EXISTING_CONTAINS);
-    ASSERT(nonExistingKey.conversionCount() == expectedConversionCount);
-
-    // Testing `count`.
+    {
+        // Testing `count`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    const Count EXPECTED_C = initKeyValue ? initKeyValue : 1;
-    const Count EXISTING_C = container.count(existingKey);
+        const Count EXPECTED_C = initKeyValue ? initKeyValue : 1;
+        const Count EXISTING_C = container.count(existingKey);
+        ASSERT(EXPECTED_C              == EXISTING_C);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        const Count NON_EXISTING_C = container.count(nonExistingKey);
+        ASSERT(0                       == NON_EXISTING_C);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERT(EXPECTED_C              == EXISTING_C);
-    ASSERT(expectedConversionCount == existingKey.conversionCount());
-
-    const Count NON_EXISTING_C = container.count(nonExistingKey);
-    ASSERT(0                       == NON_EXISTING_C);
-    ASSERT(expectedConversionCount == nonExistingKey.conversionCount());
+    {
+        // Testing `lower_bound`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    // Testing `lower_bound`.
+        const Iterator EXISTING_LB = container.lower_bound(existingKey);
+        ASSERT(existingKey.value() == EXISTING_LB->first);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    const Iterator EXISTING_LB = container.lower_bound(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        const Iterator NON_EXISTING_LB = container.lower_bound(nonExistingKey);
+        ASSERT(container.begin()       == NON_EXISTING_LB);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERT(EXISTING_F              == EXISTING_LB);
-    ASSERT(expectedConversionCount == existingKey.conversionCount());
-
-    const Iterator NON_EXISTING_LB = container.lower_bound(nonExistingKey);
-
-    ASSERT(container.begin()       == NON_EXISTING_LB);
-    ASSERT(expectedConversionCount == nonExistingKey.conversionCount());
+    {
+        // Testing `upper_bound`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    // Testing `upper_bound`.
-    TransparentlyComparable upperBoundValue(initKeyValue + 1);
-    const Iterator          EXPECTED_UB = container.find(upperBoundValue);
-    const Iterator          EXISTING_UB = container.upper_bound(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
-    }
+        TransparentlyComparable upperBoundValue(initKeyValue + 1);
+        const Iterator          EXPECTED_UB = container.find(upperBoundValue);
+        const Iterator          EXISTING_UB = container.upper_bound(existingKey);
 
-    ASSERT(EXPECTED_UB             == EXISTING_UB);
-    ASSERT(expectedConversionCount == existingKey.conversionCount());
+        ASSERT(EXPECTED_UB             == EXISTING_UB);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    const Iterator NON_EXISTING_UB = container.upper_bound(nonExistingKey);
+        const Iterator NON_EXISTING_UB = container.upper_bound(nonExistingKey);
 
-    ASSERT(container.begin()       == NON_EXISTING_UB);
-    ASSERT(expectedConversionCount == nonExistingKey.conversionCount());
+        ASSERT(container.begin()       == NON_EXISTING_UB);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
+    }
 
-    // Testing `equal_range`.
+    {
+        // Testing `equal_range`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    const bsl::pair<Iterator, Iterator> EXISTING_ER =
+        const bsl::pair<Iterator, Iterator> EXISTING_ER =
                                             container.equal_range(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
-    }
+        ASSERT(EXISTING_ER.first != EXISTING_ER.second);
 
-    ASSERT(EXISTING_LB             == EXISTING_ER.first);
-    ASSERT(EXPECTED_UB             == EXISTING_ER.second);
-    ASSERT(expectedConversionCount == existingKey.conversionCount());
+        ASSERTV(0 < static_cast<Count>(
+                        bsl::distance(EXISTING_ER.first, EXISTING_ER.second)));
+        for (Iterator it = EXISTING_ER.first; it != EXISTING_ER.second; ++it) {
+            ASSERTV(existingKey.value() == it->first);
+        }
 
-    const bsl::pair<Iterator, Iterator> NON_EXISTING_ER =
-                                         container.equal_range(nonExistingKey);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    ASSERT(NON_EXISTING_LB         == NON_EXISTING_ER.first);
-    ASSERT(NON_EXISTING_UB         == NON_EXISTING_ER.second);
-    ASSERT(expectedConversionCount == nonExistingKey.conversionCount());
+        const bsl::pair<Iterator, Iterator> NON_EXISTING_ER =
+                                         container.equal_range(nonExistingKey);
+        ASSERT(NON_EXISTING_ER.first == NON_EXISTING_ER.second);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
+    }
 }
 
                             // =============================
diff --git a/groups/bsl/bslstl/bslstl_multiset_test.t.cpp b/groups/bsl/bslstl/bslstl_multiset_test.t.cpp
index da6ea42a9e..62676a0248 100644
--- a/groups/bsl/bslstl/bslstl_multiset_test.t.cpp
+++ b/groups/bsl/bslstl/bslstl_multiset_test.t.cpp
@@ -874,6 +874,9 @@ struct TransparentComparator
 
 class TransparentlyComparable {
     // DATA
+#if BSLS_COMPILERFEATURES_CPLUSPLUS < 201103L
+    mutable
+#endif
     int d_conversionCount;  // number of times `operator int` has been called
     int d_value;            // the value
 
@@ -895,11 +898,21 @@ class TransparentlyComparable {
 
     /// Return the current value of this object.
     operator int()
+#if BSLS_COMPILERFEATURES_CPLUSPLUS < 201103L
+    const
+#endif
     {
         ++d_conversionCount;
         return d_value;
     }
 
+    /// return a count of the number of times this object has been converted to
+    /// an int.
+    void resetConversionCount()
+    {
+        d_conversionCount = 0;
+    }
+
     // ACCESSORS
 
     /// Return the number of times `operator int` has been called.
@@ -944,108 +957,139 @@ void testTransparentComparator(Container& container,
     typedef typename Container::const_iterator Iterator;
     typedef typename Container::size_type      Count;
 
-    int expectedConversionCount = 0;
+    const int expectedConversionCount = isTransparent ? 0 : 1;
 
     TransparentlyComparable existingKey(initKeyValue);
     TransparentlyComparable nonExistingKey(initKeyValue ? -initKeyValue
                                                         : -100);
 
-    ASSERT(existingKey.conversionCount() == expectedConversionCount);
-
-    // Testing `find`.
-
-    const Iterator EXISTING_F = container.find(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
-    }
-
-    ASSERT(container.end()               != EXISTING_F);
-    ASSERT(existingKey.value()           == *EXISTING_F);
-    ASSERT(existingKey.conversionCount() == expectedConversionCount);
+    {
+        // Testing `find`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    const Iterator NON_EXISTING_F = container.find(nonExistingKey);
-    ASSERT(container.end()                  == NON_EXISTING_F);
-    ASSERT(nonExistingKey.conversionCount() == expectedConversionCount);
+        const Iterator EXISTING_F = container.find(existingKey);
 
-    // Testing `contains`.
+        ASSERT(container.end()               != EXISTING_F);
+        ASSERT(existingKey.value()           == *EXISTING_F);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    const bool EXISTING_CONTAINS = container.contains(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        const Iterator NON_EXISTING_F = container.find(nonExistingKey);
+        ASSERT(container.end()                  == NON_EXISTING_F);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERT(true == EXISTING_CONTAINS);
-    ASSERT(existingKey.conversionCount() == expectedConversionCount);
+    {
+        // Testing `contains`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    const bool NON_EXISTING_CONTAINS = container.contains(nonExistingKey);
-    ASSERT(false == NON_EXISTING_CONTAINS);
-    ASSERT(nonExistingKey.conversionCount() == expectedConversionCount);
+        const bool EXISTING_CONTAINS = container.contains(existingKey);
 
-    // Testing `count`.
+        ASSERT(true == EXISTING_CONTAINS);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    const Count EXPECTED_C = initKeyValue ? initKeyValue : 1;
-    const Count EXISTING_C = container.count(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        const bool NON_EXISTING_CONTAINS = container.contains(nonExistingKey);
+        ASSERT(false == NON_EXISTING_CONTAINS);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERT(EXPECTED_C              == EXISTING_C);
-    ASSERT(expectedConversionCount == existingKey.conversionCount());
+    {
+        // Testing `count`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    const Count NON_EXISTING_C = container.count(nonExistingKey);
-    ASSERT(0                       == NON_EXISTING_C);
-    ASSERT(expectedConversionCount == nonExistingKey.conversionCount());
+        const Count EXPECTED_C = initKeyValue ? initKeyValue : 1;
+        const Count EXISTING_C = container.count(existingKey);
 
-    // Testing `lower_bound`.
+        ASSERT(EXPECTED_C              == EXISTING_C);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    const Iterator EXISTING_LB = container.lower_bound(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        const Count NON_EXISTING_C = container.count(nonExistingKey);
+        ASSERT(0                       == NON_EXISTING_C);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERT(EXISTING_F              == EXISTING_LB);
-    ASSERT(expectedConversionCount == existingKey.conversionCount());
+    {
+        // Testing `lower_bound`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    const Iterator NON_EXISTING_LB = container.lower_bound(nonExistingKey);
+        const Iterator EXISTING_LB = container.lower_bound(existingKey);
 
-    ASSERT(container.begin()       == NON_EXISTING_LB);
-    ASSERT(expectedConversionCount == nonExistingKey.conversionCount());
+        ASSERT(existingKey.value() == *EXISTING_LB);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    // Testing `upper_bound`.
+        const Iterator NON_EXISTING_LB = container.lower_bound(nonExistingKey);
 
-    TransparentlyComparable upperBoundValue(initKeyValue + 1);
-    const Iterator          EXPECTED_UB = container.find(upperBoundValue);
-    const Iterator          EXISTING_UB = container.upper_bound(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        ASSERT(container.begin()       == NON_EXISTING_LB);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERT(EXPECTED_UB             == EXISTING_UB);
-    ASSERT(expectedConversionCount == existingKey.conversionCount());
+    {
+        // Testing `upper_bound`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    const Iterator NON_EXISTING_UB = container.upper_bound(nonExistingKey);
+        TransparentlyComparable upperBoundValue(initKeyValue + 1);
+        const Iterator          EXPECTED_UB = container.find(upperBoundValue);
+        const Iterator          EXISTING_UB = container.upper_bound(existingKey);
 
-    ASSERT(container.begin()       == NON_EXISTING_UB);
-    ASSERT(expectedConversionCount == nonExistingKey.conversionCount());
+        ASSERT(EXPECTED_UB             == EXISTING_UB);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    // Testing `equal_range`.
+        const Iterator NON_EXISTING_UB = container.upper_bound(nonExistingKey);
 
-    const bsl::pair<Iterator, Iterator> EXISTING_ER =
-                                            container.equal_range(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        ASSERT(container.begin()       == NON_EXISTING_UB);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERT(EXISTING_LB             == EXISTING_ER.first);
-    ASSERT(EXPECTED_UB             == EXISTING_ER.second);
-    ASSERT(expectedConversionCount == existingKey.conversionCount());
+    {
+        // Testing `equal_range`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
+
+        const bsl::pair<Iterator, Iterator> EXISTING_ER =
+                                                container.equal_range(existingKey);
+        ASSERT(EXISTING_ER.first != EXISTING_ER.second);
+        ASSERT(0 < static_cast<Count>(
+                        bsl::distance(EXISTING_ER.first, EXISTING_ER.second)));
+        for (Iterator it = EXISTING_ER.first; it != EXISTING_ER.second; ++it) {
+            ASSERT(existingKey.value() == *it);
+        }
 
-    const bsl::pair<Iterator, Iterator> NON_EXISTING_ER =
-                                         container.equal_range(nonExistingKey);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    ASSERT(NON_EXISTING_LB         == NON_EXISTING_ER.first);
-    ASSERT(NON_EXISTING_UB         == NON_EXISTING_ER.second);
-    ASSERT(expectedConversionCount == nonExistingKey.conversionCount());
+        const bsl::pair<Iterator, Iterator> NON_EXISTING_ER =
+                                             container.equal_range(nonExistingKey);
+
+        ASSERT(NON_EXISTING_ER.first == NON_EXISTING_ER.second);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
+    }
 }
 
                             // ========================
diff --git a/groups/bsl/bslstl/bslstl_unorderedmap_test.t.cpp b/groups/bsl/bslstl/bslstl_unorderedmap_test.t.cpp
index 83b9d588b4..2ee11f6776 100644
--- a/groups/bsl/bslstl/bslstl_unorderedmap_test.t.cpp
+++ b/groups/bsl/bslstl/bslstl_unorderedmap_test.t.cpp
@@ -1710,37 +1710,40 @@ void testTransparentComparator(t_CONTAINER& container,
        // Testing `bucket`.
         existingKey.resetConversionCount();
         nonExistingKey.resetConversionCount();
-        const Count bucketFound    = container.bucket(existingKey);
-        const Count bucketNotFound = container.bucket(nonExistingKey);
-
-        ASSERTV(expectedConversionCount,    existingKey.conversionCount(),
-                      expectedConversionCount ==    existingKey.conversionCount());
-        ASSERTV(expectedConversionCount, nonExistingKey.conversionCount(),
-                      expectedConversionCount == nonExistingKey.conversionCount());
 
-        // check that we found the right bucket
         bool                                  found_it;
         const typename t_CONTAINER::key_equal c_eq = container.key_eq();
 
+        const Count bucketFound    = container.bucket(existingKey);
+        // check that we found the right bucket
+
         found_it = false;
         for (LocalIterator it  = container.begin(bucketFound);
                            it != container.end(bucketFound);
                            ++it) {
-            if (c_eq(it->first, existingKey)) {
+            if (c_eq(it->first, existingKey.value())) {
                 found_it = true;
             }
         }
         ASSERT(found_it);
+        ASSERTV(expectedConversionCount,    existingKey.conversionCount(),
+                      expectedConversionCount ==    existingKey.conversionCount());
+
+        const Count bucketNotFound = container.bucket(nonExistingKey);
 
+        // check that we found the right bucket
         found_it = false;
         for (LocalIterator it  = container.begin(bucketNotFound);
                            it != container.end(bucketNotFound);
                            ++it) {
-            if (c_eq(it->first, nonExistingKey)) {
+            if (c_eq(it->first, nonExistingKey.value())) {
                 found_it = true;
             }
         }
         ASSERT(!found_it);
+        ASSERTV(expectedConversionCount, nonExistingKey.conversionCount(),
+                      expectedConversionCount == nonExistingKey.conversionCount());
+
     }
 }
 
diff --git a/groups/bsl/bslstl/bslstl_unorderedmultimap_test.t.cpp b/groups/bsl/bslstl/bslstl_unorderedmultimap_test.t.cpp
index 3334c791e7..4c8a21866a 100644
--- a/groups/bsl/bslstl/bslstl_unorderedmultimap_test.t.cpp
+++ b/groups/bsl/bslstl/bslstl_unorderedmultimap_test.t.cpp
@@ -1249,6 +1249,9 @@ void runErasure(
 
 class TransparentlyComparable {
     // DATA
+#if BSLS_COMPILERFEATURES_CPLUSPLUS < 201103L
+    mutable
+#endif
     int d_conversionCount;  // number of times `operator int` has been called
     int d_value;            // the value
 
@@ -1270,11 +1273,21 @@ class TransparentlyComparable {
 
     /// Return the current value of this object.
     operator int()
+#if BSLS_COMPILERFEATURES_CPLUSPLUS < 201103L
+    const
+#endif
     {
         ++d_conversionCount;
         return d_value;
     }
 
+    /// return a count of the number of times this object has been converted to
+    /// an int.
+    void resetConversionCount()
+    {
+        d_conversionCount = 0;
+    }
+
     // ACCESSORS
 
     /// Return the number of times `operator int` has been called.
@@ -1365,116 +1378,137 @@ void testTransparentComparator(Container& container,
     typedef typename Container::const_iterator       Iterator;
     typedef typename Container::size_type            Count;
 
-    int expectedConversionCount = 0;
+    const int expectedConversionCount = isTransparent ? 0 : 1;
 
     TransparentlyComparable existingKey(initKeyValue);
     TransparentlyComparable nonExistingKey(initKeyValue ? -initKeyValue
                                                         : -100);
 
-    ASSERT(existingKey.conversionCount() == expectedConversionCount);
+    {
+        // Testing `find`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    // Testing `find`.
+        const Iterator EXISTING_F = container.find(existingKey);
+        ASSERT(container.end()               != EXISTING_F);
+        ASSERT(existingKey.value()           == EXISTING_F->first);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    const Iterator EXISTING_F = container.find(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        const Iterator NON_EXISTING_F = container.find(nonExistingKey);
+        ASSERT(container.end()                  == NON_EXISTING_F);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERT(container.end()               != EXISTING_F);
-    ASSERT(existingKey.value()           == EXISTING_F->first);
-    ASSERT(existingKey.conversionCount() == expectedConversionCount);
-
-    const Iterator NON_EXISTING_F = container.find(nonExistingKey);
-    ASSERT(container.end()                  == NON_EXISTING_F);
-    ASSERT(nonExistingKey.conversionCount() == expectedConversionCount);
+    {
+        // Testing `contains`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    // Testing `contains`.
+        const bool EXISTING_CONTAINS = container.contains(existingKey);
+        ASSERT(true == EXISTING_CONTAINS);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    const bool EXISTING_CONTAINS = container.contains(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        const bool NON_EXISTING_CONTAINS = container.contains(nonExistingKey);
+        ASSERT(false == NON_EXISTING_CONTAINS);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERT(true == EXISTING_CONTAINS);
-    ASSERT(existingKey.conversionCount() == expectedConversionCount);
-
-    const bool NON_EXISTING_CONTAINS = container.contains(nonExistingKey);
-    ASSERT(false == NON_EXISTING_CONTAINS);
-    ASSERT(nonExistingKey.conversionCount() == expectedConversionCount);
+    {
+        // Testing `count`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    // Testing `count`.
+        const Count EXPECTED_C = initKeyValue ? initKeyValue : 1;
+        const Count EXISTING_C = container.count(existingKey);
 
-    const Count EXPECTED_C = initKeyValue ? initKeyValue : 1;
-    const Count EXISTING_C = container.count(existingKey);
+        ASSERT(EXPECTED_C              == EXISTING_C);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        const Count NON_EXISTING_C = container.count(nonExistingKey);
+        ASSERT(0                       == NON_EXISTING_C);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERT(EXPECTED_C              == EXISTING_C);
-    ASSERT(expectedConversionCount == existingKey.conversionCount());
-
-    const Count NON_EXISTING_C = container.count(nonExistingKey);
-    ASSERT(0                       == NON_EXISTING_C);
-    ASSERT(expectedConversionCount == nonExistingKey.conversionCount());
-
-    // Testing `equal_range`.
+    {
+        // Testing `equal_range`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    const bsl::pair<Iterator, Iterator> EXISTING_ER =
+        const Count EXPECTED_C = initKeyValue ? initKeyValue : 1;
+        const bsl::pair<Iterator, Iterator> EXISTING_ER =
                                             container.equal_range(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
-    }
+        ASSERT(EXPECTED_C == static_cast<Count>(
+                        bsl::distance(EXISTING_ER.first, EXISTING_ER.second)));
 
-    ASSERT(expectedConversionCount == existingKey.conversionCount());
-    ASSERT(EXPECTED_C ==
-     static_cast<Count>(bsl::distance(EXISTING_ER.first, EXISTING_ER.second)));
+        for (Iterator it = EXISTING_ER.first; it != EXISTING_ER.second; ++it) {
+            ASSERT(existingKey.value() == it->first);
+        }
 
-    for (Iterator it = EXISTING_ER.first; it != EXISTING_ER.second; ++it) {
-        ASSERT(existingKey.value() == it->first);
-    }
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    const bsl::pair<Iterator, Iterator> NON_EXISTING_ER =
+        const bsl::pair<Iterator, Iterator> NON_EXISTING_ER =
                                          container.equal_range(nonExistingKey);
-    ASSERT(NON_EXISTING_ER.first   == NON_EXISTING_ER.second);
-    ASSERT(expectedConversionCount == nonExistingKey.conversionCount());
-
-    // Testing `bucket`.
-    const Count bucketFound    = container.bucket(existingKey);
-    const Count bucketNotFound = container.bucket(nonExistingKey);
-
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        ASSERT(NON_EXISTING_ER.first   == NON_EXISTING_ER.second);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERTV(expectedConversionCount,    existingKey.conversionCount(),
-                  expectedConversionCount ==    existingKey.conversionCount());
-    ASSERTV(expectedConversionCount, nonExistingKey.conversionCount(),
-                  expectedConversionCount == nonExistingKey.conversionCount());
-
-    // check that we found the right bucket
-    bool                                found_it;
-    const typename Container::key_equal c_eq = container.key_eq();
-
-    found_it = false;
-    for (LocalIterator it  = container.begin(bucketFound);
-                       it != container.end(bucketFound);
-                       ++it) {
-        if (c_eq(it->first, existingKey)) {
-            found_it = true;
+    {
+    // Testing `bucket`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
+
+        bool                                found_it;
+        const typename Container::key_equal c_eq = container.key_eq();
+
+        const Count bucketFound = container.bucket(existingKey);
+        // check that we found the right bucket
+        found_it = false;
+        for (LocalIterator it  = container.begin(bucketFound);
+                           it != container.end(bucketFound);
+                           ++it) {
+            if (c_eq(it->first, existingKey.value())) {
+                found_it = true;
+            }
         }
-    }
-    ASSERT(found_it);
-
-    found_it = false;
-    for (LocalIterator it  = container.begin(bucketNotFound);
-                       it != container.end(bucketNotFound);
-                       ++it) {
-        if (c_eq(it->first, nonExistingKey)) {
-            found_it = true;
+        ASSERT(found_it);
+
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
+
+        const Count bucketNotFound = container.bucket(nonExistingKey);
+        // check that we found the right bucket
+        found_it = false;
+        for (LocalIterator it  = container.begin(bucketNotFound);
+                           it != container.end(bucketNotFound);
+                           ++it) {
+            if (c_eq(it->first, nonExistingKey.value())) {
+                found_it = true;
+            }
         }
+        ASSERT(!found_it);
+
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
+
     }
-    ASSERT(!found_it);
 }
 
 }  // close unnamed namespace
diff --git a/groups/bsl/bslstl/bslstl_unorderedmultiset_test.t.cpp b/groups/bsl/bslstl/bslstl_unorderedmultiset_test.t.cpp
index eb90cc437d..a427ef55f0 100644
--- a/groups/bsl/bslstl/bslstl_unorderedmultiset_test.t.cpp
+++ b/groups/bsl/bslstl/bslstl_unorderedmultiset_test.t.cpp
@@ -1458,6 +1458,9 @@ struct CompareProctor {
 
 class TransparentlyComparable {
     // DATA
+#if BSLS_COMPILERFEATURES_CPLUSPLUS < 201103L
+    mutable
+#endif
     int d_conversionCount;  // number of times `operator int` has been called
     int d_value;            // the value
 
@@ -1479,11 +1482,21 @@ class TransparentlyComparable {
 
     /// Return the current value of this object.
     operator int()
+#if BSLS_COMPILERFEATURES_CPLUSPLUS < 201103L
+    const
+#endif
     {
         ++d_conversionCount;
         return d_value;
     }
 
+    /// return a count of the number of times this object has been converted to
+    /// an int.
+    void resetConversionCount()
+    {
+        d_conversionCount = 0;
+    }
+
     // ACCESSORS
 
     /// Return the number of times `operator int` has been called.
@@ -1574,116 +1587,135 @@ void testTransparentComparator(Container& container,
     typedef typename Container::const_iterator       Iterator;
     typedef typename Container::size_type            Count;
 
-    int expectedConversionCount = 0;
+    const int expectedConversionCount = isTransparent ? 0 : 1;
 
     TransparentlyComparable existingKey(initKeyValue);
     TransparentlyComparable nonExistingKey(initKeyValue ? -initKeyValue
                                                         : -100);
 
-    ASSERT(existingKey.conversionCount() == expectedConversionCount);
+    {
+        // Testing `find`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    // Testing `find`.
+        const Iterator EXISTING_F = container.find(existingKey);
+        ASSERT(container.end()               != EXISTING_F);
+        ASSERT(existingKey.value()           == *EXISTING_F);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    const Iterator EXISTING_F = container.find(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        const Iterator NON_EXISTING_F = container.find(nonExistingKey);
+        ASSERT(container.end()                  == NON_EXISTING_F);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERT(container.end()               != EXISTING_F);
-    ASSERT(existingKey.value()           == *EXISTING_F);
-    ASSERT(existingKey.conversionCount() == expectedConversionCount);
-
-    const Iterator NON_EXISTING_F = container.find(nonExistingKey);
-    ASSERT(container.end()                  == NON_EXISTING_F);
-    ASSERT(nonExistingKey.conversionCount() == expectedConversionCount);
+    {
+        // Testing `contains`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    // Testing `contains`.
+        const bool EXISTING_CONTAINS = container.contains(existingKey);
+        ASSERT(true == EXISTING_CONTAINS);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    const bool EXISTING_CONTAINS = container.contains(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        const bool NON_EXISTING_CONTAINS = container.contains(nonExistingKey);
+        ASSERT(false == NON_EXISTING_CONTAINS);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERT(true == EXISTING_CONTAINS);
-    ASSERT(existingKey.conversionCount() == expectedConversionCount);
-
-    const bool NON_EXISTING_CONTAINS = container.contains(nonExistingKey);
-    ASSERT(false == NON_EXISTING_CONTAINS);
-    ASSERT(nonExistingKey.conversionCount() == expectedConversionCount);
-
-    // Testing `count`.
+    {
+        // Testing `count`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    const Count EXPECTED_C = initKeyValue ? initKeyValue : 1;
-    const Count EXISTING_C = container.count(existingKey);
+        const Count EXPECTED_C = initKeyValue ? initKeyValue : 1;
+        const Count EXISTING_C = container.count(existingKey);
+        ASSERT(EXPECTED_C              == EXISTING_C);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
 
-    if (!isTransparent) {
-        ++expectedConversionCount;
+        const Count NON_EXISTING_C = container.count(nonExistingKey);
+        ASSERT(0                       == NON_EXISTING_C);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    ASSERT(EXPECTED_C              == EXISTING_C);
-    ASSERT(expectedConversionCount == existingKey.conversionCount());
-
-    const Count NON_EXISTING_C = container.count(nonExistingKey);
-    ASSERT(0                       == NON_EXISTING_C);
-    ASSERT(expectedConversionCount == nonExistingKey.conversionCount());
-
-    // Testing `equal_range`.
+    {
+        // Testing `equal_range`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
+        const Count EXPECTED_C = initKeyValue ? initKeyValue : 1;
 
-    const bsl::pair<Iterator, Iterator> EXISTING_ER =
-                                            container.equal_range(existingKey);
-    if (!isTransparent) {
-        ++expectedConversionCount;
-    }
+        const bsl::pair<Iterator, Iterator> EXISTING_ER =
+                                                container.equal_range(existingKey);
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
+        ASSERT(EXPECTED_C ==
+         static_cast<Count>(bsl::distance(EXISTING_ER.first, EXISTING_ER.second)));
 
-    ASSERT(expectedConversionCount == existingKey.conversionCount());
-    ASSERT(EXPECTED_C ==
-     static_cast<Count>(bsl::distance(EXISTING_ER.first, EXISTING_ER.second)));
+        for (Iterator it = EXISTING_ER.first; it != EXISTING_ER.second; ++it) {
+            ASSERT(existingKey.value() == *it);
+        }
 
-    for (Iterator it = EXISTING_ER.first; it != EXISTING_ER.second; ++it) {
-        ASSERT(existingKey.value() == *it);
+        const bsl::pair<Iterator, Iterator> NON_EXISTING_ER =
+                                             container.equal_range(nonExistingKey);
+        ASSERT(NON_EXISTING_ER.first   == NON_EXISTING_ER.second);
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
 
-    const bsl::pair<Iterator, Iterator> NON_EXISTING_ER =
-                                         container.equal_range(nonExistingKey);
-    ASSERT(NON_EXISTING_ER.first   == NON_EXISTING_ER.second);
-    ASSERT(expectedConversionCount == nonExistingKey.conversionCount());
-
-    // Testing `bucket`.
-    const Count bucketFound    = container.bucket(existingKey);
-    const Count bucketNotFound = container.bucket(nonExistingKey);
-
-    if (!isTransparent) {
-        ++expectedConversionCount;
-    }
+    {
+        // Testing `bucket`.
+        existingKey.resetConversionCount();
+        nonExistingKey.resetConversionCount();
 
-    ASSERTV(expectedConversionCount,    existingKey.conversionCount(),
-                  expectedConversionCount ==    existingKey.conversionCount());
-    ASSERTV(expectedConversionCount, nonExistingKey.conversionCount(),
-                  expectedConversionCount == nonExistingKey.conversionCount());
+        bool                                found_it;
+        const typename Container::key_equal c_eq = container.key_eq();
 
-    // check that we found the right bucket
-    bool                                found_it;
-    const typename Container::key_equal c_eq = container.key_eq();
+        const Count bucketFound = container.bucket(existingKey);
 
-    found_it = false;
-    for (LocalIterator it  = container.begin(bucketFound);
-                       it != container.end(bucketFound);
-                       ++it) {
-        if (c_eq(*it, existingKey)) {
-            found_it = true;
+        // check that we found the right bucket
+        found_it = false;
+        for (LocalIterator it  = container.begin(bucketFound);
+                           it != container.end(bucketFound);
+                           ++it) {
+            if (c_eq(*it, existingKey.value())) {
+                found_it = true;
+            }
         }
-    }
-    ASSERT(found_it);
-
-    found_it = false;
-    for (LocalIterator it  = container.begin(bucketNotFound);
-                       it != container.end(bucketNotFound);
-                       ++it) {
-        if (c_eq(*it, nonExistingKey)) {
-            found_it = true;
+        ASSERT(found_it);
+
+        ASSERTV(isTransparent,
+                  expectedConversionCount,   existingKey.conversionCount(),
+                  expectedConversionCount == existingKey.conversionCount());
+
+        const Count bucketNotFound = container.bucket(nonExistingKey);
+        // check that we found the right bucket
+        found_it = false;
+        for (LocalIterator it  = container.begin(bucketNotFound);
+                           it != container.end(bucketNotFound);
+                           ++it) {
+            if (c_eq(*it, nonExistingKey.value())) {
+                found_it = true;
+            }
         }
+        ASSERT(!found_it);
+
+        ASSERTV(isTransparent,
+                expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
     }
-    ASSERT(!found_it);
 }
 
 }  // close unnamed namespace
diff --git a/groups/bsl/bslstl/bslstl_unorderedset_test.t.cpp b/groups/bsl/bslstl/bslstl_unorderedset_test.t.cpp
index d98fb7c5b4..3d1ca49c12 100644
--- a/groups/bsl/bslstl/bslstl_unorderedset_test.t.cpp
+++ b/groups/bsl/bslstl/bslstl_unorderedset_test.t.cpp
@@ -1673,38 +1673,37 @@ void testTransparentComparator(t_CONTAINER& container,
         existingKey.resetConversionCount();
         nonExistingKey.resetConversionCount();
 
-        const Count bucketFound    = container.bucket(existingKey);
-
-        ASSERTV(expectedConversionCount,      existingKey.conversionCount(),
-                expectedConversionCount ==    existingKey.conversionCount());
-
-        // check that we found the right bucket
         bool                                  found_it;
         const typename t_CONTAINER::key_equal c_eq = container.key_eq();
 
+        const Count bucketFound    = container.bucket(existingKey);
+        // check that we found the right bucket
         found_it = false;
         for (LocalIterator it  = container.begin(bucketFound);
                            it != container.end(bucketFound);
                            ++it) {
-            if (c_eq(*it, existingKey)) {
+            if (c_eq(*it, existingKey.value())) {
                 found_it = true;
             }
         }
         ASSERT(found_it);
+        ASSERTV(expectedConversionCount,      existingKey.conversionCount(),
+                expectedConversionCount ==    existingKey.conversionCount());
 
         const Count bucketNotFound = container.bucket(nonExistingKey);
-        ASSERTV(expectedConversionCount,   nonExistingKey.conversionCount(),
-                expectedConversionCount == nonExistingKey.conversionCount());
-
+        // check that we found the right bucket
         found_it = false;
         for (LocalIterator it  = container.begin(bucketNotFound);
                            it != container.end(bucketNotFound);
                            ++it) {
-            if (c_eq(*it, nonExistingKey)) {
+            if (c_eq(*it, nonExistingKey.value())) {
                 found_it = true;
             }
         }
         ASSERT(!found_it);
+        ASSERTV(expectedConversionCount,   nonExistingKey.conversionCount(),
+                expectedConversionCount == nonExistingKey.conversionCount());
+
 
     }
 }