From fcce3e17d4b3ca027f15a79d2f6fee143a772b0c Mon Sep 17 00:00:00 2001
From: Hartmut Kaiser <hartmut.kaiser@gmail.com>
Date: Fri, 28 Apr 2023 13:38:25 -0500
Subject: [PATCH] Adding tests for array iteration

---
 library/include/chplx/adapt_array.hpp     |   2 +-
 library/include/chplx/array.hpp           |  22 ++-
 library/include/chplx/coforall_loop.hpp   |   4 +-
 library/include/chplx/for_loop.hpp        |   8 +
 library/include/chplx/write.hpp           |   6 +
 library/test/unit/CMakeLists.txt          |   3 +
 library/test/unit/coforall_loop_array.cpp | 222 ++++++++++++++++++++++
 library/test/unit/for_loop_array.cpp      | 211 ++++++++++++++++++++
 library/test/unit/forall_loop_array.cpp   | 219 +++++++++++++++++++++
 9 files changed, 691 insertions(+), 6 deletions(-)
 create mode 100644 library/test/unit/coforall_loop_array.cpp
 create mode 100644 library/test/unit/for_loop_array.cpp
 create mode 100644 library/test/unit/forall_loop_array.cpp

diff --git a/library/include/chplx/adapt_array.hpp b/library/include/chplx/adapt_array.hpp
index 5ae4bb57..b666e626 100644
--- a/library/include/chplx/adapt_array.hpp
+++ b/library/include/chplx/adapt_array.hpp
@@ -20,7 +20,7 @@ namespace chplx {
 //-----------------------------------------------------------------------------
 // 1D iteration support
 template <typename T, typename Domain>
-hpx::generator<T> iterate(
+hpx::generator<T&, T> iterate(
     detail::IteratorGenerator<Array<T, Domain>> a) noexcept {
 
   auto size = a.size;
diff --git a/library/include/chplx/array.hpp b/library/include/chplx/array.hpp
index e61f6755..d9bc0cf1 100644
--- a/library/include/chplx/array.hpp
+++ b/library/include/chplx/array.hpp
@@ -28,15 +28,15 @@ template <typename T, typename Domain> class Array {
 public:
   static constexpr int rank = Domain::rank();
   static constexpr bool Stridable = Domain::stridable();
+
   using idxType = typename Domain::idxType;
+  using indexType = typename Domain::indexType;
+  using indicesType = typename Domain::indicesType;
 
 private:
   using arrayHandle =
       domains::BaseRectangularArray<T, rank, idxType, Stridable>;
 
-  using indexType = typename Domain::indexType;
-  using indicesType = typename Domain::indicesType;
-
 public:
   Array() = default;
 
@@ -156,6 +156,22 @@ template <typename T, typename Domain> class Array {
     return array->dsiGetBaseDomain()->dsiDim(i);
   }
 
+  // Returns an integer representing the zero-based ordinal value of ind within
+  // the domain's sequence of values if it is a member of the sequence.
+  // Otherwise, returns -1. The indexOrder procedure is the reverse of
+  // orderToIndex.
+  [[nodiscard]] constexpr std::int64_t
+  indexOrder(indexType idx) const noexcept {
+    return array->dsiGetBaseDomain()->dsiIndexOrder(idx);
+  }
+
+  // Returns the zero-based ord-th element of this domain's represented
+  // sequence. The orderToIndex procedure is the reverse of indexOrder.
+  [[nodiscard]] constexpr indexType
+  orderToIndex(std::int64_t order) const noexcept {
+    return array->dsiGetBaseDomain()->dsiOrderToIndex(order);
+  }
+
   // return the location of this array instance
   chplx::locale locale = chplx::here;
 
diff --git a/library/include/chplx/coforall_loop.hpp b/library/include/chplx/coforall_loop.hpp
index 6de2f83d..ec9f2df6 100644
--- a/library/include/chplx/coforall_loop.hpp
+++ b/library/include/chplx/coforall_loop.hpp
@@ -159,7 +159,7 @@ void coforall(detail::ZipRange<Rs...> const &zr, F &&f, Args &&...args) {
 }
 
 //-----------------------------------------------------------------------------
-// forall loop for aray iteration
+// forall loop for array iteration
 template <typename T, typename Domain, typename F, typename... Args>
 void coforall(Array<T, Domain> const &a, F &&f, Args &&...args) {
 
@@ -170,7 +170,7 @@ void coforall(Array<T, Domain> const &a, F &&f, Args &&...args) {
   hpx::wait_all(hpx::parallel::execution::bulk_async_execute(
       policy.executor(),
       [&](std::size_t idx, auto &&...fargs) {
-        return f(a.orderToIndex(idx), std::forward<decltype(args)>(fargs)...);
+        return f(a(idx), std::forward<decltype(args)>(fargs)...);
       },
       a.size(),
       detail::task_intent<std::decay_t<Args>>::call(
diff --git a/library/include/chplx/for_loop.hpp b/library/include/chplx/for_loop.hpp
index ab48b0e8..776b773d 100644
--- a/library/include/chplx/for_loop.hpp
+++ b/library/include/chplx/for_loop.hpp
@@ -104,4 +104,12 @@ void forLoop(Array<T, Domain> const &a, F &&f) {
   }
 }
 
+template <typename T, typename Domain, typename F>
+void forLoop(Array<T, Domain> &a, F &&f) {
+
+  for (auto &e : a.these()) {
+    f(e);
+  }
+}
+
 } // namespace chplx
diff --git a/library/include/chplx/write.hpp b/library/include/chplx/write.hpp
index 9c0186d6..57015681 100644
--- a/library/include/chplx/write.hpp
+++ b/library/include/chplx/write.hpp
@@ -11,6 +11,7 @@
 
 namespace chplx {
 
+//-----------------------------------------------------------------------------
 template <typename T> void write_one(std::ostream &os, T &&t) { os << t; }
 
 template <typename... Ts> void write(std::ostream &os, Ts &&...ts) {
@@ -22,6 +23,9 @@ template <typename... Ts> void writeln(std::ostream &os, Ts &&...ts) {
   os << "\n";
 }
 
+inline void writeln(std::ostream &os) { os << "\n"; }
+
+//-----------------------------------------------------------------------------
 template <typename T, typename... Ts>
   requires(!std::is_convertible_v<std::decay_t<T> &, std::ostream &>)
 void write(T &&t, Ts &&...ts) {
@@ -34,4 +38,6 @@ void writeln(T &&t, Ts &&...ts) {
   writeln(std::cout, std::forward<T>(t), std::forward<Ts>(ts)...);
 }
 
+inline void writeln() { writeln(std::cout); }
+
 } // namespace chplx
diff --git a/library/test/unit/CMakeLists.txt b/library/test/unit/CMakeLists.txt
index 15486ab8..7bbf42d3 100644
--- a/library/test/unit/CMakeLists.txt
+++ b/library/test/unit/CMakeLists.txt
@@ -11,17 +11,20 @@ set(tests
     atomic
     begin
     cobegin
+    coforall_loop_array
     coforall_loop_assoc_domain
     coforall_loop_domain
     coforall_loop_range
     coforall_loop_tuple
     coforall_loop_zip
     domain
+    forall_loop_array
     forall_loop_assoc_domain
     forall_loop_domain
     forall_loop_range
     forall_loop_tuple
     forall_loop_zip
+    for_loop_array
     for_loop_assoc_domain
     for_loop_domain
     for_loop_range
diff --git a/library/test/unit/coforall_loop_array.cpp b/library/test/unit/coforall_loop_array.cpp
new file mode 100644
index 00000000..d069eb87
--- /dev/null
+++ b/library/test/unit/coforall_loop_array.cpp
@@ -0,0 +1,222 @@
+//  Copyright (c) 2023 Hartmut Kaiser
+//
+//  SPDX-License-Identifier: BSL-1.0
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <chplx.hpp>
+
+#include <hpx/hpx_main.hpp>
+#include <hpx/modules/testing.hpp>
+#include <hpx/thread.hpp>
+
+#include <cstddef>
+#include <mutex>
+#include <set>
+
+template <typename T, typename Domain>
+void testCoforallLoopArray(chplx::Array<T, Domain> d) {
+
+  std::set<T> values;
+  hpx::mutex mtx;
+
+  std::size_t count = 0;
+
+  chplx::coforall(
+      d,
+      [&](auto &value, int fortytwo) {
+        HPX_TEST_EQ(fortytwo, 42);
+        std::lock_guard l(mtx);
+        ++count;
+        auto p = values.insert(value);
+        HPX_TEST(p.second);
+      },
+      42);
+
+  HPX_TEST_EQ(count, static_cast<std::size_t>(d.size()));
+  count = 0;
+
+  for (auto val : d.these()) {
+    ++count;
+    HPX_TEST(values.contains(val));
+  }
+
+  HPX_TEST_EQ(count, values.size());
+}
+
+namespace detail {
+
+//-----------------------------------------------------------------------------
+template <typename T, typename R> auto initArray1D(R &&r) {
+
+  auto array = chplx::Array(chplx::Domain(r), T());
+  T value = T();
+  chplx::forLoop(array, [&](auto &v) { v = ++value; });
+  return array;
+}
+
+template <typename T, typename... Rs, std::size_t... Is>
+void testCoforallLoopArrays1D(chplx::Tuple<Rs...> const &r,
+                              std::index_sequence<Is...> s) {
+
+  (testCoforallLoopArray(initArray1D<T>(std::get<Is>(r))), ...);
+}
+
+//-----------------------------------------------------------------------------
+template <typename T, typename R1, typename R2>
+auto initArray2D(R1 &&r1, R2 &&r2) {
+
+  auto array = chplx::Array(chplx::Domain(r1, r2), T());
+  T value = T();
+  chplx::forLoop(array, [&](auto &v) { v = ++value; });
+  return array;
+}
+
+template <typename T, std::size_t N, typename... Rs, std::size_t... Js>
+void testCoforallLoopArrays2D(chplx::Tuple<Rs...> const &r,
+                              std::index_sequence<Js...>) {
+
+  (testCoforallLoopArray(initArray2D<T>(std::get<Js>(r), std::get<N>(r))), ...);
+}
+
+template <typename T, typename... Rs, std::size_t... Is>
+void testCoforallLoopArrays2D(chplx::Tuple<Rs...> const &r,
+                              std::index_sequence<Is...> s) {
+
+  (testCoforallLoopArrays2D<T, Is>(r, s), ...);
+}
+
+//-----------------------------------------------------------------------------
+template <typename T, typename R1, typename R2, typename R3>
+auto initArray3D(R1 &&r1, R2 &&r2, R3 &&r3) {
+
+  auto array = chplx::Array(chplx::Domain(r1, r2, r3), T());
+  T value = T();
+  chplx::forLoop(array, [&](auto &v) { v = ++value; });
+  return array;
+}
+
+template <typename T, std::size_t N, std::size_t M, typename... Rs,
+          std::size_t... Js>
+void testCoforallLoopArrays3D_2(chplx::Tuple<Rs...> const &r,
+                                std::index_sequence<Js...>) {
+
+  (testCoforallLoopArray(
+       initArray3D<T>(std::get<Js>(r), std::get<N>(r), std::get<M>(r))),
+   ...);
+}
+
+template <typename T, std::size_t N, typename... Rs, std::size_t... Is>
+void testCoforallLoopArrays3D_1(chplx::Tuple<Rs...> const &r,
+                                std::index_sequence<Is...> s) {
+
+  (testCoforallLoopArrays3D_2<T, N, Is>(r, s), ...);
+}
+
+template <typename T, typename... Rs, std::size_t... Is>
+void testCoforallLoopArrays3D(chplx::Tuple<Rs...> const &r,
+                              std::index_sequence<Is...> s) {
+
+  (testCoforallLoopArrays3D_1<T, Is>(r, s), ...);
+}
+
+//-----------------------------------------------------------------------------
+template <typename T, typename R1, typename R2, typename R3, typename R4>
+auto initArray4D(R1 &&r1, R2 &&r2, R3 &&r3, R4 &&r4) {
+
+  auto array = chplx::Array(chplx::Domain(r1, r2, r3, r4), T());
+  T value = T();
+  chplx::forLoop(array, [&](auto &v) { v = ++value; });
+  return array;
+}
+
+template <typename T, std::size_t N, std::size_t M, std::size_t O,
+          typename... Rs, std::size_t... Js>
+void testCoforallLoopArrays4D_3(chplx::Tuple<Rs...> const &r,
+                                std::index_sequence<Js...>) {
+
+  (testCoforallLoopArray(initArray4D<T>(std::get<Js>(r), std::get<N>(r),
+                                        std::get<M>(r), std::get<O>(r))),
+   ...);
+}
+
+template <typename T, std::size_t N, std::size_t M, typename... Rs,
+          std::size_t... Is>
+void testCoforallLoopArrays4D_2(chplx::Tuple<Rs...> const &r,
+                                std::index_sequence<Is...> s) {
+
+  (testCoforallLoopArrays4D_3<T, N, M, Is>(r, s), ...);
+}
+
+template <typename T, std::size_t N, typename... Rs, std::size_t... Is>
+void testCoforallLoopArrays4D_1(chplx::Tuple<Rs...> const &r,
+                                std::index_sequence<Is...> s) {
+
+  (testCoforallLoopArrays4D_2<T, N, Is>(r, s), ...);
+}
+
+template <typename T, typename... Rs, std::size_t... Is>
+void testCoforallLoopArrays4D(chplx::Tuple<Rs...> const &r,
+                              std::index_sequence<Is...> s) {
+
+  (testCoforallLoopArrays4D_1<T, Is>(r, s), ...);
+}
+
+} // namespace detail
+
+template <typename T, typename... Rs>
+void testCoforallLoopArrays1D(chplx::Tuple<Rs...> r) {
+
+  detail::testCoforallLoopArrays1D<T>(
+      r, std::make_index_sequence<sizeof...(Rs)>());
+}
+
+template <typename T, typename... Rs>
+void testCoforallLoopArrays2D(chplx::Tuple<Rs...> r) {
+
+  detail::testCoforallLoopArrays2D<T>(
+      r, std::make_index_sequence<sizeof...(Rs)>());
+}
+
+template <typename T, typename... Rs>
+void testCoforallLoopArrays3D(chplx::Tuple<Rs...> r) {
+
+  detail::testCoforallLoopArrays3D<T>(
+      r, std::make_index_sequence<sizeof...(Rs)>());
+}
+
+template <typename T, typename... Rs>
+void testCoforallLoopArrays4D(chplx::Tuple<Rs...> r) {
+
+  detail::testCoforallLoopArrays4D<T>(
+      r, std::make_index_sequence<sizeof...(Rs)>());
+}
+
+int main() {
+
+  {
+    auto constexpr r1 = chplx::Range(0, 10);
+    auto constexpr r2 = chplx::BoundedRange<int, true>(0, 10, -1);
+    auto constexpr r3 = chplx::BoundedRange<int, true>(0, 10, 2);
+    auto constexpr r4 = chplx::BoundedRange<int, true>(0, 10, -2);
+
+    testCoforallLoopArrays1D<double>(chplx::Tuple(r1, r2, r3, r4));
+    testCoforallLoopArrays2D<double>(chplx::Tuple(r1, r2, r3, r4));
+    testCoforallLoopArrays3D<double>(chplx::Tuple(r1, r2, r3, r4));
+    testCoforallLoopArrays4D<double>(chplx::Tuple(r1, r2, r3, r4));
+  }
+
+  {
+    auto constexpr r1 = chplx::Range(1, 9);
+    auto constexpr r2 = chplx::BoundedRange<int, true>(1, 9, -1);
+    auto constexpr r3 = chplx::BoundedRange<int, true>(1, 9, 2);
+    auto constexpr r4 = chplx::BoundedRange<int, true>(1, 9, -2);
+
+    testCoforallLoopArrays1D<int>(chplx::Tuple(r1, r2, r3, r4));
+    testCoforallLoopArrays2D<int>(chplx::Tuple(r1, r2, r3, r4));
+    testCoforallLoopArrays3D<int>(chplx::Tuple(r1, r2, r3, r4));
+    testCoforallLoopArrays4D<int>(chplx::Tuple(r1, r2, r3, r4));
+  }
+
+  return hpx::util::report_errors();
+}
diff --git a/library/test/unit/for_loop_array.cpp b/library/test/unit/for_loop_array.cpp
new file mode 100644
index 00000000..b4ed511d
--- /dev/null
+++ b/library/test/unit/for_loop_array.cpp
@@ -0,0 +1,211 @@
+//  Copyright (c) 2023 Hartmut Kaiser
+//
+//  SPDX-License-Identifier: BSL-1.0
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <chplx.hpp>
+
+#include <hpx/hpx_main.hpp>
+#include <hpx/modules/testing.hpp>
+
+#include <cstddef>
+#include <set>
+
+template <typename T, typename Domain>
+void testForLoopArray(chplx::Array<T, Domain> d) {
+
+  std::set<T> values;
+
+  std::size_t count = 0;
+
+  chplx::forLoop(d, [&](auto value) {
+    ++count;
+    auto p = values.insert(value);
+    HPX_TEST(p.second);
+  });
+
+  HPX_TEST_EQ(count, static_cast<std::size_t>(d.size()));
+
+  count = 0;
+  for (auto const &e : d.these()) {
+
+    ++count;
+    HPX_TEST(values.contains(e));
+  }
+
+  HPX_TEST_EQ(count, values.size());
+}
+
+namespace detail {
+
+//-----------------------------------------------------------------------------
+template <typename T, typename R> auto initArray1D(R &&r) {
+
+  auto array = chplx::Array(chplx::Domain(r), T());
+  T value = T();
+  chplx::forLoop(array, [&](auto &v) { v = ++value; });
+  return array;
+}
+
+template <typename T, typename... Rs, std::size_t... Is>
+void testForLoopArrays1D(chplx::Tuple<Rs...> const &r,
+                         std::index_sequence<Is...> s) {
+
+  (testForLoopArray(initArray1D<T>(std::get<Is>(r))), ...);
+}
+
+//-----------------------------------------------------------------------------
+template <typename T, typename R1, typename R2>
+auto initArray2D(R1 &&r1, R2 &&r2) {
+
+  auto array = chplx::Array(chplx::Domain(r1, r2), T());
+  T value = T();
+  chplx::forLoop(array, [&](auto &v) { v = ++value; });
+  return array;
+}
+
+template <typename T, std::size_t N, typename... Rs, std::size_t... Js>
+void testForLoopArrays2D(chplx::Tuple<Rs...> const &r,
+                         std::index_sequence<Js...>) {
+
+  (testForLoopArray(initArray2D<T>(std::get<Js>(r), std::get<N>(r))), ...);
+}
+
+template <typename T, typename... Rs, std::size_t... Is>
+void testForLoopArrays2D(chplx::Tuple<Rs...> const &r,
+                         std::index_sequence<Is...> s) {
+
+  (testForLoopArrays2D<T, Is>(r, s), ...);
+}
+
+//-----------------------------------------------------------------------------
+template <typename T, typename R1, typename R2, typename R3>
+auto initArray3D(R1 &&r1, R2 &&r2, R3 &&r3) {
+
+  auto array = chplx::Array(chplx::Domain(r1, r2, r3), T());
+  T value = T();
+  chplx::forLoop(array, [&](auto &v) { v = ++value; });
+  return array;
+}
+
+template <typename T, std::size_t N, std::size_t M, typename... Rs,
+          std::size_t... Js>
+void testForLoopArrays3D_2(chplx::Tuple<Rs...> const &r,
+                           std::index_sequence<Js...>) {
+
+  (testForLoopArray(
+       initArray3D<T>(std::get<Js>(r), std::get<N>(r), std::get<M>(r))),
+   ...);
+}
+
+template <typename T, std::size_t N, typename... Rs, std::size_t... Is>
+void testForLoopArrays3D_1(chplx::Tuple<Rs...> const &r,
+                           std::index_sequence<Is...> s) {
+
+  (testForLoopArrays3D_2<T, N, Is>(r, s), ...);
+}
+
+template <typename T, typename... Rs, std::size_t... Is>
+void testForLoopArrays3D(chplx::Tuple<Rs...> const &r,
+                         std::index_sequence<Is...> s) {
+
+  (testForLoopArrays3D_1<T, Is>(r, s), ...);
+}
+
+//-----------------------------------------------------------------------------
+template <typename T, typename R1, typename R2, typename R3, typename R4>
+auto initArray4D(R1 &&r1, R2 &&r2, R3 &&r3, R4 &&r4) {
+
+  auto array = chplx::Array(chplx::Domain(r1, r2, r3, r4), T());
+  T value = T();
+  chplx::forLoop(array, [&](auto &v) { v = ++value; });
+  return array;
+}
+
+template <typename T, std::size_t N, std::size_t M, std::size_t O,
+          typename... Rs, std::size_t... Js>
+void testForLoopArrays4D_3(chplx::Tuple<Rs...> const &r,
+                           std::index_sequence<Js...>) {
+
+  (testForLoopArray(initArray4D<T>(std::get<Js>(r), std::get<N>(r),
+                                   std::get<M>(r), std::get<O>(r))),
+   ...);
+}
+
+template <typename T, std::size_t N, std::size_t M, typename... Rs,
+          std::size_t... Is>
+void testForLoopArrays4D_2(chplx::Tuple<Rs...> const &r,
+                           std::index_sequence<Is...> s) {
+
+  (testForLoopArrays4D_3<T, N, M, Is>(r, s), ...);
+}
+
+template <typename T, std::size_t N, typename... Rs, std::size_t... Is>
+void testForLoopArrays4D_1(chplx::Tuple<Rs...> const &r,
+                           std::index_sequence<Is...> s) {
+
+  (testForLoopArrays4D_2<T, N, Is>(r, s), ...);
+}
+
+template <typename T, typename... Rs, std::size_t... Is>
+void testForLoopArrays4D(chplx::Tuple<Rs...> const &r,
+                         std::index_sequence<Is...> s) {
+
+  (testForLoopArrays4D_1<T, Is>(r, s), ...);
+}
+
+} // namespace detail
+
+template <typename T, typename... Rs>
+void testForLoopArrays1D(chplx::Tuple<Rs...> r) {
+
+  detail::testForLoopArrays1D<T>(r, std::make_index_sequence<sizeof...(Rs)>());
+}
+
+template <typename T, typename... Rs>
+void testForLoopArrays2D(chplx::Tuple<Rs...> r) {
+
+  detail::testForLoopArrays2D<T>(r, std::make_index_sequence<sizeof...(Rs)>());
+}
+
+template <typename T, typename... Rs>
+void testForLoopArrays3D(chplx::Tuple<Rs...> r) {
+
+  detail::testForLoopArrays3D<T>(r, std::make_index_sequence<sizeof...(Rs)>());
+}
+
+template <typename T, typename... Rs>
+void testForLoopArrays4D(chplx::Tuple<Rs...> r) {
+
+  detail::testForLoopArrays4D<T>(r, std::make_index_sequence<sizeof...(Rs)>());
+}
+
+int main() {
+
+  {
+    auto constexpr r1 = chplx::Range(0, 10);
+    auto constexpr r2 = chplx::BoundedRange<int, true>(0, 10, -1);
+    auto constexpr r3 = chplx::BoundedRange<int, true>(0, 10, 2);
+    auto constexpr r4 = chplx::BoundedRange<int, true>(0, 10, -2);
+
+    testForLoopArrays1D<double>(chplx::Tuple(r1, r2, r3, r4));
+    testForLoopArrays2D<double>(chplx::Tuple(r1, r2, r3, r4));
+    testForLoopArrays3D<double>(chplx::Tuple(r1, r2, r3, r4));
+    testForLoopArrays4D<double>(chplx::Tuple(r1, r2, r3, r4));
+  }
+
+  {
+    auto constexpr r1 = chplx::Range(1, 9);
+    auto constexpr r2 = chplx::BoundedRange<int, true>(1, 9, -1);
+    auto constexpr r3 = chplx::BoundedRange<int, true>(1, 9, 2);
+    auto constexpr r4 = chplx::BoundedRange<int, true>(1, 9, -2);
+
+    testForLoopArrays1D<int>(chplx::Tuple(r1, r2, r3, r4));
+    testForLoopArrays2D<int>(chplx::Tuple(r1, r2, r3, r4));
+    testForLoopArrays3D<int>(chplx::Tuple(r1, r2, r3, r4));
+    testForLoopArrays4D<int>(chplx::Tuple(r1, r2, r3, r4));
+  }
+
+  return hpx::util::report_errors();
+}
diff --git a/library/test/unit/forall_loop_array.cpp b/library/test/unit/forall_loop_array.cpp
new file mode 100644
index 00000000..b3f64aa3
--- /dev/null
+++ b/library/test/unit/forall_loop_array.cpp
@@ -0,0 +1,219 @@
+//  Copyright (c) 2023 Hartmut Kaiser
+//
+//  SPDX-License-Identifier: BSL-1.0
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <chplx.hpp>
+
+#include <hpx/hpx_main.hpp>
+#include <hpx/modules/testing.hpp>
+#include <hpx/thread.hpp>
+
+#include <cstddef>
+#include <mutex>
+#include <set>
+
+template <typename T, typename Domain>
+void testForallLoopArray(chplx::Array<T, Domain> d) {
+
+  std::set<T> values;
+  hpx::mutex mtx;
+
+  std::size_t count = 0;
+
+  chplx::forall(d, [&](auto value) {
+    std::lock_guard l(mtx);
+    ++count;
+    auto p = values.insert(value);
+    HPX_TEST(p.second);
+  });
+
+  HPX_TEST_EQ(count, static_cast<std::size_t>(d.size()));
+  count = 0;
+
+  for (auto const &e : d.these()) {
+
+    ++count;
+    HPX_TEST(values.contains(e));
+  }
+
+  HPX_TEST_EQ(count, values.size());
+}
+
+namespace detail {
+
+//-----------------------------------------------------------------------------
+template <typename T, typename R> auto initArray1D(R &&r) {
+
+  auto array = chplx::Array(chplx::Domain(r), T());
+  T value = T();
+  chplx::forLoop(array, [&](auto &v) { v = ++value; });
+  return array;
+}
+
+template <typename T, typename... Rs, std::size_t... Is>
+void testForallLoopArrays1D(chplx::Tuple<Rs...> const &r,
+                            std::index_sequence<Is...> s) {
+
+  (testForallLoopArray(initArray1D<T>(std::get<Is>(r))), ...);
+}
+
+//-----------------------------------------------------------------------------
+template <typename T, typename R1, typename R2>
+auto initArray2D(R1 &&r1, R2 &&r2) {
+
+  auto array = chplx::Array(chplx::Domain(r1, r2), T());
+  T value = T();
+  chplx::forLoop(array, [&](auto &v) { v = ++value; });
+  return array;
+}
+
+template <typename T, std::size_t N, typename... Rs, std::size_t... Js>
+void testForallLoopArrays2D(chplx::Tuple<Rs...> const &r,
+                            std::index_sequence<Js...>) {
+
+  (testForallLoopArray(initArray2D<T>(std::get<Js>(r), std::get<N>(r))), ...);
+}
+
+template <typename T, typename... Rs, std::size_t... Is>
+void testForallLoopArrays2D(chplx::Tuple<Rs...> const &r,
+                            std::index_sequence<Is...> s) {
+
+  (testForallLoopArrays2D<T, Is>(r, s), ...);
+}
+
+//-----------------------------------------------------------------------------
+template <typename T, typename R1, typename R2, typename R3>
+auto initArray3D(R1 &&r1, R2 &&r2, R3 &&r3) {
+
+  auto array = chplx::Array(chplx::Domain(r1, r2, r3), T());
+  T value = T();
+  chplx::forLoop(array, [&](auto &v) { v = ++value; });
+  return array;
+}
+
+template <typename T, std::size_t N, std::size_t M, typename... Rs,
+          std::size_t... Js>
+void testForallLoopArrays3D_2(chplx::Tuple<Rs...> const &r,
+                              std::index_sequence<Js...>) {
+
+  (testForallLoopArray(
+       initArray3D<T>(std::get<Js>(r), std::get<N>(r), std::get<M>(r))),
+   ...);
+}
+
+template <typename T, std::size_t N, typename... Rs, std::size_t... Is>
+void testForallLoopArrays3D_1(chplx::Tuple<Rs...> const &r,
+                              std::index_sequence<Is...> s) {
+
+  (testForallLoopArrays3D_2<T, N, Is>(r, s), ...);
+}
+
+template <typename T, typename... Rs, std::size_t... Is>
+void testForallLoopArrays3D(chplx::Tuple<Rs...> const &r,
+                            std::index_sequence<Is...> s) {
+
+  (testForallLoopArrays3D_1<T, Is>(r, s), ...);
+}
+
+//-----------------------------------------------------------------------------
+template <typename T, typename R1, typename R2, typename R3, typename R4>
+auto initArray4D(R1 &&r1, R2 &&r2, R3 &&r3, R4 &&r4) {
+
+  auto array = chplx::Array(chplx::Domain(r1, r2, r3, r4), T());
+  T value = T();
+  chplx::forLoop(array, [&](auto &v) { v = ++value; });
+  return array;
+}
+
+template <typename T, std::size_t N, std::size_t M, std::size_t O,
+          typename... Rs, std::size_t... Js>
+void testForallLoopArrays4D_3(chplx::Tuple<Rs...> const &r,
+                              std::index_sequence<Js...>) {
+
+  (testForallLoopArray(initArray4D<T>(std::get<Js>(r), std::get<N>(r),
+                                      std::get<M>(r), std::get<O>(r))),
+   ...);
+}
+
+template <typename T, std::size_t N, std::size_t M, typename... Rs,
+          std::size_t... Is>
+void testForallLoopArrays4D_2(chplx::Tuple<Rs...> const &r,
+                              std::index_sequence<Is...> s) {
+
+  (testForallLoopArrays4D_3<T, N, M, Is>(r, s), ...);
+}
+
+template <typename T, std::size_t N, typename... Rs, std::size_t... Is>
+void testForallLoopArrays4D_1(chplx::Tuple<Rs...> const &r,
+                              std::index_sequence<Is...> s) {
+
+  (testForallLoopArrays4D_2<T, N, Is>(r, s), ...);
+}
+
+template <typename T, typename... Rs, std::size_t... Is>
+void testForallLoopArrays4D(chplx::Tuple<Rs...> const &r,
+                            std::index_sequence<Is...> s) {
+
+  (testForallLoopArrays4D_1<T, Is>(r, s), ...);
+}
+
+} // namespace detail
+
+template <typename T, typename... Rs>
+void testForallLoopArrays1D(chplx::Tuple<Rs...> r) {
+
+  detail::testForallLoopArrays1D<T>(r,
+                                    std::make_index_sequence<sizeof...(Rs)>());
+}
+
+template <typename T, typename... Rs>
+void testForallLoopArrays2D(chplx::Tuple<Rs...> r) {
+
+  detail::testForallLoopArrays2D<T>(r,
+                                    std::make_index_sequence<sizeof...(Rs)>());
+}
+
+template <typename T, typename... Rs>
+void testForallLoopArrays3D(chplx::Tuple<Rs...> r) {
+
+  detail::testForallLoopArrays3D<T>(r,
+                                    std::make_index_sequence<sizeof...(Rs)>());
+}
+
+template <typename T, typename... Rs>
+void testForallLoopArrays4D(chplx::Tuple<Rs...> r) {
+
+  detail::testForallLoopArrays4D<T>(r,
+                                    std::make_index_sequence<sizeof...(Rs)>());
+}
+
+int main() {
+
+  {
+    auto constexpr r1 = chplx::Range(0, 10);
+    auto constexpr r2 = chplx::BoundedRange<int, true>(0, 10, -1);
+    auto constexpr r3 = chplx::BoundedRange<int, true>(0, 10, 2);
+    auto constexpr r4 = chplx::BoundedRange<int, true>(0, 10, -2);
+
+    testForallLoopArrays1D<double>(chplx::Tuple(r1, r2, r3, r4));
+    testForallLoopArrays2D<double>(chplx::Tuple(r1, r2, r3, r4));
+    testForallLoopArrays3D<double>(chplx::Tuple(r1, r2, r3, r4));
+    testForallLoopArrays4D<double>(chplx::Tuple(r1, r2, r3, r4));
+  }
+
+  {
+    auto constexpr r1 = chplx::Range(1, 9);
+    auto constexpr r2 = chplx::BoundedRange<int, true>(1, 9, -1);
+    auto constexpr r3 = chplx::BoundedRange<int, true>(1, 9, 2);
+    auto constexpr r4 = chplx::BoundedRange<int, true>(1, 9, -2);
+
+    testForallLoopArrays1D<int>(chplx::Tuple(r1, r2, r3, r4));
+    testForallLoopArrays2D<int>(chplx::Tuple(r1, r2, r3, r4));
+    testForallLoopArrays3D<int>(chplx::Tuple(r1, r2, r3, r4));
+    testForallLoopArrays4D<int>(chplx::Tuple(r1, r2, r3, r4));
+  }
+
+  return hpx::util::report_errors();
+}