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

18 files changed, 156 insertions, 156 deletions

diff --git a/cc/aead/aead_config_test.cc b/cc/aead/aead_config_test.cc
index e6e69b832..726e3d13c 100644
--- a/cc/aead/aead_config_test.cc
+++ b/cc/aead/aead_config_test.cc
@@ -92,18 +92,18 @@ TEST_F(AeadConfigTest, WrappersRegistered) {
   util::StatusOr<std::unique_ptr<Aead>> primitive_result =
       Registry::Wrap(std::move(primitive_set));
 
-  ASSERT_THAT(primitive_result.status(), IsOk());
+  ASSERT_THAT(primitive_result, IsOk());
   util::StatusOr<std::string> encryption_result =
       (*primitive_result)->Encrypt("secret", "");
-  ASSERT_THAT(encryption_result.status(), IsOk());
+  ASSERT_THAT(encryption_result, IsOk());
 
   util::StatusOr<std::string> decryption_result =
       DummyAead("dummy").Decrypt(*encryption_result, "");
-  ASSERT_THAT(decryption_result.status(), IsOk());
+  ASSERT_THAT(decryption_result, IsOk());
   EXPECT_THAT(*decryption_result, Eq("secret"));
 
   decryption_result = DummyAead("dummy").Decrypt(*encryption_result, "wrong");
-  EXPECT_THAT(decryption_result.status(), Not(IsOk()));
+  EXPECT_THAT(decryption_result, Not(IsOk()));
 }
 
 // FIPS-only mode tests
@@ -143,7 +143,7 @@ TEST_F(AeadConfigTest, RegisterFipsValidTemplates) {
 
   for (auto key_template : fips_key_templates) {
     auto new_keyset_handle_result = KeysetHandle::GenerateNew(key_template);
-    EXPECT_THAT(new_keyset_handle_result.status(), IsOk());
+    EXPECT_THAT(new_keyset_handle_result, IsOk());
   }
 }
 
diff --git a/cc/aead/aead_wrapper_test.cc b/cc/aead/aead_wrapper_test.cc
index e46dbea48..24ee4245c 100644
--- a/cc/aead/aead_wrapper_test.cc
+++ b/cc/aead/aead_wrapper_test.cc
@@ -89,7 +89,7 @@ KeysetInfo CreateTestKeysetInfo() {
 TEST(AeadSetWrapperTest, WrapNullptr) {
   AeadWrapper wrapper;
   util::StatusOr<std::unique_ptr<Aead>> aead = wrapper.Wrap(nullptr);
-  EXPECT_THAT(aead.status(), Not(IsOk()));
+  EXPECT_THAT(aead, Not(IsOk()));
   EXPECT_THAT(aead.status(), StatusIs(absl::StatusCode::kInternal));
   EXPECT_PRED_FORMAT2(IsSubstring, "non-NULL",
                       std::string(aead.status().message()));
@@ -99,7 +99,7 @@ TEST(AeadSetWrapperTest, WrapEmpty) {
   AeadWrapper wrapper;
   util::StatusOr<std::unique_ptr<Aead>> aead =
       wrapper.Wrap(absl::make_unique<PrimitiveSet<Aead>>());
-  EXPECT_THAT(aead.status(), Not(IsOk()));
+  EXPECT_THAT(aead, Not(IsOk()));
   EXPECT_THAT(aead.status(), StatusIs(absl::StatusCode::kInvalidArgument));
   EXPECT_PRED_FORMAT2(IsSubstring, "no primary",
                       std::string(aead.status().message()));
@@ -114,13 +114,13 @@ TEST(AeadSetWrapperTest, Basic) {
   std::unique_ptr<Aead> aead = absl::make_unique<DummyAead>(aead_name_0);
   util::StatusOr<PrimitiveSet<Aead>::Entry<Aead>*> aead_entry =
       aead_set->AddPrimitive(std::move(aead), keyset_info.key_info(0));
-  EXPECT_THAT(aead_entry.status(), IsOk());
+  EXPECT_THAT(aead_entry, IsOk());
   aead = absl::make_unique<DummyAead>(aead_name_1);
   aead_entry = aead_set->AddPrimitive(std::move(aead), keyset_info.key_info(1));
-  EXPECT_THAT(aead_entry.status(), IsOk());
+  EXPECT_THAT(aead_entry, IsOk());
   aead = absl::make_unique<DummyAead>(aead_name_2);
   aead_entry = aead_set->AddPrimitive(std::move(aead), keyset_info.key_info(2));
-  EXPECT_THAT(aead_entry.status(), IsOk());
+  EXPECT_THAT(aead_entry, IsOk());
   // The last key is the primary.
   EXPECT_THAT(aead_set->set_primary(*aead_entry), IsOk());
 
@@ -128,23 +128,23 @@ TEST(AeadSetWrapperTest, Basic) {
   AeadWrapper wrapper;
   util::StatusOr<std::unique_ptr<Aead>> aead_result =
       wrapper.Wrap(std::move(aead_set));
-  EXPECT_THAT(aead_result.status(), IsOk());
+  EXPECT_THAT(aead_result, IsOk());
   aead = std::move(*aead_result);
   std::string plaintext = "some_plaintext";
   std::string aad = "some_aad";
 
   util::StatusOr<std::string> encrypt_result = aead->Encrypt(plaintext, aad);
-  EXPECT_THAT(encrypt_result.status(), IsOk());
+  EXPECT_THAT(encrypt_result, IsOk());
   std::string ciphertext = *encrypt_result;
   EXPECT_PRED_FORMAT2(testing::IsSubstring, aead_name_2, ciphertext);
 
   util::StatusOr<std::string> resulting_plaintext =
       aead->Decrypt(ciphertext, aad);
-  EXPECT_THAT(resulting_plaintext.status(), IsOk());
+  EXPECT_THAT(resulting_plaintext, IsOk());
   EXPECT_EQ(*resulting_plaintext, plaintext);
 
   resulting_plaintext = aead->Decrypt("some bad ciphertext", aad);
-  EXPECT_THAT(resulting_plaintext.status(), Not(IsOk()));
+  EXPECT_THAT(resulting_plaintext, Not(IsOk()));
   EXPECT_THAT(resulting_plaintext.status(),
               StatusIs(absl::StatusCode::kInvalidArgument));
   EXPECT_PRED_FORMAT2(IsSubstring, "decryption failed",
@@ -163,10 +163,10 @@ TEST(AeadSetWrapperTest, DecryptNonPrimary) {
   std::string plaintext = "some_plaintext";
   std::string aad = "some_aad";
   util::StatusOr<std::string> ciphertext = aead->Encrypt(plaintext, aad);
-  EXPECT_THAT(ciphertext.status(), IsOk());
+  EXPECT_THAT(ciphertext, IsOk());
   util::StatusOr<PrimitiveSet<Aead>::Entry<Aead>*> aead_entry =
       aead_set->AddPrimitive(std::move(aead), keyset_info.key_info(0));
-  ASSERT_THAT(aead_entry.status(), IsOk());
+  ASSERT_THAT(aead_entry, IsOk());
   EXPECT_THAT(aead_set->set_primary(*aead_entry), IsOk());
 
   // The complete ciphertext is of the form: | key_id | ciphertext |.
@@ -175,10 +175,10 @@ TEST(AeadSetWrapperTest, DecryptNonPrimary) {
 
   aead = absl::make_unique<DummyAead>(aead_name_1);
   aead_entry = aead_set->AddPrimitive(std::move(aead), keyset_info.key_info(1));
-  EXPECT_THAT(aead_entry.status(), IsOk());
+  EXPECT_THAT(aead_entry, IsOk());
   aead = absl::make_unique<DummyAead>(aead_name_2);
   aead_entry = aead_set->AddPrimitive(std::move(aead), keyset_info.key_info(2));
-  EXPECT_THAT(aead_entry.status(), IsOk());
+  EXPECT_THAT(aead_entry, IsOk());
   // The last key is the primary.
   EXPECT_THAT(aead_set->set_primary(*aead_entry), IsOk());
 
@@ -186,7 +186,7 @@ TEST(AeadSetWrapperTest, DecryptNonPrimary) {
   AeadWrapper wrapper;
   util::StatusOr<std::unique_ptr<Aead>> aead_wrapped =
       wrapper.Wrap(std::move(aead_set));
-  EXPECT_THAT(aead_wrapped.status(), IsOk());
+  EXPECT_THAT(aead_wrapped, IsOk());
   aead = std::move(*aead_wrapped);
   EXPECT_THAT(complete_ciphertext, HasSubstr(aead_name_0));
 
@@ -194,7 +194,7 @@ TEST(AeadSetWrapperTest, DecryptNonPrimary) {
   // should still be decryptable as we have the correct key in the set.
   util::StatusOr<std::string> decrypted_plaintext =
       aead->Decrypt(complete_ciphertext, aad);
-  EXPECT_THAT(decrypted_plaintext.status(), IsOk());
+  EXPECT_THAT(decrypted_plaintext, IsOk());
 }
 
 // Tests with monitoring enabled.
@@ -260,14 +260,14 @@ TEST_F(AeadSetWrapperTestWithMonitoring,
   util::StatusOr<PrimitiveSet<Aead>::Entry<Aead>*> last =
       aead_primitive_set->AddPrimitive(absl::make_unique<DummyAead>("aead2"),
                                        keyset_info.key_info(2));
-  ASSERT_THAT(last.status(), IsOk());
+  ASSERT_THAT(last, IsOk());
   ASSERT_THAT(aead_primitive_set->set_primary(*last), IsOk());
   // Record the ID of the primary key.
   const uint32_t kPrimaryKeyId = keyset_info.key_info(2).key_id();
 
   util::StatusOr<std::unique_ptr<Aead>> aead =
       AeadWrapper().Wrap(std::move(aead_primitive_set));
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
 
   constexpr absl::string_view kPlaintext = "This is some plaintext!";
   constexpr absl::string_view kAssociatedData = "Some associated data!";
@@ -275,14 +275,14 @@ TEST_F(AeadSetWrapperTestWithMonitoring,
               Log(kPrimaryKeyId, kPlaintext.size()));
   util::StatusOr<std::string> ciphertext =
       (*aead)->Encrypt(kPlaintext, kAssociatedData);
-  ASSERT_THAT(ciphertext.status(), IsOk());
+  ASSERT_THAT(ciphertext, IsOk());
 
   // In the log expect the size of the ciphertext without the non-raw prefix.
   auto raw_ciphertext =
       absl::string_view(*ciphertext).substr(CryptoFormat::kNonRawPrefixSize);
   EXPECT_CALL(*decryption_monitoring_client_ptr_,
               Log(kPrimaryKeyId, raw_ciphertext.size()));
-  EXPECT_THAT((*aead)->Decrypt(*ciphertext, kAssociatedData).status(), IsOk());
+  EXPECT_THAT((*aead)->Decrypt(*ciphertext, kAssociatedData), IsOk());
 }
 
 // Test that monitoring logs encryption and decryption failures correctly.
@@ -311,25 +311,25 @@ TEST_F(AeadSetWrapperTestWithMonitoring,
   util::StatusOr<PrimitiveSet<Aead>::Entry<Aead>*> primary =
       aead_primitive_set->AddPrimitive(std::move(mock_aead),
                                        keyset_info.key_info(2));
-  ASSERT_THAT(primary.status(), IsOk());
+  ASSERT_THAT(primary, IsOk());
   // Set the only primitive as primary.
   ASSERT_THAT(aead_primitive_set->set_primary(*primary), IsOk());
 
   util::StatusOr<std::unique_ptr<Aead>> aead =
       AeadWrapper().Wrap(std::move(aead_primitive_set));
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
 
   // Expect encryption failure gets logged.
   EXPECT_CALL(*encryption_monitoring_client_ptr_, LogFailure());
   util::StatusOr<std::string> ciphertext =
       (*aead)->Encrypt(kPlaintext, kAssociatedData);
-  EXPECT_THAT(ciphertext.status(), Not(IsOk()));
+  EXPECT_THAT(ciphertext, Not(IsOk()));
 
   // We must prepend the identifier to the ciphertext to make sure our mock gets
   // called.
   util::StatusOr<std::string> key_identifier =
       CryptoFormat::GetOutputPrefix(keyset_info.key_info(2));
-  ASSERT_THAT(key_identifier.status(), IsOk());
+  ASSERT_THAT(key_identifier, IsOk());
   std::string ciphertext_with_key_id =
       absl::StrCat(*key_identifier, kCiphertext);
 
diff --git a/cc/aead/aes_ctr_hmac_aead_key_manager_test.cc b/cc/aead/aes_ctr_hmac_aead_key_manager_test.cc
index a2db4af95..6815ec36a 100644
--- a/cc/aead/aes_ctr_hmac_aead_key_manager_test.cc
+++ b/cc/aead/aes_ctr_hmac_aead_key_manager_test.cc
@@ -178,7 +178,7 @@ TEST(AesCtrHmacAeadKeyManagerTest, CreateKey) {
   AesCtrHmacAeadKeyFormat key_format = CreateValidKeyFormat();
   StatusOr<AesCtrHmacAeadKey> key_or =
       AesCtrHmacAeadKeyManager().CreateKey(key_format);
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
   const AesCtrHmacAeadKey& key = key_or.value();
   EXPECT_THAT(AesCtrHmacAeadKeyManager().ValidateKey(key),
               IsOk());
@@ -199,23 +199,23 @@ TEST(AesCtrHmacAeadKeyManagerTest, CreateAead) {
 
   StatusOr<std::unique_ptr<Aead>> aead_or =
       AesCtrHmacAeadKeyManager().GetPrimitive<Aead>(key);
-  ASSERT_THAT(aead_or.status(), IsOk());
+  ASSERT_THAT(aead_or, IsOk());
 
   auto direct_aes_ctr_or = subtle::AesCtrBoringSsl::New(
       util::SecretDataFromStringView(key.aes_ctr_key().key_value()),
       key.aes_ctr_key().params().iv_size());
-  ASSERT_THAT(direct_aes_ctr_or.status(), IsOk());
+  ASSERT_THAT(direct_aes_ctr_or, IsOk());
 
   auto direct_hmac_or = subtle::HmacBoringSsl::New(
       util::Enums::ProtoToSubtle(key.hmac_key().params().hash()),
       key.hmac_key().params().tag_size(),
       util::SecretDataFromStringView(key.hmac_key().key_value()));
-  ASSERT_THAT(direct_hmac_or.status(), IsOk());
+  ASSERT_THAT(direct_hmac_or, IsOk());
 
   auto direct_aead_or = subtle::EncryptThenAuthenticate::New(
       std::move(direct_aes_ctr_or.value()), std::move(direct_hmac_or.value()),
       key.hmac_key().params().tag_size());
-  ASSERT_THAT(direct_aead_or.status(), IsOk());
+  ASSERT_THAT(direct_aead_or, IsOk());
 
   EXPECT_THAT(EncryptThenDecrypt(*aead_or.value(), *direct_aead_or.value(),
                                  "message", "aad"),
diff --git a/cc/aead/aes_eax_key_manager_test.cc b/cc/aead/aes_eax_key_manager_test.cc
index c3f296bb1..26aa5e402 100644
--- a/cc/aead/aes_eax_key_manager_test.cc
+++ b/cc/aead/aes_eax_key_manager_test.cc
@@ -108,7 +108,7 @@ TEST(AesEaxKeyManagerTest, CreateKey) {
   format.set_key_size(32);
   format.mutable_params()->set_iv_size(16);
   auto key_or = AesEaxKeyManager().CreateKey(format);
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
   EXPECT_THAT(key_or.value().key_value(), SizeIs(format.key_size()));
   EXPECT_THAT(key_or.value().params().iv_size(), Eq(format.params().iv_size()));
 }
@@ -118,7 +118,7 @@ TEST(AesEaxKeyManagerTest, CreateKeyIsValid) {
   format.set_key_size(32);
   format.mutable_params()->set_iv_size(16);
   auto key_or = AesEaxKeyManager().CreateKey(format);
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
   EXPECT_THAT(AesEaxKeyManager().ValidateKey(key_or.value()), IsOk());
 }
 
@@ -128,9 +128,9 @@ TEST(AesEaxKeyManagerTest, MultipleCreateCallsCreateDifferentKeys) {
   format.set_key_size(32);
   format.mutable_params()->set_iv_size(16);
   auto key1_or = manager.CreateKey(format);
-  ASSERT_THAT(key1_or.status(), IsOk());
+  ASSERT_THAT(key1_or, IsOk());
   auto key2_or = manager.CreateKey(format);
-  ASSERT_THAT(key2_or.status(), IsOk());
+  ASSERT_THAT(key2_or, IsOk());
   EXPECT_THAT(key1_or.value().key_value(), Ne(key2_or.value().key_value()));
 }
 
@@ -178,18 +178,18 @@ TEST(AesGcmKeyManagerTest, CreateAead) {
   format.set_key_size(32);
   format.mutable_params()->set_iv_size(16);
   StatusOr<AesEaxKey> key_or = AesEaxKeyManager().CreateKey(format);
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
 
   StatusOr<std::unique_ptr<Aead>> aead_or =
       AesEaxKeyManager().GetPrimitive<Aead>(key_or.value());
 
-  ASSERT_THAT(aead_or.status(), IsOk());
+  ASSERT_THAT(aead_or, IsOk());
 
   StatusOr<std::unique_ptr<Aead>> boring_ssl_aead_or =
       subtle::AesEaxBoringSsl::New(
           util::SecretDataFromStringView(key_or.value().key_value()),
           key_or.value().params().iv_size());
-  ASSERT_THAT(boring_ssl_aead_or.status(), IsOk());
+  ASSERT_THAT(boring_ssl_aead_or, IsOk());
 
   ASSERT_THAT(EncryptThenDecrypt(*aead_or.value(), *boring_ssl_aead_or.value(),
                                  "message", "aad"),
diff --git a/cc/aead/aes_gcm_key_manager_test.cc b/cc/aead/aes_gcm_key_manager_test.cc
index bade8ce76..9f3dfbf64 100644
--- a/cc/aead/aes_gcm_key_manager_test.cc
+++ b/cc/aead/aes_gcm_key_manager_test.cc
@@ -161,7 +161,7 @@ TEST(AesGcmKeyManagerTest, Create16ByteKey) {
 
   StatusOr<AesGcmKey> key_or = AesGcmKeyManager().CreateKey(format);
 
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
   EXPECT_THAT(key_or.value().key_value().size(), Eq(format.key_size()));
 }
 
@@ -171,7 +171,7 @@ TEST(AesGcmKeyManagerTest, Create32ByteKey) {
 
   StatusOr<AesGcmKey> key_or = AesGcmKeyManager().CreateKey(format);
 
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
   EXPECT_THAT(key_or.value().key_value().size(), Eq(format.key_size()));
 }
 
@@ -179,17 +179,17 @@ TEST(AesGcmKeyManagerTest, CreateAead) {
   AesGcmKeyFormat format;
   format.set_key_size(32);
   StatusOr<AesGcmKey> key_or = AesGcmKeyManager().CreateKey(format);
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
 
   StatusOr<std::unique_ptr<Aead>> aead_or =
       AesGcmKeyManager().GetPrimitive<Aead>(key_or.value());
 
-  ASSERT_THAT(aead_or.status(), IsOk());
+  ASSERT_THAT(aead_or, IsOk());
 
   StatusOr<std::unique_ptr<Aead>> boring_ssl_aead_or =
       subtle::AesGcmBoringSsl::New(
           util::SecretDataFromStringView(key_or.value().key_value()));
-  ASSERT_THAT(boring_ssl_aead_or.status(), IsOk());
+  ASSERT_THAT(boring_ssl_aead_or, IsOk());
 
   ASSERT_THAT(EncryptThenDecrypt(*aead_or.value(), *boring_ssl_aead_or.value(),
                                  "message", "aad"),
@@ -200,17 +200,17 @@ TEST(AesGcmKeyManagerTest, CreateCordAead) {
   AesGcmKeyFormat format;
   format.set_key_size(32);
   StatusOr<AesGcmKey> key_or = AesGcmKeyManager().CreateKey(format);
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
 
   StatusOr<std::unique_ptr<CordAead>> aead_or =
       AesGcmKeyManager().GetPrimitive<CordAead>(key_or.value());
 
-  ASSERT_THAT(aead_or.status(), IsOk());
+  ASSERT_THAT(aead_or, IsOk());
 
   StatusOr<std::unique_ptr<CordAead>> boring_ssl_aead_or =
       CordAesGcmBoringSsl::New(
           util::SecretDataFromStringView(key_or.value().key_value()));
-  ASSERT_THAT(boring_ssl_aead_or.status(), IsOk());
+  ASSERT_THAT(boring_ssl_aead_or, IsOk());
 
   ASSERT_THAT(EncryptThenDecrypt(*aead_or.value(), *boring_ssl_aead_or.value(),
                                  "message", "aad"),
@@ -227,7 +227,7 @@ TEST(AesGcmKeyManagerTest, DeriveShortKey) {
 
   StatusOr<AesGcmKey> key_or =
       AesGcmKeyManager().DeriveKey(format, &input_stream);
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
   EXPECT_THAT(key_or.value().key_value(), Eq("0123456789abcdef"));
 }
 
@@ -241,7 +241,7 @@ TEST(AesGcmKeyManagerTest, DeriveLongKey) {
 
   StatusOr<AesGcmKey> key_or =
       AesGcmKeyManager().DeriveKey(format, &input_stream);
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
   EXPECT_THAT(key_or.value().key_value(),
               Eq("0123456789abcdef0123456789abcdef"));
 }
diff --git a/cc/aead/aes_gcm_siv_key_manager_test.cc b/cc/aead/aes_gcm_siv_key_manager_test.cc
index 5b400fd4e..d47990630 100644
--- a/cc/aead/aes_gcm_siv_key_manager_test.cc
+++ b/cc/aead/aes_gcm_siv_key_manager_test.cc
@@ -147,7 +147,7 @@ TEST(AesGcmSivKeyManagerTest, Create16ByteKey) {
 
   StatusOr<AesGcmSivKey> key_or = AesGcmSivKeyManager().CreateKey(format);
 
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
   EXPECT_THAT(key_or.value().key_value().size(), Eq(format.key_size()));
 }
 
@@ -157,7 +157,7 @@ TEST(AesGcmSivKeyManagerTest, Create32ByteKey) {
 
   StatusOr<AesGcmSivKey> key_or = AesGcmSivKeyManager().CreateKey(format);
 
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
   EXPECT_THAT(key_or.value().key_value().size(), Eq(format.key_size()));
 }
 
@@ -168,7 +168,7 @@ TEST(AesGcmSivKeyManagerTest, CreateAeadFailsWithOpenSsl) {
   AesGcmSivKeyFormat format;
   format.set_key_size(32);
   StatusOr<AesGcmSivKey> key = AesGcmSivKeyManager().CreateKey(format);
-  ASSERT_THAT(key.status(), IsOk());
+  ASSERT_THAT(key, IsOk());
 
   EXPECT_THAT(AesGcmSivKeyManager().GetPrimitive<Aead>(*key).status(),
               Not(IsOk()));
@@ -185,16 +185,16 @@ TEST(AesGcmSivKeyManagerTest, CreateAeadSucceedsWithBoringSsl) {
   AesGcmSivKeyFormat format;
   format.set_key_size(32);
   StatusOr<AesGcmSivKey> key = AesGcmSivKeyManager().CreateKey(format);
-  ASSERT_THAT(key.status(), IsOk());
+  ASSERT_THAT(key, IsOk());
 
   StatusOr<std::unique_ptr<Aead>> aead =
       AesGcmSivKeyManager().GetPrimitive<Aead>(*key);
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
 
   StatusOr<std::unique_ptr<Aead>> boring_ssl_aead =
       subtle::AesGcmSivBoringSsl::New(
           util::SecretDataFromStringView(key->key_value()));
-  ASSERT_THAT(boring_ssl_aead.status(), IsOk());
+  ASSERT_THAT(boring_ssl_aead, IsOk());
   EXPECT_THAT(EncryptThenDecrypt(**aead, **boring_ssl_aead, "message", "aad"),
               IsOk());
 }
diff --git a/cc/aead/cord_aead_wrapper_test.cc b/cc/aead/cord_aead_wrapper_test.cc
index c8de2528e..cb51d9dfd 100644
--- a/cc/aead/cord_aead_wrapper_test.cc
+++ b/cc/aead/cord_aead_wrapper_test.cc
@@ -91,7 +91,7 @@ TEST(AeadSetWrapperTest, WrapperEncryptDecrypt) {
   auto aead_set = setup_keyset();
   CordAeadWrapper wrapper;
   auto aead_result = wrapper.Wrap(std::move(aead_set));
-  ASSERT_THAT(aead_result.status(), IsOk());
+  ASSERT_THAT(aead_result, IsOk());
   auto aead = std::move(aead_result.value());
   absl::Cord plaintext;
   plaintext.Append("some_plaintext");
@@ -140,7 +140,7 @@ TEST(AeadSetWrapperTest, WrapperEncryptDecryptMultipleKeys) {
   // Wrap the primitive set
   CordAeadWrapper wrapper;
   auto aead_result = wrapper.Wrap(std::move(aead_set));
-  ASSERT_THAT(aead_result.status(), IsOk());
+  ASSERT_THAT(aead_result, IsOk());
   aead = std::move(aead_result.value());
 
   // Encrypt with the wrapped AEAD and check if result was equal to the
@@ -155,7 +155,7 @@ TEST(AeadSetWrapperTest, WrapperEncryptDecryptManyChunks) {
   auto aead_set = setup_keyset();
   CordAeadWrapper wrapper;
   auto aead_result = wrapper.Wrap(std::move(aead_set));
-  ASSERT_THAT(aead_result.status(), IsOk());
+  ASSERT_THAT(aead_result, IsOk());
   auto aead = std::move(aead_result.value());
 
   std::string plaintext = "";
@@ -181,7 +181,7 @@ TEST(AeadSetWrapperTest, WrapperEncryptBadDecrypt) {
   auto aead_set = setup_keyset();
   CordAeadWrapper wrapper;
   auto aead_result = wrapper.Wrap(std::move(aead_set));
-  ASSERT_THAT(aead_result.status(), IsOk());
+  ASSERT_THAT(aead_result, IsOk());
   auto aead = std::move(aead_result.value());
   absl::Cord plaintext;
   plaintext.Append("some_plaintext");
diff --git a/cc/aead/internal/aead_from_zero_copy_test.cc b/cc/aead/internal/aead_from_zero_copy_test.cc
index 555f2ad2d..2fe44866c 100644
--- a/cc/aead/internal/aead_from_zero_copy_test.cc
+++ b/cc/aead/internal/aead_from_zero_copy_test.cc
@@ -60,7 +60,7 @@ TEST(AeadFromZeroCopyTest, EncryptSucceeds) {
 
   AeadFromZeroCopy aead(std::move(mock_zero_copy_aead));
   StatusOr<std::string> ciphertext = aead.Encrypt(kPlaintext, kAssociatedData);
-  ASSERT_THAT(ciphertext.status(), IsOk());
+  ASSERT_THAT(ciphertext, IsOk());
   EXPECT_EQ(*ciphertext, kCiphertext);
 }
 
@@ -90,7 +90,7 @@ TEST(AeadFromZeroCopyTest, DecryptSucceeds) {
 
   AeadFromZeroCopy aead(std::move(mock_zero_copy_aead));
   StatusOr<std::string> plaintext = aead.Decrypt(kCiphertext, kAssociatedData);
-  ASSERT_THAT(plaintext.status(), IsOk());
+  ASSERT_THAT(plaintext, IsOk());
   EXPECT_EQ(*plaintext, kPlaintext);
 }
 
diff --git a/cc/aead/internal/aead_util_test.cc b/cc/aead/internal/aead_util_test.cc
index fe2233abf..ea3941afb 100644
--- a/cc/aead/internal/aead_util_test.cc
+++ b/cc/aead/internal/aead_util_test.cc
@@ -37,7 +37,7 @@ TEST(AeadUtilTest, GetAesGcmCipherForKeySize) {
     } else if (i == 32) {
       EXPECT_THAT(cipher, IsOkAndHolds(EVP_aes_256_gcm()));
     } else {
-      EXPECT_THAT(cipher.status(), Not(IsOk()));
+      EXPECT_THAT(cipher, Not(IsOk()));
     }
   }
 }
@@ -52,7 +52,7 @@ TEST(AeadUtilTest, GetAesAeadForKeySize) {
     } else if (i == 32) {
       EXPECT_THAT(cipher, IsOkAndHolds(EVP_aead_aes_256_gcm()));
     } else {
-      EXPECT_THAT(cipher.status(), Not(IsOk()));
+      EXPECT_THAT(cipher, Not(IsOk()));
     }
   }
 }
@@ -66,7 +66,7 @@ TEST(AeadUtilTest, GetAesGcmSivAeadCipherForKeySize) {
     } else if (i == 32) {
       EXPECT_THAT(cipher, IsOkAndHolds(EVP_aead_aes_256_gcm_siv()));
     } else {
-      EXPECT_THAT(cipher.status(), Not(IsOk()));
+      EXPECT_THAT(cipher, Not(IsOk()));
     }
   }
 }
diff --git a/cc/aead/internal/cord_aes_gcm_boringssl_test.cc b/cc/aead/internal/cord_aes_gcm_boringssl_test.cc
index ab517ff31..be6078b0e 100644
--- a/cc/aead/internal/cord_aes_gcm_boringssl_test.cc
+++ b/cc/aead/internal/cord_aes_gcm_boringssl_test.cc
@@ -59,7 +59,7 @@ class CordAesGcmBoringSslTest : public Test {
     key_ = util::SecretDataFromStringView(absl::HexStringToBytes(key_128));
     util::StatusOr<std::unique_ptr<CordAead>> res =
         CordAesGcmBoringSsl::New(key_);
-    ASSERT_THAT(res.status(), IsOk());
+    ASSERT_THAT(res, IsOk());
     cipher_ = std::move(*res);
   }
 
@@ -72,10 +72,10 @@ TEST_F(CordAesGcmBoringSslTest, EncryptDecryptCord) {
   absl::Cord associated_data_cord = absl::Cord(kAssociatedData);
   util::StatusOr<absl::Cord> ct =
       cipher_->Encrypt(message_cord, associated_data_cord);
-  ASSERT_THAT(ct.status(), IsOk());
+  ASSERT_THAT(ct, IsOk());
   EXPECT_THAT(*ct, SizeIs(message_cord.size() + 12 + 16));
   util::StatusOr<absl::Cord> pt = cipher_->Decrypt(*ct, associated_data_cord);
-  ASSERT_THAT(pt.status(), IsOk());
+  ASSERT_THAT(pt, IsOk());
   EXPECT_EQ(*pt, message_cord.Flatten());
 }
 
@@ -85,10 +85,10 @@ TEST_F(CordAesGcmBoringSslTest, ChunkyCordEncrypt) {
   absl::Cord associated_data_cord = absl::Cord(kAssociatedData);
   util::StatusOr<absl::Cord> ct =
       cipher_->Encrypt(message_cord, associated_data_cord);
-  ASSERT_THAT(ct.status(), IsOk());
+  ASSERT_THAT(ct, IsOk());
   EXPECT_THAT(*ct, SizeIs(message_cord.size() + 12 + 16));
   util::StatusOr<absl::Cord> pt = cipher_->Decrypt(*ct, associated_data_cord);
-  ASSERT_THAT(pt.status(), IsOk());
+  ASSERT_THAT(pt, IsOk());
   EXPECT_THAT(*pt, Eq(kLongMessage));
 }
 
@@ -97,12 +97,12 @@ TEST_F(CordAesGcmBoringSslTest, ChunkyCordDecrypt) {
   absl::Cord associated_data_cord = absl::Cord(kAssociatedData);
   util::StatusOr<absl::Cord> ct =
       cipher_->Encrypt(message_cord, associated_data_cord);
-  ASSERT_THAT(ct.status(), IsOk());
+  ASSERT_THAT(ct, IsOk());
   absl::Cord fragmented_ct = absl::MakeFragmentedCord(
       absl::StrSplit(ct->Flatten(), absl::ByLength(3)));
   util::StatusOr<absl::Cord> pt =
       cipher_->Decrypt(fragmented_ct, associated_data_cord);
-  ASSERT_THAT(pt.status(), IsOk());
+  ASSERT_THAT(pt, IsOk());
   EXPECT_THAT(*pt, Eq(kLongMessage));
 }
 
@@ -111,20 +111,20 @@ TEST_F(CordAesGcmBoringSslTest, CanDecryptWithStringAead) {
   absl::Cord associated_data_cord = absl::Cord(kAssociatedData);
   util::StatusOr<absl::Cord> ct =
       cipher_->Encrypt(message_cord, associated_data_cord);
-  ASSERT_THAT(ct.status(), IsOk());
+  ASSERT_THAT(ct, IsOk());
   EXPECT_EQ(ct->size(), message_cord.size() + 12 + 16);
   util::StatusOr<absl::Cord> pt = cipher_->Decrypt(*ct, associated_data_cord);
-  ASSERT_THAT(pt.status(), IsOk());
+  ASSERT_THAT(pt, IsOk());
   EXPECT_EQ(*pt, message_cord.Flatten());
 
   // Decrypt as string and check if it gives same result.
   util::StatusOr<std::unique_ptr<Aead>> string_aead =
       subtle::AesGcmBoringSsl::New(key_);
-  ASSERT_THAT(string_aead.status(), IsOk());
+  ASSERT_THAT(string_aead, IsOk());
   util::StatusOr<std::string> plaintext =
       (*string_aead)
           ->Decrypt(ct.value().Flatten(), associated_data_cord.Flatten());
-  ASSERT_THAT(plaintext.status(), IsOk());
+  ASSERT_THAT(plaintext, IsOk());
   EXPECT_EQ(*plaintext, kMessage);
 }
 
@@ -132,9 +132,9 @@ TEST_F(CordAesGcmBoringSslTest, ModifiedCord) {
   absl::Cord message = absl::Cord(kMessage);
   absl::Cord ad = absl::Cord(kAssociatedData);
   util::StatusOr<absl::Cord> ct = cipher_->Encrypt(message, ad);
-  ASSERT_THAT(ct.status(), IsOk());
+  ASSERT_THAT(ct, IsOk());
   util::StatusOr<absl::Cord> plaintext = cipher_->Decrypt(*ct, ad);
-  ASSERT_THAT(plaintext.status(), IsOk());
+  ASSERT_THAT(plaintext, IsOk());
   EXPECT_EQ(*plaintext, message);
 
   // Modify the ciphertext.
@@ -143,7 +143,7 @@ TEST_F(CordAesGcmBoringSslTest, ModifiedCord) {
     modified_ct[i / 8] ^= 1 << (i % 8);
     absl::Cord modified_ct_cord;
     modified_ct_cord = absl::Cord(modified_ct);
-    EXPECT_THAT(cipher_->Decrypt(modified_ct_cord, ad).status(), Not(IsOk()))
+    EXPECT_THAT(cipher_->Decrypt(modified_ct_cord, ad), Not(IsOk()))
         << i;
   }
   // Modify the associated data.
@@ -154,14 +154,14 @@ TEST_F(CordAesGcmBoringSslTest, ModifiedCord) {
     modified_associated_data_cord = absl::Cord(modified_ad);
     util::StatusOr<absl::Cord> decrypted =
         cipher_->Decrypt(*ct, modified_associated_data_cord);
-    EXPECT_THAT(decrypted.status(), Not(IsOk())) << i << " pt: " << *decrypted;
+    EXPECT_THAT(decrypted, Not(IsOk())) << i << " pt: " << *decrypted;
   }
   // Truncate the ciphertext.
   for (size_t i = 0; i < ct->size(); i++) {
     std::string truncated_ct(std::string(ct->Flatten()), 0, i);
     absl::Cord truncated_ct_cord;
     truncated_ct_cord = absl::Cord(truncated_ct);
-    EXPECT_THAT(cipher_->Decrypt(truncated_ct_cord, ad).status(), Not(IsOk()))
+    EXPECT_THAT(cipher_->Decrypt(truncated_ct_cord, ad), Not(IsOk()))
         << i;
   }
 }
diff --git a/cc/aead/internal/ssl_aead_large_inputs_test.cc b/cc/aead/internal/ssl_aead_large_inputs_test.cc
index 6d5b58ced..1ca2400f0 100644
--- a/cc/aead/internal/ssl_aead_large_inputs_test.cc
+++ b/cc/aead/internal/ssl_aead_large_inputs_test.cc
@@ -95,7 +95,7 @@ TEST_P(SslOneShotAeadLargeInputsTest, EncryptDecryptLargeInput) {
   util::StatusOr<std::unique_ptr<SslOneShotAead>> aead = CipherFromName(
       test_param.cipher, util::SecretDataFromStringView(
                              absl::HexStringToBytes(test_param.key_hex)));
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
 
   std::string iv = absl::HexStringToBytes(test_param.iv_hex);
   std::string ciphertext_buffer;
@@ -107,7 +107,7 @@ TEST_P(SslOneShotAeadLargeInputsTest, EncryptDecryptLargeInput) {
   ASSERT_GE(ciphertext_buffer.size(), large_input.size() + test_param.tag_size);
   util::StatusOr<int64_t> res = (*aead)->Encrypt(
       large_input, kAad, iv, absl::MakeSpan(ciphertext_buffer));
-  ASSERT_THAT(res.status(), IsOk());
+  ASSERT_THAT(res, IsOk());
   EXPECT_EQ(*res, large_input.size() + test_param.tag_size);
 
   // Decrypt.
@@ -115,7 +115,7 @@ TEST_P(SslOneShotAeadLargeInputsTest, EncryptDecryptLargeInput) {
   subtle::ResizeStringUninitialized(&plaintext_buff, large_input.size());
   util::StatusOr<int64_t> written_bytes = (*aead)->Decrypt(
       ciphertext_buffer, kAad, iv, absl::MakeSpan(plaintext_buff));
-  ASSERT_THAT(written_bytes.status(), IsOk());
+  ASSERT_THAT(written_bytes, IsOk());
   EXPECT_EQ(*written_bytes, large_input.size());
   EXPECT_EQ(plaintext_buff, large_input);
 }
diff --git a/cc/aead/internal/ssl_aead_test.cc b/cc/aead/internal/ssl_aead_test.cc
index b27be5748..375e9cda4 100644
--- a/cc/aead/internal/ssl_aead_test.cc
+++ b/cc/aead/internal/ssl_aead_test.cc
@@ -105,7 +105,7 @@ TEST_P(SslOneShotAeadTest, CiphertextPlaintextSize) {
   util::StatusOr<std::unique_ptr<SslOneShotAead>> aead = CipherFromName(
       test_param.cipher, util::SecretDataFromStringView(
                              absl::HexStringToBytes(test_param.key_hex)));
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
 
   EXPECT_EQ((*aead)->CiphertextSize(kMessage.size()),
             kMessage.size() + test_param.tag_size);
@@ -125,7 +125,7 @@ void DoTestEncrypt(SslOneShotAead* aead, absl::string_view message,
   ASSERT_GE(ciphertext_buffer.size(), message.size() + tag_size);
   util::StatusOr<int64_t> res = aead->Encrypt(
       message, associated_data, iv, absl::MakeSpan(ciphertext_buffer));
-  ASSERT_THAT(res.status(), IsOk());
+  ASSERT_THAT(res, IsOk());
   EXPECT_EQ(*res, message.size() + tag_size);
 }
 
@@ -138,7 +138,7 @@ void DoTestDecrypt(SslOneShotAead* aead, absl::string_view message,
   subtle::ResizeStringUninitialized(&plaintext_buff, message.size());
   util::StatusOr<int64_t> written_bytes = aead->Decrypt(
       ciphertext_buffer, associated_data, iv, absl::MakeSpan(plaintext_buff));
-  ASSERT_THAT(written_bytes.status(), IsOk());
+  ASSERT_THAT(written_bytes, IsOk());
   EXPECT_EQ(*written_bytes, message.size());
   EXPECT_EQ(plaintext_buff, message);
 }
@@ -148,7 +148,7 @@ TEST_P(SslOneShotAeadTest, EncryptDecrypt) {
   util::StatusOr<std::unique_ptr<SslOneShotAead>> aead = CipherFromName(
       test_param.cipher, util::SecretDataFromStringView(
                              absl::HexStringToBytes(test_param.key_hex)));
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
 
   std::string iv = absl::HexStringToBytes(test_param.iv_hex);
   std::string ciphertext_buffer;
@@ -178,7 +178,7 @@ void DoTestEncryptDecryptWithModifiedCiphertext(SslOneShotAead* aead,
 
   util::StatusOr<int64_t> written_bytes = aead->Encrypt(
       kMessage, kAssociatedData, iv, absl::MakeSpan(ciphertext_buffer));
-  ASSERT_THAT(written_bytes.status(), IsOk());
+  ASSERT_THAT(written_bytes, IsOk());
   EXPECT_EQ(*written_bytes, kMessage.size() + tag_size);
   std::string plaintext_buffer;
   subtle::ResizeStringUninitialized(&plaintext_buffer, kMessage.size());
@@ -221,7 +221,7 @@ TEST_P(SslOneShotAeadTest, TestModification) {
   util::StatusOr<std::unique_ptr<SslOneShotAead>> aead = CipherFromName(
       test_param.cipher, util::SecretDataFromStringView(
                              absl::HexStringToBytes(test_param.key_hex)));
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
 
   DoTestEncryptDecryptWithModifiedCiphertext(
       aead->get(), test_param.tag_size,
@@ -239,7 +239,7 @@ TEST_P(SslOneShotAeadTest, TestBufferClearsIfDecryptionFails) {
   util::StatusOr<std::unique_ptr<SslOneShotAead>> aead = CipherFromName(
       test_param.cipher, util::SecretDataFromStringView(
                              absl::HexStringToBytes(test_param.key_hex)));
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
 
   const int64_t kCiphertextSize = kMessage.size() + test_param.tag_size;
   std::string ciphertext_buffer;
@@ -248,7 +248,7 @@ TEST_P(SslOneShotAeadTest, TestBufferClearsIfDecryptionFails) {
   std::string iv = absl::HexStringToBytes(test_param.iv_hex);
   util::StatusOr<int64_t> written_bytes = (*aead)->Encrypt(
       kMessage, kAssociatedData, iv, absl::MakeSpan(ciphertext_buffer));
-  ASSERT_THAT(written_bytes.status(), IsOk());
+  ASSERT_THAT(written_bytes, IsOk());
   EXPECT_EQ(*written_bytes, kCiphertextSize);
 
   std::string plaintext_buffer;
@@ -306,7 +306,7 @@ TEST_P(SslOneShotAeadTest, EmptyAssociatedData) {
   util::StatusOr<std::unique_ptr<SslOneShotAead>> aead = CipherFromName(
       test_param.cipher, util::SecretDataFromStringView(
                              absl::HexStringToBytes(test_param.key_hex)));
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
   DoTestWithEmptyAssociatedData(aead->get(),
                                 absl::HexStringToBytes(test_param.iv_hex),
                                 test_param.tag_size);
@@ -345,7 +345,7 @@ TEST_P(SslOneShotAeadTest, EmptyMessage) {
   util::StatusOr<std::unique_ptr<SslOneShotAead>> aead = CipherFromName(
       test_param.cipher, util::SecretDataFromStringView(
                              absl::HexStringToBytes(test_param.key_hex)));
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
   std::string iv = absl::HexStringToBytes(test_param.iv_hex);
   DoTestEmptyMessageEncryptDecrypt(aead->get(), iv, test_param.tag_size);
 }
@@ -358,7 +358,7 @@ TEST_P(SslOneShotAeadTest, EmptyMessageAndAssociatedData) {
   util::StatusOr<std::unique_ptr<SslOneShotAead>> aead = CipherFromName(
       test_param.cipher, util::SecretDataFromStringView(
                              absl::HexStringToBytes(test_param.key_hex)));
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
   std::string iv = absl::HexStringToBytes(test_param.iv_hex);
   const absl::string_view default_associated_data;
   const absl::string_view empty_associated_data = "";
@@ -375,7 +375,7 @@ TEST_P(SslOneShotAeadTest, BufferOverlapEncryptFails) {
   util::StatusOr<std::unique_ptr<SslOneShotAead>> aead = CipherFromName(
       test_param.cipher, util::SecretDataFromStringView(
                              absl::HexStringToBytes(test_param.key_hex)));
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
 
   std::string ciphertext_buffer(kMessage.data(), kMessage.size());
   subtle::ResizeStringUninitialized(&ciphertext_buffer,
@@ -396,7 +396,7 @@ TEST_P(SslOneShotAeadTest, BufferOverlapDecryptFails) {
   util::StatusOr<std::unique_ptr<SslOneShotAead>> aead = CipherFromName(
       test_param.cipher, util::SecretDataFromStringView(
                              absl::HexStringToBytes(test_param.key_hex)));
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
 
   std::string iv = absl::HexStringToBytes(test_param.iv_hex);
   std::string ciphertext_buffer;
@@ -462,9 +462,9 @@ TEST(SslOneShotAeadTest, AesGcmTestInvalidKeySizes) {
     util::StatusOr<std::unique_ptr<SslOneShotAead>> aead =
         CreateAesGcmOneShotCrypter(key);
     if (keysize == 16 || keysize == 32) {
-      EXPECT_THAT(aead.status(), IsOk()) << "with key size " << keysize;
+      EXPECT_THAT(aead, IsOk()) << "with key size " << keysize;
     } else {
-      EXPECT_THAT(aead.status(), Not(IsOk())) << "with key size " << keysize;
+      EXPECT_THAT(aead, Not(IsOk())) << "with key size " << keysize;
     }
   }
 }
@@ -482,9 +482,9 @@ TEST(SslOneShotAeadTest, AesGcmSivTestInvalidKeySizes) {
     util::StatusOr<std::unique_ptr<SslOneShotAead>> aead =
         CreateAesGcmSivOneShotCrypter(key);
     if (keysize == 16 || keysize == 32) {
-      EXPECT_THAT(aead.status(), IsOk()) << "with key size " << keysize;
+      EXPECT_THAT(aead, IsOk()) << "with key size " << keysize;
     } else {
-      EXPECT_THAT(aead.status(), Not(IsOk())) << "with key size " << keysize;
+      EXPECT_THAT(aead, Not(IsOk())) << "with key size " << keysize;
     }
   }
 }
@@ -502,9 +502,9 @@ TEST(SslOneShotAeadTest, Xchacha20Poly1305TestInvalidKeySizes) {
     util::StatusOr<std::unique_ptr<SslOneShotAead>> aead =
         CreateXchacha20Poly1305OneShotCrypter(key);
     if (keysize == 32) {
-      EXPECT_THAT(aead.status(), IsOk()) << "with key size " << keysize;
+      EXPECT_THAT(aead, IsOk()) << "with key size " << keysize;
     } else {
-      EXPECT_THAT(aead.status(), Not(IsOk())) << "with key size " << keysize;
+      EXPECT_THAT(aead, Not(IsOk())) << "with key size " << keysize;
     }
   }
 }
@@ -534,8 +534,8 @@ TEST(SslOneShotAeadTest, AesGcmTestFipsOnly) {
   util::SecretData key_256 =
       util::SecretDataFromStringView(absl::HexStringToBytes(k256Key));
 
-  EXPECT_THAT(CreateAesGcmOneShotCrypter(key_128).status(), IsOk());
-  EXPECT_THAT(CreateAesGcmOneShotCrypter(key_256).status(), IsOk());
+  EXPECT_THAT(CreateAesGcmOneShotCrypter(key_128), IsOk());
+  EXPECT_THAT(CreateAesGcmOneShotCrypter(key_256), IsOk());
 }
 
 TEST(SslOneShotAeadTest, AesGcmTestTestFipsFailWithoutBoringCrypto) {
@@ -608,7 +608,7 @@ TEST_P(SslOneShotAeadWycheproofTest, Encrypt) {
   util::SecretData key = util::SecretDataFromStringView(test_vector.key);
   util::StatusOr<std::unique_ptr<SslOneShotAead>> aead =
       CipherFromName(params.cipher, key);
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
   std::string ciphertext_and_tag =
       absl::StrCat(test_vector.ct, test_vector.tag);
   std::string ciphertext_buffer;
@@ -624,7 +624,7 @@ TEST_P(SslOneShotAeadWycheproofTest, Encrypt) {
   std::cout << test_vector.expected << "\n";
 
   if (test_vector.expected == "valid" || test_vector.expected == "acceptable") {
-    ASSERT_THAT(written_bytes.status(), IsOk());
+    ASSERT_THAT(written_bytes, IsOk());
     EXPECT_EQ(ciphertext_buffer, expected_ciphertext);
   } else {  // invalid.
     // In this case, if the resulting ciphertext/tag are different, the
@@ -643,7 +643,7 @@ TEST_P(SslOneShotAeadWycheproofTest, Decrypt) {
   util::SecretData key = util::SecretDataFromStringView(test_vector.key);
   util::StatusOr<std::unique_ptr<SslOneShotAead>> aead =
       CipherFromName(params.cipher, key);
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
   std::string ciphertext_and_tag =
       absl::StrCat(test_vector.ct, test_vector.tag);
   std::string plaintext_buffer;
diff --git a/cc/aead/internal/zero_copy_aead_wrapper_test.cc b/cc/aead/internal/zero_copy_aead_wrapper_test.cc
index d9da8409f..489b7deaf 100644
--- a/cc/aead/internal/zero_copy_aead_wrapper_test.cc
+++ b/cc/aead/internal/zero_copy_aead_wrapper_test.cc
@@ -80,7 +80,7 @@ class ZeroCopyAeadWrapperTest : public testing::Test {
     std::unique_ptr<PrimitiveSet<ZeroCopyAead>> aead_set(
         new PrimitiveSet<ZeroCopyAead>());
     auto entry = aead_set->AddPrimitive(SetUpMockZeroCopyAead(), key_info);
-    ASSERT_THAT(entry.status(), IsOk());
+    ASSERT_THAT(entry, IsOk());
     ASSERT_THAT(aead_set->set_primary(*entry), IsOk());
     aead_set_ = std::move(aead_set);
   }
@@ -115,12 +115,12 @@ class ZeroCopyAeadWrapperTest : public testing::Test {
 TEST_F(ZeroCopyAeadWrapperTest, EncryptDecrypt) {
   ZeroCopyAeadWrapper wrapper;
   StatusOr<std::unique_ptr<Aead>> aead_set = wrapper.Wrap(std::move(aead_set_));
-  ASSERT_THAT(aead_set.status(), IsOk());
+  ASSERT_THAT(aead_set, IsOk());
 
   StatusOr<std::string> ciphertext = (*aead_set)->Encrypt(kPlaintext, kAad);
-  ASSERT_THAT(ciphertext.status(), IsOk());
+  ASSERT_THAT(ciphertext, IsOk());
   StatusOr<std::string> plaintext = (*aead_set)->Decrypt(*ciphertext, kAad);
-  ASSERT_THAT(plaintext.status(), IsOk());
+  ASSERT_THAT(plaintext, IsOk());
   EXPECT_EQ(*plaintext, kPlaintext);
 }
 
@@ -135,7 +135,7 @@ TEST_F(ZeroCopyAeadWrapperTest, EncryptMultipleKeys) {
       kPlaintext, kAad,
       absl::MakeSpan(ciphertext)
           .subspan(CryptoFormat::kNonRawPrefixSize, ciphertext.size()));
-  ASSERT_THAT(ciphertext_size.status(), IsOk());
+  ASSERT_THAT(ciphertext_size, IsOk());
   const std::string& key_id = aead_set_->get_primary()->get_identifier();
   std::memcpy(&ciphertext[0], key_id.data(), key_id.size());
   ciphertext.resize(key_id.size() + *ciphertext_size);
@@ -150,13 +150,13 @@ TEST_F(ZeroCopyAeadWrapperTest, EncryptMultipleKeys) {
               IsOk());
   ZeroCopyAeadWrapper wrapper;
   StatusOr<std::unique_ptr<Aead>> aead_set = wrapper.Wrap(std::move(aead_set_));
-  ASSERT_THAT(aead_set.status(), IsOk());
+  ASSERT_THAT(aead_set, IsOk());
 
   // Encrypt with the wrapped AEAD and check that the result is equal to
   // encrypting directly with the primary key.
   StatusOr<std::string> wrap_ciphertext =
       (*aead_set)->Encrypt(kPlaintext, kAad);
-  ASSERT_THAT(wrap_ciphertext.status(), IsOk());
+  ASSERT_THAT(wrap_ciphertext, IsOk());
   EXPECT_EQ(*wrap_ciphertext, ciphertext);
 }
 
@@ -167,13 +167,13 @@ TEST_F(ZeroCopyAeadWrapperTest, EncryptDecryptRawKey) {
   key_info.set_key_id(1234);
   key_info.set_status(KeyStatusType::ENABLED);
   auto entry = aead_set_->AddPrimitive(SetUpMockZeroCopyAead(), key_info);
-  ASSERT_THAT(entry.status(), IsOk());
+  ASSERT_THAT(entry, IsOk());
   ASSERT_THAT(aead_set_->set_primary(*entry), IsOk());
 
   // Manually encrypt with the raw key.
   util::StatusOr<const std::vector<std::unique_ptr<ZeroCopyAeadEntry>>*>
       raw_primitives = aead_set_->get_raw_primitives();
-  ASSERT_THAT(raw_primitives.status(), IsOk());
+  ASSERT_THAT(raw_primitives, IsOk());
   EXPECT_EQ((*raw_primitives)->size(), 1);
   ZeroCopyAead& aead = (*raw_primitives)->front()->get_primitive();
   std::string ciphertext;
@@ -181,17 +181,17 @@ TEST_F(ZeroCopyAeadWrapperTest, EncryptDecryptRawKey) {
                                     aead.MaxEncryptionSize(kPlaintext.size()));
   util::StatusOr<int64_t> ciphertext_size =
       aead.Encrypt(kPlaintext, kAad, absl::MakeSpan(ciphertext));
-  ASSERT_THAT(ciphertext_size.status(), IsOk());
+  ASSERT_THAT(ciphertext_size, IsOk());
   ciphertext.resize(*ciphertext_size);
 
   // Encrypt with the wrapped AEAD and check that the result is equal to
   // encrypting directly with the raw key.
   ZeroCopyAeadWrapper wrapper;
   StatusOr<std::unique_ptr<Aead>> aead_set = wrapper.Wrap(std::move(aead_set_));
-  ASSERT_THAT(aead_set.status(), IsOk());
+  ASSERT_THAT(aead_set, IsOk());
   StatusOr<std::string> wrap_ciphertext =
       (*aead_set)->Encrypt(kPlaintext, kAad);
-  ASSERT_THAT(wrap_ciphertext.status(), IsOk());
+  ASSERT_THAT(wrap_ciphertext, IsOk());
   EXPECT_EQ(*wrap_ciphertext, ciphertext);
 
   // Manually decrypt with the raw key.
@@ -200,20 +200,20 @@ TEST_F(ZeroCopyAeadWrapperTest, EncryptDecryptRawKey) {
                                     aead.MaxDecryptionSize(ciphertext.size()));
   util::StatusOr<int64_t> plaintext_size =
       aead.Decrypt(ciphertext, kAad, absl::MakeSpan(plaintext));
-  ASSERT_THAT(plaintext_size.status(), IsOk());
+  ASSERT_THAT(plaintext_size, IsOk());
   plaintext.resize(*plaintext_size);
   EXPECT_EQ(plaintext, kPlaintext);
 
   // Decrypt with the wrapped AEAD.
   StatusOr<std::string> wrap_plaintext = (*aead_set)->Decrypt(ciphertext, kAad);
-  ASSERT_THAT(wrap_plaintext.status(), IsOk());
+  ASSERT_THAT(wrap_plaintext, IsOk());
   EXPECT_EQ(*wrap_plaintext, kPlaintext);
 }
 
 TEST_F(ZeroCopyAeadWrapperTest, EncryptBadDecrypt) {
   ZeroCopyAeadWrapper wrapper;
   StatusOr<std::unique_ptr<Aead>> aead_set = wrapper.Wrap(std::move(aead_set_));
-  ASSERT_THAT(aead_set.status(), IsOk());
+  ASSERT_THAT(aead_set, IsOk());
 
   StatusOr<std::string> plaintext =
       (*aead_set)->Decrypt("some bad ciphertext", kAad);
diff --git a/cc/aead/internal/zero_copy_aes_gcm_boringssl_test.cc b/cc/aead/internal/zero_copy_aes_gcm_boringssl_test.cc
index 730fdd403..093315307 100644
--- a/cc/aead/internal/zero_copy_aes_gcm_boringssl_test.cc
+++ b/cc/aead/internal/zero_copy_aes_gcm_boringssl_test.cc
@@ -74,7 +74,7 @@ class ZeroCopyAesGcmBoringSslTest : public testing::Test {
         util::SecretDataFromStringView(absl::HexStringToBytes(kKey128Hex));
     util::StatusOr<std::unique_ptr<ZeroCopyAead>> cipher =
         ZeroCopyAesGcmBoringSsl::New(key);
-    ASSERT_THAT(cipher.status(), IsOk());
+    ASSERT_THAT(cipher, IsOk());
     cipher_ = std::move(*cipher);
   }
 
@@ -94,7 +94,7 @@ TEST_F(ZeroCopyAesGcmBoringSslTest, EncryptDecrypt) {
       &ciphertext, cipher_->MaxEncryptionSize(kMessage.size()));
   util::StatusOr<int64_t> ciphertext_size =
       cipher_->Encrypt(kMessage, kAssociatedData, absl::MakeSpan(ciphertext));
-  ASSERT_THAT(ciphertext_size.status(), IsOk());
+  ASSERT_THAT(ciphertext_size, IsOk());
   EXPECT_EQ(*ciphertext_size,
             kIvSizeInBytes + kMessage.size() + kTagSizeInBytes);
   std::string plaintext;
@@ -103,7 +103,7 @@ TEST_F(ZeroCopyAesGcmBoringSslTest, EncryptDecrypt) {
   util::StatusOr<int64_t> plaintext_size =
       cipher_->Decrypt(ciphertext, kAssociatedData, absl::MakeSpan(plaintext));
 
-  ASSERT_THAT(plaintext_size.status(), IsOk());
+  ASSERT_THAT(plaintext_size, IsOk());
   EXPECT_EQ(plaintext, kMessage);
 }
 
@@ -113,7 +113,7 @@ TEST_F(ZeroCopyAesGcmBoringSslTest, DecryptEncodedCiphertext) {
   util::StatusOr<int64_t> plaintext_size =
       cipher_->Decrypt(absl::HexStringToBytes(kEncodedCiphertext),
                        kAssociatedData, absl::MakeSpan(plaintext));
-  ASSERT_THAT(plaintext_size.status(), IsOk());
+  ASSERT_THAT(plaintext_size, IsOk());
   EXPECT_EQ(plaintext.substr(0, *plaintext_size), kMessage);
 }
 
@@ -189,7 +189,7 @@ TEST_P(ZeroCopyAesGcmBoringSslWycheproofTest, Decrypt) {
   util::SecretData key = util::SecretDataFromStringView(test_vector.key);
   util::StatusOr<std::unique_ptr<ZeroCopyAead>> cipher =
       ZeroCopyAesGcmBoringSsl::New(key);
-  ASSERT_THAT(cipher.status(), IsOk());
+  ASSERT_THAT(cipher, IsOk());
   std::string ciphertext =
       absl::StrCat(test_vector.nonce, test_vector.ct, test_vector.tag);
   std::string plaintext;
diff --git a/cc/aead/kms_aead_key_manager_test.cc b/cc/aead/kms_aead_key_manager_test.cc
index a92e67203..af7b89e40 100644
--- a/cc/aead/kms_aead_key_manager_test.cc
+++ b/cc/aead/kms_aead_key_manager_test.cc
@@ -103,7 +103,7 @@ TEST(KmsAeadKeyManagerTest, CreateKey) {
   KmsAeadKeyFormat key_format;
   key_format.set_key_uri("Some uri");
   auto key_or = KmsAeadKeyManager().CreateKey(key_format);
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
   EXPECT_THAT(key_or.value().params().key_uri(), Eq(key_format.key_uri()));
 }
 
@@ -128,7 +128,7 @@ TEST_F(KmsAeadKeyManagerCreateTest, CreateAead) {
   key.mutable_params()->set_key_uri("prefix1:some_key1");
 
   auto kms_aead = KmsAeadKeyManager().GetPrimitive<Aead>(key);
-  ASSERT_THAT(kms_aead.status(), IsOk());
+  ASSERT_THAT(kms_aead, IsOk());
 
   DummyAead direct_aead("prefix1:some_key1");
 
@@ -143,7 +143,7 @@ TEST_F(KmsAeadKeyManagerCreateTest, CreateAeadWrongKeyName) {
   key.mutable_params()->set_key_uri("prefix1:some_other_key");
 
   auto kms_aead = KmsAeadKeyManager().GetPrimitive<Aead>(key);
-  ASSERT_THAT(kms_aead.status(), Not(IsOk()));
+  ASSERT_THAT(kms_aead, Not(IsOk()));
 }
 
 TEST_F(KmsAeadKeyManagerCreateTest, CreateAeadWrongPrefix) {
@@ -152,7 +152,7 @@ TEST_F(KmsAeadKeyManagerCreateTest, CreateAeadWrongPrefix) {
   key.mutable_params()->set_key_uri("non-existing-prefix:some_key1");
 
   auto kms_aead = KmsAeadKeyManager().GetPrimitive<Aead>(key);
-  ASSERT_THAT(kms_aead.status(), Not(IsOk()));
+  ASSERT_THAT(kms_aead, Not(IsOk()));
 }
 
 TEST_F(KmsAeadKeyManagerCreateTest, CreateAeadUnboundKey) {
@@ -161,7 +161,7 @@ TEST_F(KmsAeadKeyManagerCreateTest, CreateAeadUnboundKey) {
   key.mutable_params()->set_key_uri("prefix2:some_key2");
 
   auto kms_aead = KmsAeadKeyManager().GetPrimitive<Aead>(key);
-  ASSERT_THAT(kms_aead.status(), IsOk());
+  ASSERT_THAT(kms_aead, IsOk());
 
   DummyAead direct_aead("prefix2:some_key2");
 
diff --git a/cc/aead/kms_envelope_aead_key_manager_test.cc b/cc/aead/kms_envelope_aead_key_manager_test.cc
index 5f1c7a630..7b32aa137 100644
--- a/cc/aead/kms_envelope_aead_key_manager_test.cc
+++ b/cc/aead/kms_envelope_aead_key_manager_test.cc
@@ -128,7 +128,7 @@ TEST(KmsEnvelopeAeadKeyManagerTest, CreateKey) {
   key_format.set_kek_uri("Some uri");
   *key_format.mutable_dek_template() = AeadKeyTemplates::Aes128Eax();
   auto key_or = KmsEnvelopeAeadKeyManager().CreateKey(key_format);
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
   EXPECT_THAT(key_or.value().params().kek_uri(), Eq(key_format.kek_uri()));
   EXPECT_THAT(key_or.value().params().dek_template().value(),
               Eq(key_format.dek_template().value()));
@@ -162,12 +162,12 @@ TEST_F(KmsEnvelopeAeadKeyManagerCreateTest, CreateAead) {
       AeadKeyTemplates::Aes128Eax();
 
   auto kms_aead = KmsEnvelopeAeadKeyManager().GetPrimitive<Aead>(key);
-  ASSERT_THAT(kms_aead.status(), IsOk());
+  ASSERT_THAT(kms_aead, IsOk());
 
   auto direct_aead =
       KmsEnvelopeAead::New(key.params().dek_template(),
                            absl::make_unique<DummyAead>("prefix1:some_key1"));
-  ASSERT_THAT(direct_aead.status(), IsOk());
+  ASSERT_THAT(direct_aead, IsOk());
 
   EXPECT_THAT(EncryptThenDecrypt(*kms_aead.value(), *direct_aead.value(),
                                  "plaintext", "aad"),
@@ -182,7 +182,7 @@ TEST_F(KmsEnvelopeAeadKeyManagerCreateTest, CreateAeadWrongKeyName) {
       AeadKeyTemplates::Aes128Eax();
 
   auto kms_aead = KmsEnvelopeAeadKeyManager().GetPrimitive<Aead>(key);
-  ASSERT_THAT(kms_aead.status(), Not(IsOk()));
+  ASSERT_THAT(kms_aead, Not(IsOk()));
 }
 
 TEST_F(KmsEnvelopeAeadKeyManagerCreateTest, CreateAeadWrongTypeUrl) {
@@ -195,7 +195,7 @@ TEST_F(KmsEnvelopeAeadKeyManagerCreateTest, CreateAeadWrongTypeUrl) {
       "Some unkonwn type url");
 
   auto kms_aead = KmsEnvelopeAeadKeyManager().GetPrimitive<Aead>(key);
-  ASSERT_THAT(kms_aead.status(), Not(IsOk()));
+  ASSERT_THAT(kms_aead, Not(IsOk()));
 }
 
 TEST_F(KmsEnvelopeAeadKeyManagerCreateTest, CreateAeadWrongPrefix) {
@@ -206,7 +206,7 @@ TEST_F(KmsEnvelopeAeadKeyManagerCreateTest, CreateAeadWrongPrefix) {
       AeadKeyTemplates::Aes128Eax();
 
   auto kms_aead = KmsEnvelopeAeadKeyManager().GetPrimitive<Aead>(key);
-  ASSERT_THAT(kms_aead.status(), Not(IsOk()));
+  ASSERT_THAT(kms_aead, Not(IsOk()));
 }
 
 TEST_F(KmsEnvelopeAeadKeyManagerCreateTest, CreateAeadUnboundKey) {
@@ -217,12 +217,12 @@ TEST_F(KmsEnvelopeAeadKeyManagerCreateTest, CreateAeadUnboundKey) {
       AeadKeyTemplates::Aes128Eax();
 
   auto kms_aead = KmsEnvelopeAeadKeyManager().GetPrimitive<Aead>(key);
-  ASSERT_THAT(kms_aead.status(), IsOk());
+  ASSERT_THAT(kms_aead, IsOk());
 
   auto direct_aead =
       KmsEnvelopeAead::New(key.params().dek_template(),
                            absl::make_unique<DummyAead>("prefix2:some_key2"));
-  ASSERT_THAT(direct_aead.status(), IsOk());
+  ASSERT_THAT(direct_aead, IsOk());
 
   EXPECT_THAT(EncryptThenDecrypt(*kms_aead.value(), *direct_aead.value(),
                                  "plaintext", "aad"),
diff --git a/cc/aead/kms_envelope_aead_test.cc b/cc/aead/kms_envelope_aead_test.cc
index 659850daa..673a1b559 100644
--- a/cc/aead/kms_envelope_aead_test.cc
+++ b/cc/aead/kms_envelope_aead_test.cc
@@ -56,14 +56,14 @@ TEST(KmsEnvelopeAeadTest, BasicEncryptDecrypt) {
   auto remote_aead = absl::make_unique<DummyAead>(remote_aead_name);
 
   auto aead_result = KmsEnvelopeAead::New(dek_template, std::move(remote_aead));
-  EXPECT_THAT(aead_result.status(), IsOk());
+  EXPECT_THAT(aead_result, IsOk());
   auto aead = std::move(aead_result.value());
   std::string message = "Some data to encrypt.";
   std::string aad = "Some data to authenticate.";
   auto encrypt_result = aead->Encrypt(message, aad);
-  EXPECT_THAT(encrypt_result.status(), IsOk());
+  EXPECT_THAT(encrypt_result, IsOk());
   auto decrypt_result = aead->Decrypt(encrypt_result.value(), aad);
-  EXPECT_THAT(decrypt_result.status(), IsOk());
+  EXPECT_THAT(decrypt_result, IsOk());
   EXPECT_EQ(decrypt_result.value(), message);
 }
 
@@ -103,12 +103,12 @@ TEST(KmsEnvelopeAeadTest, DecryptionErrors) {
   auto remote_aead = absl::make_unique<DummyAead>(remote_aead_name);
 
   auto aead_result = KmsEnvelopeAead::New(dek_template, std::move(remote_aead));
-  EXPECT_THAT(aead_result.status(), IsOk());
+  EXPECT_THAT(aead_result, IsOk());
   auto aead = std::move(aead_result.value());
   std::string message = "Some data to encrypt.";
   std::string aad = "Some data to authenticate.";
   auto encrypt_result = aead->Encrypt(message, aad);
-  EXPECT_THAT(encrypt_result.status(), IsOk());
+  EXPECT_THAT(encrypt_result, IsOk());
   auto ct = encrypt_result.value();
 
   // Empty ciphertext.
@@ -155,13 +155,13 @@ TEST(KmsEnvelopeAeadTest, KeyFormat) {
 
   // Create envelope AEAD and encrypt some data.
   auto aead_result = KmsEnvelopeAead::New(dek_template, std::move(remote_aead));
-  EXPECT_THAT(aead_result.status(), IsOk());
+  EXPECT_THAT(aead_result, IsOk());
 
   auto aead = std::move(aead_result.value());
   std::string message = "Some data to encrypt.";
   std::string aad = "Some data to authenticate.";
   auto encrypt_result = aead->Encrypt(message, aad);
-  EXPECT_THAT(encrypt_result.status(), IsOk());
+  EXPECT_THAT(encrypt_result, IsOk());
   auto ct = encrypt_result.value();
 
   // Recover DEK from ciphertext
diff --git a/cc/aead/xchacha20_poly1305_key_manager_test.cc b/cc/aead/xchacha20_poly1305_key_manager_test.cc
index 7145d413d..347215853 100644
--- a/cc/aead/xchacha20_poly1305_key_manager_test.cc
+++ b/cc/aead/xchacha20_poly1305_key_manager_test.cc
@@ -110,7 +110,7 @@ TEST(XChaCha20Poly1305KeyManagerTest, CreateKey) {
   StatusOr<XChaCha20Poly1305Key> key_or =
       XChaCha20Poly1305KeyManager().CreateKey(XChaCha20Poly1305KeyFormat());
 
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
   EXPECT_THAT(key_or.value().key_value(), SizeIs(32));
   EXPECT_THAT(key_or.value().version(), Eq(0));
 }
@@ -123,7 +123,7 @@ TEST(XChaCha20Poly1305KeyManagerTest, DeriveKey) {
   StatusOr<XChaCha20Poly1305Key> key_or =
       XChaCha20Poly1305KeyManager().DeriveKey(format, &input_stream);
 
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
   EXPECT_THAT(key_or.value().key_value(), SizeIs(32));
   EXPECT_THAT(key_or.value().version(), Eq(0));
 }
@@ -136,7 +136,7 @@ TEST(XChaCha20Poly1305KeyManagerTest, DeriveKeyFromLongSeed) {
   format.set_version(0);
   auto key_or = XChaCha20Poly1305KeyManager().DeriveKey(format, &input_stream);
 
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
   EXPECT_THAT(key_or.value().key_value(),
               Eq("0123456789abcdef0123456789abcdef"));
 }
@@ -170,7 +170,7 @@ TEST(XChaCha20Poly1305KeyManagerTest, CreateKeyValid) {
   StatusOr<XChaCha20Poly1305Key> key_or =
       XChaCha20Poly1305KeyManager().CreateKey(XChaCha20Poly1305KeyFormat());
 
-  ASSERT_THAT(key_or.status(), IsOk());
+  ASSERT_THAT(key_or, IsOk());
   EXPECT_THAT(XChaCha20Poly1305KeyManager().ValidateKey(key_or.value()),
               IsOk());
 }
@@ -181,7 +181,7 @@ TEST(XChaCha20Poly1305KeyManagerTest, CreateAeadFailsWithOpenSsl) {
   }
   StatusOr<XChaCha20Poly1305Key> key =
       XChaCha20Poly1305KeyManager().CreateKey(XChaCha20Poly1305KeyFormat());
-  ASSERT_THAT(key.status(), IsOk());
+  ASSERT_THAT(key, IsOk());
   EXPECT_THAT(XChaCha20Poly1305KeyManager().GetPrimitive<Aead>(*key).status(),
               Not(IsOk()));
   EXPECT_THAT(subtle::XChacha20Poly1305BoringSsl::New(
@@ -196,16 +196,16 @@ TEST(XChaCha20Poly1305KeyManagerTest, CreateAeadSucceedsWithBoringSsl) {
   }
   StatusOr<XChaCha20Poly1305Key> key =
       XChaCha20Poly1305KeyManager().CreateKey(XChaCha20Poly1305KeyFormat());
-  ASSERT_THAT(key.status(), IsOk());
+  ASSERT_THAT(key, IsOk());
 
   StatusOr<std::unique_ptr<Aead>> aead =
       XChaCha20Poly1305KeyManager().GetPrimitive<Aead>(*key);
-  ASSERT_THAT(aead.status(), IsOk());
+  ASSERT_THAT(aead, IsOk());
 
   StatusOr<std::unique_ptr<Aead>> direct_aead =
       subtle::XChacha20Poly1305BoringSsl::New(
           util::SecretDataFromStringView(key->key_value()));
-  ASSERT_THAT(direct_aead.status(), IsOk());
+  ASSERT_THAT(direct_aead, IsOk());
   EXPECT_THAT(EncryptThenDecrypt(**aead, **direct_aead, "message", "aad"),
               IsOk());
 }