Release 1.47.0 beta 1

[SVN r72708]

doc/Jamfile.v2

@@ -1,5 +0,0 @@
-using boostbook ;
-
-boostbook standalone
-	: array.xml 
-	: <xsl:param>boost.root=../../../.. ;

doc/array.xml

@@ -7,10 +7,6 @@
       <firstname>Nicolai</firstname>
       <surname>Josuttis</surname>
     </author>
-    <maintainer>
-      <firstname>Marshall</firstname>
-      <surname>Clow</surname>
-    </maintainer>
 
     <copyright>
       <year>2001</year>
@@ -20,11 +16,6 @@
       <holder>Nicolai M. Josuttis</holder>
     </copyright>
    
-    <copyright>
-      <year>2012</year>
-      <holder>Marshall Clow</holder>
-    </copyright>
-
     <legalnotice>
       <para>Distributed under the Boost Software License, Version 1.0.
       (See accompanying file <filename>LICENSE_1_0.txt</filename> or copy at 
@@ -79,11 +70,6 @@
     Technical Report, which will extend the C++ Standard (see
     <ulink url="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1548.htm">http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1548.htm</ulink>).</para>
 
-    <para>Update: <code>std::array</code> is (as of C++11) part of the C++ standard.
-    The differences between <code>boost::array</code> and <code>std::array</code> are minimal.
-    If you are using C++11, you should consider using <code>std::array</code> instead of <code>boost::array</code>.
-    </para>
-
     <para>Class <code><classname>array</classname></code> fulfills most
     but not all of the requirements of "reversible containers" (see
     Section 23.1, [lib.container.requirements] of the C++
@@ -185,24 +171,6 @@
               <returns><simpara>iterator for position after the last element</simpara></returns>
               <throws><simpara>will not throw</simpara></throws>
             </overloaded-method>
-
-            <overloaded-method name="cbegin" cv="const">
-              <signature>
-                <type>const_iterator</type>
-              </signature>
-
-              <returns><simpara>constant iterator for the first element</simpara></returns>
-              <throws><simpara>will not throw</simpara></throws>
-            </overloaded-method>
-
-            <overloaded-method name="cend" cv="const">
-              <signature>
-                <type>const_iterator</type>
-              </signature>
-
-              <returns><simpara>constant iterator for position after the last element</simpara></returns>
-              <throws><simpara>will not throw</simpara></throws>
-            </overloaded-method>
           </method-group>
 
           <method-group name="reverse iterator support">
@@ -227,24 +195,6 @@
 
               <returns><simpara>reverse iterator for position after the last element in reverse iteration</simpara></returns>
             </overloaded-method>
-  
-            <overloaded-method name="crbegin" cv="const">
-              <signature>
-                <type>const_reverse_iterator</type>
-              </signature>
-
-              <returns><simpara>constant reverse iterator for the first element of reverse iteration</simpara></returns>
-              <throws><simpara>will not throw</simpara></throws>
-            </overloaded-method>
-
-            <overloaded-method name="crend" cv="const">
-              <signature>
-                <type>const_reverse_iterator</type>
-              </signature>
-
-              <returns><simpara>constant reverse iterator for position after the last element in reverse iteration</simpara></returns>
-              <throws><simpara>will not throw</simpara></throws>
-            </overloaded-method>
           </method-group>
 
           <method-group name="capacity">
@@ -510,49 +460,6 @@
               <returns><simpara><code>!(x &lt; y)</code></simpara></returns>
             </function>
           </free-function-group>
-            
-          <free-function-group name="specializations">
-            <function name="boost::get">
-              <template>
-                <template-type-parameter name="T"/>
-                <template-nontype-parameter name="N">
-                  <type>std::size_t</type>
-                </template-nontype-parameter>
-                <template-nontype-parameter name="Idx">
-                  <type>std::size_t</type>
-                </template-nontype-parameter>
-              </template>
-
-              <type>T</type>
-              
-              <parameter name="arr">
-                <paramtype><classname>array</classname>&lt;T, N&gt;&amp;</paramtype>
-              </parameter>
-              <returns><simpara>element of array with index <code>Idx</code></simpara></returns>
-              <effects><simpara>Will <code>static_assert</code> if <code>Idx >= N</code></simpara></effects>
-            </function>
-
-            <function name="boost::get">
-              <template>
-                <template-type-parameter name="T"/>
-                <template-nontype-parameter name="N">
-                  <type>std::size_t</type>
-                </template-nontype-parameter>
-                <template-nontype-parameter name="Idx">
-                  <type>std::size_t</type>
-                </template-nontype-parameter>
-              </template>
-
-              <type>T</type>
-              
-              <parameter name="arr">
-                <paramtype>const <classname>array</classname>&lt;T, N&gt;&amp;</paramtype>
-              </parameter>
-              <returns><simpara>const element of array with index <code>Idx</code></simpara></returns>
-              <effects><simpara>Will <code>static_assert</code> if <code>Idx >= N</code></simpara></effects>
-            </function>
-          </free-function-group>
-
         </class>
       </namespace>
     </header>

include/boost/array.hpp

@@ -13,8 +13,6 @@
  * accompanying file LICENSE_1_0.txt or copy at
  * http://www.boost.org/LICENSE_1_0.txt)
  *
- *  9 Jan 2013 - (mtc) Added constexpr
- * 14 Apr 2012 - (mtc) Added support for boost::hash
  * 28 Dec 2010 - (mtc) Added cbegin and cend (and crbegin and crend) for C++Ox compatibility.
  * 10 Mar 2010 - (mtc) fill method added, matching resolution of the standard library working group.
  *      See <http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776> or Trac issue #3168
@@ -43,13 +41,11 @@
 #include <cstddef>
 #include <stdexcept>
 #include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/swap.hpp>
 
 // Handles broken standard libraries better than <iterator>
 #include <boost/detail/iterator.hpp>
 #include <boost/throw_exception.hpp>
-#include <boost/functional/hash_fwd.hpp>
 #include <algorithm>
 
 // FIXES for broken compilers
@@ -122,17 +118,19 @@ namespace boost {
         // operator[]
         reference operator[](size_type i) 
         { 
-            return BOOST_ASSERT_MSG( i < N, "out of range" ), elems[i]; 
+            BOOST_ASSERT( i < N && "out of range" ); 
+            return elems[i];
         }
         
-        /*BOOST_CONSTEXPR*/ const_reference operator[](size_type i) const 
+        const_reference operator[](size_type i) const 
         {     
-            return BOOST_ASSERT_MSG( i < N, "out of range" ), elems[i]; 
+            BOOST_ASSERT( i < N && "out of range" ); 
+            return elems[i]; 
         }
 
         // at() with range check
-        reference                           at(size_type i)       { return rangecheck(i), elems[i]; }
-        /*BOOST_CONSTEXPR*/ const_reference at(size_type i) const { return rangecheck(i), elems[i]; }
+        reference at(size_type i) { rangecheck(i); return elems[i]; }
+        const_reference at(size_type i) const { rangecheck(i); return elems[i]; }
     
         // front() and back()
         reference front() 
@@ -140,7 +138,7 @@ namespace boost {
             return elems[0]; 
         }
         
-        BOOST_CONSTEXPR const_reference front() const 
+        const_reference front() const 
         {
             return elems[0];
         }
@@ -150,15 +148,15 @@ namespace boost {
             return elems[N-1]; 
         }
         
-        BOOST_CONSTEXPR const_reference back() const 
+        const_reference back() const 
         { 
             return elems[N-1]; 
         }
 
         // size is constant
-        static BOOST_CONSTEXPR size_type size() { return N; }
-        static BOOST_CONSTEXPR bool empty() { return false; }
-        static BOOST_CONSTEXPR size_type max_size() { return N; }
+        static size_type size() { return N; }
+        static bool empty() { return false; }
+        static size_type max_size() { return N; }
         enum { static_size = N };
 
         // swap (note: linear complexity)
@@ -189,8 +187,11 @@ namespace boost {
         }
 
         // check range (may be private because it is static)
-        static BOOST_CONSTEXPR bool rangecheck (size_type i) {
-            return i > size() ? boost::throw_exception(std::out_of_range ("array<>: index out of range")), true : true;
+        static void rangecheck (size_type i) {
+            if (i >= size()) {
+                std::out_of_range e("array<>: index out of range");
+                boost::throw_exception(e);
+            }
         }
 
     };
@@ -261,14 +262,14 @@ namespace boost {
             return failed_rangecheck();
         }
 
-        /*BOOST_CONSTEXPR*/ const_reference operator[](size_type /*i*/) const
+        const_reference operator[](size_type /*i*/) const
         {
             return failed_rangecheck();
         }
 
         // at() with range check
         reference at(size_type /*i*/)               {   return failed_rangecheck(); }
-        /*BOOST_CONSTEXPR*/ const_reference at(size_type /*i*/) const   { return failed_rangecheck(); }
+        const_reference at(size_type /*i*/) const   {   return failed_rangecheck(); }
 
         // front() and back()
         reference front()
@@ -276,7 +277,7 @@ namespace boost {
             return failed_rangecheck();
         }
 
-        BOOST_CONSTEXPR const_reference front() const
+        const_reference front() const
         {
             return failed_rangecheck();
         }
@@ -286,15 +287,15 @@ namespace boost {
             return failed_rangecheck();
         }
 
-        BOOST_CONSTEXPR const_reference back() const
+        const_reference back() const
         {
             return failed_rangecheck();
         }
 
         // size is constant
-        static BOOST_CONSTEXPR size_type size() { return 0; }
-        static BOOST_CONSTEXPR bool empty() { return true; }
-        static BOOST_CONSTEXPR size_type max_size() { return 0; }
+        static size_type size() { return 0; }
+        static bool empty() { return true; }
+        static size_type max_size() { return 0; }
         enum { static_size = 0 };
 
         void swap (array<T,0>& /*y*/) {
@@ -426,43 +427,8 @@ namespace boost {
     }
 #endif
 
-
-    template<class T, std::size_t N>
-    std::size_t hash_value(const array<T,N>& arr)
-    {
-        return boost::hash_range(arr.begin(), arr.end());
-    }
-
-   template <size_t Idx, typename T, size_t N>
-   T &get(boost::array<T,N> &arr) BOOST_NOEXCEPT {
-       BOOST_STATIC_ASSERT_MSG ( Idx < N, "boost::get<>(boost::array &) index out of range" );
-       return arr[Idx];
-       }
-    
-   template <size_t Idx, typename T, size_t N>
-   const T &get(const boost::array<T,N> &arr) BOOST_NOEXCEPT {
-       BOOST_STATIC_ASSERT_MSG ( Idx < N, "boost::get<>(const boost::array &) index out of range" );
-       return arr[Idx];
-       }
-
 } /* namespace boost */
 
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-//  If we don't have std::array, I'm assuming that we don't have std::get
-namespace std {
-   template <size_t Idx, typename T, size_t N>
-   T &get(boost::array<T,N> &arr) BOOST_NOEXCEPT {
-       BOOST_STATIC_ASSERT_MSG ( Idx < N, "std::get<>(boost::array &) index out of range" );
-       return arr[Idx];
-       }
-    
-   template <size_t Idx, typename T, size_t N>
-   const T &get(const boost::array<T,N> &arr) BOOST_NOEXCEPT {
-       BOOST_STATIC_ASSERT_MSG ( Idx < N, "std::get<>(const boost::array &) index out of range" );
-       return arr[Idx];
-       }
-}
-#endif
 
 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)  
 # pragma warning(pop)  

test/Jamfile.v2

@@ -4,22 +4,12 @@
 
 import testing ;
 
-alias unit_test_framework
-    : # sources
-        /boost//unit_test_framework
-    ;        
-
 test-suite array :
-    [ run array0.cpp unit_test_framework  : : : : array0 ]
+    [ run array0.cpp ]
     [ run array1.cpp ]
     [ run array2.cpp ]
     [ run array3.cpp ]
     [ run array4.cpp ]
     [ run array5.cpp ]
-    [ run array6.cpp unit_test_framework  : : : : array6 ]
-    [ run array7.cpp unit_test_framework  : : : : array7 ]
-#    [ run array_constexpr.cpp unit_test_framework  : : : : array_constexpr ]
-    [ compile-fail array_getfail1.cpp ]
-    [ compile-fail array_getfail2.cpp ]
-    [ run array_hash.cpp unit_test_framework  : : : : array_hash ]
+    [ run array6.cpp ]
     ;

test/array0.cpp

@@ -9,15 +9,18 @@
 #include <iostream>
 #include <boost/array.hpp>
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-
 namespace {
+unsigned int failed_tests = 0;
+
+void    fail_test( const char * reason ) {
+    ++failed_tests;
+    std::cerr << "Test failure " << failed_tests << ": " << reason << std::endl;
+}
 
 template< class T >
 void    BadValue( const T &  )
 {
-    BOOST_CHECK ( false );
+    fail_test( "Unexpected value" );
 }
 
 template< class T >
@@ -33,24 +36,46 @@ void    RunTests()
 
     //  front/back and operator[] must compile, but calling them is undefined
     //  Likewise, all tests below should evaluate to false, avoiding undefined behaviour
-    BOOST_CHECK (       test_case.empty());
-    BOOST_CHECK ( const_test_case.empty());
+    if( !test_case.empty() ) {
+        BadValue( test_case.front() );
+    }
 
-    BOOST_CHECK (       test_case.size() == 0 );
-    BOOST_CHECK ( const_test_case.size() == 0 );
+    if( !const_test_case.empty() ) {
+        BadValue( const_test_case.back() );
+    }
+
+    if( test_case.size() > 0 ) {
+        BadValue( test_case[ 0 ] );
+    }
+
+    if( const_test_case.max_size() > 0 ) {
+        BadValue( const_test_case[ 0 ] );
+    }
 
     //  Assert requirements of TR1 6.2.2.4
-    BOOST_CHECK ( test_case.begin()  == test_case.end());
-    BOOST_CHECK ( test_case.cbegin() == test_case.cend());
-    BOOST_CHECK ( const_test_case.begin() == const_test_case.end());
-    BOOST_CHECK ( const_test_case.cbegin() == const_test_case.cend());
+    if( test_case.begin() != test_case.end() ) {
+        fail_test( "Not an empty range" );
+    }
+    if( test_case.cbegin() != test_case.cend() ) {
+        fail_test( "Not an empty range" );
+    }
+    if( const_test_case.begin() != const_test_case.end() ) {
+        fail_test( "Not an empty range" );
+    }
+    if( const_test_case.cbegin() != const_test_case.cend() ) {
+        fail_test( "Not an empty range" );
+    }
+
+    if( test_case.begin() == const_test_case.begin() ) {
+        fail_test( "iterators for different containers are not distinct" );
+    }
 
-    BOOST_CHECK ( test_case.begin() != const_test_case.begin() );
     if( test_case.data() == const_test_case.data() ) {
     //  Value of data is unspecified in TR1, so no requirement this test pass or fail
     //  However, it must compile!
     }
 
+
     //  Check can safely use all iterator types with std algorithms
     std::for_each( test_case.begin(), test_case.end(), BadValue< T > );
     std::for_each( test_case.rbegin(), test_case.rend(), BadValue< T > );
@@ -62,12 +87,12 @@ void    RunTests()
     //  Check swap is well formed
     std::swap( test_case, test_case );
 
-    //  Check assignment operator and overloads are well formed
+    //  Check assigment operator and overloads are well formed
     test_case   =   const_test_case;
 
     //  Confirm at() throws the std lib defined exception
     try {
-        BadValue( test_case.at( 0 ));
+        BadValue( test_case.at( 0 ) );
     } catch ( const std::out_of_range & ) {
     }
 
@@ -79,11 +104,12 @@ void    RunTests()
 
 }
 
-BOOST_AUTO_TEST_CASE( test_main )
+int main()
 {
     RunTests< bool >();
     RunTests< void * >();
     RunTests< long double >();
     RunTests< std::string >();
+    return failed_tests;
 }
 

test/array6.cpp

@@ -10,31 +10,39 @@
 #include <boost/array.hpp>
 #include <algorithm>
 
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-
 namespace {
-    template< class T >
-    void    RunTests()
-    {
-        typedef boost::array< T, 5 >    test_type;
-        typedef T arr[5];
-        test_type           test_case; //   =   { 1, 1, 2, 3, 5 };
-    
-        arr &aRef = get_c_array ( test_case );
-        BOOST_CHECK ( &*test_case.begin () == &aRef[0] );
-        
-        const arr &caRef = get_c_array ( test_case );
-        typename test_type::const_iterator iter = test_case.begin ();
-        BOOST_CHECK ( &*iter == &caRef[0] );
-    }
+unsigned int failed_tests = 0;
+
+void    fail_test( const char * reason ) {
+    ++failed_tests;
+    std::cerr << "Test failure " << failed_tests << ": " << reason << std::endl;
 }
 
-BOOST_AUTO_TEST_CASE( test_main )
+template< class T >
+void    RunTests()
+{
+    typedef boost::array< T, 5 >    test_type;
+    typedef T arr[5];
+    test_type           test_case; //   =   { 1, 1, 2, 3, 5 };
+    
+    arr &aRef = get_c_array ( test_case );
+    if ( &*test_case.begin () != &aRef[0] )
+        fail_test ( "Array6: Same thing not equal?(1)" );
+        
+    const arr &caRef = get_c_array ( test_case );
+    typename test_type::const_iterator iter = test_case.begin ();
+    if ( &*iter != &caRef[0] )
+        fail_test ( "Array6: Same thing not equal?(2)" );
+}
+
+}
+
+int main()
 {
     RunTests< bool >();
     RunTests< void * >();
     RunTests< long double >();
     RunTests< std::string >();
+    return failed_tests;
 }
 

test/array7.cpp

@@ -1,67 +0,0 @@
-/* tests using std::get on boost:array
- * (C) Copyright Marshall Clow 2012
- * 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 <string>
-#include <iostream>
-#include <boost/array.hpp>
-#include <algorithm>
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-#include <array>
-#endif
-
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-
-namespace {
-
-    #ifndef BOOST_NO_CXX11_HDR_ARRAY
-    template< class T >
-    void    RunStdTests()
-    {
-        typedef boost::array< T, 5 >    test_type;
-        typedef T arr[5];
-        test_type           test_case; //   =   { 1, 1, 2, 3, 5 };
-    
-        T &aRef = std::get<0> ( test_case );
-        BOOST_CHECK ( &*test_case.begin () == &aRef );
-        
-        const T &caRef = std::get<0> ( test_case );
-        BOOST_CHECK ( &*test_case.cbegin () == &caRef );
-    }
-    #endif
-
-    template< class T >
-    void    RunBoostTests()
-    {
-        typedef boost::array< T, 5 >    test_type;
-        typedef T arr[5];
-        test_type           test_case; //   =   { 1, 1, 2, 3, 5 };
-    
-        T &aRef = boost::get<0> ( test_case );
-        BOOST_CHECK ( &*test_case.begin () == &aRef );
-        
-        const T &caRef = boost::get<0> ( test_case );
-        BOOST_CHECK ( &*test_case.cbegin () == &caRef );
-    }
-
-}
-
-BOOST_AUTO_TEST_CASE( test_main )
-{
-    RunBoostTests< bool >();
-    RunBoostTests< void * >();
-    RunBoostTests< long double >();
-    RunBoostTests< std::string >();
-
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-    RunStdTests< bool >();
-    RunStdTests< void * >();
-    RunStdTests< long double >();
-    RunStdTests< std::string >();
-#endif
-}
-

test/array_constexpr.cpp

@@ -1,43 +0,0 @@
-/* tests using constexpr on boost:array
- * (C) Copyright Marshall Clow 2012
- * 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 <string>
-#include <iostream>
-#include <boost/array.hpp>
-#include <algorithm>
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-#include <array>
-#endif
-
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-
-#ifndef BOOST_NO_CXX11_CONSTEXPR
-constexpr boost::array<int, 10> arr  {{ 0,1,2,3,4,5,6,7,8,9 }};
-constexpr std::array<int, 10> arr_std {{ 0,1,2,3,4,5,6,7,8,9 }};
-
-template <typename T>
-void sink ( T t ) {}
-
-template <typename T, size_t N>
-void sink ( boost::array<T,N> &arr ) {}
-
-BOOST_AUTO_TEST_CASE( test_main )
-{
-//    constexpr int two = arr_std.at (2);
-    constexpr int three = arr.at (3);
-    int whatever [ arr.at(4) ];
-    (void)three;
-	(void) whatever;
-}
-
-#else	// no constexpr means no constexpr tests!
-BOOST_AUTO_TEST_CASE( test_main )
-{
-}
-#endif
-

test/array_getfail1.cpp

@@ -1,50 +0,0 @@
-/* tests using std::get on boost:array
- * (C) Copyright Marshall Clow 2012
- * 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/array.hpp>
-#include <boost/static_assert.hpp>
-
-
-#include <string>
-#include <iostream>
-#include <algorithm>
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-#include <array>
-#endif
-
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-
-namespace {
-
-    #ifndef BOOST_NO_CXX11_HDR_ARRAY
-    template< class T >
-    void    RunStdTests()
-    {
-        typedef boost::array< T, 5 >    test_type;
-        typedef T arr[5];
-        test_type           test_case; //   =   { 1, 1, 2, 3, 5 };
-    
-        T &aRef = std::get<5> ( test_case );	// should fail to compile
-        BOOST_CHECK ( &*test_case.begin () == &aRef );
-    }
-    #endif
-
-}
-
-BOOST_AUTO_TEST_CASE( test_main )
-{
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-    RunStdTests< bool >();
-    RunStdTests< void * >();
-    RunStdTests< long double >();
-    RunStdTests< std::string >();
-#else
-	BOOST_STATIC_ASSERT ( false );	// fail on C++03 systems.
-#endif
-}
-

test/array_getfail2.cpp

@@ -1,64 +0,0 @@
-/* tests using std::get on boost:array
- * (C) Copyright Marshall Clow 2012
- * 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 <string>
-#include <iostream>
-#include <boost/array.hpp>
-#include <algorithm>
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-#include <array>
-#endif
-
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-
-namespace {
-
-    #ifndef BOOST_NO_CXX11_HDR_ARRAY
-    template< class T >
-    void    RunStdTests()
-    {
-        typedef boost::array< T, 5 >    test_type;
-        typedef T arr[5];
-        test_type           test_case; //   =   { 1, 1, 2, 3, 5 };
-    
-        T &aRef = std::get<0> ( test_case );
-        BOOST_CHECK ( &*test_case.begin () == &aRef );
-        
-        const T &caRef = std::get<0> ( test_case );
-        BOOST_CHECK ( &*test_case.cbegin () == &caRef );
-    }
-    #endif
-
-    template< class T >
-    void    RunBoostTests()
-    {
-        typedef boost::array< T, 5 >    test_type;
-        typedef T arr[5];
-        test_type           test_case; //   =   { 1, 1, 2, 3, 5 };
-    
-        T &aRef = boost::get<5> ( test_case );
-        BOOST_CHECK ( &*test_case.begin () == &aRef );
-    }
-
-}
-
-BOOST_AUTO_TEST_CASE( test_main )
-{
-    RunBoostTests< bool >();
-    RunBoostTests< void * >();
-    RunBoostTests< long double >();
-    RunBoostTests< std::string >();
-
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-    RunStdTests< bool >();
-    RunStdTests< void * >();
-    RunStdTests< long double >();
-    RunStdTests< std::string >();
-#endif
-}
-

test/array_hash.cpp

@@ -1,43 +0,0 @@
-/* tests for using boost::hash with boost::array
- * (C) Copyright Marshall Clow 2012
- * 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 <string>
-#include <iostream>
-#include <boost/array.hpp>
-#include <algorithm>
-#include <boost/functional/hash.hpp>
-
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-
-namespace {
-
-    template< class T >
-    void    RunTests()
-    {
-    //    std::size_t hash0 = boost::hash<boost::array<T,0> > () ( boost::array<T, 0> ());
-    //    std::size_t hash1 = boost::hash<boost::array<T,1> > () ( boost::array<T, 1> ());
-    
-        typedef boost::array< T, 5 >    barr;
-        typedef T arr[5];
-        barr           test_barr =   {{ 1, 1, 2, 3, 5 }};
-        arr            test_arr  =    { 1, 1, 2, 3, 5 };
-    
-        std::size_t bhash = boost::hash<barr> () ( test_barr );
-        std::size_t ahash = boost::hash<arr>  () ( test_arr );
-        BOOST_CHECK ( ahash == bhash );
-    }
-
-}
-
-BOOST_AUTO_TEST_CASE( test_main )
-{
-    RunTests< int >();
-    RunTests< long >();
-    RunTests< long double >();
-}
-