template <class LogT>
class TestCompareAllocators : public TestCase
{
    WINX_TEST_SUITE(TestCompareAllocators);
        WINX_TEST(testComparison1);
    WINX_TEST_SUITE_END();
 
public:
    enum { N = 60000 };
 
    void doNewDelete1(LogT& log)
    {
        log.print("===== NewDelete =====\n");
        PerformanceCounter counter;
        for (int i = 0; i < N; ++i)
        {
            int* p = new int;
            delete p;
        }
        counter.trace(log);
    }
 
    void doAutoFreeAlloc1(LogT& log)
    {
        log.print("===== AutoFreeAlloc =====\n");
        PerformanceCounter counter;
        for (int i = 0; i < N; ++i)
        {
            AutoFreeAlloc alloc;
            int* p = STD_NEW(alloc, int);
        }
        counter.trace(log);
    }
 
    void doScopeAlloc1(LogT& log)
    {
        log.print("===== ScopeAlloc =====\n");
        BlockPool recycle;
        PerformanceCounter counter;
        for (int i = 0; i < N; ++i)
        {
            ScopeAlloc alloc(recycle);
            int* p = STD_NEW(alloc, int);
        }
        counter.trace(log);
    }
 
    void testComparison1(LogT& log)
    {
        for (int i = 0; i < 4; ++i)
        {
            log.newline();
            doAutoFreeAlloc1(log);
            doNewDelete1(log);
            doScopeAlloc1(log);
        }
    }
};

template <class LogT>
class TestCompareAllocators : public TestCase
{
    WINX_TEST_SUITE(TestCompareAllocators);
        WINX_TEST(testComparison2);
    WINX_TEST_SUITE_END();
 
public:
    enum { N = 60000 };
 
    void doNewDelete2(LogT& log)
    {
        int i, *p[N];
        log.print("===== NewDelete =====\n");
        PerformanceCounter counter;
        for (i = 0; i < N; ++i)
        {
            p[i] = new int;
        }
        for (i = 0; i < N; ++i)
        {
            delete p[i];
        }
        counter.trace(log);
    }
 
    void doAutoFreeAlloc2(LogT& log)
    {
        log.print("===== AutoFreeAlloc =====\n");
        PerformanceCounter counter;
        {
            AutoFreeAlloc alloc;
            for (int i = 0; i < N; ++i)
            {
                int* p = STD_NEW(alloc, int);
            }
        }
        counter.trace(log);
    }
 
    void doScopeAlloc2(LogT& log)
    {
        log.print("===== ScopeAlloc =====\n");
        BlockPool recycle;
        PerformanceCounter counter;
        {
            ScopeAlloc alloc(recycle);
            for (int i = 0; i < N; ++i)
            {
                int* p = STD_NEW(alloc, int);
            }
        }
        counter.trace(log);
    }
 
    void testComparison2(LogT& log)
    {
        for (int i = 0; i < 4; ++i)
        {
            log.newline();
            doAutoFreeAlloc2(log);
            doNewDelete2(log);
            doScopeAlloc2(log);
        }
    }
};