Vulkan:Add Swiftshader configs

Add Swiftshader configs to existing test instantiation macros for all ESX
variants. This causes Swiftshader to be used to run end2end tests.

Added detection code to know when tests are running on Swiftshader and skipping
a number of fails initially.

Note that when running ANGLE end2end tests within Chromium build on Win32 bots
there were crashes with Swiftshader config for tests that should have been skipped.
Due to this, just skipping Swiftshader configs on Win32 for now.

Bug: angleproject:4081
Bug: angleproject:4092
Change-Id: I32527a62304c5fad90f645b372edf9411ca2b212
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1914126
Commit-Queue: Tobin Ehlis <tobine@google.com>
Reviewed-by: Jonah Ryan-Davis <jonahr@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>

src/gpu_info_util/SystemInfo.cpp

@@ -25,6 +25,10 @@ std::string VendorName(VendorID vendor)
     {
         case kVendorID_AMD:
             return "AMD";
+        case kVendorID_ARM:
+            return "ARM";
+        case kVendorID_GOOGLE:
+            return "Google";
         case kVendorID_Intel:
             return "Intel";
         case kVendorID_ImgTec:

src/gpu_info_util/SystemInfo.h

@@ -85,6 +85,7 @@ bool GetSystemInfo(SystemInfo *info);
 // Known PCI vendor IDs
 constexpr VendorID kVendorID_AMD      = 0x1002;
 constexpr VendorID kVendorID_ARM      = 0x13B5;
+constexpr VendorID kVendorID_GOOGLE   = 0x1AE0;
 constexpr VendorID kVendorID_ImgTec   = 0x1010;
 constexpr VendorID kVendorID_Intel    = 0x8086;
 constexpr VendorID kVendorID_NVIDIA   = 0x10DE;
@@ -96,6 +97,9 @@ constexpr VendorID kVendorID_Vivante     = 0x10001;
 constexpr VendorID kVendorID_VeriSilicon = 0x10002;
 constexpr VendorID kVendorID_Kazan       = 0x10003;
 
+// Known device IDs
+constexpr DeviceID kDeviceID_Swiftshader = 0xC0DE;
+
 // Predicates on vendor IDs
 bool IsAMD(VendorID vendorId);
 bool IsARM(VendorID vendorId);
@@ -104,6 +108,7 @@ bool IsIntel(VendorID vendorId);
 bool IsKazan(VendorID vendorId);
 bool IsNVIDIA(VendorID vendorId);
 bool IsQualcomm(VendorID vendorId);
+bool IsSwiftshader(VendorID vendorId);
 bool IsVeriSilicon(VendorID vendorId);
 bool IsVMWare(VendorID vendorId);
 bool IsVivante(VendorID vendorId);

src/tests/gl_tests/BlendMinMaxTest.cpp

@@ -182,7 +182,7 @@ TEST_P(BlendMinMaxTest, RGBA16F)
     ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3 &&
                        !IsGLExtensionEnabled("GL_EXT_color_buffer_half_float"));
     // http://anglebug.com/4092
-    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+    ANGLE_SKIP_TEST_IF((IsAndroid() && IsVulkan()) || isSwiftshader());
 
     runTest(GL_RGBA16F, GL_FLOAT);
 }

src/tests/gl_tests/BufferDataTest.cpp

@@ -292,6 +292,8 @@ void main()
 // https://code.google.com/p/angleproject/issues/detail?id=709
 TEST_P(IndexedBufferCopyTest, IndexRangeBug)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     // TODO(geofflang): Figure out why this fails on AMD OpenGL (http://anglebug.com/1291)
     ANGLE_SKIP_TEST_IF(IsAMD() && IsOpenGL());
 

src/tests/gl_tests/ClearTest.cpp

@@ -622,6 +622,8 @@ TEST_P(ClearTest, MaskedClearThenDrawWithUniform)
 // clears to the correct values.
 TEST_P(ClearTestES3, ClearMultipleAttachmentsFollowedBySpecificOne)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     constexpr uint32_t kSize            = 16;
     constexpr uint32_t kAttachmentCount = 5;
     std::vector<unsigned char> pixelData(kSize * kSize * 4, 255);

src/tests/gl_tests/ComputeShaderTest.cpp

@@ -872,6 +872,8 @@ void main()
 // Test that texelFetch works well in compute shader.
 TEST_P(ComputeShaderTest, TexelFetchFunction)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     constexpr char kCS[] = R"(#version 310 es
 layout(local_size_x=16, local_size_y=16) in;
 precision highp usampler2D;
@@ -940,6 +942,8 @@ void main()
 // Test that texture function works well in compute shader.
 TEST_P(ComputeShaderTest, TextureFunction)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     constexpr char kCS[] = R"(#version 310 es
 layout(local_size_x=16, local_size_y=16) in;
 precision highp usampler2D;
@@ -2813,6 +2817,8 @@ void main()
 // Test storage buffer bound is unchanged, shader writes it, buffer content should be updated.
 TEST_P(ComputeShaderTest, StorageBufferBoundUnchanged)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     constexpr char kCS[] = R"(#version 310 es
 layout(local_size_x=16, local_size_y=16) in;
 precision highp usampler2D;

src/tests/gl_tests/CopyCompressedTextureTest.cpp

@@ -320,7 +320,7 @@ TEST_P(CopyCompressedTextureTest, Immutable)
         return;
     }
     // http://anglebug.com/4092
-    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+    ANGLE_SKIP_TEST_IF((IsAndroid() && IsVulkan()) || isSwiftshader());
 
     glBindTexture(GL_TEXTURE_2D, mTextures[0]);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

src/tests/gl_tests/DepthStencilFormatsTest.cpp

@@ -766,6 +766,7 @@ TEST_P(TinyDepthStencilWorkaroundTest, DepthTexturesStick)
 {
     // http://anglebug.com/4092
     ANGLE_SKIP_TEST_IF((IsAndroid() && IsOpenGLES()) || (IsLinux() && IsVulkan()));
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     constexpr char kDrawVS[] =
         "#version 100\n"
         "attribute vec3 vertex;\n"

src/tests/gl_tests/FramebufferRenderMipmapTest.cpp

@@ -53,6 +53,8 @@ class FramebufferRenderMipmapTest : public ANGLETest
 // when using a non-zero level in glFramebufferTexture2D.
 TEST_P(FramebufferRenderMipmapTest, Validation)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     bool renderToMipmapSupported =
         IsGLExtensionEnabled("GL_OES_fbo_render_mipmap") || getClientMajorVersion() > 2;
 

src/tests/gl_tests/FramebufferTest.cpp

@@ -990,6 +990,8 @@ TEST_P(FramebufferTest_ES31, RenderingLimitToDefaultFBOSizeWithNoAttachments)
     ANGLE_SKIP_TEST_IF(IsLinux() && IsAMD() && IsDesktopOpenGL());
     // Occlusion query reports fragments outside the render area are still rendered
     ANGLE_SKIP_TEST_IF(IsAndroid() || (IsWindows() && (IsIntel() || IsAMD())));
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
 
     constexpr char kVS1[] = R"(#version 310 es
 in layout(location = 0) highp vec2 a_position;

src/tests/gl_tests/GLSLTest.cpp

@@ -703,6 +703,8 @@ void main()
 // Draw an array of points with the first vertex offset at 0 using gl_VertexID
 TEST_P(GLSLTest_ES3, GLVertexIDOffsetZeroDrawArray)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     constexpr int kStartIndex  = 0;
     constexpr int kArrayLength = 5;
     constexpr char kVS[]       = R"(#version 300 es
@@ -765,6 +767,8 @@ void GLVertexIDIntegerTextureDrawArrays_helper(int first, int count, GLenum err)
 // https://github.com/KhronosGroup/WebGL/blob/master/sdk/tests/conformance2/rendering/vertex-id.html
 TEST_P(GLSLTest_ES3, GLVertexIDIntegerTextureDrawArrays)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     // Have to set a large point size because the window size is much larger than the texture
     constexpr char kVS[] = R"(#version 300 es
 flat out highp int vVertexID;
@@ -820,6 +824,8 @@ void main() {
 // Draw an array of points with the first vertex offset at 5 using gl_VertexID
 TEST_P(GLSLTest_ES3, GLVertexIDOffsetFiveDrawArray)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     // Bug in Nexus drivers, offset does not work. (anglebug.com/3264)
     ANGLE_SKIP_TEST_IF((IsNexus5X() || IsNexus6P()) && IsOpenGLES());
 
@@ -6130,6 +6136,8 @@ 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/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
 
     constexpr char kPointCoordVS[] = R"(attribute vec2 position;
 uniform vec2 viewportSize;

src/tests/gl_tests/IndexedPointsTest.cpp

@@ -192,26 +192,36 @@ typedef IndexedPointsTest<GLubyte, GL_UNSIGNED_BYTE> IndexedPointsTestUByte;
 
 TEST_P(IndexedPointsTestUByte, UnsignedByteOffset0)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(0);
 }
 
 TEST_P(IndexedPointsTestUByte, UnsignedByteOffset1)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(1);
 }
 
 TEST_P(IndexedPointsTestUByte, UnsignedByteOffset2)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(2);
 }
 
 TEST_P(IndexedPointsTestUByte, UnsignedByteOffset3)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(3);
 }
 
 TEST_P(IndexedPointsTestUByte, VertexWithColorUnsignedByteOffset0)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
 
@@ -220,6 +230,8 @@ TEST_P(IndexedPointsTestUByte, VertexWithColorUnsignedByteOffset0)
 
 TEST_P(IndexedPointsTestUByte, VertexWithColorUnsignedByteOffset1)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
 
@@ -228,6 +240,8 @@ TEST_P(IndexedPointsTestUByte, VertexWithColorUnsignedByteOffset1)
 
 TEST_P(IndexedPointsTestUByte, VertexWithColorUnsignedByteOffset2)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
 
@@ -236,6 +250,8 @@ TEST_P(IndexedPointsTestUByte, VertexWithColorUnsignedByteOffset2)
 
 TEST_P(IndexedPointsTestUByte, VertexWithColorUnsignedByteOffset3)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
 
@@ -246,26 +262,36 @@ typedef IndexedPointsTest<GLushort, GL_UNSIGNED_SHORT> IndexedPointsTestUShort;
 
 TEST_P(IndexedPointsTestUShort, UnsignedShortOffset0)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(0);
 }
 
 TEST_P(IndexedPointsTestUShort, UnsignedShortOffset1)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(1);
 }
 
 TEST_P(IndexedPointsTestUShort, UnsignedShortOffset2)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(2);
 }
 
 TEST_P(IndexedPointsTestUShort, UnsignedShortOffset3)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(3);
 }
 
 TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset0)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
 
@@ -274,6 +300,8 @@ TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset0)
 
 TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset1)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
 
@@ -282,6 +310,8 @@ TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset1)
 
 TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset2)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
 
@@ -290,6 +320,8 @@ TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset2)
 
 TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset3)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
 
@@ -298,6 +330,8 @@ TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffset3)
 
 TEST_P(IndexedPointsTestUShort, VertexWithColorUnsignedShortOffsetChangingIndices)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     // TODO(fjhenigman): Fix with buffer offset http://anglebug.com/2848
     ANGLE_SKIP_TEST_IF(IsVulkan() && IsAMD());
 
@@ -318,7 +352,8 @@ TEST_P(IndexedPointsTestUInt, UnsignedIntOffset0)
     {
         return;
     }
-
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(0);
 }
 
@@ -328,7 +363,8 @@ TEST_P(IndexedPointsTestUInt, UnsignedIntOffset1)
     {
         return;
     }
-
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(1);
 }
 
@@ -338,7 +374,8 @@ TEST_P(IndexedPointsTestUInt, UnsignedIntOffset2)
     {
         return;
     }
-
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(2);
 }
 
@@ -348,7 +385,8 @@ TEST_P(IndexedPointsTestUInt, UnsignedIntOffset3)
     {
         return;
     }
-
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(3);
 }
 
@@ -358,7 +396,8 @@ TEST_P(IndexedPointsTestUInt, VertexWithColorUnsignedIntOffset0)
     {
         return;
     }
-
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(0, false);
 }
 
@@ -368,7 +407,8 @@ TEST_P(IndexedPointsTestUInt, VertexWithColorUnsignedIntOffset1)
     {
         return;
     }
-
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(1, false);
 }
 
@@ -378,7 +418,8 @@ TEST_P(IndexedPointsTestUInt, VertexWithColorUnsignedIntOffset2)
     {
         return;
     }
-
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(2, false);
 }
 
@@ -388,7 +429,8 @@ TEST_P(IndexedPointsTestUInt, VertexWithColorUnsignedIntOffset3)
     {
         return;
     }
-
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     runTest(3, false);
 }
 

src/tests/gl_tests/InstancingTest.cpp

@@ -480,6 +480,8 @@ TEST_P(InstancingTestES31, UpdateAttribBindingByVertexAttribDivisor)
 // Verify that a large divisor that also changes doesn't cause issues and renders correctly.
 TEST_P(InstancingTestES3, LargeDivisor)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     constexpr char kVS[] = R"(#version 300 es
 layout(location = 0) in vec4 a_position;
 layout(location = 1) in vec4 a_color;
@@ -579,6 +581,8 @@ void main()
 // incorrectly clamped down to the maximum signed integer.
 TEST_P(InstancingTestES3, LargestDivisor)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     constexpr GLuint kLargeDivisor = std::numeric_limits<GLuint>::max();
     glVertexAttribDivisor(0, kLargeDivisor);
 

src/tests/gl_tests/PackUnpackTest.cpp

@@ -142,7 +142,7 @@ void main()
 TEST_P(PackUnpackTest, PackUnpackSnormNormal)
 {
     // http://anglebug.com/4092
-    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+    ANGLE_SKIP_TEST_IF((IsAndroid() && IsVulkan()) || isSwiftshader());
     // Expect the shader to output the same value as the input
     compareBeforeAfter(mSNormProgram, 0.5f, -0.2f);
     compareBeforeAfter(mSNormProgram, -0.35f, 0.75f);
@@ -155,7 +155,7 @@ TEST_P(PackUnpackTest, PackUnpackSnormNormal)
 TEST_P(PackUnpackTest, PackUnpackUnormNormal)
 {
     // http://anglebug.com/4092
-    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+    ANGLE_SKIP_TEST_IF((IsAndroid() && IsVulkan()) || isSwiftshader());
     // Expect the shader to output the same value as the input
     compareBeforeAfter(mUNormProgram, 0.5f, 0.2f, 0.5f, 0.2f);
     compareBeforeAfter(mUNormProgram, 0.35f, 0.75f, 0.35f, 0.75f);
@@ -168,7 +168,7 @@ TEST_P(PackUnpackTest, PackUnpackUnormNormal)
 TEST_P(PackUnpackTest, PackUnpackHalfNormal)
 {
     // http://anglebug.com/4092
-    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+    ANGLE_SKIP_TEST_IF((IsAndroid() && IsVulkan()) || isSwiftshader());
     // Expect the shader to output the same value as the input
     compareBeforeAfter(mHalfProgram, 0.5f, -0.2f);
     compareBeforeAfter(mHalfProgram, -0.35f, 0.75f);
@@ -181,7 +181,7 @@ TEST_P(PackUnpackTest, PackUnpackHalfNormal)
 TEST_P(PackUnpackTest, PackUnpackSnormSubnormal)
 {
     // http://anglebug.com/4092
-    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+    ANGLE_SKIP_TEST_IF((IsAndroid() && IsVulkan()) || isSwiftshader());
     // Expect the shader to output the same value as the input
     compareBeforeAfter(mSNormProgram, 0.00001f, -0.00001f);
 }
@@ -191,7 +191,7 @@ TEST_P(PackUnpackTest, PackUnpackSnormSubnormal)
 TEST_P(PackUnpackTest, PackUnpackUnormSubnormal)
 {
     // http://anglebug.com/4092
-    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+    ANGLE_SKIP_TEST_IF((IsAndroid() && IsVulkan()) || isSwiftshader());
     // Expect the shader to output the same value as the input for positive numbers and clamp
     // to [0, 1]
     compareBeforeAfter(mUNormProgram, 0.00001f, -0.00001f, 0.00001f, 0.0f);
@@ -202,7 +202,7 @@ TEST_P(PackUnpackTest, PackUnpackUnormSubnormal)
 TEST_P(PackUnpackTest, PackUnpackHalfSubnormal)
 {
     // http://anglebug.com/4092
-    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+    ANGLE_SKIP_TEST_IF((IsAndroid() && IsVulkan()) || isSwiftshader());
     // Expect the shader to output the same value as the input
     compareBeforeAfter(mHalfProgram, 0.00001f, -0.00001f);
 }
@@ -212,7 +212,7 @@ TEST_P(PackUnpackTest, PackUnpackHalfSubnormal)
 TEST_P(PackUnpackTest, PackUnpackSnormZero)
 {
     // http://anglebug.com/4092
-    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+    ANGLE_SKIP_TEST_IF((IsAndroid() && IsVulkan()) || isSwiftshader());
     // Expect the shader to output the same value as the input
     compareBeforeAfter(mSNormProgram, 0.00000f, -0.00000f);
 }
@@ -222,7 +222,7 @@ TEST_P(PackUnpackTest, PackUnpackSnormZero)
 TEST_P(PackUnpackTest, PackUnpackUnormZero)
 {
     // http://anglebug.com/4092
-    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+    ANGLE_SKIP_TEST_IF((IsAndroid() && IsVulkan()) || isSwiftshader());
     compareBeforeAfter(mUNormProgram, 0.00000f, -0.00000f, 0.00000f, 0.00000f);
 }
 
@@ -231,7 +231,7 @@ TEST_P(PackUnpackTest, PackUnpackUnormZero)
 TEST_P(PackUnpackTest, PackUnpackHalfZero)
 {
     // http://anglebug.com/4092
-    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+    ANGLE_SKIP_TEST_IF((IsAndroid() && IsVulkan()) || isSwiftshader());
     // Expect the shader to output the same value as the input
     compareBeforeAfter(mHalfProgram, 0.00000f, -0.00000f);
 }
@@ -241,7 +241,7 @@ TEST_P(PackUnpackTest, PackUnpackHalfZero)
 TEST_P(PackUnpackTest, PackUnpackUnormOverflow)
 {
     // http://anglebug.com/4092
-    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+    ANGLE_SKIP_TEST_IF((IsAndroid() && IsVulkan()) || isSwiftshader());
     // Expect the shader to clamp the input to [0, 1]
     compareBeforeAfter(mUNormProgram, 67000.0f, -67000.0f, 1.0f, 0.0f);
 }
@@ -251,7 +251,7 @@ TEST_P(PackUnpackTest, PackUnpackUnormOverflow)
 TEST_P(PackUnpackTest, PackUnpackSnormOverflow)
 {
     // http://anglebug.com/4092
-    ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
+    ANGLE_SKIP_TEST_IF((IsAndroid() && IsVulkan()) || isSwiftshader());
     // Expect the shader to clamp the input to [-1, 1]
     compareBeforeAfter(mSNormProgram, 67000.0f, -67000.0f, 1.0f, -1.0f);
 }

src/tests/gl_tests/ProgramInterfaceTest.cpp

@@ -122,6 +122,8 @@ TEST_P(ProgramInterfaceTestES31, GetResourceName)
 // Tests glGetProgramResourceLocation.
 TEST_P(ProgramInterfaceTestES31, GetResourceLocation)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     constexpr char kVS[] =
         "#version 310 es\n"
         "precision highp float;\n"
@@ -181,6 +183,8 @@ TEST_P(ProgramInterfaceTestES31, GetResourceLocation)
 // Tests glGetProgramResource.
 TEST_P(ProgramInterfaceTestES31, GetResource)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     constexpr char kVS[] =
         "#version 310 es\n"
         "precision highp float;\n"

src/tests/gl_tests/SamplersTest.cpp

@@ -40,6 +40,8 @@ class SamplersTest : public ANGLETest
 // Verify that samplerParameterf supports TEXTURE_MAX_ANISOTROPY_EXT valid values.
 TEST_P(SamplersTest, ValidTextureSamplerMaxAnisotropyExt)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     GLSampler sampler;
 
     // Exact min
@@ -60,6 +62,8 @@ TEST_P(SamplersTest, ValidTextureSamplerMaxAnisotropyExt)
 // GL_TEXTURE_MAX_ANISOTROPY_EXT
 TEST_P(SamplersTest, InvalidUnderTextureSamplerMaxAnisotropyExt)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     GLSampler sampler;
 
     // Under min
@@ -70,6 +74,8 @@ TEST_P(SamplersTest, InvalidUnderTextureSamplerMaxAnisotropyExt)
 // GL_TEXTURE_MAX_ANISOTROPY_EXT
 TEST_P(SamplersTest, InvalidOverTextureSamplerMaxAnisotropyExt)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     GLSampler sampler;
 
     GLfloat maxValue = 0.0f;

src/tests/gl_tests/ShaderStorageBufferTest.cpp

@@ -413,6 +413,8 @@ void main()
 // Tests reading and writing to a shader storage buffer bound at an offset.
 TEST_P(ShaderStorageBufferTest31, ShaderStorageBufferReadWriteOffset)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     constexpr char kCS[] = R"(#version 310 es
 layout(local_size_x=1, local_size_y=1, local_size_z=1) in;
 

src/tests/gl_tests/StateChangeTest.cpp

@@ -1798,6 +1798,8 @@ TEST_P(SimpleStateChangeTest, DrawElementsUBYTEX2ThenDrawElementsUSHORT)
 // verify all the rendering results are the same.
 TEST_P(SimpleStateChangeTest, DrawRepeatUnalignedVboChange)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader() && IsWindows());
     const int kRepeat = 2;
 
     // set up VBO, colorVBO is unaligned

src/tests/gl_tests/VulkanExternalImageTest.cpp

@@ -57,6 +57,8 @@ class VulkanExternalImageTest : public ANGLETest
 // glImportMemoryFdEXT must be able to import a valid opaque fd.
 TEST_P(VulkanExternalImageTest, ShouldImportMemoryOpaqueFd)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_EXT_memory_object_fd"));
 
     VulkanExternalHelper helper;
@@ -93,6 +95,8 @@ TEST_P(VulkanExternalImageTest, ShouldImportMemoryOpaqueFd)
 // glImportSemaphoreFdEXT must be able to import a valid opaque fd.
 TEST_P(VulkanExternalImageTest, ShouldImportSemaphoreOpaqueFd)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_EXT_semaphore_fd"));
 
     VulkanExternalHelper helper;
@@ -122,6 +126,8 @@ TEST_P(VulkanExternalImageTest, ShouldImportSemaphoreOpaqueFd)
 // Test creating and clearing a simple RGBA8 texture in a opaque fd.
 TEST_P(VulkanExternalImageTest, ShouldClearOpaqueFdRGBA8)
 {
+    // http://anglebug.com/4092
+    ANGLE_SKIP_TEST_IF(isSwiftshader());
     ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_EXT_memory_object_fd"));
 
     VulkanExternalHelper helper;

src/tests/test_utils/ANGLETest.h

@@ -311,6 +311,12 @@ class ANGLETestBase
 
     static void ReleaseFixtures();
 
+    bool isSwiftshader() const
+    {
+        return mCurrentParams->eglParameters.deviceType ==
+               EGL_PLATFORM_ANGLE_DEVICE_TYPE_SWIFTSHADER_ANGLE;
+    }
+
   protected:
     void ANGLETestSetUp();
     void ANGLETestTearDown();

src/tests/test_utils/angle_test_configs.cpp

@@ -660,6 +660,11 @@ PlatformParameters ES1_VULKAN_NULL()
     return PlatformParameters(1, 0, egl_platform::VULKAN_NULL());
 }
 
+PlatformParameters ES1_VULKAN_SWIFTSHADER()
+{
+    return PlatformParameters(1, 0, egl_platform::VULKAN_SWIFTSHADER());
+}
+
 PlatformParameters ES2_VULKAN()
 {
     return PlatformParameters(2, 0, egl_platform::VULKAN());
@@ -670,6 +675,11 @@ PlatformParameters ES2_VULKAN_NULL()
     return PlatformParameters(2, 0, egl_platform::VULKAN_NULL());
 }
 
+PlatformParameters ES2_VULKAN_SWIFTSHADER()
+{
+    return PlatformParameters(2, 0, egl_platform::VULKAN_SWIFTSHADER());
+}
+
 PlatformParameters ES3_VULKAN()
 {
     return PlatformParameters(3, 0, egl_platform::VULKAN());
@@ -680,6 +690,11 @@ PlatformParameters ES3_VULKAN_NULL()
     return PlatformParameters(3, 0, egl_platform::VULKAN_NULL());
 }
 
+PlatformParameters ES3_VULKAN_SWIFTSHADER()
+{
+    return PlatformParameters(3, 0, egl_platform::VULKAN_SWIFTSHADER());
+}
+
 PlatformParameters ES31_VULKAN()
 {
     return PlatformParameters(3, 1, egl_platform::VULKAN());
@@ -690,6 +705,11 @@ PlatformParameters ES31_VULKAN_NULL()
     return PlatformParameters(3, 1, egl_platform::VULKAN_NULL());
 }
 
+PlatformParameters ES31_VULKAN_SWIFTSHADER()
+{
+    return PlatformParameters(3, 1, egl_platform::VULKAN_SWIFTSHADER());
+}
+
 PlatformParameters ES2_WGL()
 {
     return PlatformParameters(2, 0, GLESDriverType::SystemWGL);

src/tests/test_utils/angle_test_configs.h

@@ -174,12 +174,16 @@ PlatformParameters ES31_NULL();
 
 PlatformParameters ES1_VULKAN();
 PlatformParameters ES1_VULKAN_NULL();
+PlatformParameters ES1_VULKAN_SWIFTSHADER();
 PlatformParameters ES2_VULKAN();
 PlatformParameters ES2_VULKAN_NULL();
+PlatformParameters ES2_VULKAN_SWIFTSHADER();
 PlatformParameters ES3_VULKAN();
 PlatformParameters ES3_VULKAN_NULL();
+PlatformParameters ES3_VULKAN_SWIFTSHADER();
 PlatformParameters ES31_VULKAN();
 PlatformParameters ES31_VULKAN_NULL();
+PlatformParameters ES31_VULKAN_SWIFTSHADER();
 
 PlatformParameters ES2_WGL();
 PlatformParameters ES3_WGL();

src/tests/test_utils/angle_test_instantiate.cpp

@@ -454,6 +454,15 @@ bool IsPlatformAvailable(const PlatformParameters &param)
         case EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE:
 #if !defined(ANGLE_ENABLE_VULKAN)
             return false;
+#elif defined(ANGLE_IS_32_BIT_CPU)
+            // http://anglebug.com/4092
+            //  Currently hitting crashes in SwS w/ 32-bit Windows so skipping for now
+            if (IsWindows() && (param.eglParameters.deviceType ==
+                                EGL_PLATFORM_ANGLE_DEVICE_TYPE_SWIFTSHADER_ANGLE))
+            {
+                return false;
+            }
+            break;
 #else
             break;
 #endif

src/tests/test_utils/angle_test_instantiate.h

@@ -100,14 +100,17 @@ struct CombinedPrintToStringParamName
     INSTANTIATE_TEST_SUITE_P(, testName, ANGLE_INSTANTIATE_TEST_PLATFORMS(testName), \
                              testing::PrintToStringParamName())
 
-#define ANGLE_ALL_TEST_PLATFORMS_ES1 ES1_D3D11(), ES1_OPENGL(), ES1_OPENGLES(), ES1_VULKAN()
+#define ANGLE_ALL_TEST_PLATFORMS_ES1 \
+    ES1_D3D11(), ES1_OPENGL(), ES1_OPENGLES(), ES1_VULKAN(), ES1_VULKAN_SWIFTSHADER()
 
 #define ANGLE_ALL_TEST_PLATFORMS_ES2 \
-    ES2_D3D9(), ES2_D3D11(), ES2_OPENGL(), ES2_OPENGLES(), ES2_VULKAN()
+    ES2_D3D9(), ES2_D3D11(), ES2_OPENGL(), ES2_OPENGLES(), ES2_VULKAN(), ES2_VULKAN_SWIFTSHADER()
 
-#define ANGLE_ALL_TEST_PLATFORMS_ES3 ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES(), ES3_VULKAN()
+#define ANGLE_ALL_TEST_PLATFORMS_ES3 \
+    ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES(), ES3_VULKAN(), ES3_VULKAN_SWIFTSHADER()
 
-#define ANGLE_ALL_TEST_PLATFORMS_ES31 ES31_D3D11(), ES31_OPENGL(), ES31_OPENGLES(), ES31_VULKAN()
+#define ANGLE_ALL_TEST_PLATFORMS_ES31 \
+    ES31_D3D11(), ES31_OPENGL(), ES31_OPENGLES(), ES31_VULKAN(), ES31_VULKAN_SWIFTSHADER()
 
 #define ANGLE_ALL_TEST_PLATFORMS_NULL ES2_NULL(), ES3_NULL(), ES31_NULL()