boost_mirror/multi_array
1
0
Fork 0
mirror of https://github.com/boostorg/multi_array.git synced 2025-05-11 21:33:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'develop'

Browse Source
This commit is contained in:
Glen Fernandes 2019-02-25 07:59:05 -05:00
commit 3ab14966b5
55 changed files with 575 additions and 405 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
doc/iterator_categories.html
View File

@ -651,8 +651,8 @@ Iterator</a>.
</h3>The Forward Iterator is an iterator that can be incremented. Also, it is </h3>The Forward Iterator is an iterator that can be incremented. Also, it is
permissible to make multiple passes through the iterator's range. 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 <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>, <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="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Constructible</a>, and <a href="https://www.boost.org/sgi/stl/EqualityComparable.html">Equality
Comparable</a> Comparable</a>
<h3>Associated types</h3> <h3>Associated types</h3>
<table border="1"> <table border="1">
@ -725,7 +725,7 @@ Traversal Iterator</a>
Iterator </h3>An iterator that provides constant-time methods for moving forward Iterator </h3>An iterator that provides constant-time methods for moving forward
and backward in arbitrary-sized steps. and backward in arbitrary-sized steps.
<h3>Refinement of</h3><a href="#concept_BidirectionalTraversalIterator">Bidirectional <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 Comparable</a> where <tt>&lt;</tt> is a total ordering
<h3>Associated types</h3> <h3>Associated types</h3>
<table border="1"> <table border="1">

20
doc/reference.html
View File

@ -353,21 +353,21 @@ This expression generates a view of the array determined by the
used to construct <code class="literal">indices</code>. 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 </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 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 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 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 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 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 type must model <a class="ulink" href="https://www.boost.org/sgi/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 <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 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 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 type must model <a class="ulink" href="https://www.boost.org/sgi/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 <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 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 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 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. constant time.
<code class="literal">size()</code> executes in at most linear time in the <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> </p><p title="Model Of."><b>Model Of. </b>
<a class="link" href="#MultiArray" title="MultiArray Concept">MultiArray</a>, <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, <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"> </p><p title="Synopsis"><b>Synopsis. </b></p><pre class="programlisting">
namespace boost { namespace boost {
@ -818,7 +818,7 @@ of the constructors.
<a class="link" href="#MultiArray" title="MultiArray Concept">MultiArray</a>, <a class="link" href="#MultiArray" title="MultiArray Concept">MultiArray</a>,
<a class="ulink" href="../../../libs/utility/CopyConstructible.html" target="_top">CopyConstructible</a>. <a class="ulink" href="../../../libs/utility/CopyConstructible.html" target="_top">CopyConstructible</a>.
and depending on the element type, it may also model 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 Detailed descriptions are provided here only for operations that are
not described in the <code class="literal">multi_array</code> reference. not described in the <code class="literal">multi_array</code> reference.
</p><p title="Synopsis"><b>Synopsis. </b></p><pre class="programlisting"> </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="link" href="#MultiArray" title="MultiArray Concept">MultiArray</a>,
<a class="ulink" href="../../../libs/utility/CopyConstructible.html" target="_top">CopyConstructible</a>. <a class="ulink" href="../../../libs/utility/CopyConstructible.html" target="_top">CopyConstructible</a>.
and depending on the element type, it may also model 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 Detailed descriptions are provided here only for operations that are
not described in the <code class="literal">multi_array</code> reference. not described in the <code class="literal">multi_array</code> reference.

7
doc/test_cases.html
View File

@ -179,6 +179,13 @@ by library users.
</td> </td>
</tr> </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> <tr>
<td><a href="../test/generative_tests.hpp">libs/multi_array/test/generative_tests.hpp</a></td> <td><a href="../test/generative_tests.hpp">libs/multi_array/test/generative_tests.hpp</a></td>
<td> <td>

2
doc/user.html
View File

@ -612,7 +612,7 @@ cases can be found <a href="./test_cases.html">here</a>.
<h2>Related Work</h2> <h2>Related Work</h2>
<a href="../../array/index.html">boost::array</a> <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 one-dimensional containers of user data. Both manage their own
memory. <tt>std::valarray</tt> is a low-level memory. <tt>std::valarray</tt> is a low-level
C++ Standard Library component C++ Standard Library component

14
doc/xml/MultiArray.xml
View File

@ -567,7 +567,7 @@ This expression generates a view of the array determined by the
<entry>bool</entry> <entry>bool</entry>
<entry>This performs a lexicographical comparison of the <entry>This performs a lexicographical comparison of the
values of <literal>a</literal> and <literal>b</literal>. The element 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> expression to be valid.</entry>
</row> </row>
<row> <row>
@ -575,7 +575,7 @@ expression to be valid.</entry>
<entry>bool</entry> <entry>bool</entry>
<entry>This performs a lexicographical comparison of the <entry>This performs a lexicographical comparison of the
values of <literal>a</literal> and <literal>b</literal>. The element 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> expression to be valid.</entry>
</row> </row>
<row> <row>
@ -583,8 +583,8 @@ expression to be valid.</entry>
<entry>bool</entry> <entry>bool</entry>
<entry>This performs a lexicographical comparison of the <entry>This performs a lexicographical comparison of the
values of <literal>a</literal> and <literal>b</literal>. The element 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 type must model <ulink url="https://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</ulink> and
<ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink> for this <ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink> for this
expression to be valid.</entry> expression to be valid.</entry>
</row> </row>
<row> <row>
@ -592,8 +592,8 @@ expression to be valid.</entry>
<entry>bool</entry> <entry>bool</entry>
<entry>This performs a lexicographical comparison of the <entry>This performs a lexicographical comparison of the
values of <literal>a</literal> and <literal>b</literal>. The element 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 type must model <ulink url="https://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</ulink> and
<ulink url="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</ulink> for this <ulink url="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</ulink> for this
expression to be valid.</entry> expression to be valid.</entry>
</row> </row>
<row> <row>
@ -601,7 +601,7 @@ expression to be valid.</entry>
<entry>bool</entry> <entry>bool</entry>
<entry>This performs a lexicographical comparison of the <entry>This performs a lexicographical comparison of the
values of <literal>a</literal> and <literal>b</literal>. The element 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> expression to be valid.</entry>
</row> </row>
</tbody> </tbody>

2
doc/xml/const_multi_array_ref.xml
View File

@ -17,7 +17,7 @@ of the constructors.
<link linkend="MultiArray">MultiArray</link>, <link linkend="MultiArray">MultiArray</link>,
<ulink url="../../../libs/utility/CopyConstructible.html">CopyConstructible</ulink>. <ulink url="../../../libs/utility/CopyConstructible.html">CopyConstructible</ulink>.
and depending on the element type, it may also model 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 Detailed descriptions are provided here only for operations that are
not described in the <literal>multi_array</literal> reference. not described in the <literal>multi_array</literal> reference.

2
doc/xml/multi_array.xml
View File

@ -18,7 +18,7 @@ using a replaceable allocator.
<para> <para>
<link linkend="MultiArray">MultiArray</link>, <link linkend="MultiArray">MultiArray</link>,
<ulink url="../../../libs/utility/CopyConstructible.html">CopyConstructible</ulink>. Depending on the element type, <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> </para>
</formalpara> </formalpara>

2
doc/xml/multi_array_ref.xml
View File

@ -17,7 +17,7 @@ of the constructors.
<link linkend="MultiArray">MultiArray</link>, <link linkend="MultiArray">MultiArray</link>,
<ulink url="../../../libs/utility/CopyConstructible.html">CopyConstructible</ulink>. <ulink url="../../../libs/utility/CopyConstructible.html">CopyConstructible</ulink>.
and depending on the element type, it may also model 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 Detailed descriptions are provided here only for operations that are
not described in the <literal>multi_array</literal> reference. not described in the <literal>multi_array</literal> reference.
</para> </para>

2
include/boost/multi_array/algorithm.hpp
View File

@ -40,7 +40,7 @@
// See http://www.boost.org/libs/multi_array for documentation. // See http://www.boost.org/libs/multi_array for documentation.
#include "boost/iterator.hpp" #include <iterator>
namespace boost { namespace boost {
namespace detail { namespace detail {

6
include/boost/multi_array/index_range.hpp
View File

@ -107,6 +107,12 @@ namespace multi_array {
index stride() const { return stride_; } 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) void set_index_range(index start, index finish, index stride=1)
{ {
start_ = start; start_ = start;

88
test/Jamfile.v2
View File

@ -4,48 +4,48 @@
# "as is" without express or implied warranty, and with no claim as # "as is" without express or implied warranty, and with no claim as
# to its suitability for any purpose. # to its suitability for any purpose.
test-suite multi_array import testing ;
:
[ 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 ]
[ compile concept_checks.cpp ] 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 ;
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 ;

12
test/access.cpp
View File

@ -16,7 +16,7 @@
// //
#include "generative_tests.hpp" #include "generative_tests.hpp"
#include "boost/static_assert.hpp" #include <boost/static_assert.hpp>
template <typename Array> template <typename Array>
void access(Array& A, const mutable_array_tag&) { 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 i = idx0; i != idx0+2; ++i)
for (index j = idx1; j != idx1+3; ++j) for (index j = idx1; j != idx1+3; ++j)
for (index k = idx2; k != idx2+4; ++k) { for (index k = idx2; k != idx2+4; ++k) {
BOOST_CHECK(A[i][j][k] == cnum++); BOOST_TEST(A[i][j][k] == cnum++);
BOOST_CHECK(CA[i][j][k] == A[i][j][k]); BOOST_TEST(CA[i][j][k] == A[i][j][k]);
} }
// operator() // operator()
@ -52,12 +52,12 @@ void access(Array& A, const const_array_tag&) {
for (index k2 = idx2; k2 != idx2+4; ++k2) { for (index k2 = idx2; k2 != idx2+4; ++k2) {
boost::array<index,ndims> indices; boost::array<index,ndims> indices;
indices[0] = i2; indices[1] = j2; indices[2] = k2; indices[0] = i2; indices[1] = j2; indices[2] = k2;
BOOST_CHECK(A(indices) == A[i2][j2][k2]); BOOST_TEST(A(indices) == A[i2][j2][k2]);
BOOST_CHECK(CA(indices) == A(indices)); BOOST_TEST(CA(indices) == A(indices));
} }
++tests_run; ++tests_run;
} }
int test_main(int,char*[]) { int main() {
return run_generative_tests(); return run_generative_tests();
} }

151
test/allocators.cpp Normal file
View File

@ -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();
}

8
test/assert.cpp
View File

@ -15,10 +15,10 @@
// with exceptions // with exceptions
// //
#include "boost/test/minimal.hpp" #include <boost/core/lightweight_test.hpp>
#define BOOST_ENABLE_ASSERT_HANDLER #define BOOST_ENABLE_ASSERT_HANDLER
#include "boost/multi_array.hpp" // includes assert.hpp #include <boost/multi_array.hpp> // includes assert.hpp
#include <stdexcept> #include <stdexcept>
@ -40,7 +40,7 @@ namespace boost {
using namespace boost; using namespace boost;
int int
test_main(int,char*[]) { main() {
typedef multi_array<int,2> array_t; typedef multi_array<int,2> array_t;
@ -55,5 +55,5 @@ test_main(int,char*[]) {
//...all good //...all good
} }
return boost::exit_success; return boost::report_errors();
} }

10
test/assign.cpp
View File

@ -15,9 +15,9 @@
// //
// //
#include "generative_tests.hpp" #include "generative_tests.hpp"
#include "boost/array.hpp" #include <boost/array.hpp>
#include "boost/multi_array.hpp" #include <boost/multi_array.hpp>
#include "boost/cstdlib.hpp" #include <boost/cstdlib.hpp>
#include <algorithm> #include <algorithm>
#include <iostream> #include <iostream>
@ -59,7 +59,7 @@ void access(Array& A, const mutable_array_tag&) {
A = filler; A = filler;
BOOST_CHECK(::equal(A,filler)); BOOST_TEST(::equal(A,filler));
++tests_run; ++tests_run;
} }
@ -68,6 +68,6 @@ void access(Array&, const const_array_tag&) {
} }
int test_main(int,char*[]) { int main() {
return run_generative_tests(); return run_generative_tests();
} }

10
test/assign_to_array.cpp
View File

@ -16,9 +16,9 @@
// //
// //
#include "generative_tests.hpp" #include "generative_tests.hpp"
#include "boost/array.hpp" #include <boost/array.hpp>
#include "boost/multi_array.hpp" #include <boost/multi_array.hpp>
#include "boost/cstdlib.hpp" #include <boost/cstdlib.hpp>
#include <algorithm> #include <algorithm>
#include <iostream> #include <iostream>
@ -50,11 +50,11 @@ template <typename Array>
void access(Array& A, const const_array_tag&) { void access(Array& A, const const_array_tag&) {
typedef boost::multi_array<int,3> array3; typedef boost::multi_array<int,3> array3;
array3 acopy(A); array3 acopy(A);
BOOST_CHECK(::equal(acopy,A)); BOOST_TEST(::equal(acopy,A));
++tests_run; ++tests_run;
} }
int test_main(int,char*[]) { int main() {
return run_generative_tests(); return run_generative_tests();
} }

54
test/compare.cpp
View File

@ -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 <algorithm>
#include <list> #include <list>
int int
test_main(int, char*[]) main()
{ {
typedef boost::multi_array<double, 3> array; typedef boost::multi_array<double, 3> array;
typedef array::size_type size_type; typedef array::size_type size_type;
@ -34,9 +34,9 @@ test_main(int, char*[])
std::vector<double> vals(num_elements, 4.5); std::vector<double> vals(num_elements, 4.5);
A.assign(vals.begin(),vals.end()); A.assign(vals.begin(),vals.end());
array B(A); array B(A);
BOOST_CHECK(A == B); BOOST_TEST(A == B);
BOOST_CHECK(B == A); BOOST_TEST(B == A);
BOOST_CHECK(A[0] == B[0]); BOOST_TEST(A[0] == B[0]);
} }
// Assignment Operator // Assignment Operator
{ {
@ -44,15 +44,15 @@ test_main(int, char*[])
std::vector<double> vals(num_elements, 4.5); std::vector<double> vals(num_elements, 4.5);
A.assign(vals.begin(),vals.end()); A.assign(vals.begin(),vals.end());
B = A; B = A;
BOOST_CHECK(A == B); BOOST_TEST(A == B);
BOOST_CHECK(B == A); BOOST_TEST(B == A);
BOOST_CHECK(B[0] == A[0]); BOOST_TEST(B[0] == A[0]);
typedef array::index_range range; typedef array::index_range range;
array::index_gen indices; array::index_gen indices;
array::array_view<2>::type C = A[indices[2][range()][range()]]; array::array_view<2>::type C = A[indices[2][range()][range()]];
array::array_view<2>::type D = B[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 // Different Arrays
{ {
@ -62,15 +62,15 @@ test_main(int, char*[])
A.assign(valsA.begin(),valsA.end()); A.assign(valsA.begin(),valsA.end());
B.assign(valsB.begin(),valsB.end()); B.assign(valsB.begin(),valsB.end());
BOOST_CHECK(A != B); BOOST_TEST(A != B);
BOOST_CHECK(B != A); BOOST_TEST(B != A);
BOOST_CHECK(A[0] != B[0]); BOOST_TEST(A[0] != B[0]);
typedef array::index_range range; typedef array::index_range range;
array::index_gen indices; array::index_gen indices;
array::array_view<2>::type C = A[indices[2][range()][range()]]; array::array_view<2>::type C = A[indices[2][range()][range()]];
array::array_view<2>::type D = B[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! // Comparisons galore!
@ -108,35 +108,35 @@ test_main(int, char*[])
A.assign(valsA,valsA+num_elements); A.assign(valsA,valsA+num_elements);
B.assign(valsB,valsB+num_elements); B.assign(valsB,valsB+num_elements);
BOOST_CHECK(B < A); BOOST_TEST(B < A);
BOOST_CHECK(A > B); BOOST_TEST(A > B);
BOOST_CHECK(B <= A); BOOST_TEST(B <= A);
BOOST_CHECK(A >= B); BOOST_TEST(A >= B);
BOOST_CHECK(B[0] == A[0]); BOOST_TEST(B[0] == A[0]);
BOOST_CHECK(B[2] < A[2]); BOOST_TEST(B[2] < A[2]);
array C = A; array C = A;
BOOST_CHECK(C <= A); BOOST_TEST(C <= A);
BOOST_CHECK(C >= A); BOOST_TEST(C >= A);
BOOST_CHECK(!(C < A)); BOOST_TEST(!(C < A));
BOOST_CHECK(!(C > A)); BOOST_TEST(!(C > A));
typedef array::index_range range; typedef array::index_range range;
array::index_gen indices; array::index_gen indices;
array::array_view<2>::type D = A[indices[2][range()][range()]]; array::array_view<2>::type D = A[indices[2][range()][range()]];
array::array_view<2>::type E = B[indices[2][range()][range()]]; array::array_view<2>::type E = B[indices[2][range()][range()]];
BOOST_CHECK(E < D); BOOST_TEST(E < D);
BOOST_CHECK(E <= D); BOOST_TEST(E <= D);
} }
return boost::exit_success; return boost::report_errors();
} }

14
test/concept_checks.cpp
View File

@ -15,18 +15,18 @@
// make sure the types meet concept requirements // make sure the types meet concept requirements
// //
#include "boost/concept_check.hpp" #include <boost/concept_check.hpp>
#include "boost/multi_array/concept_checks.hpp" #include <boost/multi_array/concept_checks.hpp>
#include "boost/multi_array.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 int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array<int,ndims> array; typedef boost::multi_array<int,ndims> array;

36
test/constructors.cpp
View File

@ -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 <algorithm>
#include <list> #include <list>
@ -30,10 +30,10 @@ void check_shape(const Array& A,
int* strides, int* strides,
unsigned int num_elements) unsigned int num_elements)
{ {
BOOST_CHECK(A.num_elements() == num_elements); BOOST_TEST(A.num_elements() == num_elements);
BOOST_CHECK(A.size() == *sizes); BOOST_TEST(A.size() == *sizes);
BOOST_CHECK(std::equal(sizes, sizes + A.num_dimensions(), A.shape())); BOOST_TEST(std::equal(sizes, sizes + A.num_dimensions(), A.shape()));
BOOST_CHECK(std::equal(strides, strides + A.num_dimensions(), A.strides())); BOOST_TEST(std::equal(strides, strides + A.num_dimensions(), A.strides()));
check_shape(A[0], ++sizes, ++strides, num_elements / A.size()); check_shape(A[0], ++sizes, ++strides, num_elements / A.size());
} }
@ -56,7 +56,7 @@ bool equal(const ArrayA& A, const ArrayB& B)
int int
test_main(int, char*[]) main()
{ {
typedef boost::multi_array<double, 3>::size_type size_type; typedef boost::multi_array<double, 3>::size_type size_type;
boost::array<size_type,3> sizes = { { 3, 3, 3 } }; boost::array<size_type,3> sizes = { { 3, 3, 3 } };
@ -132,20 +132,20 @@ test_main(int, char*[])
A.assign(vals.begin(),vals.end()); A.assign(vals.begin(),vals.end());
boost::multi_array<double, 3> B(A); boost::multi_array<double, 3> B(A);
check_shape(B, &sizes[0], strides, num_elements); check_shape(B, &sizes[0], strides, num_elements);
BOOST_CHECK(::equal(A, B)); BOOST_TEST(::equal(A, B));
double ptr[27]; double ptr[27];
boost::multi_array_ref<double, 3> C(ptr,sizes); boost::multi_array_ref<double, 3> C(ptr,sizes);
A.assign(vals.begin(),vals.end()); A.assign(vals.begin(),vals.end());
boost::multi_array_ref<double, 3> D(C); boost::multi_array_ref<double, 3> D(C);
check_shape(D, &sizes[0], strides, num_elements); check_shape(D, &sizes[0], strides, num_elements);
BOOST_CHECK(C.data() == D.data()); BOOST_TEST(C.data() == D.data());
const double* cptr = ptr; const double* cptr = ptr;
boost::const_multi_array_ref<double, 3> E(cptr,sizes); boost::const_multi_array_ref<double, 3> E(cptr,sizes);
boost::const_multi_array_ref<double, 3> F(E); boost::const_multi_array_ref<double, 3> F(E);
check_shape(F, &sizes[0], strides, num_elements); 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); boost::const_multi_array_ref<double, 3> C(A);
check_shape(B, &sizes[0], strides, num_elements); check_shape(B, &sizes[0], strides, num_elements);
check_shape(C, &sizes[0], strides, num_elements); check_shape(C, &sizes[0], strides, num_elements);
BOOST_CHECK(B.data() == A.data()); BOOST_TEST(B.data() == A.data());
BOOST_CHECK(C.data() == A.data()); BOOST_TEST(C.data() == A.data());
double ptr[27]; double ptr[27];
boost::multi_array_ref<double, 3> D(ptr,sizes); boost::multi_array_ref<double, 3> D(ptr,sizes);
D.assign(vals.begin(),vals.end()); D.assign(vals.begin(),vals.end());
boost::const_multi_array_ref<double, 3> E(D); boost::const_multi_array_ref<double, 3> E(D);
check_shape(E, &sizes[0], strides, num_elements); check_shape(E, &sizes[0], strides, num_elements);
BOOST_CHECK(E.data() == D.data()); BOOST_TEST(E.data() == D.data());
} }
// Assignment Operator // Assignment Operator
@ -182,7 +182,7 @@ test_main(int, char*[])
A.assign(vals.begin(),vals.end()); A.assign(vals.begin(),vals.end());
B = A; B = A;
check_shape(B, &sizes[0], strides, num_elements); check_shape(B, &sizes[0], strides, num_elements);
BOOST_CHECK(::equal(A, B)); BOOST_TEST(::equal(A, B));
double ptr1[27]; double ptr1[27];
double ptr2[27]; double ptr2[27];
@ -190,7 +190,7 @@ test_main(int, char*[])
C.assign(vals.begin(),vals.end()); C.assign(vals.begin(),vals.end());
D = C; D = C;
check_shape(D, &sizes[0], strides, num_elements); 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]; subarray::value_type C = B[0];
// should comparisons between the types work? // should comparisons between the types work?
BOOST_CHECK(::equal(A[1][0],C)); BOOST_TEST(::equal(A[1][0],C));
BOOST_CHECK(::equal(B[0],C)); BOOST_TEST(::equal(B[0],C));
} }
return boost::exit_success; return boost::report_errors();
} }

6
test/dimtest.cpp
View File

@ -13,9 +13,9 @@
// //
// Trying to diagnose problems under visual // Trying to diagnose problems under visual
#include "boost/config.hpp" #include <boost/config.hpp>
#include "boost/array.hpp" #include <boost/array.hpp>
#include "boost/limits.hpp" #include <boost/limits.hpp>
#include <algorithm> #include <algorithm>
#include <utility> #include <utility>

10
test/fail_cbracket.cpp
View File

@ -15,14 +15,14 @@
// checking constness of const operator[]. // 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 int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array<int,ndims> array; typedef boost::multi_array<int,ndims> array;
@ -36,5 +36,5 @@ test_main(int,char*[])
// FAIL! cannot assign to csma. // FAIL! cannot assign to csma.
csma[0][0][0] = 5; csma[0][0][0] = 5;
return boost::exit_success; return boost::report_errors();
} }

10
test/fail_cdata.cpp
View File

@ -15,14 +15,14 @@
// Testing data() member function constness. // 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 int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array<int,ndims> array; typedef boost::multi_array<int,ndims> array;
@ -37,5 +37,5 @@ test_main(int,char*[])
// FAIL! data() returns a const int* // FAIL! data() returns a const int*
*csma.data() = 0; *csma.data() = 0;
return boost::exit_success; return boost::report_errors();
} }

8
test/fail_citerator.cpp
View File

@ -15,12 +15,12 @@
// const_iterator/iterator conversion test // 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 boost::multi_array<int,3> array;
typedef array::iterator iterator1; typedef array::iterator iterator1;
@ -29,5 +29,5 @@ int test_main(int,char*[]) {
// ILLEGAL conversion from const_iterator to iterator // ILLEGAL conversion from const_iterator to iterator
iterator1 in = citerator1(); iterator1 in = citerator1();
return boost::exit_success; return boost::report_errors();
} }

10
test/fail_cparen.cpp
View File

@ -15,14 +15,14 @@
// Testing const operator() constness. // 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 int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array<int,ndims> array; typedef boost::multi_array<int,ndims> array;
@ -40,5 +40,5 @@ test_main(int,char*[])
// FAIL! Cannot assign to csma // FAIL! Cannot assign to csma
csma(indices) = 5; csma(indices) = 5;
return boost::exit_success; return boost::report_errors();
} }

8
test/fail_criterator.cpp
View File

@ -15,12 +15,12 @@
// const_reverse_iterator/reverse_iterator conversion test // 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 boost::multi_array<int,3> array;
typedef array::reverse_iterator riterator1; typedef array::reverse_iterator riterator1;
@ -29,5 +29,5 @@ int test_main(int,char*[]) {
// ILLEGAL conversion from const_reverse_iterator to reverse_iterator // ILLEGAL conversion from const_reverse_iterator to reverse_iterator
riterator1 in = criterator1(); riterator1 in = criterator1();
return boost::exit_success; return boost::report_errors();
} }

10
test/fail_csubarray.cpp
View File

@ -15,14 +15,14 @@
// Testing subarray and const_subarray assignment // 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 int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array<int,ndims> array; typedef boost::multi_array<int,ndims> array;
@ -42,5 +42,5 @@ test_main(int,char*[])
// FAIL! Preserve constness (no const_subarray -> subarray conversion). // FAIL! Preserve constness (no const_subarray -> subarray conversion).
array::subarray<ndims-1>::type sba = csba; array::subarray<ndims-1>::type sba = csba;
return boost::exit_success; return boost::report_errors();
} }

10
test/fail_csubarray2.cpp
View File

@ -15,14 +15,14 @@
// Testing constness of subarray operations. // 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 int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array<int,ndims> array; typedef boost::multi_array<int,ndims> array;
@ -41,5 +41,5 @@ test_main(int,char*[])
// FAIL! preserve constness. // FAIL! preserve constness.
array::subarray<ndims-1>::type sba = sma_const[0]; array::subarray<ndims-1>::type sba = sma_const[0];
return boost::exit_success; return boost::report_errors();
} }

10
test/fail_csubarray3.cpp
View File

@ -15,14 +15,14 @@
// Testing constness of subarray operations. // 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 int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array<int,ndims> array; typedef boost::multi_array<int,ndims> array;
@ -45,5 +45,5 @@ test_main(int,char*[])
// FAIL! sba cannot be assigned to. // FAIL! sba cannot be assigned to.
sba[j][k] = num++; sba[j][k] = num++;
return boost::exit_success; return boost::report_errors();
} }

12
test/fail_cview.cpp
View File

@ -15,15 +15,15 @@
// ensure const_array_view doesn't allow element assignment. // 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/array.hpp>
#include "boost/type.hpp" #include <boost/type.hpp>
int int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array<int,ndims> array; typedef boost::multi_array<int,ndims> array;
@ -54,7 +54,7 @@ test_main(int,char*[])
// FAIL! const_array_view cannot be assigned to. // FAIL! const_array_view cannot be assigned to.
csma2(elmt) = 5; csma2(elmt) = 5;
return boost::exit_success; return boost::report_errors();
} }

14
test/fail_cview2.cpp
View File

@ -15,17 +15,17 @@
// ensure const_array_view cannot be converted to array_view // ensure const_array_view cannot be converted to array_view
// //
#include "boost/multi_array.hpp" #include <boost/multi_array.hpp>
#define BOOST_INCLUDE_MAIN #define BOOST_INCLUDE_MAIN
#include "boost/test/test_tools.hpp" #include <boost/test/test_tools.hpp>
#include "boost/array.hpp" #include <boost/array.hpp>
#include "boost/type.hpp" #include <boost/type.hpp>
#include "boost/cstdlib.hpp" #include <boost/cstdlib.hpp>
int int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array<int,ndims> array; typedef boost::multi_array<int,ndims> array;
@ -52,7 +52,7 @@ test_main(int,char*[])
array::array_view<ndims>::type csma2 = array::array_view<ndims>::type csma2 =
csma[indices[range(0,2)][range(1,3)][range(0,4,2)]]; csma[indices[range(0,2)][range(1,3)][range(0,4,2)]];
return boost::exit_success; return boost::report_errors();
} }

12
test/fail_cview3.cpp
View File

@ -15,15 +15,15 @@
// ensure const_array_ref doesn't allow assignment. // 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/array.hpp>
#include "boost/type.hpp" #include <boost/type.hpp>
int int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array<int,ndims> array; typedef boost::multi_array<int,ndims> array;
@ -55,7 +55,7 @@ test_main(int,char*[])
// FAIL! csma2 cannot be assigned to. // FAIL! csma2 cannot be assigned to.
csma2[i][j][k] = 0; csma2[i][j][k] = 0;
return boost::exit_success; return boost::report_errors();
} }

10
test/fail_ref_cbracket.cpp
View File

@ -15,14 +15,14 @@
// checking constness of const operator[]. // 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 int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array_ref<int,ndims> array_ref; 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. // FAIL! can't assign to const multi_array_ref.
csma[0][0][0] = 5; csma[0][0][0] = 5;
return boost::exit_success; return boost::report_errors();
} }

10
test/fail_ref_cdata.cpp
View File

@ -15,14 +15,14 @@
// Testing data() member function constness. // 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 int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array_ref<int,ndims> array_ref; typedef boost::multi_array_ref<int,ndims> array_ref;
@ -36,5 +36,5 @@ test_main(int,char*[])
// FAIL! data() returns const int*. // FAIL! data() returns const int*.
*csma.data() = 0; *csma.data() = 0;
return boost::exit_success; return boost::report_errors();
} }

8
test/fail_ref_citerator.cpp
View File

@ -15,12 +15,12 @@
// const_iterator/iterator conversion test // 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 boost::multi_array_ref<int,3> array_ref;
typedef array_ref::iterator iterator1; typedef array_ref::iterator iterator1;
@ -29,5 +29,5 @@ int test_main(int,char*[]) {
// FAIL! ILLEGAL conversion from const_iterator to iterator // FAIL! ILLEGAL conversion from const_iterator to iterator
iterator1 in = citerator1(); iterator1 in = citerator1();
return boost::exit_success; return boost::report_errors();
} }

10
test/fail_ref_cparen.cpp
View File

@ -15,14 +15,14 @@
// Testing const operator() constness. // 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 int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array_ref<int,ndims> array_ref; 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 // FAIL! cannot assign to a const multi_array_ref
csma(indices) = 5; csma(indices) = 5;
return boost::exit_success; return boost::report_errors();
} }

8
test/fail_ref_criterator.cpp
View File

@ -15,12 +15,12 @@
// const_reverse_iterator/reverse_iterator conversion test // 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 boost::multi_array_ref<int,3> array_ref;
typedef array_ref::reverse_iterator riterator1; 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 // Fail! ILLEGAL conversion from const_reverse_iterator to reverse_iterator
riterator1 in = criterator1(); riterator1 in = criterator1();
return boost::exit_success; return boost::report_errors();
} }

10
test/fail_ref_csubarray.cpp
View File

@ -15,14 +15,14 @@
// Testing subarray and const_subarray assignment // 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 int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array_ref<int,ndims> array_ref; 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. array_ref::subarray<ndims-1>::type sba = csba; // FAIL! preserve constness.
return boost::exit_success; return boost::report_errors();
} }

10
test/fail_ref_csubarray2.cpp
View File

@ -15,14 +15,14 @@
// Testing constness of subarray operations. // 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 int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array_ref<int,ndims> array_ref; 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! array_ref::subarray<ndims-1>::type sba = sma_const[0]; // FAIL!
// preserve constness // preserve constness
return boost::exit_success; return boost::report_errors();
} }

10
test/fail_ref_csubarray3.cpp
View File

@ -15,14 +15,14 @@
// Testing constness of subarray operations. // 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 int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array_ref<int,ndims> array_ref; 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) for (array_ref::index k = 0; k != 4; ++k)
sba[j][k] = num++; // FAIL! can't assign to const_subarray. sba[j][k] = num++; // FAIL! can't assign to const_subarray.
return boost::exit_success; return boost::report_errors();
} }

12
test/fail_ref_cview.cpp
View File

@ -15,15 +15,15 @@
// ensure const_array_view doesn't allow element assignment. // 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/array.hpp>
#include "boost/type.hpp" #include <boost/type.hpp>
int int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array_ref<int,ndims> array_ref; 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 csma2(elmt) = 5; // FAIL! csma is read only
return boost::exit_success; return boost::report_errors();
} }

12
test/fail_ref_cview2.cpp
View File

@ -15,15 +15,15 @@
// ensure const_array_view cannot be converted to array_view // 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/array.hpp>
#include "boost/type.hpp" #include <boost/type.hpp>
int int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array_ref<int,ndims> array_ref; 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) for (array_ref::index k = 0; k != 2; ++k)
csma2[i][j][k] = 0; // FAIL! csma2 is read only csma2[i][j][k] = 0; // FAIL! csma2 is read only
return boost::exit_success; return boost::report_errors();
} }

12
test/fail_ref_cview3.cpp
View File

@ -15,15 +15,15 @@
// ensure const_array_view doesn't allow assignment. // 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/array.hpp>
#include "boost/type.hpp" #include <boost/type.hpp>
int int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array_ref<int,ndims> array_ref; 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) for (array_ref::index k = 0; k != 2; ++k)
csma2[i][j][k] = 0; // FAIL! csma2 is read only. csma2[i][j][k] = 0; // FAIL! csma2 is read only.
return boost::exit_success; return boost::report_errors();
} }

13
test/generative_tests.hpp
View File

@ -45,9 +45,9 @@
// //
// int test_main(int,char*[]) { return run_generative_tests(); } // 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 <boost/config.hpp> /* BOOST_NO_SFINAE */
#include <algorithm> #include <algorithm>
@ -100,7 +100,7 @@ template <typename Array>
void access(Array& A, const const_array_tag&); void access(Array& A, const const_array_tag&);
template <typename StorageOrder3,typename StorageOrder4,typename Modifier> template <typename StorageOrder3,typename StorageOrder4,typename Modifier>
int run_configuration(const StorageOrder3& so3, void run_configuration(const StorageOrder3& so3,
const StorageOrder4& so4, const StorageOrder4& so4,
const Modifier& modifier) { const Modifier& modifier) {
// multi_array // multi_array
@ -213,11 +213,10 @@ int run_configuration(const StorageOrder3& so3,
access(C,const_array_tag()); access(C,const_array_tag());
} }
} }
return boost::exit_success;
} }
template <typename ArrayModifier> template <typename ArrayModifier>
int run_storage_tests(const ArrayModifier& modifier) { void run_storage_tests(const ArrayModifier& modifier) {
run_configuration(boost::c_storage_order(), run_configuration(boost::c_storage_order(),
boost::c_storage_order(),modifier); boost::c_storage_order(),modifier);
run_configuration(boost::fortran_storage_order(), 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), run_configuration(boost::general_storage_order<3>(ordering,ascending),
boost::general_storage_order<4>(ordering,ascending), boost::general_storage_order<4>(ordering,ascending),
modifier); modifier);
return boost::exit_success;
} }
struct null_modifier { struct null_modifier {
@ -279,7 +276,7 @@ int run_generative_tests() {
run_storage_tests(reindex_modifier()); run_storage_tests(reindex_modifier());
run_storage_tests(reshape_modifier()); run_storage_tests(reshape_modifier());
std::cout << "Total Tests Run: " << tests_run << '\n'; std::cout << "Total Tests Run: " << tests_run << '\n';
return boost::exit_success; return boost::report_errors();
} }
#endif // GENERATIVE_TESTS_RG072001_HPP #endif // GENERATIVE_TESTS_RG072001_HPP

28
test/idxgen1.cpp
View File

@ -14,12 +14,12 @@
// idxset1.cpp - testing the code for index_gen // idxset1.cpp - testing the code for index_gen
// //
#include "boost/multi_array/index_gen.hpp" #include <boost/multi_array/index_gen.hpp>
#include "boost/multi_array/index_range.hpp" #include <boost/multi_array/index_range.hpp>
#include "boost/multi_array/types.hpp" #include <boost/multi_array/types.hpp>
#include "boost/test/minimal.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::index index_type;
typedef boost::detail::multi_array::size_type size_type; typedef boost::detail::multi_array::size_type size_type;
@ -37,7 +37,7 @@ bool operator==(const range& lhs,const range& rhs) {
} }
int int
test_main(int,char*[]) main()
{ {
boost::detail::multi_array::index_gen<0,0> indices; 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 = boost::detail::multi_array::index_gen<3,3> is1 =
indices[range(0,1,2)][range(1,2,3)][range(2,3,4)]; indices[range(0,1,2)][range(1,2,3)][range(2,3,4)];
BOOST_CHECK(is1.ranges_[0] == range(0,1,2)); BOOST_TEST(is1.ranges_[0] == range(0,1,2));
BOOST_CHECK(is1.ranges_[1] == range(1,2,3)); BOOST_TEST(is1.ranges_[1] == range(1,2,3));
BOOST_CHECK(is1.ranges_[2] == range(2,3,4)); BOOST_TEST(is1.ranges_[2] == range(2,3,4));
} }
{ {
boost::detail::multi_array::index_gen<3,2> is2 = boost::detail::multi_array::index_gen<3,2> is2 =
indices[range(0,1,2)][2][range(2,3,4)]; indices[range(0,1,2)][2][range(2,3,4)];
BOOST_CHECK(is2.ranges_[0] == range(0,1,2)); BOOST_TEST(is2.ranges_[0] == range(0,1,2));
BOOST_CHECK(is2.ranges_[1] == range(2)); BOOST_TEST(is2.ranges_[1] == range(2));
BOOST_CHECK(is2.ranges_[1].is_degenerate()); BOOST_TEST(is2.ranges_[1].is_degenerate());
BOOST_CHECK(is2.ranges_[2] == range(2,3,4)); BOOST_TEST(is2.ranges_[2] == range(2,3,4));
} }
return boost::exit_success; return boost::report_errors();
} }

34
test/index_bases.cpp
View File

@ -14,15 +14,15 @@
// index_bases - test of the index_base modifying facilities. // 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 <vector>
#include <iostream> #include <iostream>
int int
test_main(int,char*[]) main()
{ {
typedef boost::multi_array<double, 3> array; typedef boost::multi_array<double, 3> array;
typedef boost::multi_array_ref<double, 3> array_ref; 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 a = 0; a < A.shape()[0]; ++a)
for (size_type b = 0; b < A.shape()[1]; ++b) for (size_type b = 0; b < A.shape()[1]; ++b)
for (size_type c = 0; c < A.shape()[2]; ++c) { 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_TEST(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_TEST(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(D[a+bases[0]][b+bases[1]][c+bases[2]] == B[a][b][c]);
// Test that E does not inherit A's index_base // 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 a = 0; a < A.shape()[0]; ++a)
for (size_type b = 0; b < A.shape()[1]; ++b) for (size_type b = 0; b < A.shape()[1]; ++b)
for (size_type c = 0; c < A.shape()[2]; ++c) { 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_TEST(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_TEST(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(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(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 a = 0; a < A.shape()[0]; ++a)
for (size_type b = 0; b < A.shape()[1]; ++b) for (size_type b = 0; b < A.shape()[1]; ++b)
for (size_type c = 0; c < A.shape()[2]; ++c) { for (size_type c = 0; c < A.shape()[2]; ++c) {
BOOST_CHECK(A[a+1][b+1][c+1] == B[a][b][c]); BOOST_TEST(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_TEST(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_TEST(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(E[a+1][b+1][c+1] == B[a][b][c]);
} }
} }
return boost::exit_success; return boost::report_errors();
} }

18
test/iterators.cpp
View File

@ -17,9 +17,9 @@
#define MULTIARRAY_TEST_ASSIGN #define MULTIARRAY_TEST_ASSIGN
#include "generative_tests.hpp" #include "generative_tests.hpp"
#include "boost/concept_check.hpp" // for ignore_unused_variable_warning #include <boost/concept_check.hpp> // for ignore_unused_variable_warning
#include "boost/mpl/if.hpp" #include <boost/mpl/if.hpp>
#include "boost/type_traits/is_same.hpp" #include <boost/type_traits/is_same.hpp>
// iterator-test-specific code // iterator-test-specific code
@ -107,8 +107,8 @@ void test_iterators(Array& A, const IterTraits&) {
typedef typename IterTraits::iterator3 iterator; typedef typename IterTraits::iterator3 iterator;
iterator i1 = A.begin(); iterator i1 = A.begin();
iterator i2 = A.end(); iterator i2 = A.end();
BOOST_CHECK(i1 < i2); BOOST_TEST(i1 < i2);
BOOST_CHECK((i2 - i1) == typename iterator::difference_type(2)); BOOST_TEST((i2 - i1) == typename iterator::difference_type(2));
} }
// Standard Array Iteration // Standard Array Iteration
@ -121,7 +121,7 @@ void test_iterators(Array& A, const IterTraits&) {
for (iterator3 i = A.begin(); i != A.end(); ++i) for (iterator3 i = A.begin(); i != A.end(); ++i)
for(iterator2 ii = (*i).begin(); ii != (*i).end(); ++ii) for(iterator2 ii = (*i).begin(); ii != (*i).end(); ++ii)
for(iterator1 iii = (*ii).begin(); iii != (*ii).end(); ++iii) for(iterator1 iii = (*ii).begin(); iii != (*ii).end(); ++iii)
BOOST_CHECK(*iii == vals++); BOOST_TEST(*iii == vals++);
} }
// Using operator->() on iterators // 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 (iterator3 i = A.begin(); i != A.end(); ++i)
for(iterator2 ii = i->begin(); ii != i->end(); ++ii) for(iterator2 ii = i->begin(); ii != i->end(); ++ii)
for(iterator1 iii = ii->begin(); iii != ii->end(); ++iii) for(iterator1 iii = ii->begin(); iii != ii->end(); ++iii)
BOOST_CHECK(*iii == vals++); BOOST_TEST(*iii == vals++);
} }
// Reverse Iterator Hierarchy Test // 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(riterator2 ii = (*i).rbegin(); ii != (riterator2)(*i).rend(); ++ii)
for(riterator1 iii = (*ii).rbegin(); iii != (riterator1)(*ii).rend(); for(riterator1 iii = (*ii).rbegin(); iii != (riterator1)(*ii).rend();
++iii) ++iii)
BOOST_CHECK(*iii == check_iter_val--); BOOST_TEST(*iii == check_iter_val--);
} }
++tests_run; ++tests_run;
} }
@ -182,7 +182,7 @@ void access(Array& A, const const_array_tag&) {
int int
test_main(int, char*[]) main()
{ {
return run_generative_tests(); return run_generative_tests();
} }

83
test/range1.cpp
View File

@ -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> #include <cstddef>
int int
test_main(int,char*[]) main()
{ {
typedef boost::detail::multi_array::index_range<int,std::size_t> range; typedef boost::detail::multi_array::index_range<int,std::size_t> range;
{ {
// typical range creation and extraction // typical range creation and extraction
range r1(-3,5); range r1(-3,5);
BOOST_CHECK(r1.start() == -3); BOOST_TEST(r1.start() == -3);
BOOST_CHECK(r1.finish() == 5); BOOST_TEST(r1.finish() == 5);
BOOST_CHECK(r1.stride() == 1); BOOST_TEST(r1.stride() == 1);
BOOST_CHECK(!r1.is_degenerate()); BOOST_TEST(r1.size(0) == 8);
BOOST_CHECK(r1.get_start(0) == -3); BOOST_TEST(!r1.is_degenerate());
BOOST_CHECK(r1.get_finish(100) == 5); BOOST_TEST(r1.get_start(0) == -3);
BOOST_TEST(r1.get_finish(100) == 5);
} }
{ {
range r2(-3,5,2); range r2(-3,5,2);
BOOST_CHECK(r2.start() == -3); BOOST_TEST(r2.start() == -3);
BOOST_CHECK(r2.finish() == 5); BOOST_TEST(r2.finish() == 5);
BOOST_CHECK(r2.stride() == 2); BOOST_TEST(r2.stride() == 2);
BOOST_CHECK(!r2.is_degenerate()); BOOST_TEST(r2.size(0) == 4);
BOOST_TEST(!r2.is_degenerate());
} }
{ {
// degenerate creation // degenerate creation
range r3(5); range r3(5);
BOOST_CHECK(r3.start() == 5); BOOST_TEST(r3.start() == 5);
BOOST_CHECK(r3.finish() == 6); BOOST_TEST(r3.finish() == 6);
BOOST_CHECK(r3.stride() == 1); BOOST_TEST(r3.stride() == 1);
BOOST_CHECK(r3.is_degenerate()); BOOST_TEST(r3.size(0) == 1);
BOOST_TEST(r3.is_degenerate());
} }
{ {
// default range creation // default range creation
range r4; range r4;
BOOST_CHECK(r4.get_start(0) == 0); BOOST_TEST(r4.get_start(0) == 0);
BOOST_CHECK(r4.get_finish(100) == 100); BOOST_TEST(r4.get_finish(100) == 100);
BOOST_CHECK(r4.stride() == 1); BOOST_TEST(r4.stride() == 1);
BOOST_TEST(r4.size(0) == 0);
} }
{ {
// create a range using the setter methods // create a range using the setter methods
range r5 = range().stride(2).start(-3).finish(7); range r5 = range().stride(2).start(-3).finish(7);
BOOST_CHECK(r5.start() == -3); BOOST_TEST(r5.start() == -3);
BOOST_CHECK(r5.stride() == 2); BOOST_TEST(r5.stride() == 2);
BOOST_CHECK(r5.finish() == 7); BOOST_TEST(r5.finish() == 7);
BOOST_TEST(r5.size(0) == 5);
} }
// try out all the comparison operators // try out all the comparison operators
{ {
range r6 = -3 <= range().stride(2) < 7; range r6 = -3 <= range().stride(2) < 7;
BOOST_CHECK(r6.start() == -3); BOOST_TEST(r6.start() == -3);
BOOST_CHECK(r6.stride() == 2); BOOST_TEST(r6.stride() == 2);
BOOST_CHECK(r6.finish() == 7); BOOST_TEST(r6.finish() == 7);
BOOST_TEST(r6.size(0) == 5);
} }
{ {
range r7 = -3 < range() <= 7; range r7 = -3 < range() <= 7;
BOOST_CHECK(r7.start() == -2); BOOST_TEST(r7.start() == -2);
BOOST_CHECK(r7.stride() == 1); BOOST_TEST(r7.stride() == 1);
BOOST_CHECK(r7.finish() == 8); BOOST_TEST(r7.finish() == 8);
BOOST_TEST(r7.size(0) == 10);
} }
// arithmetic operators // arithmetic operators
{ {
range r8 = range(0,5) + 2; range r8 = range(0,5) + 2;
BOOST_CHECK(r8.start() == 2); BOOST_TEST(r8.start() == 2);
BOOST_CHECK(r8.stride() == 1); BOOST_TEST(r8.stride() == 1);
BOOST_CHECK(r8.finish() == 7); BOOST_TEST(r8.finish() == 7);
BOOST_TEST(r8.size(0) == 5);
} }
{ {
range r9 = range(0,5) - 2; range r9 = range(0,5) - 2;
BOOST_CHECK(r9.start() == -2); BOOST_TEST(r9.start() == -2);
BOOST_CHECK(r9.stride() == 1); BOOST_TEST(r9.stride() == 1);
BOOST_CHECK(r9.finish() == 3); BOOST_TEST(r9.finish() == 3);
BOOST_TEST(r9.size(0) == 5);
} }
return boost::exit_success; return boost::report_errors();
} }

24
test/reshape.cpp
View File

@ -14,15 +14,15 @@
// reshape.cpp - testing reshaping functionality // 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/array.hpp>
#include "boost/type.hpp" #include <boost/type.hpp>
int int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
typedef boost::multi_array<int,ndims> array; 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 i = 0; i != 4; ++i)
for (array::index j = 0; j != 3; ++j) for (array::index j = 0; j != 3; ++j)
for (array::index k = 0; k != 2; ++k) { for (array::index k = 0; k != 2; ++k) {
BOOST_CHECK(A[i][j][k] == *ptr); BOOST_TEST(A[i][j][k] == *ptr);
BOOST_CHECK(B[i][j][k] == *ptr); BOOST_TEST(B[i][j][k] == *ptr);
BOOST_CHECK(C[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 i = 0; i != 4; ++i)
for (array::index j = 1; j != 4; ++j) for (array::index j = 1; j != 4; ++j)
for (array::index k = -1; k != 1; ++k) { for (array::index k = -1; k != 1; ++k) {
BOOST_CHECK(A[i][j][k] == *ptr); BOOST_TEST(A[i][j][k] == *ptr);
BOOST_CHECK(B[i][j][k] == *ptr); BOOST_TEST(B[i][j][k] == *ptr);
BOOST_CHECK(C[i][j][k] == *ptr++); BOOST_TEST(C[i][j][k] == *ptr++);
} }
} }
return boost::exit_success; return boost::report_errors();
} }

16
test/resize.cpp
View File

@ -14,13 +14,13 @@
// resize.cpp - Test of resizing multi_arrays // resize.cpp - Test of resizing multi_arrays
// //
#include "boost/test/minimal.hpp" #include <boost/core/lightweight_test.hpp>
#include "boost/multi_array.hpp" #include <boost/multi_array.hpp>
#include <iostream> #include <iostream>
using namespace std; using namespace std;
int test_main(int,char*[]) { int main() {
typedef boost::multi_array<int,3> marray; typedef boost::multi_array<int,3> marray;
@ -58,7 +58,7 @@ int test_main(int,char*[]) {
marray A(boost::extents[2][3][4]); marray A(boost::extents[2][3][4]);
A.assign(A_data,A_data+(2*3*4)); A.assign(A_data,A_data+(2*3*4));
A.resize(boost::extents[4][3][2]); 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 // resize through the Collection
@ -67,14 +67,14 @@ int test_main(int,char*[]) {
A.assign(A_data,A_data+(2*3*4)); A.assign(A_data,A_data+(2*3*4));
boost::array<int,3> new_extents = {{4,3,2}}; boost::array<int,3> new_extents = {{4,3,2}};
A.resize(new_extents); 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) // default construct all the new elements (in this case, all elements)
{ {
marray defaultA; marray defaultA;
defaultA.resize(boost::extents[2][3][4]); 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); 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 x = 0; x < 3; x++) {
for (int y = 0; y < 4; y++) { for (int y = 0; y < 4; y++) {
for (int z = 0; z < 2; z++) { for (int z = 0; z < 2; z++) {
BOOST_CHECK(*(A.data() + check) == check); BOOST_TEST(*(A.data() + check) == check);
++check; ++check;
} }
} }
@ -123,5 +123,5 @@ int test_main(int,char*[]) {
} }
return boost::exit_success; return boost::report_errors();
} }

12
test/reverse_view.cpp
View File

@ -14,12 +14,12 @@
// reverse_view.cpp - a small test of creating a view with negative strides // reverse_view.cpp - a small test of creating a view with negative strides
// //
#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 int
test_main(int,char*[]) main()
{ {
using namespace boost; using namespace boost;
@ -36,8 +36,8 @@ test_main(int,char*[])
array::array_view<1>::type B = A[indices[range(3, -1, -1)]]; array::array_view<1>::type B = A[indices[range(3, -1, -1)]];
for(multi_array_types::size_type i = 0; i != B.size(); ++i) { 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();
} }

20
test/slice.cpp
View File

@ -15,9 +15,9 @@
// //
#include "generative_tests.hpp" #include "generative_tests.hpp"
#include "boost/array.hpp" #include <boost/array.hpp>
#include "boost/mpl/if.hpp" #include <boost/mpl/if.hpp>
#include "boost/type_traits/is_same.hpp" #include <boost/type_traits/is_same.hpp>
template <typename Array> template <typename Array>
struct view_traits_mutable { struct view_traits_mutable {
@ -71,10 +71,10 @@ void test_views(Array& A, const ViewTraits&) {
for (index i = 0; i != 2; ++i) for (index i = 0; i != 2; ++i)
for (index j = 0; j != 2; ++j) for (index j = 0; j != 2; ++j)
for (index k = 0; k != 2; ++k) { 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; boost::array<index,3> elmts;
elmts[0]=i; elmts[1]=j; elmts[2]=k; 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 // Degenerate dimensions
@ -84,10 +84,10 @@ void test_views(Array& A, const ViewTraits&) {
for (index i = 0; i != 2; ++i) for (index i = 0; i != 2; ++i)
for (index j = 0; j != 2; ++j) { 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; boost::array<index,2> elmts;
elmts[0]=i; elmts[1]=j; 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 i = 0; i != 2; ++i)
for (index j = 0; j != 2; ++j) for (index j = 0; j != 2; ++j)
for (index k = 0; k != 2; ++k) { 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; boost::array<index,3> elmts;
elmts[0]=i; elmts[1]=j; elmts[2]=k; 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(); return run_generative_tests();
} }

14
test/stl_interaction.cpp
View File

@ -14,14 +14,14 @@
// stl_interaction.cpp - Make sure multi_arrays work with STL containers. // 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 <algorithm>
#include <vector> #include <vector>
int int
test_main(int, char*[]) main()
{ {
using boost::extents; using boost::extents;
using boost::indices; using boost::indices;
@ -51,7 +51,7 @@ test_main(int, char*[])
myarray.assign(data,data+data_size); myarray.assign(data,data+data_size);
array3vec myvec(5,myarray); array3vec myvec(5,myarray);
BOOST_CHECK(myarray == myvec[1]); BOOST_TEST(myarray == myvec[1]);
array3::array_view<2>::type myview = array3::array_view<2>::type myview =
myarray[indices[1][range(0,2)][range(1,3)]]; myarray[indices[1][range(0,2)][range(1,3)]];
@ -65,8 +65,8 @@ test_main(int, char*[])
myvec.push_back(myarray); myvec.push_back(myarray);
BOOST_CHECK(myarray != myvec[1]); BOOST_TEST(myarray != myvec[1]);
BOOST_CHECK(myarray == myvec[5]); BOOST_TEST(myarray == myvec[5]);
return boost::exit_success; return boost::report_errors();
} }

18
test/storage_order.cpp
View File

@ -14,14 +14,14 @@
// storage_order.cpp - testing storage_order-isms. // 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 int
test_main(int,char*[]) main()
{ {
const int ndims=3; const int ndims=3;
@ -67,7 +67,7 @@ test_main(int,char*[])
for (array::index i = 0; i != 2; ++i) for (array::index i = 0; i != 2; ++i)
for (array::index j = 0; j != 3; ++j) for (array::index j = 0; j != 3; ++j)
for (array::index k = 0; k != 4; ++k) 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 // Mimic fortran_storage_order using
@ -88,7 +88,7 @@ test_main(int,char*[])
for (array::index i = 0; i != 2; ++i) for (array::index i = 0; i != 2; ++i)
for (array::index j = 0; j != 3; ++j) for (array::index j = 0; j != 3; ++j)
for (array::index k = 0; k != 4; ++k) 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 // 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 i = 0; i != 2; ++i)
for (array::index j = 0; j != 3; ++j) for (array::index j = 0; j != 3; ++j)
for (array::index k = 0; k != 4; ++k) 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 i = 0; i != 2; ++i)
for (array::index j = 0; j != 3; ++j) for (array::index j = 0; j != 3; ++j)
for (array::index k = 0; k != 4; ++k) 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();
} }

12
test/storage_order_convert.cpp
View File

@ -14,12 +14,12 @@
// test out my new storage_order stuff // 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 int
test_main(int,char*[]) { main() {
using namespace boost; using namespace boost;
@ -31,9 +31,9 @@ test_main(int,char*[]) {
general_storage_order<5> fortran_storage(fortran_ordering.begin(), general_storage_order<5> fortran_storage(fortran_ordering.begin(),
ascending.begin()); ascending.begin());
BOOST_CHECK(c_storage == (general_storage_order<5>) c_storage_order()); BOOST_TEST(c_storage == (general_storage_order<5>) c_storage_order());
BOOST_CHECK(fortran_storage == BOOST_TEST(fortran_storage ==
(general_storage_order<5>) fortran_storage_order()); (general_storage_order<5>) fortran_storage_order());
return boost::exit_success; return boost::report_errors();
} }

10
test/vc_death.cpp
View File

@ -14,15 +14,15 @@
// index_bases - test of the index_base modifying facilities. // 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 <vector>
#include <iostream> #include <iostream>
int int
test_main(int,char*[]) main()
{ {
typedef boost::multi_array<double, 3> array; typedef boost::multi_array<double, 3> array;
typedef array::array_view<3>::type array_view; 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)]]; array_view E = A[indices[irange(1,2)][irange(1,2)][irange(1,2)]];
} }
return boost::exit_success; return boost::report_errors();
} }