review

Author: huixie90

libcxx/test/std/ranges/range.adaptors/range.zip.transform/begin.pass.cpp

@@ -42,8 +42,63 @@ constexpr bool test() {
   }
 
   {
-    // with empty range
-    std::ranges::zip_transform_view v(MakeTuple{}, SimpleCommon{buffer}, std::ranges::empty_view<int>());
+    // one range
+    std::ranges::zip_transform_view v(MakeTuple{}, SimpleCommon{buffer});
+    auto it = v.begin();
+    assert(*it == std::make_tuple(1));
+    auto cit = std::as_const(v).begin();
+    assert(*cit == std::make_tuple(1));
+  }
+
+  {
+    // two ranges
+    std::ranges::zip_transform_view v(GetFirst{}, SimpleCommon{buffer}, std::views::iota(0));
+    auto it = v.begin();
+    assert(&*it == &buffer[0]);
+    auto cit = std::as_const(v).begin();
+    assert(&*cit == &buffer[0]);
+  }
+
+  {
+    // three ranges
+    std::ranges::zip_transform_view v(Tie{}, SimpleCommon{buffer}, SimpleCommon{buffer}, std::ranges::single_view(2.));
+    auto it = v.begin();
+    assert(&std::get<0>(*it) == &buffer[0]);
+    assert(&std::get<1>(*it) == &buffer[0]);
+    assert(std::get<2>(*it) == 2.0);
+    auto cit = std::as_const(v).begin();
+    assert(&std::get<0>(*cit) == &buffer[0]);
+    assert(&std::get<1>(*cit) == &buffer[0]);
+    assert(std::get<2>(*cit) == 2.0);
+  }
+
+  {
+    // single empty range
+    std::ranges::zip_transform_view v(MakeTuple{}, std::ranges::empty_view<int>());
+    assert(v.begin() == v.end());
+    assert(std::as_const(v).begin() == std::as_const(v).end());
+  }
+
+  {
+    // empty range at the beginning
+    std::ranges::zip_transform_view v(
+        MakeTuple{}, std::ranges::empty_view<int>(), SimpleCommon{buffer}, SimpleCommon{buffer});
+    assert(v.begin() == v.end());
+    assert(std::as_const(v).begin() == std::as_const(v).end());
+  }
+
+  {
+    // empty range in the middle
+    std::ranges::zip_transform_view v(
+        MakeTuple{}, SimpleCommon{buffer}, std::ranges::empty_view<int>(), SimpleCommon{buffer});
+    assert(v.begin() == v.end());
+    assert(std::as_const(v).begin() == std::as_const(v).end());
+  }
+
+  {
+    // empty range at the end
+    std::ranges::zip_transform_view v(
+        MakeTuple{}, SimpleCommon{buffer}, SimpleCommon{buffer}, std::ranges::empty_view<int>());
     assert(v.begin() == v.end());
     assert(std::as_const(v).begin() == std::as_const(v).end());
   }

libcxx/test/std/ranges/range.adaptors/range.zip.transform/cpo.pass.cpp

@@ -17,6 +17,9 @@
 #include <cassert>
 #include <functional>
 #include <type_traits>
+#include <vector>
+
+#include "types.h"
 
 struct NotMoveConstructible {
   NotMoveConstructible()                       = default;
@@ -99,6 +102,52 @@ constexpr bool test() {
     static_assert(std::is_same_v<std::ranges::range_reference_t<decltype(v)>, int&>);
   }
 
+  int buffer[] = {1, 2, 3};
+  {
+    // one range
+    auto v = std::views::zip_transform(MakeTuple{}, SimpleCommon{buffer});
+    assert(std::ranges::equal(v, std::vector{std::tuple(1), std::tuple(2), std::tuple(3)}));
+  }
+
+  {
+    // two ranges
+    auto v = std::views::zip_transform(GetFirst{}, SimpleCommon{buffer}, std::views::iota(0));
+    assert(std::ranges::equal(v, std::vector{1, 2, 3}));
+  }
+
+  {
+    // three ranges
+    auto v = std::views::zip_transform(Tie{}, SimpleCommon{buffer}, SimpleCommon{buffer}, std::ranges::single_view(2.));
+    assert(std::ranges::equal(v, std::vector{std::tuple(1, 1, 2.0)}));
+  }
+
+  {
+    // single empty range
+    auto v = std::views::zip_transform(MakeTuple{}, std::ranges::empty_view<int>());
+    assert(std::ranges::empty(v));
+  }
+
+  {
+    // empty range at the beginning
+    auto v = std::views::zip_transform(
+        MakeTuple{}, std::ranges::empty_view<int>(), SimpleCommon{buffer}, SimpleCommon{buffer});
+    assert(std::ranges::empty(v));
+  }
+
+  {
+    // empty range in the middle
+    auto v = std::views::zip_transform(
+        MakeTuple{}, SimpleCommon{buffer}, std::ranges::empty_view<int>(), SimpleCommon{buffer});
+    assert(std::ranges::empty(v));
+  }
+
+  {
+    // empty range at the end
+    auto v = std::views::zip_transform(
+        MakeTuple{}, SimpleCommon{buffer}, SimpleCommon{buffer}, std::ranges::empty_view<int>());
+    assert(std::ranges::empty(v));
+  }
+
   return true;
 }
 

libcxx/test/std/ranges/range.adaptors/range.zip.transform/ctor.default.pass.cpp

@@ -15,6 +15,8 @@
 #include <cassert>
 #include <type_traits>
 
+#include "types.h"
+
 constexpr int buff[] = {1, 2, 3};
 
 struct DefaultConstructibleView : std::ranges::view_base {
@@ -74,6 +76,66 @@ constexpr bool test() {
     assert(*it == 6);
   }
 
+  {
+    // one range
+    using View = std::ranges::zip_transform_view<MakeTuple, DefaultConstructibleView>;
+    View v     = View(); // the default constructor is not explicit
+    auto it    = v.begin();
+    assert(*it == std::make_tuple(1));
+  }
+
+  {
+    // two ranges
+    using View = std::ranges::zip_transform_view<MakeTuple, DefaultConstructibleView, std::ranges::iota_view<int>>;
+    View v     = View(); // the default constructor is not explicit
+    auto it    = v.begin();
+    assert(*it == std::tuple(1, 0));
+  }
+
+  {
+    // three ranges
+    using View = std::ranges::
+        zip_transform_view<MakeTuple, DefaultConstructibleView, DefaultConstructibleView, std::ranges::iota_view<int>>;
+    View v  = View(); // the default constructor is not explicit
+    auto it = v.begin();
+    assert(*it == std::tuple(1, 1, 0));
+  }
+
+  {
+    // single empty range
+    std::ranges::zip_transform_view v(MakeTuple{}, std::ranges::empty_view<int>());
+    assert(v.begin() == v.end());
+    assert(std::as_const(v).begin() == std::as_const(v).end());
+  }
+
+  {
+    // empty range at the beginning
+    using View = std::ranges::
+        zip_transform_view<MakeTuple, std::ranges::empty_view<int>, DefaultConstructibleView, DefaultConstructibleView>;
+    View v = View(); // the default constructor is not explicit
+    assert(v.empty());
+  }
+
+  {
+    // empty range in the middle
+    using View =
+        std::ranges::zip_transform_view<MakeTuple,
+                                        DefaultConstructibleView,
+                                        std::ranges::empty_view<int>,
+                                        DefaultConstructibleView,
+                                        DefaultConstructibleView>;
+    View v = View(); // the default constructor is not explicit
+    assert(v.empty());
+  }
+
+  {
+    // empty range at the end
+    using View = std::ranges::
+        zip_transform_view<MakeTuple, DefaultConstructibleView, DefaultConstructibleView, std::ranges::empty_view<int>>;
+    View v = View(); // the default constructor is not explicit
+    assert(v.empty());
+  }
+
   return true;
 }
 

libcxx/test/std/ranges/range.adaptors/range.zip.transform/ctor.views.pass.cpp

@@ -10,7 +10,9 @@
 
 // constexpr explicit zip_transform_view(F, Views...)
 
+#include <algorithm>
 #include <ranges>
+#include <vector>
 
 #include "types.h"
 
@@ -53,6 +55,50 @@ constexpr bool test() {
   int buffer[8]  = {1, 2, 3, 4, 5, 6, 7, 8};
   int buffer2[4] = {9, 8, 7, 6};
 
+  {
+    // one range
+    std::ranges::zip_transform_view v(MakeTuple{}, SimpleCommon{buffer2});
+    assert(std::ranges::equal(v, std::vector{std::tuple(9), std::tuple(8), std::tuple(7), std::tuple(6)}));
+  }
+
+  {
+    // two ranges
+    std::ranges::zip_transform_view v(GetFirst{}, SimpleCommon{buffer}, std::views::iota(0));
+    assert(std::ranges::equal(v, std::vector{1, 2, 3, 4, 5, 6, 7, 8}));
+  }
+
+  {
+    // three ranges
+    std::ranges::zip_transform_view v(Tie{}, SimpleCommon{buffer}, SimpleCommon{buffer2}, std::ranges::single_view(2.));
+    assert(std::ranges::equal(v, std::vector{std::tuple(1, 9, 2.0)}));
+  }
+
+  {
+    // single empty range
+    std::ranges::zip_transform_view v(MakeTuple{}, std::ranges::empty_view<int>());
+    assert(std::ranges::empty(v));
+  }
+
+  {
+    // empty range at the beginning
+    std::ranges::zip_transform_view v(
+        MakeTuple{}, std::ranges::empty_view<int>(), SimpleCommon{buffer}, SimpleCommon{buffer});
+    assert(std::ranges::empty(v));
+  }
+
+  {
+    // empty range in the middle
+    std::ranges::zip_transform_view v(
+        MakeTuple{}, SimpleCommon{buffer}, std::ranges::empty_view<int>(), SimpleCommon{buffer});
+    assert(std::ranges::empty(v));
+  }
+
+  {
+    // empty range at the end
+    std::ranges::zip_transform_view v(
+        MakeTuple{}, SimpleCommon{buffer}, SimpleCommon{buffer}, std::ranges::empty_view<int>());
+    assert(std::ranges::empty(v));
+  }
   {
     // constructor from views
     std::ranges::zip_transform_view v(

libcxx/test/std/ranges/range.adaptors/range.zip.transform/end.pass.cpp

@@ -36,8 +36,56 @@ constexpr bool test() {
   }
 
   {
-    // with empty range
-    std::ranges::zip_transform_view v(MakeTuple{}, SimpleCommon{buffer}, std::ranges::empty_view<int>());
+    // one range
+    std::ranges::zip_transform_view v(MakeTuple{}, SimpleCommon{buffer});
+    auto it = v.begin();
+    assert( it + 8 == v.end());
+    assert( it + 8 == std::as_const(v).end());
+  }
+
+  {
+    // two ranges
+    std::ranges::zip_transform_view v(GetFirst{}, SimpleCommon{buffer}, std::views::iota(0));
+    auto it = v.begin();
+    assert( it + 8 == v.end());
+    assert( it + 8 == std::as_const(v).end());
+  }
+
+  {
+    // three ranges
+    std::ranges::zip_transform_view v(Tie{}, SimpleCommon{buffer}, SimpleCommon{buffer}, std::ranges::single_view(2.));
+    auto it = v.begin();
+    assert( it + 1 == v.end());
+    assert( it + 1 == std::as_const(v).end());
+  }
+
+  {
+    // single empty range
+    std::ranges::zip_transform_view v(MakeTuple{}, std::ranges::empty_view<int>());
+    assert(v.begin() == v.end());
+    assert(std::as_const(v).begin() == std::as_const(v).end());
+  }
+
+  {
+    // empty range at the beginning
+    std::ranges::zip_transform_view v(
+        MakeTuple{}, std::ranges::empty_view<int>(), SimpleCommon{buffer}, SimpleCommon{buffer});
+    assert(v.begin() == v.end());
+    assert(std::as_const(v).begin() == std::as_const(v).end());
+  }
+
+  {
+    // empty range in the middle
+    std::ranges::zip_transform_view v(
+        MakeTuple{}, SimpleCommon{buffer}, std::ranges::empty_view<int>(), SimpleCommon{buffer});
+    assert(v.begin() == v.end());
+    assert(std::as_const(v).begin() == std::as_const(v).end());
+  }
+
+  {
+    // empty range at the end
+    std::ranges::zip_transform_view v(
+        MakeTuple{}, SimpleCommon{buffer}, SimpleCommon{buffer}, std::ranges::empty_view<int>());
     assert(v.begin() == v.end());
     assert(std::as_const(v).begin() == std::as_const(v).end());
   }