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

int main()
{
    std::BlockPool recycle;
    std::ScopeAlloc alloc(recycle);
    printf("\n------------------- global: have 3 objs ----------------\n");
    {
        Obj* a1 = STD_NEW(alloc, Obj)(0);
        Obj* a2 = STD_NEW_ARRAY(alloc, Obj, 2);
        printf("------------------- child 1: have 4 objs ----------------\n");
        {
            std::ScopeAlloc child1(alloc);
            Obj* o1 = STD_NEW(child1, Obj)(1);
            Obj* o2 = STD_NEW_ARRAY(child1, Obj, 3);
            printf("------------------- child 11: have 3 objs ----------------\n");
            {
                std::ScopeAlloc* child11 = STD_NEW(child1, std::ScopeAlloc)(child1);
                Obj* o11 = STD_NEW(*child11, Obj)(11);
                Obj* o12 = STD_NEW_ARRAY(*child11, Obj, 2);
            }
            printf("------------------- leave child 11 ----------------\n");
            printf("------------------- child 12: have 3 objs ----------------\n");
            {
                std::ScopeAlloc child12(child1);
                Obj* o11 = STD_NEW(child12, Obj)(12);
                Obj* o12 = STD_NEW_ARRAY(child12, Obj, 2);
            }
            printf("------------------- leave child 12 ----------------\n");
        }
        printf("------------------- leave child 1 ----------------\n");
        printf("------------------- child 2: have 4 objs ----------------\n");
        {
            std::ScopeAlloc child2(alloc);
            Obj* o1 = STD_NEW(child2, Obj)(2);
            Obj* o2 = STD_NEW_ARRAY(child2, Obj, 3);
        }
        printf("------------------- leave child 2 ----------------\n");
    }
    return 0;
}