diff --git a/libwvdrmengine/cdm/core/test/license_holder.cpp b/libwvdrmengine/cdm/core/test/license_holder.cpp
index ceef5315..c2532e2f 100644
--- a/libwvdrmengine/cdm/core/test/license_holder.cpp
+++ b/libwvdrmengine/cdm/core/test/license_holder.cpp
@@ -86,28 +86,70 @@ void LicenseHolder::GenerateAndPostRenewalRequest(
     MessageDumper::DumpRenewalRequest(request);
   }
   const std::string url = MakeUrl(config_.renewal_server(), policy_id);
-  renewal_in_flight_.reset(new UrlRequest(url));
-  ASSERT_TRUE(renewal_in_flight_->is_connected())
+  request_in_flight_.reset(new UrlRequest(url));
+  ASSERT_TRUE(request_in_flight_->is_connected())
       << "Failed for " << content_id();
-  renewal_in_flight_->PostRequest(request.message);
+  request_in_flight_->PostRequest(request.message);
 }
+
 void LicenseHolder::FetchRenewal() {
-  ASSERT_NE(renewal_in_flight_, nullptr) << "Failed for " << content_id();
+  ASSERT_NE(request_in_flight_, nullptr) << "Failed for " << content_id();
   ASSERT_NO_FATAL_FAILURE(
-      renewal_in_flight_->AssertOkResponse(&renewal_response_))
+      request_in_flight_->AssertOkResponse(&request_response_))
       << "Renewal failed for " << content_id();
 }
 
 void LicenseHolder::LoadRenewal() {
   LicenseRequest license_request;
-  license_request.GetDrmMessage(renewal_response_, renewal_message_);
+  license_request.GetDrmMessage(request_response_, request_message_);
   if (config_.dump_golden_data()) {
-    MessageDumper::DumpRenewal(renewal_message_);
+    MessageDumper::DumpRenewal(request_message_);
   }
-  EXPECT_EQ(KEY_ADDED, cdm_engine_->RenewKey(session_id_, renewal_message_))
+  EXPECT_EQ(KEY_ADDED, cdm_engine_->RenewKey(session_id_, request_message_))
       << "Failed for " << content_id();
 }
 
+void LicenseHolder::GenerateAndPostReleaseRequest(
+    const std::string& policy_id) {
+  event_listener_.set_renewal_needed(false);
+  CdmKeyRequest request;
+  CdmAppParameterMap empty_app_parameters;
+  video_widevine::WidevinePsshData pssh;
+  pssh.set_content_id(content_id_);
+  const std::string init_data_string = MakePSSH(pssh);
+  const InitializationData init_data(kCencMimeType, init_data_string);
+  init_data.DumpToLogs();
+  const CdmResponseType result = cdm_engine_->GenerateKeyRequest(
+      session_id_, key_set_id_, init_data, kLicenseTypeRelease,
+      empty_app_parameters, &request);
+  ASSERT_EQ(KEY_MESSAGE, result) << "Failed for " << content_id();
+  if (config_.dump_golden_data()) {
+    // TODO (b/295956275) vickymin: write DumpReleaseRequest function
+    // MessageDumper::DumpReleaseRequest(request);
+  }
+  const std::string url = MakeUrl(config_.renewal_server(), policy_id);
+  request_in_flight_.reset(new UrlRequest(url));
+  ASSERT_TRUE(request_in_flight_->is_connected())
+      << "Failed for " << content_id();
+  request_in_flight_->PostRequest(request.message);
+}
+
+void LicenseHolder::FetchRelease() {
+  ASSERT_NE(request_in_flight_, nullptr) << "Failed for " << content_id();
+  ASSERT_NO_FATAL_FAILURE(
+      request_in_flight_->AssertOkResponse(&request_response_))
+      << "Renewal failed for " << content_id();
+}
+
+void LicenseHolder::LoadRelease() {
+  LicenseRequest license_request;
+  license_request.GetDrmMessage(request_response_, request_message_);
+  if (config_.dump_golden_data()) {
+    // TODO (b/295956275) vickymin: write DumpRelease function
+    // MessageDumper::DumpRelease(request_message_);
+  }
+}
+
 void LicenseHolder::RemoveLicense() {
   EXPECT_EQ(NO_ERROR, cdm_engine_->RemoveLicense(session_id_))
       << "Failed for " << content_id();
diff --git a/libwvdrmengine/cdm/core/test/license_holder.h b/libwvdrmengine/cdm/core/test/license_holder.h
index 914e8d22..be527004 100644
--- a/libwvdrmengine/cdm/core/test/license_holder.h
+++ b/libwvdrmengine/cdm/core/test/license_holder.h
@@ -72,6 +72,12 @@ class LicenseHolder {
   void FetchRenewal();
   // Load the renewal response that was fetched in FetchRenewal().
   void LoadRenewal();
+  // Generate the release request, and send it to the server.
+  void GenerateAndPostReleaseRequest(const std::string& policy_id);
+  // Fetch the release response. This can add a few seconds of latency.
+  void FetchRelease();
+  // Load the release response that was fetched in FetchRelease().
+  void LoadRelease();
   // Releases the license and frees up entry in usage table.
   void RemoveLicense();
 
@@ -115,9 +121,9 @@ class LicenseHolder {
   CdmEngine* cdm_engine_ = nullptr;
   const ConfigTestEnv& config_;
   SimpleEventListener event_listener_;
-  std::unique_ptr<UrlRequest> renewal_in_flight_;
-  std::string renewal_message_;
-  std::string renewal_response_;
+  std::unique_ptr<UrlRequest> request_in_flight_;
+  std::string request_message_;
+  std::string request_response_;
 
   // Generate the license request.
   void GenerateKeyRequest(const InitializationData& init_data,
diff --git a/libwvdrmengine/cdm/core/test/policy_integration_test.cpp b/libwvdrmengine/cdm/core/test/policy_integration_test.cpp
index 2f6f8d1c..6b439f6d 100644
--- a/libwvdrmengine/cdm/core/test/policy_integration_test.cpp
+++ b/libwvdrmengine/cdm/core/test/policy_integration_test.cpp
@@ -22,6 +22,7 @@
 #include "provisioning_holder.h"
 #include "test_base.h"
 #include "test_printers.h"
+#include "test_sleep.h"
 #include "wv_cdm_types.h"
 
 namespace wvcdm {
@@ -114,6 +115,46 @@ TEST_F(CorePIGTest, OfflineHWSecureRequired) {
   ASSERT_NO_FATAL_FAILURE(holder.CloseSession());
 }
 
+// Should be able to request license, perform playback, generate a license
+// release, and receive the release response.
+TEST_F(CorePIGTest, LicenseRelease1) {
+  LicenseHolder holder("CDM_UnlimitedStreaming_can_persist", &cdm_engine_,
+                       config_);
+  holder.set_can_persist(true);
+  const KeyId key_id = "0000000000000000";
+
+  ASSERT_NO_FATAL_FAILURE(holder.OpenSession());
+  ASSERT_NO_FATAL_FAILURE(holder.FetchLicense());
+  ASSERT_NO_FATAL_FAILURE(holder.LoadLicense());
+  EXPECT_EQ(NO_ERROR, holder.Decrypt(key_id));
+  ASSERT_NO_FATAL_FAILURE(holder.GenerateAndPostReleaseRequest(
+      "CDM_UnlimitedStreaming_can_persist"));
+  EXPECT_NE(NO_ERROR, holder.Decrypt(key_id));
+  ASSERT_NO_FATAL_FAILURE(holder.FetchRelease());
+  ASSERT_NO_FATAL_FAILURE(holder.LoadRelease());
+  EXPECT_NE(NO_ERROR, holder.Decrypt(key_id));
+  ASSERT_NO_FATAL_FAILURE(holder.CloseSession());
+}
+
+// Should be able to request license, wait some time, generate a license
+// release, and receive the release response.
+TEST_F(CorePIGTest, LicenseRelease2) {
+  LicenseHolder holder("CDM_UnlimitedStreaming_can_persist", &cdm_engine_,
+                       config_);
+  holder.set_can_persist(true);
+  const KeyId key_id = "0000000000000000";
+
+  ASSERT_NO_FATAL_FAILURE(holder.OpenSession());
+  ASSERT_NO_FATAL_FAILURE(holder.FetchLicense());
+  ASSERT_NO_FATAL_FAILURE(holder.LoadLicense());
+  wvutil::TestSleep::Sleep(10);
+  ASSERT_NO_FATAL_FAILURE(holder.GenerateAndPostReleaseRequest(
+      "CDM_UnlimitedStreaming_can_persist"));
+  ASSERT_NO_FATAL_FAILURE(holder.FetchRelease());
+  ASSERT_NO_FATAL_FAILURE(holder.LoadRelease());
+  ASSERT_NO_FATAL_FAILURE(holder.CloseSession());
+}
+
 TEST_F(CorePIGTest, CastReceiverProvisioningUsingCdm) {
   const std::string digest_hex_str =
       // digest info header