Augment ranges::{fill, fill_n, find} with missing tests

winner245 · winner245 · commit aa949ce3d77e · 2025-02-19T12:51:06.000-05:00
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
@@ -84,48 +84,16 @@ TEST_CONSTEXPR_CXX20 void test_bititer_with_custom_sized_types() {
 TEST_CONSTEXPR_CXX20 bool test() {
   types::for_each(types::forward_iterator_list<char*>(), Test<char>());
   types::for_each(types::forward_iterator_list<int*>(), Test<int>());
-  {   // test vector<bool>::iterator optimization
-    { // simple case
-      std::vector<bool> in(4, false);
-      std::vector<bool> expected(4, true);
-      std::fill(in.begin(), in.end(), true);
-      assert(in == expected);
-    }
-    { // partial byte in the front is not filled
-      std::vector<bool> in(8, false);
-      std::vector<bool> expected(8, true);
-      expected[0] = false;
-      expected[1] = false;
-      std::fill(in.begin() + 2, in.end(), true);
-      assert(in == expected);
-    }
-    { // partial byte in the back is not filled
-      std::vector<bool> in(8, false);
-      std::vector<bool> expected(8, true);
-      expected[6] = false;
-      expected[7] = false;
-      std::fill(in.begin(), in.end() - 2, true);
-      assert(in == expected);
-    }
-    { // partial byte in the front and back is not filled
-      std::vector<bool> in(16, false);
-      std::vector<bool> expected(16, true);
-      expected[0]  = false;
-      expected[1]  = false;
-      expected[14] = false;
-      expected[15] = false;
-      std::fill(in.begin() + 2, in.end() - 2, true);
-      assert(in == expected);
-    }
-    { // only a few bits of a byte are set
-      std::vector<bool> in(8, false);
-      std::vector<bool> expected(8, true);
-      expected[0] = false;
-      expected[1] = false;
-      expected[6] = false;
-      expected[7] = false;
-      std::fill(in.begin() + 2, in.end() - 2, true);
-      assert(in == expected);
+
+  { // Test vector<bool>::iterator optimization
+    for (std::size_t N = 8; N <= 256; N *= 2) {
+      // Test with both full and partial bytes
+      for (std::size_t offset = 0; offset <= 4; offset += 4) {
+        std::vector<bool> in(N + 2 * offset);
+        std::vector<bool> expected(N, true);
+        std::fill(in.begin() + offset, in.end() - offset, true);
+        assert(std::equal(in.begin() + offset, in.end() - offset, expected.begin()));
+      }
     }
   }
 
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
@@ -169,8 +169,21 @@ TEST_CONSTEXPR_CXX20 bool test() {
   types::for_each(types::forward_iterator_list<int*>(), Test<int>());
 
   test_int_array();
-  test_struct_array();
-  test_int_array_struct_source();
+  test_struct_array(); 
+  test_int_array_struct_source(); 
+
+  { // Test vector<bool>::iterator optimization
+    for (std::size_t N = 8; N <= 256; N *= 2) {
+      // Test with both full and partial bytes
+      for (std::size_t offset = 0; offset <= 4; offset += 4) {
+        std::vector<bool> in(N + 2 * offset);
+        std::vector<bool> expected(N, true);
+        std::fill_n(in.begin() + offset, N + offset, true);
+        assert(std::equal(in.begin() + offset, in.end() - offset, expected.begin()));
+      }
+    }
+  }
+  
   test_bititer_with_custom_sized_types();
 
   return true;
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill.pass.cpp
@@ -173,7 +173,19 @@ constexpr bool test() {
     }
   }
 
-#if TEST_STD_VER >= 23
+#if TEST_STD_VER >= 23 
+  { // Test vector<bool>::iterator optimization
+    for (std::size_t N = 8; N <= 256; N *= 2) {
+      // Test with both full and partial bytes
+      for (std::size_t offset : {0, 4}) {
+        std::vector<bool> in(N + 2 * offset);
+        std::vector<bool> expected(N, true);
+        std::ranges::fill(std::ranges::begin(in) + offset, std::ranges::end(in) - offset, true);
+        assert(std::equal(in.begin() + offset, in.end() - offset, expected.begin()));
+      }
+    }
+  }
+
   test_bititer_with_custom_sized_types();
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill_n.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill_n.pass.cpp
@@ -122,6 +122,18 @@ constexpr bool test() {
   }
 
 #if TEST_STD_VER >= 23
+  { // Test vector<bool>::iterator optimization
+    for (std::size_t N = 8; N <= 256; N *= 2) {
+      // Test with both full and partial bytes
+      for (std::size_t offset : {0, 4}) {
+        std::vector<bool> in(N + 2 * offset);
+        std::vector<bool> expected(N, true);
+        std::ranges::fill_n(std::ranges::begin(in) + offset, N, true);
+        assert(std::equal(in.begin() + offset, in.end() - offset, expected.begin()));
+      }
+    }
+  }
+
   test_bititer_with_custom_sized_types();
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.count/ranges.count.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.count/ranges.count.pass.cpp
@@ -67,13 +67,13 @@ constexpr void test_iterators() {
   {
     // simple test
     {
-      int a[] = {1, 2, 3, 4};
+      int a[]                               = {1, 2, 3, 4};
       std::same_as<std::ptrdiff_t> auto ret = std::ranges::count(It(a), Sent(It(a + 4)), 3);
       assert(ret == 1);
     }
     {
-      int a[] = {1, 2, 3, 4};
-      auto range = std::ranges::subrange(It(a), Sent(It(a + 4)));
+      int a[]                               = {1, 2, 3, 4};
+      auto range                            = std::ranges::subrange(It(a), Sent(It(a + 4)));
       std::same_as<std::ptrdiff_t> auto ret = std::ranges::count(range, 3);
       assert(ret == 1);
     }
@@ -83,13 +83,13 @@ constexpr void test_iterators() {
     // check that an empty range works
     {
       std::array<int, 0> a = {};
-      auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 1);
+      auto ret             = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 1);
       assert(ret == 0);
     }
     {
       std::array<int, 0> a = {};
-      auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
-      auto ret = std::ranges::count(range, 1);
+      auto range           = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+      auto ret             = std::ranges::count(range, 1);
       assert(ret == 0);
     }
   }
@@ -98,13 +98,13 @@ constexpr void test_iterators() {
     // check that a range with a single element works
     {
       std::array a = {2};
-      auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 2);
+      auto ret     = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 2);
       assert(ret == 1);
     }
     {
       std::array a = {2};
-      auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
-      auto ret = std::ranges::count(range, 2);
+      auto range   = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+      auto ret     = std::ranges::count(range, 2);
       assert(ret == 1);
     }
   }
@@ -113,13 +113,13 @@ constexpr void test_iterators() {
     // check that 0 is returned with no match
     {
       std::array a = {1, 1, 1};
-      auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 0);
+      auto ret     = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 0);
       assert(ret == 0);
     }
     {
       std::array a = {1, 1, 1};
-      auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
-      auto ret = std::ranges::count(range, 0);
+      auto range   = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+      auto ret     = std::ranges::count(range, 0);
       assert(ret == 0);
     }
   }
@@ -128,13 +128,13 @@ constexpr void test_iterators() {
     // check that more than one element is counted
     {
       std::array a = {3, 3, 4, 3, 3};
-      auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 3);
+      auto ret     = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 3);
       assert(ret == 4);
     }
     {
       std::array a = {3, 3, 4, 3, 3};
-      auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
-      auto ret = std::ranges::count(range, 3);
+      auto range   = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+      auto ret     = std::ranges::count(range, 3);
       assert(ret == 4);
     }
   }
@@ -143,13 +143,13 @@ constexpr void test_iterators() {
     // check that all elements are counted
     {
       std::array a = {5, 5, 5, 5};
-      auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 5);
+      auto ret     = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 5);
       assert(ret == 4);
     }
     {
       std::array a = {5, 5, 5, 5};
-      auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
-      auto ret = std::ranges::count(range, 5);
+      auto range   = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+      auto ret     = std::ranges::count(range, 5);
       assert(ret == 4);
     }
   }
@@ -167,38 +167,46 @@ constexpr bool test() {
   {
     // check that projections are used properly and that they are called with the iterator directly
     {
-      int a[] = {1, 2, 3, 4};
+      int a[]  = {1, 2, 3, 4};
       auto ret = std::ranges::count(a, a + 4, a + 3, [](int& i) { return &i; });
       assert(ret == 1);
     }
     {
-      int a[] = {1, 2, 3, 4};
+      int a[]  = {1, 2, 3, 4};
       auto ret = std::ranges::count(a, a + 3, [](int& i) { return &i; });
       assert(ret == 1);
     }
   }
 
   {
     // check that std::invoke is used
-    struct S { int i; };
-    S a[] = { S{1}, S{3}, S{2} };
+    struct S {
+      int i;
+    };
+    S a[]                                 = {S{1}, S{3}, S{2}};
     std::same_as<std::ptrdiff_t> auto ret = std::ranges::count(a, 4, &S::i);
     assert(ret == 0);
   }
 
   {
     // count invocations of the projection
     {
-      int a[] = {1, 2, 3, 4};
+      int a[]              = {1, 2, 3, 4};
       int projection_count = 0;
-      auto ret = std::ranges::count(a, a + 4, 2, [&](int i) { ++projection_count; return i; });
+      auto ret             = std::ranges::count(a, a + 4, 2, [&](int i) {
+        ++projection_count;
+        return i;
+      });
       assert(ret == 1);
       assert(projection_count == 4);
     }
     {
-      int a[] = {1, 2, 3, 4};
+      int a[]              = {1, 2, 3, 4};
       int projection_count = 0;
-      auto ret = std::ranges::count(a, 2, [&](int i) { ++projection_count; return i; });
+      auto ret             = std::ranges::count(a, 2, [&](int i) {
+        ++projection_count;
+        return i;
+      });
       assert(ret == 1);
       assert(projection_count == 4);
     }
@@ -208,20 +216,20 @@ constexpr bool test() {
     // check that an immobile type works
     struct NonMovable {
       NonMovable(const NonMovable&) = delete;
-      NonMovable(NonMovable&&) = delete;
+      NonMovable(NonMovable&&)      = delete;
       constexpr NonMovable(int i_) : i(i_) {}
       int i;
 
       bool operator==(const NonMovable&) const = default;
     };
     {
       NonMovable a[] = {9, 8, 4, 3};
-      auto ret = std::ranges::count(a, a + 4, NonMovable(8));
+      auto ret       = std::ranges::count(a, a + 4, NonMovable(8));
       assert(ret == 1);
     }
     {
       NonMovable a[] = {9, 8, 4, 3};
-      auto ret = std::ranges::count(a, NonMovable(8));
+      auto ret       = std::ranges::count(a, NonMovable(8));
       assert(ret == 1);
     }
   }
@@ -230,15 +238,18 @@ constexpr bool test() {
     // check that difference_type is used
     struct DiffTypeIterator {
       using difference_type = signed char;
-      using value_type = int;
+      using value_type      = int;
 
       int* it = nullptr;
 
       constexpr DiffTypeIterator() = default;
       constexpr DiffTypeIterator(int* i) : it(i) {}
 
       constexpr int& operator*() const { return *it; }
-      constexpr DiffTypeIterator& operator++() { ++it; return *this; }
+      constexpr DiffTypeIterator& operator++() {
+        ++it;
+        return *this;
+      }
       constexpr void operator++(int) { ++it; }
 
       bool operator==(const DiffTypeIterator&) const = default;
@@ -251,7 +262,7 @@ constexpr bool test() {
       assert(ret == 1);
     }
     {
-      int a[] = {5, 5, 4, 3, 2, 1};
+      int a[]                                      = {5, 5, 4, 3, 2, 1};
       auto range = std::ranges::subrange(DiffTypeIterator(a), DiffTypeIterator(a + 6));
       std::same_as<signed char> decltype(auto) ret = std::ranges::count(range, 4);
       assert(ret == 1);
@@ -264,7 +275,9 @@ constexpr bool test() {
       for (size_t offset = 0; offset != 64; ++offset) {
         std::fill(vec.begin(), vec.end(), false);
         std::fill(vec.begin() + offset, vec.begin() + i + offset, true);
-        assert(std::ranges::count(vec.begin() + offset, vec.begin() + offset + 256, true) == i);
+
+        // check both (range) and (iterator, sentinel) overloads
+        assert(std::ranges::count(vec, true) == i);
         assert(std::ranges::count(vec.begin() + offset, vec.begin() + offset + 256, false) == 256 - i);
       }
     }
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp
@@ -14,6 +14,8 @@
 // MSVC warning C4389: '==': signed/unsigned mismatch
 // MSVC warning C4805: '==': unsafe mix of type 'char' and type 'bool' in operation
 // ADDITIONAL_COMPILE_FLAGS(cl-style-warnings): /wd4245 /wd4305 /wd4310 /wd4389 /wd4805
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=20000000
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-ops-limit): -fconstexpr-ops-limit=80000000
 
 // <algorithm>
 
@@ -24,6 +26,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cstddef>
 #include <deque>
 #include <vector>
 #include <type_traits>
@@ -225,6 +228,18 @@ TEST_CONSTEXPR_CXX20 bool test() {
 
   types::for_each(types::integral_types(), TestIntegerPromotions());
 
+  { // Test vector<bool>::iterator optimization
+    std::vector<bool> vec(256 + 8);
+    for (ptrdiff_t i = 8; i <= 256; i *= 2) {
+      for (size_t offset = 0; offset < 8; offset += 2) {
+        std::fill(vec.begin(), vec.end(), false);
+        std::fill(vec.begin() + offset, vec.begin() + i + offset, true);
+        assert(std::find(vec.begin(), vec.begin() + i + offset, true) == vec.begin() + offset);
+        assert(std::find(vec.begin() + offset, vec.end(), false) == vec.begin() + offset + i);
+      }
+    }
+  }
+
   return true;
 }
 
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find.pass.cpp

Original file line number	Diff line number	Diff line change
`@@ -67,13 +67,13 @@ constexpr void test_iterators() {`
`67`	`67`	`{`
`68`	`68`	`// simple test`
`69`	`69`	`{`
`70`		`- int a[] = {1, 2, 3, 4};`
	`70`	`+ int a[] = {1, 2, 3, 4};`
`71`	`71`	`std::same_as<std::ptrdiff_t> auto ret = std::ranges::count(It(a), Sent(It(a + 4)), 3);`
`72`	`72`	`assert(ret == 1);`
`73`	`73`	`}`
`74`	`74`	`{`
`75`		`- int a[] = {1, 2, 3, 4};`
`76`		`- auto range = std::ranges::subrange(It(a), Sent(It(a + 4)));`
	`75`	`+ int a[] = {1, 2, 3, 4};`
	`76`	`+ auto range = std::ranges::subrange(It(a), Sent(It(a + 4)));`
`77`	`77`	`std::same_as<std::ptrdiff_t> auto ret = std::ranges::count(range, 3);`
`78`	`78`	`assert(ret == 1);`
`79`	`79`	`}`
`@@ -83,13 +83,13 @@ constexpr void test_iterators() {`
`83`	`83`	`// check that an empty range works`
`84`	`84`	`{`
`85`	`85`	`std::array<int, 0> a = {};`
`86`		`- auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 1);`
	`86`	`+ auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 1);`
`87`	`87`	`assert(ret == 0);`
`88`	`88`	`}`
`89`	`89`	`{`
`90`	`90`	`std::array<int, 0> a = {};`
`91`		`- auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));`
`92`		`- auto ret = std::ranges::count(range, 1);`
	`91`	`+ auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));`
	`92`	`+ auto ret = std::ranges::count(range, 1);`
`93`	`93`	`assert(ret == 0);`
`94`	`94`	`}`
`95`	`95`	`}`
`@@ -98,13 +98,13 @@ constexpr void test_iterators() {`
`98`	`98`	`// check that a range with a single element works`
`99`	`99`	`{`
`100`	`100`	`std::array a = {2};`
`101`		`- auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 2);`
	`101`	`+ auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 2);`
`102`	`102`	`assert(ret == 1);`
`103`	`103`	`}`
`104`	`104`	`{`
`105`	`105`	`std::array a = {2};`
`106`		`- auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));`
`107`		`- auto ret = std::ranges::count(range, 2);`
	`106`	`+ auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));`
	`107`	`+ auto ret = std::ranges::count(range, 2);`
`108`	`108`	`assert(ret == 1);`
`109`	`109`	`}`
`110`	`110`	`}`
`@@ -113,13 +113,13 @@ constexpr void test_iterators() {`
`113`	`113`	`// check that 0 is returned with no match`
`114`	`114`	`{`
`115`	`115`	`std::array a = {1, 1, 1};`
`116`		`- auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 0);`
	`116`	`+ auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 0);`
`117`	`117`	`assert(ret == 0);`
`118`	`118`	`}`
`119`	`119`	`{`
`120`	`120`	`std::array a = {1, 1, 1};`
`121`		`- auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));`
`122`		`- auto ret = std::ranges::count(range, 0);`
	`121`	`+ auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));`
	`122`	`+ auto ret = std::ranges::count(range, 0);`
`123`	`123`	`assert(ret == 0);`
`124`	`124`	`}`
`125`	`125`	`}`
`@@ -128,13 +128,13 @@ constexpr void test_iterators() {`
`128`	`128`	`// check that more than one element is counted`
`129`	`129`	`{`
`130`	`130`	`std::array a = {3, 3, 4, 3, 3};`
`131`		`- auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 3);`
	`131`	`+ auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 3);`
`132`	`132`	`assert(ret == 4);`
`133`	`133`	`}`
`134`	`134`	`{`
`135`	`135`	`std::array a = {3, 3, 4, 3, 3};`
`136`		`- auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));`
`137`		`- auto ret = std::ranges::count(range, 3);`
	`136`	`+ auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));`
	`137`	`+ auto ret = std::ranges::count(range, 3);`
`138`	`138`	`assert(ret == 4);`
`139`	`139`	`}`
`140`	`140`	`}`
`@@ -143,13 +143,13 @@ constexpr void test_iterators() {`
`143`	`143`	`// check that all elements are counted`
`144`	`144`	`{`
`145`	`145`	`std::array a = {5, 5, 5, 5};`
`146`		`- auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 5);`
	`146`	`+ auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 5);`
`147`	`147`	`assert(ret == 4);`
`148`	`148`	`}`
`149`	`149`	`{`
`150`	`150`	`std::array a = {5, 5, 5, 5};`
`151`		`- auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));`
`152`		`- auto ret = std::ranges::count(range, 5);`
	`151`	`+ auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));`
	`152`	`+ auto ret = std::ranges::count(range, 5);`
`153`	`153`	`assert(ret == 4);`
`154`	`154`	`}`
`155`	`155`	`}`
`@@ -167,38 +167,46 @@ constexpr bool test() {`
`167`	`167`	`{`
`168`	`168`	`// check that projections are used properly and that they are called with the iterator directly`
`169`	`169`	`{`
`170`		`- int a[] = {1, 2, 3, 4};`
	`170`	`+ int a[] = {1, 2, 3, 4};`
`171`	`171`	`auto ret = std::ranges::count(a, a + 4, a + 3, [](int& i) { return &i; });`
`172`	`172`	`assert(ret == 1);`
`173`	`173`	`}`
`174`	`174`	`{`
`175`		`- int a[] = {1, 2, 3, 4};`
	`175`	`+ int a[] = {1, 2, 3, 4};`
`176`	`176`	`auto ret = std::ranges::count(a, a + 3, [](int& i) { return &i; });`
`177`	`177`	`assert(ret == 1);`
`178`	`178`	`}`
`179`	`179`	`}`
`180`	`180`
`181`	`181`	`{`
`182`	`182`	`// check that std::invoke is used`
`183`		`- struct S { int i; };`
`184`		`- S a[] = { S{1}, S{3}, S{2} };`
	`183`	`+ struct S {`
	`184`	`+ int i;`
	`185`	`+ };`
	`186`	`+ S a[] = {S{1}, S{3}, S{2}};`
`185`	`187`	`std::same_as<std::ptrdiff_t> auto ret = std::ranges::count(a, 4, &S::i);`
`186`	`188`	`assert(ret == 0);`
`187`	`189`	`}`
`188`	`190`
`189`	`191`	`{`
`190`	`192`	`// count invocations of the projection`
`191`	`193`	`{`
`192`		`- int a[] = {1, 2, 3, 4};`
	`194`	`+ int a[] = {1, 2, 3, 4};`
`193`	`195`	`int projection_count = 0;`
`194`		`- auto ret = std::ranges::count(a, a + 4, 2, [&](int i) { ++projection_count; return i; });`
	`196`	`+ auto ret = std::ranges::count(a, a + 4, 2, [&](int i) {`
	`197`	`+ ++projection_count;`
	`198`	`+ return i;`
	`199`	`+ });`
`195`	`200`	`assert(ret == 1);`
`196`	`201`	`assert(projection_count == 4);`
`197`	`202`	`}`
`198`	`203`	`{`
`199`		`- int a[] = {1, 2, 3, 4};`
	`204`	`+ int a[] = {1, 2, 3, 4};`
`200`	`205`	`int projection_count = 0;`
`201`		`- auto ret = std::ranges::count(a, 2, [&](int i) { ++projection_count; return i; });`
	`206`	`+ auto ret = std::ranges::count(a, 2, [&](int i) {`
	`207`	`+ ++projection_count;`
	`208`	`+ return i;`
	`209`	`+ });`
`202`	`210`	`assert(ret == 1);`
`203`	`211`	`assert(projection_count == 4);`
`204`	`212`	`}`
`@@ -208,20 +216,20 @@ constexpr bool test() {`
`208`	`216`	`// check that an immobile type works`
`209`	`217`	`struct NonMovable {`
`210`	`218`	`NonMovable(const NonMovable&) = delete;`
`211`		`- NonMovable(NonMovable&&) = delete;`
	`219`	`+ NonMovable(NonMovable&&) = delete;`
`212`	`220`	`constexpr NonMovable(int i_) : i(i_) {}`
`213`	`221`	`int i;`
`214`	`222`
`215`	`223`	`bool operator==(const NonMovable&) const = default;`
`216`	`224`	`};`
`217`	`225`	`{`
`218`	`226`	`NonMovable a[] = {9, 8, 4, 3};`
`219`		`- auto ret = std::ranges::count(a, a + 4, NonMovable(8));`
	`227`	`+ auto ret = std::ranges::count(a, a + 4, NonMovable(8));`
`220`	`228`	`assert(ret == 1);`
`221`	`229`	`}`
`222`	`230`	`{`
`223`	`231`	`NonMovable a[] = {9, 8, 4, 3};`
`224`		`- auto ret = std::ranges::count(a, NonMovable(8));`
	`232`	`+ auto ret = std::ranges::count(a, NonMovable(8));`
`225`	`233`	`assert(ret == 1);`
`226`	`234`	`}`
`227`	`235`	`}`
`@@ -230,15 +238,18 @@ constexpr bool test() {`
`230`	`238`	`// check that difference_type is used`
`231`	`239`	`struct DiffTypeIterator {`
`232`	`240`	`using difference_type = signed char;`
`233`		`- using value_type = int;`
	`241`	`+ using value_type = int;`
`234`	`242`
`235`	`243`	`int* it = nullptr;`
`236`	`244`
`237`	`245`	`constexpr DiffTypeIterator() = default;`
`238`	`246`	`constexpr DiffTypeIterator(int* i) : it(i) {}`
`239`	`247`
`240`	`248`	`constexpr int& operator() const { return it; }`
`241`		`- constexpr DiffTypeIterator& operator++() { ++it; return *this; }`
	`249`	`+ constexpr DiffTypeIterator& operator++() {`
	`250`	`+ ++it;`
	`251`	`+ return *this;`
	`252`	`+ }`
`242`	`253`	`constexpr void operator++(int) { ++it; }`
`243`	`254`
`244`	`255`	`bool operator==(const DiffTypeIterator&) const = default;`
`@@ -251,7 +262,7 @@ constexpr bool test() {`
`251`	`262`	`assert(ret == 1);`
`252`	`263`	`}`
`253`	`264`	`{`
`254`		`- int a[] = {5, 5, 4, 3, 2, 1};`
	`265`	`+ int a[] = {5, 5, 4, 3, 2, 1};`
`255`	`266`	`auto range = std::ranges::subrange(DiffTypeIterator(a), DiffTypeIterator(a + 6));`
`256`	`267`	`std::same_as<signed char> decltype(auto) ret = std::ranges::count(range, 4);`
`257`	`268`	`assert(ret == 1);`
`@@ -264,7 +275,9 @@ constexpr bool test() {`
`264`	`275`	`for (size_t offset = 0; offset != 64; ++offset) {`
`265`	`276`	`std::fill(vec.begin(), vec.end(), false);`
`266`	`277`	`std::fill(vec.begin() + offset, vec.begin() + i + offset, true);`
`267`		`- assert(std::ranges::count(vec.begin() + offset, vec.begin() + offset + 256, true) == i);`
	`278`	`+`
	`279`	`+ // check both (range) and (iterator, sentinel) overloads`
	`280`	`+ assert(std::ranges::count(vec, true) == i);`
`268`	`281`	`assert(std::ranges::count(vec.begin() + offset, vec.begin() + offset + 256, false) == 256 - i);`
`269`	`282`	`}`
`270`	`283`	`}`