Remove .status() usages when matching IsOk() with a StatusOr object.

Since the IsOk() matcher can handle StatusOr now, we don't need to call .status() anymore.

NOKEYCHECK

NOKEYCHECK=True
PiperOrigin-RevId: 456467311

26 files changed, 258 insertions, 258 deletions

diff --git a/cc/experimental/pqcrypto/kem/cecpq2_aead_hkdf_dem_helper_test.cc b/cc/experimental/pqcrypto/kem/cecpq2_aead_hkdf_dem_helper_test.cc
index 8119e8d56..d9c9c332b 100644
--- a/cc/experimental/pqcrypto/kem/cecpq2_aead_hkdf_dem_helper_test.cc
+++ b/cc/experimental/pqcrypto/kem/cecpq2_aead_hkdf_dem_helper_test.cc
@@ -79,7 +79,7 @@ TEST(Cecpq2AeadHkdfDemHelperTest, DemHelperWithAesGcmKeyType) {
   dem_key_template.set_value(key_format.SerializeAsString());
 
   auto dem_helper_or = Cecpq2AeadHkdfDemHelper::New(dem_key_template);
-  ASSERT_THAT(dem_helper_or.status(), IsOk());
+  ASSERT_THAT(dem_helper_or, IsOk());
   auto dem_helper = std::move(dem_helper_or.value());
 
   util::SecretData seed_32_bytes = util::SecretDataFromStringView(
@@ -87,7 +87,7 @@ TEST(Cecpq2AeadHkdfDemHelperTest, DemHelperWithAesGcmKeyType) {
                            "000102030405060708090a0b0c0d0e0f"));
   StatusOr<std::unique_ptr<AeadOrDaead>> aead_or_daead_result_or =
       dem_helper->GetAeadOrDaead(seed_32_bytes);
-  ASSERT_THAT(aead_or_daead_result_or.status(), IsOk());
+  ASSERT_THAT(aead_or_daead_result_or, IsOk());
 
   auto aead_or_daead = std::move(aead_or_daead_result_or.value());
   EXPECT_THAT(EncryptThenDecrypt(*aead_or_daead, "test_plaintext", "test_ad"),
@@ -107,7 +107,7 @@ TEST(Cecpq2AeadHkdfDemHelperTest, DemHelperWithAesSivKeyType) {
   dem_key_template.set_value(key_format.SerializeAsString());
 
   auto dem_helper_or = Cecpq2AeadHkdfDemHelper::New(dem_key_template);
-  ASSERT_THAT(dem_helper_or.status(), IsOk());
+  ASSERT_THAT(dem_helper_or, IsOk());
   auto dem_helper = std::move(dem_helper_or.value());
 
   util::SecretData seed_64_bytes = util::SecretDataFromStringView(
@@ -117,7 +117,7 @@ TEST(Cecpq2AeadHkdfDemHelperTest, DemHelperWithAesSivKeyType) {
                            "000102030405060708090a0b0c0d0e0f"));
   StatusOr<std::unique_ptr<AeadOrDaead>> aead_or_daead_result_or =
       dem_helper->GetAeadOrDaead(seed_64_bytes);
-  ASSERT_THAT(aead_or_daead_result_or.status(), IsOk());
+  ASSERT_THAT(aead_or_daead_result_or, IsOk());
 
   auto aead_or_daead = std::move(aead_or_daead_result_or.value());
   EXPECT_THAT(EncryptThenDecrypt(*aead_or_daead, "test_plaintext", "test_ad"),
@@ -136,7 +136,7 @@ TEST(Cecpq2AeadHkdfDemHelperTest, DemHelperWithXchacha20Poly1305KeyType) {
   dem_key_template.set_value(key_format.SerializeAsString());
 
   auto dem_helper_or = Cecpq2AeadHkdfDemHelper::New(dem_key_template);
-  ASSERT_THAT(dem_helper_or.status(), IsOk());
+  ASSERT_THAT(dem_helper_or, IsOk());
   auto dem_helper = std::move(dem_helper_or.value());
 
   util::SecretData seed_32_bytes = util::SecretDataFromStringView(
@@ -144,7 +144,7 @@ TEST(Cecpq2AeadHkdfDemHelperTest, DemHelperWithXchacha20Poly1305KeyType) {
                            "000102030405060708090a0b0c0d0e0f"));
   StatusOr<std::unique_ptr<AeadOrDaead>> aead_or_daead_result_or =
       dem_helper->GetAeadOrDaead(seed_32_bytes);
-  ASSERT_THAT(aead_or_daead_result_or.status(), IsOk());
+  ASSERT_THAT(aead_or_daead_result_or, IsOk());
 
   auto aead_or_daead = std::move(aead_or_daead_result_or.value());
   EXPECT_THAT(EncryptThenDecrypt(*aead_or_daead, "test_plaintext", "test_ad"),
@@ -163,11 +163,11 @@ TEST(Cecpq2AeadHkdfDemHelperTest, DemHelperKeyMaterialXChacha20Poly1305) {
   dem_key_template.set_value(key_format.SerializeAsString());
 
   auto dem_helper_or = Cecpq2AeadHkdfDemHelper::New(dem_key_template);
-  ASSERT_THAT(dem_helper_or.status(), IsOk());
+  ASSERT_THAT(dem_helper_or, IsOk());
   auto dem_helper = std::move(dem_helper_or.value());
 
   auto key_material_size_or = dem_helper->GetKeyMaterialSize();
-  ASSERT_THAT(key_material_size_or.status(), IsOk());
+  ASSERT_THAT(key_material_size_or, IsOk());
   ASSERT_EQ(key_material_size_or.value(), 32);
 }
 
@@ -183,11 +183,11 @@ TEST(Cecpq2AeadHkdfDemHelperTest, DemHelperKeyMaterialAesGcm) {
   dem_key_template.set_value(key_format.SerializeAsString());
 
   auto dem_helper_or = Cecpq2AeadHkdfDemHelper::New(dem_key_template);
-  ASSERT_THAT(dem_helper_or.status(), IsOk());
+  ASSERT_THAT(dem_helper_or, IsOk());
   auto dem_helper = std::move(dem_helper_or.value());
 
   auto key_material_size_or = dem_helper->GetKeyMaterialSize();
-  ASSERT_THAT(key_material_size_or.status(), IsOk());
+  ASSERT_THAT(key_material_size_or, IsOk());
   ASSERT_EQ(key_material_size_or.value(), 32);
 }
 
@@ -203,11 +203,11 @@ TEST(Cecpq2AeadHkdfDemHelperTest, DemHelperKeyMaterialAesSiv) {
   dem_key_template.set_value(key_format.SerializeAsString());
 
   auto dem_helper_or = Cecpq2AeadHkdfDemHelper::New(dem_key_template);
-  ASSERT_THAT(dem_helper_or.status(), IsOk());
+  ASSERT_THAT(dem_helper_or, IsOk());
   auto dem_helper = std::move(dem_helper_or.value());
 
   auto key_material_size_or = dem_helper->GetKeyMaterialSize();
-  ASSERT_THAT(key_material_size_or.status(), IsOk());
+  ASSERT_THAT(key_material_size_or, IsOk());
   ASSERT_EQ(key_material_size_or.value(), 64);
 }
 
diff --git a/cc/experimental/pqcrypto/kem/cecpq2_aead_hkdf_private_key_manager_test.cc b/cc/experimental/pqcrypto/kem/cecpq2_aead_hkdf_private_key_manager_test.cc
index 1ed0b6085..b35457ebe 100644
--- a/cc/experimental/pqcrypto/kem/cecpq2_aead_hkdf_private_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/kem/cecpq2_aead_hkdf_private_key_manager_test.cc
@@ -242,17 +242,17 @@ TEST(Cecpq2AeadHkdfPrivateKeyManagerTest, Create) {
   auto decrypt_or =
       Cecpq2AeadHkdfPrivateKeyManager().GetPrimitive<HybridDecrypt>(
           private_key);
-  ASSERT_THAT(decrypt_or.status(), IsOk());
+  ASSERT_THAT(decrypt_or, IsOk());
   auto encrypt_or = Cecpq2AeadHkdfHybridEncrypt::New(public_key);
-  ASSERT_THAT(encrypt_or.status(), IsOk());
+  ASSERT_THAT(encrypt_or, IsOk());
 
   std::string plaintext = "some text";
   std::string context_info = "some aad";
   auto ciphertext = encrypt_or.value()->Encrypt(plaintext, context_info);
-  ASSERT_THAT(ciphertext.status(), IsOk());
+  ASSERT_THAT(ciphertext, IsOk());
   auto decryption =
       decrypt_or.value()->Decrypt(ciphertext.value(), context_info);
-  ASSERT_THAT(decryption.status(), IsOk());
+  ASSERT_THAT(decryption, IsOk());
   ASSERT_EQ(decryption.value(), plaintext);
 }
 
@@ -269,17 +269,17 @@ TEST(Cecpq2AeadHkdfPrivateKeyManagerTest, CreateDifferentKey) {
   auto decrypt_or =
       Cecpq2AeadHkdfPrivateKeyManager().GetPrimitive<HybridDecrypt>(
           private_key);
-  ASSERT_THAT(decrypt_or.status(), IsOk());
+  ASSERT_THAT(decrypt_or, IsOk());
   auto encrypt_or = Cecpq2AeadHkdfHybridEncrypt::New(public_key);
-  ASSERT_THAT(encrypt_or.status(), IsOk());
+  ASSERT_THAT(encrypt_or, IsOk());
 
   std::string plaintext = "some text";
   std::string context_info = "some aad";
   auto ciphertext = encrypt_or.value()->Encrypt(plaintext, context_info);
-  ASSERT_THAT(ciphertext.status(), IsOk());
+  ASSERT_THAT(ciphertext, IsOk());
   auto decryption =
       decrypt_or.value()->Decrypt(ciphertext.value(), context_info);
-  ASSERT_THAT(decryption.status(), Not(IsOk()));
+  ASSERT_THAT(decryption, Not(IsOk()));
 }
 
 TEST(Cecpq2AeadHkdfPrivateKeyManagerTest, ValidatePrivateKeyVersion) {
diff --git a/cc/experimental/pqcrypto/kem/cecpq2_hybrid_config_test.cc b/cc/experimental/pqcrypto/kem/cecpq2_hybrid_config_test.cc
index d8680e254..36616cdc9 100644
--- a/cc/experimental/pqcrypto/kem/cecpq2_hybrid_config_test.cc
+++ b/cc/experimental/pqcrypto/kem/cecpq2_hybrid_config_test.cc
@@ -97,9 +97,9 @@ TEST_F(Cecpq2HybridConfigTest, EncryptWrapperRegistered) {
 
   auto wrapped = Registry::Wrap(std::move(primitive_set));
 
-  ASSERT_THAT(wrapped.status(), IsOk());
+  ASSERT_THAT(wrapped, IsOk());
   auto encryption_result = wrapped.value()->Encrypt("secret", "");
-  ASSERT_THAT(encryption_result.status(), IsOk());
+  ASSERT_THAT(encryption_result, IsOk());
 
   std::string prefix = CryptoFormat::GetOutputPrefix(key_info).value();
   EXPECT_EQ(
@@ -132,7 +132,7 @@ TEST_F(Cecpq2HybridConfigTest, DecryptWrapperRegistered) {
 
   auto wrapped = Registry::Wrap(std::move(primitive_set));
 
-  ASSERT_THAT(wrapped.status(), IsOk());
+  ASSERT_THAT(wrapped, IsOk());
 
   std::string prefix = CryptoFormat::GetOutputPrefix(key_info).value();
   std::string encryption =
diff --git a/cc/experimental/pqcrypto/kem/subtle/cecpq2_aead_hkdf_hybrid_decrypt_test.cc b/cc/experimental/pqcrypto/kem/subtle/cecpq2_aead_hkdf_hybrid_decrypt_test.cc
index 8c48ad13a..d1418369b 100644
--- a/cc/experimental/pqcrypto/kem/subtle/cecpq2_aead_hkdf_hybrid_decrypt_test.cc
+++ b/cc/experimental/pqcrypto/kem/subtle/cecpq2_aead_hkdf_hybrid_decrypt_test.cc
@@ -225,7 +225,7 @@ google::crypto::tink::Cecpq2AeadHkdfPrivateKey CreateValidKey() {
 TEST_F(Cecpq2AeadHkdfHybridDecryptTest, ValidKey) {
   google::crypto::tink::Cecpq2AeadHkdfPrivateKey recipient_key =
       CreateValidKey();
-  EXPECT_THAT(Cecpq2AeadHkdfHybridDecrypt::New(recipient_key).status(), IsOk());
+  EXPECT_THAT(Cecpq2AeadHkdfHybridDecrypt::New(recipient_key), IsOk());
 }
 
 TEST_F(Cecpq2AeadHkdfHybridDecryptTest, InvalidKeyNoFieldsSet) {
diff --git a/cc/experimental/pqcrypto/kem/subtle/cecpq2_aead_hkdf_hybrid_encrypt_test.cc b/cc/experimental/pqcrypto/kem/subtle/cecpq2_aead_hkdf_hybrid_encrypt_test.cc
index 7d5a34786..42d5b035d 100644
--- a/cc/experimental/pqcrypto/kem/subtle/cecpq2_aead_hkdf_hybrid_encrypt_test.cc
+++ b/cc/experimental/pqcrypto/kem/subtle/cecpq2_aead_hkdf_hybrid_encrypt_test.cc
@@ -66,7 +66,7 @@ google::crypto::tink::Cecpq2AeadHkdfPublicKey CreateValidKey() {
 TEST(Cecpq2AeadHkdfHybridEncryptTest, ValidKey) {
   google::crypto::tink::Cecpq2AeadHkdfPublicKey sender_key = CreateValidKey();
   auto result = Cecpq2AeadHkdfHybridEncrypt::New(sender_key);
-  EXPECT_THAT(result.status(), IsOk());
+  EXPECT_THAT(result, IsOk());
 }
 
 TEST(Cecpq2AeadHkdfHybridEncryptTest, InvalidKeyNoFieldSet) {
@@ -99,7 +99,7 @@ TEST(Cecpq2AeadHkdfHybridEncryptTest, InvalidKeyUnsupportedEcType) {
 TEST(Cecpq2AeadHkdfHybridEncryptTest, InvalidKeyUnsupportedDemKeyType) {
   auto status_or_cecpq2_key =
       pqc::GenerateCecpq2Keypair(subtle::EllipticCurveType::CURVE25519);
-  ASSERT_THAT(status_or_cecpq2_key.status(), IsOk());
+  ASSERT_THAT(status_or_cecpq2_key, IsOk());
   auto cecpq2_key_pair = std::move(status_or_cecpq2_key).value();
 
   google::crypto::tink::Cecpq2AeadHkdfPublicKey sender_key = CreateValidKey();
@@ -153,13 +153,13 @@ TEST(Cecpq2AeadHkdfHybridEncryptTest, Basic) {
               ->set_type_url(
                   "type.googleapis.com/google.crypto.tink.AesGcmKey");
           auto key_or = Cecpq2AeadHkdfHybridEncrypt::New(cecpq2_key);
-          ASSERT_THAT(key_or.status(), IsOk());
+          ASSERT_THAT(key_or, IsOk());
           std::unique_ptr<HybridEncrypt> hybrid_encrypt(
               std::move(key_or.value()));
           // Use the primitive
           auto encrypt_result =
               hybrid_encrypt->Encrypt(plaintext, context_info);
-          EXPECT_THAT(encrypt_result.status(), IsOk());
+          EXPECT_THAT(encrypt_result, IsOk());
         }
       }
     }
diff --git a/cc/experimental/pqcrypto/kem/subtle/cecpq2_hkdf_recipient_kem_boringssl_test.cc b/cc/experimental/pqcrypto/kem/subtle/cecpq2_hkdf_recipient_kem_boringssl_test.cc
index f2ead223e..1ab7bec21 100644
--- a/cc/experimental/pqcrypto/kem/subtle/cecpq2_hkdf_recipient_kem_boringssl_test.cc
+++ b/cc/experimental/pqcrypto/kem/subtle/cecpq2_hkdf_recipient_kem_boringssl_test.cc
@@ -185,7 +185,7 @@ TEST(Cecpq2HkdfRecipientKemBoringSslTest, TestNotPostQuantumSecureKeyLength) {
       util::SecretDataFromStringView(
           test::HexDecodeOrDie(kCecpq2X25519PrivateKeyHex)),
       std::move(hrss_private_key_seed));
-  ASSERT_THAT(cecpq2_recipient_kem_or.status(), IsOk());
+  ASSERT_THAT(cecpq2_recipient_kem_or, IsOk());
   auto cecpq2_recipient_kem = std::move(cecpq2_recipient_kem_or).value();
 
   // Recovering the symmetric key
@@ -212,7 +212,7 @@ TEST(Cecpq2HkdfRecipientKemBoringSslTest, TestRecipientFlowSuccess) {
       util::SecretDataFromStringView(
           test::HexDecodeOrDie(kCecpq2X25519PrivateKeyHex)),
       std::move(hrss_private_key_seed));
-  ASSERT_THAT(cecpq2_recipient_kem_or.status(), IsOk());
+  ASSERT_THAT(cecpq2_recipient_kem_or, IsOk());
   auto cecpq2_recipient_kem = std::move(cecpq2_recipient_kem_or).value();
 
   // Recovering the symmetric key
@@ -220,7 +220,7 @@ TEST(Cecpq2HkdfRecipientKemBoringSslTest, TestRecipientFlowSuccess) {
       test::HexDecodeOrDie(kCecpq2KemBytes), HashType::SHA256,
       test::HexDecodeOrDie(kSaltHex), test::HexDecodeOrDie(kInfoHex), out_len,
       EcPointFormat::COMPRESSED);
-  ASSERT_THAT(kem_key_or.status(), IsOk());
+  ASSERT_THAT(kem_key_or, IsOk());
 
   // The generated symmetric key should match the expected one
   EXPECT_EQ(kCorrectSharedSecret,
@@ -249,14 +249,14 @@ TEST(Cecpq2HkdfRecipientKemBoringSslTest, TestRecipientFlowFailure) {
       util::SecretDataFromStringView(
           test::HexDecodeOrDie(kCecpq2X25519PrivateKeyHex)),
       std::move(hrss_private_key_seed));
-  ASSERT_THAT(cecpq2_recipient_kem_or.status(), IsOk());
+  ASSERT_THAT(cecpq2_recipient_kem_or, IsOk());
   auto cecpq2_recipient_kem = std::move(cecpq2_recipient_kem_or).value();
 
   // Recovering the symmetric key
   auto kem_key_or = cecpq2_recipient_kem->GenerateKey(
       kem_bytes_modified, HashType::SHA256, test::HexDecodeOrDie(kSaltHex),
       test::HexDecodeOrDie(kInfoHex), out_len, EcPointFormat::COMPRESSED);
-  ASSERT_THAT(kem_key_or.status(), IsOk());
+  ASSERT_THAT(kem_key_or, IsOk());
 
   // The produced symmetric key should match the one produced by CECPQ2 in case
   // of HRSS decapsulation failure for the altered HRSS kem_bytes
diff --git a/cc/experimental/pqcrypto/kem/subtle/cecpq2_hkdf_sender_kem_boringssl_test.cc b/cc/experimental/pqcrypto/kem/subtle/cecpq2_hkdf_sender_kem_boringssl_test.cc
index ce18b2ecd..461583070 100644
--- a/cc/experimental/pqcrypto/kem/subtle/cecpq2_hkdf_sender_kem_boringssl_test.cc
+++ b/cc/experimental/pqcrypto/kem/subtle/cecpq2_hkdf_sender_kem_boringssl_test.cc
@@ -122,7 +122,7 @@ TEST(Cecpq2HkdfSenderKemBoringSslTest, TestNotPostQuantumSecureKeyLength) {
       EllipticCurveType::CURVE25519, cecpq2_key_pair.x25519_key_pair.pub_x,
       cecpq2_key_pair.x25519_key_pair.pub_y,
       cecpq2_key_pair.hrss_key_pair.hrss_public_key_marshaled);
-  ASSERT_THAT(status_or_sender_kem.status(), IsOk());
+  ASSERT_THAT(status_or_sender_kem, IsOk());
   auto sender_kem = std::move(status_or_sender_kem.value());
 
   // Generating a symmetric key
@@ -156,7 +156,7 @@ TEST(Cecpq2HkdfSenderKemBoringSslTest, TestGenerateKey) {
       EllipticCurveType::CURVE25519, cecpq2_key_pair.x25519_key_pair.pub_x,
       cecpq2_key_pair.x25519_key_pair.pub_y,
       cecpq2_key_pair.hrss_key_pair.hrss_public_key_marshaled);
-  ASSERT_THAT(status_or_sender_kem.status(), IsOk());
+  ASSERT_THAT(status_or_sender_kem, IsOk());
   auto sender_kem = std::move(status_or_sender_kem.value());
 
   // Generating a symmetric key
@@ -165,7 +165,7 @@ TEST(Cecpq2HkdfSenderKemBoringSslTest, TestGenerateKey) {
       test::HexDecodeOrDie(info_hex), out_len, EcPointFormat::COMPRESSED);
 
   // Asserting that the symmetric key has been successfully generated
-  ASSERT_THAT(status_or_kem_key.status(), IsOk());
+  ASSERT_THAT(status_or_kem_key, IsOk());
   auto kem_key = std::move(status_or_kem_key.value());
   EXPECT_FALSE(kem_key->get_kem_bytes().empty());
   EXPECT_EQ(kem_key->get_symmetric_key().size(), out_len);
@@ -251,7 +251,7 @@ TEST(Cecpq2HkdfSenderKemBoringSslTest, TestFullFlowErasedCallersPublicKey) {
       EllipticCurveType::CURVE25519, cecpq2_key_pair.x25519_key_pair.pub_x,
       cecpq2_key_pair.x25519_key_pair.pub_y,
       cecpq2_key_pair.hrss_key_pair.hrss_public_key_marshaled);
-  ASSERT_THAT(status_or_sender_kem.status(), IsOk());
+  ASSERT_THAT(status_or_sender_kem, IsOk());
   auto sender_kem = std::move(status_or_sender_kem.value());
 
   // Erasing caller's public key buffers
@@ -263,14 +263,14 @@ TEST(Cecpq2HkdfSenderKemBoringSslTest, TestFullFlowErasedCallersPublicKey) {
   auto status_or_kem_key = sender_kem->GenerateKey(
       HashType::SHA256, test::HexDecodeOrDie(salt_hex),
       test::HexDecodeOrDie(info_hex), out_len, EcPointFormat::COMPRESSED);
-  ASSERT_THAT(status_or_kem_key.status(), IsOk());
+  ASSERT_THAT(status_or_kem_key, IsOk());
   auto kem_key = std::move(status_or_kem_key.value());
 
   // Initializing recipient's KEM data structure using recipient's private keys
   auto status_or_recipient_kem = Cecpq2HkdfRecipientKemBoringSsl::New(
       EllipticCurveType::CURVE25519, cecpq2_key_pair.x25519_key_pair.priv,
       std::move(cecpq2_key_pair.hrss_key_pair.hrss_private_key_seed));
-  ASSERT_THAT(status_or_recipient_kem.status(), IsOk());
+  ASSERT_THAT(status_or_recipient_kem, IsOk());
   auto recipient_kem = std::move(status_or_recipient_kem.value());
 
   // Generating recipient's shared secret
@@ -278,7 +278,7 @@ TEST(Cecpq2HkdfSenderKemBoringSslTest, TestFullFlowErasedCallersPublicKey) {
       kem_key->get_kem_bytes(), HashType::SHA256,
       test::HexDecodeOrDie(salt_hex), test::HexDecodeOrDie(info_hex), out_len,
       EcPointFormat::COMPRESSED);
-  ASSERT_THAT(status_or_shared_secret.status(), IsOk());
+  ASSERT_THAT(status_or_shared_secret, IsOk());
 
   // Asserting that both shared secrets match
   EXPECT_EQ(test::HexEncode(
@@ -311,21 +311,21 @@ TEST(Cecpq2HkdfSenderKemBoringSslTest, TestSenderRecipientFullFlowFailure) {
       EllipticCurveType::CURVE25519, cecpq2_key_pair.x25519_key_pair.pub_x,
       cecpq2_key_pair.x25519_key_pair.pub_y,
       cecpq2_key_pair.hrss_key_pair.hrss_public_key_marshaled);
-  ASSERT_THAT(status_or_sender_kem.status(), IsOk());
+  ASSERT_THAT(status_or_sender_kem, IsOk());
   auto sender_kem = std::move(status_or_sender_kem.value());
 
   // Generating sender's shared secret (using salt_hex1)
   auto status_or_kem_key = sender_kem->GenerateKey(
       HashType::SHA256, test::HexDecodeOrDie(salt_hex),
       test::HexDecodeOrDie(info_hex), out_len, EcPointFormat::COMPRESSED);
-  ASSERT_THAT(status_or_kem_key.status(), IsOk());
+  ASSERT_THAT(status_or_kem_key, IsOk());
   auto kem_key = std::move(status_or_kem_key.value());
 
   // Initializing recipient's KEM data structure using recipient's private keys
   auto status_or_recipient_kem = Cecpq2HkdfRecipientKemBoringSsl::New(
       EllipticCurveType::CURVE25519, cecpq2_key_pair.x25519_key_pair.priv,
       std::move(cecpq2_key_pair.hrss_key_pair.hrss_private_key_seed));
-  ASSERT_THAT(status_or_recipient_kem.status(), IsOk());
+  ASSERT_THAT(status_or_recipient_kem, IsOk());
   auto recipient_kem = std::move(status_or_recipient_kem.value());
 
   // Here, we corrupt kem_bytes (we change all bytes to "a") so that
diff --git a/cc/experimental/pqcrypto/signature/dilithium_key_template_test.cc b/cc/experimental/pqcrypto/signature/dilithium_key_template_test.cc
index fdc731d28..f4b285872 100644
--- a/cc/experimental/pqcrypto/signature/dilithium_key_template_test.cc
+++ b/cc/experimental/pqcrypto/signature/dilithium_key_template_test.cc
@@ -101,7 +101,7 @@ TEST_P(DilithiumKeyTemplateTest, KeyManagerCompatibility) {
 
   util::StatusOr<std::unique_ptr<portable_proto::MessageLite>> new_key_result =
       key_manager->get_key_factory().NewKey(key_format);
-  EXPECT_THAT(new_key_result.status(), IsOk());
+  EXPECT_THAT(new_key_result, IsOk());
 }
 
 INSTANTIATE_TEST_SUITE_P(
diff --git a/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager_test.cc b/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager_test.cc
index a67756d1c..92f542385 100644
--- a/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/signature/dilithium_sign_key_manager_test.cc
@@ -92,7 +92,7 @@ TEST_P(DilithiumSignKeyManagerTest, ValidateKeyFormat) {
 
   StatusOr<DilithiumKeyFormat> key_format = CreateValidKeyFormat(
       test_case.private_key_size, test_case.seed_expansion);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   EXPECT_THAT(DilithiumSignKeyManager().ValidateKeyFormat(*key_format), IsOk());
 }
@@ -102,11 +102,11 @@ TEST_P(DilithiumSignKeyManagerTest, PrivateKeyWrongVersion) {
 
   StatusOr<DilithiumKeyFormat> key_format = CreateValidKeyFormat(
       test_case.private_key_size, test_case.seed_expansion);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   StatusOr<DilithiumPrivateKey> private_key =
       DilithiumSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   private_key->set_version(1);
   EXPECT_THAT(DilithiumSignKeyManager().ValidateKey(*private_key), Not(IsOk()));
@@ -117,11 +117,11 @@ TEST_P(DilithiumSignKeyManagerTest, CreateKey) {
 
   StatusOr<DilithiumKeyFormat> key_format = CreateValidKeyFormat(
       test_case.private_key_size, test_case.seed_expansion);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   StatusOr<DilithiumPrivateKey> private_key =
       DilithiumSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   EXPECT_THAT(private_key->version(), Eq(0));
   EXPECT_THAT(private_key->public_key().version(), Eq(private_key->version()));
@@ -135,11 +135,11 @@ TEST_P(DilithiumSignKeyManagerTest, CreateKeyValid) {
 
   StatusOr<DilithiumKeyFormat> key_format = CreateValidKeyFormat(
       test_case.private_key_size, test_case.seed_expansion);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   StatusOr<DilithiumPrivateKey> private_key =
       DilithiumSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
   EXPECT_THAT(DilithiumSignKeyManager().ValidateKey(*private_key), IsOk());
 }
 
@@ -148,14 +148,14 @@ TEST_P(DilithiumSignKeyManagerTest, CreateKeyAlwaysNew) {
 
   StatusOr<DilithiumKeyFormat> key_format = CreateValidKeyFormat(
       test_case.private_key_size, test_case.seed_expansion);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   absl::flat_hash_set<std::string> keys;
   int num_tests = 100;
   for (int i = 0; i < num_tests; ++i) {
     StatusOr<DilithiumPrivateKey> private_key =
         DilithiumSignKeyManager().CreateKey(*key_format);
-    ASSERT_THAT(private_key.status(), IsOk());
+    ASSERT_THAT(private_key, IsOk());
     keys.insert(private_key->key_value());
   }
   EXPECT_THAT(keys, SizeIs(num_tests));
@@ -166,15 +166,15 @@ TEST_P(DilithiumSignKeyManagerTest, GetPublicKey) {
 
   StatusOr<DilithiumKeyFormat> key_format = CreateValidKeyFormat(
       test_case.private_key_size, test_case.seed_expansion);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   StatusOr<DilithiumPrivateKey> private_key =
       DilithiumSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   StatusOr<DilithiumPublicKey> public_key_or =
       DilithiumSignKeyManager().GetPublicKey(*private_key);
-  ASSERT_THAT(public_key_or.status(), IsOk());
+  ASSERT_THAT(public_key_or, IsOk());
 
   EXPECT_THAT(public_key_or->version(),
               Eq(private_key->public_key().version()));
@@ -187,15 +187,15 @@ TEST_P(DilithiumSignKeyManagerTest, Create) {
 
   StatusOr<DilithiumKeyFormat> key_format = CreateValidKeyFormat(
       test_case.private_key_size, test_case.seed_expansion);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   util::StatusOr<DilithiumPrivateKey> private_key =
       DilithiumSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       DilithiumSignKeyManager().GetPrimitive<PublicKeySign>(*private_key);
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   util::StatusOr<DilithiumPublicKeyPqclean> dilithium_public_key =
       DilithiumPublicKeyPqclean::NewPublicKey(
@@ -204,11 +204,11 @@ TEST_P(DilithiumSignKeyManagerTest, Create) {
 
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       subtle::DilithiumAvx2Verify::New(*dilithium_public_key);
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   std::string message = "Some message";
   util::StatusOr<std::string> signature = (*signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
   EXPECT_THAT((*verifier)->Verify(*signature, message), IsOk());
 }
 
@@ -217,15 +217,15 @@ TEST_P(DilithiumSignKeyManagerTest, CreateDifferentKey) {
 
   StatusOr<DilithiumKeyFormat> key_format = CreateValidKeyFormat(
       test_case.private_key_size, test_case.seed_expansion);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   util::StatusOr<DilithiumPrivateKey> private_key =
       DilithiumSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       DilithiumSignKeyManager().GetPrimitive<PublicKeySign>(*private_key);
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   std::string bad_public_key_data(test_case.public_key_size, '@');
   util::StatusOr<DilithiumPublicKeyPqclean> dilithium_public_key =
@@ -234,11 +234,11 @@ TEST_P(DilithiumSignKeyManagerTest, CreateDifferentKey) {
           EnumsPqcrypto::ProtoToSubtle(test_case.seed_expansion));
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       subtle::DilithiumAvx2Verify::New(*dilithium_public_key);
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   std::string message = "Some message";
   util::StatusOr<std::string> signature = (*signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
   EXPECT_THAT((*verifier)->Verify(*signature, message), Not(IsOk()));
 }
 
diff --git a/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager_test.cc b/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager_test.cc
index 3461bbaf0..e9c169544 100644
--- a/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/signature/dilithium_verify_key_manager_test.cc
@@ -118,7 +118,7 @@ TEST_P(DilithiumVerifyKeyManagerTest, PublicKeyValid) {
 
   StatusOr<DilithiumPublicKey> public_key = CreateValidPublicKey(
       test_case.private_key_size, test_case.seed_expansion);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   EXPECT_THAT(DilithiumVerifyKeyManager().ValidateKey(*public_key), IsOk());
 }
@@ -128,7 +128,7 @@ TEST_P(DilithiumVerifyKeyManagerTest, PublicKeyWrongVersion) {
 
   StatusOr<DilithiumPublicKey> public_key = CreateValidPublicKey(
       test_case.private_key_size, test_case.seed_expansion);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   public_key->set_version(1);
   EXPECT_THAT(DilithiumVerifyKeyManager().ValidateKey(*public_key),
@@ -140,7 +140,7 @@ TEST_P(DilithiumVerifyKeyManagerTest, PublicKeyWrongKeyLength) {
 
   StatusOr<DilithiumPublicKey> public_key = CreateValidPublicKey(
       test_case.private_key_size, test_case.seed_expansion);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   for (int keysize = 0; keysize < PQCLEAN_DILITHIUM2_CRYPTO_PUBLICKEYBYTES;
        keysize++) {
@@ -155,29 +155,29 @@ TEST_P(DilithiumVerifyKeyManagerTest, Create) {
 
   StatusOr<DilithiumPrivateKey> private_key = CreateValidPrivateKey(
       test_case.private_key_size, test_case.seed_expansion);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   StatusOr<DilithiumPublicKey> public_key =
       DilithiumSignKeyManager().GetPublicKey(*private_key);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   util::StatusOr<DilithiumPrivateKeyPqclean> dilithium_private_key =
       DilithiumPrivateKeyPqclean::NewPrivateKey(
           util::SecretDataFromStringView(private_key->key_value()),
           EnumsPqcrypto::ProtoToSubtle(test_case.seed_expansion));
-  ASSERT_THAT(dilithium_private_key.status(), IsOk());
+  ASSERT_THAT(dilithium_private_key, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> direct_signer =
       subtle::DilithiumAvx2Sign::New(*dilithium_private_key);
-  ASSERT_THAT(direct_signer.status(), IsOk());
+  ASSERT_THAT(direct_signer, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       DilithiumVerifyKeyManager().GetPrimitive<PublicKeyVerify>(*public_key);
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   std::string message = "Some message";
   util::StatusOr<std::string> signature = (*direct_signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
   EXPECT_THAT((*verifier)->Verify(*signature, message), IsOk());
 }
 
@@ -186,33 +186,33 @@ TEST_P(DilithiumVerifyKeyManagerTest, CreateDifferentPublicKey) {
 
   StatusOr<DilithiumPrivateKey> private_key = CreateValidPrivateKey(
       test_case.private_key_size, test_case.seed_expansion);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   // Create a new public key derived from a diffferent private key.
   StatusOr<DilithiumPrivateKey> new_private_key = CreateValidPrivateKey(
       test_case.private_key_size, test_case.seed_expansion);
-  ASSERT_THAT(new_private_key.status(), IsOk());
+  ASSERT_THAT(new_private_key, IsOk());
   StatusOr<DilithiumPublicKey> public_key =
       DilithiumSignKeyManager().GetPublicKey(*new_private_key);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   util::StatusOr<DilithiumPrivateKeyPqclean> dilithium_private_key =
       DilithiumPrivateKeyPqclean::NewPrivateKey(
           util::SecretDataFromStringView(private_key->key_value()),
           EnumsPqcrypto::ProtoToSubtle(test_case.seed_expansion));
-  ASSERT_THAT(dilithium_private_key.status(), IsOk());
+  ASSERT_THAT(dilithium_private_key, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> direct_signer =
       subtle::DilithiumAvx2Sign::New(*dilithium_private_key);
-  ASSERT_THAT(direct_signer.status(), IsOk());
+  ASSERT_THAT(direct_signer, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       DilithiumVerifyKeyManager().GetPrimitive<PublicKeyVerify>(*public_key);
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   std::string message = "Some message";
   util::StatusOr<std::string> signature = (*direct_signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
   EXPECT_THAT((*verifier)->Verify(*signature, message), Not(IsOk()));
 }
 
diff --git a/cc/experimental/pqcrypto/signature/falcon_key_template_test.cc b/cc/experimental/pqcrypto/signature/falcon_key_template_test.cc
index 9f4a803be..8c9c16724 100644
--- a/cc/experimental/pqcrypto/signature/falcon_key_template_test.cc
+++ b/cc/experimental/pqcrypto/signature/falcon_key_template_test.cc
@@ -79,7 +79,7 @@ TEST_P(FalconKeyTemplateTest, KeyManagerCompatibility) {
 
   util::StatusOr<std::unique_ptr<portable_proto::MessageLite>> new_key_result =
       key_manager->get_key_factory().NewKey(key_format);
-  EXPECT_THAT(new_key_result.status(), IsOk());
+  EXPECT_THAT(new_key_result, IsOk());
 }
 
 INSTANTIATE_TEST_SUITE_P(
diff --git a/cc/experimental/pqcrypto/signature/falcon_sign_key_manager_test.cc b/cc/experimental/pqcrypto/signature/falcon_sign_key_manager_test.cc
index 9c110af91..eccd0bba1 100644
--- a/cc/experimental/pqcrypto/signature/falcon_sign_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/signature/falcon_sign_key_manager_test.cc
@@ -74,14 +74,14 @@ TEST_P(FalconSignKeyManagerTest, ValidKeyFormat) {
 
   StatusOr<FalconKeyFormat> key_format =
       CreateValidKeyFormat(test_case.private_key_size);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   EXPECT_THAT(FalconSignKeyManager().ValidateKeyFormat(*key_format), IsOk());
 }
 
 TEST(FalconSignKeyManagerTest, InvalidKeyFormat) {
   StatusOr<FalconKeyFormat> key_format = CreateValidKeyFormat(0);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   EXPECT_THAT(FalconSignKeyManager().ValidateKeyFormat(*key_format),
               Not(IsOk()));
@@ -92,11 +92,11 @@ TEST_P(FalconSignKeyManagerTest, CreateKeyValid) {
 
   StatusOr<FalconKeyFormat> key_format =
       CreateValidKeyFormat(test_case.private_key_size);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   StatusOr<FalconPrivateKey> private_key =
       FalconSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   EXPECT_THAT(FalconSignKeyManager().ValidateKey(*private_key), IsOk());
   EXPECT_THAT(private_key->version(), Eq(0));
@@ -109,11 +109,11 @@ TEST_P(FalconSignKeyManagerTest, PrivateKeyWrongVersion) {
 
   StatusOr<FalconKeyFormat> key_format =
       CreateValidKeyFormat(test_case.private_key_size);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   StatusOr<FalconPrivateKey> private_key =
       FalconSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   private_key->set_version(1);
   EXPECT_THAT(FalconSignKeyManager().ValidateKey(*private_key), Not(IsOk()));
@@ -124,14 +124,14 @@ TEST_P(FalconSignKeyManagerTest, CreateKeyAlwaysNew) {
 
   StatusOr<FalconKeyFormat> key_format =
       CreateValidKeyFormat(test_case.private_key_size);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   absl::flat_hash_set<std::string> keys;
   int num_tests = 5;
   for (int i = 0; i < num_tests; ++i) {
     StatusOr<FalconPrivateKey> private_key =
         FalconSignKeyManager().CreateKey(*key_format);
-    ASSERT_THAT(private_key.status(), IsOk());
+    ASSERT_THAT(private_key, IsOk());
     keys.insert(private_key->key_value());
   }
   EXPECT_THAT(keys, SizeIs(num_tests));
@@ -142,15 +142,15 @@ TEST_P(FalconSignKeyManagerTest, GetPublicKey) {
 
   StatusOr<FalconKeyFormat> key_format =
       CreateValidKeyFormat(test_case.private_key_size);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   StatusOr<FalconPrivateKey> private_key =
       FalconSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   StatusOr<FalconPublicKey> public_key =
       FalconSignKeyManager().GetPublicKey(*private_key);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   EXPECT_THAT(public_key->version(), Eq(private_key->public_key().version()));
   EXPECT_THAT(public_key->key_value(),
@@ -162,28 +162,28 @@ TEST_P(FalconSignKeyManagerTest, CreateValid) {
 
   StatusOr<FalconKeyFormat> key_format =
       CreateValidKeyFormat(test_case.private_key_size);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   util::StatusOr<FalconPrivateKey> private_key =
       FalconSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       FalconSignKeyManager().GetPrimitive<PublicKeySign>(*private_key);
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   StatusOr<subtle::FalconPublicKeyPqclean> falcon_public_key_pqclean =
       subtle::FalconPublicKeyPqclean::NewPublicKey(
           private_key->public_key().key_value());
-  ASSERT_THAT(falcon_public_key_pqclean.status(), IsOk());
+  ASSERT_THAT(falcon_public_key_pqclean, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       subtle::FalconVerify::New(*falcon_public_key_pqclean);
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   std::string message = "Some message";
   util::StatusOr<std::string> signature = (*signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
   EXPECT_THAT((*verifier)->Verify(*signature, message), IsOk());
 }
 
@@ -192,28 +192,28 @@ TEST_P(FalconSignKeyManagerTest, CreateBadPublicKey) {
 
   StatusOr<FalconKeyFormat> key_format =
       CreateValidKeyFormat(test_case.private_key_size);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   util::StatusOr<FalconPrivateKey> private_key =
       FalconSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       FalconSignKeyManager().GetPrimitive<PublicKeySign>(*private_key);
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   std::string bad_public_key_data(test_case.public_key_size, '@');
 
   StatusOr<subtle::FalconPublicKeyPqclean> falcon_public_key_pqclean =
       subtle::FalconPublicKeyPqclean::NewPublicKey(bad_public_key_data);
-  ASSERT_THAT(falcon_public_key_pqclean.status(), IsOk());
+  ASSERT_THAT(falcon_public_key_pqclean, IsOk());
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> direct_verifier =
       subtle::FalconVerify::New(*falcon_public_key_pqclean);
-  ASSERT_THAT(direct_verifier.status(), IsOk());
+  ASSERT_THAT(direct_verifier, IsOk());
 
   std::string message = "Some message";
   util::StatusOr<std::string> signature = (*signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
   EXPECT_THAT((*direct_verifier)->Verify(*signature, message), Not(IsOk()));
 }
 
diff --git a/cc/experimental/pqcrypto/signature/falcon_verify_key_manager_test.cc b/cc/experimental/pqcrypto/signature/falcon_verify_key_manager_test.cc
index b2500baf7..c486288bc 100644
--- a/cc/experimental/pqcrypto/signature/falcon_verify_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/signature/falcon_verify_key_manager_test.cc
@@ -88,7 +88,7 @@ TEST_P(FalconVerifyKeyManagerTest, PublicKeyValid) {
 
   StatusOr<FalconPublicKey> public_key =
       CreateValidPublicKey(test_case.private_key_size);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   EXPECT_THAT(FalconVerifyKeyManager().ValidateKey(*public_key), IsOk());
 }
@@ -98,7 +98,7 @@ TEST_P(FalconVerifyKeyManagerTest, PublicKeyWrongVersion) {
 
   StatusOr<FalconPublicKey> public_key =
       CreateValidPublicKey(test_case.private_key_size);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   public_key->set_version(1);
   EXPECT_THAT(FalconVerifyKeyManager().ValidateKey(*public_key), Not(IsOk()));
@@ -109,11 +109,11 @@ TEST_P(FalconVerifyKeyManagerTest, Create) {
 
   StatusOr<FalconPrivateKey> private_key =
       CreateValidPrivateKey(test_case.private_key_size);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   StatusOr<FalconPublicKey> public_key =
       FalconSignKeyManager().GetPublicKey(*private_key);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   StatusOr<subtle::FalconPrivateKeyPqclean> falcon_private_key_pqclean =
       subtle::FalconPrivateKeyPqclean::NewPrivateKey(
@@ -121,15 +121,15 @@ TEST_P(FalconVerifyKeyManagerTest, Create) {
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> direct_signer =
       subtle::FalconSign::New(*falcon_private_key_pqclean);
-  ASSERT_THAT(direct_signer.status(), IsOk());
+  ASSERT_THAT(direct_signer, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       FalconVerifyKeyManager().GetPrimitive<PublicKeyVerify>(*public_key);
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   std::string message = "Some message";
   util::StatusOr<std::string> signature = (*direct_signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
   EXPECT_THAT((*verifier)->Verify(*signature, message), IsOk());
 }
 
@@ -138,18 +138,18 @@ TEST_P(FalconVerifyKeyManagerTest, CreateInvalidPublicKey) {
 
   StatusOr<FalconPrivateKey> private_key =
       CreateValidPrivateKey(test_case.private_key_size);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   StatusOr<FalconPublicKey> public_key =
       FalconSignKeyManager().GetPublicKey(*private_key);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   std::string bad_public_key_data = "bad_public_key";
   public_key->set_key_value(bad_public_key_data);
 
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       FalconVerifyKeyManager().GetPrimitive<PublicKeyVerify>(*public_key);
-  EXPECT_THAT(verifier.status(), Not(IsOk()));
+  EXPECT_THAT(verifier, Not(IsOk()));
 }
 
 TEST_P(FalconVerifyKeyManagerTest, CreateDifferentPublicKey) {
@@ -157,15 +157,15 @@ TEST_P(FalconVerifyKeyManagerTest, CreateDifferentPublicKey) {
 
   StatusOr<FalconPrivateKey> private_key =
       CreateValidPrivateKey(test_case.private_key_size);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   // Create a new public key derived from a diffferent private key.
   StatusOr<FalconPrivateKey> new_private_key =
       CreateValidPrivateKey(test_case.private_key_size);
-  ASSERT_THAT(new_private_key.status(), IsOk());
+  ASSERT_THAT(new_private_key, IsOk());
   StatusOr<FalconPublicKey> public_key =
       FalconSignKeyManager().GetPublicKey(*new_private_key);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   StatusOr<subtle::FalconPrivateKeyPqclean> falcon_private_key_pqclean =
       subtle::FalconPrivateKeyPqclean::NewPrivateKey(
@@ -173,15 +173,15 @@ TEST_P(FalconVerifyKeyManagerTest, CreateDifferentPublicKey) {
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> direct_signer =
       subtle::FalconSign::New(*falcon_private_key_pqclean);
-  ASSERT_THAT(direct_signer.status(), IsOk());
+  ASSERT_THAT(direct_signer, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       FalconVerifyKeyManager().GetPrimitive<PublicKeyVerify>(*public_key);
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   std::string message = "Some message";
   util::StatusOr<std::string> signature = (*direct_signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
   EXPECT_THAT((*verifier)->Verify(*signature, message), Not(IsOk()));
 }
 
diff --git a/cc/experimental/pqcrypto/signature/signature_config_util_test.cc b/cc/experimental/pqcrypto/signature/signature_config_util_test.cc
index 5b8a8202f..13bc1558b 100644
--- a/cc/experimental/pqcrypto/signature/signature_config_util_test.cc
+++ b/cc/experimental/pqcrypto/signature/signature_config_util_test.cc
@@ -69,21 +69,21 @@ TEST_F(PcqSignatureConfigTest, PublicKeySignWrapperRegistered) {
   auto primitive_set = absl::make_unique<PrimitiveSet<PublicKeySign>>();
   auto add_primitive = primitive_set->AddPrimitive(
       absl::make_unique<DummyPublicKeySign>("dummy"), key_info);
-  ASSERT_THAT(add_primitive.status(), IsOk());
+  ASSERT_THAT(add_primitive, IsOk());
   ASSERT_THAT(primitive_set->set_primary(*add_primitive), IsOk());
 
   util::StatusOr<std::unique_ptr<crypto::tink::PublicKeySign>> wrapped =
       Registry::Wrap(std::move(primitive_set));
-  ASSERT_THAT(wrapped.status(), IsOk());
+  ASSERT_THAT(wrapped, IsOk());
 
   util::StatusOr<std::string> signature_result = (*wrapped)->Sign("message");
-  ASSERT_THAT(signature_result.status(), IsOk());
+  ASSERT_THAT(signature_result, IsOk());
 
   util::StatusOr<std::string> prefix = CryptoFormat::GetOutputPrefix(key_info);
-  ASSERT_THAT(prefix.status(), IsOk());
+  ASSERT_THAT(prefix, IsOk());
   util::StatusOr<std::string> signature =
       DummyPublicKeySign("dummy").Sign("message");
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   EXPECT_EQ(*signature_result, absl::StrCat(*prefix, *signature));
 }
@@ -105,18 +105,18 @@ TEST_F(PcqSignatureConfigTest, PublicKeyVerifyWrapperRegistered) {
   auto primitive_set = absl::make_unique<PrimitiveSet<PublicKeyVerify>>();
   auto add_primitive = primitive_set->AddPrimitive(
       absl::make_unique<DummyPublicKeyVerify>("dummy"), key_info);
-  ASSERT_THAT(add_primitive.status(), IsOk());
+  ASSERT_THAT(add_primitive, IsOk());
   ASSERT_THAT(primitive_set->set_primary(*add_primitive), IsOk());
 
   util::StatusOr<std::unique_ptr<crypto::tink::PublicKeyVerify>> wrapped =
       Registry::Wrap(std::move(primitive_set));
-  ASSERT_THAT(wrapped.status(), IsOk());
+  ASSERT_THAT(wrapped, IsOk());
 
   util::StatusOr<std::string> prefix = CryptoFormat::GetOutputPrefix(key_info);
-  ASSERT_THAT(prefix.status(), IsOk());
+  ASSERT_THAT(prefix, IsOk());
   util::StatusOr<std::string> signature =
       DummyPublicKeySign("dummy").Sign("message");
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   ASSERT_THAT((*wrapped)->Verify(absl::StrCat(*prefix, *signature), "message"),
               IsOk());
diff --git a/cc/experimental/pqcrypto/signature/sphincs_key_template_test.cc b/cc/experimental/pqcrypto/signature/sphincs_key_template_test.cc
index 6be0c20b5..071feb4fb 100644
--- a/cc/experimental/pqcrypto/signature/sphincs_key_template_test.cc
+++ b/cc/experimental/pqcrypto/signature/sphincs_key_template_test.cc
@@ -132,7 +132,7 @@ TEST_P(SphincsKeyTemplateTest, KeyManagerCompatibility) {
 
   util::StatusOr<std::unique_ptr<portable_proto::MessageLite>> new_key_result =
       key_manager->get_key_factory().NewKey(key_format);
-  EXPECT_THAT(new_key_result.status(), IsOk());
+  EXPECT_THAT(new_key_result, IsOk());
 }
 
 INSTANTIATE_TEST_SUITE_P(
diff --git a/cc/experimental/pqcrypto/signature/sphincs_sign_key_manager_test.cc b/cc/experimental/pqcrypto/signature/sphincs_sign_key_manager_test.cc
index 249b5e603..d621f6902 100644
--- a/cc/experimental/pqcrypto/signature/sphincs_sign_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/signature/sphincs_sign_key_manager_test.cc
@@ -132,7 +132,7 @@ TEST_P(SphincsSignKeyManagerTest, ValidKeyFormat) {
   StatusOr<SphincsKeyFormat> key_format =
       CreateValidKeyFormat(test_case.private_key_size, test_case.hash_type,
                            test_case.variant, test_case.sig_length_type);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   EXPECT_THAT(SphincsSignKeyManager().ValidateKeyFormat(*key_format), IsOk());
 }
@@ -141,7 +141,7 @@ TEST(SphincsSignKeyManagerTest, InvalidKeyFormat) {
   StatusOr<SphincsKeyFormat> key_format = CreateValidKeyFormat(
       subtle::kSphincsPrivateKeySize64, SphincsHashType::UNKNOWN_HASH_TYPE,
       SphincsVariant::UNKNOWN_VARIANT, SphincsSignatureType::UNKNOWN_SIG_TYPE);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   EXPECT_THAT(SphincsSignKeyManager().ValidateKeyFormat(*key_format),
               Not(IsOk()));
@@ -153,11 +153,11 @@ TEST_P(SphincsSignKeyManagerTest, CreateKeyValid) {
   StatusOr<SphincsKeyFormat> key_format =
       CreateValidKeyFormat(test_case.private_key_size, test_case.hash_type,
                            test_case.variant, test_case.sig_length_type);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   StatusOr<SphincsPrivateKey> private_key =
       SphincsSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   EXPECT_THAT(SphincsSignKeyManager().ValidateKey(*private_key), IsOk());
   EXPECT_THAT(private_key->version(), Eq(0));
@@ -171,11 +171,11 @@ TEST_P(SphincsSignKeyManagerTest, PrivateKeyWrongVersion) {
   StatusOr<SphincsKeyFormat> key_format =
       CreateValidKeyFormat(test_case.private_key_size, test_case.hash_type,
                            test_case.variant, test_case.sig_length_type);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   StatusOr<SphincsPrivateKey> private_key =
       SphincsSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   private_key->set_version(1);
   EXPECT_THAT(SphincsSignKeyManager().ValidateKey(*private_key), Not(IsOk()));
@@ -185,11 +185,11 @@ TEST(SphincsSignKeyManagerTest, CreateKeyInvalidParams) {
   StatusOr<SphincsKeyFormat> key_format = CreateValidKeyFormat(
       subtle::kSphincsPrivateKeySize64, SphincsHashType::UNKNOWN_HASH_TYPE,
       SphincsVariant::UNKNOWN_VARIANT, SphincsSignatureType::UNKNOWN_SIG_TYPE);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   StatusOr<SphincsPrivateKey> private_key =
       SphincsSignKeyManager().CreateKey(*key_format);
-  EXPECT_THAT(private_key.status(), Not(IsOk()));
+  EXPECT_THAT(private_key, Not(IsOk()));
 }
 
 TEST_P(SphincsSignKeyManagerTest, CreateKeyAlwaysNew) {
@@ -198,14 +198,14 @@ TEST_P(SphincsSignKeyManagerTest, CreateKeyAlwaysNew) {
   StatusOr<SphincsKeyFormat> key_format =
       CreateValidKeyFormat(test_case.private_key_size, test_case.hash_type,
                            test_case.variant, test_case.sig_length_type);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   absl::flat_hash_set<std::string> keys;
   int num_tests = 5;
   for (int i = 0; i < num_tests; ++i) {
     StatusOr<SphincsPrivateKey> private_key =
         SphincsSignKeyManager().CreateKey(*key_format);
-    ASSERT_THAT(private_key.status(), IsOk());
+    ASSERT_THAT(private_key, IsOk());
     keys.insert(private_key->key_value());
   }
   EXPECT_THAT(keys, SizeIs(num_tests));
@@ -217,15 +217,15 @@ TEST_P(SphincsSignKeyManagerTest, GetPublicKey) {
   StatusOr<SphincsKeyFormat> key_format =
       CreateValidKeyFormat(test_case.private_key_size, test_case.hash_type,
                            test_case.variant, test_case.sig_length_type);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   StatusOr<SphincsPrivateKey> private_key =
       SphincsSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   StatusOr<SphincsPublicKey> public_key_or =
       SphincsSignKeyManager().GetPublicKey(*private_key);
-  ASSERT_THAT(public_key_or.status(), IsOk());
+  ASSERT_THAT(public_key_or, IsOk());
 
   EXPECT_THAT(public_key_or->version(),
               Eq(private_key->public_key().version()));
@@ -239,15 +239,15 @@ TEST_P(SphincsSignKeyManagerTest, CreateValid) {
   StatusOr<SphincsKeyFormat> key_format =
       CreateValidKeyFormat(test_case.private_key_size, test_case.hash_type,
                            test_case.variant, test_case.sig_length_type);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   util::StatusOr<SphincsPrivateKey> private_key =
       SphincsSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       SphincsSignKeyManager().GetPrimitive<PublicKeySign>(*private_key);
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   subtle::SphincsParamsPqclean sphincs_params_pqclean = {
       .hash_type = EnumsPqcrypto::ProtoToSubtle(test_case.hash_type),
@@ -261,11 +261,11 @@ TEST_P(SphincsSignKeyManagerTest, CreateValid) {
 
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       subtle::SphincsVerify::New(sphincs_public_key_pqclean);
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   std::string message = "Some message";
   util::StatusOr<std::string> signature = (*signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
   EXPECT_THAT((*verifier)->Verify(*signature, message), IsOk());
 }
 
@@ -275,15 +275,15 @@ TEST_P(SphincsSignKeyManagerTest, CreateBadPublicKey) {
   StatusOr<SphincsKeyFormat> key_format =
       CreateValidKeyFormat(test_case.private_key_size, test_case.hash_type,
                            test_case.variant, test_case.sig_length_type);
-  ASSERT_THAT(key_format.status(), IsOk());
+  ASSERT_THAT(key_format, IsOk());
 
   util::StatusOr<SphincsPrivateKey> private_key =
       SphincsSignKeyManager().CreateKey(*key_format);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       SphincsSignKeyManager().GetPrimitive<PublicKeySign>(*private_key);
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   std::string bad_public_key_data(test_case.public_key_size, '@');
 
@@ -298,11 +298,11 @@ TEST_P(SphincsSignKeyManagerTest, CreateBadPublicKey) {
                                                      sphincs_params_pqclean);
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> direct_verifier =
       subtle::SphincsVerify::New(sphincs_public_key_pqclean);
-  ASSERT_THAT(direct_verifier.status(), IsOk());
+  ASSERT_THAT(direct_verifier, IsOk());
 
   std::string message = "Some message";
   util::StatusOr<std::string> signature = (*signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
   EXPECT_THAT((*direct_verifier)->Verify(*signature, message), Not(IsOk()));
 }
 
diff --git a/cc/experimental/pqcrypto/signature/sphincs_verify_key_manager_test.cc b/cc/experimental/pqcrypto/signature/sphincs_verify_key_manager_test.cc
index 29b2acafa..9072c7373 100644
--- a/cc/experimental/pqcrypto/signature/sphincs_verify_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/signature/sphincs_verify_key_manager_test.cc
@@ -160,7 +160,7 @@ TEST_P(SphincsVerifyKeyManagerTest, PublicKeyValid) {
   StatusOr<SphincsPublicKey> public_key =
       CreateValidPublicKey(test_case.private_key_size, test_case.hash_type,
                            test_case.variant, test_case.sig_length_type);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   EXPECT_THAT(SphincsVerifyKeyManager().ValidateKey(*public_key), IsOk());
 }
@@ -169,7 +169,7 @@ TEST(SphincsVerifyKeyManagerTest, PublicKeyInvalidParams) {
   StatusOr<SphincsPublicKey> public_key = CreateValidPublicKey(
       subtle::kSphincsPrivateKeySize64, SphincsHashType::UNKNOWN_HASH_TYPE,
       SphincsVariant::UNKNOWN_VARIANT, SphincsSignatureType::UNKNOWN_SIG_TYPE);
-  EXPECT_THAT(public_key.status(), Not(IsOk()));
+  EXPECT_THAT(public_key, Not(IsOk()));
 }
 
 TEST_P(SphincsVerifyKeyManagerTest, PublicKeyWrongVersion) {
@@ -178,7 +178,7 @@ TEST_P(SphincsVerifyKeyManagerTest, PublicKeyWrongVersion) {
   StatusOr<SphincsPublicKey> public_key =
       CreateValidPublicKey(test_case.private_key_size, test_case.hash_type,
                            test_case.variant, test_case.sig_length_type);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   public_key->set_version(1);
   EXPECT_THAT(SphincsVerifyKeyManager().ValidateKey(*public_key), Not(IsOk()));
@@ -190,11 +190,11 @@ TEST_P(SphincsVerifyKeyManagerTest, Create) {
   StatusOr<SphincsPrivateKey> private_key =
       CreateValidPrivateKey(test_case.private_key_size, test_case.hash_type,
                             test_case.variant, test_case.sig_length_type);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   StatusOr<SphincsPublicKey> public_key =
       SphincsSignKeyManager().GetPublicKey(*private_key);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   subtle::SphincsParamsPqclean sphincs_params_pqclean = {
       .hash_type = EnumsPqcrypto::ProtoToSubtle(test_case.hash_type),
@@ -208,15 +208,15 @@ TEST_P(SphincsVerifyKeyManagerTest, Create) {
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> direct_signer =
       subtle::SphincsSign::New(sphincs_private_key_pqclean);
-  ASSERT_THAT(direct_signer.status(), IsOk());
+  ASSERT_THAT(direct_signer, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       SphincsVerifyKeyManager().GetPrimitive<PublicKeyVerify>(*public_key);
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   std::string message = "Some message";
   util::StatusOr<std::string> signature = (*direct_signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
   EXPECT_THAT((*verifier)->Verify(*signature, message), IsOk());
 }
 
@@ -226,18 +226,18 @@ TEST_P(SphincsVerifyKeyManagerTest, CreateInvalidPublicKey) {
   StatusOr<SphincsPrivateKey> private_key =
       CreateValidPrivateKey(test_case.private_key_size, test_case.hash_type,
                             test_case.variant, test_case.sig_length_type);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   StatusOr<SphincsPublicKey> public_key =
       SphincsSignKeyManager().GetPublicKey(*private_key);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   std::string bad_public_key_data = "bad_public_key";
   public_key->set_key_value(bad_public_key_data);
 
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       SphincsVerifyKeyManager().GetPrimitive<PublicKeyVerify>(*public_key);
-  EXPECT_THAT(verifier.status(), Not(IsOk()));
+  EXPECT_THAT(verifier, Not(IsOk()));
 }
 
 TEST_P(SphincsVerifyKeyManagerTest, CreateDifferentPublicKey) {
@@ -246,16 +246,16 @@ TEST_P(SphincsVerifyKeyManagerTest, CreateDifferentPublicKey) {
   StatusOr<SphincsPrivateKey> private_key =
       CreateValidPrivateKey(test_case.private_key_size, test_case.hash_type,
                             test_case.variant, test_case.sig_length_type);
-  ASSERT_THAT(private_key.status(), IsOk());
+  ASSERT_THAT(private_key, IsOk());
 
   // Create a new public key derived from a diffferent private key.
   StatusOr<SphincsPrivateKey> new_private_key =
       CreateValidPrivateKey(test_case.private_key_size, test_case.hash_type,
                             test_case.variant, test_case.sig_length_type);
-  ASSERT_THAT(new_private_key.status(), IsOk());
+  ASSERT_THAT(new_private_key, IsOk());
   StatusOr<SphincsPublicKey> public_key =
       SphincsSignKeyManager().GetPublicKey(*new_private_key);
-  ASSERT_THAT(public_key.status(), IsOk());
+  ASSERT_THAT(public_key, IsOk());
 
   subtle::SphincsParamsPqclean sphincs_params_pqclean = {
       .hash_type = EnumsPqcrypto::ProtoToSubtle(test_case.hash_type),
@@ -269,15 +269,15 @@ TEST_P(SphincsVerifyKeyManagerTest, CreateDifferentPublicKey) {
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> direct_signer =
       subtle::SphincsSign::New(sphincs_private_key_pqclean);
-  ASSERT_THAT(direct_signer.status(), IsOk());
+  ASSERT_THAT(direct_signer, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       SphincsVerifyKeyManager().GetPrimitive<PublicKeyVerify>(*public_key);
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   std::string message = "Some message";
   util::StatusOr<std::string> signature = (*direct_signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
   EXPECT_THAT((*verifier)->Verify(*signature, message), Not(IsOk()));
 }
 
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign_test.cc b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign_test.cc
index 3f7030f8c..a0dcba5c6 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_sign_test.cc
@@ -96,17 +96,17 @@ TEST_P(DilithiumAvx2SignTest, SignatureLength) {
       key_pair = DilithiumPrivateKeyPqclean::GenerateKeyPair(
           test_case.key_size, test_case.seed_expansion);
 
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       DilithiumAvx2Sign::New(key_pair->first);
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Sign a message.
   std::string message = "message to be signed";
   util::StatusOr<std::string> signature = (*std::move(signer))->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   // Check signature size.
   EXPECT_NE(*signature, message);
@@ -126,26 +126,26 @@ TEST_P(DilithiumAvx2SignTest, Determinism) {
       key_pair = DilithiumPrivateKeyPqclean::GenerateKeyPair(
           test_case.key_size, test_case.seed_expansion);
 
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create two signers based on same private key.
   util::StatusOr<std::unique_ptr<PublicKeySign>> first_signer =
       DilithiumAvx2Sign::New(key_pair->first);
-  ASSERT_THAT(first_signer.status(), IsOk());
+  ASSERT_THAT(first_signer, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> second_signer =
       DilithiumAvx2Sign::New(key_pair->first);
-  ASSERT_THAT(second_signer.status(), IsOk());
+  ASSERT_THAT(second_signer, IsOk());
 
   // Sign the same message twice, using the same private key.
   std::string message = "message to be signed";
   util::StatusOr<std::string> first_signature =
       (*std::move(first_signer))->Sign(message);
-  ASSERT_THAT(first_signature.status(), IsOk());
+  ASSERT_THAT(first_signature, IsOk());
 
   util::StatusOr<std::string> second_signature =
       (*std::move(second_signer))->Sign(message);
-  ASSERT_THAT(second_signature.status(), IsOk());
+  ASSERT_THAT(second_signature, IsOk());
 
   // Check signatures size.
   EXPECT_NE(*first_signature, message);
@@ -171,7 +171,7 @@ TEST_P(DilithiumAvx2SignTest, FipsMode) {
       key_pair = DilithiumPrivateKeyPqclean::GenerateKeyPair(
           test_case.key_size, test_case.seed_expansion);
 
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   EXPECT_THAT(DilithiumAvx2Sign::New(key_pair->first).status(),
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify_test.cc b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify_test.cc
index ef37f5a63..6d90fc3c7 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_avx2_verify_test.cc
@@ -103,22 +103,22 @@ TEST_P(DilithiumAvx2VerifyTest, BasicSignVerify) {
       key_pair = DilithiumPrivateKeyPqclean::GenerateKeyPair(
           test_case.key_size, test_case.seed_expansion);
 
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       DilithiumAvx2Sign::New(key_pair->first);
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Create a new verifier.
   absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       DilithiumAvx2Verify::New(key_pair->second);
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   // Sign a message.
   std::string message = "message to be signed";
   absl::StatusOr<std::string> signature = (*std::move(signer))->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   // Verify signature.
   Status status = (*verifier)->Verify(*signature, message);
@@ -138,22 +138,22 @@ TEST_P(DilithiumAvx2VerifyTest, FailsWithWrongMessage) {
       key_pair = DilithiumPrivateKeyPqclean::GenerateKeyPair(
           test_case.key_size, test_case.seed_expansion);
 
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       DilithiumAvx2Sign::New(key_pair->first);
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Create a new verifier.
   absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       DilithiumAvx2Verify::New(key_pair->second);
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   // Sign a message.
   std::string message = "message to be signed";
   absl::StatusOr<std::string> signature = (*std::move(signer))->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   // Verify signature.
   Status status = (*verifier)->Verify(*signature, "some bad message");
@@ -173,22 +173,22 @@ TEST_P(DilithiumAvx2VerifyTest, FailsWithWrongSignature) {
       key_pair = DilithiumPrivateKeyPqclean::GenerateKeyPair(
           test_case.key_size, test_case.seed_expansion);
 
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       DilithiumAvx2Sign::New(key_pair->first);
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Create a new verifier.
   absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       DilithiumAvx2Verify::New(key_pair->second);
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   // Sign a message.
   std::string message = "message to be signed";
   absl::StatusOr<std::string> signature = (*std::move(signer))->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   // Verify signature.
   Status status =
@@ -209,22 +209,22 @@ TEST_P(DilithiumAvx2VerifyTest, FailsWithByteFlipped) {
       key_pair = DilithiumPrivateKeyPqclean::GenerateKeyPair(
           test_case.key_size, test_case.seed_expansion);
 
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       DilithiumAvx2Sign::New(key_pair->first);
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Create a new verifier.
   absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       DilithiumAvx2Verify::New(key_pair->second);
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   // Sign a message.
   std::string message = "message to be signed";
   absl::StatusOr<std::string> signature = (*std::move(signer))->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   // Invalidate one signature byte.
   (*signature)[0] ^= 1;
@@ -247,7 +247,7 @@ TEST_P(DilithiumAvx2VerifyTest, FipsMode) {
       key_pair = DilithiumPrivateKeyPqclean::GenerateKeyPair(
           test_case.key_size, test_case.seed_expansion);
 
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   EXPECT_THAT(DilithiumAvx2Verify::New(key_pair->second).status(),
               StatusIs(absl::StatusCode::kInternal));
@@ -864,7 +864,7 @@ TEST(DilithiumAvx2VerifyTest, Vectors) {
     absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
         DilithiumAvx2Verify::New(*DilithiumPublicKeyPqclean::NewPublicKey(
             v.public_key, DilithiumSeedExpansion::SEED_EXPANSION_SHAKE));
-    ASSERT_THAT(verifier.status(), IsOk());
+    ASSERT_THAT(verifier, IsOk());
 
     // Verify signature.
     Status status = (*verifier)->Verify(v.signature, v.message);
@@ -1420,7 +1420,7 @@ TEST(DilithiumAvx2VerifyTest, AesVectors) {
     absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
         DilithiumAvx2Verify::New(*DilithiumPublicKeyPqclean::NewPublicKey(
             v.public_key, DilithiumSeedExpansion::SEED_EXPANSION_AES));
-    ASSERT_THAT(verifier.status(), IsOk());
+    ASSERT_THAT(verifier, IsOk());
 
     // Verify signature.
     Status status = (*verifier)->Verify(v.signature, v.message);
diff --git a/cc/experimental/pqcrypto/signature/subtle/dilithium_key_test.cc b/cc/experimental/pqcrypto/signature/subtle/dilithium_key_test.cc
index dd71572db..186ee00b2 100644
--- a/cc/experimental/pqcrypto/signature/subtle/dilithium_key_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/dilithium_key_test.cc
@@ -60,7 +60,7 @@ TEST_P(DilithiumKeyTest, DilithiumKeysLength) {
       key_pair = DilithiumPrivateKeyPqclean::GenerateKeyPair(
           test_case.private_key_size, test_case.seed_expansion);
 
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Check keys size.
   EXPECT_EQ((key_pair->first).GetKeyData().size(), test_case.private_key_size);
@@ -76,7 +76,7 @@ TEST_P(DilithiumKeyTest, DifferentContent) {
       key_pair = DilithiumPrivateKeyPqclean::GenerateKeyPair(
           test_case.private_key_size, test_case.seed_expansion);
 
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Check keys content is different.
   EXPECT_NE(util::SecretDataAsStringView(key_pair->first.GetKeyData()),
diff --git a/cc/experimental/pqcrypto/signature/subtle/falcon_sign_test.cc b/cc/experimental/pqcrypto/signature/subtle/falcon_sign_test.cc
index bca1e3648..639a69a44 100644
--- a/cc/experimental/pqcrypto/signature/subtle/falcon_sign_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/falcon_sign_test.cc
@@ -58,17 +58,17 @@ TEST_P(FalconSignTest, ValidSignatureLength) {
   // Generate falcon key pair.
   util::StatusOr<FalconKeyPair> key_pair =
       GenerateFalconKeyPair(test_case.private_key_size);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       FalconSign::New(key_pair->GetPrivateKey());
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Sign a message.
   std::string message = "message to be signed";
   util::StatusOr<std::string> signature = ((*signer)->Sign(message));
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   // Check signature size.
   EXPECT_NE(*signature, message);
@@ -85,20 +85,20 @@ TEST_P(FalconSignTest, NonDeterminism) {
   // Generate falcon key pair.
   util::StatusOr<FalconKeyPair> key_pair =
       GenerateFalconKeyPair(test_case.private_key_size);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create two signers based on same private key.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       FalconSign::New(key_pair->GetPrivateKey());
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Sign the same message twice, using the same private key.
   std::string message = "message to be signed";
   util::StatusOr<std::string> first_signature = ((*signer))->Sign(message);
-  ASSERT_THAT(first_signature.status(), IsOk());
+  ASSERT_THAT(first_signature, IsOk());
 
   util::StatusOr<std::string> second_signature = ((*signer))->Sign(message);
-  ASSERT_THAT(second_signature.status(), IsOk());
+  ASSERT_THAT(second_signature, IsOk());
 
   // Check signatures size.
   EXPECT_NE(*first_signature, message);
@@ -121,7 +121,7 @@ TEST_P(FalconSignTest, FipsMode) {
   // Generate falcon key pair.
   util::StatusOr<FalconKeyPair> key_pair =
       GenerateFalconKeyPair(test_case.private_key_size);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   EXPECT_THAT(FalconSign::New(key_pair->GetPrivateKey()).status(),
diff --git a/cc/experimental/pqcrypto/signature/subtle/falcon_subtle_utils_test.cc b/cc/experimental/pqcrypto/signature/subtle/falcon_subtle_utils_test.cc
index 4ac7782d8..0b0536324 100644
--- a/cc/experimental/pqcrypto/signature/subtle/falcon_subtle_utils_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/falcon_subtle_utils_test.cc
@@ -49,7 +49,7 @@ TEST_P(FalconUtilsTest, FalconKeyGeneration) {
   // Generate falcon key pair.
   util::StatusOr<FalconKeyPair> key_pair =
       GenerateFalconKeyPair(test_case.private_key_size);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Check keys size.
   EXPECT_EQ(key_pair->GetPrivateKey().GetKey().size(),
@@ -64,7 +64,7 @@ TEST_P(FalconUtilsTest, DifferentContent) {
   // Generate falcon key pair.
   util::StatusOr<FalconKeyPair> key_pair =
       GenerateFalconKeyPair(test_case.private_key_size);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Check keys content is different.
   EXPECT_NE(util::SecretDataAsStringView(key_pair->GetPrivateKey().GetKey()),
@@ -119,7 +119,7 @@ TEST(FalconUtilsTest, InvalidPubliceKey) {
   util::StatusOr<FalconPublicKeyPqclean> public_key =
       FalconPublicKeyPqclean::NewPublicKey(bad_public_key_data);
 
-  EXPECT_THAT(public_key.status(), Not(IsOk()));
+  EXPECT_THAT(public_key, Not(IsOk()));
 }
 
 INSTANTIATE_TEST_SUITE_P(
diff --git a/cc/experimental/pqcrypto/signature/subtle/falcon_verify_test.cc b/cc/experimental/pqcrypto/signature/subtle/falcon_verify_test.cc
index 8db691ed2..c1cad8dd9 100644
--- a/cc/experimental/pqcrypto/signature/subtle/falcon_verify_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/falcon_verify_test.cc
@@ -65,22 +65,22 @@ TEST_P(FalconVerifyTest, BasicSignVerify) {
   // Generate falcon key pair.
   util::StatusOr<FalconKeyPair> key_pair =
       GenerateFalconKeyPair(test_case.private_key_size);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       FalconSign::New(key_pair->GetPrivateKey());
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Sign a message.
   std::string message = "message to be signed";
   util::StatusOr<std::string> signature = (*signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   // Create a new verifier.
   absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       FalconVerify::New(key_pair->GetPublicKey());
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   // Verify signature.
   Status status = (*verifier)->Verify(*signature, message);
@@ -97,22 +97,22 @@ TEST_P(FalconVerifyTest, FailsWithWrongSignature) {
   // Generate falcon key pair.
   util::StatusOr<FalconKeyPair> key_pair =
       GenerateFalconKeyPair(test_case.private_key_size);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       FalconSign::New(key_pair->GetPrivateKey());
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Sign a message.
   std::string message = "message to be signed";
   util::StatusOr<std::string> signature = (*signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   // Create a new verifier.
   absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       FalconVerify::New(key_pair->GetPublicKey());
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   // Verify signature.
   Status status =
@@ -130,22 +130,22 @@ TEST_P(FalconVerifyTest, FailsWithWrongMessage) {
   // Generate falcon key pair.
   util::StatusOr<FalconKeyPair> key_pair =
       GenerateFalconKeyPair(test_case.private_key_size);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       FalconSign::New(key_pair->GetPrivateKey());
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Sign a message.
   std::string message = "message to be signed";
   util::StatusOr<std::string> signature = (*signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   // Create a new verifier.
   absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       FalconVerify::New(key_pair->GetPublicKey());
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   // Verify signature.
   Status status = (*verifier)->Verify(*signature, "some bad message");
@@ -162,22 +162,22 @@ TEST_P(FalconVerifyTest, FailsWithBytesFlipped) {
   // Generate falcon key pair.
   util::StatusOr<FalconKeyPair> key_pair =
       GenerateFalconKeyPair(test_case.private_key_size);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       FalconSign::New(key_pair->GetPrivateKey());
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Sign a message.
   std::string message = "message to be signed";
   util::StatusOr<std::string> signature = (*signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   // Create a new verifier.
   absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       FalconVerify::New(key_pair->GetPublicKey());
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   // Invalidate one signature byte.
   (*signature)[0] ^= 1;
@@ -197,7 +197,7 @@ TEST_P(FalconVerifyTest, FipsMode) {
   // Generate falcon key pair.
   util::StatusOr<FalconKeyPair> key_pair =
       GenerateFalconKeyPair(test_case.private_key_size);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   EXPECT_THAT(FalconVerify::New(key_pair->GetPublicKey()).status(),
diff --git a/cc/experimental/pqcrypto/signature/subtle/sphincs_sign_test.cc b/cc/experimental/pqcrypto/signature/subtle/sphincs_sign_test.cc
index ddb36e8c7..58df17cab 100644
--- a/cc/experimental/pqcrypto/signature/subtle/sphincs_sign_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/sphincs_sign_test.cc
@@ -107,17 +107,17 @@ TEST_P(SphincsSignTest, SignatureLength) {
 
   // Generate sphincs key pair.
   util::StatusOr<SphincsKeyPair> key_pair = GenerateSphincsKeyPair(params);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       SphincsSign::New(key_pair->GetPrivateKey());
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Sign a message.
   std::string message = "message to be signed";
   util::StatusOr<std::string> signature = (*signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   // Check signature size.
   EXPECT_NE(*signature, message);
@@ -140,25 +140,25 @@ TEST_P(SphincsSignTest, NonDeterminism) {
 
   // Generate sphincs key pair.
   util::StatusOr<SphincsKeyPair> key_pair = GenerateSphincsKeyPair(params);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create two signers based on same private key.
   util::StatusOr<std::unique_ptr<PublicKeySign>> first_signer =
       SphincsSign::New(key_pair->GetPrivateKey());
-  ASSERT_THAT(first_signer.status(), IsOk());
+  ASSERT_THAT(first_signer, IsOk());
 
   util::StatusOr<std::unique_ptr<PublicKeySign>> second_signer =
       SphincsSign::New(key_pair->GetPrivateKey());
-  ASSERT_THAT(second_signer.status(), IsOk());
+  ASSERT_THAT(second_signer, IsOk());
 
   // Sign the same message twice, using the same private key.
   std::string message = "message to be signed";
   util::StatusOr<std::string> first_signature = (*first_signer)->Sign(message);
-  ASSERT_THAT(first_signature.status(), IsOk());
+  ASSERT_THAT(first_signature, IsOk());
 
   util::StatusOr<std::string> second_signature =
       (*second_signer)->Sign(message);
-  ASSERT_THAT(second_signature.status(), IsOk());
+  ASSERT_THAT(second_signature, IsOk());
 
   // Check signatures size.
   EXPECT_NE(*first_signature, message);
@@ -187,7 +187,7 @@ TEST_P(SphincsSignTest, FipsMode) {
 
   // Generate sphincs key pair.
   util::StatusOr<SphincsKeyPair> key_pair = GenerateSphincsKeyPair(params);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   EXPECT_THAT(SphincsSign::New(key_pair->GetPrivateKey()).status(),
diff --git a/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils_test.cc b/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils_test.cc
index dca7bd0f1..a2e97c8c0 100644
--- a/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/sphincs_subtle_utils_test.cc
@@ -96,7 +96,7 @@ TEST_P(SphincsUtilsTest, SphincsKeysLength) {
 
   // Generate sphincs key pair.
   util::StatusOr<SphincsKeyPair> key_pair = GenerateSphincsKeyPair(params);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Check keys size.
   EXPECT_EQ(key_pair->GetPrivateKey().GetKey().size(),
@@ -117,7 +117,7 @@ TEST_P(SphincsUtilsTest, DifferentContent) {
 
   // Generate sphincs key pair.
   util::StatusOr<SphincsKeyPair> key_pair = GenerateSphincsKeyPair(params);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Check keys content is different.
   EXPECT_NE(util::SecretDataAsStringView(key_pair->GetPrivateKey().GetKey()),
diff --git a/cc/experimental/pqcrypto/signature/subtle/sphincs_verify_test.cc b/cc/experimental/pqcrypto/signature/subtle/sphincs_verify_test.cc
index 95f5a0bb4..544db9838 100644
--- a/cc/experimental/pqcrypto/signature/subtle/sphincs_verify_test.cc
+++ b/cc/experimental/pqcrypto/signature/subtle/sphincs_verify_test.cc
@@ -108,22 +108,22 @@ TEST_P(SphincsVerifyTest, BasicSignVerify) {
 
   // Generate sphincs key pair.
   util::StatusOr<SphincsKeyPair> key_pair = GenerateSphincsKeyPair(params);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       SphincsSign::New(key_pair->GetPrivateKey());
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Sign a message.
   std::string message = "message to be signed";
   util::StatusOr<std::string> signature = (*signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   // Create a new verifier.
   absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       SphincsVerify::New(key_pair->GetPublicKey());
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   // Verify signature.
   Status status = (*verifier)->Verify(*signature, message);
@@ -146,22 +146,22 @@ TEST_P(SphincsVerifyTest, FailsWithWrongSignature) {
 
   // Generate sphincs key pair.
   util::StatusOr<SphincsKeyPair> key_pair = GenerateSphincsKeyPair(params);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       SphincsSign::New(key_pair->GetPrivateKey());
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Sign a message.
   std::string message = "message to be signed";
   util::StatusOr<std::string> signature = (*signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   // Create a new verifier.
   absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       SphincsVerify::New(key_pair->GetPublicKey());
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   // Verify signature.
   Status status =
@@ -185,22 +185,22 @@ TEST_P(SphincsVerifyTest, FailsWithWrongMessage) {
 
   // Generate sphincs key pair.
   util::StatusOr<SphincsKeyPair> key_pair = GenerateSphincsKeyPair(params);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       SphincsSign::New(key_pair->GetPrivateKey());
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Sign a message.
   std::string message = "message to be signed";
   util::StatusOr<std::string> signature = (*signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   // Create a new verifier.
   absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       SphincsVerify::New(key_pair->GetPublicKey());
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   // Verify signature.
   Status status = (*verifier)->Verify(*signature, "some bad message");
@@ -223,22 +223,22 @@ TEST_P(SphincsVerifyTest, FailsWithBytesFlipped) {
 
   // Generate sphincs key pair.
   util::StatusOr<SphincsKeyPair> key_pair = GenerateSphincsKeyPair(params);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   util::StatusOr<std::unique_ptr<PublicKeySign>> signer =
       SphincsSign::New(key_pair->GetPrivateKey());
-  ASSERT_THAT(signer.status(), IsOk());
+  ASSERT_THAT(signer, IsOk());
 
   // Sign a message.
   std::string message = "message to be signed";
   util::StatusOr<std::string> signature = (*signer)->Sign(message);
-  ASSERT_THAT(signature.status(), IsOk());
+  ASSERT_THAT(signature, IsOk());
 
   // Create a new verifier.
   absl::StatusOr<std::unique_ptr<PublicKeyVerify>> verifier =
       SphincsVerify::New(key_pair->GetPublicKey());
-  ASSERT_THAT(verifier.status(), IsOk());
+  ASSERT_THAT(verifier, IsOk());
 
   // Invalidate one signature byte.
   (*signature)[0] ^= 1;
@@ -264,7 +264,7 @@ TEST_P(SphincsVerifyTest, FipsMode) {
 
   // Generate sphincs key pair.
   util::StatusOr<SphincsKeyPair> key_pair = GenerateSphincsKeyPair(params);
-  ASSERT_THAT(key_pair.status(), IsOk());
+  ASSERT_THAT(key_pair, IsOk());
 
   // Create a new signer.
   EXPECT_THAT(SphincsVerify::New(key_pair->GetPublicKey()).status(),