diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/client/anonymous_tokens_rsa_bssa_client_test.cc b/quiche/blind_sign_auth/anonymous_tokens/cpp/client/anonymous_tokens_rsa_bssa_client_test.cc
index 37d3a01..25cf416 100644
--- a/quiche/blind_sign_auth/anonymous_tokens/cpp/client/anonymous_tokens_rsa_bssa_client_test.cc
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/client/anonymous_tokens_rsa_bssa_client_test.cc
@@ -36,7 +36,6 @@
 namespace {
 
 using ::testing::SizeIs;
-using quiche::test::StatusIs;
 
 // Returns a fixed public private key pair by calling GetStrongRsaKeys4096().
 absl::StatusOr<std::pair<RSABlindSignaturePublicKey, RSAPrivateKey>>
@@ -117,44 +116,49 @@
 
 TEST(CreateAnonymousTokensRsaBssaClientTest, Success) {
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto rsa_key, CreateClientTestKey());
-  QUICHE_EXPECT_OK(AnonymousTokensRsaBssaClient::Create(rsa_key.first));
+  EXPECT_TRUE(AnonymousTokensRsaBssaClient::Create(rsa_key.first).ok());
 }
 
 TEST(CreateAnonymousTokensRsaBssaClientTest, InvalidUseCase) {
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto rsa_key,
                                    CreateClientTestKey("INVALID_USE_CASE"));
-  EXPECT_THAT(AnonymousTokensRsaBssaClient::Create(rsa_key.first),
-              StatusIs(absl::StatusCode::kInvalidArgument));
+  absl::StatusOr<std::unique_ptr<AnonymousTokensRsaBssaClient>> client =
+      AnonymousTokensRsaBssaClient::Create(rsa_key.first);
+  EXPECT_EQ(client.status().code(), absl::StatusCode::kInvalidArgument);
 }
 
 TEST(CreateAnonymousTokensRsaBssaClientTest, NotAUseCase) {
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto rsa_key,
                                    CreateClientTestKey("NOT_A_USE_CASE"));
-  EXPECT_THAT(AnonymousTokensRsaBssaClient::Create(rsa_key.first),
-              StatusIs(absl::StatusCode::kInvalidArgument));
+  absl::StatusOr<std::unique_ptr<AnonymousTokensRsaBssaClient>> client =
+      AnonymousTokensRsaBssaClient::Create(rsa_key.first);
+  EXPECT_EQ(client.status().code(), absl::StatusCode::kInvalidArgument);
 }
 
 TEST(CreateAnonymousTokensRsaBssaClientTest, InvalidKeyVersion) {
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(auto rsa_key,
                                    CreateClientTestKey("TEST_USE_CASE", 0));
-  EXPECT_THAT(AnonymousTokensRsaBssaClient::Create(rsa_key.first),
-              StatusIs(absl::StatusCode::kInvalidArgument));
+  absl::StatusOr<std::unique_ptr<AnonymousTokensRsaBssaClient>> client =
+      AnonymousTokensRsaBssaClient::Create(rsa_key.first);
+  EXPECT_EQ(client.status().code(), absl::StatusCode::kInvalidArgument);
 }
 
 TEST(CreateAnonymousTokensRsaBssaClientTest, InvalidMessageMaskType) {
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto rsa_key,
       CreateClientTestKey("TEST_USE_CASE", 0, AT_MESSAGE_MASK_TYPE_UNDEFINED));
-  EXPECT_THAT(AnonymousTokensRsaBssaClient::Create(rsa_key.first),
-              StatusIs(absl::StatusCode::kInvalidArgument));
+  absl::StatusOr<std::unique_ptr<AnonymousTokensRsaBssaClient>> client =
+      AnonymousTokensRsaBssaClient::Create(rsa_key.first);
+  EXPECT_EQ(client.status().code(), absl::StatusCode::kInvalidArgument);
 }
 
 TEST(CreateAnonymousTokensRsaBssaClientTest, InvalidMessageMaskSize) {
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto rsa_key,
       CreateClientTestKey("TEST_USE_CASE", 0, AT_MESSAGE_MASK_CONCAT, 0));
-  EXPECT_THAT(AnonymousTokensRsaBssaClient::Create(rsa_key.first),
-              StatusIs(absl::StatusCode::kInvalidArgument));
+  absl::StatusOr<std::unique_ptr<AnonymousTokensRsaBssaClient>> client =
+      AnonymousTokensRsaBssaClient::Create(rsa_key.first);
+  EXPECT_EQ(client.status().code(), absl::StatusCode::kInvalidArgument);
 }
 
 class AnonymousTokensRsaBssaClientTest : public testing::Test {
@@ -180,7 +184,7 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(AnonymousTokensSignResponse response,
                                    CreateResponse(request, private_key_));
   EXPECT_THAT(response.anonymous_tokens(), SizeIs(1));
-  QUICHE_EXPECT_OK(client_->ProcessResponse(response));
+  EXPECT_TRUE(client_->ProcessResponse(response).ok());
 }
 
 TEST_F(AnonymousTokensRsaBssaClientTest, SuccessMultipleMessages) {
@@ -192,7 +196,7 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(AnonymousTokensSignResponse response,
                                    CreateResponse(request, private_key_));
   EXPECT_THAT(response.anonymous_tokens(), SizeIs(4));
-  QUICHE_EXPECT_OK(client_->ProcessResponse(response));
+  EXPECT_TRUE(client_->ProcessResponse(response).ok());
 }
 
 TEST_F(AnonymousTokensRsaBssaClientTest, EnsureRandomTokens) {
@@ -219,8 +223,9 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::vector<PlaintextMessageWithPublicMetadata> input_messages,
       CreateInput({}));
-  EXPECT_THAT(client_->CreateRequest(input_messages),
-              StatusIs(absl::StatusCode::kInvalidArgument));
+  absl::StatusOr<AnonymousTokensSignRequest> request =
+      client_->CreateRequest(input_messages);
+  EXPECT_EQ(request.status().code(), absl::StatusCode::kInvalidArgument);
 }
 
 TEST_F(AnonymousTokensRsaBssaClientTest, NotYetValidKey) {
@@ -235,8 +240,9 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::vector<PlaintextMessageWithPublicMetadata> input_messages,
       CreateInput({"message"}));
-  EXPECT_THAT(client->CreateRequest(input_messages),
-              StatusIs(absl::StatusCode::kFailedPrecondition));
+  absl::StatusOr<AnonymousTokensSignRequest> request =
+      client->CreateRequest(input_messages);
+  EXPECT_EQ(request.status().code(), absl::StatusCode::kFailedPrecondition);
 }
 
 TEST_F(AnonymousTokensRsaBssaClientTest, ExpiredKey) {
@@ -250,23 +256,27 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::vector<PlaintextMessageWithPublicMetadata> input_messages,
       CreateInput({"message"}));
-  EXPECT_THAT(client->CreateRequest(input_messages),
-              StatusIs(absl::StatusCode::kFailedPrecondition));
+  absl::StatusOr<AnonymousTokensSignRequest> request =
+      client->CreateRequest(input_messages);
+  EXPECT_EQ(request.status().code(), absl::StatusCode::kFailedPrecondition);
 }
 
 TEST_F(AnonymousTokensRsaBssaClientTest, CreateRequestTwice) {
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       std::vector<PlaintextMessageWithPublicMetadata> input_messages,
       CreateInput({"message"}));
-  QUICHE_EXPECT_OK(client_->CreateRequest(input_messages));
-  EXPECT_THAT(client_->CreateRequest(input_messages),
-              StatusIs(absl::StatusCode::kFailedPrecondition));
+  EXPECT_TRUE(client_->CreateRequest(input_messages).ok());
+  absl::StatusOr<AnonymousTokensSignRequest> request =
+      client_->CreateRequest(input_messages);
+  EXPECT_EQ(request.status().code(), absl::StatusCode::kFailedPrecondition);
 }
 
 TEST_F(AnonymousTokensRsaBssaClientTest, ProcessResponseWithoutCreateRequest) {
   AnonymousTokensSignResponse response;
-  EXPECT_THAT(client_->ProcessResponse(response),
-              StatusIs(absl::StatusCode::kFailedPrecondition));
+  absl::StatusOr<std::vector<RSABlindSignatureTokenWithInput>>
+      processed_response = client_->ProcessResponse(response);
+  EXPECT_EQ(processed_response.status().code(),
+            absl::StatusCode::kFailedPrecondition);
 }
 
 TEST_F(AnonymousTokensRsaBssaClientTest, ProcessEmptyResponse) {
@@ -276,8 +286,10 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(AnonymousTokensSignRequest request,
                                    client_->CreateRequest(input_messages));
   AnonymousTokensSignResponse response;
-  EXPECT_THAT(client_->ProcessResponse(response),
-              StatusIs(absl::StatusCode::kInvalidArgument));
+  absl::StatusOr<std::vector<RSABlindSignatureTokenWithInput>>
+      processed_response = client_->ProcessResponse(response);
+  EXPECT_EQ(processed_response.status().code(),
+            absl::StatusCode::kInvalidArgument);
 }
 
 TEST_F(AnonymousTokensRsaBssaClientTest, ProcessResponseWithBadUseCase) {
@@ -289,8 +301,10 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(AnonymousTokensSignResponse response,
                                    CreateResponse(request, private_key_));
   response.mutable_anonymous_tokens(0)->set_use_case("TEST_USE_CASE_2");
-  EXPECT_THAT(client_->ProcessResponse(response),
-              StatusIs(absl::StatusCode::kInvalidArgument));
+  absl::StatusOr<std::vector<RSABlindSignatureTokenWithInput>>
+      processed_response = client_->ProcessResponse(response);
+  EXPECT_EQ(processed_response.status().code(),
+            absl::StatusCode::kInvalidArgument);
 }
 
 TEST_F(AnonymousTokensRsaBssaClientTest, ProcessResponseWithBadKeyVersion) {
@@ -302,8 +316,10 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(AnonymousTokensSignResponse response,
                                    CreateResponse(request, private_key_));
   response.mutable_anonymous_tokens(0)->set_key_version(2);
-  EXPECT_THAT(client_->ProcessResponse(response),
-              StatusIs(absl::StatusCode::kInvalidArgument));
+  absl::StatusOr<std::vector<RSABlindSignatureTokenWithInput>>
+      processed_response = client_->ProcessResponse(response);
+  EXPECT_EQ(processed_response.status().code(),
+            absl::StatusCode::kInvalidArgument);
 }
 
 TEST_F(AnonymousTokensRsaBssaClientTest, ProcessResponseFromDifferentClient) {
@@ -321,10 +337,14 @@
                                    CreateResponse(request1, private_key_));
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(AnonymousTokensSignResponse response2,
                                    CreateResponse(request2, private_key_));
-  EXPECT_THAT(client_->ProcessResponse(response2),
-              StatusIs(absl::StatusCode::kInvalidArgument));
-  EXPECT_THAT(client2->ProcessResponse(response1),
-              StatusIs(absl::StatusCode::kInvalidArgument));
+  absl::StatusOr<std::vector<RSABlindSignatureTokenWithInput>>
+      processed_response2 = client_->ProcessResponse(response2);
+  EXPECT_EQ(processed_response2.status().code(),
+            absl::StatusCode::kInvalidArgument);
+  absl::StatusOr<std::vector<RSABlindSignatureTokenWithInput>>
+      processed_response1 = client2->ProcessResponse(response1);
+  EXPECT_EQ(processed_response1.status().code(),
+            absl::StatusCode::kInvalidArgument);
 }
 
 class AnonymousTokensRsaBssaClientWithPublicMetadataTest
@@ -359,7 +379,7 @@
       AnonymousTokensSignResponse response,
       CreateResponse(request, private_key_, /*enable_public_metadata=*/true));
   EXPECT_THAT(response.anonymous_tokens(), SizeIs(1));
-  QUICHE_EXPECT_OK(public_metadata_client_->ProcessResponse(response));
+  EXPECT_TRUE(public_metadata_client_->ProcessResponse(response).ok());
 }
 
 TEST_F(AnonymousTokensRsaBssaClientWithPublicMetadataTest,
@@ -373,8 +393,10 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       AnonymousTokensSignResponse response,
       CreateResponse(request, private_key_, /*enable_public_metadata=*/false));
-  EXPECT_THAT(public_metadata_client_->ProcessResponse(response),
-              StatusIs(absl::StatusCode::kInvalidArgument));
+  absl::StatusOr<std::vector<RSABlindSignatureTokenWithInput>>
+      processed_response = public_metadata_client_->ProcessResponse(response);
+  EXPECT_EQ(processed_response.status().code(),
+            absl::StatusCode::kInvalidArgument);
 }
 
 TEST_F(AnonymousTokensRsaBssaClientWithPublicMetadataTest,
@@ -390,8 +412,10 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       AnonymousTokensSignResponse response,
       CreateResponse(request, private_key_, /*enable_public_metadata=*/true));
-  EXPECT_THAT(public_metadata_client_->ProcessResponse(response),
-              StatusIs(absl::StatusCode::kInvalidArgument));
+  absl::StatusOr<std::vector<RSABlindSignatureTokenWithInput>>
+      processed_response = public_metadata_client_->ProcessResponse(response);
+  EXPECT_EQ(processed_response.status().code(),
+            absl::StatusCode::kInvalidArgument);
 }
 
 TEST_F(AnonymousTokensRsaBssaClientWithPublicMetadataTest,
@@ -412,8 +436,11 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       AnonymousTokensSignResponse response,
       CreateResponse(request, private_key_, /*enable_public_metadata=*/true));
-  EXPECT_THAT(non_public_metadata_client->ProcessResponse(response),
-              StatusIs(absl::StatusCode::kInvalidArgument));
+  absl::StatusOr<std::vector<RSABlindSignatureTokenWithInput>>
+      processed_response =
+          non_public_metadata_client->ProcessResponse(response);
+  EXPECT_EQ(processed_response.status().code(),
+            absl::StatusCode::kInvalidArgument);
 }
 
 TEST_F(AnonymousTokensRsaBssaClientWithPublicMetadataTest,
@@ -429,7 +456,7 @@
       AnonymousTokensSignResponse response,
       CreateResponse(request, private_key_, /*enable_public_metadata=*/true));
   EXPECT_THAT(response.anonymous_tokens(), SizeIs(4));
-  QUICHE_EXPECT_OK(public_metadata_client_->ProcessResponse(response));
+  EXPECT_TRUE(public_metadata_client_->ProcessResponse(response).ok());
 }
 
 TEST_F(AnonymousTokensRsaBssaClientWithPublicMetadataTest,
@@ -446,7 +473,7 @@
       AnonymousTokensSignResponse response,
       CreateResponse(request, private_key_, /*enable_public_metadata=*/true));
   EXPECT_THAT(response.anonymous_tokens(), SizeIs(4));
-  QUICHE_EXPECT_OK(public_metadata_client_->ProcessResponse(response));
+  EXPECT_TRUE(public_metadata_client_->ProcessResponse(response).ok());
 }
 
 TEST_F(AnonymousTokensRsaBssaClientWithPublicMetadataTest,
@@ -462,7 +489,7 @@
       AnonymousTokensSignResponse response,
       CreateResponse(request, private_key_, /*enable_public_metadata=*/true));
   EXPECT_THAT(response.anonymous_tokens(), SizeIs(4));
-  QUICHE_EXPECT_OK(public_metadata_client_->ProcessResponse(response));
+  EXPECT_TRUE(public_metadata_client_->ProcessResponse(response).ok());
 }
 
 }  // namespace
diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/at_crypto_utils_test.cc b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/at_crypto_utils_test.cc
index 982767e..24ff66f 100644
--- a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/at_crypto_utils_test.cc
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/at_crypto_utils_test.cc
@@ -77,9 +77,9 @@
   std::string str;
   absl::StatusOr<std::string> empty_str_hash = ComputeHash(str, *EVP_sha512());
 
-  QUICHE_EXPECT_OK(null_hash);
-  QUICHE_EXPECT_OK(empty_hash);
-  QUICHE_EXPECT_OK(empty_str_hash);
+  ASSERT_TRUE(null_hash.ok());
+  ASSERT_TRUE(empty_hash.ok());
+  ASSERT_TRUE(empty_str_hash.ok());
 
   EXPECT_EQ(*null_hash, *empty_hash);
   EXPECT_EQ(*null_hash, *empty_str_hash);
diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blind_signer_test.cc b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blind_signer_test.cc
index 7106eb5..a332f19 100644
--- a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blind_signer_test.cc
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blind_signer_test.cc
@@ -83,17 +83,18 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       const auto verifier,
       RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_, public_key_));
-  QUICHE_EXPECT_OK(verifier->Verify(potentially_insecure_signature, message));
+  EXPECT_TRUE(verifier->Verify(potentially_insecure_signature, message).ok());
 }
 
 TEST_P(RsaBlindSignerTest, SignerFails) {
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::unique_ptr<RsaBlindSigner> signer,
                                    RsaBlindSigner::New(private_key_));
   absl::string_view message = "Hello World!";
-  EXPECT_THAT(signer->Sign(message),
-              quiche::test::StatusIs(
-                  absl::StatusCode::kInternal,
-                  ::testing::HasSubstr("Expected blind data size")));
+
+  absl::StatusOr<std::string> signature = signer->Sign(message);
+  EXPECT_EQ(signature.status().code(), absl::StatusCode::kInternal);
+  EXPECT_THAT(signature.status().message(),
+              ::testing::HasSubstr("Expected blind data size"));
 
   int sig_size = public_key_.n().size();
   std::string message2 = RandomString(sig_size, &distr_u8_, &generator_);
@@ -102,10 +103,10 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       const auto verifier,
       RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_, public_key_));
-  EXPECT_THAT(
-      verifier->Verify(insecure_sig, message2),
-      quiche::test::StatusIs(absl::StatusCode::kInvalidArgument,
-                                  ::testing::HasSubstr("verification failed")));
+  absl::Status verification_result = verifier->Verify(insecure_sig, message2);
+  EXPECT_EQ(verification_result.code(), absl::StatusCode::kInvalidArgument);
+  EXPECT_THAT(verification_result.message(),
+              ::testing::HasSubstr("verification failed"));
 }
 
 INSTANTIATE_TEST_SUITE_P(RsaBlindSignerTest, RsaBlindSignerTest,
@@ -155,7 +156,7 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto verifier, RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_,
                                             public_key_, public_metadata));
-  QUICHE_EXPECT_OK(verifier->Verify(potentially_insecure_signature, message));
+  EXPECT_TRUE(verifier->Verify(potentially_insecure_signature, message).ok());
 }
 
 TEST_P(RsaBlindSignerTestWithPublicMetadata,
@@ -177,7 +178,7 @@
       auto verifier,
       RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_, public_key_,
                              empty_public_metadata));
-  QUICHE_EXPECT_OK(verifier->Verify(potentially_insecure_signature, message));
+  EXPECT_TRUE(verifier->Verify(potentially_insecure_signature, message).ok());
 }
 
 TEST_P(RsaBlindSignerTestWithPublicMetadata,
@@ -199,10 +200,11 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto verifier, RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_,
                                             public_key_, public_metadata_2));
-  EXPECT_THAT(
-      verifier->Verify(potentially_insecure_signature, message),
-      quiche::test::StatusIs(absl::StatusCode::kInvalidArgument,
-                                  ::testing::HasSubstr("verification failed")));
+  absl::Status verification_result =
+      verifier->Verify(potentially_insecure_signature, message);
+  EXPECT_EQ(verification_result.code(), absl::StatusCode::kInvalidArgument);
+  EXPECT_THAT(verification_result.message(),
+              ::testing::HasSubstr("verification failed"));
 }
 
 TEST_P(RsaBlindSignerTestWithPublicMetadata,
@@ -224,10 +226,11 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto verifier, RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_,
                                             public_key_, public_metadata_2));
-  EXPECT_THAT(
-      verifier->Verify(potentially_insecure_signature, message),
-      quiche::test::StatusIs(absl::StatusCode::kInvalidArgument,
-                                  ::testing::HasSubstr("verification failed")));
+  absl::Status verification_result =
+      verifier->Verify(potentially_insecure_signature, message);
+  EXPECT_EQ(verification_result.code(), absl::StatusCode::kInvalidArgument);
+  EXPECT_THAT(verification_result.message(),
+              ::testing::HasSubstr("verification failed"));
 }
 
 INSTANTIATE_TEST_SUITE_P(
diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder_test.cc b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder_test.cc
index cd1b11d..509bfda 100644
--- a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder_test.cc
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_blinder_test.cc
@@ -98,7 +98,7 @@
   EXPECT_NE(signature, blinded_message);
   EXPECT_NE(signature, message);
 
-  QUICHE_EXPECT_OK(blinder->Verify(signature, message));
+  EXPECT_TRUE(blinder->Verify(signature, message).ok());
 }
 
 TEST_P(RsaBlinderTest, DoubleBlindingFailure) {
@@ -148,7 +148,7 @@
                                    TestSign(blinded_message, rsa_key_.get()));
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(std::string signature,
                                    blinder->Unblind(blinded_signature));
-  QUICHE_EXPECT_OK(blinder->Verify(signature, message));
+  EXPECT_TRUE(blinder->Verify(signature, message).ok());
 
   // Invalidate the signature by replacing the last 10 characters by 10 '0's
   for (int i = 0; i < 10; i++) {
@@ -235,7 +235,7 @@
   EXPECT_NE(signature, blinded_message);
   EXPECT_NE(signature, message);
 
-  QUICHE_EXPECT_OK(blinder->Verify(signature, message));
+  EXPECT_TRUE(blinder->Verify(signature, message).ok());
 }
 
 TEST_P(RsaBlinderWithPublicMetadataTest,
@@ -263,7 +263,7 @@
   EXPECT_NE(signature, blinded_message);
   EXPECT_NE(signature, message);
 
-  QUICHE_EXPECT_OK(blinder->Verify(signature, message));
+  EXPECT_TRUE(blinder->Verify(signature, message).ok());
 }
 
 TEST_P(RsaBlinderWithPublicMetadataTest, WrongPublicMetadata) {
@@ -290,10 +290,10 @@
   EXPECT_NE(signature, blinded_signature);
   EXPECT_NE(signature, blinded_message);
   EXPECT_NE(signature, message);
-  EXPECT_THAT(
-      blinder->Verify(signature, message),
-      quiche::test::StatusIs(absl::StatusCode::kInvalidArgument,
-                                  ::testing::HasSubstr("verification failed")));
+  absl::Status verification_result = blinder->Verify(signature, message);
+  EXPECT_EQ(verification_result.code(), absl::StatusCode::kInvalidArgument);
+  EXPECT_THAT(verification_result.message(),
+              ::testing::HasSubstr("verification failed"));
 }
 
 TEST_P(RsaBlinderWithPublicMetadataTest, NoPublicMetadataForSigning) {
@@ -317,10 +317,10 @@
   EXPECT_NE(signature, blinded_signature);
   EXPECT_NE(signature, blinded_message);
   EXPECT_NE(signature, message);
-  EXPECT_THAT(
-      blinder->Verify(signature, message),
-      quiche::test::StatusIs(absl::StatusCode::kInvalidArgument,
-                                  ::testing::HasSubstr("verification failed")));
+  absl::Status verification_result = blinder->Verify(signature, message);
+  EXPECT_EQ(verification_result.code(), absl::StatusCode::kInvalidArgument);
+  EXPECT_THAT(verification_result.message(),
+              ::testing::HasSubstr("verification failed"));
 }
 
 TEST_P(RsaBlinderWithPublicMetadataTest, NoPublicMetadataInBlinding) {
@@ -344,10 +344,10 @@
   EXPECT_NE(signature, blinded_signature);
   EXPECT_NE(signature, blinded_message);
   EXPECT_NE(signature, message);
-  EXPECT_THAT(
-      blinder->Verify(signature, message),
-      quiche::test::StatusIs(absl::StatusCode::kInvalidArgument,
-                                  ::testing::HasSubstr("verification failed")));
+  absl::Status verification_result = blinder->Verify(signature, message);
+  EXPECT_EQ(verification_result.code(), absl::StatusCode::kInvalidArgument);
+  EXPECT_THAT(verification_result.message(),
+              ::testing::HasSubstr("verification failed"));
 }
 
 INSTANTIATE_TEST_SUITE_P(
diff --git a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier_test.cc b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier_test.cc
index 1d19310..2732c75 100644
--- a/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier_test.cc
+++ b/quiche/blind_sign_auth/anonymous_tokens/cpp/crypto/rsa_ssa_pss_verifier_test.cc
@@ -47,7 +47,7 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       const auto verifier, RsaSsaPssVerifier::New(salt_length, sig_hash,
                                                   mgf1_hash, test_keys.first));
-  QUICHE_EXPECT_OK(verifier->Verify(test_vec.signature, test_vec.message));
+  EXPECT_TRUE(verifier->Verify(test_vec.signature, test_vec.message).ok());
 }
 
 TEST(RsaSsaPssVerifier, InvalidSignature) {
@@ -65,10 +65,11 @@
   std::string wrong_sig = test_vec.signature;
   wrong_sig.replace(10, 1, "x");
 
-  EXPECT_THAT(
-      verifier->Verify(wrong_sig, test_vec.message),
-      quiche::test::StatusIs(absl::StatusCode::kInvalidArgument,
-                                testing::HasSubstr("verification failed")));
+  absl::Status verification_result =
+      verifier->Verify(wrong_sig, test_vec.message);
+  EXPECT_EQ(verification_result.code(), absl::StatusCode::kInvalidArgument);
+  EXPECT_THAT(verification_result.message(),
+              testing::HasSubstr("verification failed"));
 }
 
 TEST(RsaSsaPssVerifier, InvalidVerificationKey) {
@@ -84,10 +85,11 @@
       RsaSsaPssVerifier::New(salt_length, sig_hash, mgf1_hash,
                              new_keys_pair.first));
 
-  EXPECT_THAT(
-      verifier->Verify(test_vec.signature, test_vec.message),
-      quiche::test::StatusIs(absl::StatusCode::kInvalidArgument,
-                                testing::HasSubstr("verification failed")));
+  absl::Status verification_result =
+      verifier->Verify(test_vec.signature, test_vec.message);
+  EXPECT_EQ(verification_result.code(), absl::StatusCode::kInvalidArgument);
+  EXPECT_THAT(verification_result.message(),
+              testing::HasSubstr("verification failed"));
 }
 
 TEST(RsaSsaPssVerifierTestWithPublicMetadata,
@@ -110,7 +112,7 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto verifier,
       RsaSsaPssVerifier::New(salt_length, sig_hash, mgf1_hash, test_key.first));
-  QUICHE_EXPECT_OK(verifier->Verify(potentially_insecure_signature, message));
+  EXPECT_TRUE(verifier->Verify(potentially_insecure_signature, message).ok());
 }
 
 // TODO(b/275956922): Consolidate all tests that use IETF test vectors into one
@@ -129,9 +131,11 @@
         auto verifier,
         RsaSsaPssVerifier::New(salt_length, sig_hash, mgf1_hash, test_key.first,
                                test_vector.public_metadata));
-    QUICHE_EXPECT_OK(verifier->Verify(
-        test_vector.signature,
-        MaskMessageConcat(test_vector.message_mask, test_vector.message)));
+    EXPECT_TRUE(verifier
+                    ->Verify(test_vector.signature,
+                             MaskMessageConcat(test_vector.message_mask,
+                                               test_vector.message))
+                    .ok());
   }
 }
 
@@ -180,7 +184,7 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto verifier, RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_,
                                             public_key_, public_metadata));
-  QUICHE_EXPECT_OK(verifier->Verify(potentially_insecure_signature, message));
+  EXPECT_TRUE(verifier->Verify(potentially_insecure_signature, message).ok());
 }
 
 TEST_P(RsaSsaPssVerifierTestWithPublicMetadata,
@@ -201,10 +205,11 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto verifier, RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_,
                                             public_key_, public_metadata_2));
-  EXPECT_THAT(
-      verifier->Verify(potentially_insecure_signature, message),
-      quiche::test::StatusIs(absl::StatusCode::kInvalidArgument,
-                                  ::testing::HasSubstr("verification failed")));
+  absl::Status verification_result =
+      verifier->Verify(potentially_insecure_signature, message);
+  EXPECT_EQ(verification_result.code(), absl::StatusCode::kInvalidArgument);
+  EXPECT_THAT(verification_result.message(),
+              testing::HasSubstr("verification failed"));
 }
 
 TEST_P(RsaSsaPssVerifierTestWithPublicMetadata,
@@ -226,10 +231,11 @@
       auto verifier,
       RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_, public_key_,
                              empty_public_metadata));
-  EXPECT_THAT(
-      verifier->Verify(potentially_insecure_signature, message),
-      quiche::test::StatusIs(absl::StatusCode::kInvalidArgument,
-                                  ::testing::HasSubstr("verification failed")));
+  absl::Status verification_result =
+      verifier->Verify(potentially_insecure_signature, message);
+  EXPECT_EQ(verification_result.code(), absl::StatusCode::kInvalidArgument);
+  EXPECT_THAT(verification_result.message(),
+              testing::HasSubstr("verification failed"));
 }
 
 TEST_P(RsaSsaPssVerifierTestWithPublicMetadata,
@@ -249,10 +255,11 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto verifier,
       RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_, public_key_));
-  EXPECT_THAT(
-      verifier->Verify(potentially_insecure_signature, message),
-      quiche::test::StatusIs(absl::StatusCode::kInvalidArgument,
-                                  ::testing::HasSubstr("verification failed")));
+  absl::Status verification_result =
+      verifier->Verify(potentially_insecure_signature, message);
+  EXPECT_EQ(verification_result.code(), absl::StatusCode::kInvalidArgument);
+  EXPECT_THAT(verification_result.message(),
+              testing::HasSubstr("verification failed"));
 }
 
 TEST_P(RsaSsaPssVerifierTestWithPublicMetadata,
@@ -272,7 +279,7 @@
   ANON_TOKENS_ASSERT_OK_AND_ASSIGN(
       auto verifier, RsaSsaPssVerifier::New(salt_length_, sig_hash_, mgf1_hash_,
                                             public_key_, public_metadata));
-  QUICHE_EXPECT_OK(verifier->Verify(potentially_insecure_signature, message));
+  EXPECT_TRUE(verifier->Verify(potentially_insecure_signature, message).ok());
 }
 
 INSTANTIATE_TEST_SUITE_P(RsaSsaPssVerifierTestWithPublicMetadata,