[CK_BUILDER] Factory tests (#3071)

This pull requests adds some initial "factory tests" - these check that the instances which are used in MIOpen are actually present in CK. The main reason for this is documentation and sanity checking. Its likely that these tests get outdated fast, so we'll have to maintain them, but fortunately this is quite straight forward and shouldn't take a lot of time once they are in place.

experimental/builder/test/testing_utils.cpp

@@ -1,21 +1,18 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) 2018-2025, Advanced Micro Devices, Inc. All rights reserved.
 
-#include <string>
-#include <sstream>
-#include <vector>
-#include <algorithm>
-#include <unistd.h>
+#include "testing_utils.hpp"
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
-#include "testing_utils.hpp"
+#include <unistd.h>
+#include <string>
+#include <sstream>
+#include <ostream>
+#include <vector>
+#include <algorithm>
 
 namespace ck_tile::test {
 
-namespace {
-
-} // namespace
-
 // Wagner-Fischer Algorithm for Computing Edit Distance and Inline Diff
 //
 // OUTPUT FORMAT: [expected|actual] for differences, plain text for matches
@@ -216,4 +213,88 @@ void StringEqWithDiffMatcher::DescribeNegationTo(std::ostream* os) const
     return ::testing::MakeMatcher(new StringEqWithDiffMatcher(expected));
 }
 
+std::ostream& operator<<(std::ostream& os, const InstanceSet& set)
+{
+    // These sets can grow very large, and so its not very nice or useful to print them
+    // in the event of a mismatch. Just print a brief description here, and use
+    // InstancesMatcher to print a more useful message.
+    return (os << "(set of " << set.instances.size() << " instances)");
+}
+
+InstanceMatcher::InstanceMatcher(const InstanceSet& expected) : expected_(expected) {}
+
+::testing::Matcher<InstanceSet> InstancesMatch(const InstanceSet& expected)
+{
+    return ::testing::MakeMatcher(new InstanceMatcher(expected));
+}
+
+bool InstanceMatcher::MatchAndExplain(InstanceSet actual,
+                                      ::testing::MatchResultListener* listener) const
+{
+    if(actual.instances == expected_.instances)
+    {
+        return true;
+    }
+
+    if(listener->IsInterested())
+    {
+        std::vector<std::string> instances;
+        std::set_difference(expected_.instances.begin(),
+                            expected_.instances.end(),
+                            actual.instances.begin(),
+                            actual.instances.end(),
+                            std::back_inserter(instances));
+
+        *listener << "\n";
+
+        if(instances.size() > 0)
+        {
+            *listener << " Missing: " << instances.size() << "\n";
+            for(const auto& instance : instances)
+            {
+                if(instance == "")
+                {
+                    *listener << "- (empty string)\n";
+                }
+                else
+                {
+                    *listener << "- " << instance << "\n";
+                }
+            }
+        }
+
+        instances.clear();
+        std::set_difference(actual.instances.begin(),
+                            actual.instances.end(),
+                            expected_.instances.begin(),
+                            expected_.instances.end(),
+                            std::back_inserter(instances));
+
+        if(instances.size() > 0)
+        {
+            *listener << "Unexpected: " << instances.size() << "\n";
+            for(const auto& instance : instances)
+            {
+                if(instance == "")
+                {
+                    *listener << "- (empty string)\n";
+                }
+                else
+                {
+                    *listener << "- " << instance << "\n";
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
+void InstanceMatcher::DescribeTo(std::ostream* os) const { *os << expected_; }
+
+void InstanceMatcher::DescribeNegationTo(std::ostream* os) const
+{
+    *os << "is not equal to " << expected_;
+}
+
 } // namespace ck_tile::test