diff --git a/tests/unittest/event_bean/event_bean_inner_unit_test.cpp b/tests/unittest/event_bean/event_bean_inner_unit_test.cpp
index 34136484fa493085f7815bddecfae0b825581af9..1c1cb2f711f4c032691dc27739b12ee6f53395b0 100644
--- a/tests/unittest/event_bean/event_bean_inner_unit_test.cpp
+++ b/tests/unittest/event_bean/event_bean_inner_unit_test.cpp
@@ -15,6 +15,8 @@
 
 #include <gtest/gtest.h>
 #include "event_bean.h"
+#include "iremote_proxy.h"
+#include "parcel.h"
 
 using namespace std;
 using namespace testing::ext;
@@ -36,6 +38,13 @@ public:
     std::shared_ptr<MediaMonitor::EventBean> eventBean_;
     const std::string strKey = "invalidKey";
     std::string strValue = "invalidValue";
+    int32_t int32Value_ = -1;
+    uint64_t uint64Value_ = -1;
+    float floatValue_ = -1.0f;
+    std::map<std::string, std::int32_t> int32Map_;
+    std::map<std::string, std::string> stringMap_;
+    std::map<std::string, uint64_t> uint64Map_;
+    std::map<std::string, float> floatMap_;
 };
 
 void EventBeanInnerUnitTest::SetUpTestCase(void) {}
@@ -135,6 +144,84 @@ HWTEST_F(EventBeanInnerUnitTest, UpdateFloatMap_001, TestSize.Level1)
     eventBean_->UpdateFloatMap(strKey, 1);
     EXPECT_EQ(0, eventBean_->GetFloatValue(strKey));
 }
+
+
+/**
+ * @tc.name: GetIntMap_001
+ * @tc.desc: Test GetIntMap interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(EventBeanInnerUnitTest, GetIntMap_001, TestSize.Level1)
+{
+    eventBean_->Add(strKey, int32Value_);
+    int32Map_ = eventBean_->GetIntMap();
+    EXPECT_EQ(int32Value_, int32Map_[strKey]);
+    int32Map_.clear();
+}
+
+/**
+ * @tc.name: GetStringMap_001
+ * @tc.desc: Test GetStringMap interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(EventBeanInnerUnitTest, GetStringMap_001, TestSize.Level1)
+{
+    eventBean_->Add(strKey, strValue);
+    stringMap_ = eventBean_->GetStringMap();
+    EXPECT_EQ(strValue, stringMap_[strKey]);
+    stringMap_.clear();
+}
+
+/**
+ * @tc.name: GetUint64Map_001
+ * @tc.desc: Test GetUint64Map interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(EventBeanInnerUnitTest, GetUint64Map_001, TestSize.Level1)
+{
+    eventBean_->Add(strKey, uint64Value_);
+    uint64Map_ = eventBean_->GetUint64Map();
+    EXPECT_EQ(uint64Value_, uint64Map_[strKey]);
+    uint64Map_.clear();
+}
+
+/**
+ * @tc.name: GetFloatMap_001
+ * @tc.desc: Test GetFloatMap interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(EventBeanInnerUnitTest, GetFloatMap_001, TestSize.Level1)
+{
+    eventBean_->Add(strKey, floatValue_);
+    floatMap_ = eventBean_->GetFloatMap();
+    EXPECT_EQ(floatValue_, floatMap_[strKey]);
+    floatMap_.clear();
+}
+
+/**
+ * @tc.name: ReadFromParcel_001
+ * @tc.desc: Test ReadFromParcel interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(EventBeanInnerUnitTest, ReadFromParcel_001, TestSize.Level1)
+{
+    MessageParcel parcel;
+    eventBean_->ReadFromParcel(parcel);
+    EXPECT_NE(nullptr, eventBean_);
+}
+
+/**
+ * @tc.name: Unmarshalling_001
+ * @tc.desc: Test Unmarshalling interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(EventBeanInnerUnitTest, Unmarshalling_001, TestSize.Level1)
+{
+    Parcel data;
+    MediaMonitor::EventBean *eventBean = eventBean_->Unmarshalling(data);
+    EXPECT_NE(nullptr, eventBean);
+    delete eventBean;
+}
 } // namespace EventBeanUT
 } // namespace Media
 } // namespace OHOS
diff --git a/tests/unittest/filter/filter_unit_test.cpp b/tests/unittest/filter/filter_unit_test.cpp
index 83214585534f34c46f3900817332e3b7cdf16f49..839713c6a6ae4c14f54548f2752800cd47190e01 100644
--- a/tests/unittest/filter/filter_unit_test.cpp
+++ b/tests/unittest/filter/filter_unit_test.cpp
@@ -37,6 +37,56 @@ public:
     const int32_t sleepTime_ = 1;
 };
 
+class FilterLinkCallbackTest : public FilterLinkCallback {
+public:
+    FilterLinkCallbackTest() = default;
+
+    ~FilterLinkCallbackTest() = default;
+
+    void OnLinkedResult(const sptr<AVBufferQueueProducer>& queue, std::shared_ptr<Meta>& meta) override
+    {
+        (void)queue;
+        (void)meta;
+    }
+
+    void OnUnlinkedResult(std::shared_ptr<Meta>& meta) override
+    {
+        (void)meta;
+    }
+
+    void OnUpdatedResult(std::shared_ptr<Meta>& meta) override
+    {
+        (void)meta;
+    }
+};
+
+class FilterCallbackTest : public FilterCallback {
+public:
+    FilterCallbackTest() = default;
+
+    ~FilterCallbackTest() = default;
+
+    Status OnCallback(const std::shared_ptr<Filter>& filter, FilterCallBackCommand cmd, StreamType outType) override
+    {
+        (void)filter;
+        (void)cmd;
+        (void)outType;
+        return Status::OK;
+    }
+};
+
+class EventReceiverTest : public EventReceiver {
+public:
+    EventReceiverTest() = default;
+
+    ~EventReceiverTest() = default;
+
+    void OnEvent(const Event& event) override
+    {
+        (void)event;
+    }
+};
+
 void FilterUnitTest::SetUpTestCase(void) {}
 
 void FilterUnitTest::TearDownTestCase(void) {}
@@ -433,6 +483,202 @@ HWTEST_F(FilterUnitTest, ReInitAndStart_002, TestSize.Level1)
     EXPECT_EQ(Status::OK, filter->ReInitAndStart());
     sleep(sleepTime_);
 }
+
+/**
+ * @tc.name: SetPlayRange_001
+ * @tc.desc: Test SetPlayRange interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, SetPlayRange_001, TestSize.Level1)
+{
+    std::shared_ptr<Filter> filter = std::make_shared<Filter>("testFilter", FilterType::FILTERTYPE_VENC, true);
+    EXPECT_EQ(Status::OK, filter->SetPlayRange(0, 0));
+}
+
+/**
+ * @tc.name: DoSetPlayRange_001
+ * @tc.desc: Test DoSetPlayRange interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, DoSetPlayRange_001, TestSize.Level1)
+{
+    std::shared_ptr<Filter> filter = std::make_shared<Filter>("testFilter", FilterType::FILTERTYPE_VENC, true);
+    EXPECT_EQ(Status::OK, filter->DoSetPlayRange(0, 0));
+}
+
+/**
+ * @tc.name: Flush_001
+ * @tc.desc: Test Flush interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, Flush_001, TestSize.Level1)
+{
+    std::shared_ptr<Filter> filter = std::make_shared<Filter>("testFilter", FilterType::FILTERTYPE_VENC, true);
+    EXPECT_EQ(Status::OK, filter->Flush());
+}
+
+/**
+ * @tc.name: DoFlush_001
+ * @tc.desc: Test DoFlush interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, DoFlush_001, TestSize.Level1)
+{
+    std::shared_ptr<Filter> filter = std::make_shared<Filter>("testFilter", FilterType::FILTERTYPE_VENC, true);
+    EXPECT_EQ(Status::OK, filter->DoFlush());
+}
+
+/**
+ * @tc.name: HandleFormatChange_001
+ * @tc.desc: Test HandleFormatChange interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, HandleFormatChange_001, TestSize.Level1)
+{
+    std::shared_ptr<Filter> filter = std::make_shared<Filter>("testFilter", FilterType::FILTERTYPE_VENC, true);
+    std::shared_ptr<Meta> meta = std::make_shared<Meta>();
+    EXPECT_EQ(Status::OK, filter->HandleFormatChange(meta));
+}
+
+/**
+ * @tc.name: DoSetPerfRecEnabled_001
+ * @tc.desc: Test DoSetPerfRecEnabled interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, DoSetPerfRecEnabled_001, TestSize.Level1)
+{
+    std::shared_ptr<Filter> filter = std::make_shared<Filter>("testFilter", FilterType::FILTERTYPE_VENC, true);
+    EXPECT_EQ(Status::OK, filter->DoSetPerfRecEnabled(true));
+}
+
+/**
+ * @tc.name: DoProcessInputBuffer_001
+ * @tc.desc: Test DoProcessInputBuffer interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, DoProcessInputBuffer_001, TestSize.Level1)
+{
+    std::shared_ptr<Filter> filter = std::make_shared<Filter>("testFilter", FilterType::FILTERTYPE_VENC, true);
+    EXPECT_EQ(Status::OK, filter->DoProcessInputBuffer(0, true));
+}
+
+/**
+ * @tc.name: SetParameter_001
+ * @tc.desc: Test SetParameter interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, SetParameter_001, TestSize.Level1)
+{
+    std::shared_ptr<Filter> filter = std::make_shared<Filter>("testFilter", FilterType::FILTERTYPE_VENC, true);
+    std::shared_ptr<Meta> inMeta = std::make_shared<Meta>();
+    std::shared_ptr<Meta> outMeta = std::make_shared<Meta>();
+    filter->SetParameter(inMeta);
+    filter->GetParameter(outMeta);
+    EXPECT_EQ(inMeta, outMeta);
+}
+
+/**
+ * @tc.name: GetParameter_001
+ * @tc.desc: Test GetParameter interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, GetParameter_001, TestSize.Level1)
+{
+    std::shared_ptr<Filter> filter = std::make_shared<Filter>("testFilter", FilterType::FILTERTYPE_VENC, true);
+    std::shared_ptr<Meta> inMeta = std::make_shared<Meta>();
+    std::shared_ptr<Meta> outMeta = std::make_shared<Meta>();
+    filter->SetParameter(inMeta);
+    filter->GetParameter(outMeta);
+    EXPECT_EQ(inMeta, outMeta);
+}
+
+/**
+ * @tc.name: OnUpdated_001
+ * @tc.desc: Test OnUpdated interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, OnUpdated_001, TestSize.Level1)
+{
+    std::shared_ptr<Filter> filter = std::make_shared<Filter>("testFilter", FilterType::FILTERTYPE_VENC, true);
+    StreamType streamType = StreamType::STREAMTYPE_PACKED;
+    std::shared_ptr<Meta> meta = std::make_shared<Meta>();
+    std::shared_ptr<FilterLinkCallback> cb = std::make_shared<FilterLinkCallbackTest>();
+    EXPECT_EQ(Status::OK, filter->OnUpdated(streamType, meta, cb));
+}
+
+/**
+ * @tc.name: OnUnLinked_001
+ * @tc.desc: Test OnUnLinked interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, OnUnLinked_001, TestSize.Level1)
+{
+    std::shared_ptr<Filter> filter = std::make_shared<Filter>("testFilter", FilterType::FILTERTYPE_VENC, true);
+    StreamType streamType = StreamType::STREAMTYPE_PACKED;
+    std::shared_ptr<FilterLinkCallback> cb = std::make_shared<FilterLinkCallbackTest>();
+    EXPECT_EQ(Status::OK, filter->OnUnLinked(streamType, cb));
+}
+
+/**
+ * @tc.name: SetMuted_001
+ * @tc.desc: Test SetMuted interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, SetMuted_001, TestSize.Level1)
+{
+    std::shared_ptr<Filter> filter = std::make_shared<Filter>("testFilter", FilterType::FILTERTYPE_VENC, true);
+    EXPECT_EQ(Status::OK, filter->SetMuted(true));
+}
+
+/**
+ * @tc.name: NotifyRelease_001
+ * @tc.desc: Test NotifyRelease interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, NotifyRelease_001, TestSize.Level1)
+{
+    std::shared_ptr<FilterCallback> filterCb = std::make_shared<FilterCallbackTest>();
+    filterCb->NotifyRelease();
+    EXPECT_NE(nullptr, filterCb);
+}
+
+/**
+ * @tc.name: OnDfxEvent_001
+ * @tc.desc: Test OnDfxEvent interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, OnDfxEvent_001, TestSize.Level1)
+{
+    std::shared_ptr<EventReceiver> eventReceiver = std::make_shared<EventReceiverTest>();
+    DfxEvent event;
+    eventReceiver->OnDfxEvent(event);
+    EXPECT_NE(nullptr, eventReceiver);
+}
+
+/**
+ * @tc.name: NotifyRelease_002
+ * @tc.desc: Test NotifyRelease interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, NotifyRelease_002, TestSize.Level1)
+{
+    std::shared_ptr<EventReceiver> eventReceiver = std::make_shared<EventReceiverTest>();
+    eventReceiver->NotifyRelease();
+    EXPECT_NE(nullptr, eventReceiver);
+}
+
+/**
+ * @tc.name: OnMemoryUsageEvent_001
+ * @tc.desc: Test OnMemoryUsageEvent interface
+ * @tc.type: FUNC
+ */
+HWTEST_F(FilterUnitTest, OnMemoryUsageEvent_001, TestSize.Level1)
+{
+    std::shared_ptr<EventReceiver> eventReceiver = std::make_shared<EventReceiverTest>();
+    DfxEvent event;
+    eventReceiver->OnMemoryUsageEvent(event);
+    EXPECT_NE(nullptr, eventReceiver);
+}
 } // namespace FilterUnitTest
 } // namespace Media
 } // namespace OHOS
\ No newline at end of file