diff --git a/services/distributedfiledaemon/test/unittest/ipc/daemon_execute/daemon_execute_test.cpp b/services/distributedfiledaemon/test/unittest/ipc/daemon_execute/daemon_execute_test.cpp
index 706579bc7b46fc5b3b923e0cac9c746d7e6c6c72..a3e255d0517cf2674e2a3e47ec06a49b00825b8d 100644
--- a/services/distributedfiledaemon/test/unittest/ipc/daemon_execute/daemon_execute_test.cpp
+++ b/services/distributedfiledaemon/test/unittest/ipc/daemon_execute/daemon_execute_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -20,6 +20,8 @@
 
 #include "all_connect_manager_mock.h"
 #include "daemon_execute.h"
+#include "daemon_mock.h"
+#include "device_manager_impl.h"
 #include "dfs_error.h"
 #include "sandbox_helper.h"
 #include "softbus_handler_asset_mock.h"
@@ -30,6 +32,11 @@ std::string g_physicalPath;
 int32_t g_getPhysicalPath = 0;
 bool g_checkValidPath = false;
 bool g_isFolder;
+int32_t g_dmResult = 0;
+
+const int32_t E_INVAL_ARG_NAPI = 401;
+const std::string FILE_MANAGER_AUTHORITY = "docs";
+const std::string MEDIA_AUTHORITY = "media";
 } // namespace
 
 namespace OHOS::AppFileService {
@@ -45,6 +52,15 @@ bool SandboxHelper::CheckValidPath(const std::string &filePath)
 }
 } // namespace OHOS::AppFileService
 
+namespace OHOS::DistributedHardware {
+
+int32_t DeviceManagerImpl::GetLocalDeviceInfo(const std::string &pkgName, DmDeviceInfo &info)
+{
+    return g_dmResult;
+}
+
+} // namespace OHOS::DistributedHardware
+
 namespace OHOS::Storage::DistributedFile::Utils {
 bool IsFolder(const std::string &name)
 {
@@ -334,4 +350,226 @@ HWTEST_F(DaemonExecuteTest, DaemonExecute_HandleZip_001, TestSize.Level1)
     EXPECT_EQ(daemonExecute_->HandleZip(fileList, assetObj, sendFileName, isSingleFile), E_OK);
     GTEST_LOG_(INFO) << "DaemonExecute_HandleZip_001 end";
 }
+
+/**
+ * @tc.name: DaemonExecute_PrepareSessionInner_001
+ * @tc.desc: verify PrepareSessionInner.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(DaemonExecuteTest, DaemonExecute_PrepareSessionInner_001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_001 begin";
+
+    std::string srcUri;
+    std::string physicalPath;
+    std::string sessionName;
+    sptr<DaemonMock> daemon = new (std::nothrow) DaemonMock();
+    HmdfsInfo info;
+
+    // Test case 1: CreateSessionServer fails
+    EXPECT_CALL(*softBusHandlerMock_, CreateSessionServer(_, _, _, _)).WillOnce(Return(-1));
+    EXPECT_EQ(daemonExecute_->PrepareSessionInner(srcUri, physicalPath, sessionName, daemon, info),
+              E_SOFTBUS_SESSION_FAILED);
+
+    GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_001 end";
+}
+
+/**
+ * @tc.name: DaemonExecute_PrepareSessionInner_002
+ * @tc.desc: verify PrepareSessionInner.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(DaemonExecuteTest, DaemonExecute_PrepareSessionInner_002, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_002 begin";
+
+    std::string srcUri;
+    std::string physicalPath;
+    std::string sessionName;
+    sptr<DaemonMock> daemon = nullptr;
+    HmdfsInfo info;
+
+    // Test case 2: CreateSessionServer success but daemon is nullptr
+    EXPECT_CALL(*softBusHandlerMock_, CreateSessionServer(_, _, _, _)).WillOnce(Return(1));
+    EXPECT_EQ(daemonExecute_->PrepareSessionInner(srcUri, physicalPath, sessionName, daemon, info), E_INVAL_ARG_NAPI);
+
+    GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_002 end";
+}
+
+/**
+ * @tc.name: DaemonExecute_PrepareSessionInner_003
+ * @tc.desc: verify PrepareSessionInner.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(DaemonExecuteTest, DaemonExecute_PrepareSessionInner_003, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_003 begin";
+
+    std::string srcUri;
+    std::string physicalPath;
+    std::string sessionName;
+    sptr<DaemonMock> daemon = new (std::nothrow) DaemonMock();
+    HmdfsInfo info;
+
+    // Test case 3: CreateSessionServer succeeds, but authority is not media or docs
+    EXPECT_CALL(*softBusHandlerMock_, CreateSessionServer(_, _, _, _)).WillOnce(Return(1));
+    EXPECT_CALL(*daemon, RequestSendFile(_, _, _, _)).WillOnce(Return(ERR_BAD_VALUE));
+    EXPECT_EQ(daemonExecute_->PrepareSessionInner(srcUri, physicalPath, sessionName, daemon, info), E_SA_LOAD_FAILED);
+
+    GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_003 end";
+}
+
+/**
+ * @tc.name: DaemonExecute_PrepareSessionInner_004
+ * @tc.desc: verify PrepareSessionInner.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(DaemonExecuteTest, DaemonExecute_PrepareSessionInner_004, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_004 begin";
+
+    std::string srcUri;
+    std::string physicalPath;
+    std::string sessionName;
+    sptr<DaemonMock> daemon = new (std::nothrow) DaemonMock();
+    HmdfsInfo info;
+    info.authority = FILE_MANAGER_AUTHORITY;
+
+    // Test case 4: CreateSessionServer succeeds, authority is media or docs, but Copy fails
+    EXPECT_CALL(*softBusHandlerMock_, CreateSessionServer(_, _, _, _)).WillOnce(Return(1));
+    EXPECT_CALL(*daemon, RequestSendFile(_, _, _, _)).WillOnce(Return(E_OK));
+
+    EXPECT_EQ(daemonExecute_->PrepareSessionInner(srcUri, physicalPath, sessionName, daemon, info), E_OK);
+    GTEST_LOG_(INFO) << "DaemonExecute_PrepareSessionInner_004 end";
+}
+
+/**
+ * @tc.name: DaemonExecute_ExecutePrepareSession_001
+ * @tc.desc: Verify ExecutePrepareSession with null event does not throw
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(DaemonExecuteTest, DaemonExecute_ExecutePrepareSession_001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_001 begin";
+
+    // Test case 1: event is nullptr
+    AppExecFwk::InnerEvent::Pointer pointer2 = AppExecFwk::InnerEvent::Get(); // 获取空事件
+    EXPECT_NO_THROW(daemonExecute_->ExecutePrepareSession(pointer2));
+
+    GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_001 end";
+}
+
+/**
+ * @tc.name: DaemonExecute_ExecutePrepareSession_002
+ * @tc.desc: Verify ExecutePrepareSession with null prepareSessionData does not throw
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(DaemonExecuteTest, DaemonExecute_ExecutePrepareSession_002, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_002 begin";
+
+    // Test case 2: prepareSessionData is nullptr
+    std::shared_ptr<PrepareSessionData> prepareSessionData = nullptr;
+    auto event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_PREPARE_SESSION, prepareSessionData, 0);
+    EXPECT_NO_THROW(daemonExecute_->ExecutePrepareSession(event));
+
+    GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_002 end";
+}
+
+/**
+ * @tc.name: DaemonExecute_ExecutePrepareSession_003
+ * @tc.desc: Verify ExecutePrepareSession with null prepareSessionBlock does not throw
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(DaemonExecuteTest, DaemonExecute_ExecutePrepareSession_003, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_003 begin";
+
+    // Test case 3: prepareSessionBlock is nullptr
+    std::string srcUri = "";
+    std::string physicalPath = "";
+    std::string sessionName = "";
+    sptr<IDaemon> daemon = nullptr;
+    HmdfsInfo info;
+    std::shared_ptr<BlockObject<int32_t>> nullBlock = nullptr;
+
+    // // Initialize the PrepareSessionData
+    auto prepareSessionData =
+        std::make_shared<PrepareSessionData>(srcUri, physicalPath, sessionName, daemon, info, nullBlock);
+
+    // Initialize InnerEvent
+    auto event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_PREPARE_SESSION, prepareSessionData);
+
+    EXPECT_NO_THROW(daemonExecute_->ExecutePrepareSession(event));
+
+    GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_003 end";
+}
+
+/**
+ * @tc.name: DaemonExecute_ExecutePrepareSession_004
+ * @tc.desc: Verify ExecutePrepareSession with valid parameters
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(DaemonExecuteTest, DaemonExecute_ExecutePrepareSession_004, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_004 begin";
+
+    // Test case 4: All parameters are valid
+    auto prepareSessionBlock = std::make_shared<BlockObject<int32_t>>(BLOCK_INTERVAL_SEND_FILE, ERR_BAD_VALUE);
+    sptr<DaemonMock> daemon = new (std::nothrow) DaemonMock();
+    HmdfsInfo info;
+
+    // Initialize PrepareSessionData
+    auto prepareSessionData = std::make_shared<PrepareSessionData>("test_uri", "test_path", "test_session", daemon,
+                                                                   info, prepareSessionBlock);
+
+    auto event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_PREPARE_SESSION, prepareSessionData, 0);
+
+    // Mock PrepareSessionInner to return success
+    EXPECT_CALL(*softBusHandlerMock_, CreateSessionServer(_, _, _, _)).WillOnce(Return(1));
+    EXPECT_CALL(*daemon, RequestSendFile(_, _, _, _)).WillOnce(Return(E_OK));
+
+    EXPECT_NO_THROW(daemonExecute_->ExecutePrepareSession(event));
+    EXPECT_EQ(prepareSessionBlock->GetValue(), E_OK);
+
+    GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_004 end";
+}
+
+/**
+ * @tc.name: DaemonExecute_ExecutePrepareSession_005
+ * @tc.desc: Verify ExecutePrepareSession with PrepareSessionInner failure
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(DaemonExecuteTest, DaemonExecute_ExecutePrepareSession_005, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_005 begin";
+
+    // Test case 5: PrepareSessionInner returns failure
+    auto prepareSessionBlock = std::make_shared<BlockObject<int32_t>>(BLOCK_INTERVAL_SEND_FILE, ERR_BAD_VALUE);
+    sptr<DaemonMock> daemon = new (std::nothrow) DaemonMock();
+    HmdfsInfo info;
+
+    // Initialize PrepareSessionData
+    auto prepareSessionData = std::make_shared<PrepareSessionData>("test_uri", "test_path", "test_session", daemon,
+                                                                   info, prepareSessionBlock);
+
+    auto event = AppExecFwk::InnerEvent::Get(DEAMON_EXECUTE_PREPARE_SESSION, prepareSessionData, 0);
+
+    // Mock PrepareSessionInner to return failure
+    EXPECT_CALL(*softBusHandlerMock_, CreateSessionServer(_, _, _, _)).WillOnce(Return(-1));
+
+    EXPECT_NO_THROW(daemonExecute_->ExecutePrepareSession(event));
+    EXPECT_EQ(prepareSessionBlock->GetValue(), E_SOFTBUS_SESSION_FAILED);
+
+    GTEST_LOG_(INFO) << "DaemonExecute_ExecutePrepareSession_005 end";
+}
 } // namespace OHOS::Storage::DistributedFile::Test
\ No newline at end of file
diff --git a/test/unittests/distributed_file_inner/copy/trans_listener_test.cpp b/test/unittests/distributed_file_inner/copy/trans_listener_test.cpp
index 4cc735938197dbd9ee600c1738ac4e147a580c15..9d10d252a0ba5dd547b1c080182e934c354fde4f 100644
--- a/test/unittests/distributed_file_inner/copy/trans_listener_test.cpp
+++ b/test/unittests/distributed_file_inner/copy/trans_listener_test.cpp
@@ -1,21 +1,22 @@
 /*
-* Copyright (c) 2024 Huawei Device Co., Ltd.
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
+
+#include "dfs_error.h"
 #include <copy/file_copy_manager.h>
 #include <copy/trans_listener.h>
 #include <gtest/gtest.h>
-#include "dfs_error.h"
 
 namespace OHOS::Storage::DistributedFile::Test {
 using namespace OHOS::FileManagement;
@@ -30,8 +31,11 @@ public:
     void SetUp();
     void TearDown();
 
-    uint64_t process = 0;
-    uint64_t fileSize = 0;
+    // Variables to track file transfer progress
+    uint64_t process = 0;  // Bytes processed so far
+    uint64_t fileSize = 0; // Total file size
+
+    // Callback definition for progress updates
     using callBack = std::function<void(uint64_t processSize, uint64_t totalFileSize)>;
     callBack listener = [&](uint64_t processSize, uint64_t totalFileSize) {
         process = processSize;
@@ -52,6 +56,9 @@ void TransListenerTest::TearDownTestCase(void)
 void TransListenerTest::SetUp(void)
 {
     GTEST_LOG_(INFO) << "SetUp";
+    // Reset progress counters before each test
+    process = 0;
+    fileSize = 0;
 }
 
 void TransListenerTest::TearDown(void)
@@ -60,89 +67,350 @@ void TransListenerTest::TearDown(void)
 }
 
 /**
-* @tc.name: TransListener_0001
-* @tc.desc: The execution of the CopyTosandbox success.
-* @tc.type: FUNC
-* @tc.require: I7TDJK
+ * @tc.name: TransListener_0001
+ * @tc.desc: The execution of the CopyTosandbox success.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
  */
 HWTEST_F(TransListenerTest, TransListener_0001, TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "TransListener_0001 Start";
+
+    // Set up source and destination URIs with docs authority
     string srcuri = "file://docs/storage/media/100/local/files/Docs/aa/";
     string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
+
+    // Create TransListener instance with destination URI and callback
     auto ptr = std::make_shared<TransListener>(desturi, listener);
+
+    // Execute file copy operation and verify success
     int32_t ret = ptr->CopyToSandBox(srcuri);
-    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(ret, E_OK); // Expect operation to succeed
+
     GTEST_LOG_(INFO) << "TransListener_0001 End";
 }
 
 /**
-* @tc.name: TransListener_0002
-* @tc.desc: The execution of the Cancel success.
-* @tc.type: FUNC
-* @tc.require: I7TDJK
+ * @tc.name: TransListener_0002
+ * @tc.desc: The execution of the Cancel success.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
  */
 HWTEST_F(TransListenerTest, TransListener_0002, TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "TransListener_0002 Start";
+
+    // Set up test URIs
     string srcuri = "file://docs/storage/media/100/local/files/Docs/aa/";
     string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
+
+    // Create TransListener instance
     auto ptr = std::make_shared<TransListener>(desturi, listener);
+
+    // Attempt to cancel operation and verify expected failure
+    // (Expecting failure because test environment lacks real proxy)
     int32_t ret = ptr->Cancel();
     EXPECT_EQ(ret, E_SA_LOAD_FAILED);
+
     GTEST_LOG_(INFO) << "TransListener_0002 End";
 }
 
 /**
-* @tc.name: TransListener_0003
-* @tc.desc: The execution of the OnFileReceive success.
-* @tc.type: FUNC
-* @tc.require: I7TDJK
+ * @tc.name: TransListener_0003
+ * @tc.desc: The execution of the OnFileReceive success.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
  */
 HWTEST_F(TransListenerTest, TransListener_0003, TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "TransListener_0003 Start";
+
+    // Set up test URIs
     string srcuri = "file://docs/storage/media/100/local/files/Docs/aa/";
     string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
+
+    // Create TransListener instance
     auto ptr = std::make_shared<TransListener>(desturi, listener);
+
+    // Test file receive callback with current progress values
     int32_t ret = ptr->OnFileReceive(process, fileSize);
-    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(ret, E_OK); // Expect callback to succeed
+
     GTEST_LOG_(INFO) << "TransListener_0003 End";
 }
 
 /**
-* @tc.name: TransListener_0004
-* @tc.desc: The execution of the OnFinished success.
-* @tc.type: FUNC
-* @tc.require: I7TDJK
+ * @tc.name: TransListener_0004
+ * @tc.desc: The execution of the OnFinished success.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
  */
 HWTEST_F(TransListenerTest, TransListener_0004, TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "TransListener_0004 Start";
+
+    // Set up test parameters
     string sessionName = "test";
     string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
+
+    // Create TransListener instance
     auto ptr = std::make_shared<TransListener>(desturi, listener);
+
+    // Simulate successful operation completion
     int32_t ret = ptr->OnFinished(sessionName);
-    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(ret, E_OK); // Expect completion handler to succeed
+
     GTEST_LOG_(INFO) << "TransListener_0004 End";
 }
 
 /**
-* @tc.name: TransListener_0005
-* @tc.desc: The execution of the OnFailed success.
-* @tc.type: FUNC
-* @tc.require: I7TDJK
+ * @tc.name: TransListener_0005
+ * @tc.desc: The execution of the OnFailed success.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
  */
 HWTEST_F(TransListenerTest, TransListener_0005, TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "TransListener_0005 Start";
+
+    // Set up test parameters
     string sessionName = "test";
-    int32_t errorCode = 0;
+    int32_t errorCode = 0; // Using 0 as generic error code for testing
     string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
+
+    // Create TransListener instance
     auto ptr = std::make_shared<TransListener>(desturi, listener);
+
+    // Simulate operation failure
     int32_t ret = ptr->OnFailed(sessionName, errorCode);
-    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(ret, E_OK); // Expect failure handler to succeed
+
     GTEST_LOG_(INFO) << "TransListener_0005 End";
 }
 
-}
\ No newline at end of file
+/**
+ * @tc.name: TransListener_0006
+ * @tc.desc: Test CreateTmpDir with docs authority.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(TransListenerTest, TransListener_0006, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListener_0006 Start";
+
+    // Set up destination URI with docs authority
+    string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
+
+    // Create TransListener instance
+    auto ptr = std::make_shared<TransListener>(desturi, listener);
+
+    // Test temporary directory creation (should skip actual creation for docs)
+    int32_t ret = ptr->CreateTmpDir();
+    EXPECT_EQ(ret, E_OK); // Expect success even though no dir is created
+
+    GTEST_LOG_(INFO) << "TransListener_0006 End";
+}
+
+/**
+ * @tc.name: TransListener_0007
+ * @tc.desc: Test CreateTmpDir with media authority.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(TransListenerTest, TransListener_0007, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListener_0007 Start";
+
+    // Set up destination URI with media authority
+    string desturi = "file://media/storage/media/100/local/files/Media/aa1/";
+
+    // Create TransListener instance
+    auto ptr = std::make_shared<TransListener>(desturi, listener);
+
+    // Test temporary directory creation (should skip actual creation for media)
+    int32_t ret = ptr->CreateTmpDir();
+    EXPECT_EQ(ret, E_OK); // Expect success even though no dir is created
+
+    GTEST_LOG_(INFO) << "TransListener_0007 End";
+}
+
+/**
+ * @tc.name: TransListener_0008
+ * @tc.desc: Test CreateTmpDir with invalid path.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(TransListenerTest, TransListener_0008, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListener_0008 Start";
+
+    // Set up destination URI with invalid authority
+    string desturi = "file://invalid/storage/media/100/local/files/Invalid/aa1/";
+
+    // Create TransListener instance
+    auto ptr = std::make_shared<TransListener>(desturi, listener);
+
+    // Test temporary directory creation with invalid path
+    int32_t ret = ptr->CreateTmpDir();
+    EXPECT_NE(ret, E_OK); // Expect failure due to invalid authority
+
+    GTEST_LOG_(INFO) << "TransListener_0008 End";
+}
+
+/**
+ * @tc.name: TransListener_0009
+ * @tc.desc: Test WaitForCopyResult with success result.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(TransListenerTest, TransListener_0009, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListener_0009 Start";
+
+    // Set up destination URI
+    string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
+    auto ptr = std::make_shared<TransListener>(desturi, listener);
+
+    // Simulate successful completion in separate thread
+    std::thread t([ptr]() {
+        ptr->OnFinished("test_session"); // Trigger success callback
+    });
+
+    // Wait for operation result and verify success
+    int32_t ret = ptr->WaitForCopyResult();
+    t.join();                // Ensure thread completes
+    EXPECT_EQ(ret, SUCCESS); // Expect success status
+
+    GTEST_LOG_(INFO) << "TransListener_0009 End";
+}
+
+/**
+ * @tc.name: TransListener_0010
+ * @tc.desc: Test WaitForCopyResult with failed result.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(TransListenerTest, TransListener_0010, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListener_0010 Start";
+
+    // Set up destination URI
+    string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
+    auto ptr = std::make_shared<TransListener>(desturi, listener);
+
+    // Simulate failure in separate thread
+    std::thread t([ptr]() {
+        ptr->OnFailed("test_session", EIO); // Trigger failure callback
+    });
+
+    // Wait for operation result and verify failure
+    int32_t ret = ptr->WaitForCopyResult();
+    t.join();               // Ensure thread completes
+    EXPECT_EQ(ret, FAILED); // Expect failure status
+
+    GTEST_LOG_(INFO) << "TransListener_0010 End";
+}
+
+/**
+ * @tc.name: TransListener_0011
+ * @tc.desc: Test GetFileName with valid path.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(TransListenerTest, TransListener_0011, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListener_0011 Start";
+
+    // Set up destination URI
+    string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
+    auto ptr = std::make_shared<TransListener>(desturi, listener);
+
+    // Test filename extraction from valid path
+    string filename = ptr->GetFileName("/path/to/file.txt");
+    EXPECT_FALSE(filename.empty()); // Expect non-empty filename
+
+    GTEST_LOG_(INFO) << "TransListener_0011 End";
+}
+
+/**
+ * @tc.name: TransListener_0012
+ * @tc.desc: Test GetFileName with invalid path.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(TransListenerTest, TransListener_0012, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListener_0012 Start";
+
+    // Set up destination URI
+    string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
+    auto ptr = std::make_shared<TransListener>(desturi, listener);
+
+    // Test filename extraction from invalid path
+    string filename = ptr->GetFileName("invalidpath");
+    EXPECT_TRUE(filename.empty()); // Expect empty result for invalid path
+
+    GTEST_LOG_(INFO) << "TransListener_0012 End";
+}
+
+/**
+ * @tc.name: TransListener_0013
+ * @tc.desc: Test GetNetworkIdFromUri with network parameter.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(TransListenerTest, TransListener_0013, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListener_0013 Start";
+
+    // Set up URI with network ID parameter
+    string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/?networkid=12345";
+    auto ptr = std::make_shared<TransListener>(desturi, listener);
+
+    // Test network ID extraction
+    string networkId = ptr->GetNetworkIdFromUri(desturi);
+    EXPECT_EQ(networkId, "12345"); // Expect correct network ID extraction
+
+    GTEST_LOG_(INFO) << "TransListener_0013 End";
+}
+
+/**
+ * @tc.name: TransListener_0014
+ * @tc.desc: Test RmTmpDir with docs authority.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(TransListenerTest, TransListener_0014, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListener_0014 Start";
+
+    // Set up destination URI with docs authority
+    string desturi = "file://docs/storage/media/100/local/files/Docs/aa1/";
+    auto ptr = std::make_shared<TransListener>(desturi, listener);
+
+    // Test temporary directory removal (should skip for docs)
+    EXPECT_NO_THROW(ptr->RmTmpDir()); // Expect no exception
+
+    GTEST_LOG_(INFO) << "TransListener_0014 End";
+}
+
+/**
+ * @tc.name: TransListener_0015
+ * @tc.desc: Test RmTmpDir with non-docs authority.
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(TransListenerTest, TransListener_0015, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TransListener_0015 Start";
+
+    // Set up destination URI with non-docs authority
+    string desturi = "file://other/storage/media/100/local/files/Other/aa1/";
+    auto ptr = std::make_shared<TransListener>(desturi, listener);
+
+    // Test temporary directory removal
+    EXPECT_NO_THROW(ptr->RmTmpDir()); // Expect no exception
+
+    GTEST_LOG_(INFO) << "TransListener_0015 End";
+}
+} // namespace OHOS::Storage::DistributedFile::Test
\ No newline at end of file