ImageCacheTest.cpp revision e4eb122a61d7c29f1dd979a41d90524fd249db3f 
1/*
2 * Copyright 2013 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "Test.h"
9#include "SkDiscardableMemory.h"
10#include "SkScaledImageCache.h"
11
12static void make_bm(SkBitmap* bm, int w, int h) {
13    bm->setConfig(SkBitmap::kARGB_8888_Config, w, h);
14    bm->allocPixels();
15}
16
17static const int COUNT = 10;
18static const int DIM = 256;
19
20static void test_cache(skiatest::Reporter* reporter, SkScaledImageCache& cache,
21                       bool testPurge) {
22    SkScaledImageCache::ID* id;
23
24    SkBitmap bm[COUNT];
25
26    SkScalar scale = 2;
27    for (int i = 0; i < COUNT; ++i) {
28        SkBitmap tmp;
29
30        make_bm(&bm[i], DIM, DIM);
31        id = cache.findAndLock(bm[i], scale, scale, &tmp);
32        REPORTER_ASSERT(reporter, NULL == id);
33
34        make_bm(&tmp, DIM, DIM);
35        id = cache.addAndLock(bm[i], scale, scale, tmp);
36        REPORTER_ASSERT(reporter, NULL != id);
37
38        SkBitmap tmp2;
39        SkScaledImageCache::ID* id2 = cache.findAndLock(bm[i], scale, scale,
40                                                        &tmp2);
41        REPORTER_ASSERT(reporter, id == id2);
42        REPORTER_ASSERT(reporter, tmp.pixelRef() == tmp2.pixelRef());
43        REPORTER_ASSERT(reporter, tmp.width() == tmp2.width());
44        REPORTER_ASSERT(reporter, tmp.height() == tmp2.height());
45        cache.unlock(id2);
46
47        cache.unlock(id);
48    }
49
50    if (testPurge) {
51        // stress test, should trigger purges
52        for (size_t i = 0; i < COUNT * 100; ++i) {
53            scale += 1;
54
55            SkBitmap tmp;
56
57            make_bm(&tmp, DIM, DIM);
58            id = cache.addAndLock(bm[0], scale, scale, tmp);
59            REPORTER_ASSERT(reporter, NULL != id);
60            cache.unlock(id);
61        }
62    }
63    cache.setByteLimit(0);
64}
65
66static void TestImageCache(skiatest::Reporter* reporter) {
67    {
68        static const size_t defLimit = DIM * DIM * 4 * COUNT + 1024;    // 1K slop
69        SkScaledImageCache cache(defLimit);
70        test_cache(reporter, cache, true);
71    }
72    {
73        SkScaledImageCache cache(SkDiscardableMemory::Create);
74        test_cache(reporter, cache, false);
75    }
76}
77
78#include "TestClassDef.h"
79DEFINE_TESTCLASS("ImageCache", TestImageCacheClass, TestImageCache)
80
81DEF_TEST(ImageCache_doubleAdd, r) {
82    // Adding the same key twice should be safe.
83    SkScaledImageCache cache(1024);
84
85    SkBitmap original;
86    original.setConfig(SkBitmap::kARGB_8888_Config, 40, 40);
87    original.allocPixels();
88
89    SkBitmap scaled;
90    scaled.setConfig(SkBitmap::kARGB_8888_Config, 20, 20);
91    scaled.allocPixels();
92
93    SkScaledImageCache::ID* id1 = cache.addAndLock(original, 0.5f, 0.5f, scaled);
94    SkScaledImageCache::ID* id2 = cache.addAndLock(original, 0.5f, 0.5f, scaled);
95    // We don't really care if id1 == id2 as long as unlocking both works.
96    cache.unlock(id1);
97    cache.unlock(id2);
98}
99