OffscreenBufferPoolTests.cpp revision 64db2bf1118db88c937e2b8c61b299bb2a80e3cb 
1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <gtest/gtest.h>
18#include <Rect.h>
19#include <renderstate/OffscreenBufferPool.h>
20
21#include <tests/common/TestUtils.h>
22
23using namespace android::uirenderer;
24
25TEST(OffscreenBuffer, computeIdealDimension) {
26    EXPECT_EQ(64u, OffscreenBuffer::computeIdealDimension(1));
27    EXPECT_EQ(64u, OffscreenBuffer::computeIdealDimension(31));
28    EXPECT_EQ(64u, OffscreenBuffer::computeIdealDimension(33));
29    EXPECT_EQ(64u, OffscreenBuffer::computeIdealDimension(64));
30    EXPECT_EQ(1024u, OffscreenBuffer::computeIdealDimension(1000));
31}
32
33TEST(OffscreenBuffer, construct) {
34    TestUtils::runOnRenderThread([] (renderthread::RenderThread& thread) {
35        OffscreenBuffer layer(thread.renderState(), Caches::getInstance(), 49u, 149u);
36        EXPECT_EQ(49u, layer.viewportWidth);
37        EXPECT_EQ(149u, layer.viewportHeight);
38
39        EXPECT_EQ(64u, layer.texture.width());
40        EXPECT_EQ(192u, layer.texture.height());
41
42        EXPECT_EQ(64u * 192u * 4u, layer.getSizeInBytes());
43    });
44}
45
46TEST(OffscreenBuffer, getTextureCoordinates) {
47    TestUtils::runOnRenderThread([] (renderthread::RenderThread& thread) {
48        OffscreenBuffer layerAligned(thread.renderState(), Caches::getInstance(), 256u, 256u);
49        EXPECT_EQ(Rect(0, 1, 1, 0),
50                layerAligned.getTextureCoordinates());
51
52        OffscreenBuffer layerUnaligned(thread.renderState(), Caches::getInstance(), 200u, 225u);
53        EXPECT_EQ(Rect(0, 225.0f / 256.0f, 200.0f / 256.0f, 0),
54                layerUnaligned.getTextureCoordinates());
55    });
56}
57
58TEST(OffscreenBuffer, dirty) {
59    TestUtils::runOnRenderThread([] (renderthread::RenderThread& thread) {
60        OffscreenBuffer buffer(thread.renderState(), Caches::getInstance(), 256u, 256u);
61        buffer.dirty(Rect(-100, -100, 100, 100));
62        EXPECT_EQ(android::Rect(100, 100), buffer.region.getBounds());
63    });
64}
65
66TEST(OffscreenBufferPool, construct) {
67    TestUtils::runOnRenderThread([] (renderthread::RenderThread& thread) {
68        OffscreenBufferPool pool;
69        EXPECT_EQ(0u, pool.getCount()) << "pool must be created empty";
70        EXPECT_EQ(0u, pool.getSize()) << "pool must be created empty";
71        EXPECT_EQ((uint32_t) Properties::layerPoolSize, pool.getMaxSize())
72                << "pool must read size from Properties";
73    });
74}
75
76TEST(OffscreenBufferPool, getPutClear) {
77    TestUtils::runOnRenderThread([] (renderthread::RenderThread& thread) {
78        OffscreenBufferPool pool;
79
80        auto layer = pool.get(thread.renderState(), 100u, 200u);
81        EXPECT_EQ(100u, layer->viewportWidth);
82        EXPECT_EQ(200u, layer->viewportHeight);
83
84        ASSERT_LT(layer->getSizeInBytes(), pool.getMaxSize());
85
86        pool.putOrDelete(layer);
87        ASSERT_EQ(layer->getSizeInBytes(), pool.getSize());
88
89        auto layer2 = pool.get(thread.renderState(), 102u, 202u);
90        EXPECT_EQ(layer, layer2) << "layer should be recycled";
91        ASSERT_EQ(0u, pool.getSize()) << "pool should have been emptied by removing only layer";
92
93        pool.putOrDelete(layer);
94        EXPECT_EQ(1u, pool.getCount());
95        pool.clear();
96        EXPECT_EQ(0u, pool.getSize());
97        EXPECT_EQ(0u, pool.getCount());
98    });
99}
100
101TEST(OffscreenBufferPool, resize) {
102    TestUtils::runOnRenderThread([] (renderthread::RenderThread& thread) {
103        OffscreenBufferPool pool;
104
105        auto layer = pool.get(thread.renderState(), 64u, 64u);
106
107        // resize in place
108        ASSERT_EQ(layer, pool.resize(layer, 60u, 55u));
109        EXPECT_EQ(60u, layer->viewportWidth);
110        EXPECT_EQ(55u, layer->viewportHeight);
111        EXPECT_EQ(64u, layer->texture.width());
112        EXPECT_EQ(64u, layer->texture.height());
113
114        // resized to use different object in pool
115        auto layer2 = pool.get(thread.renderState(), 128u, 128u);
116        pool.putOrDelete(layer2);
117        ASSERT_EQ(1u, pool.getCount());
118        ASSERT_EQ(layer2, pool.resize(layer, 120u, 125u));
119        EXPECT_EQ(120u, layer2->viewportWidth);
120        EXPECT_EQ(125u, layer2->viewportHeight);
121        EXPECT_EQ(128u, layer2->texture.width());
122        EXPECT_EQ(128u, layer2->texture.height());
123
124        // original allocation now only thing in pool
125        EXPECT_EQ(1u, pool.getCount());
126        EXPECT_EQ(layer->getSizeInBytes(), pool.getSize());
127
128        pool.putOrDelete(layer2);
129    });
130}
131
132TEST(OffscreenBufferPool, putAndDestroy) {
133    TestUtils::runOnRenderThread([] (renderthread::RenderThread& thread) {
134        OffscreenBufferPool pool;
135        // layer too big to return to the pool
136        // Note: this relies on the fact that the pool won't reject based on max texture size
137        auto hugeLayer = pool.get(thread.renderState(), pool.getMaxSize() / 64, 64);
138        EXPECT_GT(hugeLayer->getSizeInBytes(), pool.getMaxSize());
139        pool.putOrDelete(hugeLayer);
140        EXPECT_EQ(0u, pool.getCount()); // failed to put (so was destroyed instead)
141    });
142}
143