diff -r 000000000000 -r e4d67989cc36 stdcpp/tsrc/Boost_test/smart_ptr/src/shared_ptr_alloc2_test.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/stdcpp/tsrc/Boost_test/smart_ptr/src/shared_ptr_alloc2_test.cpp	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,248 @@
+#include <boost/config.hpp>
+
+//  shared_ptr_alloc2_test.cpp
+//
+//  Copyright (c) 2005 Peter Dimov
+//
+// 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)
+
+/*
+ * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.
+*/
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/shared_ptr.hpp>
+#include <memory>
+#include <cstddef>
+
+#ifdef __SYMBIAN32__
+#include "std_log_result.h"
+#define LOG_FILENAME_LINE __FILE__, __LINE__
+#endif
+
+// test_allocator
+
+struct test_allocator_base
+{
+    int id_;
+
+    static int last_global_id_;
+    static int count_;
+
+    explicit test_allocator_base( int id ): id_( id )
+    {
+    }
+};
+
+int test_allocator_base::last_global_id_ = 0;
+int test_allocator_base::count_ = 0;
+
+template<class T> class test_allocator: public test_allocator_base
+{
+public:
+
+    typedef T * pointer;
+    typedef T const * const_pointer;
+    typedef T & reference;
+    typedef T const & const_reference;
+    typedef T value_type;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+
+private:
+
+    static T * last_pointer_;
+    static std::size_t last_n_;
+    static int last_id_;
+
+public:
+
+    template<class U> struct rebind
+    {
+        typedef test_allocator<U> other;
+    };
+
+    pointer address( reference r ) const
+    {
+        return &r;
+    }
+
+    const_pointer address( const_reference s ) const
+    {
+        return &s;
+    }
+
+    explicit test_allocator( int id = 0 ): test_allocator_base( id )
+    {
+    }
+
+    template<class U> test_allocator( test_allocator<U> const & r ): test_allocator_base( r )
+    {
+    }
+
+    template<class U> test_allocator & operator=( test_allocator<U> const & r )
+    {
+        test_allocator_base::operator=( r );
+        return *this;
+    }
+
+    void deallocate( pointer p, size_type n )
+    {
+        BOOST_TEST( p == last_pointer_ );
+        BOOST_TEST( n == last_n_ );
+        BOOST_TEST( id_ == last_id_ );
+
+        --count_;
+
+        ::operator delete( p );
+    }
+
+    pointer allocate( size_type n, void const * )
+    {
+        T * p = static_cast< T* >( ::operator new( n * sizeof( T ) ) );
+
+        last_pointer_ = p;
+        last_n_ = n;
+        last_id_ = id_;
+
+        last_global_id_ = id_;
+        ++count_;
+
+        return p;
+    }
+
+    void construct( pointer p, T const & t )
+    {
+        new( p ) T( t );
+    }
+
+    void destroy( pointer p )
+    {
+        p->~T();
+    }
+
+    size_type max_size() const
+    {
+        return size_type( -1 ) / sizeof( T );
+    }
+};
+
+template<class T> T * test_allocator<T>::last_pointer_ = 0;
+template<class T> std::size_t test_allocator<T>::last_n_ = 0;
+template<class T> int test_allocator<T>::last_id_ = 0;
+
+template<class T, class U> inline bool operator==( test_allocator<T> const & a1, test_allocator<U> const & a2 )
+{
+    return a1.id_ == a2.id_;
+}
+
+template<class T, class U> inline bool operator!=( test_allocator<T> const & a1, test_allocator<U> const & a2 )
+{
+    return a1.id_ != a2.id_;
+}
+
+template<> class test_allocator<void>: public test_allocator_base
+{
+public:
+
+    typedef void * pointer;
+    typedef void const * const_pointer;
+    typedef void value_type;
+
+    template<class U> struct rebind
+    {
+        typedef test_allocator<U> other;
+    };
+
+    explicit test_allocator( int id = 0 ): test_allocator_base( id )
+    {
+    }
+
+    template<class U> test_allocator( test_allocator<U> const & r ): test_allocator_base( r )
+    {
+    }
+
+    template<class U> test_allocator & operator=( test_allocator<U> const & r )
+    {
+        test_allocator_base::operator=( r );
+        return *this;
+    }
+};
+
+//
+
+struct X
+{
+    static int instances;
+
+    X()
+    {
+        ++instances;
+    }
+
+    ~X()
+    {
+        --instances;
+    }
+
+private:
+
+    X( X const & );
+    X & operator=( X const & );
+};
+
+int X::instances = 0;
+
+int main()
+{
+	std_log(LOG_FILENAME_LINE,"[Test Case for shared_ptr_alloc2_test]");
+    BOOST_TEST( X::instances == 0 );
+
+    boost::shared_ptr<void> pv( new X, boost::checked_deleter<X>(), std::allocator<X>() );
+
+    BOOST_TEST( X::instances == 1 );
+
+    pv.reset( new X, boost::checked_deleter<X>(), test_allocator<float>( 42 ) );
+
+    BOOST_TEST( X::instances == 1 );
+
+    BOOST_TEST( test_allocator_base::last_global_id_ == 42 );
+    BOOST_TEST( test_allocator_base::count_ > 0 );
+
+    pv.reset();
+
+    BOOST_TEST( X::instances == 0 );
+    BOOST_TEST( test_allocator_base::count_ == 0 );
+
+    pv.reset( new X, boost::checked_deleter<X>(), test_allocator<void>( 43 ) );
+
+    BOOST_TEST( X::instances == 1 );
+    BOOST_TEST( test_allocator_base::last_global_id_ == 43 );
+
+    pv.reset( new X, boost::checked_deleter<X>(), std::allocator<void>() );
+
+    BOOST_TEST( X::instances == 1 );
+
+    pv.reset();
+
+    BOOST_TEST( X::instances == 0 );
+
+#ifdef __SYMBIAN32__
+	int failures = boost::report_errors();
+	if(failures)
+	{
+		std_log(LOG_FILENAME_LINE,"Result : Failed");
+		assert_failed = true;
+	}
+	else
+	{
+		std_log(LOG_FILENAME_LINE,"Result : Passed");
+	}
+	std_log(LOG_FILENAME_LINE,"[End Test Case ]");
+#endif
+	testResultXml("shared_ptr_alloc2_test");
+	close_log_file();
+	return failures;
+}