ImageCacheTest.cpp File Reference

#include "include/core/SkRefCnt.h"
#include "include/core/SkTypes.h"
#include "include/private/chromium/SkDiscardableMemory.h"
#include "src/core/SkResourceCache.h"
#include "src/lazy/SkDiscardableMemoryPool.h"
#include "tests/Test.h"
#include <cstddef>
#include <cstdint>

Go to the source code of this file.

Functions
static void	test_cache (skiatest::Reporter *reporter, SkResourceCache &cache, bool testPurge)
static void	test_cache_purge_shared_id (skiatest::Reporter *reporter, SkResourceCache &cache)
static SkDiscardableMemory *	pool_factory (size_t bytes)
	DEF_TEST (ImageCache, reporter)
	DEF_TEST (ImageCache_doubleAdd, r)

Variables
static const int	COUNT = 10
static const int	DIM = 256
static SkDiscardableMemoryPool *	gPool

Function Documentation

DEF_TEST() [1/2]

DEF_TEST	(	ImageCache	,
		reporter
	)

Definition at line 120 of file ImageCacheTest.cpp.

                               {
    static const size_t defLimit = DIM * DIM * 4 * COUNT + 1024;    // 1K slop
 
    {
        SkResourceCache cache(defLimit);
        test_cache(reporter, cache, true);
    }
    {
        sk_sp<SkDiscardableMemoryPool> pool(SkDiscardableMemoryPool::Make(defLimit));
        gPool = pool.get();
        SkResourceCache cache(pool_factory);
        test_cache(reporter, cache, true);
    }
    {
        SkResourceCache cache(SkDiscardableMemory::Create);
        test_cache(reporter, cache, false);
    }
    {
        SkResourceCache cache(defLimit);
        test_cache_purge_shared_id(reporter, cache);
    }
}

DEF_TEST() [2/2]

DEF_TEST	(	ImageCache_doubleAdd	,
		r
	)

Definition at line 143 of file ImageCacheTest.cpp.

                                  {
    // Adding the same key twice should be safe.
    SkResourceCache cache(4096);
 
    TestingKey key(1);
 
    cache.add(new TestingRec(key, 2));
    cache.add(new TestingRec(key, 3));
 
    // Lookup can return either value.
    intptr_t value = -1;
    REPORTER_ASSERT(r, cache.find(key, TestingRec::Visitor, &value));
    REPORTER_ASSERT(r, 2 == value || 3 == value);
}

pool_factory()

static SkDiscardableMemory * pool_factory ( size_t  bytes )

static

Definition at line 115 of file ImageCacheTest.cpp.

                                                       {
    SkASSERT(gPool);
    return gPool->create(bytes);
}

test_cache()

static void test_cache ( skiatest::Reporter *  reporter, SkResourceCache &  cache, bool  testPurge  )

static

Definition at line 51 of file ImageCacheTest.cpp.

                                                                                           {
    for (int i = 0; i < COUNT; ++i) {
        TestingKey key(i);
        intptr_t value = -1;
 
        REPORTER_ASSERT(reporter, !cache.find(key, TestingRec::Visitor, &value));
        REPORTER_ASSERT(reporter, -1 == value);
 
        cache.add(new TestingRec(key, i));
 
        REPORTER_ASSERT(reporter, cache.find(key, TestingRec::Visitor, &value));
        REPORTER_ASSERT(reporter, i == value);
    }
 
    if (testPurge) {
        // stress test, should trigger purges
        for (int i = 0; i < COUNT * 100; ++i) {
            TestingKey key(i);
            cache.add(new TestingRec(key, i));
        }
    }
 
    // test the originals after all that purging
    for (int i = 0; i < COUNT; ++i) {
        intptr_t value;
        (void)cache.find(TestingKey(i), TestingRec::Visitor, &value);
    }
 
    cache.setTotalByteLimit(0);
}

test_cache_purge_shared_id()

static void test_cache_purge_shared_id ( skiatest::Reporter *  reporter, SkResourceCache &  cache  )

static

Definition at line 82 of file ImageCacheTest.cpp.

                                                                                           {
    for (int i = 0; i < COUNT; ++i) {
        TestingKey key(i, i & 1);   // every other key will have a 1 for its sharedID
        cache.add(new TestingRec(key, i));
    }
 
    // Ensure that everyone is present
    for (int i = 0; i < COUNT; ++i) {
        TestingKey key(i, i & 1);   // every other key will have a 1 for its sharedID
        intptr_t value = -1;
 
        REPORTER_ASSERT(reporter, cache.find(key, TestingRec::Visitor, &value));
        REPORTER_ASSERT(reporter, value == i);
    }
 
    // Now purge the ones that had a non-zero sharedID (the odd-indexed ones)
    cache.purgeSharedID(1);
 
    // Ensure that only the even ones are still present
    for (int i = 0; i < COUNT; ++i) {
        TestingKey key(i, i & 1);   // every other key will have a 1 for its sharedID
        intptr_t value = -1;
 
        if (i & 1) {
            REPORTER_ASSERT(reporter, !cache.find(key, TestingRec::Visitor, &value));
        } else {
            REPORTER_ASSERT(reporter, cache.find(key, TestingRec::Visitor, &value));
            REPORTER_ASSERT(reporter, value == i);
        }
    }
}

Variable Documentation

COUNT

const int COUNT = 10

static

Definition at line 48 of file ImageCacheTest.cpp.

DIM

const int DIM = 256

static

Definition at line 49 of file ImageCacheTest.cpp.

gPool

SkDiscardableMemoryPool* gPool

static

Definition at line 114 of file ImageCacheTest.cpp.