1/*
2 * Copyright 2013 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#define LOG_TAG "SurfaceTextureGLToGL_test"
18//#define LOG_NDEBUG 0
19
20#include "SurfaceTextureGLToGL.h"
21
22namespace android {
23
24TEST_F(SurfaceTextureGLToGLTest, TransformHintGetsRespected) {
25    const uint32_t texWidth = 32;
26    const uint32_t texHeight = 64;
27
28    mST->setDefaultBufferSize(texWidth, texHeight);
29    mST->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_90);
30
31    // This test requires 3 buffers to avoid deadlock because we're
32    // both producer and consumer, and only using one thread. Set max dequeued
33    // to 2, and max acquired already defaults to 1.
34    ASSERT_EQ(OK, mSTC->setMaxDequeuedBufferCount(2));
35
36    SetUpWindowAndContext();
37
38    // Do the producer side of things
39    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
40            mProducerEglSurface, mProducerEglContext));
41    ASSERT_EQ(EGL_SUCCESS, eglGetError());
42
43    // Start a buffer with our chosen size and transform hint moving
44    // through the system.
45    glClear(GL_COLOR_BUFFER_BIT);  // give the driver something to do
46    eglSwapBuffers(mEglDisplay, mProducerEglSurface);
47    mST->updateTexImage();  // consume it
48    // Swap again.
49    glClear(GL_COLOR_BUFFER_BIT);
50    eglSwapBuffers(mEglDisplay, mProducerEglSurface);
51    mST->updateTexImage();
52
53    // The current buffer should either show the effects of the transform
54    // hint (in the form of an inverse transform), or show that the
55    // transform hint has been ignored.
56    sp<GraphicBuffer> buf = mST->getCurrentBuffer();
57    if (mST->getCurrentTransform() == NATIVE_WINDOW_TRANSFORM_ROT_270) {
58        ASSERT_EQ(texWidth, buf->getHeight());
59        ASSERT_EQ(texHeight, buf->getWidth());
60    } else {
61        ASSERT_EQ(texWidth, buf->getWidth());
62        ASSERT_EQ(texHeight, buf->getHeight());
63    }
64
65    // Reset the transform hint and confirm that it takes.
66    mST->setTransformHint(0);
67    glClear(GL_COLOR_BUFFER_BIT);
68    eglSwapBuffers(mEglDisplay, mProducerEglSurface);
69    mST->updateTexImage();
70    glClear(GL_COLOR_BUFFER_BIT);
71    eglSwapBuffers(mEglDisplay, mProducerEglSurface);
72    mST->updateTexImage();
73
74    buf = mST->getCurrentBuffer();
75    ASSERT_EQ((uint32_t) 0, mST->getCurrentTransform());
76    ASSERT_EQ(texWidth, buf->getWidth());
77    ASSERT_EQ(texHeight, buf->getHeight());
78}
79
80TEST_F(SurfaceTextureGLToGLTest, TexturingFromGLFilledRGBABufferPow2) {
81    const int texWidth = 64;
82    const int texHeight = 64;
83
84    mST->setDefaultBufferSize(texWidth, texHeight);
85
86    // This test requires 3 buffers to complete run on a single thread.
87    // Set max dequeued to 2, and max acquired already defaults to 1.
88    ASSERT_EQ(OK, mSTC->setMaxDequeuedBufferCount(2));
89
90    SetUpWindowAndContext();
91
92    // Do the producer side of things
93    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
94            mProducerEglSurface, mProducerEglContext));
95    ASSERT_EQ(EGL_SUCCESS, eglGetError());
96
97    // This is needed to ensure we pick up a buffer of the correct size.
98    eglSwapBuffers(mEglDisplay, mProducerEglSurface);
99
100    glClearColor(0.6, 0.6, 0.6, 0.6);
101    glClear(GL_COLOR_BUFFER_BIT);
102
103    glEnable(GL_SCISSOR_TEST);
104    glScissor(4, 4, 4, 4);
105    glClearColor(1.0, 0.0, 0.0, 1.0);
106    glClear(GL_COLOR_BUFFER_BIT);
107
108    glScissor(24, 48, 4, 4);
109    glClearColor(0.0, 1.0, 0.0, 1.0);
110    glClear(GL_COLOR_BUFFER_BIT);
111
112    glScissor(37, 17, 4, 4);
113    glClearColor(0.0, 0.0, 1.0, 1.0);
114    glClear(GL_COLOR_BUFFER_BIT);
115
116    eglSwapBuffers(mEglDisplay, mProducerEglSurface);
117
118    // Do the consumer side of things
119    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
120            mEglContext));
121    ASSERT_EQ(EGL_SUCCESS, eglGetError());
122
123    glDisable(GL_SCISSOR_TEST);
124
125    // Skip the first frame, which was empty
126    ASSERT_EQ(NO_ERROR, mST->updateTexImage());
127    ASSERT_EQ(NO_ERROR, mST->updateTexImage());
128
129    glClearColor(0.2, 0.2, 0.2, 0.2);
130    glClear(GL_COLOR_BUFFER_BIT);
131
132    glViewport(0, 0, texWidth, texHeight);
133    drawTexture();
134
135    EXPECT_TRUE(checkPixel( 0,  0, 153, 153, 153, 153));
136    EXPECT_TRUE(checkPixel(63,  0, 153, 153, 153, 153));
137    EXPECT_TRUE(checkPixel(63, 63, 153, 153, 153, 153));
138    EXPECT_TRUE(checkPixel( 0, 63, 153, 153, 153, 153));
139
140    EXPECT_TRUE(checkPixel( 4,  7, 255,   0,   0, 255));
141    EXPECT_TRUE(checkPixel(25, 51,   0, 255,   0, 255));
142    EXPECT_TRUE(checkPixel(40, 19,   0,   0, 255, 255));
143    EXPECT_TRUE(checkPixel(29, 51, 153, 153, 153, 153));
144    EXPECT_TRUE(checkPixel( 5, 32, 153, 153, 153, 153));
145    EXPECT_TRUE(checkPixel(13,  8, 153, 153, 153, 153));
146    EXPECT_TRUE(checkPixel(46,  3, 153, 153, 153, 153));
147    EXPECT_TRUE(checkPixel(30, 33, 153, 153, 153, 153));
148    EXPECT_TRUE(checkPixel( 6, 52, 153, 153, 153, 153));
149    EXPECT_TRUE(checkPixel(55, 33, 153, 153, 153, 153));
150    EXPECT_TRUE(checkPixel(16, 29, 153, 153, 153, 153));
151    EXPECT_TRUE(checkPixel( 1, 30, 153, 153, 153, 153));
152    EXPECT_TRUE(checkPixel(41, 37, 153, 153, 153, 153));
153    EXPECT_TRUE(checkPixel(46, 29, 153, 153, 153, 153));
154    EXPECT_TRUE(checkPixel(15, 25, 153, 153, 153, 153));
155    EXPECT_TRUE(checkPixel( 3, 52, 153, 153, 153, 153));
156}
157
158TEST_F(SurfaceTextureGLToGLTest, EglDestroySurfaceUnrefsBuffers) {
159    SetUpWindowAndContext();
160    sp<GraphicBuffer> buffers[2];
161
162    // This test requires async mode to run on a single thread.
163    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
164            mProducerEglSurface, mProducerEglContext));
165    ASSERT_EQ(EGL_SUCCESS, eglGetError());
166    EXPECT_TRUE(eglSwapInterval(mEglDisplay, 0));
167    ASSERT_EQ(EGL_SUCCESS, eglGetError());
168
169    for (int i = 0; i < 2; i++) {
170        // Produce a frame
171        EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
172                mProducerEglSurface, mProducerEglContext));
173        ASSERT_EQ(EGL_SUCCESS, eglGetError());
174        glClear(GL_COLOR_BUFFER_BIT);
175        eglSwapBuffers(mEglDisplay, mProducerEglSurface);
176
177        // Consume a frame
178        EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
179                mEglContext));
180        ASSERT_EQ(EGL_SUCCESS, eglGetError());
181        mFW->waitForFrame();
182        ASSERT_EQ(NO_ERROR, mST->updateTexImage());
183        buffers[i] = mST->getCurrentBuffer();
184    }
185
186    // Destroy the GL texture object to release its ref on buffers[2].
187    GLuint texID = TEX_ID;
188    glDeleteTextures(1, &texID);
189
190    // Destroy the EGLSurface
191    EXPECT_TRUE(eglDestroySurface(mEglDisplay, mProducerEglSurface));
192    ASSERT_EQ(EGL_SUCCESS, eglGetError());
193    mProducerEglSurface = EGL_NO_SURFACE;
194
195    // This test should have the only reference to buffer 0.
196    EXPECT_EQ(1, buffers[0]->getStrongCount());
197
198    // The GLConsumer should hold one reference to buffer 1 in its
199    // mCurrentTextureImage member and another reference in mEglSlots. The third
200    // reference is in this test.
201    EXPECT_EQ(3, buffers[1]->getStrongCount());
202}
203
204TEST_F(SurfaceTextureGLToGLTest, EglDestroySurfaceAfterAbandonUnrefsBuffers) {
205    SetUpWindowAndContext();
206    sp<GraphicBuffer> buffers[3];
207
208    // This test requires async mode to run on a single thread.
209    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
210            mProducerEglSurface, mProducerEglContext));
211    ASSERT_EQ(EGL_SUCCESS, eglGetError());
212    EXPECT_TRUE(eglSwapInterval(mEglDisplay, 0));
213    ASSERT_EQ(EGL_SUCCESS, eglGetError());
214
215    for (int i = 0; i < 3; i++) {
216        // Produce a frame
217        EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
218                mProducerEglSurface, mProducerEglContext));
219        ASSERT_EQ(EGL_SUCCESS, eglGetError());
220        glClear(GL_COLOR_BUFFER_BIT);
221        EXPECT_TRUE(eglSwapBuffers(mEglDisplay, mProducerEglSurface));
222        ASSERT_EQ(EGL_SUCCESS, eglGetError());
223
224        // Consume a frame
225        EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
226                mEglContext));
227        ASSERT_EQ(EGL_SUCCESS, eglGetError());
228        mFW->waitForFrame();
229        ASSERT_EQ(NO_ERROR, mST->updateTexImage());
230        buffers[i] = mST->getCurrentBuffer();
231    }
232
233    // Abandon the GLConsumer, releasing the ref that the GLConsumer has
234    // on buffers[2].
235    mST->abandon();
236
237    // Destroy the GL texture object to release its ref on buffers[2].
238    GLuint texID = TEX_ID;
239    glDeleteTextures(1, &texID);
240
241    // Destroy the EGLSurface.
242    EXPECT_TRUE(eglDestroySurface(mEglDisplay, mProducerEglSurface));
243    ASSERT_EQ(EGL_SUCCESS, eglGetError());
244    mProducerEglSurface = EGL_NO_SURFACE;
245
246    EXPECT_EQ(1, buffers[1]->getStrongCount());
247
248    // Depending on how lazily the GL driver dequeues buffers, we may end up
249    // with either two or three total buffers.  If there are three, each entry
250    // of the buffers array will be unique and there should only be one
251    // reference (the one in this test). If there are two the first and last
252    // element in the array will be equal meaning that buffer representing both
253    // 0 and 2 will have two references (one for 0 and one for 2).
254    if (buffers[2] != buffers[0]) {
255        EXPECT_EQ(1, buffers[0]->getStrongCount());
256        EXPECT_EQ(1, buffers[2]->getStrongCount());
257    } else {
258        EXPECT_EQ(2, buffers[0]->getStrongCount());
259    }
260}
261
262TEST_F(SurfaceTextureGLToGLTest, EglMakeCurrentBeforeConsumerDeathUnrefsBuffers) {
263    SetUpWindowAndContext();
264    sp<GraphicBuffer> buffer;
265
266    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
267            mProducerEglSurface, mProducerEglContext));
268
269    // Produce a frame
270    glClear(GL_COLOR_BUFFER_BIT);
271    EXPECT_TRUE(eglSwapBuffers(mEglDisplay, mProducerEglSurface));
272    ASSERT_EQ(EGL_SUCCESS, eglGetError());
273
274    // Destroy the EGLSurface.
275    EXPECT_TRUE(eglDestroySurface(mEglDisplay, mProducerEglSurface));
276    ASSERT_EQ(EGL_SUCCESS, eglGetError());
277    mProducerEglSurface = EGL_NO_SURFACE;
278    mSTC.clear();
279    mANW.clear();
280    mTextureRenderer.clear();
281
282    // Consume a frame
283    ASSERT_EQ(NO_ERROR, mST->updateTexImage());
284    buffer = mST->getCurrentBuffer();
285
286    // Destroy the GL texture object to release its ref
287    GLuint texID = TEX_ID;
288    glDeleteTextures(1, &texID);
289
290    // make un-current, all references to buffer should be gone
291    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE,
292            EGL_NO_SURFACE, EGL_NO_CONTEXT));
293
294    // Destroy consumer
295    mST.clear();
296
297    EXPECT_EQ(1, buffer->getStrongCount());
298}
299
300TEST_F(SurfaceTextureGLToGLTest, EglMakeCurrentAfterConsumerDeathUnrefsBuffers) {
301    SetUpWindowAndContext();
302    sp<GraphicBuffer> buffer;
303
304    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
305            mProducerEglSurface, mProducerEglContext));
306
307    // Produce a frame
308    glClear(GL_COLOR_BUFFER_BIT);
309    EXPECT_TRUE(eglSwapBuffers(mEglDisplay, mProducerEglSurface));
310    ASSERT_EQ(EGL_SUCCESS, eglGetError());
311
312    // Destroy the EGLSurface.
313    EXPECT_TRUE(eglDestroySurface(mEglDisplay, mProducerEglSurface));
314    ASSERT_EQ(EGL_SUCCESS, eglGetError());
315    mProducerEglSurface = EGL_NO_SURFACE;
316    mSTC.clear();
317    mANW.clear();
318    mTextureRenderer.clear();
319
320    // Consume a frame
321    ASSERT_EQ(NO_ERROR, mST->updateTexImage());
322    buffer = mST->getCurrentBuffer();
323
324    // Destroy the GL texture object to release its ref
325    GLuint texID = TEX_ID;
326    glDeleteTextures(1, &texID);
327
328    // Destroy consumer
329    mST.clear();
330
331    // make un-current, all references to buffer should be gone
332    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE,
333            EGL_NO_SURFACE, EGL_NO_CONTEXT));
334
335    EXPECT_EQ(1, buffer->getStrongCount());
336}
337
338TEST_F(SurfaceTextureGLToGLTest, TexturingFromUserSizedGLFilledBuffer) {
339    enum { texWidth = 64 };
340    enum { texHeight = 64 };
341
342    // This test requires 3 buffers to complete run on a single thread.
343    // Set max dequeued to 2, and max acquired already defaults to 1.
344    ASSERT_EQ(OK, mSTC->setMaxDequeuedBufferCount(2));
345
346    SetUpWindowAndContext();
347
348    // Set the user buffer size.
349    native_window_set_buffers_user_dimensions(mANW.get(), texWidth, texHeight);
350
351    // Do the producer side of things
352    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
353            mProducerEglSurface, mProducerEglContext));
354    ASSERT_EQ(EGL_SUCCESS, eglGetError());
355
356    // This is needed to ensure we pick up a buffer of the correct size.
357    eglSwapBuffers(mEglDisplay, mProducerEglSurface);
358
359    glClearColor(0.6, 0.6, 0.6, 0.6);
360    glClear(GL_COLOR_BUFFER_BIT);
361
362    glEnable(GL_SCISSOR_TEST);
363    glScissor(4, 4, 1, 1);
364    glClearColor(1.0, 0.0, 0.0, 1.0);
365    glClear(GL_COLOR_BUFFER_BIT);
366
367    eglSwapBuffers(mEglDisplay, mProducerEglSurface);
368
369    // Do the consumer side of things
370    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
371            mEglContext));
372    ASSERT_EQ(EGL_SUCCESS, eglGetError());
373
374    glDisable(GL_SCISSOR_TEST);
375
376    // Skip the first frame, which was empty
377    ASSERT_EQ(NO_ERROR, mST->updateTexImage());
378    ASSERT_EQ(NO_ERROR, mST->updateTexImage());
379
380    glClearColor(0.2, 0.2, 0.2, 0.2);
381    glClear(GL_COLOR_BUFFER_BIT);
382
383    glViewport(0, 0, texWidth, texHeight);
384    drawTexture();
385
386    EXPECT_TRUE(checkPixel( 0,  0, 153, 153, 153, 153));
387    EXPECT_TRUE(checkPixel(63,  0, 153, 153, 153, 153));
388    EXPECT_TRUE(checkPixel(63, 63, 153, 153, 153, 153));
389    EXPECT_TRUE(checkPixel( 0, 63, 153, 153, 153, 153));
390
391    EXPECT_TRUE(checkPixel( 4,  4, 255,   0,   0, 255));
392    EXPECT_TRUE(checkPixel( 5,  5, 153, 153, 153, 153));
393    EXPECT_TRUE(checkPixel( 3,  3, 153, 153, 153, 153));
394    EXPECT_TRUE(checkPixel(45, 52, 153, 153, 153, 153));
395    EXPECT_TRUE(checkPixel(12, 36, 153, 153, 153, 153));
396}
397
398TEST_F(SurfaceTextureGLToGLTest, TexturingFromPreRotatedUserSizedGLFilledBuffer) {
399    enum { texWidth = 64 };
400    enum { texHeight = 16 };
401
402    // This test requires 3 buffers to complete run on a single thread.
403    // Set max dequeued to 2, and max acquired already defaults to 1.
404    ASSERT_EQ(OK, mSTC->setMaxDequeuedBufferCount(2));
405
406    SetUpWindowAndContext();
407
408    // Set the transform hint.
409    mST->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_90);
410
411    // Set the user buffer size.
412    native_window_set_buffers_user_dimensions(mANW.get(), texWidth, texHeight);
413
414    // Do the producer side of things
415    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
416            mProducerEglSurface, mProducerEglContext));
417    ASSERT_EQ(EGL_SUCCESS, eglGetError());
418
419    // This is needed to ensure we pick up a buffer of the correct size and the
420    // new rotation hint.
421    eglSwapBuffers(mEglDisplay, mProducerEglSurface);
422
423    glClearColor(0.6, 0.6, 0.6, 0.6);
424    glClear(GL_COLOR_BUFFER_BIT);
425
426    glEnable(GL_SCISSOR_TEST);
427    glScissor(24, 4, 1, 1);
428    glClearColor(1.0, 0.0, 0.0, 1.0);
429    glClear(GL_COLOR_BUFFER_BIT);
430
431    eglSwapBuffers(mEglDisplay, mProducerEglSurface);
432
433    // Do the consumer side of things
434    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
435            mEglContext));
436    ASSERT_EQ(EGL_SUCCESS, eglGetError());
437
438    glDisable(GL_SCISSOR_TEST);
439
440    // Skip the first frame, which was empty
441    ASSERT_EQ(NO_ERROR, mST->updateTexImage());
442    ASSERT_EQ(NO_ERROR, mST->updateTexImage());
443
444    glClearColor(0.2, 0.2, 0.2, 0.2);
445    glClear(GL_COLOR_BUFFER_BIT);
446
447    glViewport(0, 0, texWidth, texHeight);
448    drawTexture();
449
450    EXPECT_TRUE(checkPixel( 0,  0, 153, 153, 153, 153));
451    EXPECT_TRUE(checkPixel(63,  0, 153, 153, 153, 153));
452    EXPECT_TRUE(checkPixel(63, 15, 153, 153, 153, 153));
453    EXPECT_TRUE(checkPixel( 0, 15, 153, 153, 153, 153));
454
455    EXPECT_TRUE(checkPixel(24,  4, 255,   0,   0, 255));
456    EXPECT_TRUE(checkPixel(25,  5, 153, 153, 153, 153));
457    EXPECT_TRUE(checkPixel(23,  3, 153, 153, 153, 153));
458    EXPECT_TRUE(checkPixel(45, 13, 153, 153, 153, 153));
459    EXPECT_TRUE(checkPixel(12,  8, 153, 153, 153, 153));
460}
461
462TEST_F(SurfaceTextureGLToGLTest, TexturingFromPreRotatedGLFilledBuffer) {
463    enum { texWidth = 64 };
464    enum { texHeight = 16 };
465
466    // This test requires 3 buffers to complete run on a single thread.
467    // Set max dequeued to 2, and max acquired already defaults to 1.
468    ASSERT_EQ(OK, mSTC->setMaxDequeuedBufferCount(2));
469
470    SetUpWindowAndContext();
471
472    // Set the transform hint.
473    mST->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_90);
474
475    // Set the default buffer size.
476    mST->setDefaultBufferSize(texWidth, texHeight);
477
478    // Do the producer side of things
479    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
480            mProducerEglSurface, mProducerEglContext));
481    ASSERT_EQ(EGL_SUCCESS, eglGetError());
482
483    // This is needed to ensure we pick up a buffer of the correct size and the
484    // new rotation hint.
485    eglSwapBuffers(mEglDisplay, mProducerEglSurface);
486
487    glClearColor(0.6, 0.6, 0.6, 0.6);
488    glClear(GL_COLOR_BUFFER_BIT);
489
490    glEnable(GL_SCISSOR_TEST);
491    glScissor(24, 4, 1, 1);
492    glClearColor(1.0, 0.0, 0.0, 1.0);
493    glClear(GL_COLOR_BUFFER_BIT);
494
495    eglSwapBuffers(mEglDisplay, mProducerEglSurface);
496
497    // Do the consumer side of things
498    EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
499            mEglContext));
500    ASSERT_EQ(EGL_SUCCESS, eglGetError());
501
502    glDisable(GL_SCISSOR_TEST);
503
504    // Skip the first frame, which was empty
505    ASSERT_EQ(NO_ERROR, mST->updateTexImage());
506    ASSERT_EQ(NO_ERROR, mST->updateTexImage());
507
508    glClearColor(0.2, 0.2, 0.2, 0.2);
509    glClear(GL_COLOR_BUFFER_BIT);
510
511    glViewport(0, 0, texWidth, texHeight);
512    drawTexture();
513
514    EXPECT_TRUE(checkPixel( 0,  0, 153, 153, 153, 153));
515    EXPECT_TRUE(checkPixel(63,  0, 153, 153, 153, 153));
516    EXPECT_TRUE(checkPixel(63, 15, 153, 153, 153, 153));
517    EXPECT_TRUE(checkPixel( 0, 15, 153, 153, 153, 153));
518
519    EXPECT_TRUE(checkPixel(24,  4, 255,   0,   0, 255));
520    EXPECT_TRUE(checkPixel(25,  5, 153, 153, 153, 153));
521    EXPECT_TRUE(checkPixel(23,  3, 153, 153, 153, 153));
522    EXPECT_TRUE(checkPixel(45, 13, 153, 153, 153, 153));
523    EXPECT_TRUE(checkPixel(12,  8, 153, 153, 153, 153));
524}
525
526} // namespace android
527