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 // Must be included first to prevent errors with "None".
10 #include "test_utils/ANGLETest.h"
11
12 #include <map>
13 #include <vector>
14
15 #include "common/PackedEnums.h"
16 #include "common/angleutils.h"
17 #include "test_utils/gl_raii.h"
18 #include "util/EGLWindow.h"
19
20 using namespace angle;
21
22 constexpr char kEGLExtName[] = "EGL_ANDROID_blob_cache";
23
24 enum class CacheOpResult
25 {
26 SetSuccess,
27 GetNotFound,
28 GetMemoryTooSmall,
29 GetSuccess,
30 ValueNotSet,
31 EnumCount
32 };
33
34 angle::PackedEnumMap<CacheOpResult, std::string> kCacheOpToString = {
35 {CacheOpResult::SetSuccess, "SetSuccess"},
36 {CacheOpResult::GetNotFound, "GetNotFound"},
37 {CacheOpResult::GetMemoryTooSmall, "GetMemoryTooSmall"},
38 {CacheOpResult::GetSuccess, "GetSuccess"},
39 {CacheOpResult::ValueNotSet, "ValueNotSet"},
40 };
41
operator <<(std::ostream & os,CacheOpResult result)42 std::ostream &operator<<(std::ostream &os, CacheOpResult result)
43 {
44 return os << kCacheOpToString[result];
45 }
46
47 namespace
48 {
49 std::map<std::vector<uint8_t>, std::vector<uint8_t>> gApplicationCache;
50 CacheOpResult gLastCacheOpResult = CacheOpResult::ValueNotSet;
51
SetBlob(const void * key,EGLsizeiANDROID keySize,const void * value,EGLsizeiANDROID valueSize)52 void SetBlob(const void *key, EGLsizeiANDROID keySize, const void *value, EGLsizeiANDROID valueSize)
53 {
54 std::vector<uint8_t> keyVec(keySize);
55 memcpy(keyVec.data(), key, keySize);
56
57 std::vector<uint8_t> valueVec(valueSize);
58 memcpy(valueVec.data(), value, valueSize);
59
60 gApplicationCache[keyVec] = valueVec;
61
62 gLastCacheOpResult = CacheOpResult::SetSuccess;
63 }
64
GetBlob(const void * key,EGLsizeiANDROID keySize,void * value,EGLsizeiANDROID valueSize)65 EGLsizeiANDROID GetBlob(const void *key,
66 EGLsizeiANDROID keySize,
67 void *value,
68 EGLsizeiANDROID valueSize)
69 {
70 std::vector<uint8_t> keyVec(keySize);
71 memcpy(keyVec.data(), key, keySize);
72
73 auto entry = gApplicationCache.find(keyVec);
74 if (entry == gApplicationCache.end())
75 {
76 gLastCacheOpResult = CacheOpResult::GetNotFound;
77 return 0;
78 }
79
80 if (entry->second.size() <= static_cast<size_t>(valueSize))
81 {
82 memcpy(value, entry->second.data(), entry->second.size());
83 gLastCacheOpResult = CacheOpResult::GetSuccess;
84 }
85 else
86 {
87 gLastCacheOpResult = CacheOpResult::GetMemoryTooSmall;
88 }
89
90 return entry->second.size();
91 }
92 } // anonymous namespace
93
94 class EGLBlobCacheTest : public ANGLETest
95 {
96 protected:
EGLBlobCacheTest()97 EGLBlobCacheTest() : mHasBlobCache(false)
98 {
99 // Force disply caching off. Blob cache functions require it.
100 forceNewDisplay();
101 }
102
testSetUp()103 void testSetUp() override
104 {
105 EGLDisplay display = getEGLWindow()->getDisplay();
106 mHasBlobCache = IsEGLDisplayExtensionEnabled(display, kEGLExtName);
107 }
108
testTearDown()109 void testTearDown() override { gApplicationCache.clear(); }
110
programBinaryAvailable()111 bool programBinaryAvailable() { return IsGLExtensionEnabled("GL_OES_get_program_binary"); }
112
113 bool mHasBlobCache;
114 };
115
116 // Makes sure the extension exists and works
TEST_P(EGLBlobCacheTest,Functional)117 TEST_P(EGLBlobCacheTest, Functional)
118 {
119 EGLDisplay display = getEGLWindow()->getDisplay();
120
121 EXPECT_TRUE(mHasBlobCache);
122 eglSetBlobCacheFuncsANDROID(display, SetBlob, GetBlob);
123 ASSERT_EGL_SUCCESS();
124
125 constexpr char kVertexShaderSrc[] = R"(attribute vec4 aTest;
126 attribute vec2 aPosition;
127 varying vec4 vTest;
128 void main()
129 {
130 vTest = aTest;
131 gl_Position = vec4(aPosition, 0.0, 1.0);
132 gl_PointSize = 1.0;
133 })";
134
135 constexpr char kFragmentShaderSrc[] = R"(precision mediump float;
136 varying vec4 vTest;
137 void main()
138 {
139 gl_FragColor = vTest;
140 })";
141
142 constexpr char kVertexShaderSrc2[] = R"(attribute vec4 aTest;
143 attribute vec2 aPosition;
144 varying vec4 vTest;
145 void main()
146 {
147 vTest = aTest;
148 gl_Position = vec4(aPosition, 1.0, 1.0);
149 gl_PointSize = 1.0;
150 })";
151
152 constexpr char kFragmentShaderSrc2[] = R"(precision mediump float;
153 varying vec4 vTest;
154 void main()
155 {
156 gl_FragColor = vTest - vec4(0.0, 1.0, 0.0, 0.0);
157 })";
158
159 // Compile a shader so it puts something in the cache
160 if (programBinaryAvailable())
161 {
162 GLuint program = CompileProgram(kVertexShaderSrc, kFragmentShaderSrc);
163 ASSERT_NE(0u, program);
164 EXPECT_EQ(CacheOpResult::SetSuccess, gLastCacheOpResult);
165 gLastCacheOpResult = CacheOpResult::ValueNotSet;
166
167 // Compile the same shader again, so it would try to retrieve it from the cache
168 program = CompileProgram(kVertexShaderSrc, kFragmentShaderSrc);
169 ASSERT_NE(0u, program);
170 EXPECT_EQ(CacheOpResult::GetSuccess, gLastCacheOpResult);
171 gLastCacheOpResult = CacheOpResult::ValueNotSet;
172
173 // Compile another shader, which should create a new entry
174 program = CompileProgram(kVertexShaderSrc2, kFragmentShaderSrc2);
175 ASSERT_NE(0u, program);
176 EXPECT_EQ(CacheOpResult::SetSuccess, gLastCacheOpResult);
177 gLastCacheOpResult = CacheOpResult::ValueNotSet;
178
179 // Compile the first shader again, which should still reside in the cache
180 program = CompileProgram(kVertexShaderSrc, kFragmentShaderSrc);
181 ASSERT_NE(0u, program);
182 EXPECT_EQ(CacheOpResult::GetSuccess, gLastCacheOpResult);
183 gLastCacheOpResult = CacheOpResult::ValueNotSet;
184 }
185 }
186
187 // Tests error conditions of the APIs.
TEST_P(EGLBlobCacheTest,NegativeAPI)188 TEST_P(EGLBlobCacheTest, NegativeAPI)
189 {
190 EXPECT_TRUE(mHasBlobCache);
191
192 // Test bad display
193 eglSetBlobCacheFuncsANDROID(EGL_NO_DISPLAY, nullptr, nullptr);
194 EXPECT_EGL_ERROR(EGL_BAD_DISPLAY);
195
196 eglSetBlobCacheFuncsANDROID(EGL_NO_DISPLAY, SetBlob, GetBlob);
197 EXPECT_EGL_ERROR(EGL_BAD_DISPLAY);
198
199 EGLDisplay display = getEGLWindow()->getDisplay();
200
201 // Test bad arguments
202 eglSetBlobCacheFuncsANDROID(display, nullptr, nullptr);
203 EXPECT_EGL_ERROR(EGL_BAD_PARAMETER);
204
205 eglSetBlobCacheFuncsANDROID(display, SetBlob, nullptr);
206 EXPECT_EGL_ERROR(EGL_BAD_PARAMETER);
207
208 eglSetBlobCacheFuncsANDROID(display, nullptr, GetBlob);
209 EXPECT_EGL_ERROR(EGL_BAD_PARAMETER);
210
211 // Set the arguments once and test setting them again (which should fail)
212 eglSetBlobCacheFuncsANDROID(display, SetBlob, GetBlob);
213 ASSERT_EGL_SUCCESS();
214
215 eglSetBlobCacheFuncsANDROID(display, SetBlob, GetBlob);
216 EXPECT_EGL_ERROR(EGL_BAD_PARAMETER);
217
218 // Try again with bad parameters
219 eglSetBlobCacheFuncsANDROID(EGL_NO_DISPLAY, nullptr, nullptr);
220 EXPECT_EGL_ERROR(EGL_BAD_DISPLAY);
221
222 eglSetBlobCacheFuncsANDROID(display, nullptr, nullptr);
223 EXPECT_EGL_ERROR(EGL_BAD_PARAMETER);
224
225 eglSetBlobCacheFuncsANDROID(display, SetBlob, nullptr);
226 EXPECT_EGL_ERROR(EGL_BAD_PARAMETER);
227
228 eglSetBlobCacheFuncsANDROID(display, nullptr, GetBlob);
229 EXPECT_EGL_ERROR(EGL_BAD_PARAMETER);
230 }
231
232 // Regression test for including the fragment output locatins in the program key.
233 // http://anglebug.com/4535
TEST_P(EGLBlobCacheTest,FragmentOutputLocationKey)234 TEST_P(EGLBlobCacheTest, FragmentOutputLocationKey)
235 {
236 ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_EXT_blend_func_extended") ||
237 getClientMajorVersion() < 3);
238
239 EGLDisplay display = getEGLWindow()->getDisplay();
240
241 EXPECT_TRUE(mHasBlobCache);
242 eglSetBlobCacheFuncsANDROID(display, SetBlob, GetBlob);
243 ASSERT_EGL_SUCCESS();
244
245 // Compile a shader so it puts something in the cache
246 if (programBinaryAvailable())
247 {
248 constexpr char kFragmentShaderSrc[] = R"(#version 300 es
249 #extension GL_EXT_blend_func_extended : require
250 precision mediump float;
251 uniform vec4 src;
252 uniform vec4 src1;
253 out vec4 FragData;
254 out vec4 SecondaryFragData;
255 void main() {
256 FragData = src;
257 SecondaryFragData = src1;
258 })";
259
260 constexpr char kVertexShaderSrc[] = R"(#version 300 es
261 in vec4 position;
262 void main() {
263 gl_Position = position;
264 })";
265
266 GLuint program = CompileProgram(kVertexShaderSrc, kFragmentShaderSrc, [](GLuint p) {
267 glBindFragDataLocationEXT(p, 0, "FragData[0]");
268 glBindFragDataLocationIndexedEXT(p, 0, 1, "SecondaryFragData[0]");
269 });
270 ASSERT_NE(0u, program);
271 EXPECT_EQ(CacheOpResult::SetSuccess, gLastCacheOpResult);
272 gLastCacheOpResult = CacheOpResult::ValueNotSet;
273
274 // Re-link the program with different fragment output bindings
275 program = CompileProgram(kVertexShaderSrc, kFragmentShaderSrc, [](GLuint p) {
276 glBindFragDataLocationEXT(p, 0, "FragData");
277 glBindFragDataLocationIndexedEXT(p, 0, 1, "SecondaryFragData");
278 });
279 ASSERT_NE(0u, program);
280 EXPECT_EQ(CacheOpResult::SetSuccess, gLastCacheOpResult);
281 gLastCacheOpResult = CacheOpResult::ValueNotSet;
282 }
283 }
284
285 ANGLE_INSTANTIATE_TEST_ES2_AND_ES3(EGLBlobCacheTest);
286