| /*------------------------------------------------------------------------- |
| * drawElements Quality Program EGL Module |
| * --------------------------------------- |
| * |
| * Copyright 2014 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. |
| * |
| *//*! |
| * \file |
| * \brief Surface query tests. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "teglQuerySurfaceTests.hpp" |
| |
| #include "teglSimpleConfigCase.hpp" |
| |
| #include "egluNativeDisplay.hpp" |
| #include "egluNativeWindow.hpp" |
| #include "egluNativePixmap.hpp" |
| #include "egluStrUtil.hpp" |
| #include "egluUtil.hpp" |
| #include "egluUnique.hpp" |
| |
| #include "eglwLibrary.hpp" |
| #include "eglwEnums.hpp" |
| |
| #include "tcuTestLog.hpp" |
| #include "tcuTestContext.hpp" |
| #include "tcuCommandLine.hpp" |
| |
| #include "deUniquePtr.hpp" |
| #include "deRandom.hpp" |
| |
| #include <string> |
| #include <vector> |
| |
| namespace deqp |
| { |
| namespace egl |
| { |
| |
| using eglu::ConfigInfo; |
| using tcu::TestLog; |
| using namespace eglw; |
| |
| static void logSurfaceAttribute (tcu::TestLog& log, EGLint attribute, EGLint value) |
| { |
| const char* name = eglu::getSurfaceAttribName(attribute); |
| const eglu::SurfaceAttribValueFmt valueFmt (attribute, value); |
| |
| log << TestLog::Message << " " << name << ": " << valueFmt << TestLog::EndMessage; |
| } |
| |
| static void logSurfaceAttributes (tcu::TestLog& log, const Library& egl, EGLDisplay display, EGLSurface surface, const EGLint* attributes, int numAttribs) |
| { |
| for (int ndx = 0; ndx < numAttribs; ndx++) |
| logSurfaceAttribute(log, attributes[ndx], eglu::querySurfaceInt(egl, display, surface, attributes[ndx])); |
| } |
| |
| static void logCommonSurfaceAttributes (tcu::TestLog& log, const Library& egl, EGLDisplay display, EGLSurface surface) |
| { |
| static const EGLint attributes[] = |
| { |
| EGL_CONFIG_ID, |
| EGL_WIDTH, |
| EGL_HEIGHT, |
| EGL_HORIZONTAL_RESOLUTION, |
| EGL_VERTICAL_RESOLUTION, |
| EGL_MULTISAMPLE_RESOLVE, |
| EGL_PIXEL_ASPECT_RATIO, |
| EGL_RENDER_BUFFER, |
| EGL_SWAP_BEHAVIOR, |
| EGL_ALPHA_FORMAT, |
| EGL_COLORSPACE |
| }; |
| |
| logSurfaceAttributes(log, egl, display, surface, attributes, DE_LENGTH_OF_ARRAY(attributes)); |
| } |
| |
| static void logPbufferSurfaceAttributes (tcu::TestLog& log, const Library& egl, EGLDisplay display, EGLSurface surface) |
| { |
| static const EGLint attributes[] = |
| { |
| EGL_LARGEST_PBUFFER, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_TARGET, |
| EGL_MIPMAP_TEXTURE, |
| EGL_MIPMAP_LEVEL, |
| }; |
| |
| logSurfaceAttributes(log, egl, display, surface, attributes, DE_LENGTH_OF_ARRAY(attributes)); |
| } |
| |
| class QuerySurfaceCase : public SimpleConfigCase |
| { |
| public: |
| QuerySurfaceCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters); |
| |
| void checkCommonAttributes (EGLDisplay display, EGLSurface surface, const ConfigInfo& info); |
| void checkNonPbufferAttributes (EGLDisplay display, EGLSurface surface); |
| }; |
| |
| QuerySurfaceCase::QuerySurfaceCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters) |
| : SimpleConfigCase(eglTestCtx, name, description, filters) |
| { |
| } |
| |
| void QuerySurfaceCase::checkCommonAttributes (EGLDisplay display, EGLSurface surface, const ConfigInfo& info) |
| { |
| const Library& egl = m_eglTestCtx.getLibrary(); |
| tcu::TestLog& log = m_testCtx.getLog(); |
| |
| // Attributes which are common to all surface types |
| |
| // Config ID |
| { |
| const EGLint id = eglu::querySurfaceInt(egl, display, surface, EGL_CONFIG_ID); |
| |
| if (id != info.configId) |
| { |
| log << TestLog::Message << " Fail, config ID " << id << " does not match the one used to create the surface" << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Config ID mismatch"); |
| } |
| } |
| |
| // Width and height |
| { |
| const EGLint width = eglu::querySurfaceInt(egl, display, surface, EGL_WIDTH); |
| const EGLint height = eglu::querySurfaceInt(egl, display, surface, EGL_HEIGHT); |
| |
| if (width <= 0 || height <= 0) |
| { |
| log << TestLog::Message << " Fail, invalid surface size " << width << "x" << height << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid surface size"); |
| } |
| } |
| |
| // Horizontal and vertical resolution |
| { |
| const EGLint hRes = eglu::querySurfaceInt(egl, display, surface, EGL_HORIZONTAL_RESOLUTION); |
| const EGLint vRes = eglu::querySurfaceInt(egl, display, surface, EGL_VERTICAL_RESOLUTION); |
| |
| if ((hRes <= 0 || vRes <= 0) && (hRes != EGL_UNKNOWN && vRes != EGL_UNKNOWN)) |
| { |
| log << TestLog::Message << " Fail, invalid surface resolution " << hRes << "x" << vRes << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid surface resolution"); |
| } |
| } |
| |
| // Pixel aspect ratio |
| { |
| const EGLint pixelRatio = eglu::querySurfaceInt(egl, display, surface, EGL_PIXEL_ASPECT_RATIO); |
| |
| if (pixelRatio <= 0 && pixelRatio != EGL_UNKNOWN) |
| { |
| log << TestLog::Message << " Fail, invalid pixel aspect ratio " << eglu::querySurfaceInt(egl, display, surface, EGL_PIXEL_ASPECT_RATIO) << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid pixel aspect ratio"); |
| } |
| } |
| |
| // Render buffer |
| { |
| const EGLint renderBuffer = eglu::querySurfaceInt(egl, display, surface, EGL_RENDER_BUFFER); |
| |
| if (renderBuffer != EGL_BACK_BUFFER && renderBuffer != EGL_SINGLE_BUFFER) |
| { |
| log << TestLog::Message << " Fail, invalid render buffer value " << renderBuffer << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid render buffer"); |
| } |
| } |
| |
| // Multisample resolve |
| { |
| const EGLint multisampleResolve = eglu::querySurfaceInt(egl, display, surface, EGL_MULTISAMPLE_RESOLVE); |
| |
| if (multisampleResolve != EGL_MULTISAMPLE_RESOLVE_DEFAULT && multisampleResolve != EGL_MULTISAMPLE_RESOLVE_BOX) |
| { |
| log << TestLog::Message << " Fail, invalid multisample resolve value " << multisampleResolve << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid multisample resolve"); |
| } |
| |
| if (multisampleResolve == EGL_MULTISAMPLE_RESOLVE_BOX && !(info.surfaceType & EGL_MULTISAMPLE_RESOLVE_BOX_BIT)) |
| { |
| log << TestLog::Message << " Fail, multisample resolve is reported as box filter but configuration does not support it." << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid multisample resolve"); |
| } |
| } |
| |
| // Swap behavior |
| { |
| const EGLint swapBehavior = eglu::querySurfaceInt(egl, display, surface, EGL_SWAP_BEHAVIOR); |
| |
| if (swapBehavior != EGL_BUFFER_DESTROYED && swapBehavior != EGL_BUFFER_PRESERVED) |
| { |
| log << TestLog::Message << " Fail, invalid swap behavior value " << swapBehavior << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid swap behavior"); |
| } |
| |
| if (swapBehavior == EGL_BUFFER_PRESERVED && !(info.surfaceType & EGL_SWAP_BEHAVIOR_PRESERVED_BIT)) |
| { |
| log << TestLog::Message << " Fail, swap behavior is reported as preserve but configuration does not support it." << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid swap behavior"); |
| } |
| } |
| |
| // alpha format |
| { |
| const EGLint alphaFormat = eglu::querySurfaceInt(egl, display, surface, EGL_ALPHA_FORMAT); |
| |
| if (alphaFormat != EGL_ALPHA_FORMAT_NONPRE && alphaFormat != EGL_ALPHA_FORMAT_PRE) |
| { |
| log << TestLog::Message << " Fail, invalid alpha format value " << alphaFormat << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid alpha format"); |
| } |
| |
| if (alphaFormat == EGL_ALPHA_FORMAT_PRE && !(info.surfaceType & EGL_VG_ALPHA_FORMAT_PRE_BIT)) |
| { |
| log << TestLog::Message << " Fail, is set to use premultiplied alpha but configuration does not support it." << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid alpha format"); |
| } |
| } |
| |
| // color space |
| { |
| const EGLint colorspace = eglu::querySurfaceInt(egl, display, surface, EGL_COLORSPACE); |
| |
| if (colorspace != EGL_VG_COLORSPACE_sRGB && colorspace != EGL_VG_COLORSPACE_LINEAR) |
| { |
| log << TestLog::Message << " Fail, invalid color space value " << colorspace << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid color space"); |
| } |
| |
| if (colorspace == EGL_VG_COLORSPACE_LINEAR && !(info.surfaceType & EGL_VG_COLORSPACE_LINEAR_BIT)) |
| { |
| log << TestLog::Message << " Fail, is set to use a linear color space but configuration does not support it." << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid color space"); |
| } |
| } |
| } |
| |
| void QuerySurfaceCase::checkNonPbufferAttributes (EGLDisplay display, EGLSurface surface) |
| { |
| const Library& egl = m_eglTestCtx.getLibrary(); |
| const EGLint uninitializedMagicValue = -42; |
| tcu::TestLog& log = m_testCtx.getLog(); |
| EGLint value = uninitializedMagicValue; |
| |
| static const EGLint pbufferAttribs[] = |
| { |
| EGL_LARGEST_PBUFFER, |
| EGL_TEXTURE_FORMAT, |
| EGL_TEXTURE_TARGET, |
| EGL_MIPMAP_TEXTURE, |
| EGL_MIPMAP_LEVEL, |
| }; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(pbufferAttribs); ndx++) |
| { |
| const EGLint attribute = pbufferAttribs[ndx]; |
| const std::string name = eglu::getSurfaceAttribName(pbufferAttribs[ndx]); |
| |
| egl.querySurface(display, surface, attribute, &value); |
| |
| { |
| const EGLint error = egl.getError(); |
| |
| if (error != EGL_SUCCESS) |
| { |
| log << TestLog::Message << " Fail, querying " << name << " from a non-pbuffer surface should not result in an error, received " |
| << eglu::getErrorStr(error) << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Illegal error condition"); |
| break; |
| } |
| } |
| |
| // "For a window or pixmap surface, the contents of value are not modified." |
| if (value != uninitializedMagicValue) |
| { |
| log << TestLog::Message << " Fail, return value contents were modified when querying " << name << " from a non-pbuffer surface." << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Illegal modification of return value"); |
| } |
| } |
| } |
| |
| class QuerySurfaceSimpleWindowCase : public QuerySurfaceCase |
| { |
| public: |
| QuerySurfaceSimpleWindowCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters) |
| : QuerySurfaceCase(eglTestCtx, name, description, filters) |
| { |
| } |
| |
| void executeForConfig (EGLDisplay display, EGLConfig config) |
| { |
| const Library& egl = m_eglTestCtx.getLibrary(); |
| tcu::TestLog& log = m_testCtx.getLog(); |
| const int width = 64; |
| const int height = 64; |
| const eglu::NativeWindowFactory* windowFactory = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); |
| ConfigInfo info; |
| |
| if (!windowFactory) |
| TCU_THROW(NotSupportedError, "Windows not supported"); |
| |
| eglu::queryConfigInfo(egl, display, config, &info); |
| |
| log << TestLog::Message << "Creating window surface with config ID " << info.configId << TestLog::EndMessage; |
| EGLU_CHECK_MSG(egl, "before queries"); |
| |
| de::UniquePtr<eglu::NativeWindow> window (windowFactory->createWindow(&m_eglTestCtx.getNativeDisplay(), display, config, DE_NULL, eglu::WindowParams(width, height, eglu::parseWindowVisibility(m_testCtx.getCommandLine())))); |
| eglu::UniqueSurface surface (egl, display, eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *window, display, config, DE_NULL)); |
| |
| logCommonSurfaceAttributes (log, egl, display, *surface); |
| checkCommonAttributes (display, *surface, info); |
| checkNonPbufferAttributes (display, *surface); |
| } |
| }; |
| |
| class QuerySurfaceSimplePixmapCase : public QuerySurfaceCase |
| { |
| public: |
| QuerySurfaceSimplePixmapCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters) |
| : QuerySurfaceCase(eglTestCtx, name, description, filters) |
| { |
| } |
| |
| void executeForConfig (EGLDisplay display, EGLConfig config) |
| { |
| const Library& egl = m_eglTestCtx.getLibrary(); |
| tcu::TestLog& log = m_testCtx.getLog(); |
| const int width = 64; |
| const int height = 64; |
| const eglu::NativePixmapFactory* pixmapFactory = eglu::selectNativePixmapFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); |
| ConfigInfo info; |
| |
| if (!pixmapFactory) |
| TCU_THROW(NotSupportedError, "Pixmaps not supported"); |
| |
| eglu::queryConfigInfo(egl, display, config, &info); |
| |
| log << TestLog::Message << "Creating pixmap surface with config ID " << info.configId << TestLog::EndMessage; |
| EGLU_CHECK_MSG(egl, "before queries"); |
| |
| de::UniquePtr<eglu::NativePixmap> pixmap (pixmapFactory->createPixmap(&m_eglTestCtx.getNativeDisplay(), display, config, DE_NULL, width, height)); |
| eglu::UniqueSurface surface (egl, display, eglu::createPixmapSurface(m_eglTestCtx.getNativeDisplay(), *pixmap, display, config, DE_NULL)); |
| |
| logCommonSurfaceAttributes (log, egl, display, *surface); |
| checkCommonAttributes (display, *surface, info); |
| checkNonPbufferAttributes (display, *surface); |
| } |
| }; |
| |
| class QuerySurfaceSimplePbufferCase : public QuerySurfaceCase |
| { |
| public: |
| QuerySurfaceSimplePbufferCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters) |
| : QuerySurfaceCase(eglTestCtx, name, description, filters) |
| { |
| } |
| |
| void executeForConfig (EGLDisplay display, EGLConfig config) |
| { |
| const Library& egl = m_eglTestCtx.getLibrary(); |
| tcu::TestLog& log = m_testCtx.getLog(); |
| int width = 64; |
| int height = 64; |
| ConfigInfo info; |
| |
| eglu::queryConfigInfo(egl, display, config, &info); |
| |
| log << TestLog::Message << "Creating pbuffer surface with config ID " << info.configId << TestLog::EndMessage; |
| EGLU_CHECK_MSG(egl, "before queries"); |
| |
| // Clamp to maximums reported by implementation |
| width = deMin32(width, eglu::getConfigAttribInt(egl, display, config, EGL_MAX_PBUFFER_WIDTH)); |
| height = deMin32(height, eglu::getConfigAttribInt(egl, display, config, EGL_MAX_PBUFFER_HEIGHT)); |
| |
| if (width == 0 || height == 0) |
| { |
| log << TestLog::Message << " Fail, maximum pbuffer size of " << width << "x" << height << " reported" << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid maximum pbuffer size"); |
| return; |
| } |
| |
| const EGLint attribs[] = |
| { |
| EGL_WIDTH, width, |
| EGL_HEIGHT, height, |
| EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE, |
| EGL_NONE |
| }; |
| |
| { |
| eglu::UniqueSurface surface(egl, display, egl.createPbufferSurface(display, config, attribs)); |
| |
| logCommonSurfaceAttributes (log, egl, display, *surface); |
| logPbufferSurfaceAttributes (log, egl, display, *surface); |
| checkCommonAttributes (display, *surface, info); |
| |
| // Pbuffer-specific attributes |
| |
| // Largest pbuffer |
| { |
| const EGLint largestPbuffer = eglu::querySurfaceInt(egl, display, *surface, EGL_LARGEST_PBUFFER); |
| |
| if (largestPbuffer != EGL_FALSE && largestPbuffer != EGL_TRUE) |
| { |
| log << TestLog::Message << " Fail, invalid largest pbuffer value " << largestPbuffer << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid largest pbuffer"); |
| } |
| } |
| |
| // Texture format |
| { |
| const EGLint textureFormat = eglu::querySurfaceInt(egl, display, *surface, EGL_TEXTURE_FORMAT); |
| |
| if (textureFormat != EGL_NO_TEXTURE && textureFormat != EGL_TEXTURE_RGB && textureFormat != EGL_TEXTURE_RGBA) |
| { |
| log << TestLog::Message << " Fail, invalid texture format value " << textureFormat << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid texture format"); |
| } |
| } |
| |
| // Texture target |
| { |
| const EGLint textureTarget = eglu::querySurfaceInt(egl, display, *surface, EGL_TEXTURE_TARGET); |
| |
| if (textureTarget != EGL_NO_TEXTURE && textureTarget != EGL_TEXTURE_2D) |
| { |
| log << TestLog::Message << " Fail, invalid texture target value " << textureTarget << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid texture target"); |
| } |
| } |
| |
| // Mipmap texture |
| { |
| const EGLint mipmapTexture = eglu::querySurfaceInt(egl, display, *surface, EGL_MIPMAP_TEXTURE); |
| |
| if (mipmapTexture != EGL_FALSE && mipmapTexture != EGL_TRUE) |
| { |
| log << TestLog::Message << " Fail, invalid mipmap texture value " << mipmapTexture << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid mipmap texture"); |
| } |
| } |
| } |
| } |
| }; |
| |
| class SurfaceAttribCase : public SimpleConfigCase |
| { |
| public: |
| SurfaceAttribCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters); |
| virtual ~SurfaceAttribCase (void) {} |
| |
| void testAttributes (EGLDisplay display, EGLSurface surface, EGLint surfaceType, const ConfigInfo& info); |
| }; |
| |
| SurfaceAttribCase::SurfaceAttribCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters) |
| : SimpleConfigCase(eglTestCtx, name, description, filters) |
| { |
| } |
| |
| void SurfaceAttribCase::testAttributes (EGLDisplay display, EGLSurface surface, EGLint surfaceType, const ConfigInfo& info) |
| { |
| const Library& egl = m_eglTestCtx.getLibrary(); |
| tcu::TestLog& log = m_testCtx.getLog(); |
| const eglu::Version version = eglu::getVersion(egl, display); |
| de::Random rnd (deStringHash(m_name.c_str()) ^ 0xf215918f); |
| |
| if (version.getMajor() == 1 && version.getMinor() == 0) |
| { |
| log << TestLog::Message << "No attributes can be set in EGL 1.0" << TestLog::EndMessage; |
| return; |
| } |
| |
| // Mipmap level |
| if (info.renderableType & EGL_OPENGL_ES_BIT || info.renderableType & EGL_OPENGL_ES2_BIT) |
| { |
| const EGLint initialValue = 0xDEADBAAD; |
| EGLint value = initialValue; |
| |
| EGLU_CHECK_CALL(egl, querySurface(display, surface, EGL_MIPMAP_LEVEL, &value)); |
| |
| logSurfaceAttribute(log, EGL_MIPMAP_LEVEL, value); |
| |
| if (surfaceType == EGL_PBUFFER_BIT) |
| { |
| if (value != 0) |
| { |
| log << TestLog::Message << " Fail, initial mipmap level value should be 0, is " << value << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid default mipmap level"); |
| } |
| } |
| else if (value != initialValue) |
| { |
| log << TestLog::Message << " Fail, eglQuerySurface changed value when querying EGL_MIPMAP_LEVEL for non-pbuffer surface. Result: " << value << ". Expected: " << initialValue << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "EGL_MIPMAP_LEVEL query modified result for non-pbuffer surface."); |
| } |
| |
| egl.surfaceAttrib(display, surface, EGL_MIPMAP_LEVEL, 1); |
| |
| { |
| const EGLint error = egl.getError(); |
| |
| if (error != EGL_SUCCESS) |
| { |
| log << TestLog::Message << " Fail, setting EGL_MIPMAP_LEVEL should not result in an error, received " << eglu::getErrorStr(error) << TestLog::EndMessage; |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Illegal error condition"); |
| } |
| } |
| } |
| |
| // Only mipmap level can be set in EGL 1.3 and lower |
| if (version.getMajor() == 1 && version.getMinor() <= 3) return; |
| |
| // Multisample resolve |
| { |
| const EGLint value = eglu::querySurfaceInt(egl, display, surface, EGL_MULTISAMPLE_RESOLVE); |
| |
| logSurfaceAttribute(log, EGL_MULTISAMPLE_RESOLVE, value); |
| |
| if (value != EGL_MULTISAMPLE_RESOLVE_DEFAULT) |
| { |
| log << TestLog::Message << " Fail, initial multisample resolve value should be EGL_MULTISAMPLE_RESOLVE_DEFAULT, is " |
| << eglu::getSurfaceAttribValueStr(EGL_MULTISAMPLE_RESOLVE, value) << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid default multisample resolve"); |
| } |
| |
| if (info.renderableType & EGL_MULTISAMPLE_RESOLVE_BOX_BIT) |
| { |
| log << TestLog::Message << " Box filter is supported by surface, trying to set." << TestLog::EndMessage; |
| |
| egl.surfaceAttrib(display, surface, EGL_MULTISAMPLE_RESOLVE, EGL_MULTISAMPLE_RESOLVE_BOX); |
| |
| if (eglu::querySurfaceInt(egl, display, surface, EGL_MULTISAMPLE_RESOLVE) != EGL_MULTISAMPLE_RESOLVE_BOX) |
| { |
| log << TestLog::Message << " Fail, tried to enable box filter but value did not change."; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to set multisample resolve"); |
| } |
| } |
| } |
| |
| // Swap behavior |
| { |
| const EGLint value = eglu::querySurfaceInt(egl, display, surface, EGL_SWAP_BEHAVIOR); |
| |
| logSurfaceAttribute(log, EGL_SWAP_BEHAVIOR, value); |
| |
| if (info.renderableType & EGL_SWAP_BEHAVIOR_PRESERVED_BIT) |
| { |
| const EGLint nextValue = (value == EGL_BUFFER_DESTROYED) ? EGL_BUFFER_PRESERVED : EGL_BUFFER_DESTROYED; |
| |
| egl.surfaceAttrib(display, surface, EGL_SWAP_BEHAVIOR, nextValue); |
| |
| if (eglu::querySurfaceInt(egl, display, surface, EGL_SWAP_BEHAVIOR) != nextValue) |
| { |
| log << TestLog::Message << " Fail, tried to set swap behavior to " << eglu::getSurfaceAttribStr(nextValue) << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to set swap behavior"); |
| } |
| } |
| } |
| } |
| |
| class SurfaceAttribWindowCase : public SurfaceAttribCase |
| { |
| public: |
| SurfaceAttribWindowCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters) |
| : SurfaceAttribCase(eglTestCtx, name, description, filters) |
| { |
| } |
| |
| void executeForConfig (EGLDisplay display, EGLConfig config) |
| { |
| const Library& egl = m_eglTestCtx.getLibrary(); |
| tcu::TestLog& log = m_testCtx.getLog(); |
| const int width = 64; |
| const int height = 64; |
| const eglu::NativeWindowFactory* windowFactory = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); |
| ConfigInfo info; |
| |
| if (!windowFactory) |
| TCU_THROW(NotSupportedError, "Windows not supported"); |
| |
| eglu::queryConfigInfo(egl, display, config, &info); |
| |
| log << TestLog::Message << "Creating window surface with config ID " << info.configId << TestLog::EndMessage; |
| EGLU_CHECK_MSG(egl, "before queries"); |
| |
| de::UniquePtr<eglu::NativeWindow> window (windowFactory->createWindow(&m_eglTestCtx.getNativeDisplay(), display, config, DE_NULL, eglu::WindowParams(width, height, eglu::parseWindowVisibility(m_testCtx.getCommandLine())))); |
| eglu::UniqueSurface surface (egl, display, eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *window, display, config, DE_NULL)); |
| |
| testAttributes(display, *surface, EGL_WINDOW_BIT, info); |
| } |
| }; |
| |
| class SurfaceAttribPixmapCase : public SurfaceAttribCase |
| { |
| public: |
| SurfaceAttribPixmapCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters) |
| : SurfaceAttribCase(eglTestCtx, name, description, filters) |
| { |
| } |
| |
| void executeForConfig (EGLDisplay display, EGLConfig config) |
| { |
| const Library& egl = m_eglTestCtx.getLibrary(); |
| tcu::TestLog& log = m_testCtx.getLog(); |
| const int width = 64; |
| const int height = 64; |
| const eglu::NativePixmapFactory* pixmapFactory = eglu::selectNativePixmapFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); |
| ConfigInfo info; |
| |
| if (!pixmapFactory) |
| TCU_THROW(NotSupportedError, "Pixmaps not supported"); |
| |
| eglu::queryConfigInfo(egl, display, config, &info); |
| |
| log << TestLog::Message << "Creating pixmap surface with config ID " << info.configId << TestLog::EndMessage; |
| EGLU_CHECK_MSG(egl, "before queries"); |
| |
| de::UniquePtr<eglu::NativePixmap> pixmap (pixmapFactory->createPixmap(&m_eglTestCtx.getNativeDisplay(), display, config, DE_NULL, width, height)); |
| eglu::UniqueSurface surface (egl, display, eglu::createPixmapSurface(m_eglTestCtx.getNativeDisplay(), *pixmap, display, config, DE_NULL)); |
| |
| testAttributes(display, *surface, EGL_PIXMAP_BIT, info); |
| } |
| }; |
| |
| class SurfaceAttribPbufferCase : public SurfaceAttribCase |
| { |
| public: |
| SurfaceAttribPbufferCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters) |
| : SurfaceAttribCase(eglTestCtx, name, description, filters) |
| { |
| } |
| |
| void executeForConfig (EGLDisplay display, EGLConfig config) |
| { |
| const Library& egl = m_eglTestCtx.getLibrary(); |
| tcu::TestLog& log = m_testCtx.getLog(); |
| int width = 64; |
| int height = 64; |
| ConfigInfo info; |
| |
| eglu::queryConfigInfo(egl, display, config, &info); |
| |
| log << TestLog::Message << "Creating pbuffer surface with config ID " << info.configId << TestLog::EndMessage; |
| EGLU_CHECK_MSG(egl, "before queries"); |
| |
| // Clamp to maximums reported by implementation |
| width = deMin32(width, eglu::getConfigAttribInt(egl, display, config, EGL_MAX_PBUFFER_WIDTH)); |
| height = deMin32(height, eglu::getConfigAttribInt(egl, display, config, EGL_MAX_PBUFFER_HEIGHT)); |
| |
| if (width == 0 || height == 0) |
| { |
| log << TestLog::Message << " Fail, maximum pbuffer size of " << width << "x" << height << " reported" << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid maximum pbuffer size"); |
| return; |
| } |
| |
| const EGLint attribs[] = |
| { |
| EGL_WIDTH, width, |
| EGL_HEIGHT, height, |
| EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE, |
| EGL_NONE |
| }; |
| |
| eglu::UniqueSurface surface(egl, display, egl.createPbufferSurface(display, config, attribs)); |
| |
| testAttributes(display, *surface, EGL_PBUFFER_BIT, info); |
| } |
| }; |
| |
| QuerySurfaceTests::QuerySurfaceTests (EglTestContext& eglTestCtx) |
| : TestCaseGroup(eglTestCtx, "query_surface", "Surface Query Tests") |
| { |
| } |
| |
| QuerySurfaceTests::~QuerySurfaceTests (void) |
| { |
| } |
| |
| template <deUint32 Type> |
| static bool surfaceType (const eglu::CandidateConfig& c) |
| { |
| return (c.surfaceType() & Type) == Type; |
| } |
| |
| void QuerySurfaceTests::init (void) |
| { |
| // Simple queries |
| { |
| tcu::TestCaseGroup* simpleGroup = new tcu::TestCaseGroup(m_testCtx, "simple", "Simple queries"); |
| addChild(simpleGroup); |
| |
| // Window |
| { |
| tcu::TestCaseGroup* windowGroup = new tcu::TestCaseGroup(m_testCtx, "window", "Window surfaces"); |
| simpleGroup->addChild(windowGroup); |
| |
| eglu::FilterList baseFilters; |
| baseFilters << surfaceType<EGL_WINDOW_BIT>; |
| |
| std::vector<NamedFilterList> filterLists; |
| getDefaultFilterLists(filterLists, baseFilters); |
| |
| for (std::vector<NamedFilterList>::iterator i = filterLists.begin(); i != filterLists.end(); i++) |
| windowGroup->addChild(new QuerySurfaceSimpleWindowCase(m_eglTestCtx, i->getName(), i->getDescription(), *i)); |
| } |
| |
| // Pixmap |
| { |
| tcu::TestCaseGroup* pixmapGroup = new tcu::TestCaseGroup(m_testCtx, "pixmap", "Pixmap surfaces"); |
| simpleGroup->addChild(pixmapGroup); |
| |
| eglu::FilterList baseFilters; |
| baseFilters << surfaceType<EGL_PIXMAP_BIT>; |
| |
| std::vector<NamedFilterList> filterLists; |
| getDefaultFilterLists(filterLists, baseFilters); |
| |
| for (std::vector<NamedFilterList>::iterator i = filterLists.begin(); i != filterLists.end(); i++) |
| pixmapGroup->addChild(new QuerySurfaceSimplePixmapCase(m_eglTestCtx, i->getName(), i->getDescription(), *i)); |
| } |
| |
| // Pbuffer |
| { |
| tcu::TestCaseGroup* pbufferGroup = new tcu::TestCaseGroup(m_testCtx, "pbuffer", "Pbuffer surfaces"); |
| simpleGroup->addChild(pbufferGroup); |
| |
| eglu::FilterList baseFilters; |
| baseFilters << surfaceType<EGL_PBUFFER_BIT>; |
| |
| std::vector<NamedFilterList> filterLists; |
| getDefaultFilterLists(filterLists, baseFilters); |
| |
| for (std::vector<NamedFilterList>::iterator i = filterLists.begin(); i != filterLists.end(); i++) |
| pbufferGroup->addChild(new QuerySurfaceSimplePbufferCase(m_eglTestCtx, i->getName(), i->getDescription(), *i)); |
| } |
| } |
| |
| // Set surface attributes |
| { |
| tcu::TestCaseGroup* setAttributeGroup = new tcu::TestCaseGroup(m_testCtx, "set_attribute", "Setting attributes"); |
| addChild(setAttributeGroup); |
| |
| // Window |
| { |
| tcu::TestCaseGroup* windowGroup = new tcu::TestCaseGroup(m_testCtx, "window", "Window surfaces"); |
| setAttributeGroup->addChild(windowGroup); |
| |
| eglu::FilterList baseFilters; |
| baseFilters << surfaceType<EGL_WINDOW_BIT>; |
| |
| std::vector<NamedFilterList> filterLists; |
| getDefaultFilterLists(filterLists, baseFilters); |
| |
| for (std::vector<NamedFilterList>::iterator i = filterLists.begin(); i != filterLists.end(); i++) |
| windowGroup->addChild(new SurfaceAttribWindowCase(m_eglTestCtx, i->getName(), i->getDescription(), *i)); |
| } |
| |
| // Pixmap |
| { |
| tcu::TestCaseGroup* pixmapGroup = new tcu::TestCaseGroup(m_testCtx, "pixmap", "Pixmap surfaces"); |
| setAttributeGroup->addChild(pixmapGroup); |
| |
| eglu::FilterList baseFilters; |
| baseFilters << surfaceType<EGL_PIXMAP_BIT>; |
| |
| std::vector<NamedFilterList> filterLists; |
| getDefaultFilterLists(filterLists, baseFilters); |
| |
| for (std::vector<NamedFilterList>::iterator i = filterLists.begin(); i != filterLists.end(); i++) |
| pixmapGroup->addChild(new SurfaceAttribPixmapCase(m_eglTestCtx, i->getName(), i->getDescription(), *i)); |
| } |
| |
| // Pbuffer |
| { |
| tcu::TestCaseGroup* pbufferGroup = new tcu::TestCaseGroup(m_testCtx, "pbuffer", "Pbuffer surfaces"); |
| setAttributeGroup->addChild(pbufferGroup); |
| |
| eglu::FilterList baseFilters; |
| baseFilters << surfaceType<EGL_PBUFFER_BIT>; |
| |
| std::vector<NamedFilterList> filterLists; |
| getDefaultFilterLists(filterLists, baseFilters); |
| |
| for (std::vector<NamedFilterList>::iterator i = filterLists.begin(); i != filterLists.end(); i++) |
| pbufferGroup->addChild(new SurfaceAttribPbufferCase(m_eglTestCtx, i->getName(), i->getDescription(), *i)); |
| } |
| } |
| } |
| |
| } // egl |
| } // deqp |