CachedDataTest.cpp File Reference

#include "include/core/SkRefCnt.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkMalloc.h"
#include "src/core/SkCachedData.h"
#include "src/lazy/SkDiscardableMemoryPool.h"
#include "tests/Test.h"
#include <cstring>

Go to the source code of this file.

Enumerations
enum	LockedState {   kUnlocked , kLocked , kUnlocked , kLocked ,   kNotLocked , kLocked , kUnlocked , kLocked }
enum	CachedState {   kNotInCache , kInCache , kNotInCache , kInCache ,   kNotInCache , kInCache , kNotInCache , kInCache }

Functions
static void	check_data (skiatest::Reporter *reporter, SkCachedData *data, int refcnt, CachedState cacheState, LockedState lockedState)
static SkCachedData *	make_data (size_t size, SkDiscardableMemoryPool *pool)
static SkCachedData *	test_locking (skiatest::Reporter *reporter, size_t size, SkDiscardableMemoryPool *pool)
	DEF_TEST (CachedData, reporter)

Enumeration Type Documentation

CachedState

enum CachedState

Enumerator
kNotInCache
kInCache
kNotInCache
kInCache
kNotInCache
kInCache
kNotInCache
kInCache

Definition at line 24 of file CachedDataTest.cpp.

                 {
    kNotInCache,
    kInCache,
};

LockedState

enum LockedState

Enumerator
kUnlocked
kLocked
kUnlocked
kLocked
kNotLocked
kLocked
kUnlocked
kLocked

Definition at line 19 of file CachedDataTest.cpp.

                 {
    kUnlocked,
    kLocked,
};

Function Documentation

check_data()

static void check_data ( skiatest::Reporter *  reporter, SkCachedData *  data, int  refcnt, CachedState  cacheState, LockedState  lockedState  )

static

Definition at line 29 of file CachedDataTest.cpp.

                                                                                    {
    REPORTER_ASSERT(reporter, data->testing_only_getRefCnt() == refcnt);
    REPORTER_ASSERT(reporter, data->testing_only_isInCache() == (kInCache == cacheState));
    REPORTER_ASSERT(reporter, data->testing_only_isLocked() == (lockedState == kLocked));
}

DEF_TEST()

DEF_TEST	(	CachedData	,
		reporter
	)

Definition at line 81 of file CachedDataTest.cpp.

                               {
    sk_sp<SkDiscardableMemoryPool> pool(SkDiscardableMemoryPool::Make(1000));
 
    for (int useDiscardable = 0; useDiscardable <= 1; ++useDiscardable) {
        const size_t size = 100;
 
        // test with client as last owner
        SkCachedData* data = test_locking(reporter, size, useDiscardable ? pool.get() : nullptr);
        check_data(reporter, data, 2, kInCache, kLocked);
        data->detachFromCacheAndUnref();
        check_data(reporter, data, 1, kNotInCache, kLocked);
        data->unref();
 
        // test with cache as last owner
        data = test_locking(reporter, size, useDiscardable ? pool.get() : nullptr);
        check_data(reporter, data, 2, kInCache, kLocked);
        data->unref();
        check_data(reporter, data, 1, kInCache, kUnlocked);
        data->detachFromCacheAndUnref();
    }
}

make_data()

static SkCachedData * make_data ( size_t  size, SkDiscardableMemoryPool *  pool  )

static

Definition at line 36 of file CachedDataTest.cpp.

                                                                           {
    if (pool) {
        SkDiscardableMemory* dm = pool->create(size);
        // the pool "can" return null, but it shouldn't in these controlled conditions
        SkASSERT_RELEASE(dm);
        return new SkCachedData(size, dm);
    } else {
        return new SkCachedData(sk_malloc_throw(size), size);
    }
}

test_locking()

static SkCachedData * test_locking ( skiatest::Reporter *  reporter, size_t  size, SkDiscardableMemoryPool *  pool  )

static

Definition at line 48 of file CachedDataTest.cpp.

                                                                              {
    SkCachedData* data = make_data(size, pool);
 
    memset(data->writable_data(), 0x80, size);  // just to use writable_data()
 
    check_data(reporter, data, 1, kNotInCache, kLocked);
 
    data->ref();
    check_data(reporter, data, 2, kNotInCache, kLocked);
    data->unref();
    check_data(reporter, data, 1, kNotInCache, kLocked);
 
    data->attachToCacheAndRef();
    check_data(reporter, data, 2, kInCache, kLocked);
 
    data->unref();
    check_data(reporter, data, 1, kInCache, kUnlocked);
 
    data->ref();
    check_data(reporter, data, 2, kInCache, kLocked);
 
    return data;
}