[llvm-exegesis] Add clustering test.

[courbet]

Summary

To show that dbscan is insensitive to the order of the points.

[courbet]

Thanks.

llvm/unittests/tools/llvm-exegesis/ClusteringTest.cpp

 namespace exegesis {
 
 namespace {
 
 using testing::Field;
 using testing::UnorderedElementsAre;
 using testing::UnorderedElementsAreArray;
 
+static constexpr auto HasPoints = [](const std::vector<int> &Indices) {
+  return Field(&InstructionBenchmarkClustering::Cluster::PointIndices,
+                 UnorderedElementsAreArray(Indices));
+};
+
 TEST(ClusteringTest, Clusters3D) {
   std::vector<InstructionBenchmark> Points(6);
 
   // Cluster around (x=0, y=1, z=2): points {0, 3}.
   Points[0].Measurements = {
       {"x", 0.01, 0.0}, {"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
   Points[3].Measurements = {
       {"x", -0.01, 0.0}, {"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
   // Cluster around (x=1, y=1, z=2): points {1, 4}.
   Points[1].Measurements = {
       {"x", 1.01, 0.0}, {"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
   Points[4].Measurements = {
       {"x", 0.99, 0.0}, {"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
   // Cluster around (x=0, y=0, z=0): points {5}, marked as noise.
   Points[5].Measurements = {
       {"x", 0.0, 0.0}, {"y", 0.01, 0.0}, {"z", -0.02, 0.0}};
   // Error cluster: points {2}
   Points[2].Error = "oops";
 
-  auto HasPoints = [](const std::vector<int> &Indices) {
-    return Field(&InstructionBenchmarkClustering::Cluster::PointIndices,
-                 UnorderedElementsAreArray(Indices));
-  };
-
   auto Clustering = InstructionBenchmarkClustering::create(Points, 2, 0.25);
   ASSERT_TRUE((bool)Clustering);
   EXPECT_THAT(Clustering.get().getValidClusters(),
               UnorderedElementsAre(HasPoints({0, 3}), HasPoints({1, 4})));
   EXPECT_THAT(Clustering.get().getCluster(
                   InstructionBenchmarkClustering::ClusterId::noise()),
               HasPoints({5}));
   EXPECT_THAT(Clustering.get().getCluster(
TEST(ClusteringTest, Ordering) {
 
   ASSERT_LT(InstructionBenchmarkClustering::ClusterId::makeValid(2),
             InstructionBenchmarkClustering::ClusterId::error());
 
   ASSERT_LT(InstructionBenchmarkClustering::ClusterId::noise(),
             InstructionBenchmarkClustering::ClusterId::error());
 }
 
+TEST(ClusteringTest, Ordering1) {
+  std::vector<InstructionBenchmark> Points(3);
+
+  Points[0].Measurements = {
+      {"x", 0.0, 0.0}};
+  Points[1].Measurements = {
+      {"x", 1.0, 0.0}};
+  Points[2].Measurements = {
+      {"x", 2.0, 0.0}};
+
+  auto Clustering = InstructionBenchmarkClustering::create(Points, 2, 1.1);
+  ASSERT_TRUE((bool)Clustering);
+  EXPECT_THAT(Clustering.get().getValidClusters(),
+              UnorderedElementsAre(HasPoints({0, 1, 2})));
+}
+
+TEST(ClusteringTest, Ordering2) {
+  std::vector<InstructionBenchmark> Points(3);
+
+  Points[0].Measurements = {
+      {"x", 0.0, 0.0}};
+  Points[1].Measurements = {
+      {"x", 2.0, 0.0}};
+  Points[2].Measurements = {
+      {"x", 1.0, 0.0}};
+
+  auto Clustering = InstructionBenchmarkClustering::create(Points, 2, 1.1);
+  ASSERT_TRUE((bool)Clustering);
+  EXPECT_THAT(Clustering.get().getValidClusters(),
+              UnorderedElementsAre(HasPoints({0, 1, 2})));
+}
+
 } // namespace
 } // namespace exegesis
 } // namespace llvm