1 //
2 // Copyright 2018 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6 // EGLBlobCacheTest:
7 // Unit tests for the EGL_ANDROID_blob_cache extension.
8
9 #include <map>
10 #include <vector>
11
12 #include "common/angleutils.h"
13 #include "test_utils/ANGLETest.h"
14 #include "test_utils/gl_raii.h"
15 #include "util/EGLWindow.h"
16
17 using namespace angle;
18
19 constexpr char kEGLExtName[] = "EGL_ANDROID_blob_cache";
20
21 enum class CacheOpResult
22 {
23 SET_SUCCESS,
24 GET_NOT_FOUND,
25 GET_MEMORY_TOO_SMALL,
26 GET_SUCCESS,
27
28 VALUE_NOT_SET,
29 };
30
31 namespace
32 {
33 std::map<std::vector<uint8_t>, std::vector<uint8_t>> gApplicationCache;
34 CacheOpResult gLastCacheOpResult = CacheOpResult::VALUE_NOT_SET;
35
SetBlob(const void * key,EGLsizeiANDROID keySize,const void * value,EGLsizeiANDROID valueSize)36 void SetBlob(const void *key, EGLsizeiANDROID keySize, const void *value, EGLsizeiANDROID valueSize)
37 {
38 std::vector<uint8_t> keyVec(keySize);
39 memcpy(keyVec.data(), key, keySize);
40
41 std::vector<uint8_t> valueVec(valueSize);
42 memcpy(valueVec.data(), value, valueSize);
43
44 gApplicationCache[keyVec] = valueVec;
45
46 gLastCacheOpResult = CacheOpResult::SET_SUCCESS;
47 }
48
GetBlob(const void * key,EGLsizeiANDROID keySize,void * value,EGLsizeiANDROID valueSize)49 EGLsizeiANDROID GetBlob(const void *key,
50 EGLsizeiANDROID keySize,
51 void *value,
52 EGLsizeiANDROID valueSize)
53 {
54 std::vector<uint8_t> keyVec(keySize);
55 memcpy(keyVec.data(), key, keySize);
56
57 auto entry = gApplicationCache.find(keyVec);
58 if (entry == gApplicationCache.end())
59 {
60 gLastCacheOpResult = CacheOpResult::GET_NOT_FOUND;
61 return 0;
62 }
63
64 if (entry->second.size() <= static_cast<size_t>(valueSize))
65 {
66 memcpy(value, entry->second.data(), entry->second.size());
67 gLastCacheOpResult = CacheOpResult::GET_SUCCESS;
68 }
69 else
70 {
71 gLastCacheOpResult = CacheOpResult::GET_MEMORY_TOO_SMALL;
72 }
73
74 return entry->second.size();
75 }
76 } // anonymous namespace
77
78 class EGLBlobCacheTest : public ANGLETest
79 {
80 protected:
EGLBlobCacheTest()81 EGLBlobCacheTest() : mHasBlobCache(false)
82 {
83 // Force disply caching off. Blob cache functions require it.
84 forceNewDisplay();
85 }
86
testSetUp()87 void testSetUp() override
88 {
89 EGLDisplay display = getEGLWindow()->getDisplay();
90 mHasBlobCache = IsEGLDisplayExtensionEnabled(display, kEGLExtName);
91 }
92
programBinaryAvailable()93 bool programBinaryAvailable()
94 {
95 return (getClientMajorVersion() >= 3 || IsGLExtensionEnabled("GL_OES_get_program_binary"));
96 }
97
98 bool mHasBlobCache;
99 };
100
101 // Makes sure the extension exists and works
TEST_P(EGLBlobCacheTest,Functional)102 TEST_P(EGLBlobCacheTest, Functional)
103 {
104 EGLDisplay display = getEGLWindow()->getDisplay();
105
106 EXPECT_TRUE(mHasBlobCache);
107 eglSetBlobCacheFuncsANDROID(display, SetBlob, GetBlob);
108 ASSERT_EGL_SUCCESS();
109
110 constexpr char kVertexShaderSrc[] = R"(attribute vec4 aTest;
111 attribute vec2 aPosition;
112 varying vec4 vTest;
113 void main()
114 {
115 vTest = aTest;
116 gl_Position = vec4(aPosition, 0.0, 1.0);
117 gl_PointSize = 1.0;
118 })";
119
120 constexpr char kFragmentShaderSrc[] = R"(precision mediump float;
121 varying vec4 vTest;
122 void main()
123 {
124 gl_FragColor = vTest;
125 })";
126
127 constexpr char kVertexShaderSrc2[] = R"(attribute vec4 aTest;
128 attribute vec2 aPosition;
129 varying vec4 vTest;
130 void main()
131 {
132 vTest = aTest;
133 gl_Position = vec4(aPosition, 1.0, 1.0);
134 gl_PointSize = 1.0;
135 })";
136
137 constexpr char kFragmentShaderSrc2[] = R"(precision mediump float;
138 varying vec4 vTest;
139 void main()
140 {
141 gl_FragColor = vTest - vec4(0.0, 1.0, 0.0, 0.0);
142 })";
143
144 // Compile a shader so it puts something in the cache
145 if (programBinaryAvailable())
146 {
147 GLuint program = CompileProgram(kVertexShaderSrc, kFragmentShaderSrc);
148 ASSERT_NE(0u, program);
149 EXPECT_EQ(CacheOpResult::SET_SUCCESS, gLastCacheOpResult);
150 gLastCacheOpResult = CacheOpResult::VALUE_NOT_SET;
151
152 // Compile the same shader again, so it would try to retrieve it from the cache
153 program = CompileProgram(kVertexShaderSrc, kFragmentShaderSrc);
154 ASSERT_NE(0u, program);
155 EXPECT_EQ(CacheOpResult::GET_SUCCESS, gLastCacheOpResult);
156 gLastCacheOpResult = CacheOpResult::VALUE_NOT_SET;
157
158 // Compile another shader, which should create a new entry
159 program = CompileProgram(kVertexShaderSrc2, kFragmentShaderSrc2);
160 ASSERT_NE(0u, program);
161 EXPECT_EQ(CacheOpResult::SET_SUCCESS, gLastCacheOpResult);
162 gLastCacheOpResult = CacheOpResult::VALUE_NOT_SET;
163
164 // Compile the first shader again, which should still reside in the cache
165 program = CompileProgram(kVertexShaderSrc, kFragmentShaderSrc);
166 ASSERT_NE(0u, program);
167 EXPECT_EQ(CacheOpResult::GET_SUCCESS, gLastCacheOpResult);
168 gLastCacheOpResult = CacheOpResult::VALUE_NOT_SET;
169 }
170 }
171
172 // Tests error conditions of the APIs.
TEST_P(EGLBlobCacheTest,NegativeAPI)173 TEST_P(EGLBlobCacheTest, NegativeAPI)
174 {
175 EXPECT_TRUE(mHasBlobCache);
176
177 // Test bad display
178 eglSetBlobCacheFuncsANDROID(EGL_NO_DISPLAY, nullptr, nullptr);
179 EXPECT_EGL_ERROR(EGL_BAD_DISPLAY);
180
181 eglSetBlobCacheFuncsANDROID(EGL_NO_DISPLAY, SetBlob, GetBlob);
182 EXPECT_EGL_ERROR(EGL_BAD_DISPLAY);
183
184 EGLDisplay display = getEGLWindow()->getDisplay();
185
186 // Test bad arguments
187 eglSetBlobCacheFuncsANDROID(display, nullptr, nullptr);
188 EXPECT_EGL_ERROR(EGL_BAD_PARAMETER);
189
190 eglSetBlobCacheFuncsANDROID(display, SetBlob, nullptr);
191 EXPECT_EGL_ERROR(EGL_BAD_PARAMETER);
192
193 eglSetBlobCacheFuncsANDROID(display, nullptr, GetBlob);
194 EXPECT_EGL_ERROR(EGL_BAD_PARAMETER);
195
196 // Set the arguments once and test setting them again (which should fail)
197 eglSetBlobCacheFuncsANDROID(display, SetBlob, GetBlob);
198 ASSERT_EGL_SUCCESS();
199
200 eglSetBlobCacheFuncsANDROID(display, SetBlob, GetBlob);
201 EXPECT_EGL_ERROR(EGL_BAD_PARAMETER);
202
203 // Try again with bad parameters
204 eglSetBlobCacheFuncsANDROID(EGL_NO_DISPLAY, nullptr, nullptr);
205 EXPECT_EGL_ERROR(EGL_BAD_DISPLAY);
206
207 eglSetBlobCacheFuncsANDROID(display, nullptr, nullptr);
208 EXPECT_EGL_ERROR(EGL_BAD_PARAMETER);
209
210 eglSetBlobCacheFuncsANDROID(display, SetBlob, nullptr);
211 EXPECT_EGL_ERROR(EGL_BAD_PARAMETER);
212
213 eglSetBlobCacheFuncsANDROID(display, nullptr, GetBlob);
214 EXPECT_EGL_ERROR(EGL_BAD_PARAMETER);
215 }
216
217 ANGLE_INSTANTIATE_TEST(EGLBlobCacheTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL(), ES2_VULKAN());
218