[libcxx][test] the domain of == for forward iterators is iterator values from the same range

[CaseyCarter]

Summary

• Default-initialized basic_string iterators are not portably in the domain of ==.
• Avoid comparing iterators from non-equal string_views which MSVCSTL considers not to be in the domain of equality.
• Don't test invalid range [in, out + N).

Also silence some truncation warnings by testing with a non-narrowing conversion.

[• Quuxplusone]

LGTM % discussion on whether we should eliminate the bogus test in libcxx/test/std/strings/basic.string/string.iterators/iterators.pass.cpp entirely.

libcxx/test/std/strings/basic.string/string.iterators/iterators.pass.cpp

56–57

Default-initialized basic_string iterators are not portably in the domain of ==.

Oh yeah, because they can conformingly be just garbage-initialized const char*s, right? Makes sense. We probably shouldn't even be testing this case, then.

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy.pass.cpp

221

Mild yikes. Did MSVC catch this with a warning, instrumented debug iterators, or otherwise?

328

This is "silence some truncation warnings," right? SGTM.

[CaseyCarter]

Review comment.

[CaseyCarter]

libcxx/test/std/strings/basic.string/string.iterators/iterators.pass.cpp

56–57

I'll strike.

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy.pass.cpp

221

Range validity checks - we check first <= last when both are pointers - caught both occurrences when the compiler decided to place out before in on the stack.

[• Quuxplusone]

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy.pass.cpp

221

Ah, neat (but also disappointingly arbitrary :)). I wonder if there's a Clang option to randomize stack layout, or if ASAN/MSAN/UBSAN would catch unrelated pointer comparisons like that and if so could we turn it on for our debug-build CI, which also includes variations on _LIBCPP_ASSERT(first <= last).

libcxx/test/std/ranges/range.adaptors/range.all/range.owning.view/begin_end.pass.cpp

constexpr bool test()
     assert(std::as_const(ov).begin() == a);
     assert(ov.end() == a+1);
     assert(std::as_const(ov).end() == a+1);
   }
   {
     // Test a non-view.
     std::array<int, 2> a = {1, 2};
     auto ov = std::ranges::owning_view(std::move(a));
-    assert(ov.begin() != a.begin()); // because it points into the copy
-    assert(std::as_const(ov).begin() != a.begin());
-    assert(ov.end() != a.end());
-    assert(std::as_const(ov).end() != a.end());
+    assert(std::to_address(ov.begin()) != std::to_address(a.begin())); // because it points into the copy
+    assert(std::to_address(std::as_const(ov).begin()) != std::to_address(a.begin()));
+    assert(std::to_address(ov.end()) != std::to_address(a.end()));
+    assert(std::to_address(std::as_const(ov).end()) != std::to_address(a.end()));
   }
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/plus_minus.pass.cpp

 
 #include "test_macros.h"
 #include "../types.h"
 
 constexpr bool test() {
   std::ranges::transform_view<MoveOnlyView, PlusOneMutable> transformView1;
   auto iter1 = std::move(transformView1).begin();
   std::ranges::transform_view<MoveOnlyView, PlusOneMutable> transformView2;
-  auto iter2 = std::move(transformView2).begin();
+  [[maybe_unused]] auto iter2 = std::move(transformView2).begin();
   iter1 += 4;
   assert((iter1 + 1).base() == globalBuff + 5);
   assert((1 + iter1).base() == globalBuff + 5);
   assert((iter1 - 1).base() == globalBuff + 3);
-  assert(iter1 - iter2 == 4);
+  LIBCPP_ASSERT(iter1 - iter2 == 4);
   assert((iter1 + 2) - 2 == iter1);
   assert((iter1 - 2) + 2 == iter1);
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.iterators/iterators.pass.cpp

TEST_CONSTEXPR_CXX20 void test()
         assert ( (ii1 >= cii ));
         assert ( (cii >= ii1 ));
         assert (cii - ii1 == 0);
         assert (ii1 - cii == 0);
     }
     {
         C a;
         typename C::iterator i1 = a.begin();
         typename C::iterator i2;
-        assert ( i1 != i2 );
         i2 = i1;
         assert ( i1 == i2 );
     }
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
     test<std::string>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<std::wstring>();

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp

constexpr void test(const CharT* fmt) {
     context.advance_to(context.begin() + 1);
     assert(context.begin() == context.end());
   }
   {
     std::basic_string_view view{fmt};
     std::basic_format_parse_context context(view);
 
     context.advance_to(context.begin() + 1);
-    assert(context.begin() == view.begin() + 1);
+    assert(std::to_address(context.begin()) == std::to_address(view.begin()) + 1);
 
     context.advance_to(context.begin() + 1);
-    assert(context.begin() == view.begin() + 2);
+    assert(std::to_address(context.begin()) == std::to_address(view.begin()) + 2);
 
     context.advance_to(context.begin() + 1);
     assert(context.begin() == context.end());
   }
 }
 
 constexpr bool test() {
   test("abc");

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy.pass.cpp

int main(int, char**) {
   }
   Counted::reset();
 
   // Any existing values should be overwritten by copy constructors.
   {
     constexpr int N = 5;
     int in[N] = {1, 2, 3, 4, 5};
     int out[N] = {6, 7, 8, 9, 10};
-    assert(!std::equal(in, in + N, in, out + N));
+    assert(!std::equal(in, in + N, out, out + N));
 
     std::ranges::uninitialized_copy(in, in + 1, out, out + N);
     assert(out[0] == 1);
     assert(out[1] == 7);
 
     std::ranges::uninitialized_copy(in, in + N, out, out + N);
     assert(std::equal(in, in + N, out, out + N));
   }
// Works with const iterators, (range) overload.
 
     std::destroy(out.begin(), out.end());
   }
   Counted::reset();
 
   // Conversions, (iter, sentinel) overload.
   {
     constexpr int N = 3;
-    double in[N] = {1.0, 2.0, 3.0};
-    Buffer<int, N> out;
+    int in[N] = {1, 2, 3};
+    Buffer<double, N> out;
 
     std::ranges::uninitialized_copy(in, in + N, out.begin(), out.end());
     assert(std::equal(in, in + N, out.begin(), out.end()));
   }
 
   // Conversions, (range) overload.
   {
     constexpr int N = 3;
-    double in[N] = {1.0, 2.0, 3.0};
-    Buffer<int, N> out;
+    int in[N] = {1, 2, 3};
+    Buffer<double, N> out;
 
     std::ranges::uninitialized_copy(in, out);
     assert(std::equal(in, in + N, out.begin(), out.end()));
   }
 
   // Destination range is shorter than the source range, (iter, sentinel) overload.
   {
     constexpr int M = 3;

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy_n.pass.cpp

// Works with const iterators.
 
     std::destroy(out.begin(), out.end());
   }
   Counted::reset();
 
   // Conversions.
   {
     constexpr int N = 3;
-    double in[N] = {1.0, 2.0, 3.0};
-    Buffer<int, N> out;
+    int in[N] = {1, 2, 3};
+    Buffer<double, N> out;
 
     std::ranges::uninitialized_copy_n(in, N, out.begin(), out.end());
     assert(std::equal(in, in + N, out.begin(), out.end()));
   }
 
   // Destination range is shorter than the source range.
   {
     constexpr int M = 3;

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move.pass.cpp

int main(int, char**) {
   }
   Counted::reset();
 
   // Any existing values should be overwritten by move constructors.
   {
     constexpr int N = 5;
     int in[N] = {1, 2, 3, 4, 5};
     int out[N] = {6, 7, 8, 9, 10};
-    assert(!std::equal(in, in + N, in, out + N));
+    assert(!std::equal(in, in + N, out, out + N));
 
     std::ranges::uninitialized_move(in, in + 1, out, out + N);
     assert(out[0] == 1);
     assert(out[1] == 7);
 
     std::ranges::uninitialized_move(in, in + N, out, out + N);
     assert(std::equal(in, in + N, out, out + N));
   }
// Works with const iterators, (range) overload.
 
     std::destroy(out.begin(), out.end());
   }
   Counted::reset();
 
   // Conversions, (iter, sentinel) overload.
   {
     constexpr int N = 3;
-    double in[N] = {1.0, 2.0, 3.0};
-    Buffer<int, N> out;
+    int in[N] = {1, 2, 3};
+    Buffer<double, N> out;
 
     std::ranges::uninitialized_move(in, in + N, out.begin(), out.end());
     assert(std::equal(in, in + N, out.begin(), out.end()));
   }
 
   // Conversions, (range) overload.
   {
     constexpr int N = 3;
-    double in[N] = {1.0, 2.0, 3.0};
-    Buffer<int, N> out;
+    int in[N] = {1, 2, 3};
+    Buffer<double, N> out;
 
     std::ranges::uninitialized_move(in, out);
     assert(std::equal(in, in + N, out.begin(), out.end()));
   }
 
   // Destination range is shorter than the source range, (iter, sentinel) overload.
   {
     constexpr int M = 3;

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move_n.pass.cpp

// Works with const iterators.
 
     std::destroy(out.begin(), out.end());
   }
   Counted::reset();
 
   // Conversions.
   {
     constexpr int N = 3;
-    double in[N] = {1.0, 2.0, 3.0};
-    Buffer<int, N> out;
+    int in[N] = {1, 2, 3};
+    Buffer<double, N> out;
 
     std::ranges::uninitialized_move_n(in, N, out.begin(), out.end());
     assert(std::equal(in, in + N, out.begin(), out.end()));
   }
 
   // Destination range is shorter than the source range.
   {
     constexpr int M = 3;