Method TestMemPool

util/memory/pool_ut.cpp:91–171

private:
    inline void TestMemPool() {
        TCheckedAllocator alloc;

        {
            TMemoryPool pool(123, TMemoryPool::TExpGrow::Instance(), &alloc);

            for (size_t i = 0; i < 1000; ++i) {
                UNIT_ASSERT(pool.Allocate(i));
            }
        }

        alloc.CheckAtEnd();

        {
            TMemoryPool pool(150, TMemoryPool::TExpGrow::Instance(), &alloc);

            pool.Allocate(8);

            size_t memavail = pool.Available();
            size_t memwaste = pool.MemoryWaste();
            size_t memalloc = pool.MemoryAllocated();

            for (size_t i = 0; i < 1000; ++i) {
                void* m = pool.Allocate(i);
                UNIT_ASSERT(m);
                memset(m, 0, i);
            }

            UNIT_ASSERT_VALUES_EQUAL(pool.ClearReturnUsedChunkCount(true), 11);

            UNIT_ASSERT_VALUES_EQUAL(memalloc - 8, pool.MemoryAllocated());
            UNIT_ASSERT_VALUES_EQUAL(memwaste + 8, pool.MemoryWaste());
            UNIT_ASSERT_VALUES_EQUAL(memavail + 8, pool.Available());

            for (size_t i = 0; i < 1000; ++i) {
                void* m = pool.Allocate(i);
                UNIT_ASSERT(m);
                memset(m, 0, i);
            }

            UNIT_ASSERT_VALUES_EQUAL(pool.ClearReturnUsedChunkCount(false), 12);

            UNIT_ASSERT_VALUES_EQUAL(0, pool.MemoryAllocated());
            UNIT_ASSERT_VALUES_EQUAL(0, pool.MemoryWaste());
            UNIT_ASSERT_VALUES_EQUAL(0, pool.Available());
        }

        alloc.CheckAtEnd();

        struct TConstructorTest {
            int ConstructorType;
            TConstructorTest()
                : ConstructorType(1)
            {
            }
            TConstructorTest(int)
                : ConstructorType(2)
            {