Add support for modular build structure. (#36 )

* Make the library modular usable. * Switch to library requirements instead of source. As source puts extra source in install targets. * Add requires-b2 check to top-level build file. * Bump B2 require to 5.2 * Change all <source> references to <library>. * Update copyright dates. * Move inter-lib dependencies to a project variable and into the build targets. * Switch to /boost/test//included target for header only mode of Boost.Test. * Update build deps. * Add GHA CI with simpler working one based on alandefreitas/cpp-actions utilities. * Move project global include to target local include. * Only msvc gets minor version tests. * Remove GHA CI to undo move to cpp-actions.
Add CMakeLists.txt
2026-01-25 06:22:10 +00:00 · 2025-06-26 02:51:42 +03:00 · 2021-05-28 00:46:21 +03:00 · 2021-05-28 00:45:40 +03:00 · 2021-01-20 15:58:46 -05:00 · 2019-12-17 08:42:23 -05:00
75 changed files with 1195 additions and 525 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,297 @@
+# Copyright 2018 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+
+language: cpp
+
+sudo: false
+
+dist: trusty
+
+python: "2.7"
+
+branches:
+  only:
+    - master
+    - develop
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
+
+    - os: linux
+      compiler: g++-4.4
+      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.4
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.6
+      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.7
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.8
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.9
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-8
+      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-9
+      env: TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - g++-9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
+
+    - os: linux
+      compiler: /usr/bin/clang++
+      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.3
+
+    - os: linux
+      compiler: /usr/bin/clang++
+      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.4
+
+    - os: linux
+      compiler: clang++-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
+
+    - os: linux
+      compiler: clang++-3.6
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      compiler: clang++-3.7
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+
+    - os: linux
+      compiler: clang++-3.8
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      compiler: clang++-5.0
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+
+    - os: linux
+      compiler: clang++-6.0
+      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-6.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-6.0
+
+    - os: linux
+      compiler: clang++-7
+      env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-7
+
+    - os: linux
+      compiler: clang++-8
+      env: TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-8
+
+    - os: linux
+      compiler: clang++-libc++
+      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - libc++-dev
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+
+install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - cd ..
+  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost
+  - cd boost
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - mkdir -p libs/multi_array
+  - cp -r $TRAVIS_BUILD_DIR/* libs/multi_array
+  - python tools/boostdep/depinst/depinst.py multi_array
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - ./b2 -j 3 libs/multi_array/test toolset=$TOOLSET cxxstd=$CXXSTD
+
+notifications:
+  email:
+    on_success: always
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -0,0 +1,34 @@
+# Generated by `boostdep --cmake multi_array`
+# Copyright 2020 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(boost_multi_array VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_multi_array INTERFACE)
+add_library(Boost::multi_array ALIAS boost_multi_array)
+
+target_include_directories(boost_multi_array INTERFACE include)
+
+target_link_libraries(boost_multi_array
+  INTERFACE
+    Boost::array
+    Boost::assert
+    Boost::concept_check
+    Boost::config
+    Boost::core
+    Boost::functional
+    Boost::iterator
+    Boost::mpl
+    Boost::static_assert
+    Boost::type_traits
+)
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+
+  add_subdirectory(test)
+
+endif()
+
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -0,0 +1,56 @@
+# Copyright 2018 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-9.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-10.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-11.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-12.0
+      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-14.0
+      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+      ADDRMD: 32,64
+      STANDARD: 14,17
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: clang-win
+      ADDRMD: 32,64
+      STANDARD: 14,17
+
+
+install:
+  - set BOOST_BRANCH=develop
+  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
+  - cd ..
+  - git clone -b %BOOST_BRANCH% https://github.com/boostorg/boost.git boost
+  - cd boost
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\multi_array\
+  - python tools/boostdep/depinst/depinst.py multi_array
+  - cmd /c bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - PATH=%ADDPATH%%PATH%
+  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+  - b2 -j 3 libs/multi_array/test toolset=%TOOLSET% %CXXSTD%
--- a/build.jam
+++ b/build.jam
@@ -0,0 +1,30 @@
+# Copyright René Ferdinand Rivera Morell 2023-2024
+# 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)
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/array//boost_array
+    /boost/assert//boost_assert
+    /boost/concept_check//boost_concept_check
+    /boost/config//boost_config
+    /boost/core//boost_core
+    /boost/functional//boost_functional
+    /boost/iterator//boost_iterator
+    /boost/mpl//boost_mpl
+    /boost/static_assert//boost_static_assert
+    /boost/type_traits//boost_type_traits ;
+
+project /boost/multi_array
+    ;
+
+explicit
+    [ alias boost_multi_array : : :
+        : <include>include <library>$(boost_dependencies) ]
+    [ alias all : boost_multi_array test ]
+    ;
+
+call-if : boost-library multi_array
+    ;
--- a/doc/iterator_categories.html
+++ b/doc/iterator_categories.html
@@ -651,8 +651,8 @@ Iterator</a>.
 </h3>The Forward Iterator is an iterator that can be incremented. Also, it is 
 permissible to make multiple passes through the iterator's range. 
 <h3>Refinement of</h3><a href="http://www.boost.org/libs/utility/CopyConstructible.html">Copy 
-Constructible</a>, <a href="http://www.boost.org/libs/utility/Assignable.html">Assignable</a>, <a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default 
-Constructible</a>, and <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality 
+Constructible</a>, <a href="http://www.boost.org/libs/utility/Assignable.html">Assignable</a>, <a href="https://www.boost.org/sgi/stl/DefaultConstructible.html">Default 
+Constructible</a>, and <a href="https://www.boost.org/sgi/stl/EqualityComparable.html">Equality 
 Comparable</a> 
 <h3>Associated types</h3>
 <table border="1">
@@ -725,7 +725,7 @@ Traversal Iterator</a>
 Iterator </h3>An iterator that provides constant-time methods for moving forward 
 and backward in arbitrary-sized steps. 
 <h3>Refinement of</h3><a href="#concept_BidirectionalTraversalIterator">Bidirectional 
-Traversal Iterator</a> and <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">Less Than 
+Traversal Iterator</a> and <a href="https://www.boost.org/sgi/stl/LessThanComparable.html">Less Than 
 Comparable</a> where <tt>&lt;</tt> is a total ordering 
 <h3>Associated types</h3>
 <table border="1">
--- a/doc/reference.html
+++ b/doc/reference.html
@@ -353,21 +353,21 @@ This expression generates a view of the array determined by the
 used to construct <code class="literal">indices</code>.
 </td></tr><tr><td><code class="literal">a == b</code></td><td>bool</td><td>This performs a lexicographical comparison of the
 values of <code class="literal">a</code> and <code class="literal">b</code>.  The element
-type must model <a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top">EqualityComparable</a> for this
+type must model <a class="ulink" href="https://www.boost.org/sgi/stl/EqualityComparable.html" target="_top">EqualityComparable</a> for this
 expression to be valid.</td></tr><tr><td><code class="literal">a &lt; b</code></td><td>bool</td><td>This performs a lexicographical comparison of the
 values of <code class="literal">a</code> and <code class="literal">b</code>.  The element
-type must model <a class="ulink" href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
+type must model <a class="ulink" href="https://www.boost.org/sgi/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
 expression to be valid.</td></tr><tr><td><code class="literal">a &lt;= b</code></td><td>bool</td><td>This performs a lexicographical comparison of the
 values of <code class="literal">a</code> and <code class="literal">b</code>.  The element
-type must model <a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and
-<a class="ulink" href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
+type must model <a class="ulink" href="https://www.boost.org/sgi/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and
+<a class="ulink" href="https://www.boost.org/sgi/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
 expression to be valid.</td></tr><tr><td><code class="literal">a &gt; b</code></td><td>bool</td><td>This performs a lexicographical comparison of the
 values of <code class="literal">a</code> and <code class="literal">b</code>.  The element
-type must model <a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and 
-<a class="ulink" href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
+type must model <a class="ulink" href="https://www.boost.org/sgi/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and 
+<a class="ulink" href="https://www.boost.org/sgi/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
 expression to be valid.</td></tr><tr><td><code class="literal">a &gt;= b</code></td><td>bool</td><td>This performs a lexicographical comparison of the
 values of <code class="literal">a</code> and <code class="literal">b</code>.  The element
-type must model <a class="ulink" href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
+type must model <a class="ulink" href="https://www.boost.org/sgi/stl/LessThanComparable.html" target="_top">LessThanComparable</a> for this
 expression to be valid.</td></tr></tbody></table></div></div><br class="table-break"></div><div class="sect2" title="Complexity guarantees"><div class="titlepage"><div><div><h3 class="title"><a name="idp18588736"></a>Complexity guarantees</h3></div></div></div><code class="literal">begin()</code> and <code class="literal">end()</code> execute in amortized
 constant time.
 <code class="literal">size()</code> executes in at most linear time in the 
@@ -589,7 +589,7 @@ using a replaceable allocator.
 </p><p title="Model Of."><b>Model Of. </b>
 <a class="link" href="#MultiArray" title="MultiArray Concept">MultiArray</a>,
 <a class="ulink" href="../../../libs/utility/CopyConstructible.html" target="_top">CopyConstructible</a>. Depending on the element type, 
-it may also model <a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and <a class="ulink" href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top">LessThanComparable</a>. 
+it may also model <a class="ulink" href="https://www.boost.org/sgi/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and <a class="ulink" href="https://www.boost.org/sgi/stl/LessThanComparable.html" target="_top">LessThanComparable</a>. 
 </p><p title="Synopsis"><b>Synopsis. </b></p><pre class="programlisting">

 namespace boost {
@@ -818,7 +818,7 @@ of the constructors.
 <a class="link" href="#MultiArray" title="MultiArray Concept">MultiArray</a>,
 <a class="ulink" href="../../../libs/utility/CopyConstructible.html" target="_top">CopyConstructible</a>.
 and depending on the element type, it may also model
-<a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and <a class="ulink" href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top">LessThanComparable</a>. 
+<a class="ulink" href="https://www.boost.org/sgi/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and <a class="ulink" href="https://www.boost.org/sgi/stl/LessThanComparable.html" target="_top">LessThanComparable</a>. 
 Detailed descriptions are provided here only for operations that are
 not described in the <code class="literal">multi_array</code> reference.
 </p><p title="Synopsis"><b>Synopsis. </b></p><pre class="programlisting">
@@ -978,7 +978,7 @@ of the constructors.
 <a class="link" href="#MultiArray" title="MultiArray Concept">MultiArray</a>,
 <a class="ulink" href="../../../libs/utility/CopyConstructible.html" target="_top">CopyConstructible</a>.
 and depending on the element type, it may also model
-<a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and <a class="ulink" href="http://www.sgi.com/tech/stl/LessThanComparable.html" target="_top">LessThanComparable</a>. 
+<a class="ulink" href="https://www.boost.org/sgi/stl/EqualityComparable.html" target="_top">EqualityComparable</a> and <a class="ulink" href="https://www.boost.org/sgi/stl/LessThanComparable.html" target="_top">LessThanComparable</a>. 

 Detailed descriptions are provided here only for operations that are
 not described in the <code class="literal">multi_array</code> reference.
--- a/doc/test_cases.html
+++ b/doc/test_cases.html
@@ -179,6 +179,13 @@ by library users.
 </td>
 </tr>

+<tr>
+<td><a href="../test/allocators.cpp">libs/multi_array/test/allocators.cpp</a></td>
+<td>
+Test support for custom allocators.
+</td>
+</tr>
+
 <tr>
 <td><a href="../test/generative_tests.hpp">libs/multi_array/test/generative_tests.hpp</a></td>
 <td>
--- a/doc/user.html
+++ b/doc/user.html
@@ -612,7 +612,7 @@ cases can be found <a href="./test_cases.html">here</a>.
 <h2>Related Work</h2>

 <a href="../../array/index.html">boost::array</a>
- and <a href="http://www.sgi.com/tech/stl/Vector.html">std::vector</a> are
+ and <a href="https://www.boost.org/sgi/stl/Vector.html">std::vector</a> are
    one-dimensional containers of user data.  Both manage their own
    memory. <tt>std::valarray</tt> is a low-level 
    C++ Standard Library component
@@ -661,6 +661,11 @@ arrays, as <tt>boost::array</tt> does for C one-dimensional arrays.
      <li><a href="mailto:bdawes@acm.org">Beman Dawes</a>
      helped immensely with porting the library to Microsoft Windows
      compilers.
+
+      <li><a href="mailto:glenjofe@gmail.com">Glen Fernandes</a>
+      implemented support for the C++11 allocator model, including
+      support for stateful allocators, minimal allocators, and
+      optimized storage for stateless allocators.
 </ul>

 <hr>
--- a/doc/xml/MultiArray.xml
+++ b/doc/xml/MultiArray.xml
@@ -567,7 +567,7 @@ This expression generates a view of the array determined by the
 	      <entry>bool</entry>
 	      <entry>This performs a lexicographical comparison of the
 values of <literal>a</literal> and <literal>b</literal>.  The element
-type must model <ulink url="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</ulink> for this
+type must model <ulink url="https://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</ulink> for this
 expression to be valid.</entry>
 	    </row>
 	    <row>
@@ -575,7 +575,7 @@ expression to be valid.</entry>
 	      <entry>bool</entry>
 	      <entry>This performs a lexicographical comparison of the
 values of <literal>a</literal> and <literal>b</literal>.  The element
-type must model <ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink> for this
+type must model <ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink> for this
 expression to be valid.</entry>
 	    </row>
 	    <row>
@@ -583,8 +583,8 @@ expression to be valid.</entry>
 	      <entry>bool</entry>
 	      <entry>This performs a lexicographical comparison of the
 values of <literal>a</literal> and <literal>b</literal>.  The element
-type must model <ulink url="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</ulink> and
-<ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink> for this
+type must model <ulink url="https://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</ulink> and
+<ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink> for this
 expression to be valid.</entry>
 	    </row>
 	    <row>
@@ -592,8 +592,8 @@ expression to be valid.</entry>
 	      <entry>bool</entry>
 	      <entry>This performs a lexicographical comparison of the
 values of <literal>a</literal> and <literal>b</literal>.  The element
-type must model <ulink url="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</ulink> and 
-<ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink> for this
+type must model <ulink url="https://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</ulink> and 
+<ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink> for this
 expression to be valid.</entry>
 	    </row>
 	    <row>
@@ -601,7 +601,7 @@ expression to be valid.</entry>
 	      <entry>bool</entry>
 	      <entry>This performs a lexicographical comparison of the
 values of <literal>a</literal> and <literal>b</literal>.  The element
-type must model <ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink> for this
+type must model <ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink> for this
 expression to be valid.</entry>
 	    </row>
    </tbody>
--- a/doc/xml/const_multi_array_ref.xml
+++ b/doc/xml/const_multi_array_ref.xml
@@ -17,7 +17,7 @@ of the constructors.
 <link linkend="MultiArray">MultiArray</link>,
 <ulink url="../../../libs/utility/CopyConstructible.html">CopyConstructible</ulink>.
 and depending on the element type, it may also model
-<ulink url="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</ulink> and <ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink>. 
+<ulink url="https://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</ulink> and <ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink>. 

 Detailed descriptions are provided here only for operations that are
 not described in the <literal>multi_array</literal> reference.
--- a/doc/xml/multi_array.xml
+++ b/doc/xml/multi_array.xml
@@ -18,7 +18,7 @@ using a replaceable allocator.
 <para>
 <link linkend="MultiArray">MultiArray</link>,
 <ulink url="../../../libs/utility/CopyConstructible.html">CopyConstructible</ulink>. Depending on the element type, 
-it may also model <ulink url="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</ulink> and <ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink>. 
+it may also model <ulink url="https://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</ulink> and <ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink>. 
 </para>
 </formalpara>

@@ -65,7 +65,7 @@ public:

  // constructors and destructors

-  multi_array();
+  multi_array(const Allocator& alloc = Allocator());

  template <typename ExtentList>
  explicit multi_array(const ExtentList& sizes,
@@ -75,13 +75,19 @@ public:
                       const storage_order_type& store = c_storage_order(),
 	               const Allocator& alloc = Allocator());
  multi_array(const multi_array& x);
-  multi_array(const const_multi_array_ref<ValueType,NumDims>& x);
-  multi_array(const const_subarray<NumDims>::type& x);
-  multi_array(const const_array_view<NumDims>::type& x);
+  multi_array(const const_multi_array_ref<ValueType,NumDims>& x,
+              const Allocator& alloc = Allocator());
+  multi_array(const const_subarray<NumDims>::type& x,
+              const Allocator& alloc = Allocator());
+  multi_array(const const_array_view<NumDims>::type& x,
+              const Allocator& alloc = Allocator());

-  multi_array(const multi_array_ref<ValueType,NumDims>& x);
-  multi_array(const subarray<NumDims>::type& x);
-  multi_array(const array_view<NumDims>::type& x);
+  multi_array(const multi_array_ref<ValueType,NumDims>& x,
+              const Allocator& alloc = Allocator());
+  multi_array(const subarray<NumDims>::type& x,
+              const Allocator& alloc = Allocator());
+  multi_array(const array_view<NumDims>::type& x,
+              const Allocator& alloc = Allocator());

  ~multi_array();

@@ -207,12 +213,18 @@ elements.
 <varlistentry>
 <term><programlisting>
 <![CDATA[multi_array(const multi_array& x);
-multi_array(const const_multi_array_ref<ValueType,NumDims>& x);
-multi_array(const const_subarray<NumDims>::type& x);
-multi_array(const const_array_view<NumDims>::type& x);
-multi_array(const multi_array_ref<ValueType,NumDims>& x);
-multi_array(const subarray<NumDims>::type& x);
-multi_array(const array_view<NumDims>::type& x);]]>
+multi_array(const const_multi_array_ref<ValueType,NumDims>& x,
+    const Allocator& alloc = Allocator());
+multi_array(const const_subarray<NumDims>::type& x,
+    const Allocator& alloc = Allocator());
+multi_array(const const_array_view<NumDims>::type& x,
+    const Allocator& alloc = Allocator());
+multi_array(const multi_array_ref<ValueType,NumDims>& x,
+    const Allocator& alloc = Allocator());
+multi_array(const subarray<NumDims>::type& x,
+    const Allocator& alloc = Allocator());
+multi_array(const array_view<NumDims>::type& x,
+    const Allocator& alloc = Allocator());]]>
 </programlisting></term>
 <listitem>
 <para>These constructors all constructs a <literal>multi_array</literal> and 
--- a/doc/xml/multi_array_ref.xml
+++ b/doc/xml/multi_array_ref.xml
@@ -17,7 +17,7 @@ of the constructors.
 <link linkend="MultiArray">MultiArray</link>,
 <ulink url="../../../libs/utility/CopyConstructible.html">CopyConstructible</ulink>.
 and depending on the element type, it may also model
-<ulink url="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</ulink> and <ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink>. 
+<ulink url="https://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</ulink> and <ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink>. 
 Detailed descriptions are provided here only for operations that are
 not described in the <literal>multi_array</literal> reference.
 </para>
--- a/include/boost/multi_array.hpp
+++ b/include/boost/multi_array.hpp
@@ -1,5 +1,8 @@
 // Copyright 2002 The Trustees of Indiana University.

+// Copyright 2018 Glen Joseph Fernandes
+// (glenjofe@gmail.com)
+
 // Use, modification and distribution is subject to 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)
@@ -10,8 +13,8 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.

-#ifndef BOOST_MULTI_ARRAY_RG071801_HPP
-#define BOOST_MULTI_ARRAY_RG071801_HPP
+#ifndef BOOST_MULTI_ARRAY_HPP
+#define BOOST_MULTI_ARRAY_HPP

 //
 // multi_array.hpp - contains the multi_array class template
@@ -30,6 +33,8 @@
 #include "boost/multi_array/subarray.hpp"
 #include "boost/multi_array/multi_array_ref.hpp"
 #include "boost/multi_array/algorithm.hpp"
+#include "boost/core/alloc_construct.hpp"
+#include "boost/core/empty_value.hpp"
 #include "boost/array.hpp"
 #include "boost/mpl/if.hpp"
 #include "boost/type_traits.hpp"
@@ -114,8 +119,10 @@ struct disable_multi_array_impl<int>
 template<typename T, std::size_t NumDims,
  typename Allocator>
 class multi_array :
-  public multi_array_ref<T,NumDims>
+  public multi_array_ref<T,NumDims>,
+  private boost::empty_value<Allocator>
 {
+  typedef boost::empty_value<Allocator> alloc_base;
  typedef multi_array_ref<T,NumDims> super_type;
 public:
  typedef typename super_type::value_type value_type;
@@ -142,22 +149,25 @@ public:
    typedef boost::detail::multi_array::multi_array_view<T,NDims> type;
  };

-  explicit multi_array() :
+  explicit multi_array(const Allocator& alloc = Allocator()) :
    super_type((T*)initial_base_,c_storage_order(),
-               /*index_bases=*/0, /*extents=*/0) {
+               /*index_bases=*/0, /*extents=*/0),
+    alloc_base(boost::empty_init_t(),alloc) {
    allocate_space(); 
  }

  template <class ExtentList>
  explicit multi_array(
-      ExtentList const& extents
+      ExtentList const& extents,
+      const Allocator& alloc = Allocator()
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
      , typename mpl::if_<
      detail::multi_array::is_multi_array_impl<ExtentList>,
      int&,int>::type* = 0
 #endif
      ) :
-    super_type((T*)initial_base_,extents) {
+    super_type((T*)initial_base_,extents),
+    alloc_base(boost::empty_init_t(),alloc) {
    boost::function_requires<
      detail::multi_array::CollectionConcept<ExtentList> >();
    allocate_space();
@@ -167,7 +177,8 @@ public:
  template <class ExtentList>
  explicit multi_array(ExtentList const& extents,
                       const general_storage_order<NumDims>& so) :
-    super_type((T*)initial_base_,extents,so) {
+    super_type((T*)initial_base_,extents,so),
+    alloc_base(boost::empty_init_t()) {
    boost::function_requires<
      detail::multi_array::CollectionConcept<ExtentList> >();
    allocate_space();
@@ -177,7 +188,8 @@ public:
  explicit multi_array(ExtentList const& extents,
                       const general_storage_order<NumDims>& so,
                       Allocator const& alloc) :
-    super_type((T*)initial_base_,extents,so), allocator_(alloc) {
+    super_type((T*)initial_base_,extents,so),
+    alloc_base(boost::empty_init_t(),alloc) {
    boost::function_requires<
      detail::multi_array::CollectionConcept<ExtentList> >();
    allocate_space();
@@ -185,8 +197,10 @@ public:


  explicit multi_array(const detail::multi_array
-                       ::extent_gen<NumDims>& ranges) :
-    super_type((T*)initial_base_,ranges) {
+                       ::extent_gen<NumDims>& ranges,
+                       const Allocator& alloc = Allocator()) :
+    super_type((T*)initial_base_,ranges),
+    alloc_base(boost::empty_init_t(),alloc) {

    allocate_space();
  }
@@ -195,7 +209,8 @@ public:
  explicit multi_array(const detail::multi_array
                       ::extent_gen<NumDims>& ranges,
                       const general_storage_order<NumDims>& so) :
-    super_type((T*)initial_base_,ranges,so) {
+    super_type((T*)initial_base_,ranges,so),
+    alloc_base(boost::empty_init_t()) {

    allocate_space();
  }
@@ -205,13 +220,15 @@ public:
                       ::extent_gen<NumDims>& ranges,
                       const general_storage_order<NumDims>& so,
                       Allocator const& alloc) :
-    super_type((T*)initial_base_,ranges,so), allocator_(alloc) {
+    super_type((T*)initial_base_,ranges,so),
+    alloc_base(boost::empty_init_t(),alloc) {

    allocate_space();
  }

  multi_array(const multi_array& rhs) :
-  super_type(rhs), allocator_(rhs.allocator_) {
+  super_type(rhs),
+  alloc_base(static_cast<const alloc_base&>(rhs)) {
    allocate_space();
    boost::detail::multi_array::copy_n(rhs.base_,rhs.num_elements(),base_);
  }
@@ -228,8 +245,10 @@ public:
 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
  template <typename OPtr>
  multi_array(const const_multi_array_ref<T,NumDims,OPtr>& rhs,
-              const general_storage_order<NumDims>& so = c_storage_order())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              const general_storage_order<NumDims>& so = c_storage_order(),
+              const Allocator& alloc = Allocator())
+    : super_type(0,so,rhs.index_bases(),rhs.shape()),
+      alloc_base(boost::empty_init_t(),alloc)
  {
    allocate_space();
    // Warning! storage order may change, hence the following copy technique.
@@ -239,8 +258,10 @@ public:
  template <typename OPtr>
  multi_array(const detail::multi_array::
              const_sub_array<T,NumDims,OPtr>& rhs,
-              const general_storage_order<NumDims>& so = c_storage_order())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              const general_storage_order<NumDims>& so = c_storage_order(),
+              const Allocator& alloc = Allocator())
+    : super_type(0,so,rhs.index_bases(),rhs.shape()),
+      alloc_base(boost::empty_init_t(),alloc)
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -250,8 +271,10 @@ public:
  template <typename OPtr>
  multi_array(const detail::multi_array::
              const_multi_array_view<T,NumDims,OPtr>& rhs,
-              const general_storage_order<NumDims>& so = c_storage_order())
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              const general_storage_order<NumDims>& so = c_storage_order(),
+              const Allocator& alloc = Allocator())
+    : super_type(0,so,rhs.index_bases(),rhs.shape()),
+      alloc_base(boost::empty_init_t(),alloc)
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -261,8 +284,10 @@ public:
  // More limited support for MSVC


-  multi_array(const const_multi_array_ref<T,NumDims>& rhs)
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
+  multi_array(const const_multi_array_ref<T,NumDims>& rhs,
+              const Allocator& alloc = Allocator())
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
+      alloc_base(boost::empty_init_t(),alloc)
  {
    allocate_space();
    // Warning! storage order may change, hence the following copy technique.
@@ -270,8 +295,10 @@ public:
  }

  multi_array(const const_multi_array_ref<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so)
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              const general_storage_order<NumDims>& so,
+              const Allocator& alloc = Allocator())
+    : super_type(0,so,rhs.index_bases(),rhs.shape()),
+      alloc_base(boost::empty_init_t(),alloc)
  {
    allocate_space();
    // Warning! storage order may change, hence the following copy technique.
@@ -279,8 +306,10 @@ public:
  }

  multi_array(const detail::multi_array::
-              const_sub_array<T,NumDims>& rhs)
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
+              const_sub_array<T,NumDims>& rhs,
+              const Allocator& alloc = Allocator())
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
+      alloc_base(boost::empty_init_t(),alloc)
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -288,8 +317,10 @@ public:

  multi_array(const detail::multi_array::
              const_sub_array<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so)
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              const general_storage_order<NumDims>& so,
+              const Allocator& alloc = Allocator())
+    : super_type(0,so,rhs.index_bases(),rhs.shape()),
+      alloc_base(boost::empty_init_t(),alloc)
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -297,8 +328,10 @@ public:


  multi_array(const detail::multi_array::
-              const_multi_array_view<T,NumDims>& rhs)
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
+              const_multi_array_view<T,NumDims>& rhs,
+              const Allocator& alloc = Allocator())
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
+      alloc_base(boost::empty_init_t(),alloc)
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -306,8 +339,10 @@ public:

  multi_array(const detail::multi_array::
              const_multi_array_view<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so)
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              const general_storage_order<NumDims>& so,
+              const Allocator& alloc = Allocator())
+    : super_type(0,so,rhs.index_bases(),rhs.shape()),
+      alloc_base(boost::empty_init_t(),alloc)
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -316,8 +351,10 @@ public:
 #endif // !BOOST_NO_FUNCTION_TEMPLATE_ORDERING

  // Thes constructors are necessary because of more exact template matches.
-  multi_array(const multi_array_ref<T,NumDims>& rhs)
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
+  multi_array(const multi_array_ref<T,NumDims>& rhs,
+              const Allocator& alloc = Allocator())
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
+      alloc_base(boost::empty_init_t(),alloc)
  {
    allocate_space();
    // Warning! storage order may change, hence the following copy technique.
@@ -325,8 +362,10 @@ public:
  }

  multi_array(const multi_array_ref<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so)
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              const general_storage_order<NumDims>& so,
+              const Allocator& alloc = Allocator())
+    : super_type(0,so,rhs.index_bases(),rhs.shape()),
+      alloc_base(boost::empty_init_t(),alloc)
  {
    allocate_space();
    // Warning! storage order may change, hence the following copy technique.
@@ -335,8 +374,10 @@ public:


  multi_array(const detail::multi_array::
-              sub_array<T,NumDims>& rhs)
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
+              sub_array<T,NumDims>& rhs,
+              const Allocator& alloc = Allocator())
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
+      alloc_base(boost::empty_init_t(),alloc)
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -344,8 +385,10 @@ public:

  multi_array(const detail::multi_array::
              sub_array<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so)
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              const general_storage_order<NumDims>& so,
+              const Allocator& alloc = Allocator())
+    : super_type(0,so,rhs.index_bases(),rhs.shape()),
+      alloc_base(boost::empty_init_t(),alloc)
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -353,8 +396,10 @@ public:


  multi_array(const detail::multi_array::
-              multi_array_view<T,NumDims>& rhs)
-    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) 
+              multi_array_view<T,NumDims>& rhs,
+              const Allocator& alloc = Allocator())
+    : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()),
+      alloc_base(boost::empty_init_t(),alloc)
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -362,8 +407,10 @@ public:
    
  multi_array(const detail::multi_array::
              multi_array_view<T,NumDims>& rhs,
-              const general_storage_order<NumDims>& so)
-    : super_type(0,so,rhs.index_bases(),rhs.shape()) 
+              const general_storage_order<NumDims>& so,
+              const Allocator& alloc = Allocator())
+    : super_type(0,so,rhs.index_bases(),rhs.shape()),
+      alloc_base(boost::empty_init_t(),alloc)
  {
    allocate_space();
    std::copy(rhs.begin(),rhs.end(),this->begin());
@@ -408,7 +455,7 @@ public:


    // build a multi_array with the specs given
-    multi_array new_array(ranges,this->storage_order());
+    multi_array new_array(ranges,this->storage_order(),allocator());


    // build a view of tmp with the minimum extents
@@ -454,6 +501,7 @@ public:
    using std::swap;
    // Swap the internals of these arrays.
    swap(this->super_type::base_,new_array.super_type::base_);
+    swap(this->allocator(),new_array.allocator());
    swap(this->storage_,new_array.storage_);
    swap(this->extent_list_,new_array.extent_list_);
    swap(this->stride_list_,new_array.stride_list_);
@@ -461,7 +509,6 @@ public:
    swap(this->origin_offset_,new_array.origin_offset_);
    swap(this->directional_offset_,new_array.directional_offset_);
    swap(this->num_elements_,new_array.num_elements_);
-    swap(this->allocator_,new_array.allocator_);
    swap(this->base_,new_array.base_);
    swap(this->allocated_elements_,new_array.allocated_elements_);

@@ -474,26 +521,43 @@ public:
  }

 private:
+  friend inline bool operator==(const multi_array& a, const multi_array& b) {
+    return a.base() == b.base();
+  }
+
+  friend inline bool operator!=(const multi_array& a, const multi_array& b) {
+    return !(a == b);
+  }
+
+  const super_type& base() const {
+    return *this;
+  }
+
+  const Allocator& allocator() const {
+    return alloc_base::get();
+  }
+
+  Allocator& allocator() {
+    return alloc_base::get();
+  }
+
  void allocate_space() {
-    typename Allocator::const_pointer no_hint=0;
-    base_ = allocator_.allocate(this->num_elements(),no_hint);
+    base_ = allocator().allocate(this->num_elements());
    this->set_base_ptr(base_);
    allocated_elements_ = this->num_elements();
-    std::uninitialized_fill_n(base_,allocated_elements_,T());
+    boost::alloc_construct_n(allocator(),base_,allocated_elements_);
  }

  void deallocate_space() {
    if(base_) {
-      for(T* i = base_; i != base_+allocated_elements_; ++i)
-        allocator_.destroy(i);
-      allocator_.deallocate(base_,allocated_elements_);
+      boost::alloc_destroy_n(allocator(),base_,allocated_elements_);
+      allocator().deallocate(base_,allocated_elements_);
    }
  }

  typedef boost::array<size_type,NumDims> size_list;
  typedef boost::array<index,NumDims> index_list;

-  Allocator allocator_;
  T* base_;
  size_type allocated_elements_;
  enum {initial_base_ = 0};
@@ -505,4 +569,4 @@ private:
 #  pragma GCC diagnostic pop
 #endif

-#endif // BOOST_MULTI_ARRAY_RG071801_HPP
+#endif
--- a/include/boost/multi_array/algorithm.hpp
+++ b/include/boost/multi_array/algorithm.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_ALGORITHM_RG071801_HPP
-#define BOOST_ALGORITHM_RG071801_HPP
+#ifndef BOOST_MULTI_ARRAY_ALGORITHM_HPP
+#define BOOST_MULTI_ARRAY_ALGORITHM_HPP

 //
 //
@@ -40,7 +40,7 @@
 //  See http://www.boost.org/libs/multi_array for documentation.


-#include "boost/iterator.hpp"
+#include <iterator>

 namespace boost {
 namespace detail {
@@ -100,4 +100,4 @@ copy_n(InputIter first, Size count, OutputIter result) {
 } // namespace detail
 } // namespace boost

-#endif // BOOST_ALGORITHM_RG071801_HPP
+#endif
--- a/include/boost/multi_array/base.hpp
+++ b/include/boost/multi_array/base.hpp
@@ -10,8 +10,8 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.

-#ifndef BASE_RG071801_HPP
-#define BASE_RG071801_HPP
+#ifndef BOOST_MULTI_ARRAY_BASE_HPP
+#define BOOST_MULTI_ARRAY_BASE_HPP

 //
 // base.hpp - some implementation base classes for from which
@@ -498,4 +498,4 @@ protected:

 } // namespace boost

-#endif // BASE_RG071801_HPP
+#endif
--- a/include/boost/multi_array/collection_concept.hpp
+++ b/include/boost/multi_array/collection_concept.hpp
@@ -10,8 +10,8 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.

-#ifndef COLLECTION_CONCEPT_RG103101_HPP
-#define COLLECTION_CONCEPT_RG103101_HPP
+#ifndef BOOST_MULTI_ARRAY_COLLECTION_CONCEPT_HPP
+#define BOOST_MULTI_ARRAY_COLLECTION_CONCEPT_HPP

 #include "boost/concept_check.hpp"

@@ -23,4 +23,4 @@ namespace multi_array { // Old location for this
 }

 }
-#endif // COLLECTION_CONCEPT_RG103101_HPP
+#endif
--- a/include/boost/multi_array/concept_checks.hpp
+++ b/include/boost/multi_array/concept_checks.hpp
@@ -10,8 +10,8 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.

-#ifndef BOOST_MULTI_ARRAY_CONCEPT_CHECKS_RG110101_HPP
-#define BOOST_MULTI_ARRAY_CONCEPT_CHECKS_RG110101_HPP
+#ifndef BOOST_MULTI_ARRAY_CONCEPT_CHECKS_HPP
+#define BOOST_MULTI_ARRAY_CONCEPT_CHECKS_HPP

 //
 // concept-checks.hpp - Checks out Const MultiArray and MultiArray
@@ -218,4 +218,4 @@ namespace detail {
 } // namespace boost


-#endif // BOOST_MULTI_ARRAY_CONCEPT_CHECKS_RG110101_HPP
+#endif
--- a/include/boost/multi_array/copy_array.hpp
+++ b/include/boost/multi_array/copy_array.hpp
@@ -10,8 +10,8 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.

-#ifndef COPY_ARRAY_RG092101_HPP
-#define COPY_ARRAY_RG092101_HPP
+#ifndef BOOST_MULTI_ARRAY_COPY_ARRAY_HPP
+#define BOOST_MULTI_ARRAY_COPY_ARRAY_HPP

 //
 // copy_array.hpp - generic code for copying the contents of one
@@ -65,4 +65,4 @@ void copy_array (Array1& source, Array2& dest) {
 } // namespace detail
 } // namespace boost

-#endif // COPY_ARRAY_RG092101_HPP
+#endif
--- a/include/boost/multi_array/extent_gen.hpp
+++ b/include/boost/multi_array/extent_gen.hpp
@@ -10,8 +10,8 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.

-#ifndef BOOST_EXTENT_GEN_RG071801_HPP
-#define BOOST_EXTENT_GEN_RG071801_HPP
+#ifndef BOOST_MULTI_ARRAY_EXTENT_GEN_HPP
+#define BOOST_MULTI_ARRAY_EXTENT_GEN_HPP

 #include "boost/multi_array/extent_range.hpp"
 #include "boost/multi_array/range_list.hpp"
@@ -72,4 +72,4 @@ public:
 } // namespace boost


-#endif // BOOST_EXTENT_GEN_RG071801_HPP
+#endif
--- a/include/boost/multi_array/extent_range.hpp
+++ b/include/boost/multi_array/extent_range.hpp
@@ -10,8 +10,8 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.

-#ifndef BOOST_EXTENT_RANGE_RG071801_HPP
-#define BOOST_EXTENT_RANGE_RG071801_HPP
+#ifndef BOOST_MULTI_ARRAY_EXTENT_RANGE_HPP
+#define BOOST_MULTI_ARRAY_EXTENT_RANGE_HPP

 #include <utility>

@@ -46,4 +46,4 @@ public:
 } // namespace boost


-#endif // BOOST_EXTENT_RANGE_RG071801_HPP
+#endif
--- a/include/boost/multi_array/index_gen.hpp
+++ b/include/boost/multi_array/index_gen.hpp
@@ -10,8 +10,8 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.

-#ifndef BOOST_INDEX_GEN_RG071801_HPP
-#define BOOST_INDEX_GEN_RG071801_HPP
+#ifndef BOOST_MULTI_ARRAY_INDEX_GEN_HPP
+#define BOOST_MULTI_ARRAY_INDEX_GEN_HPP

 #include "boost/array.hpp"
 #include "boost/multi_array/index_range.hpp"
@@ -78,4 +78,4 @@ public:
 } // namespace boost


-#endif // BOOST_INDEX_GEN_RG071801_HPP
+#endif
--- a/include/boost/multi_array/index_range.hpp
+++ b/include/boost/multi_array/index_range.hpp
@@ -10,8 +10,8 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.

-#ifndef BOOST_INDEX_RANGE_RG071801_HPP
-#define BOOST_INDEX_RANGE_RG071801_HPP
+#ifndef BOOST_MULTI_ARRAY_INDEX_RANGE_HPP
+#define BOOST_MULTI_ARRAY_INDEX_RANGE_HPP

 #include <boost/config.hpp>
 #include <utility>
@@ -107,6 +107,12 @@ namespace multi_array {

    index stride() const { return stride_; }

+    size_type size(index idx) const
+    {
+      return (start_ == from_start() || finish_ == to_end())
+        ? idx : ((finish_ - start_) / stride_);
+    }
+
    void set_index_range(index start, index finish, index stride=1)
    {
      start_ = start;
@@ -185,4 +191,4 @@ namespace multi_array {
 } // namespace detail  
 } // namespace boost

-#endif // BOOST_INDEX_RANGE_RG071801_HPP
+#endif
--- a/include/boost/multi_array/iterator.hpp
+++ b/include/boost/multi_array/iterator.hpp
@@ -10,8 +10,8 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.

-#ifndef ITERATOR_RG071801_HPP
-#define ITERATOR_RG071801_HPP
+#ifndef BOOST_MULTI_ARRAY_ITERATOR_HPP
+#define BOOST_MULTI_ARRAY_ITERATOR_HPP

 //
 // iterator.hpp - implementation of iterators for the
@@ -162,4 +162,4 @@ public:
 } // namespace detail
 } // namespace boost

-#endif // ITERATOR_RG071801_HPP
+#endif
--- a/include/boost/multi_array/multi_array_ref.hpp
+++ b/include/boost/multi_array/multi_array_ref.hpp
@@ -10,8 +10,8 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.

-#ifndef BOOST_MULTI_ARRAY_REF_RG071801_HPP
-#define BOOST_MULTI_ARRAY_REF_RG071801_HPP
+#ifndef BOOST_MULTI_ARRAY_MULTI_ARRAY_REF_HPP
+#define BOOST_MULTI_ARRAY_MULTI_ARRAY_REF_HPP

 //
 // multi_array_ref.hpp - code for creating "views" of array data.
@@ -619,4 +619,4 @@ protected:

 } // namespace boost

-#endif // BOOST_MULTI_ARRAY_REF_RG071801_HPP
+#endif
--- a/include/boost/multi_array/range_list.hpp
+++ b/include/boost/multi_array/range_list.hpp
@@ -10,8 +10,8 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.

-#ifndef RANGE_LIST_RG072501_HPP
-#define RANGE_LIST_RG072501_HPP
+#ifndef BOOST_MULTI_ARRAY_RANGE_LIST_HPP
+#define BOOST_MULTI_ARRAY_RANGE_LIST_HPP
 //
 // range_list.hpp - helper to build boost::arrays for *_set types
 //
@@ -67,4 +67,4 @@ public:
 } // namespace detail
 } // namespace boost

-#endif // RANGE_LIST_RG072501_HPP
+#endif
--- a/include/boost/multi_array/storage_order.hpp
+++ b/include/boost/multi_array/storage_order.hpp
@@ -10,8 +10,8 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.

-#ifndef BOOST_STORAGE_ORDER_RG071801_HPP
-#define BOOST_STORAGE_ORDER_RG071801_HPP
+#ifndef BOOST_MULTI_ARRAY_STORAGE_ORDER_HPP
+#define BOOST_MULTI_ARRAY_STORAGE_ORDER_HPP

 #include "boost/multi_array/types.hpp"
 #include "boost/array.hpp"
@@ -122,4 +122,4 @@ namespace boost {

 } // namespace boost

-#endif // BOOST_ARRAY_STORAGE_RG071801_HPP
+#endif
--- a/include/boost/multi_array/subarray.hpp
+++ b/include/boost/multi_array/subarray.hpp
@@ -10,8 +10,8 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.

-#ifndef SUBARRAY_RG071801_HPP
-#define SUBARRAY_RG071801_HPP
+#ifndef BOOST_MULTI_ARRAY_SUBARRAY_HPP
+#define BOOST_MULTI_ARRAY_SUBARRAY_HPP

 //
 // subarray.hpp - used to implement standard operator[] on
@@ -384,4 +384,4 @@ public:
 };
 } // namespace boost
  
-#endif // SUBARRAY_RG071801_HPP
+#endif
--- a/include/boost/multi_array/types.hpp
+++ b/include/boost/multi_array/types.hpp
@@ -11,8 +11,8 @@
 //  See http://www.boost.org/libs/multi_array for documentation.


-#ifndef BOOST_MULTI_ARRAY_TYPES_RG071801_HPP
-#define BOOST_MULTI_ARRAY_TYPES_RG071801_HPP
+#ifndef BOOST_MULTI_ARRAY_TYPES_HPP
+#define BOOST_MULTI_ARRAY_TYPES_HPP

 //
 // types.hpp - supply types that are needed by several headers
@@ -35,4 +35,4 @@ typedef std::ptrdiff_t index;



-#endif // BOOST_MULTI_ARRAY_TYPES_RG071801_HPP
+#endif
--- a/include/boost/multi_array/view.hpp
+++ b/include/boost/multi_array/view.hpp
@@ -10,8 +10,8 @@
 //           Andrew Lumsdaine
 //  See http://www.boost.org/libs/multi_array for documentation.

-#ifndef BOOST_MULTI_ARRAY_VIEW_RG071301_HPP
-#define BOOST_MULTI_ARRAY_VIEW_RG071301_HPP
+#ifndef BOOST_MULTI_ARRAY_VIEW_HPP
+#define BOOST_MULTI_ARRAY_VIEW_HPP

 //
 // view.hpp - code for creating "views" of array data.
@@ -457,5 +457,4 @@ public:

 } // namespace boost

-#endif // BOOST_MULTI_ARRAY_VIEW_RG071301_HPP
-
+#endif
--- a/meta/libraries.json
+++ b/meta/libraries.json
@@ -11,5 +11,6 @@
    ],
    "maintainers": [
        "Ronald Garcia <garcia -at- osl.iu.edu>"
-    ]
+    ],
+    "cxxstd": "03"
 }
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -4,48 +4,50 @@
 # "as is" without express or implied warranty, and with no claim as
 # to its suitability for any purpose.

-test-suite multi_array
-    : 
-      [ compile-fail fail_cbracket.cpp ]
-      [ compile-fail fail_cdata.cpp ]
-      [ compile-fail fail_citerator.cpp ]
-      [ compile-fail fail_cparen.cpp ]
-      [ compile-fail fail_criterator.cpp ]
-      [ compile-fail fail_csubarray.cpp ]
-      [ compile-fail fail_csubarray2.cpp ]
-      [ compile-fail fail_csubarray3.cpp ]
-      [ compile-fail fail_cview.cpp ]
-      [ compile-fail fail_cview2.cpp ]
-      [ compile-fail fail_cview3.cpp ]
-      [ compile-fail fail_ref_cbracket.cpp ]
-      [ compile-fail fail_ref_cdata.cpp ]
-      [ compile-fail fail_ref_citerator.cpp ]
-      [ compile-fail fail_ref_cparen.cpp ]
-      [ compile-fail fail_ref_criterator.cpp ]
-      [ compile-fail fail_ref_csubarray.cpp ]
-      [ compile-fail fail_ref_csubarray2.cpp ]
-      [ compile-fail fail_ref_csubarray3.cpp ]
-      [ compile-fail fail_ref_cview.cpp ]
-      [ compile-fail fail_ref_cview2.cpp ]
-      [ compile-fail fail_ref_cview3.cpp ]
-  
-      [ run constructors.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run access.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run compare.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run iterators.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run slice.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run assign.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run assign_to_array.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run index_bases.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run storage_order_convert.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run storage_order.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run reshape.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run range1.cpp ../../test/build//boost_test_exec_monitor  ]
-      [ run idxgen1.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run stl_interaction.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run resize.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run assert.cpp ../../test/build//boost_test_exec_monitor ]
-      [ run reverse_view.cpp ../../test/build//boost_test_exec_monitor ]
+import testing ;

-      [ compile concept_checks.cpp ]
-    ;
+project : requirements <library>/boost/multi_array//boost_multi_array ;
+
+compile-fail fail_cbracket.cpp ;
+compile-fail fail_cdata.cpp ;
+compile-fail fail_citerator.cpp ;
+compile-fail fail_cparen.cpp ;
+compile-fail fail_criterator.cpp ;
+compile-fail fail_csubarray.cpp ;
+compile-fail fail_csubarray2.cpp ;
+compile-fail fail_csubarray3.cpp ;
+compile-fail fail_cview.cpp ;
+compile-fail fail_cview2.cpp : <library>/boost/test//included ;
+compile-fail fail_cview3.cpp ;
+compile-fail fail_ref_cbracket.cpp ;
+compile-fail fail_ref_cdata.cpp ;
+compile-fail fail_ref_citerator.cpp ;
+compile-fail fail_ref_cparen.cpp ;
+compile-fail fail_ref_criterator.cpp ;
+compile-fail fail_ref_csubarray.cpp ;
+compile-fail fail_ref_csubarray2.cpp ;
+compile-fail fail_ref_csubarray3.cpp ;
+compile-fail fail_ref_cview.cpp ;
+compile-fail fail_ref_cview2.cpp ;
+compile-fail fail_ref_cview3.cpp ;
+
+run constructors.cpp ;
+run access.cpp ;
+run compare.cpp ;
+run iterators.cpp ;
+run slice.cpp ;
+run assign.cpp ;
+run assign_to_array.cpp ;
+run index_bases.cpp ;
+run storage_order_convert.cpp ;
+run storage_order.cpp ;
+run reshape.cpp ;
+run range1.cpp  ;
+run idxgen1.cpp ;
+run stl_interaction.cpp ;
+run resize.cpp ;
+run assert.cpp ;
+run reverse_view.cpp ;
+run allocators.cpp ;
+
+compile concept_checks.cpp ;
--- a/test/access.cpp
+++ b/test/access.cpp
@@ -16,7 +16,7 @@
 //

 #include "generative_tests.hpp"
-#include "boost/static_assert.hpp"
+#include <boost/static_assert.hpp>

 template <typename Array>
 void access(Array& A, const mutable_array_tag&) {
@@ -42,8 +42,8 @@ void access(Array& A, const const_array_tag&) {
  for (index i = idx0; i != idx0+2; ++i)
    for (index j = idx1; j != idx1+3; ++j)
      for (index k = idx2; k != idx2+4; ++k) {
-        BOOST_CHECK(A[i][j][k] == cnum++);
-        BOOST_CHECK(CA[i][j][k] == A[i][j][k]);
+        BOOST_TEST(A[i][j][k] == cnum++);
+        BOOST_TEST(CA[i][j][k] == A[i][j][k]);
      }

  // operator()
@@ -52,12 +52,12 @@ void access(Array& A, const const_array_tag&) {
      for (index k2 = idx2; k2 != idx2+4; ++k2) {
        boost::array<index,ndims> indices;
        indices[0] = i2; indices[1] = j2; indices[2] = k2;
-        BOOST_CHECK(A(indices) == A[i2][j2][k2]);
-        BOOST_CHECK(CA(indices) == A(indices));
+        BOOST_TEST(A(indices) == A[i2][j2][k2]);
+        BOOST_TEST(CA(indices) == A(indices));
      }
  ++tests_run;
 }

-int test_main(int,char*[]) {
+int main() {
  return run_generative_tests();
 }
--- a/test/allocators.cpp
+++ b/test/allocators.cpp
@@ -0,0 +1,151 @@
+// Copyright 2019 Glen Joseph Fernandes
+// (glenjofe@gmail.com)
+//
+// 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 <boost/core/lightweight_test.hpp>
+#include <boost/multi_array.hpp>
+#include <algorithm>
+
+template<class T>
+class creator {
+public:
+  typedef T value_type;
+  typedef T* pointer;
+  typedef std::size_t size_type;
+  typedef std::ptrdiff_t difference_type;
+
+  template<class U>
+  struct rebind {
+    typedef creator<U> other;
+  };
+
+  creator(int state)
+    : state_(state) { }
+
+  template<class U>
+  creator(const creator<U>& other)
+    : state_(other.state()) { }
+
+  T* allocate(std::size_t size) {
+    return static_cast<T*>(::operator new(sizeof(T) * size));
+  }
+
+  void deallocate(T* ptr, std::size_t) {
+    ::operator delete(ptr);
+  }
+
+  int state() const {
+    return state_;
+  }
+
+private:
+  int state_;
+};
+
+template<class T, class U>
+inline bool
+operator==(const creator<T>& a, const creator<U>& b)
+{
+  return a.state() == b.state();
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>& a, const creator<U>& b)
+{
+  return !(a == b);
+}
+
+void test(const double&, std::size_t*, int*, unsigned)
+{
+}
+
+template<class Array>
+void test(const Array& array, std::size_t* sizes, int* strides,
+    unsigned elements)
+{
+  BOOST_TEST(array.num_elements() == elements);
+  BOOST_TEST(array.size() == *sizes);
+  BOOST_TEST(std::equal(sizes, sizes + array.num_dimensions(), array.shape()));
+  BOOST_TEST(std::equal(strides, strides + array.num_dimensions(),
+    array.strides()));
+  test(array[0], ++sizes, ++strides, elements / array.size());
+}
+
+bool test(const double& a, const double& b)
+{
+  return a == b;
+}
+
+template<class A1, class A2>
+bool test(const A1& a1, const A2& a2)
+{
+  typename A1::const_iterator i1 = a1.begin();
+  typename A2::const_iterator i2 = a2.begin();
+  for (; i1 != a1.end(); ++i1, ++i2) {
+    if (!test(*i1, *i2)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+int main()
+{
+  typedef boost::multi_array<double, 3, creator<double> > type;
+  creator<double> state(1);
+  {
+    type array(state);
+  }
+  boost::array<type::size_type, 3> sizes = { { 3, 3, 3 } };
+  type::size_type elements = 27;
+  {
+    int strides[] = { 9, 3, 1 };
+    type array(sizes, state);
+    test(array, &sizes[0], strides, elements);
+  }
+  {
+    int strides[] = { 1, 3, 9 };
+    type array(sizes, boost::fortran_storage_order(), state);
+    test(array, &sizes[0], strides, elements);
+  }
+  {
+    int strides[] = { 9, 3, 1 };
+    type::extent_gen extents;
+    type array(extents[3][3][3], state);
+    test(array, &sizes[0], strides, elements);
+  }
+  {
+    type array1(sizes, state);
+    std::vector<double> values(elements, 4.5);
+    array1.assign(values.begin(), values.end());
+    type array2(array1);
+    int strides[] = { 9, 3, 1 };
+    test(array2, &sizes[0], strides, elements);
+    BOOST_TEST(test(array1, array2));
+  }
+  {
+    type array1(sizes, state);
+    type array2(sizes, state);
+    std::vector<double> values(elements, 4.5);
+    array1.assign(values.begin(), values.end());
+    array2 = array1;
+    int strides[] = { 9, 3, 1 };
+    test(array2, &sizes[0], strides, elements);
+    BOOST_TEST(test(array1, array2));
+  }
+  {
+    type array1(sizes, state);
+    std::vector<double> values(elements, 4.5);
+    array1.assign(values.begin(), values.end());
+    typedef type::subarray<2>::type other;
+    other array2 = array1[1];
+    other::value_type value = array2[0];
+    BOOST_TEST(test(array1[1][0], value));
+    BOOST_TEST(test(array2[0], value));
+  }
+  return boost::report_errors();
+}
--- a/test/assert.cpp
+++ b/test/assert.cpp
@@ -15,10 +15,10 @@
 // with exceptions
 //

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

 #define BOOST_ENABLE_ASSERT_HANDLER
-#include "boost/multi_array.hpp" // includes assert.hpp
+#include <boost/multi_array.hpp> // includes assert.hpp

 #include <stdexcept>

@@ -40,7 +40,7 @@ namespace boost {
 using namespace boost;

 int
-test_main(int,char*[]) {
+main() {

  typedef multi_array<int,2> array_t;

@@ -55,5 +55,5 @@ test_main(int,char*[]) {
    //...all good
  }

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/assign.cpp
+++ b/test/assign.cpp
@@ -15,9 +15,9 @@
 //
 //
 #include "generative_tests.hpp"
-#include "boost/array.hpp"
-#include "boost/multi_array.hpp"
-#include "boost/cstdlib.hpp"
+#include <boost/array.hpp>
+#include <boost/multi_array.hpp>
+#include <boost/cstdlib.hpp>
 #include <algorithm>
 #include <iostream>

@@ -59,7 +59,7 @@ void access(Array& A, const mutable_array_tag&) {

  A = filler;

-  BOOST_CHECK(::equal(A,filler));
+  BOOST_TEST(::equal(A,filler));
  ++tests_run;
 }

@@ -68,6 +68,6 @@ void access(Array&, const const_array_tag&) {
 }


-int test_main(int,char*[]) {
+int main() {
  return run_generative_tests();
 }
--- a/test/assign_to_array.cpp
+++ b/test/assign_to_array.cpp
@@ -16,9 +16,9 @@
 //
 //
 #include "generative_tests.hpp"
-#include "boost/array.hpp"
-#include "boost/multi_array.hpp"
-#include "boost/cstdlib.hpp"
+#include <boost/array.hpp>
+#include <boost/multi_array.hpp>
+#include <boost/cstdlib.hpp>
 #include <algorithm>
 #include <iostream>

@@ -50,11 +50,11 @@ template <typename Array>
 void access(Array& A, const const_array_tag&) {
  typedef boost::multi_array<int,3> array3;
  array3 acopy(A);
-  BOOST_CHECK(::equal(acopy,A));
+  BOOST_TEST(::equal(acopy,A));
  ++tests_run;
 }


-int test_main(int,char*[]) {
+int main() {
  return run_generative_tests();
 }
--- a/test/compare.cpp
+++ b/test/compare.cpp
@@ -12,16 +12,16 @@



-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

 #include <algorithm>
 #include <list>


 int
-test_main(int, char*[])
+main()
 {
  typedef boost::multi_array<double, 3> array;
  typedef array::size_type size_type;
@@ -34,9 +34,9 @@ test_main(int, char*[])
    std::vector<double> vals(num_elements, 4.5);
    A.assign(vals.begin(),vals.end());
    array B(A);
-    BOOST_CHECK(A == B);
-    BOOST_CHECK(B == A);
-    BOOST_CHECK(A[0] == B[0]);
+    BOOST_TEST(A == B);
+    BOOST_TEST(B == A);
+    BOOST_TEST(A[0] == B[0]);
  }
  // Assignment Operator
  {
@@ -44,15 +44,15 @@ test_main(int, char*[])
    std::vector<double> vals(num_elements, 4.5);
    A.assign(vals.begin(),vals.end());
    B = A;
-    BOOST_CHECK(A == B);
-    BOOST_CHECK(B == A);
-    BOOST_CHECK(B[0] == A[0]);
+    BOOST_TEST(A == B);
+    BOOST_TEST(B == A);
+    BOOST_TEST(B[0] == A[0]);

    typedef array::index_range range;
    array::index_gen indices;
    array::array_view<2>::type C = A[indices[2][range()][range()]];
    array::array_view<2>::type D = B[indices[2][range()][range()]];
-    BOOST_CHECK(C == D);
+    BOOST_TEST(C == D);
  }
  // Different Arrays
  {
@@ -62,15 +62,15 @@ test_main(int, char*[])
    A.assign(valsA.begin(),valsA.end());
    B.assign(valsB.begin(),valsB.end());

-    BOOST_CHECK(A != B);
-    BOOST_CHECK(B != A);
-    BOOST_CHECK(A[0] != B[0]);
+    BOOST_TEST(A != B);
+    BOOST_TEST(B != A);
+    BOOST_TEST(A[0] != B[0]);

    typedef array::index_range range;
    array::index_gen indices;
    array::array_view<2>::type C = A[indices[2][range()][range()]];
    array::array_view<2>::type D = B[indices[2][range()][range()]];
-    BOOST_CHECK(C != D);
+    BOOST_TEST(C != D);
  }

  // Comparisons galore!
@@ -108,35 +108,35 @@ test_main(int, char*[])
    A.assign(valsA,valsA+num_elements);
    B.assign(valsB,valsB+num_elements);

-    BOOST_CHECK(B < A);
-    BOOST_CHECK(A > B);
+    BOOST_TEST(B < A);
+    BOOST_TEST(A > B);

-    BOOST_CHECK(B <= A);
-    BOOST_CHECK(A >= B);
+    BOOST_TEST(B <= A);
+    BOOST_TEST(A >= B);

-    BOOST_CHECK(B[0] == A[0]);
-    BOOST_CHECK(B[2] < A[2]);
+    BOOST_TEST(B[0] == A[0]);
+    BOOST_TEST(B[2] < A[2]);

    array C = A;
    
-    BOOST_CHECK(C <= A);
-    BOOST_CHECK(C >= A);
+    BOOST_TEST(C <= A);
+    BOOST_TEST(C >= A);

-    BOOST_CHECK(!(C < A));
-    BOOST_CHECK(!(C > A));
+    BOOST_TEST(!(C < A));
+    BOOST_TEST(!(C > A));

    typedef array::index_range range;
    array::index_gen indices;
    array::array_view<2>::type D = A[indices[2][range()][range()]];
    array::array_view<2>::type E = B[indices[2][range()][range()]];

-    BOOST_CHECK(E < D);
-    BOOST_CHECK(E <= D);
+    BOOST_TEST(E < D);
+    BOOST_TEST(E <= D);
  }



-  return boost::exit_success;
+  return boost::report_errors();
 }


--- a/test/concept_checks.cpp
+++ b/test/concept_checks.cpp
@@ -15,18 +15,18 @@
 //   make sure the types meet concept requirements
 //

-#include "boost/concept_check.hpp"
-#include "boost/multi_array/concept_checks.hpp"
-#include "boost/multi_array.hpp"
+#include <boost/concept_check.hpp>
+#include <boost/multi_array/concept_checks.hpp>
+#include <boost/multi_array.hpp>

-#include "boost/cstdlib.hpp"
+#include <boost/cstdlib.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array<int,ndims> array;
--- a/test/constructors.cpp
+++ b/test/constructors.cpp
@@ -15,9 +15,9 @@
 //


-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 #include <algorithm>
 #include <list>

@@ -30,10 +30,10 @@ void check_shape(const Array& A,
                 int* strides,
                 unsigned int num_elements)
 {
-  BOOST_CHECK(A.num_elements() == num_elements);
-  BOOST_CHECK(A.size() == *sizes);
-  BOOST_CHECK(std::equal(sizes, sizes + A.num_dimensions(), A.shape()));
-  BOOST_CHECK(std::equal(strides, strides + A.num_dimensions(), A.strides()));
+  BOOST_TEST(A.num_elements() == num_elements);
+  BOOST_TEST(A.size() == *sizes);
+  BOOST_TEST(std::equal(sizes, sizes + A.num_dimensions(), A.shape()));
+  BOOST_TEST(std::equal(strides, strides + A.num_dimensions(), A.strides()));
  check_shape(A[0], ++sizes, ++strides, num_elements / A.size());
 }

@@ -56,7 +56,7 @@ bool equal(const ArrayA& A, const ArrayB& B)


 int
-test_main(int, char*[])
+main()
 {
  typedef boost::multi_array<double, 3>::size_type size_type;
  boost::array<size_type,3> sizes = { { 3, 3, 3 } };
@@ -132,20 +132,20 @@ test_main(int, char*[])
    A.assign(vals.begin(),vals.end());
    boost::multi_array<double, 3> B(A);
    check_shape(B, &sizes[0], strides, num_elements);
-    BOOST_CHECK(::equal(A, B));
+    BOOST_TEST(::equal(A, B));

    double ptr[27];
    boost::multi_array_ref<double, 3> C(ptr,sizes);
    A.assign(vals.begin(),vals.end());
    boost::multi_array_ref<double, 3> D(C);
    check_shape(D, &sizes[0], strides, num_elements);
-    BOOST_CHECK(C.data() == D.data());
+    BOOST_TEST(C.data() == D.data());

    const double* cptr = ptr;
    boost::const_multi_array_ref<double, 3> E(cptr,sizes);
    boost::const_multi_array_ref<double, 3> F(E);
    check_shape(F, &sizes[0], strides, num_elements);
-    BOOST_CHECK(E.data() == F.data());
+    BOOST_TEST(E.data() == F.data());
  }


@@ -161,15 +161,15 @@ test_main(int, char*[])
    boost::const_multi_array_ref<double, 3> C(A);
    check_shape(B, &sizes[0], strides, num_elements);
    check_shape(C, &sizes[0], strides, num_elements);
-    BOOST_CHECK(B.data() == A.data());
-    BOOST_CHECK(C.data() == A.data());
+    BOOST_TEST(B.data() == A.data());
+    BOOST_TEST(C.data() == A.data());

    double ptr[27];
    boost::multi_array_ref<double, 3> D(ptr,sizes);
    D.assign(vals.begin(),vals.end());
    boost::const_multi_array_ref<double, 3> E(D);
    check_shape(E, &sizes[0], strides, num_elements);
-    BOOST_CHECK(E.data() == D.data());
+    BOOST_TEST(E.data() == D.data());
  }

  // Assignment Operator
@@ -182,7 +182,7 @@ test_main(int, char*[])
    A.assign(vals.begin(),vals.end());
    B = A;
    check_shape(B, &sizes[0], strides, num_elements);
-    BOOST_CHECK(::equal(A, B));
+    BOOST_TEST(::equal(A, B));

    double ptr1[27];
    double ptr2[27];
@@ -190,7 +190,7 @@ test_main(int, char*[])
    C.assign(vals.begin(),vals.end());
    D = C;
    check_shape(D, &sizes[0], strides, num_elements);
-    BOOST_CHECK(::equal(C,D));
+    BOOST_TEST(::equal(C,D));
  }


@@ -209,10 +209,10 @@ test_main(int, char*[])
    subarray::value_type C = B[0];

    // should comparisons between the types work?
-    BOOST_CHECK(::equal(A[1][0],C));
-    BOOST_CHECK(::equal(B[0],C));
+    BOOST_TEST(::equal(A[1][0],C));
+    BOOST_TEST(::equal(B[0],C));
  }
-  return boost::exit_success;
+  return boost::report_errors();
 }


--- a/test/dimtest.cpp
+++ b/test/dimtest.cpp
@@ -13,9 +13,9 @@
 //
 // Trying to diagnose problems under visual

-#include "boost/config.hpp"
-#include "boost/array.hpp"
-#include "boost/limits.hpp"
+#include <boost/config.hpp>
+#include <boost/array.hpp>
+#include <boost/limits.hpp>
 #include <algorithm>
 #include <utility>

--- a/test/fail_cbracket.cpp
+++ b/test/fail_cbracket.cpp
@@ -15,14 +15,14 @@
 //   checking constness of  const operator[].
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array<int,ndims> array;
@@ -36,5 +36,5 @@ test_main(int,char*[])
  // FAIL! cannot assign to csma.
  csma[0][0][0] = 5;

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/fail_cdata.cpp
+++ b/test/fail_cdata.cpp
@@ -15,14 +15,14 @@
 //   Testing data() member function constness.
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array<int,ndims> array;
@@ -37,5 +37,5 @@ test_main(int,char*[])

  // FAIL! data() returns a const int*
  *csma.data() = 0;
-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/fail_citerator.cpp
+++ b/test/fail_citerator.cpp
@@ -15,12 +15,12 @@
 //   const_iterator/iterator conversion  test
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>


-int test_main(int,char*[]) {
+int main() {
  typedef boost::multi_array<int,3> array;

  typedef array::iterator iterator1;
@@ -29,5 +29,5 @@ int test_main(int,char*[]) {
  // ILLEGAL conversion from const_iterator to iterator
  iterator1 in = citerator1();

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/fail_cparen.cpp
+++ b/test/fail_cparen.cpp
@@ -15,14 +15,14 @@
 //   Testing const operator() constness.
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array<int,ndims> array;
@@ -40,5 +40,5 @@ test_main(int,char*[])
  // FAIL! Cannot assign to csma
  csma(indices) = 5;

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/fail_criterator.cpp
+++ b/test/fail_criterator.cpp
@@ -15,12 +15,12 @@
 //   const_reverse_iterator/reverse_iterator conversion  test
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>


-int test_main(int,char*[]) {
+int main() {
    typedef boost::multi_array<int,3> array;

    typedef array::reverse_iterator riterator1;
@@ -29,5 +29,5 @@ int test_main(int,char*[]) {
    // ILLEGAL conversion from const_reverse_iterator to reverse_iterator
    riterator1 in = criterator1();

-    return boost::exit_success;
+    return boost::report_errors();
 }
--- a/test/fail_csubarray.cpp
+++ b/test/fail_csubarray.cpp
@@ -15,14 +15,14 @@
 //   Testing subarray and const_subarray assignment 
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array<int,ndims> array;
@@ -42,5 +42,5 @@ test_main(int,char*[])
  // FAIL! Preserve constness (no const_subarray -> subarray conversion).
  array::subarray<ndims-1>::type sba = csba;

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/fail_csubarray2.cpp
+++ b/test/fail_csubarray2.cpp
@@ -15,14 +15,14 @@
 //   Testing constness of subarray operations.
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array<int,ndims> array;
@@ -41,5 +41,5 @@ test_main(int,char*[])
  // FAIL! preserve constness.
  array::subarray<ndims-1>::type sba = sma_const[0];

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/fail_csubarray3.cpp
+++ b/test/fail_csubarray3.cpp
@@ -15,14 +15,14 @@
 //  Testing constness of subarray operations.
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array<int,ndims> array;
@@ -45,5 +45,5 @@ test_main(int,char*[])
        // FAIL! sba cannot be assigned to.
        sba[j][k] = num++;

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/fail_cview.cpp
+++ b/test/fail_cview.cpp
@@ -15,15 +15,15 @@
 //   ensure const_array_view doesn't allow element assignment.
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
-#include "boost/type.hpp"
+#include <boost/array.hpp>
+#include <boost/type.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array<int,ndims> array;
@@ -54,7 +54,7 @@ test_main(int,char*[])
  // FAIL! const_array_view cannot be assigned to.
  csma2(elmt) = 5;
  
-  return boost::exit_success;
+  return boost::report_errors();
 }


--- a/test/fail_cview2.cpp
+++ b/test/fail_cview2.cpp
@@ -15,17 +15,17 @@
 //   ensure const_array_view cannot be converted to array_view
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

 #define BOOST_INCLUDE_MAIN
-#include "boost/test/test_tools.hpp"
+#include <boost/test/test_tools.hpp>

-#include "boost/array.hpp"
-#include "boost/type.hpp"
-#include "boost/cstdlib.hpp"
+#include <boost/array.hpp>
+#include <boost/type.hpp>
+#include <boost/cstdlib.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array<int,ndims> array;
@@ -52,7 +52,7 @@ test_main(int,char*[])
  array::array_view<ndims>::type csma2 =
    csma[indices[range(0,2)][range(1,3)][range(0,4,2)]];

-  return boost::exit_success;
+  return boost::report_errors();
 }


--- a/test/fail_cview3.cpp
+++ b/test/fail_cview3.cpp
@@ -15,15 +15,15 @@
 //   ensure const_array_ref doesn't allow assignment.
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
-#include "boost/type.hpp"
+#include <boost/array.hpp>
+#include <boost/type.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array<int,ndims> array;
@@ -55,7 +55,7 @@ test_main(int,char*[])
        // FAIL! csma2 cannot be assigned to.
        csma2[i][j][k] = 0;
  
-  return boost::exit_success;
+  return boost::report_errors();
 }


--- a/test/fail_ref_cbracket.cpp
+++ b/test/fail_ref_cbracket.cpp
@@ -15,14 +15,14 @@
 //   checking constness of  const operator[].
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -40,5 +40,5 @@ test_main(int,char*[])
  // FAIL! can't assign to const multi_array_ref.
  csma[0][0][0] = 5;

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/fail_ref_cdata.cpp
+++ b/test/fail_ref_cdata.cpp
@@ -15,14 +15,14 @@
 //   Testing data() member function constness.
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -36,5 +36,5 @@ test_main(int,char*[])

  // FAIL! data() returns const int*.
  *csma.data() = 0;
-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/fail_ref_citerator.cpp
+++ b/test/fail_ref_citerator.cpp
@@ -15,12 +15,12 @@
 //   const_iterator/iterator conversion  test
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>


-int test_main(int,char*[]) {
+int main() {
  typedef boost::multi_array_ref<int,3> array_ref;

  typedef array_ref::iterator iterator1;
@@ -29,5 +29,5 @@ int test_main(int,char*[]) {
  // FAIL! ILLEGAL conversion from const_iterator to iterator
  iterator1 in = citerator1();

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/fail_ref_cparen.cpp
+++ b/test/fail_ref_cparen.cpp
@@ -15,14 +15,14 @@
 //   Testing const operator() constness. 
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -40,5 +40,5 @@ test_main(int,char*[])
  // FAIL! cannot assign to a const multi_array_ref
  csma(indices) = 5;

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/fail_ref_criterator.cpp
+++ b/test/fail_ref_criterator.cpp
@@ -15,12 +15,12 @@
 //   const_reverse_iterator/reverse_iterator conversion  test
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>


-int test_main(int,char*[]) {
+int main() {
    typedef boost::multi_array_ref<int,3> array_ref;

    typedef array_ref::reverse_iterator riterator1;
@@ -29,5 +29,5 @@ int test_main(int,char*[]) {
    // Fail! ILLEGAL conversion from const_reverse_iterator to reverse_iterator
    riterator1 in = criterator1();

-    return boost::exit_success;
+    return boost::report_errors();
 }
--- a/test/fail_ref_csubarray.cpp
+++ b/test/fail_ref_csubarray.cpp
@@ -15,14 +15,14 @@
 //   Testing subarray and const_subarray assignment 
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -44,5 +44,5 @@ test_main(int,char*[])

  array_ref::subarray<ndims-1>::type sba = csba; // FAIL! preserve constness.

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/fail_ref_csubarray2.cpp
+++ b/test/fail_ref_csubarray2.cpp
@@ -15,14 +15,14 @@
 //   Testing constness of subarray operations.
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -45,5 +45,5 @@ test_main(int,char*[])
  array_ref::subarray<ndims-1>::type sba = sma_const[0]; // FAIL!
                                                         // preserve constness

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/fail_ref_csubarray3.cpp
+++ b/test/fail_ref_csubarray3.cpp
@@ -15,14 +15,14 @@
 //   Testing constness of subarray operations.
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -48,5 +48,5 @@ test_main(int,char*[])
      for (array_ref::index k = 0; k != 4; ++k)
        sba[j][k] = num++; // FAIL! can't assign to const_subarray.

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/fail_ref_cview.cpp
+++ b/test/fail_ref_cview.cpp
@@ -15,15 +15,15 @@
 //   ensure const_array_view doesn't allow element assignment.
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
-#include "boost/type.hpp"
+#include <boost/array.hpp>
+#include <boost/type.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -51,7 +51,7 @@ test_main(int,char*[])

  csma2(elmt) = 5; // FAIL! csma is read only
  
-  return boost::exit_success;
+  return boost::report_errors();
 }


--- a/test/fail_ref_cview2.cpp
+++ b/test/fail_ref_cview2.cpp
@@ -15,15 +15,15 @@
 //   ensure const_array_view cannot be converted to array_view
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
-#include "boost/type.hpp"
+#include <boost/array.hpp>
+#include <boost/type.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -52,7 +52,7 @@ test_main(int,char*[])
      for (array_ref::index k = 0; k != 2; ++k)
        csma2[i][j][k] = 0; // FAIL! csma2 is read only
  
-  return boost::exit_success;
+  return boost::report_errors();
 }


--- a/test/fail_ref_cview3.cpp
+++ b/test/fail_ref_cview3.cpp
@@ -15,15 +15,15 @@
 //   ensure const_array_view doesn't allow assignment.
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
-#include "boost/type.hpp"
+#include <boost/array.hpp>
+#include <boost/type.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array_ref<int,ndims> array_ref;
@@ -53,7 +53,7 @@ test_main(int,char*[])
      for (array_ref::index k = 0; k != 2; ++k)
        csma2[i][j][k] = 0; // FAIL! csma2 is read only.
  
-  return boost::exit_success;
+  return boost::report_errors();
 }


--- a/test/generative_tests.hpp
+++ b/test/generative_tests.hpp
@@ -1,5 +1,5 @@
-#ifndef GENERATIVE_TESTS_RG072001_HPP
-#define GENERATIVE_TESTS_RG072001_HPP
+#ifndef BOOST_MULTI_ARRAY_GENERATIVE_TESTS_HPP
+#define BOOST_MULTI_ARRAY_GENERATIVE_TESTS_HPP

 // Copyright 2002 The Trustees of Indiana University.

@@ -45,9 +45,9 @@
 //
 //  int test_main(int,char*[]) { return run_generative_tests(); }
 //
-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

 #include <boost/config.hpp> /* BOOST_NO_SFINAE */
 #include <algorithm>
@@ -100,7 +100,7 @@ template <typename Array>
 void access(Array& A, const const_array_tag&);

 template <typename StorageOrder3,typename StorageOrder4,typename Modifier>
-int run_configuration(const StorageOrder3& so3,
+void run_configuration(const StorageOrder3& so3,
                      const StorageOrder4& so4,
                      const Modifier& modifier) {
  // multi_array
@@ -213,11 +213,10 @@ int run_configuration(const StorageOrder3& so3,
      access(C,const_array_tag());
    }
  }
-  return boost::exit_success;
 }

 template <typename ArrayModifier>
-int run_storage_tests(const ArrayModifier& modifier) {
+void run_storage_tests(const ArrayModifier& modifier) {
  run_configuration(boost::c_storage_order(),
                    boost::c_storage_order(),modifier);
  run_configuration(boost::fortran_storage_order(),
@@ -228,8 +227,6 @@ int run_storage_tests(const ArrayModifier& modifier) {
  run_configuration(boost::general_storage_order<3>(ordering,ascending),
                    boost::general_storage_order<4>(ordering,ascending),
                    modifier); 
-
-  return boost::exit_success;
 }

 struct null_modifier {
@@ -279,7 +276,7 @@ int run_generative_tests() {
  run_storage_tests(reindex_modifier());
  run_storage_tests(reshape_modifier());
  std::cout << "Total Tests Run: " << tests_run << '\n';
-  return boost::exit_success;
+  return boost::report_errors();
 }

-#endif // GENERATIVE_TESTS_RG072001_HPP
+#endif
--- a/test/idxgen1.cpp
+++ b/test/idxgen1.cpp
@@ -14,12 +14,12 @@
 // idxset1.cpp - testing the code for index_gen
 //

-#include "boost/multi_array/index_gen.hpp"
-#include "boost/multi_array/index_range.hpp"
-#include "boost/multi_array/types.hpp"
-#include "boost/test/minimal.hpp"
+#include <boost/multi_array/index_gen.hpp>
+#include <boost/multi_array/index_range.hpp>
+#include <boost/multi_array/types.hpp>
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>

 typedef boost::detail::multi_array::index index_type;
 typedef boost::detail::multi_array::size_type size_type;
@@ -37,7 +37,7 @@ bool operator==(const range& lhs,const range& rhs) {
 }

 int
-test_main(int,char*[])
+main()
 {

  boost::detail::multi_array::index_gen<0,0> indices;
@@ -62,20 +62,20 @@ test_main(int,char*[])
  {
    boost::detail::multi_array::index_gen<3,3> is1 =
      indices[range(0,1,2)][range(1,2,3)][range(2,3,4)];
-    BOOST_CHECK(is1.ranges_[0] == range(0,1,2));
-    BOOST_CHECK(is1.ranges_[1] == range(1,2,3));
-    BOOST_CHECK(is1.ranges_[2] == range(2,3,4));
+    BOOST_TEST(is1.ranges_[0] == range(0,1,2));
+    BOOST_TEST(is1.ranges_[1] == range(1,2,3));
+    BOOST_TEST(is1.ranges_[2] == range(2,3,4));
  }

  {
    boost::detail::multi_array::index_gen<3,2> is2 = 
      indices[range(0,1,2)][2][range(2,3,4)];
-    BOOST_CHECK(is2.ranges_[0] == range(0,1,2));
-    BOOST_CHECK(is2.ranges_[1] == range(2));
-    BOOST_CHECK(is2.ranges_[1].is_degenerate());
-    BOOST_CHECK(is2.ranges_[2] == range(2,3,4));
+    BOOST_TEST(is2.ranges_[0] == range(0,1,2));
+    BOOST_TEST(is2.ranges_[1] == range(2));
+    BOOST_TEST(is2.ranges_[1].is_degenerate());
+    BOOST_TEST(is2.ranges_[2] == range(2,3,4));
  }

-  return boost::exit_success;
+  return boost::report_errors();
 }

--- a/test/index_bases.cpp
+++ b/test/index_bases.cpp
@@ -14,15 +14,15 @@
 // index_bases - test of the index_base modifying facilities.
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>
 #include <vector>
 #include <iostream>
 int
-test_main(int,char*[])
+main()
 {
  typedef boost::multi_array<double, 3> array;
  typedef boost::multi_array_ref<double, 3> array_ref;
@@ -63,11 +63,11 @@ test_main(int,char*[])
    for (size_type a = 0; a < A.shape()[0]; ++a)
      for (size_type b = 0; b < A.shape()[1]; ++b)
        for (size_type c = 0; c < A.shape()[2]; ++c) {
-          BOOST_CHECK(A[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
-          BOOST_CHECK(C[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
-          BOOST_CHECK(D[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
+          BOOST_TEST(A[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
+          BOOST_TEST(C[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
+          BOOST_TEST(D[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
          // Test that E does not inherit A's index_base
-          BOOST_CHECK(E[a][b][c] == B[a][b][c]);
+          BOOST_TEST(E[a][b][c] == B[a][b][c]);
        }
  }

@@ -100,10 +100,10 @@ test_main(int,char*[])
    for (size_type a = 0; a < A.shape()[0]; ++a)
      for (size_type b = 0; b < A.shape()[1]; ++b)
        for (size_type c = 0; c < A.shape()[2]; ++c) {
-          BOOST_CHECK(A[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
-          BOOST_CHECK(C[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
-          BOOST_CHECK(D[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
-          BOOST_CHECK(E[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
+          BOOST_TEST(A[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
+          BOOST_TEST(C[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
+          BOOST_TEST(D[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
+          BOOST_TEST(E[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
        }
  }

@@ -142,12 +142,12 @@ test_main(int,char*[])
    for (size_type a = 0; a < A.shape()[0]; ++a)
      for (size_type b = 0; b < A.shape()[1]; ++b)
        for (size_type c = 0; c < A.shape()[2]; ++c) {
-          BOOST_CHECK(A[a+1][b+1][c+1] == B[a][b][c]);
-          BOOST_CHECK(C[a+1][b+1][c+1] == B[a][b][c]);
-          BOOST_CHECK(D[a+1][b+1][c+1] == B[a][b][c]);
-          BOOST_CHECK(E[a+1][b+1][c+1] == B[a][b][c]);
+          BOOST_TEST(A[a+1][b+1][c+1] == B[a][b][c]);
+          BOOST_TEST(C[a+1][b+1][c+1] == B[a][b][c]);
+          BOOST_TEST(D[a+1][b+1][c+1] == B[a][b][c]);
+          BOOST_TEST(E[a+1][b+1][c+1] == B[a][b][c]);
        }
  }

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/iterators.cpp
+++ b/test/iterators.cpp
@@ -17,9 +17,9 @@

 #define MULTIARRAY_TEST_ASSIGN
 #include "generative_tests.hpp"
-#include "boost/concept_check.hpp" // for ignore_unused_variable_warning
-#include "boost/mpl/if.hpp"
-#include "boost/type_traits/is_same.hpp"
+#include <boost/concept_check.hpp> // for ignore_unused_variable_warning
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_same.hpp>

 // iterator-test-specific code

@@ -107,8 +107,8 @@ void test_iterators(Array& A, const IterTraits&) {
    typedef typename IterTraits::iterator3 iterator;
    iterator i1 = A.begin();
    iterator i2 = A.end();
-    BOOST_CHECK(i1 < i2);
-    BOOST_CHECK((i2 - i1) == typename iterator::difference_type(2));
+    BOOST_TEST(i1 < i2);
+    BOOST_TEST((i2 - i1) == typename iterator::difference_type(2));
  }

  // Standard Array Iteration
@@ -121,7 +121,7 @@ void test_iterators(Array& A, const IterTraits&) {
    for (iterator3 i = A.begin(); i != A.end(); ++i)
      for(iterator2 ii = (*i).begin(); ii != (*i).end(); ++ii)
        for(iterator1  iii = (*ii).begin(); iii != (*ii).end(); ++iii)
-          BOOST_CHECK(*iii == vals++);
+          BOOST_TEST(*iii == vals++);
  }

  // Using operator->() on iterators
@@ -134,7 +134,7 @@ void test_iterators(Array& A, const IterTraits&) {
    for (iterator3 i = A.begin(); i != A.end(); ++i)
      for(iterator2 ii = i->begin(); ii != i->end(); ++ii)
        for(iterator1  iii = ii->begin(); iii != ii->end(); ++iii)
-          BOOST_CHECK(*iii == vals++);
+          BOOST_TEST(*iii == vals++);
  }

  // Reverse Iterator Hierarchy Test
@@ -148,7 +148,7 @@ void test_iterators(Array& A, const IterTraits&) {
      for(riterator2 ii = (*i).rbegin(); ii != (riterator2)(*i).rend(); ++ii)
        for(riterator1 iii = (*ii).rbegin(); iii != (riterator1)(*ii).rend();
            ++iii)
-          BOOST_CHECK(*iii == check_iter_val--);
+          BOOST_TEST(*iii == check_iter_val--);
  }
  ++tests_run;
 }
@@ -182,7 +182,7 @@ void access(Array& A, const const_array_tag&) {


 int
-test_main(int, char*[])
+main()
 {
  return run_generative_tests();
 }
--- a/test/range1.cpp
+++ b/test/range1.cpp
@@ -15,91 +15,100 @@
 //


-#include "boost/multi_array/index_range.hpp"
+#include <boost/multi_array/index_range.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>
 #include <cstddef>

 int
-test_main(int,char*[])
+main()
 {
  typedef boost::detail::multi_array::index_range<int,std::size_t> range;

  {
    // typical range creation and extraction
    range r1(-3,5);
-    BOOST_CHECK(r1.start() == -3);
-    BOOST_CHECK(r1.finish() == 5);
-    BOOST_CHECK(r1.stride() == 1);
-    BOOST_CHECK(!r1.is_degenerate());
-    BOOST_CHECK(r1.get_start(0) == -3);
-    BOOST_CHECK(r1.get_finish(100) == 5);
+    BOOST_TEST(r1.start() == -3);
+    BOOST_TEST(r1.finish() == 5);
+    BOOST_TEST(r1.stride() == 1);
+    BOOST_TEST(r1.size(0) == 8);
+    BOOST_TEST(!r1.is_degenerate());
+    BOOST_TEST(r1.get_start(0) == -3);
+    BOOST_TEST(r1.get_finish(100) == 5);
  }

  {
    range r2(-3,5,2);
-    BOOST_CHECK(r2.start() == -3);
-    BOOST_CHECK(r2.finish() == 5);
-    BOOST_CHECK(r2.stride() == 2);
-    BOOST_CHECK(!r2.is_degenerate());
+    BOOST_TEST(r2.start() == -3);
+    BOOST_TEST(r2.finish() == 5);
+    BOOST_TEST(r2.stride() == 2);
+    BOOST_TEST(r2.size(0) == 4);
+    BOOST_TEST(!r2.is_degenerate());
  }

  {
    // degenerate creation
    range r3(5);
-    BOOST_CHECK(r3.start() == 5);
-    BOOST_CHECK(r3.finish() == 6);
-    BOOST_CHECK(r3.stride() == 1);
-    BOOST_CHECK(r3.is_degenerate());
+    BOOST_TEST(r3.start() == 5);
+    BOOST_TEST(r3.finish() == 6);
+    BOOST_TEST(r3.stride() == 1);
+    BOOST_TEST(r3.size(0) == 1);
+    BOOST_TEST(r3.is_degenerate());
  }

  {
    // default range creation
    range r4;
-    BOOST_CHECK(r4.get_start(0) == 0);
-    BOOST_CHECK(r4.get_finish(100) == 100);
-    BOOST_CHECK(r4.stride() == 1);
+    BOOST_TEST(r4.get_start(0) == 0);
+    BOOST_TEST(r4.get_finish(100) == 100);
+    BOOST_TEST(r4.stride() == 1);
+    BOOST_TEST(r4.size(0) == 0);
  }

  {
    // create a range using the setter methods
    range r5 = range().stride(2).start(-3).finish(7);
-    BOOST_CHECK(r5.start() == -3);
-    BOOST_CHECK(r5.stride() == 2);
-    BOOST_CHECK(r5.finish() == 7);
+    BOOST_TEST(r5.start() == -3);
+    BOOST_TEST(r5.stride() == 2);
+    BOOST_TEST(r5.finish() == 7);
+    BOOST_TEST(r5.size(0) == 5);
  }

  // try out all the comparison operators
  {
    range r6 = -3 <= range().stride(2) < 7;
-    BOOST_CHECK(r6.start() == -3);
-    BOOST_CHECK(r6.stride() == 2);
-    BOOST_CHECK(r6.finish() == 7);
+    BOOST_TEST(r6.start() == -3);
+    BOOST_TEST(r6.stride() == 2);
+    BOOST_TEST(r6.finish() == 7);
+    BOOST_TEST(r6.size(0) == 5);
  }

  {
    range r7 = -3 < range() <= 7;
-    BOOST_CHECK(r7.start() == -2);
-    BOOST_CHECK(r7.stride() == 1);
-    BOOST_CHECK(r7.finish() == 8);
+    BOOST_TEST(r7.start() == -2);
+    BOOST_TEST(r7.stride() == 1);
+    BOOST_TEST(r7.finish() == 8);
+    BOOST_TEST(r7.size(0) == 10);
  }

  // arithmetic operators
  {
    range r8 = range(0,5) + 2;
-    BOOST_CHECK(r8.start() == 2);
-    BOOST_CHECK(r8.stride() == 1);
-    BOOST_CHECK(r8.finish() == 7);
+    BOOST_TEST(r8.start() == 2);
+    BOOST_TEST(r8.stride() == 1);
+    BOOST_TEST(r8.finish() == 7);
+    BOOST_TEST(r8.size(0) == 5);
  }

  {
    range r9 = range(0,5) - 2;
-    BOOST_CHECK(r9.start() == -2);
-    BOOST_CHECK(r9.stride() == 1);
-    BOOST_CHECK(r9.finish() == 3);
+    BOOST_TEST(r9.start() == -2);
+    BOOST_TEST(r9.stride() == 1);
+    BOOST_TEST(r9.finish() == 3);
+    BOOST_TEST(r9.size(0) == 5);
  }

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/reshape.cpp
+++ b/test/reshape.cpp
@@ -14,15 +14,15 @@
 // reshape.cpp - testing reshaping functionality
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
-#include "boost/type.hpp"
+#include <boost/array.hpp>
+#include <boost/type.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  typedef boost::multi_array<int,ndims> array;
@@ -52,9 +52,9 @@ test_main(int,char*[])
    for (array::index i = 0; i != 4; ++i)
      for (array::index j = 0; j != 3; ++j)
        for (array::index k = 0; k != 2; ++k) {
-          BOOST_CHECK(A[i][j][k] == *ptr);
-          BOOST_CHECK(B[i][j][k] == *ptr);
-          BOOST_CHECK(C[i][j][k] == *ptr++);
+          BOOST_TEST(A[i][j][k] == *ptr);
+          BOOST_TEST(B[i][j][k] == *ptr);
+          BOOST_TEST(C[i][j][k] == *ptr++);
        }
  }

@@ -80,13 +80,13 @@ test_main(int,char*[])
    for (array::index i = 0; i != 4; ++i)
      for (array::index j = 1; j != 4; ++j)
        for (array::index k = -1; k != 1; ++k) {
-          BOOST_CHECK(A[i][j][k] == *ptr);
-          BOOST_CHECK(B[i][j][k] == *ptr);
-          BOOST_CHECK(C[i][j][k] == *ptr++);
+          BOOST_TEST(A[i][j][k] == *ptr);
+          BOOST_TEST(B[i][j][k] == *ptr);
+          BOOST_TEST(C[i][j][k] == *ptr++);
        }
  }
  
-  return boost::exit_success;
+  return boost::report_errors();
 }


--- a/test/resize.cpp
+++ b/test/resize.cpp
@@ -14,13 +14,13 @@
 // resize.cpp - Test of resizing multi_arrays
 //

-#include "boost/test/minimal.hpp"
-#include "boost/multi_array.hpp"
+#include <boost/core/lightweight_test.hpp>
+#include <boost/multi_array.hpp>
 #include <iostream>
 using namespace std;


-int test_main(int,char*[]) {
+int main() {

  typedef boost::multi_array<int,3> marray;

@@ -58,7 +58,7 @@ int test_main(int,char*[]) {
    marray A(boost::extents[2][3][4]);
    A.assign(A_data,A_data+(2*3*4));
    A.resize(boost::extents[4][3][2]);
-    BOOST_CHECK(std::equal(A_resize,A_resize+(4*3*2),A.data()));
+    BOOST_TEST(std::equal(A_resize,A_resize+(4*3*2),A.data()));
  }  

  // resize through the Collection
@@ -67,14 +67,14 @@ int test_main(int,char*[]) {
    A.assign(A_data,A_data+(2*3*4));
    boost::array<int,3> new_extents = {{4,3,2}};
    A.resize(new_extents);
-    BOOST_CHECK(std::equal(A_resize,A_resize+(4*3*2),A.data()));
+    BOOST_TEST(std::equal(A_resize,A_resize+(4*3*2),A.data()));
  }  

  // default construct all the new elements (in this case, all elements)
  {
    marray defaultA;
    defaultA.resize(boost::extents[2][3][4]);
-    BOOST_CHECK(std::accumulate(defaultA.data(),
+    BOOST_TEST(std::accumulate(defaultA.data(),
                               defaultA.data()+(2*3*4),0) == 0);
  }

@@ -107,7 +107,7 @@ int test_main(int,char*[]) {
    for (int x = 0; x < 3; x++) { 
      for (int y = 0; y < 4; y++) {
        for (int z = 0; z < 2; z++) {
-          BOOST_CHECK(*(A.data() + check) == check);
+          BOOST_TEST(*(A.data() + check) == check);
          ++check;
        }
      }
@@ -123,5 +123,5 @@ int test_main(int,char*[]) {
  }


-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/reverse_view.cpp
+++ b/test/reverse_view.cpp
@@ -14,12 +14,12 @@
 // reverse_view.cpp - a small test of creating a view with negative strides
 //

-#include "boost/multi_array.hpp"
-#include "boost/test/minimal.hpp"
-#include "boost/array.hpp"
+#include <boost/multi_array.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/array.hpp>

 int
-test_main(int,char*[])
+main()
 {
  using namespace boost;
  
@@ -36,8 +36,8 @@ test_main(int,char*[])
  array::array_view<1>::type B = A[indices[range(3, -1, -1)]];
  
  for(multi_array_types::size_type i = 0; i != B.size(); ++i) {
-    BOOST_CHECK(B[i] == rdata[i]);
+    BOOST_TEST(B[i] == rdata[i]);
  }
  
-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/slice.cpp
+++ b/test/slice.cpp
@@ -15,9 +15,9 @@
 //

 #include "generative_tests.hpp"
-#include "boost/array.hpp"
-#include "boost/mpl/if.hpp"
-#include "boost/type_traits/is_same.hpp"
+#include <boost/array.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_same.hpp>

 template <typename Array>
 struct view_traits_mutable {
@@ -71,10 +71,10 @@ void test_views(Array& A, const ViewTraits&) {
    for (index i = 0; i != 2; ++i)
      for (index j = 0; j != 2; ++j)
        for (index k = 0; k != 2; ++k) {
-          BOOST_CHECK(B[i][j][k] == A[idx0+i][idx1+j+1][idx2+k*2]);
+          BOOST_TEST(B[i][j][k] == A[idx0+i][idx1+j+1][idx2+k*2]);
          boost::array<index,3> elmts;
          elmts[0]=i; elmts[1]=j; elmts[2]=k;
-          BOOST_CHECK(B(elmts) == A[idx0+i][idx1+j+1][idx2+k*2]);
+          BOOST_TEST(B(elmts) == A[idx0+i][idx1+j+1][idx2+k*2]);
        }
  }
  // Degenerate dimensions
@@ -84,10 +84,10 @@ void test_views(Array& A, const ViewTraits&) {
    
    for (index i = 0; i != 2; ++i)
      for (index j = 0; j != 2; ++j) {
-        BOOST_CHECK(B[i][j] == A[idx0+i][idx1+1][idx2+j*2]);
+        BOOST_TEST(B[i][j] == A[idx0+i][idx1+1][idx2+j*2]);
        boost::array<index,2> elmts;
        elmts[0]=i; elmts[1]=j;
-        BOOST_CHECK(B(elmts) == A[idx0+i][idx1+1][idx2+j*2]);
+        BOOST_TEST(B(elmts) == A[idx0+i][idx1+1][idx2+j*2]);
      }
  }

@@ -105,10 +105,10 @@ void test_views(Array& A, const ViewTraits&) {
    for (index i = 0; i != 2; ++i)
      for (index j = 0; j != 2; ++j) 
        for (index k = 0; k != 2; ++k) {
-        BOOST_CHECK(B[i][j][k] == A[idx0+i][idx1+j][idx2+2-k]);
+        BOOST_TEST(B[i][j][k] == A[idx0+i][idx1+j][idx2+2-k]);
        boost::array<index,3> elmts;
        elmts[0]=i; elmts[1]=j; elmts[2]=k;
-        BOOST_CHECK(B(elmts) == A[idx0+i][idx1+j][idx2+2-k]);
+        BOOST_TEST(B(elmts) == A[idx0+i][idx1+j][idx2+2-k]);
      }
  }

@@ -141,6 +141,6 @@ void access(Array& A, const const_array_tag&) {
 }


-int test_main(int,char*[]) {
+int main() {
  return run_generative_tests();
 }
--- a/test/stl_interaction.cpp
+++ b/test/stl_interaction.cpp
@@ -14,14 +14,14 @@
 // stl_interaction.cpp - Make sure multi_arrays work with STL containers.
 //

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>
 #include <algorithm>
 #include <vector>

 int
-test_main(int, char*[])
+main()
 {
  using boost::extents;
  using boost::indices;
@@ -51,7 +51,7 @@ test_main(int, char*[])
  myarray.assign(data,data+data_size);

  array3vec myvec(5,myarray);
-  BOOST_CHECK(myarray == myvec[1]);
+  BOOST_TEST(myarray == myvec[1]);

  array3::array_view<2>::type myview =
    myarray[indices[1][range(0,2)][range(1,3)]];
@@ -65,8 +65,8 @@ test_main(int, char*[])

  myvec.push_back(myarray);

-  BOOST_CHECK(myarray != myvec[1]);
-  BOOST_CHECK(myarray == myvec[5]);
+  BOOST_TEST(myarray != myvec[1]);
+  BOOST_TEST(myarray == myvec[5]);

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/storage_order.cpp
+++ b/test/storage_order.cpp
@@ -14,14 +14,14 @@
 // storage_order.cpp - testing storage_order-isms.
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>
 
-#include "boost/array.hpp"
+#include <boost/array.hpp>

 int
-test_main(int,char*[])
+main()
 {
  const int ndims=3;
  
@@ -67,7 +67,7 @@ test_main(int,char*[])
    for (array::index i = 0; i != 2; ++i)
      for (array::index j = 0; j != 3; ++j)
        for (array::index k = 0; k != 4; ++k)
-          BOOST_CHECK(A[i][j][k] == *num++);
+          BOOST_TEST(A[i][j][k] == *num++);
  }

  // Mimic fortran_storage_order using
@@ -88,7 +88,7 @@ test_main(int,char*[])
    for (array::index i = 0; i != 2; ++i)
      for (array::index j = 0; j != 3; ++j)
        for (array::index k = 0; k != 4; ++k)
-          BOOST_CHECK(A[i][j][k] == *num++);
+          BOOST_TEST(A[i][j][k] == *num++);
  }

  // general_storage_order with arbitrary storage order
@@ -119,7 +119,7 @@ test_main(int,char*[])
    for (array::index i = 0; i != 2; ++i)
      for (array::index j = 0; j != 3; ++j)
        for (array::index k = 0; k != 4; ++k)
-          BOOST_CHECK(A[i][j][k] == *num++);
+          BOOST_TEST(A[i][j][k] == *num++);
  }


@@ -152,8 +152,8 @@ test_main(int,char*[])
    for (array::index i = 0; i != 2; ++i)
      for (array::index j = 0; j != 3; ++j)
        for (array::index k = 0; k != 4; ++k)
-          BOOST_CHECK(A[i][j][k] == *num++);
+          BOOST_TEST(A[i][j][k] == *num++);
  }

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/storage_order_convert.cpp
+++ b/test/storage_order_convert.cpp
@@ -14,12 +14,12 @@
 // test out my new storage_order stuff
 //

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/multi_array/storage_order.hpp"
+#include <boost/multi_array/storage_order.hpp>

 int 
-test_main(int,char*[]) {
+main() {

  using namespace boost;

@@ -31,9 +31,9 @@ test_main(int,char*[]) {
  general_storage_order<5> fortran_storage(fortran_ordering.begin(),
                                           ascending.begin());
 
-  BOOST_CHECK(c_storage == (general_storage_order<5>) c_storage_order());
-  BOOST_CHECK(fortran_storage ==
+  BOOST_TEST(c_storage == (general_storage_order<5>) c_storage_order());
+  BOOST_TEST(fortran_storage ==
             (general_storage_order<5>) fortran_storage_order());

-  return boost::exit_success;
+  return boost::report_errors();
 }
--- a/test/vc_death.cpp
+++ b/test/vc_death.cpp
@@ -14,15 +14,15 @@
 // index_bases - test of the index_base modifying facilities.
 //

-#include "boost/multi_array.hpp"
+#include <boost/multi_array.hpp>

-#include "boost/test/minimal.hpp"
+#include <boost/core/lightweight_test.hpp>

-#include "boost/array.hpp"
+#include <boost/array.hpp>
 #include <vector>
 #include <iostream>
 int
-test_main(int,char*[])
+main()
 {
  typedef boost::multi_array<double, 3> array;
  typedef array::array_view<3>::type array_view;
@@ -40,5 +40,5 @@ test_main(int,char*[])
    array_view E = A[indices[irange(1,2)][irange(1,2)][irange(1,2)]];

  }
-  return boost::exit_success;
+  return boost::report_errors();
 }
Author	SHA1	Message	Date
René Ferdinand Rivera Morell	333c304d84	Add support for modular build structure. (#36 ) * Make the library modular usable. * Switch to library requirements instead of source. As source puts extra source in install targets. * Add requires-b2 check to top-level build file. * Bump B2 require to 5.2 * Change all <source> references to <library>. * Update copyright dates. * Move inter-lib dependencies to a project variable and into the build targets. * Switch to /boost/test//included target for header only mode of Boost.Test. * Update build deps. * Add GHA CI with simpler working one based on alandefreitas/cpp-actions utilities. * Move project global include to target local include. * Only msvc gets minor version tests. * Remove GHA CI to undo move to cpp-actions.	2025-06-26 02:51:42 +03:00
Peter Dimov	0c5348bef7	Add CMakeLists.txt	2021-05-28 00:46:21 +03:00
Peter Dimov	dfbe377927	Merge branch 'master' into develop	2021-05-28 00:45:40 +03:00
Edward Diener	e8140d8183	Add "cxxstd" json field	2021-01-20 15:58:46 -05:00
Glen Fernandes	3b40572055	Merge branch 'develop'	2019-12-17 08:42:23 -05:00
Glen Fernandes	eab203a2c5	Update Travis configuration	2019-12-17 08:41:00 -05:00
Glen Fernandes	e6f210c7ca	Correct all guard macros to conform to Boost guidelines	2019-12-16 19:27:19 -05:00
Glen Fernandes	74cbc0f659	Merge branch 'develop'	2019-05-03 20:01:49 -04:00
Glen Fernandes	2f03d28dab	Update appveyor configuration	2019-05-03 17:38:44 -04:00
Glen Fernandes	5bdb4f852c	Use alloc_construct utilities from Boost.Core	2019-05-03 10:24:32 -04:00
Glen Fernandes	3ab14966b5	Merge branch 'develop'	2019-02-25 07:59:05 -05:00
Glen Fernandes	72763d70be	Fix contribution from CromwellEnage to actually compile	2019-02-24 23:09:05 -05:00
Glen Fernandes	f59629cebb	Merge pull request #17 from CromwellEnage/index_range_size index_range.size() was missing	2019-02-24 20:49:58 -05:00
Glen Fernandes	55bba0ed5b	Merge branch 'develop' into index_range_size	2019-02-24 20:48:00 -05:00
Glen Fernandes	9642ba7103	Add test cases for allocators	2019-02-19 00:57:25 -05:00
Glen Fernandes	453d38b269	Update sgi.com/tech URLs in docs to boost.org/sgi	2019-02-18 22:32:30 -05:00
Glen Fernandes	56b9b62ce4	Merge pull request #22 from boostorg/lightweight_test Switch to Boost.Lightweight_Test for faster test build and run times	2019-02-18 22:30:34 -05:00
Glen Fernandes	11d00187fa	Switch to Boost.Lightweight_Test for faster test build and run times	2019-02-18 15:59:40 -05:00
rxg	25b8a5479f	Merge pull request #10 from DanielaE/feature/retire-header-iterator Get rid of iterator.hpp	2018-10-13 17:43:38 -07:00
Ronald Garcia	804dff44de	Merge branch 'develop'	2018-10-03 20:38:17 -07:00
CromwellEnage	17f9326ecc	index_range.size() was missing Added missing size() member function to index_range in accordance with reference documentation.	2018-09-19 12:06:36 -04:00
Glen Fernandes	f126e8d7be	Merge pull request #13 from glenfe/develop Add Travis and Appveyor configurations	2018-09-18 22:36:05 -04:00
Glen Fernandes	f589527689	Add Travis and Appveyor configurations	2018-09-08 20:36:05 -04:00
rxg	dedb1eaade	Merge pull request #12 from glenfe/develop Improve C++11 allocator support	2018-09-05 20:42:38 -07:00
Glen Fernandes	e9229c8bf4	Improve C++11 allocator support * Use the empty base optimization for storing the allocator * Support C++11 minimal allocators * Support C++11 stateful allocators * Support C++11 allocator construct and destroy	2018-09-05 18:31:26 -04:00
Daniela Engert	c30eee78db	Get rid of iterator.hpp It does nothing more than pulling std::iterator into namespace boost and including headers. This library only takes advantage of the included headers. OTOH, pulling std::iterator into boost generates deprecation warnings in MSVC 14.1 when compiling in C++17 mode. Even more, Boost's iterator.hpp is deprecated, too. Signed-off-by: Daniela Engert <dani@ngrt.de>	2017-12-27 15:59:42 +01:00