tests/tests/graphics/src/android/graphics/cts/EGL15Test.java - platform/cts - Git at Google

 /*
  * Copyright 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package android.graphics.cts;

 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.anyOf;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
 import static org.hamcrest.Matchers.lessThan;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;

 import android.hardware.SyncFence;
 import android.opengl.EGL14;
 import android.opengl.EGL15;
 import android.opengl.EGLConfig;
 import android.opengl.EGLContext;
 import android.opengl.EGLDisplay;
 import android.opengl.EGLExt;
 import android.opengl.EGLImage;
 import android.opengl.EGLSurface;
 import android.opengl.EGLSync;
 import android.opengl.GLES20;
 import android.os.SystemProperties;

 import androidx.test.filters.SmallTest;

 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.BlockJUnit4ClassRunner;

 @SmallTest
 @RunWith(BlockJUnit4ClassRunner.class)
 public class EGL15Test {

     static {
         System.loadLibrary("ctsgraphics_jni");
     }

     private static final String TAG = EGL15Test.class.getSimpleName();
     private static final boolean DEBUG = false;

     private EGLDisplay mEglDisplay = EGL15.EGL_NO_DISPLAY;
     private EGLConfig mEglConfig = null;
     private EGLSurface mEglPbuffer = EGL15.EGL_NO_SURFACE;
     private EGLContext mEglContext = EGL15.EGL_NO_CONTEXT;
     private int mEglVersion = 0;

     @Before
     public void setup() throws Throwable {
         int error;

         mEglDisplay = EGL15.eglGetPlatformDisplay(EGL15.EGL_PLATFORM_ANDROID_KHR,
                 EGL14.EGL_DEFAULT_DISPLAY,
                 new long[] {
                     EGL14.EGL_NONE },
                 0);
         if (mEglDisplay == EGL15.EGL_NO_DISPLAY) {
             throw new RuntimeException("no EGL display");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglGetPlatformDisplay failed");
         }

         int[] major = new int[1];
         int[] minor = new int[1];
         if (!EGL14.eglInitialize(mEglDisplay, major, 0, minor, 0)) {
             throw new RuntimeException("error in eglInitialize");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglInitialize failed");
         }
         mEglVersion = major[0] * 10 + minor[0];

         // If we could rely on having EGL_KHR_surfaceless_context and EGL_KHR_context_no_config, we
         // wouldn't have to create a config or pbuffer at all.

         int[] numConfigs = new int[1];
         EGLConfig[] configs = new EGLConfig[1];
         if (!EGL14.eglChooseConfig(mEglDisplay,
                 new int[] {
                     EGL14.EGL_RENDERABLE_TYPE, EGL14.EGL_OPENGL_ES2_BIT,
                     EGL14.EGL_SURFACE_TYPE, EGL14.EGL_PBUFFER_BIT,
                     EGL14.EGL_NONE},
                 0, configs, 0, 1, numConfigs, 0)) {
             throw new RuntimeException("eglChooseConfig failed");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglChooseConfig failed");
         }

         mEglConfig = configs[0];

         mEglPbuffer = EGL14.eglCreatePbufferSurface(mEglDisplay, mEglConfig,
                 new int[] {EGL14.EGL_WIDTH, 1, EGL14.EGL_HEIGHT, 1, EGL14.EGL_NONE}, 0);
         if (mEglPbuffer == EGL15.EGL_NO_SURFACE) {
             throw new RuntimeException("eglCreatePbufferSurface failed");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglCreatePbufferSurface failed");
         }


         mEglContext = EGL14.eglCreateContext(mEglDisplay, mEglConfig, EGL14.EGL_NO_CONTEXT,
                 new int[] {EGL14.EGL_CONTEXT_CLIENT_VERSION, 2, EGL14.EGL_NONE}, 0);
         if (mEglContext == EGL15.EGL_NO_CONTEXT) {
             throw new RuntimeException("eglCreateContext failed");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglCreateContext failed");
         }


         if (!EGL14.eglMakeCurrent(mEglDisplay, mEglPbuffer, mEglPbuffer, mEglContext)) {
             throw new RuntimeException("eglMakeCurrent failed");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglMakeCurrent failed");
         }
     }

     @After
     public void teardown() throws Throwable {
         EGL14.eglTerminate(mEglDisplay);
     }

     @Test
     public void testEGL15SyncFence() {
         if (mEglVersion < 15) {
             return;
         }
         EGLSync sync = EGL15.eglCreateSync(mEglDisplay, EGL15.EGL_SYNC_FENCE,
                 new long[] {
                     EGL14.EGL_NONE },
                 0);
         if (sync == EGL15.EGL_NO_SYNC) {
             throw new RuntimeException("eglCreateSync failed");
         }
         int error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglCreateSync failed");
         }

         GLES20.glFlush();
         error = GLES20.glGetError();
         if (error != GLES20.GL_NO_ERROR) {
             throw new RuntimeException("glFlush failed");
         }

         int status = EGL15.eglClientWaitSync(mEglDisplay, sync, 0, EGL15.EGL_FOREVER);
         if (status != EGL15.EGL_CONDITION_SATISFIED) {
             throw new RuntimeException("eglClientWaitSync failed");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglClientWaitSync failed");
         }

         if (!EGL15.eglDestroySync(mEglDisplay, sync)) {
             throw new RuntimeException("eglDestroySync failed");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglDestroySync failed");
         }
     }

     @Test
     public void testEGL15AndroidNativeFence() {
         if (mEglVersion < 15) {
             return;
         }
         String eglExtensions = EGL14.eglQueryString(mEglDisplay, EGL14.EGL_EXTENSIONS);
         if (!eglExtensions.contains("EGL_ANDROID_native_fence_sync")) {
             return;
         }
         long before = System.nanoTime();
         EGLSync sync = EGL15.eglCreateSync(mEglDisplay, EGLExt.EGL_SYNC_NATIVE_FENCE_ANDROID,
                 new long[] {
                         EGL14.EGL_NONE },
                 0);
         assertNotEquals(sync, EGL15.EGL_NO_SYNC);
         assertEquals(EGL14.EGL_SUCCESS, EGL14.eglGetError());

         SyncFence nativeFence = EGLExt.eglDupNativeFenceFDANDROID(mEglDisplay, sync);
         assertNotNull(nativeFence);
         assertEquals(EGL14.EGL_SUCCESS, EGL14.eglGetError());
         // If the fence isn't valid, trigger a flush & try again
         if (!nativeFence.isValid()) {
             GLES20.glFlush();
             assertEquals(GLES20.GL_NO_ERROR, GLES20.glGetError());

             // Have flushed, native fence should be populated
             nativeFence = EGLExt.eglDupNativeFenceFDANDROID(mEglDisplay, sync);
             assertNotNull(nativeFence);
             assertTrue(nativeFence.isValid());
             assertEquals(EGL14.EGL_SUCCESS, EGL14.eglGetError());
         }

         long signaledTime = nativeFence.getSignalTime();
         // We don't know if the fence has or hasn't signaled yet. But either way it must be
         // greater than before the fence was created (either signaled, or PENDING which is LONG_MAX)
         assertThat("getSignalTime before waiting", signaledTime, greaterThan(before));
         // Similarly, if the fence has signaled it must be less than now
         assertThat("getSignalTime before waiting", signaledTime,
                 anyOf(equalTo(SyncFence.SIGNAL_TIME_PENDING), lessThan(System.nanoTime())));

         assertTrue(EGL15.eglDestroySync(mEglDisplay, sync));
         assertEquals(EGL14.EGL_SUCCESS, EGL14.eglGetError());

         assertTrue(nativeFence.awaitForever());
         signaledTime = nativeFence.getSignalTime();
         assertNotEquals(SyncFence.SIGNAL_TIME_INVALID, signaledTime);
         assertThat("getSignalTime after waiting", signaledTime, greaterThan(before));

         nativeFence.close();
         assertFalse(nativeFence.isValid());
         assertEquals(SyncFence.SIGNAL_TIME_INVALID, nativeFence.getSignalTime());
     }

     @Test
     public void testEGL15GetSyncType() {
         if (mEglVersion < 15) {
             return;
         }
         EGLSync sync = EGL15.eglCreateSync(mEglDisplay, EGL15.EGL_SYNC_FENCE,
                 new long[] {
                     EGL14.EGL_NONE },
                 0);
         if (sync == EGL15.EGL_NO_SYNC) {
             throw new RuntimeException("eglCreateSync failed");
         }
         int error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglCreateSync failed");
         }

         long[] type = new long[1];
         boolean success = EGL15.eglGetSyncAttrib(mEglDisplay, sync, EGL15.EGL_SYNC_TYPE, type, 0);
         if (!success) {
             throw new RuntimeException("eglGetSyncAttrib failed (returned false)");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglGetSyncAttrib failed");
         }
         assertEquals(type[0], EGL15.EGL_SYNC_FENCE);

         if (!EGL15.eglDestroySync(mEglDisplay, sync)) {
             throw new RuntimeException("eglDestroySync failed");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglDestroySync failed");
         }
     }

     @Test
     public void testEGL15WaitSync() {
         if (mEglVersion < 15) {
             return;
         }
         EGLSync sync = EGL15.eglCreateSync(mEglDisplay, EGL15.EGL_SYNC_FENCE,
                 new long[] {
                     EGL14.EGL_NONE },
                 0);
         if (sync == EGL15.EGL_NO_SYNC) {
             throw new RuntimeException("eglCreateSync failed");
         }
         int error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglCreateSync failed");
         }

         boolean success = EGL15.eglWaitSync(mEglDisplay, sync, 0);
         if (!success) {
             throw new RuntimeException("eglWaitSync failed (returned false)");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglWaitSync failed");
         }

         if (!EGL15.eglDestroySync(mEglDisplay, sync)) {
             throw new RuntimeException("eglDestroySync failed");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglDestroySync failed");
         }
     }

     @Test
     public void testEGL15CreateImage() {
         if (mEglVersion < 15) {
             return;
         }

         int error;
         int srcTex = 1;
         GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, srcTex);
         error = GLES20.glGetError();
         if (error != GLES20.GL_NO_ERROR) {
             throw new RuntimeException("glBindTexture failed");
         }

         GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, 64, 64, 0,
                             GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);
         error = GLES20.glGetError();
         if (error != GLES20.GL_NO_ERROR) {
             throw new RuntimeException("glTexImage2D failed");
         }

         GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER,
                                GLES20.GL_LINEAR);
         error = GLES20.glGetError();
         if (error != GLES20.GL_NO_ERROR) {
             throw new RuntimeException("glTexParameteri failed");
         }

         long[] attribs = new long[] {
                 EGL15.EGL_GL_TEXTURE_LEVEL, 0,
                 EGL14.EGL_NONE };
         EGLImage image = EGL15.eglCreateImage(mEglDisplay, mEglContext,
                 EGL15.EGL_GL_TEXTURE_2D, srcTex, attribs, 0);
         if (image == EGL15.EGL_NO_IMAGE) {
             throw new RuntimeException("eglCreateImage failed, got EGL_NO_IMAGE");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglCreateImage failed");
         }

         boolean success = EGL15.eglDestroyImage(mEglDisplay, image);
         if (!success) {
             throw new RuntimeException("eglDestroyImage failed (returned false)");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglDestroyImage failed");
         }
     }

     @Test
     public void testEGL15CreatePlatformPixmap() {
         if (mEglVersion < 15) {
             return;
         }

         long[] attribs = new long[] { EGL14.EGL_NONE };
         boolean unsupported = false;
         try {
             EGLSurface surface = EGL15.eglCreatePlatformPixmapSurface(mEglDisplay,
                     mEglConfig, null, attribs, 0);
         } catch (UnsupportedOperationException e) {
             unsupported = true;
         }
         if (!unsupported) {
             throw new RuntimeException("eglCreatePlatformPixmapSurface is not supported on Android,"
                     + " why did call not report that!");
         }
     }

     @Test
     public void testEGL15CreateDebugContext() {
         int error;

         if (mEglVersion < 15) {
             return;
         }

         // Required functionality for devices released with Android R (11),
         // skip if launched with older version of Android.
         if (SystemProperties.getInt("ro.product.first_api_level", 0) < 30) {
             return;
         }

         mEglContext = EGL14.eglCreateContext(mEglDisplay, mEglConfig, EGL14.EGL_NO_CONTEXT,
                 new int[] { EGL15.EGL_CONTEXT_OPENGL_DEBUG, EGL14.EGL_FALSE, EGL14.EGL_NONE }, 0);
         if (mEglContext == EGL15.EGL_NO_CONTEXT) {
             throw new RuntimeException("eglCreateContext failed");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglCreateContext failed");
         }
         EGL14.eglDestroyContext(mEglDisplay, mEglContext);

         mEglContext = EGL14.eglCreateContext(mEglDisplay, mEglConfig, EGL14.EGL_NO_CONTEXT,
                 new int[] { EGL15.EGL_CONTEXT_OPENGL_DEBUG, EGL14.EGL_TRUE, EGL14.EGL_NONE }, 0);
         if (mEglContext == EGL15.EGL_NO_CONTEXT) {
             throw new RuntimeException("eglCreateContext failed");
         }
         error = EGL14.eglGetError();
         if (error != EGL14.EGL_SUCCESS) {
             throw new RuntimeException("eglCreateContext failed");
         }
         EGL14.eglDestroyContext(mEglDisplay, mEglContext);
     }
 }

 // Note: Need to add tests for eglCreatePlatformWindowSurface
	/*
	* Copyright 2017 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package android.graphics.cts;

	import static org.hamcrest.MatcherAssert.assertThat;
	import static org.hamcrest.Matchers.anyOf;
	import static org.hamcrest.Matchers.equalTo;
	import static org.hamcrest.Matchers.greaterThan;
	import static org.hamcrest.Matchers.lessThan;
	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertFalse;
	import static org.junit.Assert.assertNotEquals;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.assertTrue;

	import android.hardware.SyncFence;
	import android.opengl.EGL14;
	import android.opengl.EGL15;
	import android.opengl.EGLConfig;
	import android.opengl.EGLContext;
	import android.opengl.EGLDisplay;
	import android.opengl.EGLExt;
	import android.opengl.EGLImage;
	import android.opengl.EGLSurface;
	import android.opengl.EGLSync;
	import android.opengl.GLES20;
	import android.os.SystemProperties;

	import androidx.test.filters.SmallTest;

	import org.junit.After;
	import org.junit.Before;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.junit.runners.BlockJUnit4ClassRunner;

	@SmallTest
	@RunWith(BlockJUnit4ClassRunner.class)
	public class EGL15Test {

	static {
	System.loadLibrary("ctsgraphics_jni");
	}

	private static final String TAG = EGL15Test.class.getSimpleName();
	private static final boolean DEBUG = false;

	private EGLDisplay mEglDisplay = EGL15.EGL_NO_DISPLAY;
	private EGLConfig mEglConfig = null;
	private EGLSurface mEglPbuffer = EGL15.EGL_NO_SURFACE;
	private EGLContext mEglContext = EGL15.EGL_NO_CONTEXT;
	private int mEglVersion = 0;

	@Before
	public void setup() throws Throwable {
	int error;

	mEglDisplay = EGL15.eglGetPlatformDisplay(EGL15.EGL_PLATFORM_ANDROID_KHR,
	EGL14.EGL_DEFAULT_DISPLAY,
	new long[] {
	EGL14.EGL_NONE },
	0);
	if (mEglDisplay == EGL15.EGL_NO_DISPLAY) {
	throw new RuntimeException("no EGL display");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglGetPlatformDisplay failed");
	}

	int[] major = new int[1];
	int[] minor = new int[1];
	if (!EGL14.eglInitialize(mEglDisplay, major, 0, minor, 0)) {
	throw new RuntimeException("error in eglInitialize");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglInitialize failed");
	}
	mEglVersion = major[0] * 10 + minor[0];

	// If we could rely on having EGL_KHR_surfaceless_context and EGL_KHR_context_no_config, we
	// wouldn't have to create a config or pbuffer at all.

	int[] numConfigs = new int[1];
	EGLConfig[] configs = new EGLConfig[1];
	if (!EGL14.eglChooseConfig(mEglDisplay,
	new int[] {
	EGL14.EGL_RENDERABLE_TYPE, EGL14.EGL_OPENGL_ES2_BIT,
	EGL14.EGL_SURFACE_TYPE, EGL14.EGL_PBUFFER_BIT,
	EGL14.EGL_NONE},
	0, configs, 0, 1, numConfigs, 0)) {
	throw new RuntimeException("eglChooseConfig failed");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglChooseConfig failed");
	}

	mEglConfig = configs[0];

	mEglPbuffer = EGL14.eglCreatePbufferSurface(mEglDisplay, mEglConfig,
	new int[] {EGL14.EGL_WIDTH, 1, EGL14.EGL_HEIGHT, 1, EGL14.EGL_NONE}, 0);
	if (mEglPbuffer == EGL15.EGL_NO_SURFACE) {
	throw new RuntimeException("eglCreatePbufferSurface failed");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglCreatePbufferSurface failed");
	}


	mEglContext = EGL14.eglCreateContext(mEglDisplay, mEglConfig, EGL14.EGL_NO_CONTEXT,
	new int[] {EGL14.EGL_CONTEXT_CLIENT_VERSION, 2, EGL14.EGL_NONE}, 0);
	if (mEglContext == EGL15.EGL_NO_CONTEXT) {
	throw new RuntimeException("eglCreateContext failed");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglCreateContext failed");
	}


	if (!EGL14.eglMakeCurrent(mEglDisplay, mEglPbuffer, mEglPbuffer, mEglContext)) {
	throw new RuntimeException("eglMakeCurrent failed");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglMakeCurrent failed");
	}
	}

	@After
	public void teardown() throws Throwable {
	EGL14.eglTerminate(mEglDisplay);
	}

	@Test
	public void testEGL15SyncFence() {
	if (mEglVersion < 15) {
	return;
	}
	EGLSync sync = EGL15.eglCreateSync(mEglDisplay, EGL15.EGL_SYNC_FENCE,
	new long[] {
	EGL14.EGL_NONE },
	0);
	if (sync == EGL15.EGL_NO_SYNC) {
	throw new RuntimeException("eglCreateSync failed");
	}
	int error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglCreateSync failed");
	}

	GLES20.glFlush();
	error = GLES20.glGetError();
	if (error != GLES20.GL_NO_ERROR) {
	throw new RuntimeException("glFlush failed");
	}

	int status = EGL15.eglClientWaitSync(mEglDisplay, sync, 0, EGL15.EGL_FOREVER);
	if (status != EGL15.EGL_CONDITION_SATISFIED) {
	throw new RuntimeException("eglClientWaitSync failed");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglClientWaitSync failed");
	}

	if (!EGL15.eglDestroySync(mEglDisplay, sync)) {
	throw new RuntimeException("eglDestroySync failed");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglDestroySync failed");
	}
	}

	@Test
	public void testEGL15AndroidNativeFence() {
	if (mEglVersion < 15) {
	return;
	}
	String eglExtensions = EGL14.eglQueryString(mEglDisplay, EGL14.EGL_EXTENSIONS);
	if (!eglExtensions.contains("EGL_ANDROID_native_fence_sync")) {
	return;
	}
	long before = System.nanoTime();
	EGLSync sync = EGL15.eglCreateSync(mEglDisplay, EGLExt.EGL_SYNC_NATIVE_FENCE_ANDROID,
	new long[] {
	EGL14.EGL_NONE },
	0);
	assertNotEquals(sync, EGL15.EGL_NO_SYNC);
	assertEquals(EGL14.EGL_SUCCESS, EGL14.eglGetError());

	SyncFence nativeFence = EGLExt.eglDupNativeFenceFDANDROID(mEglDisplay, sync);
	assertNotNull(nativeFence);
	assertEquals(EGL14.EGL_SUCCESS, EGL14.eglGetError());
	// If the fence isn't valid, trigger a flush & try again
	if (!nativeFence.isValid()) {
	GLES20.glFlush();
	assertEquals(GLES20.GL_NO_ERROR, GLES20.glGetError());

	// Have flushed, native fence should be populated
	nativeFence = EGLExt.eglDupNativeFenceFDANDROID(mEglDisplay, sync);
	assertNotNull(nativeFence);
	assertTrue(nativeFence.isValid());
	assertEquals(EGL14.EGL_SUCCESS, EGL14.eglGetError());
	}

	long signaledTime = nativeFence.getSignalTime();
	// We don't know if the fence has or hasn't signaled yet. But either way it must be
	// greater than before the fence was created (either signaled, or PENDING which is LONG_MAX)
	assertThat("getSignalTime before waiting", signaledTime, greaterThan(before));
	// Similarly, if the fence has signaled it must be less than now
	assertThat("getSignalTime before waiting", signaledTime,
	anyOf(equalTo(SyncFence.SIGNAL_TIME_PENDING), lessThan(System.nanoTime())));

	assertTrue(EGL15.eglDestroySync(mEglDisplay, sync));
	assertEquals(EGL14.EGL_SUCCESS, EGL14.eglGetError());

	assertTrue(nativeFence.awaitForever());
	signaledTime = nativeFence.getSignalTime();
	assertNotEquals(SyncFence.SIGNAL_TIME_INVALID, signaledTime);
	assertThat("getSignalTime after waiting", signaledTime, greaterThan(before));

	nativeFence.close();
	assertFalse(nativeFence.isValid());
	assertEquals(SyncFence.SIGNAL_TIME_INVALID, nativeFence.getSignalTime());
	}

	@Test
	public void testEGL15GetSyncType() {
	if (mEglVersion < 15) {
	return;
	}
	EGLSync sync = EGL15.eglCreateSync(mEglDisplay, EGL15.EGL_SYNC_FENCE,
	new long[] {
	EGL14.EGL_NONE },
	0);
	if (sync == EGL15.EGL_NO_SYNC) {
	throw new RuntimeException("eglCreateSync failed");
	}
	int error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglCreateSync failed");
	}

	long[] type = new long[1];
	boolean success = EGL15.eglGetSyncAttrib(mEglDisplay, sync, EGL15.EGL_SYNC_TYPE, type, 0);
	if (!success) {
	throw new RuntimeException("eglGetSyncAttrib failed (returned false)");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglGetSyncAttrib failed");
	}
	assertEquals(type[0], EGL15.EGL_SYNC_FENCE);

	if (!EGL15.eglDestroySync(mEglDisplay, sync)) {
	throw new RuntimeException("eglDestroySync failed");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglDestroySync failed");
	}
	}

	@Test
	public void testEGL15WaitSync() {
	if (mEglVersion < 15) {
	return;
	}
	EGLSync sync = EGL15.eglCreateSync(mEglDisplay, EGL15.EGL_SYNC_FENCE,
	new long[] {
	EGL14.EGL_NONE },
	0);
	if (sync == EGL15.EGL_NO_SYNC) {
	throw new RuntimeException("eglCreateSync failed");
	}
	int error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglCreateSync failed");
	}

	boolean success = EGL15.eglWaitSync(mEglDisplay, sync, 0);
	if (!success) {
	throw new RuntimeException("eglWaitSync failed (returned false)");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglWaitSync failed");
	}

	if (!EGL15.eglDestroySync(mEglDisplay, sync)) {
	throw new RuntimeException("eglDestroySync failed");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglDestroySync failed");
	}
	}

	@Test
	public void testEGL15CreateImage() {
	if (mEglVersion < 15) {
	return;
	}

	int error;
	int srcTex = 1;
	GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, srcTex);
	error = GLES20.glGetError();
	if (error != GLES20.GL_NO_ERROR) {
	throw new RuntimeException("glBindTexture failed");
	}

	GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, 64, 64, 0,
	GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);
	error = GLES20.glGetError();
	if (error != GLES20.GL_NO_ERROR) {
	throw new RuntimeException("glTexImage2D failed");
	}

	GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER,
	GLES20.GL_LINEAR);
	error = GLES20.glGetError();
	if (error != GLES20.GL_NO_ERROR) {
	throw new RuntimeException("glTexParameteri failed");
	}

	long[] attribs = new long[] {
	EGL15.EGL_GL_TEXTURE_LEVEL, 0,
	EGL14.EGL_NONE };
	EGLImage image = EGL15.eglCreateImage(mEglDisplay, mEglContext,
	EGL15.EGL_GL_TEXTURE_2D, srcTex, attribs, 0);
	if (image == EGL15.EGL_NO_IMAGE) {
	throw new RuntimeException("eglCreateImage failed, got EGL_NO_IMAGE");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglCreateImage failed");
	}

	boolean success = EGL15.eglDestroyImage(mEglDisplay, image);
	if (!success) {
	throw new RuntimeException("eglDestroyImage failed (returned false)");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglDestroyImage failed");
	}
	}

	@Test
	public void testEGL15CreatePlatformPixmap() {
	if (mEglVersion < 15) {
	return;
	}

	long[] attribs = new long[] { EGL14.EGL_NONE };
	boolean unsupported = false;
	try {
	EGLSurface surface = EGL15.eglCreatePlatformPixmapSurface(mEglDisplay,
	mEglConfig, null, attribs, 0);
	} catch (UnsupportedOperationException e) {
	unsupported = true;
	}
	if (!unsupported) {
	throw new RuntimeException("eglCreatePlatformPixmapSurface is not supported on Android,"
	+ " why did call not report that!");
	}
	}

	@Test
	public void testEGL15CreateDebugContext() {
	int error;

	if (mEglVersion < 15) {
	return;
	}

	// Required functionality for devices released with Android R (11),
	// skip if launched with older version of Android.
	if (SystemProperties.getInt("ro.product.first_api_level", 0) < 30) {
	return;
	}

	mEglContext = EGL14.eglCreateContext(mEglDisplay, mEglConfig, EGL14.EGL_NO_CONTEXT,
	new int[] { EGL15.EGL_CONTEXT_OPENGL_DEBUG, EGL14.EGL_FALSE, EGL14.EGL_NONE }, 0);
	if (mEglContext == EGL15.EGL_NO_CONTEXT) {
	throw new RuntimeException("eglCreateContext failed");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglCreateContext failed");
	}
	EGL14.eglDestroyContext(mEglDisplay, mEglContext);

	mEglContext = EGL14.eglCreateContext(mEglDisplay, mEglConfig, EGL14.EGL_NO_CONTEXT,
	new int[] { EGL15.EGL_CONTEXT_OPENGL_DEBUG, EGL14.EGL_TRUE, EGL14.EGL_NONE }, 0);
	if (mEglContext == EGL15.EGL_NO_CONTEXT) {
	throw new RuntimeException("eglCreateContext failed");
	}
	error = EGL14.eglGetError();
	if (error != EGL14.EGL_SUCCESS) {
	throw new RuntimeException("eglCreateContext failed");
	}
	EGL14.eglDestroyContext(mEglDisplay, mEglContext);
	}
	}

	// Note: Need to add tests for eglCreatePlatformWindowSurface