some updates

Author: changkhothuychung

a.log

@@ -0,0 +1,7 @@
+-- Testing: 1 tests, 1 workers --
+PASS: llvm-libc++-shared.cfg.in :: libcxx/ranges/range.adaptors/range.concat/iterator.valueless_by_exception.pass.cpp (1 of 1)
+
+Testing Time: 4.15s
+
+Total Discovered Tests: 1
+  Passed: 1 (100.00%)

libcxx/include/__ranges/concat_view.h

@@ -336,7 +336,7 @@ class concat_view<_Views...>::__iterator {
 
   _LIBCPP_HIDE_FROM_ABI constexpr __iterator(__iterator<!_Const> __i)
     requires _Const && (convertible_to<iterator_t<_Views>, iterator_t<const _Views>> && ...)
-      : __it_([&__src = __i.it_]<size_t... _Indices>(size_t __idx, index_sequence<_Indices...>) -> __base_iter {
+      : __it_([&__src = __i.__it_]<size_t... _Indices>(size_t __idx, index_sequence<_Indices...>) -> __base_iter {
           _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
               !__src.valueless_by_exception(), "Trying to convert from a valueless iterator of concat_view.");
           using __src_lref          = decltype((__src));
@@ -345,7 +345,7 @@ class concat_view<_Views...>::__iterator {
             return __base_iter(in_place_index<_Indices>, std::__unchecked_get<_Indices>(std::move(__src_var)));
           }...};
           return __vtable[__idx](__src);
-        }(__i.index(), make_index_sequence<variant_size_v<__base_iter>>{})),
+        }(__i.__it_.index(), make_index_sequence<variant_size_v<__base_iter>>{})),
         __parent_(__i.parent_) {}
 
   _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const {

libcxx/test/libcxx/ranges/range.adaptors/range.concat/iterator.valueless_by_exception.pass.cpp

@@ -7,56 +7,141 @@
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: std-at-least-c++26
-// UNSUPPORTED: libcpp-hardening-mode=none, no-exceptions
+// UNSUPPORTED: no-exceptions
 
+#include <iostream>
 #include <ranges>
 #include <utility>
+#include <vector>
 
 #include "check_assertion.h"
+#include "double_move_tracker.h"
+#include "test_iterators.h"
 
 int globalArray[8] = {0, 1, 2, 3, 4, 5, 6, 7};
 
-struct ThrowOnCopyView : std::ranges::view_base {
-  int start_;
-  int* ptr_;
-  constexpr explicit ThrowOnCopyView(int* ptr = globalArray, int start = 0) : start_(start), ptr_(ptr) {}
-  constexpr ThrowOnCopyView(ThrowOnCopyView&&) = default;
-  constexpr ThrowOnCopyView(const ThrowOnCopyView&) { throw 42; };
-  constexpr ThrowOnCopyView& operator=(ThrowOnCopyView&&) = default;
-  constexpr ThrowOnCopyView& operator=(const ThrowOnCopyView&) {
-    throw 42;
-    return *this;
-  };
-  constexpr int* begin() const { return ptr_ + start_; }
-  constexpr int* end() const { return ptr_ + 8; }
+
+template <class It, class ItTraits = It >
+class ThrowOnMoveIterator
+{
+    typedef std::iterator_traits<ItTraits> Traits;
+    It it_;
+    support::double_move_tracker tracker_;
+    bool moved = false; 
+
+    template <class U, class T> friend class ThrowOnMoveIterator;
+public:
+    typedef          std::input_iterator_tag                   iterator_category;
+    typedef typename Traits::value_type                        value_type;
+    typedef typename Traits::difference_type                   difference_type;
+    typedef It                                                 pointer;
+    typedef typename Traits::reference                         reference;
+
+    constexpr ThrowOnMoveIterator() {}
+
+    constexpr ThrowOnMoveIterator(It it) : it_(it) {}
+
+    template <class U, class T>
+    constexpr ThrowOnMoveIterator(const ThrowOnMoveIterator<U, T>& u) : it_(u.it_), tracker_(u.tracker_), moved(u.moved) {}
+
+    constexpr ThrowOnMoveIterator(const ThrowOnMoveIterator& other): moved(other.moved){}
+
+    constexpr ThrowOnMoveIterator(ThrowOnMoveIterator&& other){
+      throw std::runtime_error("Move failed in iter");
+      other.moved = true;
+      moved = other.moved;
+    }
+
+    ThrowOnMoveIterator& operator=(ThrowOnMoveIterator&& other) {
+        if (other.moved) {
+            throw std::runtime_error("Move assignment failed in iter");
+        }
+        other.moved = true;
+        moved = other.moved;
+        return *this;
+    }
+
+    constexpr reference operator*() const {return *it_;}
+
+    constexpr ThrowOnMoveIterator& operator++() {++it_; return *this;}
+    constexpr ThrowOnMoveIterator operator++(int) {return ThrowOnMoveIterator(it_++);}
+
+    friend constexpr bool operator==(const ThrowOnMoveIterator& x, const ThrowOnMoveIterator& y) {return x.it_ == y.it_;}
+    friend constexpr bool operator!=(const ThrowOnMoveIterator& x, const ThrowOnMoveIterator& y) {return x.it_ != y.it_;}
+
+    friend constexpr It base(const ThrowOnMoveIterator& i) { return i.it_; }
+
+    template <class T>
+    void operator,(T const &) = delete;
+};
+
+template <class T>
+struct BufferView : std::ranges::view_base {
+  T* buffer_;
+  std::size_t size_;
+
+  template <std::size_t N>
+  constexpr BufferView(T (&b)[N]) : buffer_(b), size_(N) {}
+};
+
+using IntBufferView = BufferView<int>;
+
+template <bool Simple>
+struct Common :  IntBufferView {
+  using IntBufferView::IntBufferView;
+  using Iter = ThrowOnMoveIterator<int*>; 
+  using ConstIter = ThrowOnMoveIterator<const int*>; 
+  using Sent = sentinel_wrapper<Iter>; 
+  using ConstSent = sentinel_wrapper<ConstIter>; 
+
+  constexpr Iter begin()
+    requires(!Simple)
+  {
+    return Iter{buffer_};
+  }
+  constexpr const ConstIter begin() const { return ConstIter{buffer_}; }
+  constexpr Sent end()
+    requires(!Simple)
+  {
+    return Sent(buffer_ + size_);
+  }
+  constexpr ConstSent end() const { return ConstSent(buffer_ + size_); }
 };
 
+using SimpleCommon = Common<true>;
+using NonSimpleCommon = Common<false>;
+
 int main() {
+
   {
-    //valueless by exception test constructor
-    std::ranges::concat_view<ThrowOnCopyView> concatView_2;
-    std::ranges::iterator_t<std::ranges::concat_view<ThrowOnCopyView>> it1;
-    std::ranges::iterator_t<std::ranges::concat_view<ThrowOnCopyView>> it2;
+    int buffer[3] = {1, 2, 3};
+    int buffer2[3] = {1, 2, 3};
+    NonSimpleCommon view(buffer); 
+    NonSimpleCommon view2(buffer2); 
+    std::ranges::concat_view v(view, view2);
+    std::ranges::iterator_t<std::ranges::concat_view<decltype(view), decltype(view2)>> it1;
     try {
-      it1 = concatView_2.begin();
+      it1 = v.begin();
     } catch (...) {
       TEST_LIBCPP_ASSERT_FAILURE(
-          [&] {
-            it2 = it1;
+          [=] {
+            std::ranges::iterator_t<const decltype(v)> it2(v.begin());
             (void)it2;
           }(),
           "valueless by exception");
     }
   }
-
+/*
   {
     //valueless by exception test operator==
-    std::ranges::concat_view<ThrowOnCopyView> concatView_2;
-    std::ranges::iterator_t<std::ranges::concat_view<ThrowOnCopyView>> it1;
-    std::ranges::iterator_t<std::ranges::concat_view<ThrowOnCopyView>> it2;
+    ThrowingRange<int*> throwing{3, 5};
+    auto concatView_2 = std::views::concat(throwing);
+    decltype(concatView_2.begin()) it1{};
+    decltype(concatView_2.begin()) it2{};
     try {
       it1 = concatView_2.begin();
     } catch (...) {
+      std::cout << "Catch is hit" << std::endl;
       TEST_LIBCPP_ASSERT_FAILURE([&] { (void)(it1 == it2); }(), "valueless by exception");
     }
   }
@@ -68,6 +153,7 @@ int main() {
     try {
       it1 = concatView_2.begin();
     } catch (...) {
+      std::cout << "Catch is hit" << std::endl;
       TEST_LIBCPP_ASSERT_FAILURE([&] { (void)--*it1; }(), "valueless by exception");
     }
   }
@@ -79,6 +165,7 @@ int main() {
     try {
       it1 = concatView_2.begin();
     } catch (...) {
+      std::cout << "Catch is hit" << std::endl;
       TEST_LIBCPP_ASSERT_FAILURE([&] { (void)*it1; }(), "valueless by exception");
     }
   }
@@ -90,6 +177,7 @@ int main() {
     try {
       it1 = concatView_2.begin();
     } catch (...) {
+      std::cout << "Catch is hit" << std::endl;
       TEST_LIBCPP_ASSERT_FAILURE([&] { (void)++*it1; }(), "valueless by exception");
     }
   }
@@ -101,7 +189,9 @@ int main() {
     try {
       it1 = concatView_2.begin();
     } catch (...) {
+      std::cout << "Catch is hit" << std::endl;
       TEST_LIBCPP_ASSERT_FAILURE([&] { (void)(it1 += 1); }(), "valueless by exception");
     }
   }
+  */
 }