Add EGLSurfaceTest.ResizeWindowWithDraw

src/tests/egl_tests/EGLSurfaceTest.cpp

@@ -92,6 +92,7 @@ class EGLSurfaceTest : public ANGLETest
     void initializeDisplay()
     {
         GLenum platformType = GetParam().getRenderer();
+        GLenum deviceType   = GetParam().getDeviceType();
 
         std::vector<EGLint> displayAttributes;
         displayAttributes.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE);
@@ -101,7 +102,7 @@ class EGLSurfaceTest : public ANGLETest
         displayAttributes.push_back(EGL_PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE);
         displayAttributes.push_back(EGL_DONT_CARE);
         displayAttributes.push_back(EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE);
-        displayAttributes.push_back(EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE);
+        displayAttributes.push_back(deviceType);
         displayAttributes.push_back(EGL_NONE);
 
         mDisplay = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE,
@@ -300,7 +301,7 @@ TEST_P(EGLSurfaceTest, ResizeWindow)
     // TODO(syoussefi): http://anglebug.com/3123
     ANGLE_SKIP_TEST_IF(IsAndroid());
 
-    // Necessary for a window resizing test
+    // Necessary for a window resizing test if there is no per-frame window size query
     mOSWindow->setVisible(true);
 
     GLenum platform               = GetParam().getRenderer();
@@ -346,6 +347,91 @@ TEST_P(EGLSurfaceTest, ResizeWindow)
     ASSERT_EQ(64, height);
 }
 
+// Test that the backbuffer is correctly resized after calling swapBuffers
+TEST_P(EGLSurfaceTest, ResizeWindowWithDraw)
+{
+    // Necessary for a window resizing test if there is no per-frame window size query
+
+    mOSWindow->setVisible(true);
+
+    initializeDisplay();
+    initializeSurfaceWithDefaultConfig();
+    initializeContext();
+
+    int size      = 64;
+    EGLint height = 0;
+    EGLint width  = 0;
+
+    eglMakeCurrent(mDisplay, mWindowSurface, mWindowSurface, mContext);
+    eglSwapBuffers(mDisplay, mWindowSurface);
+    ASSERT_EGL_SUCCESS();
+
+    // Clear to red
+    glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    eglQuerySurface(mDisplay, mWindowSurface, EGL_HEIGHT, &height);
+    eglQuerySurface(mDisplay, mWindowSurface, EGL_WIDTH, &width);
+    ASSERT_EGL_SUCCESS();
+
+    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
+    EXPECT_PIXEL_COLOR_EQ(size - 1, 0, GLColor::red);
+    EXPECT_PIXEL_COLOR_EQ(size - 1, size - 1, GLColor::red);
+    EXPECT_PIXEL_COLOR_EQ(0, size - 1, GLColor::red);
+    EXPECT_PIXEL_COLOR_EQ(-1, -1, GLColor::transparentBlack);
+    EXPECT_PIXEL_COLOR_EQ(size, 0, GLColor::transparentBlack);
+    EXPECT_PIXEL_COLOR_EQ(0, size, GLColor::transparentBlack);
+    EXPECT_PIXEL_COLOR_EQ(size, size, GLColor::transparentBlack);
+
+    // set window's size small
+    size = 1;
+    mOSWindow->resize(size, size);
+
+    eglSwapBuffers(mDisplay, mWindowSurface);
+    ASSERT_EGL_SUCCESS();
+
+    // Clear to green
+    glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    eglQuerySurface(mDisplay, mWindowSurface, EGL_HEIGHT, &height);
+    eglQuerySurface(mDisplay, mWindowSurface, EGL_WIDTH, &width);
+    ASSERT_EGL_SUCCESS();
+
+    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
+    EXPECT_PIXEL_COLOR_EQ(size - 1, 0, GLColor::green);
+    EXPECT_PIXEL_COLOR_EQ(size - 1, size - 1, GLColor::green);
+    EXPECT_PIXEL_COLOR_EQ(0, size - 1, GLColor::green);
+    EXPECT_PIXEL_COLOR_EQ(-1, -1, GLColor::transparentBlack);
+    EXPECT_PIXEL_COLOR_EQ(size, 0, GLColor::transparentBlack);
+    EXPECT_PIXEL_COLOR_EQ(0, size, GLColor::transparentBlack);
+    EXPECT_PIXEL_COLOR_EQ(size, size, GLColor::transparentBlack);
+
+    // set window's height large
+    size = 128;
+    mOSWindow->resize(size, size);
+
+    eglSwapBuffers(mDisplay, mWindowSurface);
+    ASSERT_EGL_SUCCESS();
+
+    // Clear to blue
+    glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    eglQuerySurface(mDisplay, mWindowSurface, EGL_HEIGHT, &height);
+    eglQuerySurface(mDisplay, mWindowSurface, EGL_WIDTH, &width);
+    ASSERT_EGL_SUCCESS();
+
+    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::blue);
+    EXPECT_PIXEL_COLOR_EQ(size - 1, 0, GLColor::blue);
+    EXPECT_PIXEL_COLOR_EQ(size - 1, size - 1, GLColor::blue);
+    EXPECT_PIXEL_COLOR_EQ(0, size - 1, GLColor::blue);
+    EXPECT_PIXEL_COLOR_EQ(-1, -1, GLColor::transparentBlack);
+    EXPECT_PIXEL_COLOR_EQ(size, 0, GLColor::transparentBlack);
+    EXPECT_PIXEL_COLOR_EQ(0, size, GLColor::transparentBlack);
+    EXPECT_PIXEL_COLOR_EQ(size, size, GLColor::transparentBlack);
+}
+
 // Test that swap interval works.
 TEST_P(EGLSurfaceTest, SwapInterval)
 {
@@ -358,6 +444,8 @@ TEST_P(EGLSurfaceTest, SwapInterval)
     ANGLE_SKIP_TEST_IF(IsLinux() && IsNVIDIA() && isVulkanRenderer());
     // Flaky on Linux NVIDIA OpenGL driver. http://anglebug.com/3807
     ANGLE_SKIP_TEST_IF(IsLinux() && IsNVIDIA() && isGLRenderer());
+    // Test fails on Swangle http://anglebug.com/4169
+    ANGLE_SKIP_TEST_IF(isVulkanSwiftshaderRenderer());
 
     initializeDisplay();
     initializeSurfaceWithDefaultConfig();
@@ -811,7 +899,9 @@ ANGLE_INSTANTIATE_TEST(EGLSurfaceTest,
                        WithNoFixture(ES2_OPENGLES()),
                        WithNoFixture(ES3_OPENGLES()),
                        WithNoFixture(ES2_VULKAN()),
-                       WithNoFixture(ES3_VULKAN()));
+                       WithNoFixture(ES3_VULKAN()),
+                       WithNoFixture(ES2_VULKAN_SWIFTSHADER()),
+                       WithNoFixture(ES3_VULKAN_SWIFTSHADER()));
 ANGLE_INSTANTIATE_TEST(EGLSurfaceTest3, WithNoFixture(ES3_VULKAN()));
 
 #if defined(ANGLE_ENABLE_D3D11)

src/tests/test_utils/ANGLETest.h

@@ -470,6 +470,12 @@ class ANGLETestBase
         return mCurrentParams->getRenderer() == EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE;
     }
 
+    bool isVulkanSwiftshaderRenderer() const
+    {
+        return mCurrentParams->getRenderer() == EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE &&
+               mCurrentParams->getDeviceType() == EGL_PLATFORM_ANGLE_DEVICE_TYPE_SWIFTSHADER_ANGLE;
+    }
+
   private:
     void checkD3D11SDKLayersMessages();
 

src/tests/test_utils/angle_test_configs.cpp

@@ -39,6 +39,11 @@ EGLint PlatformParameters::getRenderer() const
     return eglParameters.renderer;
 }
 
+EGLint PlatformParameters::getDeviceType() const
+{
+    return eglParameters.deviceType;
+}
+
 void PlatformParameters::initDefaultParameters()
 {
 #if defined(ANGLE_ENABLE_VULKAN_VALIDATION_LAYERS_BY_DEFAULT)

src/tests/test_utils/angle_test_configs.h

@@ -43,6 +43,7 @@ struct PlatformParameters
     PlatformParameters(EGLint majorVersion, EGLint minorVersion, GLESDriverType driver);
 
     EGLint getRenderer() const;
+    EGLint getDeviceType() const;
 
     void initDefaultParameters();