Improve test expectations overlap check.

src/tests/test_expectations/GPUTestExpectationsParser.cpp

@@ -236,6 +236,38 @@ inline Token ParseToken(const std::string &word)
     }
     return kTokenWord;
 }
+
+bool ConditionArrayIsSubset(const GPUTestConfig::ConditionArray &subset,
+                            const GPUTestConfig::ConditionArray &superset)
+{
+    for (size_t subsetCondition : subset)
+    {
+        bool foundCondition = false;
+        for (size_t supersetCondition : superset)
+        {
+            if (subsetCondition == supersetCondition)
+            {
+                foundCondition = true;
+                break;
+            }
+        }
+
+        if (!foundCondition)
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+// If one array is completely contained within the other, then we say the conditions overlap.
+bool ConditionsOverlap(const GPUTestConfig::ConditionArray &conditionsI,
+                       const GPUTestConfig::ConditionArray &conditionsJ)
+{
+    return ConditionArrayIsSubset(conditionsI, conditionsJ) ||
+           ConditionArrayIsSubset(conditionsJ, conditionsI);
+}
 }  // anonymous namespace
 
 const char *GetConditionName(uint32_t condition)
@@ -601,10 +633,13 @@ bool GPUTestExpectationsParser::detectConflictsBetweenEntries()
     {
         for (size_t j = i + 1; j < mEntries.size(); ++j)
         {
-            if (mEntries[i].testName == mEntries[j].testName)
+            const GPUTestExpectationEntry &entryI = mEntries[i];
+            const GPUTestExpectationEntry &entryJ = mEntries[j];
+            if (entryI.testName == entryJ.testName &&
+                ConditionsOverlap(entryI.conditions, entryJ.conditions))
             {
-                pushErrorMessage(kErrorMessage[kErrorEntriesOverlap], mEntries[i].lineNumber,
-                                 mEntries[j].lineNumber);
+                pushErrorMessage(kErrorMessage[kErrorEntriesOverlap], entryI.lineNumber,
+                                 entryJ.lineNumber);
                 rt = true;
             }
         }

src/tests/test_expectations/GPUTestExpectationsParser_unittest.cpp

@@ -411,6 +411,20 @@ TEST_P(GPUTestExpectationsParserTest, GPUTestExpectationsParserOverrideExpectati
     EXPECT_TRUE(parser.getUnusedExpectationsMessages().empty());
 }
 
+// Tests that overlap checking doesn't generate false positives.
+TEST_P(GPUTestExpectationsParserTest, OverlapConditions)
+{
+    std::string lines = R"(
+100 NVIDIA VULKAN : dEQP-GLES31.functional.layout_binding.ubo.* = SKIP
+100 NVIDIA D3D11 : dEQP-GLES31.functional.layout_binding.ubo.* = SKIP)";
+
+    ASSERT_TRUE(load(lines));
+    ASSERT_TRUE(parser.getErrorMessages().empty());
+
+    EXPECT_EQ(get("dEQP-GLES31.functional.layout_binding.ubo.vertex_binding_max"),
+              GPUTestExpectationsParser::kGpuTestSkip);
+}
+
 std::string ConditionTestTypeName(testing::TestParamInfo<ConditionTestType> testParamInfo)
 {
     if (testParamInfo.param == ConditionTestType::OnLoad)