template <class LogT>
class TestAprPools : public TestCase
{
    WINX_TEST_SUITE(TestAprPools);
        WINX_TEST(testCompare);
    WINX_TEST_SUITE_END();
 
    enum { N = 40000 };
 
    void doStlDeque(LogT& log)
    {
        typedef std::deque<int> DequeT;
        log.print("===== std::deque =====\n");
        std::PerformanceCounter counter;
        {
            DequeT coll;
            for (int i = 0; i < N; ++i)
                coll.push_back(i);
        }
        counter.trace(log);
    }
 
    void doDeque(LogT& log)
    {
        typedef NS_STDEXT::Deque<int> DequeT;
        log.print("===== Deque (ScopeAlloc) =====\n");
        std::PerformanceCounter counter;
        {
            NS_STDEXT::BlockPool recycle;
            NS_STDEXT::ScopeAlloc alloc(recycle);
            DequeT coll(alloc);
            for (int i = 0; i < N; ++i)
                coll.push_back(i);
        }
        counter.trace(log);
    }
 
    void doShareAllocDeque(LogT& log)
    {
        typedef NS_STDEXT::Deque<int> DequeT;
        NS_STDEXT::BlockPool recycle;
        log.newline();
        for (int i = 0; i < 5; ++i)
        {
            log.print("===== doShareAllocDeque =====\n");
            NS_STDEXT::PerformanceCounter counter;
            {
                NS_STDEXT::ScopeAlloc alloc(recycle);
                DequeT coll(alloc);
                for (int i = 0; i < N; ++i)
                    coll.push_back(i);
            }
            counter.trace(log);
        }
    }
 
    void testCompare(LogT& log)
    {
        for (int i = 0; i < 5; ++i)
        {
            log.newline();
            doStlDeque(log);
            doDeque(log);
        }
        doShareAllocDeque(log);
    }
};