[llvm] [orc-rt] Use the Error matchers in SimpleSymbolTableTest (PR #228343)

[Lang Hames via llvm-commits]

https://github.com/lhames created https://github.com/llvm/llvm-project/pull/228343

Use the Error matchers introduced in 4c8a437d0487 to clean up error checks in SimpleSymbolTableTest.

The isA<StringError>() checks become Failed<StringError>(), with the message checks folded in as a Property matcher on StringError::toString so that both the type and the message are still verified.

>From 6c2f361a0c978e380296c7a11b403635290a9da3 Mon Sep 17 00:00:00 2001
From: Lang Hames <lhames at gmail.com>
Date: Thu, 1 Oct 2026 09:28:40 +1000
Subject: [PATCH] [orc-rt] Use the Error matchers in SimpleSymbolTableTest

Use the Error matchers introduced in 4c8a437d0487 to clean up error
checks in SimpleSymbolTableTest.

The isA<StringError>() checks become Failed<StringError>(), with the
message checks folded in as a Property matcher on StringError::toString
so that both the type and the message are still verified.
---
 .../unit/bedrock/SimpleSymbolTableTest.cpp    | 52 ++++++++++---------
 1 file changed, 27 insertions(+), 25 deletions(-)

diff --git a/orc-rt/test/unit/bedrock/SimpleSymbolTableTest.cpp b/orc-rt/test/unit/bedrock/SimpleSymbolTableTest.cpp
index 1276d1d7b832166..1e2d9d06974f239 100644
--- a/orc-rt/test/unit/bedrock/SimpleSymbolTableTest.cpp
+++ b/orc-rt/test/unit/bedrock/SimpleSymbolTableTest.cpp
@@ -11,12 +11,19 @@
 //===----------------------------------------------------------------------===//
 
 #include "orc-rt/bedrock/SimpleSymbolTable.h"
+
+#include "ErrorMatchers.h"
 #include "gtest/gtest.h"
 
 #include <set>
 #include <string>
 
 using namespace orc_rt;
+using namespace orc_rt::test;
+
+using ::testing::AllOf;
+using ::testing::HasSubstr;
+using ::testing::Property;
 
 TEST(SimpleSymbolTableTest, EmptyByDefault) {
   SimpleSymbolTable ST;
@@ -32,8 +39,8 @@ TEST(SimpleSymbolTableTest, AddSymbolsUnique) {
       {SymbolNameSpec::linker("orc_rt_A"), &X},
       {SymbolNameSpec::linker("orc_rt_B"), &Y}};
 
-  auto Err = ST.addUnique(Syms);
-  EXPECT_FALSE(Err) << "Unexpected error adding unique symbols";
+  EXPECT_THAT_ERROR(ST.addUnique(Syms), Succeeded())
+      << "Unexpected error adding unique symbols";
 
   EXPECT_EQ(ST.size(), 2U);
   EXPECT_FALSE(ST.empty());
@@ -50,7 +57,7 @@ TEST(SimpleSymbolTableTest, AddConstPointers) {
   std::pair<SymbolNameSpec, const void *> Syms[] = {
       {SymbolNameSpec::linker("orc_rt_A"), &X},
       {SymbolNameSpec::linker("orc_rt_B"), &Y}};
-  cantFail(ST.addUnique(Syms));
+  ASSERT_THAT_ERROR(ST.addUnique(Syms), Succeeded());
 
   EXPECT_EQ(ST.at(SymbolNameSpec::linker("orc_rt_A")), &X);
   EXPECT_EQ(ST.at(SymbolNameSpec::linker("orc_rt_B")), &Y);
@@ -65,8 +72,8 @@ TEST(SimpleSymbolTableTest, AddSymbolsUniqueMultipleCalls) {
   std::pair<SymbolNameSpec, void *> Second[] = {
       {SymbolNameSpec::linker("orc_rt_B"), &Y}};
 
-  cantFail(ST.addUnique(First));
-  cantFail(ST.addUnique(Second));
+  ASSERT_THAT_ERROR(ST.addUnique(First), Succeeded());
+  ASSERT_THAT_ERROR(ST.addUnique(Second), Succeeded());
 
   EXPECT_EQ(ST.size(), 2U);
   EXPECT_EQ(ST.at(SymbolNameSpec::linker("orc_rt_A")), &X);
@@ -79,15 +86,13 @@ TEST(SimpleSymbolTableTest, AddSymbolsUniqueDuplicateRejected) {
 
   std::pair<SymbolNameSpec, void *> First[] = {
       {SymbolNameSpec::linker("orc_rt_A"), &X}};
-  cantFail(ST.addUnique(First));
+  ASSERT_THAT_ERROR(ST.addUnique(First), Succeeded());
 
   std::pair<SymbolNameSpec, void *> Second[] = {
       {SymbolNameSpec::linker("orc_rt_A"), &Y}};
-  auto Err = ST.addUnique(Second);
-  EXPECT_TRUE(Err.isA<StringError>());
-
-  auto ErrMsg = toString(std::move(Err));
-  EXPECT_NE(ErrMsg.find("orc_rt_A"), std::string::npos)
+  EXPECT_THAT_ERROR(ST.addUnique(Second),
+                    Failed<StringError>(Property(&StringError::toString,
+                                                 HasSubstr("orc_rt_A"))))
       << "Error message should mention the duplicate symbol name";
 
   // Original not overwritten.
@@ -101,17 +106,15 @@ TEST(SimpleSymbolTableTest, AddSymbolsUniqueMultipleDuplicates) {
   std::pair<SymbolNameSpec, void *> First[] = {
       {SymbolNameSpec::linker("orc_rt_A"), &X},
       {SymbolNameSpec::linker("orc_rt_B"), &Y}};
-  cantFail(ST.addUnique(First));
+  ASSERT_THAT_ERROR(ST.addUnique(First), Succeeded());
 
   std::pair<SymbolNameSpec, void *> Second[] = {
       {SymbolNameSpec::linker("orc_rt_A"), &Z},
       {SymbolNameSpec::linker("orc_rt_B"), &Z}};
-  auto Err = ST.addUnique(Second);
-  EXPECT_TRUE(Err.isA<StringError>());
-
-  auto ErrMsg = toString(std::move(Err));
-  EXPECT_NE(ErrMsg.find("orc_rt_A"), std::string::npos);
-  EXPECT_NE(ErrMsg.find("orc_rt_B"), std::string::npos);
+  EXPECT_THAT_ERROR(ST.addUnique(Second),
+                    Failed<StringError>(Property(
+                        &StringError::toString,
+                        AllOf(HasSubstr("orc_rt_A"), HasSubstr("orc_rt_B")))));
 
   // Originals not overwritten.
   EXPECT_EQ(ST.at(SymbolNameSpec::linker("orc_rt_A")), &X);
@@ -124,15 +127,13 @@ TEST(SimpleSymbolTableTest, AddSymbolsUniqueAllOrNothing) {
 
   std::pair<SymbolNameSpec, void *> First[] = {
       {SymbolNameSpec::linker("orc_rt_existing"), &X}};
-  cantFail(ST.addUnique(First));
+  ASSERT_THAT_ERROR(ST.addUnique(First), Succeeded());
 
   // One new, one incompatible — neither should be added.
   std::pair<SymbolNameSpec, void *> Second[] = {
       {SymbolNameSpec::linker("orc_rt_new"), &Y},
       {SymbolNameSpec::linker("orc_rt_existing"), &Z}};
-  auto Err = ST.addUnique(Second);
-  EXPECT_TRUE(Err.isA<StringError>());
-  consumeError(std::move(Err));
+  EXPECT_THAT_ERROR(ST.addUnique(Second), Failed<StringError>());
 
   EXPECT_EQ(ST.size(), 1U);
   EXPECT_EQ(ST.at(SymbolNameSpec::linker("orc_rt_existing")), &X);
@@ -144,8 +145,9 @@ TEST(SimpleSymbolTableTest, AddUniqueSameAddressSucceeds) {
   int X = 0;
   std::pair<SymbolNameSpec, void *> Syms[] = {
       {SymbolNameSpec::linker("orc_rt_A"), &X}};
-  cantFail(ST.addUnique(Syms));
-  cantFail(ST.addUnique(Syms)); // Same name, same address — should succeed.
+  ASSERT_THAT_ERROR(ST.addUnique(Syms), Succeeded());
+  // Same name, same address — should succeed.
+  ASSERT_THAT_ERROR(ST.addUnique(Syms), Succeeded());
   EXPECT_EQ(ST.size(), 1U);
   EXPECT_EQ(ST.at(SymbolNameSpec::linker("orc_rt_A")), &X);
 }
@@ -157,7 +159,7 @@ TEST(SimpleSymbolTableTest, Iteration) {
       {SymbolNameSpec::linker("orc_rt_A"), &X},
       {SymbolNameSpec::linker("orc_rt_B"), &Y},
       {SymbolNameSpec::linker("orc_rt_C"), &Z}};
-  cantFail(ST.addUnique(Syms));
+  ASSERT_THAT_ERROR(ST.addUnique(Syms), Succeeded());
 
   std::set<std::string> Names;
   for (auto &[Name, Addr] : ST)