Vulkan: Enable dEQP point limit raster test.

null77 · Commit Bot · commit fa7ca18f44ed · 2019-01-30T15:09:30.000Z
This requires enabling a workaround in the ANGLE shader translator to clamp the point size. Bug: angleproject:2599 Change-Id: I3171bdca5dd2e5af965e94ee2a955f46f8d706da Reviewed-on: https://chromium-review.googlesource.com/c/1412235 Reviewed-by: Jamie Madill <jmadill@chromium.org> Commit-Queue: Jamie Madill <jmadill@chromium.org>
diff --git a/src/libANGLE/renderer/vulkan/RendererVk.cpp b/src/libANGLE/renderer/vulkan/RendererVk.cpp
@@ -1050,6 +1050,13 @@ void RendererVk::initFeatures(const std::vector<VkExtensionProperties> &deviceEx
         mFeatures.clampPointSize = true;
     }
 
+    // We also need to clamp point size on several Android drivers.
+    // TODO(jmadill): Remove suppression once fixed. http://anglebug.com/2599
+    if (IsAndroid())
+    {
+        mFeatures.clampPointSize = true;
+    }
+
 #if defined(ANGLE_PLATFORM_ANDROID)
     // Work around ineffective compute-graphics barriers on Nexus 5X.
     // TODO(syoussefi): Figure out which other vendors and driver versions are affected.
diff --git a/src/tests/deqp_support/deqp_gles2_test_expectations.txt b/src/tests/deqp_support/deqp_gles2_test_expectations.txt
@@ -199,7 +199,6 @@
 
 // Fails on Nexus 5x only. TODO(jmadill): Remove suppression when possible. http://anglebug.com/2791
 2791 VULKAN ANDROID : dEQP-GLES2.functional.clipping.* = SKIP
-2599 VULKAN ANDROID : dEQP-GLES2.functional.rasterization.limits.points = FAIL
 
 // Failing on the Pixel 2.
 2727 VULKAN ANDROID : dEQP-GLES2.functional.shaders.builtin_variable.pointcoord = FAIL
diff --git a/src/tests/gl_tests/GLSLTest.cpp b/src/tests/gl_tests/GLSLTest.cpp
@@ -4696,6 +4696,9 @@ TEST_P(GLSLTest, PointCoordConsistency)
     // AMD's OpenGL drivers may have the same issue. http://anglebug.com/1643
     ANGLE_SKIP_TEST_IF(IsAMD() && IsWindows() && IsOpenGL());
 
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     constexpr char kPointCoordVS[] = R"(attribute vec2 position;
 uniform vec2 viewportSize;
 void main()
diff --git a/src/tests/gl_tests/IndexedPointsTest.cpp b/src/tests/gl_tests/IndexedPointsTest.cpp
@@ -197,21 +197,33 @@ typedef IndexedPointsTest<GLubyte, GL_UNSIGNED_BYTE> IndexedPointsTestUByte;
 
 TEST_P(IndexedPointsTestUByte, UnsignedByteOffset0)
 {
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(0);
 }
 
 TEST_P(IndexedPointsTestUByte, UnsignedByteOffset1)
 {
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(1);
 }
 
 TEST_P(IndexedPointsTestUByte, UnsignedByteOffset2)
 {
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(2);
 }
 
 TEST_P(IndexedPointsTestUByte, UnsignedByteOffset3)
 {
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(3);
 }
 
@@ -220,77 +232,120 @@ TEST_P(IndexedPointsTestUByte, VertexWithColorUnsignedByteOffset0)
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
 
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(0, true);
 }
 
 TEST_P(IndexedPointsTestUByte, VertexWithColorUnsignedByteOffset1)
 {
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
+
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(1, true);
 }
 
 TEST_P(IndexedPointsTestUByte, VertexWithColorUnsignedByteOffset2)
 {
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
+
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(2, true);
 }
 
 TEST_P(IndexedPointsTestUByte, VertexWithColorUnsignedByteOffset3)
 {
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
+
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(3, true);
 }
 
 typedef IndexedPointsTest<GLushort, GL_UNSIGNED_SHORT> IndexedPointsTestUShort;
 
 TEST_P(IndexedPointsTestUShort, UnsignedShortOffset0)
 {
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(0);
 }
 
 TEST_P(IndexedPointsTestUShort, UnsignedShortOffset1)
 {
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(1);
 }
 
 TEST_P(IndexedPointsTestUShort, UnsignedShortOffset2)
 {
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(2);
 }
 
 TEST_P(IndexedPointsTestUShort, UnsignedShortOffset3)
 {
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(3);
 }
 
 TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset0)
 {
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
+
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(0, true);
 }
 
 TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset1)
 {
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
+
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(1, true);
 }
 
 TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset2)
 {
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
+
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(2, true);
 }
 
 TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset3)
 {
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
+
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(3, true);
 }
 
@@ -302,6 +357,9 @@ TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffsetChangingIndice
     // TODO(fjhenigman): Figure out why this fails on Ozone Intel.
     ANGLE_SKIP_TEST_IF(IsOzone() && IsIntel() && IsOpenGLES());
 
+    // http://anglebug.com/2599: Fails on the 5x due to driver bug.
+    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+
     runTest(3, true);
     runTest(1, true);
     runTest(0, true);

Original file line number	Diff line number	Diff line change
`@@ -197,21 +197,33 @@ typedef IndexedPointsTest<GLubyte, GL_UNSIGNED_BYTE> IndexedPointsTestUByte;`
`197`	`197`
`198`	`198`	`TEST_P(IndexedPointsTestUByte, UnsignedByteOffset0)`
`199`	`199`	`{`
	`200`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`201`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`202`	`+`
`200`	`203`	`runTest(0);`
`201`	`204`	`}`
`202`	`205`
`203`	`206`	`TEST_P(IndexedPointsTestUByte, UnsignedByteOffset1)`
`204`	`207`	`{`
	`208`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`209`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`210`	`+`
`205`	`211`	`runTest(1);`
`206`	`212`	`}`
`207`	`213`
`208`	`214`	`TEST_P(IndexedPointsTestUByte, UnsignedByteOffset2)`
`209`	`215`	`{`
	`216`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`217`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`218`	`+`
`210`	`219`	`runTest(2);`
`211`	`220`	`}`
`212`	`221`
`213`	`222`	`TEST_P(IndexedPointsTestUByte, UnsignedByteOffset3)`
`214`	`223`	`{`
	`224`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`225`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`226`	`+`
`215`	`227`	`runTest(3);`
`216`	`228`	`}`
`217`	`229`
`@@ -220,77 +232,120 @@ TEST_P(IndexedPointsTestUByte, VertexWithColorUnsignedByteOffset0)`
`220`	`232`	`// TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848`
`221`	`233`	`ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());`
`222`	`234`
	`235`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`236`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`237`	`+`
`223`	`238`	`runTest(0, true);`
`224`	`239`	`}`
`225`	`240`
`226`	`241`	`TEST_P(IndexedPointsTestUByte, VertexWithColorUnsignedByteOffset1)`
`227`	`242`	`{`
`228`	`243`	`// TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848`
`229`	`244`	`ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());`
	`245`	`+`
	`246`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`247`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`248`	`+`
`230`	`249`	`runTest(1, true);`
`231`	`250`	`}`
`232`	`251`
`233`	`252`	`TEST_P(IndexedPointsTestUByte, VertexWithColorUnsignedByteOffset2)`
`234`	`253`	`{`
`235`	`254`	`// TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848`
`236`	`255`	`ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());`
	`256`	`+`
	`257`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`258`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`259`	`+`
`237`	`260`	`runTest(2, true);`
`238`	`261`	`}`
`239`	`262`
`240`	`263`	`TEST_P(IndexedPointsTestUByte, VertexWithColorUnsignedByteOffset3)`
`241`	`264`	`{`
`242`	`265`	`// TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848`
`243`	`266`	`ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());`
	`267`	`+`
	`268`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`269`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`270`	`+`
`244`	`271`	`runTest(3, true);`
`245`	`272`	`}`
`246`	`273`
`247`	`274`	`typedef IndexedPointsTest<GLushort, GL_UNSIGNED_SHORT> IndexedPointsTestUShort;`
`248`	`275`
`249`	`276`	`TEST_P(IndexedPointsTestUShort, UnsignedShortOffset0)`
`250`	`277`	`{`
	`278`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`279`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`280`	`+`
`251`	`281`	`runTest(0);`
`252`	`282`	`}`
`253`	`283`
`254`	`284`	`TEST_P(IndexedPointsTestUShort, UnsignedShortOffset1)`
`255`	`285`	`{`
	`286`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`287`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`288`	`+`
`256`	`289`	`runTest(1);`
`257`	`290`	`}`
`258`	`291`
`259`	`292`	`TEST_P(IndexedPointsTestUShort, UnsignedShortOffset2)`
`260`	`293`	`{`
	`294`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`295`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`296`	`+`
`261`	`297`	`runTest(2);`
`262`	`298`	`}`
`263`	`299`
`264`	`300`	`TEST_P(IndexedPointsTestUShort, UnsignedShortOffset3)`
`265`	`301`	`{`
	`302`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`303`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`304`	`+`
`266`	`305`	`runTest(3);`
`267`	`306`	`}`
`268`	`307`
`269`	`308`	`TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset0)`
`270`	`309`	`{`
`271`	`310`	`// TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848`
`272`	`311`	`ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());`
	`312`	`+`
	`313`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`314`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`315`	`+`
`273`	`316`	`runTest(0, true);`
`274`	`317`	`}`
`275`	`318`
`276`	`319`	`TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset1)`
`277`	`320`	`{`
`278`	`321`	`// TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848`
`279`	`322`	`ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());`
	`323`	`+`
	`324`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`325`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`326`	`+`
`280`	`327`	`runTest(1, true);`
`281`	`328`	`}`
`282`	`329`
`283`	`330`	`TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset2)`
`284`	`331`	`{`
`285`	`332`	`// TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848`
`286`	`333`	`ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());`
	`334`	`+`
	`335`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`336`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`337`	`+`
`287`	`338`	`runTest(2, true);`
`288`	`339`	`}`
`289`	`340`
`290`	`341`	`TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset3)`
`291`	`342`	`{`
`292`	`343`	`// TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848`
`293`	`344`	`ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());`
	`345`	`+`
	`346`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`347`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`348`	`+`
`294`	`349`	`runTest(3, true);`
`295`	`350`	`}`
`296`	`351`
`@@ -302,6 +357,9 @@ TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffsetChangingIndice`
`302`	`357`	`// TODO(fjhenigman): Figure out why this fails on Ozone Intel.`
`303`	`358`	`ANGLE_SKIP_TEST_IF(IsOzone() && IsIntel() && IsOpenGLES());`
`304`	`359`
	`360`	`+ // http://anglebug.com/2599: Fails on the 5x due to driver bug.`
	`361`	`+ ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());`
	`362`	`+`
`305`	`363`	`runTest(3, true);`
`306`	`364`	`runTest(1, true);`
`307`	`365`	`runTest(0, true);`