attempting to fix the gtest print issues in vs17

1 files changed, 393 insertions, 364 deletions

diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
index 2f39d2b..cb21e5c 100644
--- a/tests/span_tests.cpp
+++ b/tests/span_tests.cpp
@@ -77,55 +77,55 @@ struct AddressOverloaded
 TEST(span_test, constructors)
 {
     span<int> s;
-    EXPECT_EQ(s.size(), 0);
-    EXPECT_EQ(s.data(), nullptr);
+    EXPECT_TRUE(s.size() == 0);
+    EXPECT_TRUE(s.data() == nullptr);
 
     span<const int> cs;
-    EXPECT_EQ(cs.size(), 0);
-    EXPECT_EQ(cs.data(), nullptr);
+    EXPECT_TRUE(cs.size() == 0);
+    EXPECT_TRUE(cs.data() == nullptr);
 }
 
 TEST(span_test, constructors_with_extent)
 {
     span<int, 0> s;
-    EXPECT_EQ(s.size(), 0);
-    EXPECT_EQ(s.data(), nullptr);
+    EXPECT_TRUE(s.size() == 0);
+    EXPECT_TRUE(s.data() == nullptr);
 
     span<const int, 0> cs;
-    EXPECT_EQ(cs.size(), 0);
-    EXPECT_EQ(cs.data(), nullptr);
+    EXPECT_TRUE(cs.size() == 0);
+    EXPECT_TRUE(cs.data() == nullptr);
 }
 
 TEST(span_test, constructors_with_bracket_init)
 {
     span<int> s{};
-    EXPECT_EQ(s.size(), 0);
-    EXPECT_EQ(s.data(), nullptr);
+    EXPECT_TRUE(s.size() == 0);
+    EXPECT_TRUE(s.data() == nullptr);
 
     span<const int> cs{};
-    EXPECT_EQ(cs.size(), 0);
-    EXPECT_EQ(cs.data(), nullptr);
+    EXPECT_TRUE(cs.size() == 0);
+    EXPECT_TRUE(cs.data() == nullptr);
 }
 
 TEST(span_test, size_optimization)
 {
     span<int> s;
-    EXPECT_EQ(sizeof(s), sizeof(int*) + sizeof(ptrdiff_t));
+    EXPECT_TRUE(sizeof(s) == sizeof(int*) + sizeof(ptrdiff_t));
 
     span<int, 0> se;
-    EXPECT_EQ(sizeof(se), sizeof(int*));
+    EXPECT_TRUE(sizeof(se) == sizeof(int*));
 }
 
 TEST(span_test, from_nullptr_size_constructor)
 {
     {
         span<int> s{nullptr, narrow_cast<span<int>::index_type>(0)};
-        EXPECT_EQ(s.size(), 0);
-        EXPECT_EQ(s.data(), nullptr);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == nullptr);
 
         span<int> cs{nullptr, narrow_cast<span<int>::index_type>(0)};
-        EXPECT_EQ(cs.size(), 0);
-        EXPECT_EQ(cs.data(), nullptr);
+        EXPECT_TRUE(cs.size() == 0);
+        EXPECT_TRUE(cs.data() == nullptr);
     }
     {
         auto workaround_macro = []() {
@@ -149,12 +149,12 @@ TEST(span_test, from_nullptr_size_constructor)
     }
     {
         span<int*> s{nullptr, narrow_cast<span<int>::index_type>(0)};
-        EXPECT_EQ(s.size(), 0);
-        EXPECT_EQ(s.data(), nullptr);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == nullptr);
 
         span<const int*> cs{nullptr, narrow_cast<span<int>::index_type>(0)};
-        EXPECT_EQ(cs.size(), 0);
-        EXPECT_EQ(cs.data(), nullptr);
+        EXPECT_TRUE(cs.size() == 0);
+        EXPECT_TRUE(cs.data() == nullptr);
     }
 }
 
@@ -167,27 +167,27 @@ TEST(span_test, from_pointer_length_constructor)
         {
             {
                 span<int> s = {&arr[0], i};
-                EXPECT_EQ(s.size(), i);
-                EXPECT_EQ(s.data(), &arr[0]);
-                EXPECT_EQ(s.empty(), i == 0);
+                EXPECT_TRUE(s.size() == i);
+                EXPECT_TRUE(s.data() == &arr[0]);
+                EXPECT_TRUE(s.empty() == (i == 0));
                 for (int j = 0; j < i; ++j)
                 {
-                    EXPECT_EQ(arr[j], s[j]);
-                    EXPECT_EQ(arr[j], s.at(j));
-                    EXPECT_EQ(arr[j], s(j));
+                    EXPECT_TRUE(arr[j] == s[j]);
+                    EXPECT_TRUE(arr[j] == s.at(j));
+                    EXPECT_TRUE(arr[j] == s(j));
                 }
             }
             {
                 span<int> s = {&arr[i], 4 - narrow_cast<ptrdiff_t>(i)};
-                EXPECT_EQ(s.size(), 4 - i);
-                EXPECT_EQ(s.data(), &arr[i]);
-                EXPECT_EQ(s.empty(), (4 - i) == 0);
+                EXPECT_TRUE(s.size() == 4 - i);
+                EXPECT_TRUE(s.data() == &arr[i]);
+                EXPECT_TRUE(s.empty() == ((4 - i) == 0));
 
                 for (int j = 0; j < 4 - i; ++j)
                 {
-                    EXPECT_EQ(arr[j + i], s[j]);
-                    EXPECT_EQ(arr[j + i], s.at(j));
-                    EXPECT_EQ(arr[j + i], s(j));
+                    EXPECT_TRUE(arr[j + i] == s[j]);
+                    EXPECT_TRUE(arr[j + i] == s.at(j));
+                    EXPECT_TRUE(arr[j + i] == s(j));
                 }
             }
         }
@@ -195,17 +195,17 @@ TEST(span_test, from_pointer_length_constructor)
 
     {
         span<int, 2> s{&arr[0], 2};
-        EXPECT_EQ(s.size(), 2);
-        EXPECT_EQ(s.data(), &arr[0]);
-        EXPECT_EQ(s[0], 1);
-        EXPECT_EQ(s[1], 2);
+        EXPECT_TRUE(s.size() == 2);
+        EXPECT_TRUE(s.data() == &arr[0]);
+        EXPECT_TRUE(s[0] == 1);
+        EXPECT_TRUE(s[1] == 2);
     }
 
     {
         int* p = nullptr;
         span<int> s{p, narrow_cast<span<int>::index_type>(0)};
-        EXPECT_EQ(s.size(), 0);
-        EXPECT_EQ(s.data(), nullptr);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == nullptr);
     }
 
     {
@@ -216,17 +216,17 @@ TEST(span_test, from_pointer_length_constructor)
 
     {
         auto s = make_span(&arr[0], 2);
-        EXPECT_EQ(s.size(), 2);
-        EXPECT_EQ(s.data(), &arr[0]);
-        EXPECT_EQ(s[0], 1);
-        EXPECT_EQ(s[1], 2);
+        EXPECT_TRUE(s.size() == 2);
+        EXPECT_TRUE(s.data() == &arr[0]);
+        EXPECT_TRUE(s[0] == 1);
+        EXPECT_TRUE(s[1] == 2);
     }
 
     {
         int* p = nullptr;
         auto s = make_span(p, narrow_cast<span<int>::index_type>(0));
-        EXPECT_EQ(s.size(), 0);
-        EXPECT_EQ(s.data(), nullptr);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == nullptr);
     }
 
     {
@@ -242,29 +242,29 @@ TEST(span_test, from_pointer_pointer_construction)
 
     {
         span<int> s{&arr[0], &arr[2]};
-        EXPECT_EQ(s.size(), 2);
-        EXPECT_EQ(s.data(), &arr[0]);
-        EXPECT_EQ(s[0], 1);
-        EXPECT_EQ(s[1], 2);
+        EXPECT_TRUE(s.size() == 2);
+        EXPECT_TRUE(s.data() == &arr[0]);
+        EXPECT_TRUE(s[0] == 1);
+        EXPECT_TRUE(s[1] == 2);
     }
     {
         span<int, 2> s{&arr[0], &arr[2]};
-        EXPECT_EQ(s.size(), 2);
-        EXPECT_EQ(s.data(), &arr[0]);
-        EXPECT_EQ(s[0], 1);
-        EXPECT_EQ(s[1], 2);
+        EXPECT_TRUE(s.size() == 2);
+        EXPECT_TRUE(s.data() == &arr[0]);
+        EXPECT_TRUE(s[0] == 1);
+        EXPECT_TRUE(s[1] == 2);
     }
 
     {
         span<int> s{&arr[0], &arr[0]};
-        EXPECT_EQ(s.size(), 0);
-        EXPECT_EQ(s.data(), &arr[0]);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == &arr[0]);
     }
 
     {
         span<int, 0> s{&arr[0], &arr[0]};
-        EXPECT_EQ(s.size(), 0);
-        EXPECT_EQ(s.data(), &arr[0]);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == &arr[0]);
     }
 
     // this will fail the std::distance() precondition, which asserts on MSVC debug builds
@@ -283,15 +283,15 @@ TEST(span_test, from_pointer_pointer_construction)
     {
         int* p = nullptr;
         span<int> s{p, p};
-        EXPECT_EQ(s.size(), 0);
-        EXPECT_EQ(s.data(), nullptr);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == nullptr);
     }
 
     {
         int* p = nullptr;
         span<int, 0> s{p, p};
-        EXPECT_EQ(s.size(), 0);
-        EXPECT_EQ(s.data(), nullptr);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == nullptr);
     }
 
     // this will fail the std::distance() precondition, which asserts on MSVC debug builds
@@ -303,23 +303,23 @@ TEST(span_test, from_pointer_pointer_construction)
 
     {
         auto s = make_span(&arr[0], &arr[2]);
-        EXPECT_EQ(s.size(), 2);
-        EXPECT_EQ(s.data(), &arr[0]);
-        EXPECT_EQ(s[0], 1);
-        EXPECT_EQ(s[1], 2);
+        EXPECT_TRUE(s.size() == 2);
+        EXPECT_TRUE(s.data() == &arr[0]);
+        EXPECT_TRUE(s[0] == 1);
+        EXPECT_TRUE(s[1] == 2);
     }
 
     {
         auto s = make_span(&arr[0], &arr[0]);
-        EXPECT_EQ(s.size(), 0);
-        EXPECT_EQ(s.data(), &arr[0]);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == &arr[0]);
     }
 
     {
         int* p = nullptr;
         auto s = make_span(p, p);
-        EXPECT_EQ(s.size(), 0);
-        EXPECT_EQ(s.data(), nullptr);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == nullptr);
     }
 }
 
@@ -329,14 +329,14 @@ TEST(span_test, from_array_constructor)
 
      {
          const span<int> s{arr};
-         EXPECT_EQ(s.size(), 5);
-         EXPECT_EQ(s.data(), &arr[0]);
+         EXPECT_TRUE(s.size() == 5);
+         EXPECT_TRUE(s.data() == &arr[0]);
      }
 
      {
          const span<int, 5> s{arr};
-         EXPECT_EQ(s.size(), 5);
-         EXPECT_EQ(s.data(), &arr[0]);
+         EXPECT_TRUE(s.size() == 5);
+         EXPECT_TRUE(s.data() == &arr[0]);
      }
 
      int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
@@ -348,22 +348,22 @@ TEST(span_test, from_array_constructor)
 
      {
          span<int, 0> s{arr};
-         EXPECT_EQ(s.size(), 0);
-         EXPECT_EQ(s.data(), &arr[0]);
+         EXPECT_TRUE(s.size() == 0);
+         EXPECT_TRUE(s.data() == &arr[0]);
      }
 
      {
          span<int> s{arr2d};
-         EXPECT_EQ(s.size(), 6);
-         EXPECT_EQ(s.data(), &arr2d[0][0]);
-         EXPECT_EQ(s[0], 1);
-         EXPECT_EQ(s[5], 6);
+         EXPECT_TRUE(s.size() == 6);
+         EXPECT_TRUE(s.data() == &arr2d[0][0]);
+         EXPECT_TRUE(s[0] == 1);
+         EXPECT_TRUE(s[5] == 6);
      }
 
      {
          span<int, 0> s{arr2d};
-         EXPECT_EQ(s.size(), 0);
-         EXPECT_EQ(s.data(), &arr2d[0][0]);
+         EXPECT_TRUE(s.size() == 0);
+         EXPECT_TRUE(s.data() == &arr2d[0][0]);
      }
 
      {
@@ -372,8 +372,8 @@ TEST(span_test, from_array_constructor)
  #endif
      {
          const span<int[3]> s{std::addressof(arr2d[0]), 1};
-         EXPECT_EQ(s.size(), 1);
-         EXPECT_EQ(s.data(), std::addressof(arr2d[0]));
+         EXPECT_TRUE(s.size() == 1);
+         EXPECT_TRUE(s.data() == std::addressof(arr2d[0]));
      }
 
      int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
@@ -381,16 +381,16 @@ TEST(span_test, from_array_constructor)
  #ifdef CONFIRM_COMPILATION_ERRORS
      {
          span<int> s{arr3d};
-         EXPECT_EQ(s.size(), 12);
-         EXPECT_EQ(s.data(), &arr3d[0][0][0]);
-         EXPECT_EQ(s[0], 1);
-         EXPECT_EQ(s[11], 12);
+         EXPECT_TRUE(s.size() == 12);
+         EXPECT_TRUE(s.data() == &arr3d[0][0][0]);
+         EXPECT_TRUE(s[0] == 1);
+         EXPECT_TRUE(s[11] == 12);
      }
 
      {
          span<int, 0> s{arr3d};
-         EXPECT_EQ(s.size(), 0);
-         EXPECT_EQ(s.data(), &arr3d[0][0][0]);
+         EXPECT_TRUE(s.size() == 0);
+         EXPECT_TRUE(s.data() == &arr3d[0][0][0]);
      }
 
      {
@@ -399,41 +399,41 @@ TEST(span_test, from_array_constructor)
 
      {
          span<int, 12> s{arr3d};
-         EXPECT_EQ(s.size(), 12);
-         EXPECT_EQ(s.data(), &arr3d[0][0][0]);
-         EXPECT_EQ(s[0], 1);
-         EXPECT_EQ(s[5], 6);
+         EXPECT_TRUE(s.size() == 12);
+         EXPECT_TRUE(s.data() == &arr3d[0][0][0]);
+         EXPECT_TRUE(s[0] == 1);
+         EXPECT_TRUE(s[5] == 6);
      }
  #endif
      {
          const span<int[3][2]> s{std::addressof(arr3d[0]), 1};
-         EXPECT_EQ(s.size(),  1);
+         EXPECT_TRUE(s.size() ==  1);
      }
 
      {
          const auto s = make_span(arr);
-         EXPECT_EQ(s.size(),  5);
-         EXPECT_EQ(s.data(),std::addressof(arr[0]));
+         EXPECT_TRUE(s.size() == 5);
+         EXPECT_TRUE(s.data() == std::addressof(arr[0]));
      }
 
      {
          const auto s = make_span(std::addressof(arr2d[0]), 1);
-         EXPECT_EQ(s.size(),  1);
-         EXPECT_EQ(s.data(), std::addressof(arr2d[0]));
+         EXPECT_TRUE(s.size() == 1);
+         EXPECT_TRUE(s.data() == std::addressof(arr2d[0]));
      }
 
      {
          const auto s = make_span(std::addressof(arr3d[0]), 1);
-         EXPECT_EQ(s.size(),  1);
-         EXPECT_EQ(s.data(), std::addressof(arr3d[0]));
+         EXPECT_TRUE(s.size() == 1);
+         EXPECT_TRUE(s.data() == std::addressof(arr3d[0]));
      }
 
      AddressOverloaded ao_arr[5] = {};
 
      {
          const span<AddressOverloaded, 5> s{ao_arr};
-         EXPECT_EQ(s.size(),  5);
-         EXPECT_EQ(s.data(), std::addressof(ao_arr[0]));
+         EXPECT_TRUE(s.size() == 5);
+         EXPECT_TRUE(s.data() == std::addressof(ao_arr[0]));
      }
  }
 
@@ -443,12 +443,14 @@ TEST(span_test, from_array_constructor)
 
      {
          span<double> s(&arr[0][0][0], 10);
-         EXPECT_EQ(s.size(),  10); EXPECT_EQ(s.data(), &arr[0][0][0]);
+         EXPECT_TRUE(s.size() == 10);
+         EXPECT_TRUE(s.data() == &arr[0][0][0]);
      }
 
      {
          auto s = make_span(&arr[0][0][0], 10);
-         EXPECT_EQ(s.size(),  10); EXPECT_EQ(s.data(), &arr[0][0][0]);
+         EXPECT_TRUE(s.size() == 10);
+         EXPECT_TRUE(s.data() == &arr[0][0][0]);
      }
 
      delete[] arr;
@@ -460,24 +462,28 @@ TEST(span_test, from_array_constructor)
 
      {
          span<int> s{arr};
-         EXPECT_EQ(s.size(),  narrow_cast<ptrdiff_t>(arr.size())); EXPECT_EQ(s.data(), arr.data());
+         EXPECT_TRUE(s.size() == narrow_cast<ptrdiff_t>(arr.size()));
+         EXPECT_TRUE(s.data() == arr.data());
 
          span<const int> cs{arr};
-         EXPECT_EQ(cs.size(),  narrow_cast<ptrdiff_t>(arr.size())); EXPECT_EQ(cs.data(), arr.data());
+         EXPECT_TRUE(cs.size() == narrow_cast<ptrdiff_t>(arr.size()));
+         EXPECT_TRUE(cs.data() == arr.data());
      }
 
      {
          span<int, 4> s{arr};
-         EXPECT_EQ(s.size(),  narrow_cast<ptrdiff_t>(arr.size())); EXPECT_EQ(s.data(), arr.data());
+         EXPECT_TRUE(s.size() == narrow_cast<ptrdiff_t>(arr.size()));
+         EXPECT_TRUE(s.data() == arr.data());
 
          span<const int, 4> cs{arr};
-         EXPECT_EQ(cs.size(),  narrow_cast<ptrdiff_t>(arr.size())); EXPECT_EQ(cs.data(), arr.data());
+         EXPECT_TRUE(cs.size() == narrow_cast<ptrdiff_t>(arr.size()));
+         EXPECT_TRUE(cs.data() == arr.data());
      }
 
      {
          std::array<int, 0> empty_arr{};
          span<int> s{empty_arr};
-         EXPECT_EQ(s.size(), 0);
+         EXPECT_TRUE(s.size() == 0);
          EXPECT_TRUE(s.empty());
      }
 
@@ -485,25 +491,29 @@ TEST(span_test, from_array_constructor)
 
      {
          span<AddressOverloaded, 4> fs{ao_arr};
-         EXPECT_EQ(fs.size(), narrow_cast<ptrdiff_t>(ao_arr.size()));
-         EXPECT_EQ(ao_arr.data(), fs.data());
+         EXPECT_TRUE(fs.size() == narrow_cast<ptrdiff_t>(ao_arr.size()));
+         EXPECT_TRUE(ao_arr.data() == fs.data());
      }
 
  #ifdef CONFIRM_COMPILATION_ERRORS
      {
          span<int, 2> s{arr};
-         EXPECT_EQ(s.size(),  2); EXPECT_EQ(s.data(), arr.data());
+         EXPECT_TRUE(s.size() == 2);
+         EXPECT_TRUE(s.data() == arr.data());
 
          span<const int, 2> cs{arr};
-         EXPECT_EQ(cs.size(),  2); EXPECT_EQ(cs.data(), arr.data());
+         EXPECT_TRUE(cs.size() == 2);
+         EXPECT_TRUE(cs.data() == arr.data());
      }
 
      {
          span<int, 0> s{arr};
-         EXPECT_EQ(s.size(),  0); EXPECT_EQ(s.data(), arr.data());
+         EXPECT_TRUE(s.size() == 0);
+         EXPECT_TRUE(s.data() == arr.data());
 
          span<const int, 0> cs{arr};
-         EXPECT_EQ(cs.size(),  0); EXPECT_EQ(cs.data(), arr.data());
+         EXPECT_TRUE(cs.size() == 0);
+         EXPECT_TRUE(cs.data() == arr.data());
      }
 
      {
@@ -527,7 +537,8 @@ TEST(span_test, from_array_constructor)
 
      {
          auto s = make_span(arr);
-         EXPECT_EQ(s.size(),  narrow_cast<ptrdiff_t>(arr.size())); EXPECT_EQ(s.data(), arr.data());
+         EXPECT_TRUE(s.size() == narrow_cast<ptrdiff_t>(arr.size()));
+         EXPECT_TRUE(s.data() == arr.data());
      }
 
      // This test checks for the bug found in gcc 6.1, 6.2, 6.3, 6.4, 6.5 7.1, 7.2, 7.3 - issue #590
@@ -541,10 +552,10 @@ TEST(span_test, from_array_constructor)
      __GNUC_PATCHLEVEL__ == 0 && defined(__OPTIMIZE__)
          // Known to be broken in gcc 6.4 and 6.5 with optimizations
          // Issue in gcc: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83116
-         EXPECT_EQ(s1.size(), 4);
-         EXPECT_EQ(s2.size(), 0);
+         EXPECT_TRUE(s1.size() == 4);
+         EXPECT_TRUE(s2.size() == 0);
  #else
-         EXPECT_EQ(s1.size(), s2.size());
+         EXPECT_TRUE(s1.size() == s2.size());
  #endif
      }
  }
@@ -555,31 +566,35 @@ TEST(span_test, from_array_constructor)
 
      {
          span<const int> s{arr};
-         EXPECT_EQ(s.size(),  narrow_cast<ptrdiff_t>(arr.size())); EXPECT_EQ(s.data(), arr.data());
+         EXPECT_TRUE(s.size() == narrow_cast<ptrdiff_t>(arr.size()));
+         EXPECT_TRUE(s.data() == arr.data());
      }
 
      {
          span<const int, 4> s{arr};
-         EXPECT_EQ(s.size(),  narrow_cast<ptrdiff_t>(arr.size())); EXPECT_EQ(s.data(), arr.data());
+         EXPECT_TRUE(s.size() == narrow_cast<ptrdiff_t>(arr.size()));
+         EXPECT_TRUE(s.data() == arr.data());
      }
 
      const std::array<AddressOverloaded, 4> ao_arr{};
 
      {
          span<const AddressOverloaded, 4> s{ao_arr};
-         EXPECT_EQ(s.size(), narrow_cast<ptrdiff_t>(ao_arr.size()));
-         EXPECT_EQ(s.data(), ao_arr.data());
+         EXPECT_TRUE(s.size() == narrow_cast<ptrdiff_t>(ao_arr.size()));
+         EXPECT_TRUE(s.data() == ao_arr.data());
      }
 
  #ifdef CONFIRM_COMPILATION_ERRORS
      {
          span<const int, 2> s{arr};
-         EXPECT_EQ(s.size(),  2); EXPECT_EQ(s.data(), arr.data());
+         EXPECT_TRUE(s.size() == 2);
+         EXPECT_TRUE(s.data() == arr.data());
      }
 
      {
          span<const int, 0> s{arr};
-         EXPECT_EQ(s.size(),  0); EXPECT_EQ(s.data(), arr.data());
+         EXPECT_TRUE(s.size() == 0);
+         EXPECT_TRUE(s.data() == arr.data());
      }
 
      {
@@ -596,7 +611,8 @@ TEST(span_test, from_array_constructor)
 
      {
          auto s = make_span(arr);
-         EXPECT_EQ(s.size(),  narrow_cast<ptrdiff_t>(arr.size())); EXPECT_EQ(s.data(), arr.data());
+         EXPECT_TRUE(s.size() == narrow_cast<ptrdiff_t>(arr.size()));
+         EXPECT_TRUE(s.data() == arr.data());
      }
  }
 
@@ -606,23 +622,27 @@ TEST(span_test, from_array_constructor)
 
      {
          span<const int> s{arr};
-         EXPECT_EQ(s.size(),  narrow_cast<ptrdiff_t>(arr.size())); EXPECT_EQ(s.data(), arr.data());
+         EXPECT_TRUE(s.size() == narrow_cast<ptrdiff_t>(arr.size()));
+         EXPECT_TRUE(s.data() == arr.data());
      }
 
      {
          span<const int, 4> s{arr};
-         EXPECT_EQ(s.size(),  narrow_cast<ptrdiff_t>(arr.size())); EXPECT_EQ(s.data(), arr.data());
+         EXPECT_TRUE(s.size() ==  narrow_cast<ptrdiff_t>(arr.size()));
+         EXPECT_TRUE(s.data() == arr.data());
      }
 
  #ifdef CONFIRM_COMPILATION_ERRORS
      {
          span<const int, 2> s{arr};
-         EXPECT_EQ(s.size(),  2); EXPECT_EQ(s.data(), arr.data());
+         EXPECT_TRUE(s.size() == 2);
+         EXPECT_TRUE(s.data() == arr.data());
      }
 
      {
          span<const int, 0> s{arr};
-         EXPECT_EQ(s.size(),  0); EXPECT_EQ(s.data(), arr.data());
+         EXPECT_TRUE(s.size() == 0);
+         EXPECT_TRUE(s.data() == arr.data());
      }
 
      {
@@ -636,7 +656,8 @@ TEST(span_test, from_array_constructor)
 
      {
          auto s = make_span(arr);
-         EXPECT_EQ(s.size(),  narrow_cast<ptrdiff_t>(arr.size())); EXPECT_EQ(s.data(), arr.data());
+         EXPECT_TRUE(s.size() == narrow_cast<ptrdiff_t>(arr.size()));
+         EXPECT_TRUE(s.data() == arr.data());
      }
  }
 
@@ -647,10 +668,12 @@ TEST(span_test, from_array_constructor)
 
      {
          span<int> s{v};
-         EXPECT_EQ(s.size(),  narrow_cast<std::ptrdiff_t>(v.size())); EXPECT_EQ(s.data(), v.data());
+         EXPECT_TRUE(s.size() == narrow_cast<std::ptrdiff_t>(v.size()));
+         EXPECT_TRUE(s.data() == v.data());
 
          span<const int> cs{v};
-         EXPECT_EQ(cs.size(),  narrow_cast<std::ptrdiff_t>(v.size())); EXPECT_EQ(cs.data(), v.data());
+         EXPECT_TRUE(cs.size() == narrow_cast<std::ptrdiff_t>(v.size()));
+         EXPECT_TRUE(cs.data() == v.data());
      }
 
      std::string str = "hello";
@@ -659,12 +682,12 @@ TEST(span_test, from_array_constructor)
      {
  #ifdef CONFIRM_COMPILATION_ERRORS
          span<char> s{str};
-         EXPECT_EQ(s.size(), narrow_cast<std::ptrdiff_t>(str.size()));
-         EXPECT_EQ(s.data(), str.data()));
+         EXPECT_TRUE(s.size() == narrow_cast<std::ptrdiff_t>(str.size()));
+         EXPECT_TRUE(s.data() == str.data()));
  #endif
          span<const char> cs{str};
-         EXPECT_EQ(cs.size(), narrow_cast<std::ptrdiff_t>(str.size()));
-         EXPECT_EQ(cs.data(), str.data());
+         EXPECT_TRUE(cs.size() == narrow_cast<std::ptrdiff_t>(str.size()));
+         EXPECT_TRUE(cs.data() == str.data());
      }
 
      {
@@ -672,8 +695,8 @@ TEST(span_test, from_array_constructor)
          span<char> s{cstr};
  #endif
          span<const char> cs{cstr};
-         EXPECT_EQ(cs.size(), narrow_cast<std::ptrdiff_t>(cstr.size()));
-         EXPECT_EQ(cs.data(), cstr.data());
+         EXPECT_TRUE(cs.size() == narrow_cast<std::ptrdiff_t>(cstr.size()));
+         EXPECT_TRUE(cs.data() == cstr.data());
      }
 
      {
@@ -727,11 +750,12 @@ TEST(span_test, from_array_constructor)
 
      {
          auto s = make_span(v);
-         EXPECT_EQ(s.size(),  narrow_cast<std::ptrdiff_t>(v.size())); EXPECT_EQ(s.data(), v.data());
+         EXPECT_TRUE(s.size() == narrow_cast<std::ptrdiff_t>(v.size()));
+         EXPECT_TRUE(s.data() == v.data());
 
          auto cs = make_span(cv);
-         EXPECT_EQ(cs.size(), narrow_cast<std::ptrdiff_t>(cv.size()));
-         EXPECT_EQ(cs.data(), cv.data());
+         EXPECT_TRUE(cs.size() == narrow_cast<std::ptrdiff_t>(cv.size()));
+         EXPECT_TRUE(cs.data() == cv.data());
      }
  }
 
@@ -777,17 +801,21 @@ TEST(span_test, from_array_constructor)
      int arr[] = {3, 4, 5};
 
      span<const int> s2 = arr;
-     EXPECT_EQ(s2.size(),  3); EXPECT_EQ(s2.data(), &arr[0]);
+     EXPECT_TRUE(s2.size() ==  3);
+     EXPECT_TRUE(s2.data() == &arr[0]);
 
      s2 = s1;
      EXPECT_TRUE(s2.empty());
 
      auto get_temp_span = [&]() -> span<int> { return {&arr[1], 2}; };
-     auto use_span = [&](span<const int> s) { EXPECT_EQ(s.size(),  2); EXPECT_EQ(s.data(), &arr[1]);
+     auto use_span = [&](span<const int> s) {
+         EXPECT_TRUE(s.size() ==  2);
+         EXPECT_TRUE(s.data() == &arr[1]);
      }; use_span(get_temp_span());
 
      s1 = get_temp_span();
-     EXPECT_EQ(s1.size(),  2); EXPECT_EQ(s1.data(), &arr[1]);
+     EXPECT_TRUE(s1.size() ==  2);
+     EXPECT_TRUE(s1.data() == &arr[1]);
  }
 
  TEST(span_test, first)
@@ -796,35 +824,35 @@ TEST(span_test, from_array_constructor)
 
      {
          span<int, 5> av = arr;
-         EXPECT_EQ(av.first<2>().size(), 2);
-         EXPECT_EQ(av.first(2).size(), 2);
+         EXPECT_TRUE(av.first<2>().size() == 2);
+         EXPECT_TRUE(av.first(2).size() == 2);
      }
 
      {
          span<int, 5> av = arr;
-         EXPECT_EQ(av.first<0>().size(), 0);
-         EXPECT_EQ(av.first(0).size(), 0);
+         EXPECT_TRUE(av.first<0>().size() == 0);
+         EXPECT_TRUE(av.first(0).size() == 0);
      }
 
      {
          span<int, 5> av = arr;
-         EXPECT_EQ(av.first<5>().size(), 5);
-         EXPECT_EQ(av.first(5).size(), 5);
+         EXPECT_TRUE(av.first<5>().size() == 5);
+         EXPECT_TRUE(av.first(5).size() == 5);
      }
 
      {
          span<int, 5> av = arr;
  #ifdef CONFIRM_COMPILATION_ERRORS
-         EXPECT_EQ(av.first<6>().size(), 6);
-         EXPECT_EQ(av.first<-1>().size(), -1);
+         EXPECT_TRUE(av.first<6>().size() == 6);
+         EXPECT_TRUE(av.first<-1>().size() == -1);
  #endif
          EXPECT_DEATH(av.first(6).size(), ".*");
      }
 
      {
          span<int> av;
-         EXPECT_EQ(av.first<0>().size(), 0);
-         EXPECT_EQ(av.first(0).size(), 0);
+         EXPECT_TRUE(av.first<0>().size() == 0);
+         EXPECT_TRUE(av.first(0).size() == 0);
      }
  }
 
@@ -834,34 +862,34 @@ TEST(span_test, from_array_constructor)
 
      {
          span<int, 5> av = arr;
-         EXPECT_EQ(av.last<2>().size(), 2);
-         EXPECT_EQ(av.last(2).size(), 2);
+         EXPECT_TRUE(av.last<2>().size() == 2);
+         EXPECT_TRUE(av.last(2).size() == 2);
      }
 
      {
          span<int, 5> av = arr;
-         EXPECT_EQ(av.last<0>().size(), 0);
-         EXPECT_EQ(av.last(0).size(), 0);
+         EXPECT_TRUE(av.last<0>().size() == 0);
+         EXPECT_TRUE(av.last(0).size() == 0);
      }
 
      {
          span<int, 5> av = arr;
-         EXPECT_EQ(av.last<5>().size(), 5);
-         EXPECT_EQ(av.last(5).size(), 5);
+         EXPECT_TRUE(av.last<5>().size() == 5);
+         EXPECT_TRUE(av.last(5).size() == 5);
      }
 
      {
          span<int, 5> av = arr;
  #ifdef CONFIRM_COMPILATION_ERRORS
-         EXPECT_EQ(av.last<6>().size(), 6);
+         EXPECT_TRUE(av.last<6>().size() == 6);
  #endif
          EXPECT_DEATH(av.last(6).size(), ".*");
      }
 
      {
          span<int> av;
-         EXPECT_EQ(av.last<0>().size(), 0);
-         EXPECT_EQ(av.last(0).size(), 0);
+         EXPECT_TRUE(av.last<0>().size() == 0);
+         EXPECT_TRUE(av.last(0).size() == 0);
      }
  }
 
@@ -871,24 +899,24 @@ TEST(span_test, from_array_constructor)
 
      {
          span<int, 5> av = arr;
-         EXPECT_EQ((av.subspan<2, 2>().size()), 2);
-         EXPECT_EQ(decltype(av.subspan<2, 2>())::extent, 2);
-         EXPECT_EQ(av.subspan(2, 2).size(), 2);
-         EXPECT_EQ(av.subspan(2, 3).size(), 3);
+         EXPECT_TRUE((av.subspan<2, 2>().size()) == 2);
+         EXPECT_TRUE(decltype(av.subspan<2, 2>())::extent == 2);
+         EXPECT_TRUE(av.subspan(2, 2).size() == 2);
+         EXPECT_TRUE(av.subspan(2, 3).size() == 3);
      }
 
      {
          span<int, 5> av = arr;
-         EXPECT_EQ((av.subspan<0, 0>().size()), 0);
-         EXPECT_EQ(decltype(av.subspan<0, 0>())::extent, 0);
-         EXPECT_EQ(av.subspan(0, 0).size(), 0);
+         EXPECT_TRUE((av.subspan<0, 0>().size()) == 0);
+         EXPECT_TRUE(decltype(av.subspan<0, 0>())::extent == 0);
+         EXPECT_TRUE(av.subspan(0, 0).size() == 0);
      }
 
      {
          span<int, 5> av = arr;
-         EXPECT_EQ((av.subspan<0, 5>().size()), 5);
-         EXPECT_EQ(decltype(av.subspan<0, 5>())::extent, 5);
-         EXPECT_EQ(av.subspan(0, 5).size(), 5);
+         EXPECT_TRUE((av.subspan<0, 5>().size()) == 5);
+         EXPECT_TRUE(decltype(av.subspan<0, 5>())::extent == 5);
+         EXPECT_TRUE(av.subspan(0, 5).size() == 5);
 
          EXPECT_DEATH(av.subspan(0, 6).size(), ".*");
          EXPECT_DEATH(av.subspan(1, 5).size(), ".*");
@@ -896,53 +924,53 @@ TEST(span_test, from_array_constructor)
 
      {
          span<int, 5> av = arr;
-         EXPECT_EQ((av.subspan<4, 0>().size()), 0);
-         EXPECT_EQ(decltype(av.subspan<4, 0>())::extent, 0);
-         EXPECT_EQ(av.subspan(4, 0).size(), 0);
-         EXPECT_EQ(av.subspan(5, 0).size(), 0);
+         EXPECT_TRUE((av.subspan<4, 0>().size()) == 0);
+         EXPECT_TRUE(decltype(av.subspan<4, 0>())::extent == 0);
+         EXPECT_TRUE(av.subspan(4, 0).size() == 0);
+         EXPECT_TRUE(av.subspan(5, 0).size() == 0);
          EXPECT_DEATH(av.subspan(6, 0).size(), ".*");
      }
 
      {
          span<int, 5> av = arr;
-         EXPECT_EQ(av.subspan<1>().size(), 4);
-         EXPECT_EQ(decltype(av.subspan<1>())::extent, 4);
+         EXPECT_TRUE(av.subspan<1>().size() == 4);
+         EXPECT_TRUE(decltype(av.subspan<1>())::extent == 4);
      }
 
      {
          span<int> av;
-         EXPECT_EQ((av.subspan<0, 0>().size()), 0);
-         EXPECT_EQ(decltype(av.subspan<0, 0>())::extent, 0);
-         EXPECT_EQ(av.subspan(0, 0).size(), 0);
+         EXPECT_TRUE((av.subspan<0, 0>().size()) == 0);
+         EXPECT_TRUE(decltype(av.subspan<0, 0>())::extent == 0);
+         EXPECT_TRUE(av.subspan(0, 0).size() == 0);
          EXPECT_DEATH((av.subspan<1, 0>().size()), ".*");
      }
 
      {
          span<int> av;
-         EXPECT_EQ(av.subspan(0).size(), 0);
+         EXPECT_TRUE(av.subspan(0).size() == 0);
          EXPECT_DEATH(av.subspan(1).size(), ".*");
      }
 
      {
          span<int> av = arr;
-         EXPECT_EQ(av.subspan(0).size(), 5);
-         EXPECT_EQ(av.subspan(1).size(), 4);
-         EXPECT_EQ(av.subspan(4).size(), 1);
-         EXPECT_EQ(av.subspan(5).size(), 0);
+         EXPECT_TRUE(av.subspan(0).size() == 5);
+         EXPECT_TRUE(av.subspan(1).size() == 4);
+         EXPECT_TRUE(av.subspan(4).size() == 1);
+         EXPECT_TRUE(av.subspan(5).size() == 0);
          EXPECT_DEATH(av.subspan(6).size(), ".*");
          const auto av2 = av.subspan(1);
-         for (int i = 0; i < 4; ++i) EXPECT_EQ(av2[i], i + 2);
+         for (int i = 0; i < 4; ++i) EXPECT_TRUE(av2[i] == i + 2);
      }
 
      {
          span<int, 5> av = arr;
-         EXPECT_EQ(av.subspan(0).size(), 5);
-         EXPECT_EQ(av.subspan(1).size(), 4);
-         EXPECT_EQ(av.subspan(4).size(), 1);
-         EXPECT_EQ(av.subspan(5).size(), 0);
+         EXPECT_TRUE(av.subspan(0).size() == 5);
+         EXPECT_TRUE(av.subspan(1).size() == 4);
+         EXPECT_TRUE(av.subspan(4).size() == 1);
+         EXPECT_TRUE(av.subspan(5).size() == 0);
          EXPECT_DEATH(av.subspan(6).size(), ".*");
          const auto av2 = av.subspan(1);
-         for (int i = 0; i < 4; ++i) EXPECT_EQ(av2[i], i + 2);
+         for (int i = 0; i < 4; ++i) EXPECT_TRUE(av2[i] == i + 2);
      }
  }
 
@@ -952,15 +980,15 @@ TEST(span_test, from_array_constructor)
 
      {
          span<int> s = arr;
-         EXPECT_EQ(s.at(0), 1);
+         EXPECT_TRUE(s.at(0) == 1);
          EXPECT_DEATH(s.at(5), ".*");
      }
 
      {
          int arr2d[2] = {1, 6};
          span<int, 2> s = arr2d;
-         EXPECT_EQ(s.at(0), 1);
-         EXPECT_EQ(s.at(1), 6);
+         EXPECT_TRUE(s.at(0) == 1);
+         EXPECT_TRUE(s.at(1) == 6);
          EXPECT_DEATH(s.at(2), ".*");
      }
  }
@@ -971,15 +999,15 @@ TEST(span_test, from_array_constructor)
 
      {
          span<int> s = arr;
-         EXPECT_EQ(s(0), 1);
+         EXPECT_TRUE(s(0) == 1);
          EXPECT_DEATH(s(5), ".*");
      }
 
      {
          int arr2d[2] = {1, 6};
          span<int, 2> s = arr2d;
-         EXPECT_EQ(s(0), 1);
-         EXPECT_EQ(s(1), 6);
+         EXPECT_TRUE(s(0) == 1);
+         EXPECT_TRUE(s(1) == 6);
          EXPECT_DEATH(s(2), ".*");
      }
  }
@@ -988,21 +1016,21 @@ TEST(span_test, from_array_constructor)
  {
      span<int>::iterator it1;
      span<int>::iterator it2;
-     EXPECT_EQ(it1, it2);
+     EXPECT_TRUE(it1 == it2);
  }
 
  TEST(span_test, const_iterator_default_init)
  {
      span<int>::const_iterator it1;
      span<int>::const_iterator it2;
-     EXPECT_EQ(it1, it2);
+     EXPECT_TRUE(it1 == it2);
  }
 
  TEST(span_test, iterator_conversions)
  {
      span<int>::iterator badIt;
      span<int>::const_iterator badConstIt;
-     EXPECT_EQ(badIt, badConstIt);
+     EXPECT_TRUE(badIt == badConstIt);
 
      int a[] = {1, 2, 3, 4};
      span<int> s = a;
@@ -1010,14 +1038,14 @@ TEST(span_test, from_array_constructor)
      auto it = s.begin();
      auto cit = s.cbegin();
 
-     EXPECT_EQ(it, cit);
-     EXPECT_EQ(cit, it);
+     EXPECT_TRUE(it == cit);
+     EXPECT_TRUE(cit == it);
 
      span<int>::const_iterator cit2 = it;
-     EXPECT_EQ(cit2, cit);
+     EXPECT_TRUE(cit2 == cit);
 
      span<int>::const_iterator cit3 = it + 4;
-     EXPECT_EQ(cit3, s.cend());
+     EXPECT_TRUE(cit3 == s.cend());
  }
 
  TEST(span_test, iterator_comparisons)
@@ -1029,41 +1057,41 @@ TEST(span_test, from_array_constructor)
          auto it2 = it + 1;
          span<int>::const_iterator cit = s.cbegin();
 
-         EXPECT_EQ(it, cit);
-         EXPECT_EQ(cit, it);
-         EXPECT_EQ(it, it);
-         EXPECT_EQ(cit, cit);
-         EXPECT_EQ(cit, s.begin());
-         EXPECT_EQ(s.begin(), cit);
-         EXPECT_EQ(s.cbegin(), cit);
-         EXPECT_EQ(it, s.begin());
-         EXPECT_EQ(s.begin(), it);
-
-         EXPECT_NE(it, it2);
-         EXPECT_NE(it2, it);
-         EXPECT_NE(it, s.end());
-         EXPECT_NE(it2, s.end());
-         EXPECT_NE(s.end(), it);
-         EXPECT_NE(it2, cit);
-         EXPECT_NE(cit, it2);
-
-         EXPECT_LT(it, it2);
-         EXPECT_LE(it, it2);
-         EXPECT_LE(it2, s.end());
-         EXPECT_LT(it, s.end());
-         EXPECT_LE(it, cit);
-         EXPECT_LE(cit, it);
-         EXPECT_LT(cit, it2);
-         EXPECT_LE(cit, it2);
-         EXPECT_LT(cit, s.end());
-         EXPECT_LE(cit, s.end());
-
-         EXPECT_GT(it2, it);
-         EXPECT_GE(it2, it);
-         EXPECT_GT(s.end(), it2);
-         EXPECT_GE(s.end(), it2);
-         EXPECT_GT(it2, cit);
-         EXPECT_GE(it2, cit);
+         EXPECT_TRUE(it == cit);
+         EXPECT_TRUE(cit == it);
+         EXPECT_TRUE(it == it);
+         EXPECT_TRUE(cit == cit);
+         EXPECT_TRUE(cit == s.begin());
+         EXPECT_TRUE(s.begin() == cit);
+         EXPECT_TRUE(s.cbegin() == cit);
+         EXPECT_TRUE(it == s.begin());
+         EXPECT_TRUE(s.begin() == it);
+
+         EXPECT_TRUE(it != it2);
+         EXPECT_TRUE(it2 != it);
+         EXPECT_TRUE(it != s.end());
+         EXPECT_TRUE(it2 != s.end());
+         EXPECT_TRUE(s.end() != it);
+         EXPECT_TRUE(it2 != cit);
+         EXPECT_TRUE(cit != it2);
+
+         EXPECT_TRUE(it < it2);
+         EXPECT_TRUE(it <= it2);
+         EXPECT_TRUE(it2 <= s.end());
+         EXPECT_TRUE(it < s.end());
+         EXPECT_TRUE(it <= cit);
+         EXPECT_TRUE(cit <= it);
+         EXPECT_TRUE(cit < it2);
+         EXPECT_TRUE(cit <= it2);
+         EXPECT_TRUE(cit < s.end());
+         EXPECT_TRUE(cit <= s.end());
+
+         EXPECT_TRUE(it2 > it);
+         EXPECT_TRUE(it2 >= it);
+         EXPECT_TRUE(s.end() > it2);
+         EXPECT_TRUE(s.end() >= it2);
+         EXPECT_TRUE(it2 > cit);
+         EXPECT_TRUE(it2 >= cit);
      }
  }
 
@@ -1075,11 +1103,11 @@ TEST(span_test, from_array_constructor)
 
          span<int>::iterator it = s.begin();
          span<int>::iterator it2 = std::begin(s);
-         EXPECT_EQ(it, it2);
+         EXPECT_TRUE(it == it2);
 
          it = s.end();
          it2 = std::end(s);
-         EXPECT_EQ(it, it2);
+         EXPECT_TRUE(it == it2);
      }
 
      {
@@ -1088,36 +1116,36 @@ TEST(span_test, from_array_constructor)
 
          auto it = s.begin();
          auto first = it;
-         EXPECT_EQ(it, first);
-         EXPECT_EQ(*it, 1);
+         EXPECT_TRUE(it == first);
+         EXPECT_TRUE(*it == 1);
 
          auto beyond = s.end();
-         EXPECT_NE(it, beyond);
+         EXPECT_TRUE(it != beyond);
          EXPECT_DEATH(*beyond, ".*");
 
-         EXPECT_EQ(beyond - first, 4);
-         EXPECT_EQ(first - first, 0);
-         EXPECT_EQ(beyond - beyond, 0);
+         EXPECT_TRUE(beyond - first == 4);
+         EXPECT_TRUE(first - first == 0);
+         EXPECT_TRUE(beyond - beyond == 0);
 
          ++it;
-         EXPECT_EQ(it - first, 1);
-         EXPECT_EQ(*it, 2);
+         EXPECT_TRUE(it - first == 1);
+         EXPECT_TRUE(*it == 2);
          *it = 22;
-         EXPECT_EQ(*it, 22);
-         EXPECT_EQ(beyond - it, 3);
+         EXPECT_TRUE(*it == 22);
+         EXPECT_TRUE(beyond - it == 3);
 
          it = first;
-         EXPECT_EQ(it, first);
+         EXPECT_TRUE(it == first);
          while (it != s.end())
          {
              *it = 5;
              ++it;
          }
 
-         EXPECT_EQ(it, beyond);
-         EXPECT_EQ(it - beyond, 0);
+         EXPECT_TRUE(it == beyond);
+         EXPECT_TRUE(it - beyond == 0);
 
-         for (const auto& n : s) { EXPECT_EQ(n, 5); }
+         for (const auto& n : s) { EXPECT_TRUE(n == 5); }
      }
  }
 
@@ -1129,11 +1157,11 @@ TEST(span_test, from_array_constructor)
 
          span<int>::const_iterator cit = s.cbegin();
          span<int>::const_iterator cit2 = std::cbegin(s);
-         EXPECT_EQ(cit, cit2);
+         EXPECT_TRUE(cit == cit2);
 
          cit = s.cend();
          cit2 = std::cend(s);
-         EXPECT_EQ(cit, cit2);
+         EXPECT_TRUE(cit == cit2);
      }
 
      {
@@ -1142,35 +1170,35 @@ TEST(span_test, from_array_constructor)
 
          auto it = s.cbegin();
          auto first = it;
-         EXPECT_EQ(it, first);
-         EXPECT_EQ(*it, 1);
+         EXPECT_TRUE(it == first);
+         EXPECT_TRUE(*it == 1);
 
          auto beyond = s.cend();
-         EXPECT_NE(it, beyond);
+         EXPECT_TRUE(it != beyond);
          EXPECT_DEATH(*beyond, ".*");
 
-         EXPECT_EQ(beyond - first, 4);
-         EXPECT_EQ(first - first, 0);
-         EXPECT_EQ(beyond - beyond, 0);
+         EXPECT_TRUE(beyond - first == 4);
+         EXPECT_TRUE(first - first == 0);
+         EXPECT_TRUE(beyond - beyond == 0);
 
          ++it;
-         EXPECT_EQ(it - first, 1);
-         EXPECT_EQ(*it, 2);
-         EXPECT_EQ(beyond - it, 3);
+         EXPECT_TRUE(it - first == 1);
+         EXPECT_TRUE(*it == 2);
+         EXPECT_TRUE(beyond - it == 3);
 
          int last = 0;
          it = first;
-         EXPECT_EQ(it, first);
+         EXPECT_TRUE(it == first);
          while (it != s.cend())
          {
-             EXPECT_EQ(*it, last + 1);
+             EXPECT_TRUE(*it == last + 1);
 
              last = *it;
              ++it;
          }
 
-         EXPECT_EQ(it, beyond);
-         EXPECT_EQ(it - beyond, 0);
+         EXPECT_TRUE(it == beyond);
+         EXPECT_TRUE(it - beyond == 0);
      }
  }
 
@@ -1182,36 +1210,36 @@ TEST(span_test, from_array_constructor)
 
          auto it = s.rbegin();
          auto first = it;
-         EXPECT_EQ(it, first);
-         EXPECT_EQ(*it, 4);
+         EXPECT_TRUE(it == first);
+         EXPECT_TRUE(*it == 4);
 
          auto beyond = s.rend();
-         EXPECT_NE(it, beyond);
+         EXPECT_TRUE(it != beyond);
          //EXPECT_DEATH(*beyond, ".*");
 
-         EXPECT_EQ(beyond - first, 4);
-         EXPECT_EQ(first - first, 0);
-         EXPECT_EQ(beyond - beyond, 0);
+         EXPECT_TRUE(beyond - first == 4);
+         EXPECT_TRUE(first - first == 0);
+         EXPECT_TRUE(beyond - beyond == 0);
 
          ++it;
-         EXPECT_EQ(it - first, 1);
-         EXPECT_EQ(*it, 3);
+         EXPECT_TRUE(it - first == 1);
+         EXPECT_TRUE(*it == 3);
          *it = 22;
-         EXPECT_EQ(*it, 22);
-         EXPECT_EQ(beyond - it, 3);
+         EXPECT_TRUE(*it == 22);
+         EXPECT_TRUE(beyond - it == 3);
 
          it = first;
-         EXPECT_EQ(it, first);
+         EXPECT_TRUE(it == first);
          while (it != s.rend())
          {
              *it = 5;
              ++it;
          }
 
-         EXPECT_EQ(it, beyond);
-         EXPECT_EQ(it - beyond, 0);
+         EXPECT_TRUE(it == beyond);
+         EXPECT_TRUE(it - beyond == 0);
 
-         for (const auto& n : s) { EXPECT_EQ(n, 5); }
+         for (const auto& n : s) { EXPECT_TRUE(n == 5); }
      }
  }
 
@@ -1223,35 +1251,35 @@ TEST(span_test, from_array_constructor)
 
          auto it = s.crbegin();
          auto first = it;
-         EXPECT_EQ(it, first);
-         EXPECT_EQ(*it, 4);
+         EXPECT_TRUE(it == first);
+         EXPECT_TRUE(*it == 4);
 
          auto beyond = s.crend();
-         EXPECT_NE(it, beyond);
+         EXPECT_TRUE(it != beyond);
          //EXPECT_DEATH(*beyond, ".*");
 
-         EXPECT_EQ(beyond - first, 4);
-         EXPECT_EQ(first - first, 0);
-         EXPECT_EQ(beyond - beyond, 0);
+         EXPECT_TRUE(beyond - first == 4);
+         EXPECT_TRUE(first - first == 0);
+         EXPECT_TRUE(beyond - beyond == 0);
 
          ++it;
-         EXPECT_EQ(it - first, 1);
-         EXPECT_EQ(*it, 3);
-         EXPECT_EQ(beyond - it, 3);
+         EXPECT_TRUE(it - first == 1);
+         EXPECT_TRUE(*it == 3);
+         EXPECT_TRUE(beyond - it == 3);
 
          it = first;
-         EXPECT_EQ(it, first);
+         EXPECT_TRUE(it == first);
          int last = 5;
          while (it != s.crend())
          {
-             EXPECT_EQ(*it, last - 1);
+             EXPECT_TRUE(*it == last - 1);
              last = *it;
 
              ++it;
          }
 
-         EXPECT_EQ(it, beyond);
-         EXPECT_EQ(it - beyond, 0);
+         EXPECT_TRUE(it == beyond);
+         EXPECT_TRUE(it - beyond == 0);
      }
  }
 
@@ -1260,18 +1288,18 @@ TEST(span_test, from_array_constructor)
      {
          span<int> s1;
          span<int> s2;
-         EXPECT_EQ(s1, s2);
+         EXPECT_TRUE(s1 == s2);
          EXPECT_FALSE(s1 != s2);
          EXPECT_FALSE(s1 < s2);
-         EXPECT_LE(s1, s2);
+         EXPECT_TRUE(s1 <= s2);
          EXPECT_FALSE(s1 > s2);
-         EXPECT_GE(s1, s2);
-         EXPECT_EQ(s2, s1);
+         EXPECT_TRUE(s1 >= s2);
+         EXPECT_TRUE(s2 == s1);
          EXPECT_FALSE(s2 != s1);
          EXPECT_FALSE(s2 != s1);
-         EXPECT_LE(s2, s1);
+         EXPECT_TRUE(s2 <= s1);
          EXPECT_FALSE(s2 > s1);
-         EXPECT_GE(s2, s1);
+         EXPECT_TRUE(s2 >= s1);
      }
 
      {
@@ -1279,18 +1307,18 @@ TEST(span_test, from_array_constructor)
          span<int> s1 = arr;
          span<int> s2 = arr;
 
-         EXPECT_EQ(s1, s2);
+         EXPECT_TRUE(s1 == s2);
          EXPECT_FALSE(s1 != s2);
          EXPECT_FALSE(s1 < s2);
-         EXPECT_LE(s1, s2);
+         EXPECT_TRUE(s1 <= s2);
          EXPECT_FALSE(s1 > s2);
-         EXPECT_GE(s1, s2);
-         EXPECT_EQ(s2, s1);
+         EXPECT_TRUE(s1 >= s2);
+         EXPECT_TRUE(s2 == s1);
          EXPECT_FALSE(s2 != s1);
          EXPECT_FALSE(s2 < s1);
-         EXPECT_LE(s2, s1);
+         EXPECT_TRUE(s2 <= s1);
          EXPECT_FALSE(s2 > s1);
-         EXPECT_GE(s2, s1);
+         EXPECT_TRUE(s2 >= s1);
      }
 
      {
@@ -1299,17 +1327,17 @@ TEST(span_test, from_array_constructor)
          span<int> s1;
          span<int> s2 = arr;
 
-         EXPECT_NE(s1, s2);
-         EXPECT_NE(s2, s1);
+         EXPECT_TRUE(s1 != s2);
+         EXPECT_TRUE(s2 != s1);
          EXPECT_FALSE(s1 == s2);
          EXPECT_FALSE(s2 == s1);
-         EXPECT_LT(s1, s2);
+         EXPECT_TRUE(s1 < s2);
          EXPECT_FALSE(s2 < s1);
-         EXPECT_LE(s1, s2);
+         EXPECT_TRUE(s1 <= s2);
          EXPECT_FALSE(s2 <= s1);
-         EXPECT_GT(s2, s1);
+         EXPECT_TRUE(s2 > s1);
          EXPECT_FALSE(s1 > s2);
-         EXPECT_GE(s2, s1);
+         EXPECT_TRUE(s2 >= s1);
          EXPECT_FALSE(s1 >= s2);
      }
 
@@ -1319,18 +1347,18 @@ TEST(span_test, from_array_constructor)
          span<int> s1 = arr1;
          span<int> s2 = arr2;
 
-         EXPECT_EQ(s1, s2);
+         EXPECT_TRUE(s1 == s2);
          EXPECT_FALSE(s1 != s2);
          EXPECT_FALSE(s1 < s2);
-         EXPECT_LE(s1, s2);
+         EXPECT_TRUE(s1 <= s2);
          EXPECT_FALSE(s1 > s2);
-         EXPECT_GE(s1, s2);
-         EXPECT_EQ(s2, s1);
+         EXPECT_TRUE(s1 >= s2);
+         EXPECT_TRUE(s2 == s1);
          EXPECT_FALSE(s2 != s1);
          EXPECT_FALSE(s2 < s1);
-         EXPECT_LE(s2, s1);
+         EXPECT_TRUE(s2 <= s1);
          EXPECT_FALSE(s2 > s1);
-         EXPECT_GE(s2, s1);
+         EXPECT_TRUE(s2 >= s1);
      }
 
      {
@@ -1339,17 +1367,17 @@ TEST(span_test, from_array_constructor)
          span<int> s1 = {&arr[0], 2}; // shorter
          span<int> s2 = arr;          // longer
 
-         EXPECT_NE(s1, s2);
-         EXPECT_NE(s2, s1);
+         EXPECT_TRUE(s1 != s2);
+         EXPECT_TRUE(s2 != s1);
          EXPECT_FALSE(s1 == s2);
          EXPECT_FALSE(s2 == s1);
-         EXPECT_LT(s1, s2);
+         EXPECT_TRUE(s1 < s2);
          EXPECT_FALSE(s2 < s1);
-         EXPECT_LE(s1, s2);
+         EXPECT_TRUE(s1 <= s2);
          EXPECT_FALSE(s2 <= s1);
-         EXPECT_GT(s2, s1);
+         EXPECT_TRUE(s2 > s1);
          EXPECT_FALSE(s1 > s2);
-         EXPECT_GE(s2, s1);
+         EXPECT_TRUE(s2 >= s1);
          EXPECT_FALSE(s1 >= s2);
      }
 
@@ -1360,17 +1388,17 @@ TEST(span_test, from_array_constructor)
          span<int> s1 = arr1;
          span<int> s2 = arr2;
 
-         EXPECT_NE(s1, s2);
-         EXPECT_NE(s2, s1);
+         EXPECT_TRUE(s1 != s2);
+         EXPECT_TRUE(s2 != s1);
          EXPECT_FALSE(s1 == s2);
          EXPECT_FALSE(s2 == s1);
-         EXPECT_LT(s1, s2);
+         EXPECT_TRUE(s1 < s2);
          EXPECT_FALSE(s2 < s1);
-         EXPECT_LE(s1, s2);
+         EXPECT_TRUE(s1 <= s2);
          EXPECT_FALSE(s2 <= s1);
-         EXPECT_GT(s2, s1);
+         EXPECT_TRUE(s2 > s1);
          EXPECT_FALSE(s1 > s2);
-         EXPECT_GE(s2, s1);
+         EXPECT_TRUE(s2 >= s1);
          EXPECT_FALSE(s1 >= s2);
      }
  }
@@ -1381,27 +1409,27 @@ TEST(span_test, from_array_constructor)
 
      {
          const span<const int> s = a;
-         EXPECT_EQ(s.size(), 4);
+         EXPECT_TRUE(s.size() == 4);
          const span<const byte> bs = as_bytes(s);
-         EXPECT_EQ(static_cast<const void*>(bs.data()), static_cast<const void*>(s.data()));
-         EXPECT_EQ(bs.size(), s.size_bytes());
+         EXPECT_TRUE(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
+         EXPECT_TRUE(bs.size() == s.size_bytes());
      }
 
      {
          span<int> s;
          const auto bs = as_bytes(s);
-         EXPECT_EQ(bs.size(), s.size());
-         EXPECT_EQ(bs.size(), 0);
-         EXPECT_EQ(bs.size_bytes(), 0);
-         EXPECT_EQ(static_cast<const void*>(bs.data()), static_cast<const void*>(s.data()));
-         EXPECT_EQ(bs.data(), nullptr);
+         EXPECT_TRUE(bs.size() == s.size());
+         EXPECT_TRUE(bs.size() == 0);
+         EXPECT_TRUE(bs.size_bytes() == 0);
+         EXPECT_TRUE(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
+         EXPECT_TRUE(bs.data() == nullptr);
      }
 
      {
          span<int> s = a;
          const auto bs = as_bytes(s);
-         EXPECT_EQ(static_cast<const void*>(bs.data()), static_cast<const void*>(s.data()));
-         EXPECT_EQ(bs.size(), s.size_bytes());
+         EXPECT_TRUE(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
+         EXPECT_TRUE(bs.size() == s.size_bytes());
      }
  }
 
@@ -1413,28 +1441,28 @@ TEST(span_test, from_array_constructor)
  #ifdef CONFIRM_COMPILATION_ERRORS
          // you should not be able to get writeable bytes for const objects
          span<const int> s = a;
-         EXPECT_EQ(s.size(), 4);
+         EXPECT_TRUE(s.size() == 4);
          span<const byte> bs = as_writeable_bytes(s);
-         EXPECT_EQ(static_cast<void*>(bs.data()), static_cast<void*>(s.data()));
-         EXPECT_EQ(bs.size(), s.size_bytes());
+         EXPECT_TRUE(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
+         EXPECT_TRUE(bs.size() == s.size_bytes());
  #endif
      }
 
      {
          span<int> s;
          const auto bs = as_writeable_bytes(s);
-         EXPECT_EQ(bs.size(), s.size());
-         EXPECT_EQ(bs.size(), 0);
-         EXPECT_EQ(bs.size_bytes(), 0);
-         EXPECT_EQ(static_cast<void*>(bs.data()), static_cast<void*>(s.data()));
-         EXPECT_EQ(bs.data(), nullptr);
+         EXPECT_TRUE(bs.size() == s.size());
+         EXPECT_TRUE(bs.size() == 0);
+         EXPECT_TRUE(bs.size_bytes() == 0);
+         EXPECT_TRUE(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
+         EXPECT_TRUE(bs.data() == nullptr);
      }
 
      {
          span<int> s = a;
          const auto bs = as_writeable_bytes(s);
-         EXPECT_EQ(static_cast<void*>(bs.data()), static_cast<void*>(s.data()));
-         EXPECT_EQ(bs.size(), s.size_bytes());
+         EXPECT_TRUE(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
+         EXPECT_TRUE(bs.size() == s.size_bytes());
      }
  }
 
@@ -1444,12 +1472,12 @@ TEST(span_test, from_array_constructor)
 
      // converting to an span from an equal size array is ok
      span<int, 4> s4 = arr;
-     EXPECT_EQ(s4.size(), 4);
+     EXPECT_TRUE(s4.size() == 4);
 
      // converting to dynamic_range is always ok
      {
          span<int> s = s4;
-         EXPECT_EQ(s.size(), s4.size());
+         EXPECT_TRUE(s.size() == s4.size());
          static_cast<void>(s);
      }
 
@@ -1533,22 +1561,23 @@ TEST(span_test, from_array_constructor)
      EXPECT_TRUE(match.ready());
      EXPECT_FALSE(match.empty());
      EXPECT_TRUE(match[0].matched);
-     EXPECT_EQ(match[0].first, s.begin());
-     EXPECT_EQ(match[0].second, s.end());
+     EXPECT_TRUE(match[0].first == s.begin());
+     EXPECT_TRUE(match[0].second == s.end());
 
      std::regex_search(s.begin(), s.end(), match, std::regex("F"));
      EXPECT_TRUE(match.ready());
      EXPECT_FALSE(match.empty());
      EXPECT_TRUE(match[0].matched);
-     EXPECT_EQ(match[0].first, f_it);
-     EXPECT_EQ(match[0].second, (f_it + 1));
+     EXPECT_TRUE(match[0].first == f_it);
+     EXPECT_TRUE(match[0].second == (f_it + 1));
  }
 
  TEST(span_test, interop_with_gsl_at)
  {
      int arr[5] = {1, 2, 3, 4, 5};
      span<int> s{arr};
-     EXPECT_EQ(at(s, 0),  1); EXPECT_EQ(at(s, 1), 2);
+     EXPECT_TRUE(at(s, 0) ==  1);
+     EXPECT_TRUE(at(s, 1) == 2);
  }
 
  TEST(span_test, default_constructible)