Reenable failing test

doc/array/changes.adoc

@@ -14,3 +14,5 @@ http://www.boost.org/LICENSE_1_0.txt
 
 * Converted documentation to AsciiDoc (Christian Mazakas).
 * Added `noexcept` and `constexpr` as appropriate.
+* Marked obsolete functions as deprecated.
+* Removed obsolete compiler workarounds.

include/boost/array.hpp

@@ -37,15 +37,14 @@
 
 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
 # pragma warning(push)
-# pragma warning(disable:4996) // 'std::equal': Function call with parameters that may be unsafe
 # pragma warning(disable:4510) // boost::array<T,N>' : default constructor could not be generated
-# pragma warning(disable:4610) // warning C4610: class 'boost::array<T,N>' can never be instantiated - user defined constructor required
+# pragma warning(disable:4512) // boost::array<T,N>' : assignment operator could not be generated
+# pragma warning(disable:4610) // class 'boost::array<T,N>' can never be instantiated - user defined constructor required
 #endif
 
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/throw_exception.hpp>
-#include <algorithm>
 #include <iterator>
 #include <stdexcept>
 #include <utility>
@@ -158,15 +157,29 @@ namespace boost {
 
         // assignment with type conversion
         template <typename T2>
-        array<T,N>& operator= (const array<T2,N>& rhs) {
-            std::copy(rhs.begin(),rhs.end(), begin());
+        array<T,N>& operator= (const array<T2,N>& rhs)
+        {
+            for( std::size_t i = 0; i < N; ++i )
+            {
+                elems[ i ] = rhs.elems[ i ];
+            }
+
             return *this;
         }
 
         // fill with one value
         BOOST_CXX14_CONSTEXPR void fill (const T& value)
         {
-            std::fill_n(begin(),size(),value);
+            // using elems[ 0 ] as a temporary copy
+            // avoids the aliasing opportunity betw.
+            // `value` and `elems`
+
+            elems[ 0 ] = value;
+
+            for( std::size_t i = 1; i < N; ++i )
+            {
+                elems[ i ] = elems[ 0 ];
+            }
         }
 
         // an obsolete synonym for fill
@@ -290,19 +303,10 @@ namespace boost {
         BOOST_CXX14_CONSTEXPR void fill (const T& ) {}
 
         // check range (may be private because it is static)
-        static reference failed_rangecheck () {
-                std::out_of_range e("attempt to access element of an empty array");
-                boost::throw_exception(e);
-#if defined(BOOST_NO_EXCEPTIONS) || (!defined(BOOST_MSVC) && !defined(__PATHSCALE__))
-                //
-                // We need to return something here to keep
-                // some compilers happy: however we will never
-                // actually get here....
-                //
-                static T placeholder;
-                return placeholder;
-#endif
-            }
+        static reference failed_rangecheck ()
+        {
+            boost::throw_exception( std::out_of_range( "attempt to access element of an empty array" ) );
+        }
     };
 
     // comparisons

test/Jamfile.v2

@@ -59,6 +59,9 @@ compile array_get_test_cx.cpp ;
 
 # C++14 constexpr
 
+compile array_assign_test_cx.cpp ;
+compile array_access_test_cx2.cpp ;
+compile array_fill_test_cx.cpp ;
 compile array_eq_test_cx.cpp ;
 compile array_lt_test_cx.cpp ;
 

test/array0.cpp

@@ -5,11 +5,11 @@
  * http://www.boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/array.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <algorithm>
 #include <string>
 #include <iostream>
-#include <boost/array.hpp>
-
-#include <boost/core/lightweight_test_trait.hpp>
 
 namespace {
 

test/array_access_test_cx2.cpp

@@ -0,0 +1,45 @@
+// Copyright 2025 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/array.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+#include <boost/config/workaround.hpp>
+#include <cstddef>
+
+#if defined(BOOST_NO_CXX14_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined")
+
+#else
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+template<class T, std::size_t N> constexpr boost::array<T, N> modified( boost::array<T, N> a1 )
+{
+    a1.front() = 1;
+    a1[ 1 ] = 2;
+    a1.at( 2 ) = 3;
+    a1.back() = 4;
+
+    return a1;
+}
+
+template<class T> void test1()
+{
+    constexpr boost::array<T, 4> a1 = {};
+    constexpr boost::array<T, 4> a2 = modified( a1 );
+
+    STATIC_ASSERT( a2[0] == 1 );
+    STATIC_ASSERT( a2[1] == 2 );
+    STATIC_ASSERT( a2[2] == 3 );
+    STATIC_ASSERT( a2[3] == 4 );
+}
+
+int main()
+{
+    test1<int>();
+}
+
+#endif

test/array_assign_test_cx.cpp

@@ -0,0 +1,54 @@
+// Copyright 2025 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/array.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+#include <boost/config/workaround.hpp>
+#include <cstddef>
+
+#if defined(BOOST_NO_CXX14_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined")
+
+#else
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+template<class T, std::size_t N> constexpr boost::array<T, N> assigned( boost::array<T, N> const& a1 )
+{
+    boost::array<T, N> a2 = {};
+
+    a2 = a1;
+
+    return a2;
+}
+
+template<class T> void test1()
+{
+    constexpr boost::array<T, 4> a1 = {{ 1, 2, 3, 4 }};
+    constexpr boost::array<T, 4> a2 = assigned( a1 );
+
+    STATIC_ASSERT( a1[0] == a2[0] );
+    STATIC_ASSERT( a1[1] == a2[1] );
+    STATIC_ASSERT( a1[2] == a2[2] );
+    STATIC_ASSERT( a1[3] == a2[3] );
+}
+
+template<class T> void test2()
+{
+    constexpr boost::array<T, 0> a1 = {};
+    constexpr boost::array<T, 0> a2 = assigned( a1 );
+
+    (void)a1;
+    (void)a2;
+}
+
+int main()
+{
+    test1<int>();
+    test2<int>();
+}
+
+#endif

test/array_fill_test_cx.cpp

@@ -0,0 +1,51 @@
+// Copyright 2025 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/array.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+#include <boost/config/workaround.hpp>
+#include <cstddef>
+
+#if defined(BOOST_NO_CXX14_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined")
+
+#else
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+template<class T, std::size_t N> constexpr boost::array<T, N> filled( T const& v )
+{
+    boost::array<T, N> r = {};
+
+    r.fill( v );
+
+    return r;
+}
+
+template<class T> void test1()
+{
+    constexpr boost::array<T, 4> a1 = filled<T, 4>( 7 );
+
+    STATIC_ASSERT( a1[0] == 7 );
+    STATIC_ASSERT( a1[1] == 7 );
+    STATIC_ASSERT( a1[2] == 7 );
+    STATIC_ASSERT( a1[3] == 7 );
+}
+
+template<class T> void test2()
+{
+    constexpr boost::array<T, 0> a1 = filled<T, 0>( 7 );
+
+    (void)a1;
+}
+
+int main()
+{
+    test1<int>();
+    test2<int>();
+}
+
+#endif

test/array_init_test.cpp

@@ -58,7 +58,7 @@ int main()
     test2<int, 1>();
     test2<int, 7>();
 
-    // test2<int const, 0>();
+    test2<int const, 0>();
 
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) || BOOST_WORKAROUND(BOOST_GCC, < 50000)