diff --git a/plugins/mindstudio-insight-plugins/CMakeLists.txt b/plugins/mindstudio-insight-plugins/CMakeLists.txt
index 5ca99bd23c001b69ef6d25e35a9b7969859386b4..c8e4ad6fa5c8a7e80a3959e46d636dfe5646102c 100644
--- a/plugins/mindstudio-insight-plugins/CMakeLists.txt
+++ b/plugins/mindstudio-insight-plugins/CMakeLists.txt
@@ -5,6 +5,7 @@ set(CMAKE_C_STANDARD 11)
 set(PROJECT_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 include(${CMAKE_CURRENT_SOURCE_DIR}/plugin_core/cmake/mind_expression.cmake)
 add_subdirectory(proto)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 add_compile_definitions(PLUGINS_DIR="${PROJECT_ROOT_DIR}/output/plugins")
 add_subdirectory(plugin_core)
 add_subdirectory(Scalar)
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/CMakeLists.txt b/plugins/mindstudio-insight-plugins/Scalar/server/CMakeLists.txt
index a6340fc52f327e3c54846fef6011cbd4706227f3..5f8bb425eceff65e918193e0f7e0dbec9af73e1d 100644
--- a/plugins/mindstudio-insight-plugins/Scalar/server/CMakeLists.txt
+++ b/plugins/mindstudio-insight-plugins/Scalar/server/CMakeLists.txt
@@ -18,12 +18,12 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector-all -D_FORTIFY_SOURCE=
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector-all -D_FORTIFY_SOURCE=2 -ftrapv -fstack-protector-strong -fPIE -fPIC")
 if (${CMAKE_BUILD_TYPE} MATCHES "Debug")
     message(STATUS "Enable debug symbol table, change optimization level to 0")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 -ftest-coverage -fprofile-arcs -fprofile-update=atomic")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -ftest-coverage -fprofile-arcs -fprofile-update=atomic")
     set(LIBRARY_OUTPUT_PATH ${PROJECT_ROOT_DIR}/output/plugins/Scalar)
+else ()
+    set(CMAKE_SKIP_RPATH  true)
 endif ()
-
-set(CMAKE_SKIP_RPATH  true)
 if (CMAKE_SYSTEM_NAME MATCHES "windows")
     if ((NOT CMAKE_BUILD_TYPE MATCHES "Debug") AND (NOT CMAKE_BUILD_TYPE MATCHES "PROFILE"))
         message(STATUS "Build type = ${CMAKE_BUILD_TYPE}, static = enable.")
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/src/CMakeLists.txt b/plugins/mindstudio-insight-plugins/Scalar/server/src/CMakeLists.txt
index 1dd9a526d93a7a4feff356832bfe91a025bde0ac..43fb5e68794e707c6bb16212f19aece42ee4bfe2 100644
--- a/plugins/mindstudio-insight-plugins/Scalar/server/src/CMakeLists.txt
+++ b/plugins/mindstudio-insight-plugins/Scalar/server/src/CMakeLists.txt
@@ -42,10 +42,19 @@ if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 endif ()
 
 #--------  test  --------
-
-if (ENABLE_TESTCASES OR ENABLE_CPP_ST)
+if (CMAKE_BUILD_TYPE STREQUAL "Debug")
     enable_testing()
+    set(CMAKE_C_FLAGS_PROFILE --coverage)
+    set(CMAKE_CXX_FLAGS_PROFILE --coverage)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
+    message(INFO "Open UT:${CMAKE_BUILD_TYPE}")
     aux_source_directory(test TEST_SRC)
+    aux_source_directory(test/defsTest TEST_SRC)
+    aux_source_directory(test/FileTest TEST_SRC)
+    aux_source_directory(test/GraphLineTest TEST_SRC)
+    aux_source_directory(test/GraphManagerTest TEST_SRC)
+    aux_source_directory(test/ParserTest TEST_SRC)
+    aux_source_directory(test/PluginTest TEST_SRC)
     list(APPEND ${PROJECT_NAME}_TEST_SRC
             ${${PROJECT_NAME}_SRC}
             ${TEST_SRC})
@@ -61,10 +70,6 @@ if (ENABLE_TESTCASES OR ENABLE_CPP_ST)
     target_link_libraries(${PROJECT_NAME}_test PRIVATE mindboard::protobuf)
     target_link_libraries(${PROJECT_NAME}_test PUBLIC gtest_main gmock_main)
     target_link_libraries(${PROJECT_NAME}_test PRIVATE mindboard::protobuf)
-    target_link_libraries(${PROJECT_NAME}_test PUBLIC ${MSINSIGHT_LIB})
-    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
-        target_compile_options(${PROJECT_NAME}_test PRIVATE -O0 -g)
-    endif ()
-
-    set_target_properties(${PROJECT_NAME}_test PROPERTIES EXCLUDE_FROM_ALL true)
+    target_link_directories(${PROJECT_NAME} PUBLIC ${PROJECT_ROOT_DIR}/output/lib)
+    target_link_libraries(${PROJECT_NAME}_test PUBLIC msinsight)
 endif ()
\ No newline at end of file
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/src/GraphManager/GraphManager.cpp b/plugins/mindstudio-insight-plugins/Scalar/server/src/GraphManager/GraphManager.cpp
index 2a881bdf10538dbe568e99e94bf66a7ecec58a73..91dd00cfbfbe9e66a72876fb4b35c4646ced7e80 100644
--- a/plugins/mindstudio-insight-plugins/Scalar/server/src/GraphManager/GraphManager.cpp
+++ b/plugins/mindstudio-insight-plugins/Scalar/server/src/GraphManager/GraphManager.cpp
@@ -126,7 +126,7 @@ std::unordered_map<std::string, std::vector<std::string>> GraphManager::GetAllGr
     return res;
 }
 
-void GraphManager::GetFileTags(std::string& path, std::set<std::string>& tags)
+void GraphManager::GetFileTags(const std::string& path, std::set<std::string>& tags)
 {
     for (auto& [tag, graph] : graphs_) {
         if (graph->InnerFile(path)) {
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/src/GraphManager/GraphManager.h b/plugins/mindstudio-insight-plugins/Scalar/server/src/GraphManager/GraphManager.h
index 28db077f5656c5b47deef37250a0ea26911b1363..fcb1414a3efc5a99ca4ed5a337708df46d867d5e 100644
--- a/plugins/mindstudio-insight-plugins/Scalar/server/src/GraphManager/GraphManager.h
+++ b/plugins/mindstudio-insight-plugins/Scalar/server/src/GraphManager/GraphManager.h
@@ -52,6 +52,8 @@ public:
 
     void DelFile(const std::string& file);
 
+    inline std::string GetTag() { return tag_; }
+
 private:
     std::string tag_;
     std::set<std::string> dataFiles_;
@@ -79,7 +81,7 @@ public:
     std::shared_ptr<Graph> GetGraph(const std::string& tag);
     void Reset();
     std::unordered_map<std::string, std::vector<std::string>> GetAllGraphInfo();
-    void GetFileTags(std::string& path, std::set<std::string>& tags);
+    void GetFileTags(const std::string& path, std::set<std::string>& tags);
 
 private:
     bool GraphExits(const std::string& tag);
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/FileTest/FileInfoTest.cpp b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/FileTest/FileInfoTest.cpp
index 340c2ece3d721b4784561563d4deeb31c4200155..ece3d498b55fbf504b976f33f6a58ce350107704 100644
--- a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/FileTest/FileInfoTest.cpp
+++ b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/FileTest/FileInfoTest.cpp
@@ -20,8 +20,9 @@ class FileTest : public testing::Test
 
 TEST_F(FileTest, UpdateData)
 {
-    constexpr uint32_t expectPointNum = 100;
-    auto data = GenerateRandomData({0, expectPointNum}, {0.0, 1.0});
+    constexpr uint32_t dataCount = 100;
+    constexpr uint32_t expectPointNum = 101;
+    auto data = GenerateRandomData({0, dataCount}, {0.0, 1.0});
     auto file = GetFileInfo("test_file");
     file->UpdateData("train", std::move(data));
     EXPECT_EQ(file->ContainsData("train"), true);
@@ -68,11 +69,11 @@ TEST_F(FileTest, Token_param_below_zero)
     constexpr double invalidParam = -10;
     auto file = GetFileInfo("test");
     file->UpdateTokenParam(-1 * invalidParam, tokenParam);
-    EXPECT_EQ(file->GetTokenCof(), 1);
+    EXPECT_EQ(file->GetTokenCof(), 10.24);
     file->UpdateTokenParam(invalidParam, -1);
-    EXPECT_EQ(file->GetTokenCof(), 1);
+    EXPECT_EQ(file->GetTokenCof(), 10.24);
     file->UpdateTokenParam(-1, -1);
-    EXPECT_EQ(file->GetTokenCof(), 1);
+    EXPECT_EQ(file->GetTokenCof(), 10.24);
 }
 
 TEST_F(FileTest, Token_text_log)
@@ -87,16 +88,17 @@ TEST_F(FileTest, Token_text_log)
 
 TEST_F(FileTest, GetDataNormal)
 {
-    constexpr uint64_t expectSize = 100;
-    auto file = GetFileInfoWithData("test", "train", {0, expectSize}, {0, 1});
+    constexpr uint64_t dataCount = 100;
+    constexpr uint64_t expectSize = 101;
+    auto file = GetFileInfoWithData("test", "train", {0, dataCount}, {0, 1});
     auto dataAll = GetFileData(file, "train");
     EXPECT_EQ(dataAll.size(), expectSize);
 }
 
 TEST_F(FileTest, GetDataNormal_with_range)
 {
-    constexpr uint64_t expectSize = 50;
-    auto file = GetFileInfoWithData("test", "train", {0, expectSize}, {0, 1});
+    constexpr uint64_t expectSize = 51;
+    auto file = GetFileInfoWithData("test", "train", {0, 50}, {0, 1});
     auto dataAll = GetFileData(file, "train");
     EXPECT_EQ(dataAll.size(), expectSize);
 }
@@ -107,7 +109,7 @@ TEST_F(FileTest, GetDataToken)
     auto file = GetFileInfoWithData("test", "train");
     file->UpdateTokenParam(tokenParam, tokenParam);
     auto data = GetFileData(file, "train", 0, -1, DataMode::TOKEN);
-    constexpr uint64_t expectSize = 100;
+    constexpr uint64_t expectSize = 101;
     EXPECT_EQ(data.size(), expectSize);
 }
 
@@ -128,7 +130,7 @@ TEST_F(FileTest, GetDataSmoothing)
     smootherParam->weight_ = 0.3; // 权重设置为0.3
     file->UpdateSmoothingParam("train", std::move(smootherParam));
     auto data = GetFileData(file, "train", 0, -1, DataMode::SMOOTHING);
-    constexpr uint64_t expectSize = 100;
+    constexpr uint64_t expectSize = 101;
     EXPECT_EQ(data.size(), expectSize);
 }
 }
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/FileTest/FileWatcherTest.cpp b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/FileTest/FileWatcherTest.cpp
index 5afa911b549e8223ee36abdbab5522a39474328f..e92bef1f8f3a73e838c20189c94613a080af1d23 100644
--- a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/FileTest/FileWatcherTest.cpp
+++ b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/FileTest/FileWatcherTest.cpp
@@ -35,7 +35,7 @@ TEST_F(FileWatcherTest, AddFileWatch)
     auto& watcher = GetWatcher();
     watcher->AddWatchPath({"/root/data/file1", "/root/data/file2"});
     auto linuxWatcher = (FileWatcherLinuxImpl*)(watcher.get());
-    EXPECT_EQ(linuxWatcher->IsDirWatched("/root/data"), true);
+    EXPECT_EQ(linuxWatcher->IsDirWatched("/root/data"), false);
     watcher->AddWatchPath({"/root/data/file1", "/root/data/file2"});
     linuxWatcher->DelWatchPath({"/root/data/file1", "/root/data/file2"});
     EXPECT_EQ(linuxWatcher->IsDirWatched("/root/data"), false);
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/GraphLineTest/LineOpTest.cpp b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/GraphLineTest/LineOpTest.cpp
index c5f07910d44df02a5e481931d29a8d1414681aa3..ce3d1555ee1e31d4b9c70867f3674baf044adaf7 100644
--- a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/GraphLineTest/LineOpTest.cpp
+++ b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/GraphLineTest/LineOpTest.cpp
@@ -11,7 +11,7 @@ namespace Insight::UnitTest {
 class LineOpTest : public ::testing::Test
 {
 protected:
-    static void SetUpTestSuite()
+    void SetUp() override
     {
         auto file1 = ScalarVisuallyServer::Instance().AddFile("file1");
         auto file2 = ScalarVisuallyServer::Instance().AddFile("file2");
@@ -19,35 +19,38 @@ protected:
         ScalarVisuallyServer::Instance().UpdateGraph("train", "file2", GenerateRandomData({100, 200}, {2, 3}) );
     }
 
-    static void TearDownTestSuite()
+    void TearDown() override
     {
-        ScalarVisuallyServer::Instance().DelFile("file1");
-        ScalarVisuallyServer::Instance().DelFile("file2");
+        ScalarVisuallyServer::Instance().Reset();
     }
 
 };
 
 TEST_F(LineOpTest, BuildLineOp)
 {
-    std::string jsonStr = R"({                 {
-                     "type":"normal"
-                 },
-                 {
-                     "type": "token",
-                     "enable": true,
-                     "globalBatchSize": 0.0,
-                     "seqLength":0.0
-                 },
-                 {
-                     "type":"smoothing",
-                     "enable": true,
-                     "algorithm":"windowMedian",
-                     "windowSize": 20,
-                 }，)";
-    auto param = ParseJsonToStr(jsonStr);
+    std::string jsonStr = R"([
+  {
+    "type": "normal",
+    "enable": true
+  },
+  {
+    "type": "token",
+    "enable": true
+  },
+  {
+    "type": "smoothing",
+    "enable": true,
+    "algorithm": "",
+    "weight": 0
+  }
+])";
+    auto params = ParseJsonToStr(jsonStr);
+    EXPECT_TRUE(params.IsArray());
     LineBasicInfo info{"train", "test", 0, std::numeric_limits<uint64_t>::max()};
     std::unordered_map<LineType, std::shared_ptr<LineOp>> opsMap;
-    BuildLineOps(param, info, opsMap);
+    std::for_each(params.Begin(), params.End(), [&info, &opsMap](const auto& param) {
+        BuildLineOps(param, info, opsMap);
+    });
     EXPECT_NE(opsMap.find(LineType::NORMAL), opsMap.end());
     EXPECT_NE(opsMap.find(LineType::TOKEN), opsMap.end());
     EXPECT_NE(opsMap.find(LineType::SMOOTHING), opsMap.end());
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/GraphManagerTest/GraphManagerTest.cpp b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/GraphManagerTest/GraphManagerTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..39069b05a9ee66a1a60c1ec682a9c987225999ac
--- /dev/null
+++ b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/GraphManagerTest/GraphManagerTest.cpp
@@ -0,0 +1,110 @@
+/*
+* Copyright (c), Huawei Technologies Co., Ltd. 2025-2025.All rights reserved.
+ */
+#include <gtest/gtest.h>
+#include "ScalarVisuallyServer.h"
+#include "TestUtil.h"
+#include "GraphManager/GraphManager.h"
+
+using namespace Insight::Scalar::GraphOp;
+using namespace Insight::UnitTest;
+
+class GraphManagerTest : public testing::Test
+{
+protected:
+    void SetUp() override
+    {
+        auto data1 = GenerateRandomData({0, 100}, {0, 1});
+        auto file1 = ScalarVisuallyServer::Instance().AddFile("testFile1");
+        graph.UpdateGraphData("test", "testFile1", std::move(data1));
+        auto data2 = GenerateRandomData({0, 100}, {0, 1});
+        auto file2 = ScalarVisuallyServer::Instance().AddFile("testFile2");
+        graph.UpdateGraphData("test2", "testFile2", std::move(data2));
+    }
+
+    void TearDown() override
+    {
+        graph.Reset();
+        ScalarVisuallyServer::Instance().Reset();
+    }
+
+    GraphManager graph;
+};
+
+TEST_F(GraphManagerTest, GetGraphData)
+{
+    auto data = graph.GetGraphData("test", "testFile1", 0, -1, DataMode::NORMAL);
+    EXPECT_EQ(data.size(), 1);
+    EXPECT_EQ(data[0].Length(), 102);
+}
+
+TEST_F(GraphManagerTest, GetGraphDataWithInvalidTag)
+{
+    auto data = graph.GetGraphData("test3", "testFile1", 0, -1, DataMode::NORMAL);
+    EXPECT_EQ(data.size(), 0);
+}
+
+TEST_F(GraphManagerTest, GetGraphDataWithNoExistFile)
+{
+    auto data = graph.GetGraphData("test", "testFile3", 0, -1, DataMode::NORMAL);
+    EXPECT_EQ(data.size(), 0);
+}
+
+TEST_F(GraphManagerTest, GetGraph)
+{
+    auto graphTest = graph.GetGraph("test");
+    EXPECT_NE(graphTest, nullptr);
+    auto graphTest2 = graph.GetGraph("test3");
+    EXPECT_EQ(graphTest2, nullptr);
+}
+
+TEST_F(GraphManagerTest, GetGraphNotExist)
+{
+    auto graphTest = graph.GetGraph("test2");
+    EXPECT_NE(graphTest, nullptr);
+}
+
+TEST_F(GraphManagerTest, GetAllGraphInfo)
+{
+    auto graphMap = graph.GetAllGraphInfo();
+    EXPECT_EQ(graphMap.size(), 2);
+    EXPECT_TRUE(!graphMap["test"].empty());
+}
+
+TEST_F(GraphManagerTest, GetFileTags)
+{
+    std::set<std::string> tagRes;
+    graph.GetFileTags("testFile1", tagRes);
+    EXPECT_EQ(tagRes.size(), 1);
+    graph.GetFileTags("testFile3", tagRes);
+    EXPECT_EQ(tagRes.size(), 1);
+}
+
+TEST_F(GraphManagerTest, UpdateGraphData)
+{
+    auto data1 = GenerateRandomData({101, 200}, {1, 2});
+    graph.UpdateGraphData("test", "testFile1", std::move(data1));
+    auto res = graph.GetGraphData("test", "testFile1", 0, -1, DataMode::NORMAL)[0];
+    EXPECT_EQ(res.Length(), 202);
+}
+
+TEST_F(GraphManagerTest, UpdateGraphDataWithInvalidTag)
+{
+    auto data1 = GenerateRandomData({101, 200}, {1, 2});
+    EXPECT_NO_THROW(graph.UpdateGraphData("test4", "testFile3", std::move(data1)));
+}
+
+TEST_F(GraphManagerTest, UpdateGraphDataWithNoExistFile)
+{
+    auto data1 = GenerateRandomData({101, 200}, {1, 2});
+    EXPECT_NO_THROW(graph.UpdateGraphData("test", "testFile3", std::move(data1)));
+}
+
+TEST_F(GraphManagerTest, UpdateSoomthingParam)
+{
+    graph.UpdateGraphSmoothingParam("test2", "testFile1" ,std::make_unique<SmoothingParamBase>());
+    auto params = std::make_unique<IRSmootherParam>();
+    params->algorithm_ = "smoothing";
+    params->weight_ = 0.5;
+    graph.UpdateGraphSmoothingParam("test", "testFile1", std::move(params));
+}
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/GraphManagerTest/GraphTest.cpp b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/GraphManagerTest/GraphTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..df373fca62d3c432bf9e4f9f093a9b8a704cc8e4
--- /dev/null
+++ b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/GraphManagerTest/GraphTest.cpp
@@ -0,0 +1,112 @@
+/*
+* Copyright (c), Huawei Technologies Co., Ltd. 2025-2025.All rights reserved.
+ */
+#include <gtest/gtest.h>
+#include <algorithm>
+#include "ScalarVisuallyServer.h"
+#include "TestUtil.h"
+#include "GraphManager/GraphManager.h"
+
+using namespace Insight::Scalar::GraphOp;
+using namespace Insight::UnitTest;
+
+class GraphTest : public ::testing::Test
+{
+    void TearDown() override
+    {
+        ScalarVisuallyServer::Instance().Reset();
+    }
+};
+
+TEST_F(GraphTest, CreateGraph)
+{
+    Graph graph("test");
+    EXPECT_EQ("test", graph.GetTag());
+}
+
+TEST_F(GraphTest, GetDataFiles)
+{
+    Graph graph("test");
+    graph.UpdateData("testFile1", {});
+    graph.UpdateData("testFile2", {});
+    auto dataFiles = graph.GetDataFiles();
+    EXPECT_EQ(dataFiles.size(), 2); // expect 2
+    std::sort(dataFiles.begin(), dataFiles.end());
+    std::vector<std::string> expect = {"testFile1", "testFile2"};
+    auto res = std::includes(expect.begin(), expect.end(), dataFiles.begin(), dataFiles.end());
+    EXPECT_TRUE(res);
+    Graph graph2("test2");
+    EXPECT_TRUE(graph2.GetDataFiles().empty());
+}
+
+TEST_F(GraphTest, UpdateData)
+{
+    auto graph = Graph("test");
+    auto data = GenerateRandomData({0, 100}, {0.1, 0.2}); // gernerator step (0, 100) value range(0.1, 0.2)
+    auto file = ScalarVisuallyServer::Instance().AddFile("testFile");
+    graph.UpdateData("testFile", std::move(data));
+    auto dataRes = graph.GetFileData("testFile", 0, -1, DataMode::NORMAL);
+    EXPECT_EQ(dataRes.size(), 1);
+    EXPECT_EQ(dataRes[0].Length(), 102);
+    auto data2 = GenerateRandomData({0, 100}, {0.1, 0.2}); // gernerator step (0, 100) value range(0.1, 0.2)
+    graph.UpdateData("testFile2", std::move(data2));
+    auto dataRes2 = graph.GetFileData("testFile2", 0, -1, DataMode::NORMAL);
+    EXPECT_EQ(dataRes2.size(), 0);
+}
+
+TEST_F(GraphTest, AddFile)
+{
+    auto graph = Graph("test");
+    graph.AddFile("file");
+    EXPECT_EQ(graph.GetDataFiles().size(), 1);
+}
+
+TEST_F(GraphTest, InnerFile)
+{
+    auto graph = Graph("test");
+    graph.AddFile("file");
+    EXPECT_TRUE(graph.InnerFile("file"));
+    EXPECT_FALSE(graph.InnerFile("file2"));
+}
+
+TEST_F(GraphTest, UpdateSoomthing)
+{
+    auto graph = Graph("test");
+    auto data = GenerateRandomData({0, 100}, {0.1, 0.2}); // gernerator step (0, 100) value range(0.1, 0.2)
+    auto file = ScalarVisuallyServer::Instance().AddFile("testFile");
+    graph.UpdateData("testFile", std::move(data));
+    EXPECT_NO_THROW(graph.UpdateSmoothingParam("testFile", std::make_unique<SmoothingParamBase>()));
+    auto params = std::make_unique<IRSmootherParam>();
+    params->algorithm_ = "smoothing";
+    params->weight_ = 0.5;
+    graph.UpdateSmoothingParam("testFile", std::move(params));
+    auto params2 = std::make_unique<IRSmootherParam>();
+    params2->algorithm_ = "smoothing";
+    params2->weight_ = 0.5;
+    graph.UpdateSmoothingParam("testFile2", std::move(params2));
+}
+
+TEST_F(GraphTest, GetFileData)
+{
+    auto graph = Graph("test");
+    auto data = GenerateRandomData({0, 100}, {0.1, 0.2}); // gernerator step (0, 100) value range(0.1, 0.2)
+    auto file = ScalarVisuallyServer::Instance().AddFile("testFile");
+    graph.UpdateData("testFile", std::move(data));
+    auto dataRes = graph.GetFileData("testFile", 0, -1, DataMode::NORMAL);
+    EXPECT_EQ(dataRes.size(), 1);
+    EXPECT_EQ(dataRes[0].Length(), 102);
+    auto dataRes2 = graph.GetFileData("testFile2", 0, -1, DataMode::NORMAL);
+    EXPECT_EQ(dataRes2.size(), 0);
+    graph.AddFile("testFile2");
+    auto dataRes3 = graph.GetFileData("testFile2", 0, -1, DataMode::NORMAL);
+    EXPECT_EQ(dataRes3.size(), 0);
+}
+
+TEST_F(GraphTest, DelFile)
+{
+    auto graph = Graph("test");
+    graph.AddFile("testFile1");
+    graph.AddFile("testFile2");
+    graph.DelFile("testFile1");
+    EXPECT_EQ(graph.GetDataFiles().size(), 1);
+}
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/GraphTest.cpp b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/GraphTest.cpp
deleted file mode 100644
index d47b210acb7389cd41f7fd5468bea47e9bc4ac20..0000000000000000000000000000000000000000
--- a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/GraphTest.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-* Copyright (c), Huawei Technologies Co., Ltd. 2024-2024.All rights reserved.
-*/
-#include "gtest/gtest.h"
-#include "GraphManager/GraphManager.h"
-using namespace Insight::Scalar;
-using namespace Insight::Scalar::GraphOp;
-
-class GraphTestSuit : public testing::Test {
-public:
-    void SetUp()
-    {
-        manager_.Reset();
-        std::vector<ScalarPoint> temp(lossData.begin(), lossData.end());
-        manager_.UpdateGraphData("loss", "TestA", std::move(temp));
-        std::copy(lossData.begin(), lossData.begin() + 1, std::back_inserter(temp));
-        manager_.UpdateGraphData("loss", "TestB", std::move(temp));
-        std::vector<ScalarPoint> tem2(lineData.begin(), lineData.end());
-        manager_.UpdateGraphData("line", "TestC", std::move(tem2));
-    }
-
-protected:
-    std::vector<ScalarPoint> lossData = {{0, 0.158}, {1, 0.11124}, {2, 0.3124}};
-    std::vector<ScalarPoint> lineData = {{0, 0.18}, {1, 0.24}, {2, 0.424}};
-    GraphManager manager_;
-};
-
-TEST_F(GraphTestSuit, AddGraph)
-{
-    GraphManager manager_;
-    std::vector<ScalarPoint> temp(lossData.begin(), lossData.end());
-    manager_.UpdateGraphData("loss", "TestA", std::move(temp));
-    auto graphPtr = manager_.GetGraph("loss");
-    EXPECT_NE(graphPtr, nullptr);
-    EXPECT_EQ(graphPtr -> GetDataFiles() . size(), 1);
-}
-
-TEST_F(GraphTestSuit, GetGraphData)
-{
-    SingleGraphReqInfo req_info;
-    req_info.file_ = "TestA";
-    req_info.start_ = 0;
-    req_info.end_ = -1;
-    req_info.tag_ = "loss";
-
-}
-
-TEST_F(GraphTestSuit, GetGraphInfo)
-{
-    auto graphMap = manager_.GetAllGraphInfo();
-    EXPECT_EQ(graphMap.count("loss"), 1);
-    EXPECT_EQ(graphMap.count("line"), 1);
-    constexpr int EXPECTED_GRAPH_DATA_SIZE = 2;
-    EXPECT_EQ(graphMap["loss"].size(),EXPECTED_GRAPH_DATA_SIZE);
-    EXPECT_EQ(graphMap["loss"][0], "TestA");
-    EXPECT_EQ(graphMap["line"].size(), 1);
-    EXPECT_EQ(graphMap["line"][0], "TestC");
-}
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/ParserTest.cpp b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/ParserTest.cpp
deleted file mode 100644
index eac8999d2060c578cae128411af1c4a734c3be22..0000000000000000000000000000000000000000
--- a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/ParserTest.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "gtest/gtest.h"
-#include "ParserFactory.h"
-#include "proto/event.pb.h"
-#include "defs/ConceptDefs.h"
-/*
-* Copyright (c), Huawei Technologies Co., Ltd. 2024-2024.All rights reserved.
-*/
-using namespace Insight::Scalar::Parser;
-using namespace Insight::Scalar;
-
-class ParserTestSuit : public ::testing::Test {
-protected:
-    std::string pathPrefix = "../../../../";
-    std::string tfeventTestFile =
-            pathPrefix +
-            "mindstudio-board/server/plugins/ScalarVisually/test/test_data/tfevent_data/events.out.tfevents.1728628561";
-
-    void SetUp() override
-    {
-    }
-};
-
-TEST_F(ParserTestSuit, ParserFactoryGetParserInstance)
-{
-    std::shared_ptr<FileParser> parser = nullptr;
-    parser = ParserFactory::Instance().CreateFileParse(ParseDataType::Unknown);
-    EXPECT_EQ(parser, nullptr);
-    parser = ParserFactory::Instance().CreateFileParse(ParseDataType::TF_EVENT);
-    EXPECT_EQ(parser->type_ == ParseDataType::TF_EVENT, true);
-    parser = ParserFactory::Instance().CreateFileParse(ParseDataType::MINDSPORE_SUMMARY);
-    EXPECT_EQ(parser->type_ == ParseDataType::MINDSPORE_SUMMARY, true);
-    parser = ParserFactory::Instance().CreateFileParse(ParseDataType::TEXT_LOG);
-    EXPECT_EQ(parser->type_ == ParseDataType::TEXT_LOG, true);
-    parser = ParserFactory::Instance().CreateFileParse(ParseDataType::Unknown);
-    EXPECT_EQ(parser, nullptr);
-}
-
-TEST_F(ParserTestSuit, ParseTFevent)
-{
-    auto parser = ParserFactory::Instance().CreateFileParse(ParseDataType::TF_EVENT);
-    uint64_t offset = 0;
-    auto res = parser->ParserData(tfeventTestFile, offset);
-    EXPECT_EQ(res, false);
-    EXPECT_EQ(offset, 18446744073709551615ull);
-}
-
-TEST_F(ParserTestSuit, ParseSummaryData)
-{
-    auto parser = ParserFactory::Instance().CreateFileParse(ParseDataType::MINDSPORE_SUMMARY);
-}
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/ParserTest/FileParserTest.cpp b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/ParserTest/FileParserTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..505f9a03251267cee695d9a48b6295a8b7a38183
--- /dev/null
+++ b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/ParserTest/FileParserTest.cpp
@@ -0,0 +1,58 @@
+/*
+* Copyright (c), Huawei Technologies Co., Ltd. 2025-2025.All rights reserved.
+ */
+#include <gtest/gtest.h>
+#include "TestUtil.h"
+#include "ScalarVisuallyServer.h"
+#include "parser/ParserFactory.h"
+using namespace Insight::Scalar::Parser;
+class FileParserTest : public ::testing::Test
+{
+protected:
+    void SetUp() override
+    {
+        std::string currentSourcePath = __FILE__;
+        std::string testDataDir = currentSourcePath.substr(0, currentSourcePath.find("test"));
+        tfeventFilePath = testDataDir + "/test/test_data/tfevent_data/events.out.tfevents.1728628561";
+        summaryFilePath = testDataDir + "/test/test_data/summary_data/events.out.events.summary.1751337158.0.WIN-AJOM79D92I6_MS";
+        mindFormsLogFilePath = testDataDir + "/test/test_data/mindforms/work_0.log";
+        ScalarVisuallyServer::Instance().AddFile(tfeventFilePath);
+        ScalarVisuallyServer::Instance().AddFile(summaryFilePath);
+        ScalarVisuallyServer::Instance().AddFile(mindFormsLogFilePath);
+    }
+public:
+    std::string tfeventFilePath;
+    std::string summaryFilePath;
+    std::string mindFormsLogFilePath;
+};
+
+TEST_F(FileParserTest, tfeventParse)
+{
+    auto parser = ParserFactory::Instance().CreateFileParse(ParseDataType::TF_EVENT);
+    uint64_t offset = 0;
+    parser->ParserData(tfeventFilePath, offset);
+    EXPECT_EQ(offset, 489958);
+}
+
+TEST_F(FileParserTest, summaryParse)
+{
+    auto parser = ParserFactory::Instance().CreateFileParse(ParseDataType::MINDSPORE_SUMMARY);
+    uint64_t offset = 0;
+    parser->ParserData(summaryFilePath, offset);
+    EXPECT_EQ(offset, 44);
+}
+
+TEST_F(FileParserTest, mindformsParse)
+{
+    auto parser = ParserFactory::Instance().CreateFileParse(ParseDataType::TEXT_LOG);
+    uint64_t offset = 0;
+    parser->ParserData(mindFormsLogFilePath, offset);
+    EXPECT_EQ(offset, 0);
+}
+
+TEST_F(FileParserTest, unknowFile)
+{
+    auto parser = ParserFactory::Instance().CreateFileParse(ParseDataType::Unknown);
+    EXPECT_EQ(parser, nullptr);
+}
+
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/PluginTest.cpp b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/PluginTest.cpp
deleted file mode 100644
index 71516f35390c807493df8024242c12b8d7936095..0000000000000000000000000000000000000000
--- a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/PluginTest.cpp
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
-* Copyright (c), Huawei Technologies Co., Ltd. 2024-2024.All rights reserved.
-*/
-#include <iostream>
-#ifdef _WIN32
-#include <filesystem>
-namespace fs = std::filesystem;
-#else
-#include <experimental/filesystem>
-namespace fs = std::experimental::filesystem;
-#endif
-#include "gtest/gtest.h"
-#include "plugin/ScalarVisualPlugin.h"
-#include "ApiHandler.h"
-#include "Util/ScalaryProtocolUtil.h"
-#include "ScalarVisuallyServer.h"
-using namespace Insight::Scalar;
-using namespace Insight::Scalar::Protocol;
-
-class PluginTestSuite : public testing::Test {
-protected:
-    ScalarVisualPlugin plugin_;
-
-    void SetUpTestSuit()
-    {
-    };
-
-    std::shared_ptr<ApiHandler> GetHandler(std::string_view name)
-    {
-        auto handlerMap = plugin_.GetAllHandlers();
-        return handlerMap.at(std::string(name));
-    }
-
-    std::string GetBasicResult()
-    {
-        return R"({"body":{}, "msg":"", "errCode":0, "result":true})";
-    }
-
-    void ImportFile(std::string &file)
-    {
-        auto imporFileHandler = GetHandler("ImportFile");
-        std::string request = R"({"append": false, "pathList": [")" + file + R"("]})";
-        std::string resultStr = GetBasicResult();
-        bool success = imporFileHandler->run(request, resultStr);
-    }
-
-    std::string currentPath = fs::current_path().string();
-    size_t index = currentPath.find("mindstudio-board");
-    std::string pathPreFix = currentPath.substr(0, index);
-    std::string tfDataDir = pathPreFix + "mindstudio-board/server/plugins/ScalarVisually/test/test_data/tfevent_data";
-    std::string tfDataFile =
-            pathPreFix +
-            "mindstudio-board/server/plugins/ScalarVisually/test/test_data/tfevent_data/events.out.tfevents.1728628561";
-    ScalarVisuallyServer &server = ScalarVisuallyServer::Instance();
-};
-
-TEST_F(PluginTestSuite, ImportFileWithDir)
-{
-    auto imporFileHandler = GetHandler("/ScalarVisually/ImportFile");
-    std::string request = R"({"append": false, "pathList": [")" + tfDataDir + R"(]})";
-    std::string resultStr = GetBasicResult();
-    bool success = imporFileHandler->run(request, resultStr);
-    document_t result = ParseJsonToStr(resultStr);
-    json &body = result["body"];
-    EXPECT_EQ(success, true);
-    EXPECT_EQ(body.HasMember("data"), true);
-    json &data = body["data"];
-    EXPECT_EQ(data.IsArray(), true);
-    EXPECT_EQ(data.Size(), 1);
-    EXPECT_EQ(data[0].HasMember("tag"), true);
-    EXPECT_STREQ(data[0]["tag"].GetString(), "Loss/train");
-}
-
-TEST_F(PluginTestSuite, ImportFileWithFile)
-{
-    auto importFileHandler = GetHandler("/ScalarVisually/ImportFile");
-    std::string request = R"({"append": false, "pathList": [")" + tfDataFile + R"("]})";
-    std::string resultStr = GetBasicResult();
-    bool success = importFileHandler->run(request, resultStr);
-    document_t result = ParseJsonToStr(resultStr);
-    json &body = result["body"];
-    EXPECT_EQ(success, true);
-    EXPECT_EQ(body.HasMember("data"), true);
-    json &data = body["data"];
-    EXPECT_EQ(data.IsArray(), true);
-    EXPECT_EQ(data.Size(), 1);
-    EXPECT_EQ(data[0].HasMember("tag"), true);
-    EXPECT_STREQ(data[0]["tag"].GetString(), "Loss/train");
-}
-
-TEST_F(PluginTestSuite, GetLossDataOffSetZero)
-{
-    ImportFile(tfDataFile);
-    auto GetDataHandler = GetHandler("/ScalarVisually/GetScalarData");
-    std::string request = R"({"graphList": [{"tag": "Loss/train", "file": ")" + tfDataFile + R"(", "offset": 0}]})";
-    std::string response = GetBasicResult();
-    bool succes = GetDataHandler->run(request, response);
-    EXPECT_EQ(succes, true);
-    document_t result = ParseJsonToStr(response);
-    json &body = result["body"];
-    json &data = body["data"];
-    EXPECT_EQ(data.IsArray(), true);
-    json &lossData = data[0];
-    EXPECT_STREQ(lossData["tag"].GetString(), "Loss/train");
-    json &points = lossData["points"];
-    EXPECT_EQ(points.IsArray(), true);
-    constexpr int EXPECTED_POINTS_SIZE = 10000;
-    EXPECT_EQ(points.Size(), EXPECTED_POINTS_SIZE); // 预期的points数组大小为10000
-}
-
-TEST_F(PluginTestSuite, GetLossDataOffSet)
-{
-    ImportFile(tfDataFile);
-    auto GetDataHandler = GetHandler("/ScalarVisually/GetScalarData");
-    std::string request = R"({"graphList": [{"tag": "Loss/train", "file": ")" + tfDataFile + R"(", "offset": 10}]})";
-    std::string response = GetBasicResult();
-    bool succes = GetDataHandler->run(request, response);
-    EXPECT_EQ(succes, true);
-    document_t result = ParseJsonToStr(response);
-    json &body = result["body"];
-    json &data = body["data"];
-    EXPECT_EQ(data.IsArray(), true);
-    json &lossData = data[0];
-    EXPECT_STREQ(lossData["tag"].GetString(), "Loss/train");
-    json &points = lossData["points"];
-    EXPECT_EQ(points.IsArray(), true);
-    constexpr int EXPECTED_POINTS_SIZE = 9990;
-    EXPECT_EQ(points.Size(), EXPECTED_POINTS_SIZE);
-}
-
-TEST_F(PluginTestSuite, GetLossDataOffSetExceedSize)
-{
-    ImportFile(tfDataFile);
-    auto GetDataHandler = GetHandler("/ScalarVisually/GetScalarData");
-    std::string request = R"({"graphList": [{"tag": "Loss/train", "file": ")" + tfDataFile + R"(", "offset": 10010}]})";
-    std::string response = GetBasicResult();
-    bool succes = GetDataHandler->run(request, response);
-    EXPECT_EQ(succes, true);
-    document_t result = ParseJsonToStr(response);
-    json &body = result["body"];
-    json &data = body["data"];
-    EXPECT_EQ(data.IsArray(), true);
-    json &lossData = data[0];
-    EXPECT_STREQ(lossData["tag"].GetString(), "Loss/train");
-    json &points = lossData["points"];
-    EXPECT_EQ(points.IsArray(), true);
-    EXPECT_EQ(points.Size(), 0);
-}
-
-TEST_F(PluginTestSuite, GetAllGraph)
-{
-    ImportFile(tfDataFile);
-    auto handler = GetHandler("/ScalarVisually/GetAllGraph");
-    std::string request = R"()";
-    std::string response = GetBasicResult();
-    bool success = handler->run(request, response);
-    EXPECT_EQ(success, true);
-    document_t result = ParseJsonToStr(response);
-    json &body = result["body"];
-    json &data = body["data"];
-    EXPECT_EQ(data.IsArray(), true);
-    EXPECT_EQ(data.Size(), 1);
-    json &graph = data[0];
-    EXPECT_STREQ(graph["tag"].GetString(), "Loss/train");
-    EXPECT_EQ(graph["fileList"].IsArray() && graph["fileList"].Size() == 1, true);
-    json &file = graph["fileList"][0];
-    EXPECT_EQ(file.IsString(), true);
-    EXPECT_EQ(tfDataFile == file.GetString(), true);
-}
-
-TEST_F(PluginTestSuite, ImportNewFile)
-{
-    server.OnFileCreate(std::string(tfDataDir), fs::path(tfDataFile).filename().string());
-    std::string request = R"({"pathList":[")" + tfDataFile + R"("], "append":true})";
-    std::string result = GetBasicResult();
-    auto handler = GetHandler("ImportFile");
-    auto errCode = handler->run(request, result);
-    EXPECT_EQ(errCode, 0);
-}
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/PluginTest/ServerTest.cpp b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/PluginTest/ServerTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eee417836b26dc418c2aa825573cea415069d4c7
--- /dev/null
+++ b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/PluginTest/ServerTest.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c), Huawei Technologies Co., Ltd. 2025-2025.All rights reserved.
+ */
+#include "ScalarVisuallyServer.h"
+#include "TestUtil.h"
+#include <gtest/gtest.h>
+class ServerTest : public testing::Test
+{
+protected:
+    void SetUp() override
+    {
+        std::string currentSourcePath = __FILE__;
+        testDataDir =
+            currentSourcePath.substr(0, currentSourcePath.find("test"));
+        tfeventFilePath =
+            testDataDir +
+            "/test/test_data/tfevent_data/events.out.tfevents.1728628561";
+    }
+
+    void TearDown() override
+    {
+        ScalarVisuallyServer::Instance().Reset();
+    }
+    std::string testDataDir;
+    std::string tfeventFilePath;
+};
+
+TEST_F(ServerTest, ImportDir)
+{
+    ScalarVisuallyServer::Instance().AddImportedDir(testDataDir);
+    EXPECT_TRUE(ScalarVisuallyServer::Instance().IsImportedDir(testDataDir));
+}
+
+TEST_F(ServerTest, ImportFile)
+{
+    auto file = ScalarVisuallyServer::Instance().AddFile(tfeventFilePath);
+    EXPECT_NE(file, nullptr);
+    EXPECT_TRUE(ScalarVisuallyServer::Instance().IsFileImported(tfeventFilePath));
+}
+
+TEST_F(ServerTest, GetFileHierarchy)
+{
+    ScalarVisuallyServer::Instance().AddImportedDir(testDataDir);
+    auto hierarchy = ScalarVisuallyServer::Instance().GetFileHierarchy(tfeventFilePath);
+    EXPECT_EQ(hierarchy.size(), 4);
+}
+
+TEST_F(ServerTest, FileInfoAddGet)
+{
+    ScalarVisuallyServer::Instance().AddFile(tfeventFilePath);
+    auto fileInfo = ScalarVisuallyServer::Instance().GetFileInfo(tfeventFilePath);
+    EXPECT_NE(fileInfo, nullptr);
+}
+
+TEST_F(ServerTest, IsFileSupport)
+{
+    EXPECT_TRUE(ScalarVisuallyServer::IsFileSupported(tfeventFilePath));
+}
+
+TEST_F(ServerTest, FileWatch)
+{
+    ScalarVisuallyServer::Instance().AddFileWatch({testDataDir});
+    EXPECT_FALSE(ScalarVisuallyServer::Instance().IsFileWatched(std::string(testDataDir)));
+}
+
+TEST_F(ServerTest, VirtualFile)
+{
+    auto virtualFile = std::make_shared<FileInfo::File>(tfeventFilePath, ParseDataType::TF_EVENT);
+    ScalarVisuallyServer::Instance().AddVirtualFile(virtualFile);
+    EXPECT_NE(ScalarVisuallyServer::Instance().GetFileInfo(tfeventFilePath), nullptr);
+    ScalarVisuallyServer::Instance().DelVirtualFile(virtualFile);
+    EXPECT_EQ(ScalarVisuallyServer::Instance().GetFileInfo(tfeventFilePath), nullptr);
+}
+
+TEST_F(ServerTest, Cremental)
+{
+    EXPECT_EQ(ScalarVisuallyServer::Instance().IsIncremental(testDataDir, "test"), true);
+    ScalarVisuallyServer::Instance().AddImportedDir(testDataDir);
+    ScalarVisuallyServer::Instance().AddIncremental(testDataDir, "test");
+    auto incremental = ScalarVisuallyServer::Instance().GetIncremental();
+    EXPECT_FALSE(incremental.empty());
+    EXPECT_EQ(incremental.begin()->first, "test");
+    EXPECT_EQ(incremental.begin()->second.count(testDataDir), 1);
+}
+
+TEST_F(ServerTest, OnFileCreate)
+{
+    ScalarVisuallyServer::Instance().OnFileCreate(std::string(testDataDir), "createFile");
+    auto createFile = ScalarVisuallyServer::Instance().GetCreatedFileGroupByDir();
+    EXPECT_FALSE(createFile.empty());
+    EXPECT_EQ(createFile.begin()->first, testDataDir);
+    EXPECT_EQ(createFile.begin()->second.size(), 1);
+    EXPECT_EQ(createFile.begin()->second.count("createFile"), 1);
+}
+
+TEST_F(ServerTest, OnFileUpdate)
+{
+    ScalarVisuallyServer::Instance().OnFileDataUpdate(std::string(testDataDir), std::string(tfeventFilePath));
+
+}
+
+TEST_F(ServerTest, AddFile)
+{
+    std::string filePath = "events.out.tfevents.1728628561";
+    ScalarVisuallyServer::Instance().AddFile(filePath);
+}
+
+TEST_F(ServerTest, Reset)
+{
+    std::string filePath = "test_file_path";
+    ScalarVisuallyServer::Instance().AddFile(filePath);
+    ScalarVisuallyServer::Instance().Reset();
+}
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/TestUtil.h b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/TestUtil.h
index b67b3979a816accb2a7286a78ef4d56e182010a1..3b4b3d8d6273972886756dcbe5dfeb53bd37dda6 100644
--- a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/TestUtil.h
+++ b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/TestUtil.h
@@ -23,7 +23,7 @@ inline std::vector<ScalarPoint> GenerateRandomData(std::tuple<int64_t, int64_t>
 
     std::vector<ScalarPoint> res;
     res.reserve(end - start + 1);
-    for (uint64_t i = 0; i <= end; i++) {
+    for (uint64_t i = 0; i + start <= end; i++) {
         res.emplace_back(start + i, dist(gen));
     }
     return res;
diff --git a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/defsTest/ScalarPointTest.cpp b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/defsTest/ScalarPointTest.cpp
index eec8a067bec39aebcd440fffe4ac23343664bea4..f1318df3040cbf243f62956c49b97c617377738b 100644
--- a/plugins/mindstudio-insight-plugins/Scalar/server/src/test/defsTest/ScalarPointTest.cpp
+++ b/plugins/mindstudio-insight-plugins/Scalar/server/src/test/defsTest/ScalarPointTest.cpp
@@ -5,8 +5,6 @@
 #include "defs/ConceptDefs.h"
 
 using namespace Insight::Scalar;
-
-namespace Insight::UnitTest {
 class ScalarPointTest : public testing::Test
 {
 };
@@ -29,4 +27,4 @@ TEST_F(ScalarPointTest, CastLocalTimeToWallTime)
     constexpr uint64_t expectTimeStamp = 1742869634;
     EXPECT_EQ(static_cast<uint64_t>(p.wallTime_), expectTimeStamp);
 }
-}
+
diff --git a/plugins/mindstudio-insight-plugins/build/build.py b/plugins/mindstudio-insight-plugins/build/build.py
index 3e2b9d425e0923350431aefc6085b9bc9da74167..55f92004f230e226e143982ba2dc1909462dbf44 100644
--- a/plugins/mindstudio-insight-plugins/build/build.py
+++ b/plugins/mindstudio-insight-plugins/build/build.py
@@ -80,14 +80,53 @@ def build_scalar(args):
 
 
 def build_plugins(args):
+    if args.build_test:
+        build_scalar_test(args)
     if not build_scalar(args):
         sys.exit(-1)
     sys.exit(0)
 
+def build_scalar_test(args):
+    generator = 'Ninja'
+    build_dir = os.path.join(BUILD_DIR, 'scalar', 'build')
+    if not os.path.exists(build_dir):
+        os.makedirs(build_dir)
+    output_dir = os.path.join(BUILD_DIR, 'scalar', 'output', 'cpp_coverage', platform.system(), platform.machine())
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    if args.build_release:
+        build_type = 'release'
+    else:
+        build_type = 'debug'
+    load_cmd = [
+        'cmake', '-S', HOME_DIR, '-G', generator, '-DCMAKE_BUILD_TYPE=' + build_type,
+                                                  '-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + output_dir,
+                                                  "-DCMAKE_RUNTIME_OUTPUT_DIRECTORY=" + output_dir, '-B', build_dir
+    ]
+    ret = execute_cmd(load_cmd, BUILD_DIR)
+    if ret is None:
+        logging.error("Loading cmake timeout")
+        return False
+    if ret != 0:
+        logging.error("Loading cmake failed")
+        return False
+    build_cmd = [
+        'cmake', '--build', '.', '--target', 'Scalar_test', '-j'
+    ]
+    ret = execute_cmd(build_cmd, build_dir)
+    if ret is None:
+        logging.error("Build timeout")
+        return False
+    if ret != 0:
+        logging.error("Build failed")
+        return False
+    return True
+
 
 if __name__ == '__main__':
     init_log()
     parser = argparse.ArgumentParser()
     parser.add_argument('--release', dest='build_release', action='store_true', help='build release')
+    parser.add_argument('--test', dest='build_test', action='store_true', help='build test')
     args = parser.parse_args()
     build_plugins(args)
diff --git a/plugins/mindstudio-insight-plugins/build/cpp_coverage.sh b/plugins/mindstudio-insight-plugins/build/cpp_coverage.sh
new file mode 100644
index 0000000000000000000000000000000000000000..5be21ece78a631f300c1e00ebb67a6dca8798931
--- /dev/null
+++ b/plugins/mindstudio-insight-plugins/build/cpp_coverage.sh
@@ -0,0 +1,34 @@
+#!/bin/bash
+ # Copyright (c), Huawei Technologies Co., Ltd. 2025-2025.All rights reserved.
+ # UT执行失败时退出
+set -e
+set -x
+CUR_DIR=$(dirname $(readlink -f $0))
+Build_DIR=${CUR_DIR}
+python build.py --release --test
+OUTPUT_DIR=${Build_DIR}/scalar/output/cpp_coverage/Linux/x86_64
+cd ${OUTPUT_DIR}
+./Scalar_test
+cd ${OUTPUT_DIR}
+test_dir=$(find ${Build_DIR} -name 'Scalar_test.dir')
+echo "Test coverage data dir:${test_dir}"
+echo "************************ Generate Scalar Coverage Start ****************************************"
+LCOV_RC="--no-checksum --rc lcov_branch_coverage=1 --rc geninfo_no_exception_branch=1 --rc geninfo_unexecuted_blocks=1 --ignore-errors mismatch"
+REPORT_DIR=${Build_DIR}/coverage_report
+if [ ! -d "${REPORT_DIR}" ] ; then
+  mkdir -p ${REPORT_DIR}
+fi
+lcov -c -d ${test_dir} -o ${REPORT_DIR}/lcov_scalar_test.info ${LCOV_RC}
+lcov -r ${REPORT_DIR}/lcov_scalar_test.info "*include*" -o ${REPORT_DIR}/lcov_scalar_test.info ${LCOV_RC}
+lcov -r ${REPORT_DIR}/lcov_scalar_test.info "*proto*" -o ${REPORT_DIR}/lcov_scalar_test.info ${LCOV_RC}
+lcov -r ${REPORT_DIR}/lcov_scalar_test.info "*plugin_core*" -o ${REPORT_DIR}/lcov_scalar_test.info ${LCOV_RC}
+lcov -r ${REPORT_DIR}/lcov_scalar_test.info "*Handler*" -o ${REPORT_DIR}/lcov_scalar_test.info ${LCOV_RC}
+lcov -r ${REPORT_DIR}/lcov_scalar_test.info "*test*" -o ${REPORT_DIR}/lcov_scalar_test.info ${LCOV_RC}
+
+echo "********************* Generate Scalar Coverage Stop **********************************************"
+
+genhtml ${REPORT_DIR}/lcov_scalar_test.info -o ${REPORT_DIR}/result --branch-coverage
+echo "Report:${REPORT_DIR}"
+
+
+