fix: repair test cases

10 files changed, 545 insertions, 484 deletions

diff --git a/src/core/function/gpg/GpgBasicOperator.cpp b/src/core/function/gpg/GpgBasicOperator.cpp
index 7b6d45b2..f559a086 100644
--- a/src/core/function/gpg/GpgBasicOperator.cpp
+++ b/src/core/function/gpg/GpgBasicOperator.cpp
@@ -33,6 +33,7 @@
 #include "core/GpgModel.h"
 #include "core/utils/AsyncUtils.h"
 #include "core/utils/GpgUtils.h"
+#include "spdlog/spdlog.h"
 
 namespace GpgFrontend {
 
@@ -44,8 +45,7 @@ void GpgFrontend::GpgBasicOperator::Encrypt(KeyListPtr keys,
                                             const GpgOperationCallback& cb) {
   RunGpgOperaAsync(
       [=](const DataObjectPtr& data_object) -> GpgError {
-        std::vector<gpgme_key_t> recipients(keys->size() + 1);
-
+        std::vector<gpgme_key_t> recipients;
         for (const auto& key : *keys) {
           recipients.emplace_back(key);
         }
diff --git a/src/core/function/gpg/GpgKeyGetter.cpp b/src/core/function/gpg/GpgKeyGetter.cpp
index 8ce3c4fa..de8895d9 100644
--- a/src/core/function/gpg/GpgKeyGetter.cpp
+++ b/src/core/function/gpg/GpgKeyGetter.cpp
@@ -76,13 +76,18 @@ class GpgKeyGetter::Impl : public SingletonFunctionObject<GpgKeyGetter::Impl> {
   }
 
   auto FetchKey() -> KeyLinkListPtr {
-    // get the lock
-    std::lock_guard<std::mutex> lock(keys_cache_mutex_);
+    if (keys_cache_.empty()) {
+      FlushKeyCache();
+    }
 
     auto keys_list = std::make_unique<GpgKeyLinkList>();
 
-    for (const auto& [key, value] : keys_cache_) {
-      keys_list->push_back(value);
+    {
+      // get the lock
+      std::lock_guard<std::mutex> lock(keys_cache_mutex_);
+      for (const auto& [key, value] : keys_cache_) {
+        keys_list->push_back(value);
+      }
     }
     return keys_list;
   }
diff --git a/src/core/typedef/GpgTypedef.h b/src/core/typedef/GpgTypedef.h
index 377457a9..f4bd5401 100644
--- a/src/core/typedef/GpgTypedef.h
+++ b/src/core/typedef/GpgTypedef.h
@@ -28,6 +28,8 @@
 
 #pragma once
 
+#include <tuple>
+
 #include "core/model/DataObject.h"
 namespace GpgFrontend {
 
@@ -58,4 +60,5 @@ using KeyPtrArgsList = const std::initializer_list<KeyPtr>;               ///<
 
 using GpgOperaRunnable = std::function<GpgError(DataObjectPtr)>;
 using GpgOperationCallback = std::function<void(GpgError, DataObjectPtr)>;
+using GpgOperationFuture = std::future<std::tuple<GpgError, DataObjectPtr>>;
 }  // namespace GpgFrontend
\ No newline at end of file
diff --git a/src/core/utils/GpgUtils.cpp b/src/core/utils/GpgUtils.cpp
index ba8d8ba8..b9fa59bd 100644
--- a/src/core/utils/GpgUtils.cpp
+++ b/src/core/utils/GpgUtils.cpp
@@ -69,12 +69,13 @@ auto GetGpgmeErrorString(gpgme_error_t err) -> std::string {
 }
 
 auto CheckGpgError(GpgError err) -> GpgError {
-  if (gpg_err_code(err) != GPG_ERR_NO_ERROR) {
+  auto err_code = gpg_err_code(err);
+  if (err_code != GPG_ERR_NO_ERROR) {
     SPDLOG_ERROR(
         "gpg operation failed [error code: {}], source: {} description: {}",
-        gpg_err_code(err), gpgme_strsource(err), GetGpgmeErrorString(err));
+        err_code, gpgme_strsource(err), GetGpgmeErrorString(err));
   }
-  return err;
+  return err_code;
 }
 
 auto CheckGpgError2ErrCode(GpgError err, GpgError predict) -> GpgErrorCode {
diff --git a/src/test/GpgFrontendTest.cpp b/src/test/GpgFrontendTest.cpp
index b356a380..0cc2c45e 100644
--- a/src/test/GpgFrontendTest.cpp
+++ b/src/test/GpgFrontendTest.cpp
@@ -41,6 +41,8 @@
 #include "core/function/GlobalSettingStation.h"
 #include "core/function/basic/ChannelObject.h"
 #include "core/function/gpg/GpgContext.h"
+#include "core/function/gpg/GpgKeyImportExporter.h"
+#include "core/utils/IOUtils.h"
 #include "spdlog/spdlog.h"
 
 namespace GpgFrontend::Test {
@@ -121,8 +123,43 @@ void ConfigureGpgContext() {
       });
 }
 
+void ImportPrivateKeys(std::filesystem::path data_path,
+                       const libconfig::Setting& config) {
+  if (config.exists("load_keys.private_keys")) {
+    auto& private_keys = config.lookup("load_keys.private_keys");
+    for (auto& private_key : private_keys) {
+      if (private_key.exists("filename")) {
+        std::string filename;
+        private_key.lookupValue("filename", filename);
+        auto data_file_path = data_path / filename;
+        std::string data = ReadAllDataInFile(data_file_path.string());
+        auto secret_key_copy = SecureCreateSharedObject<std::string>(data);
+        GpgKeyImportExporter::GetInstance(kGpgFrontendDefaultChannel)
+            .ImportKey(secret_key_copy);
+      }
+    }
+  }
+}
+
+void SetupGlobalTestEnv() {
+  auto app_path = GlobalSettingStation::GetInstance().GetAppDir();
+  auto test_path = app_path / "test";
+  auto test_config_path = test_path / "conf" / "test.cfg";
+  auto test_data_path = test_path / "data";
+
+  SPDLOG_INFO("test config file path: {}", test_config_path.string());
+  SPDLOG_INFO("test data file path: {}", test_data_path.string());
+
+  libconfig::Config cfg;
+  ASSERT_NO_THROW(cfg.readFile(test_config_path.c_str()));
+
+  auto& root = cfg.getRoot();
+  ImportPrivateKeys(test_data_path, root);
+}
+
 auto ExecuteAllTestCase(GpgFrontendContext args) -> int {
   ConfigureGpgContext();
+  SetupGlobalTestEnv();
 
   testing::InitGoogleTest(&args.argc, args.argv);
   return RUN_ALL_TESTS();
diff --git a/src/test/core/GpgCoreTest.cpp b/src/test/core/GpgCoreTest.cpp
index b00e5c0e..1e33536f 100644
--- a/src/test/core/GpgCoreTest.cpp
+++ b/src/test/core/GpgCoreTest.cpp
@@ -35,29 +35,9 @@
 
 namespace GpgFrontend::Test {
 
-void GpgCoreTest::import_private_keys(const libconfig::Setting& root) {
-  if (root.exists("load_keys.private_keys")) {
-    auto& private_keys = root.lookup("load_keys.private_keys");
-    for (auto& private_key : private_keys) {
-      if (private_key.exists("filename")) {
-        std::string filename;
-        private_key.lookupValue("filename", filename);
-        auto data_file_path = data_path_ / filename;
-        std::string data = ReadAllDataInFile(data_file_path.string());
-        auto secret_key_copy = SecureCreateSharedObject<std::string>(data);
-        GpgKeyImportExporter::GetInstance(kGpgFrontendDefaultChannel)
-            .ImportKey(secret_key_copy);
-      }
-    }
-  }
-}
-
 void GpgCoreTest::TearDown() {}
 
 void GpgCoreTest::SetUp() {
-  // libconfig::Config cfg;
-  // ASSERT_NO_THROW(cfg.readFile(config_path_.string()));
-  // auto& root = cfg.getRoot();
-  // import_private_keys(root);
+
 }
 }  // namespace GpgFrontend::Test
diff --git a/src/test/core/GpgCoreTest.h b/src/test/core/GpgCoreTest.h
index 22504f5d..b436118a 100644
--- a/src/test/core/GpgCoreTest.h
+++ b/src/test/core/GpgCoreTest.h
@@ -28,17 +28,9 @@
 
 #pragma once
 
-#include <QtWidgets/qapplication.h>
 #include <gtest/gtest.h>
-#include <qcoreapplication.h>
 
 #include <boost/date_time.hpp>
-#include <boost/dll.hpp>
-#include <boost/dll/runtime_symbol_info.hpp>
-#include <filesystem>
-
-#include "core/function/GlobalSettingStation.h"
-#include "core/typedef/CoreTypedef.h"
 
 namespace GpgFrontend::Test {
 
@@ -47,18 +39,6 @@ class GpgCoreTest : public ::testing::Test {
   void SetUp() override;
 
   void TearDown() override;
-
- private:
-  void import_private_keys(const libconfig::Setting& root);
-
-  std::filesystem::path app_path_ = std::filesystem::path{
-      QCoreApplication::applicationDirPath().toStdString()};
-
-  // Configure File Location
-  std::filesystem::path config_path_ = app_path_ / "test" / "conf" / "core.cfg";
-
-  // Data File Directory Location
-  std::filesystem::path data_path_ = app_path_ / "test" / "data";
 };
 
 }  // namespace GpgFrontend::Test
\ No newline at end of file
diff --git a/src/test/core/GpgCoreTestBasicOpera.cpp b/src/test/core/GpgCoreTestBasicOpera.cpp
index 19af4918..d54b4f20 100644
--- a/src/test/core/GpgCoreTestBasicOpera.cpp
+++ b/src/test/core/GpgCoreTestBasicOpera.cpp
@@ -36,199 +36,197 @@
 
 namespace GpgFrontend::Test {
 
-// TEST_F(GpgCoreTest, CoreEncryptDecrTest) {
-//   auto encrypt_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
-//                          .GetPubkey("467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
-//   ByteArray encrypt_text = "Hello GpgFrontend!";
-//   KeyListPtr keys = std::make_unique<KeyArgsList>();
-//   keys->push_back(std::move(encrypt_key));
-//   GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
-//       .Encrypt(std::move(keys), encrypt_text,
-//                [](GpgError err, const DataObjectPtr&) {
-
-//                });
-
-//   //   ASSERT_EQ(e_result->invalid_recipients, nullptr);
-//   //   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
-
-//   //   GpgDecrResult d_result;
-//   //   ByteArrayPtr decr_out_data;
-//   //   err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
-//   //             .Decrypt(*encr_out_data, decr_out_data, d_result);
-//   //   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
-//   //   ASSERT_NE(d_result->recipients, nullptr);
-//   //   ASSERT_EQ(std::string(d_result->recipients->keyid),
-//   "F89C95A05088CC93");
-//   //   ASSERT_EQ(*decr_out_data, encrypt_text);
-//   // }
-
-//   // TEST_F(GpgCoreTest, CoreEncryptDecrTest_KeyNotFound_1) {
-//   //   ByteArrayPtr encr_out_data = std::make_unique<ByteArray>(
-//   //       "-----BEGIN PGP MESSAGE-----\n"
-//   //       "\n"
-//   // "hQEMA6UM/S9sZ32MAQf9Fb6gp6nvgKTQBv2mmjXia6ODXYq6kNeLsPVzLCbHyWOs\n"
-//   // "0GDED11R1NksA3EQxFf4fzLkDpbo68r5bWy7c28c99Fr68IRET19Tw6Gu65MQezD\n"
-//   // "Rdzo1oVqmK9sfKqOT3+0S2H+suFYw5kfBztMZLVGGl9R9fOXdKcj0fqGs2br3e9D\n"
-//   // "ArBFqq07Bae2DD1J8mckWB2x9Uem4vjRiY+vEJcEdAS1N5xu1n7qzzyDgcRcS34X\n"
-//   // "PNBQeTrFMc2RS7mnip2DbyZVEjORobhguK6xZyqXXbvFacStGWDLptV3dcCn4JRO\n"
-//   // "dIORyt5wugqAtgE4qEGTvr/pJ/oXPw4Wve/trece/9I/AR38vW8ntVmDa/hV75iZ\n"
-//   // "4QGAhQ8grD4kq31GHXHUOmBX51XXW9SINmplC8elEx3R460EUZJjjb0OvTih+eZH\n"
-//   //       "=8n2H\n"
-//   //       "-----END PGP MESSAGE-----");
-
-//   //   GpgDecrResult d_result;
-//   //   ByteArrayPtr decr_out_data;
-//   //   auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
-//   //                  .Decrypt(*encr_out_data, decr_out_data, d_result);
-//   //   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_SECKEY);
-//   //   ASSERT_NE(d_result->recipients, nullptr);
-//   //   ASSERT_EQ(std::string(d_result->recipients->keyid),
-//   "A50CFD2F6C677D8C");
-// }
-
-// TEST_F(GpgCoreTest, CoreEncryptDecrTest_KeyNotFound_ResultAnalyse) {
-//   // ByteArrayPtr encr_out_data = std::make_unique<ByteArray>(
-//   //     "-----BEGIN PGP MESSAGE-----\n"
-//   //     "\n"
-//   //     "hQEMA6UM/S9sZ32MAQf9Fb6gp6nvgKTQBv2mmjXia6ODXYq6kNeLsPVzLCbHyWOs\n"
-//   //     "0GDED11R1NksA3EQxFf4fzLkDpbo68r5bWy7c28c99Fr68IRET19Tw6Gu65MQezD\n"
-//   //     "Rdzo1oVqmK9sfKqOT3+0S2H+suFYw5kfBztMZLVGGl9R9fOXdKcj0fqGs2br3e9D\n"
-//   //     "ArBFqq07Bae2DD1J8mckWB2x9Uem4vjRiY+vEJcEdAS1N5xu1n7qzzyDgcRcS34X\n"
-//   //     "PNBQeTrFMc2RS7mnip2DbyZVEjORobhguK6xZyqXXbvFacStGWDLptV3dcCn4JRO\n"
-//   //     "dIORyt5wugqAtgE4qEGTvr/pJ/oXPw4Wve/trece/9I/AR38vW8ntVmDa/hV75iZ\n"
-//   //     "4QGAhQ8grD4kq31GHXHUOmBX51XXW9SINmplC8elEx3R460EUZJjjb0OvTih+eZH\n"
-//   //     "=8n2H\n"
-//   //     "-----END PGP MESSAGE-----");
-
-//   // GpgDecrResult d_result;
-//   // ByteArrayPtr decr_out_data;
-//   // auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
-//   //                .Decrypt(*encr_out_data, decr_out_data, d_result);
-//   // ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_SECKEY);
-//   // ASSERT_NE(d_result->recipients, nullptr);
-//   // ASSERT_EQ(std::string(d_result->recipients->keyid), "A50CFD2F6C677D8C");
-
-//   // GpgDecryptResultAnalyse analyse{err, d_result};
-//   // analyse.Analyse();
-//   // ASSERT_EQ(analyse.GetStatus(), -1);
-//   // ASSERT_FALSE(analyse.GetResultReport().empty());
-// }
-
-// TEST_F(GpgCoreTest, CoreSignVerifyNormalTest) {
-//   // auto encrypt_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
-//   // .GetPubkey("467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
-//   // ByteArray sign_text = "Hello GpgFrontend!";
-//   // ByteArrayPtr sign_out_data;
-//   // GpgSignResult s_result;
-//   // KeyListPtr keys = std::make_unique<KeyArgsList>();
-//   // keys->push_back(std::move(encrypt_key));
-//   // auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
-//   //                .Sign(std::move(keys), sign_text, sign_out_data,
-//   //                      GPGME_SIG_MODE_NORMAL, s_result);
-//   // ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
-//   // ASSERT_EQ(s_result->invalid_signers, nullptr);
-
-//   // GpgVerifyResult v_result;
-//   // ByteArrayPtr sign_buff = nullptr;
-//   // err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
-//   //           .Verify(*sign_out_data, sign_buff, v_result);
-//   // ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
-//   // ASSERT_NE(v_result->signatures, nullptr);
-//   // ASSERT_EQ(std::string(v_result->signatures->fpr),
-//   //           "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
-//   // ASSERT_EQ(v_result->signatures->next, nullptr);
-// }
-
-// TEST_F(GpgCoreTest, CoreSignVerifyDetachTest) {
-//   // auto encrypt_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
-//   // .GetPubkey("467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
-//   // ByteArray sign_text = "Hello GpgFrontend!";
-//   // ByteArrayPtr sign_out_data;
-//   // GpgSignResult s_result;
-//   // KeyListPtr keys = std::make_unique<KeyArgsList>();
-//   // keys->push_back(std::move(encrypt_key));
-//   // auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
-//   //                .Sign(std::move(keys), sign_text, sign_out_data,
-//   //                      GPGME_SIG_MODE_DETACH, s_result);
-//   // ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
-//   // ASSERT_EQ(s_result->invalid_signers, nullptr);
-
-//   // GpgVerifyResult v_result;
-//   // err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
-//   //           .Verify(sign_text, sign_out_data, v_result);
-//   // ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
-//   // ASSERT_NE(v_result->signatures, nullptr);
-//   // ASSERT_EQ(std::string(v_result->signatures->fpr),
-//   //           "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
-//   // ASSERT_EQ(v_result->signatures->next, nullptr);
-// }
-
-// TEST_F(GpgCoreTest, CoreSignVerifyClearTest) {
-//   // auto sign_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
-//   //                     .GetKey("467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
-//   // ByteArray sign_text = "Hello GpgFrontend!";
-//   // ByteArrayPtr sign_out_data;
-//   // GpgSignResult s_result;
-//   // KeyListPtr keys = std::make_unique<KeyArgsList>();
-//   // keys->push_back(std::move(sign_key));
-//   // auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
-//   //                .Sign(std::move(keys), sign_text, sign_out_data,
-//   //                      GPGME_SIG_MODE_CLEAR, s_result);
-//   // ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
-//   // ASSERT_EQ(s_result->invalid_signers, nullptr);
-
-//   // GpgVerifyResult v_result;
-//   // ByteArrayPtr sign_buff = nullptr;
-//   // err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
-//   //           .Verify(*sign_out_data, sign_buff, v_result);
-//   // ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
-//   // ASSERT_NE(v_result->signatures, nullptr);
-//   // ASSERT_EQ(std::string(v_result->signatures->fpr),
-//   //           "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
-//   // ASSERT_EQ(v_result->signatures->next, nullptr);
-// }
-
-// TEST_F(GpgCoreTest, CoreEncryptSignDecrVerifyTest) {
-//   // auto encrypt_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
-//   // .GetPubkey("467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
-//   // auto sign_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
-//   //                     .GetKey("8933EB283A18995F45D61DAC021D89771B680FFB");
-//   // //   Question?
-//   // //   ASSERT_FALSE(encrypt_key.is_private_key());
-//   // ASSERT_TRUE(sign_key.IsPrivateKey());
-//   // ASSERT_TRUE(sign_key.IsHasActualSigningCapability());
-//   // ByteArray encrypt_text = "Hello GpgFrontend!";
-//   // ByteArrayPtr encr_out_data;
-//   // GpgEncrResult e_result;
-//   // GpgSignResult s_result;
-
-//   // KeyListPtr keys = std::make_unique<KeyArgsList>(),
-//   //            sign_keys = std::make_unique<KeyArgsList>();
-//   // keys->push_back(std::move(encrypt_key));
-//   // sign_keys->push_back(std::move(sign_key));
-
-//   // auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
-//   //                .EncryptSign(std::move(keys), std::move(sign_keys),
-//   //                             encrypt_text, encr_out_data, e_result,
-//   //                             s_result);
-//   // ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
-//   // ASSERT_EQ(e_result->invalid_recipients, nullptr);
-//   // ASSERT_EQ(s_result->invalid_signers, nullptr);
-
-//   // GpgDecrResult d_result;
-//   // GpgVerifyResult v_result;
-//   // ByteArrayPtr decr_out_data = nullptr;
-//   // err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
-//   //           .DecryptVerify(*encr_out_data, decr_out_data, d_result,
-//   //           v_result);
-//   // ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
-//   // ASSERT_NE(d_result->recipients, nullptr);
-//   // ASSERT_EQ(std::string(d_result->recipients->keyid), "F89C95A05088CC93");
-//   // ASSERT_EQ(*decr_out_data, encrypt_text);
-//   // ASSERT_NE(v_result->signatures, nullptr);
-//   // ASSERT_EQ(std::string(v_result->signatures->fpr),
-//   //           "8933EB283A18995F45D61DAC021D89771B680FFB");
-//   // ASSERT_EQ(v_result->signatures->next, nullptr);
-// }
+TEST_F(GpgCoreTest, CoreEncryptDecrTest) {
+  auto encrypt_key = GpgKeyGetter::GetInstance().GetPubkey(
+      "E87C6A2D8D95C818DE93B3AE6A2764F8298DEB29");
+  ByteArray encrypt_text = "Hello GpgFrontend!";
+  KeyListPtr keys = std::make_unique<KeyArgsList>();
+  keys->push_back(std::move(encrypt_key));
+
+  GpgBasicOperator::GetInstance().Encrypt(
+      keys, encrypt_text,
+      [encrypt_text](GpgError err, const DataObjectPtr& data_obj) {
+        auto result = ExtractParams<GpgEncrResult>(data_obj, 0);
+        auto encr_out_buffer = ExtractParams<ByteArrayPtr>(data_obj, 1);
+        ASSERT_EQ(result->invalid_recipients, nullptr);
+        ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+
+        GpgDecrResult d_result;
+        ByteArrayPtr decr_out_data;
+        err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
+                  .Decrypt(*encr_out_buffer, decr_out_data, d_result);
+        ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+        ASSERT_NE(d_result->recipients, nullptr);
+        ASSERT_EQ(std::string(d_result->recipients->keyid), "6A2764F8298DEB29");
+        ASSERT_EQ(*decr_out_data, encrypt_text);
+      });
+}
+
+TEST_F(GpgCoreTest, CoreEncryptDecrTest_KeyNotFound_1) {
+  ByteArrayPtr encr_out_data = std::make_unique<ByteArray>(
+      "-----BEGIN PGP MESSAGE-----\n"
+      "\n"
+      "hQEMA6UM/S9sZ32MAQf9Fb6gp6nvgKTQBv2mmjXia6ODXYq6kNeLsPVzLCbHyWOs\n"
+      "0GDED11R1NksA3EQxFf4fzLkDpbo68r5bWy7c28c99Fr68IRET19Tw6Gu65MQezD\n"
+      "Rdzo1oVqmK9sfKqOT3+0S2H+suFYw5kfBztMZLVGGl9R9fOXdKcj0fqGs2br3e9D\n"
+      "ArBFqq07Bae2DD1J8mckWB2x9Uem4vjRiY+vEJcEdAS1N5xu1n7qzzyDgcRcS34X\n"
+      "PNBQeTrFMc2RS7mnip2DbyZVEjORobhguK6xZyqXXbvFacStGWDLptV3dcCn4JRO\n"
+      "dIORyt5wugqAtgE4qEGTvr/pJ/oXPw4Wve/trece/9I/AR38vW8ntVmDa/hV75iZ\n"
+      "4QGAhQ8grD4kq31GHXHUOmBX51XXW9SINmplC8elEx3R460EUZJjjb0OvTih+eZH\n"
+      "=8n2H\n"
+      "-----END PGP MESSAGE-----");
+
+  GpgDecrResult d_result;
+  ByteArrayPtr decr_out_data;
+  auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
+                 .Decrypt(*encr_out_data, decr_out_data, d_result);
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_SECKEY);
+  ASSERT_NE(d_result->recipients, nullptr);
+  ASSERT_EQ(std::string(d_result->recipients->keyid), "A50CFD2F6C677D8C");
+}
+
+TEST_F(GpgCoreTest, CoreEncryptDecrTest_KeyNotFound_ResultAnalyse) {
+  ByteArrayPtr encr_out_data = std::make_unique<ByteArray>(
+      "-----BEGIN PGP MESSAGE-----\n"
+      "\n"
+      "hQEMA6UM/S9sZ32MAQf9Fb6gp6nvgKTQBv2mmjXia6ODXYq6kNeLsPVzLCbHyWOs\n"
+      "0GDED11R1NksA3EQxFf4fzLkDpbo68r5bWy7c28c99Fr68IRET19Tw6Gu65MQezD\n"
+      "Rdzo1oVqmK9sfKqOT3+0S2H+suFYw5kfBztMZLVGGl9R9fOXdKcj0fqGs2br3e9D\n"
+      "ArBFqq07Bae2DD1J8mckWB2x9Uem4vjRiY+vEJcEdAS1N5xu1n7qzzyDgcRcS34X\n"
+      "PNBQeTrFMc2RS7mnip2DbyZVEjORobhguK6xZyqXXbvFacStGWDLptV3dcCn4JRO\n"
+      "dIORyt5wugqAtgE4qEGTvr/pJ/oXPw4Wve/trece/9I/AR38vW8ntVmDa/hV75iZ\n"
+      "4QGAhQ8grD4kq31GHXHUOmBX51XXW9SINmplC8elEx3R460EUZJjjb0OvTih+eZH\n"
+      "=8n2H\n"
+      "-----END PGP MESSAGE-----");
+
+  GpgDecrResult d_result;
+  ByteArrayPtr decr_out_data;
+  auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
+                 .Decrypt(*encr_out_data, decr_out_data, d_result);
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_SECKEY);
+  ASSERT_NE(d_result->recipients, nullptr);
+  ASSERT_EQ(std::string(d_result->recipients->keyid), "A50CFD2F6C677D8C");
+
+  GpgDecryptResultAnalyse analyse{err, d_result};
+  analyse.Analyse();
+  ASSERT_EQ(analyse.GetStatus(), -1);
+  ASSERT_FALSE(analyse.GetResultReport().empty());
+}
+
+TEST_F(GpgCoreTest, CoreSignVerifyNormalTest) {
+  auto encrypt_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                         .GetPubkey("467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
+  ByteArray sign_text = "Hello GpgFrontend!";
+  ByteArrayPtr sign_out_data;
+  GpgSignResult s_result;
+  KeyListPtr keys = std::make_unique<KeyArgsList>();
+  keys->push_back(std::move(encrypt_key));
+  auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
+                 .Sign(std::move(keys), sign_text, sign_out_data,
+                       GPGME_SIG_MODE_NORMAL, s_result);
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_EQ(s_result->invalid_signers, nullptr);
+
+  GpgVerifyResult v_result;
+  ByteArrayPtr sign_buff = nullptr;
+  err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
+            .Verify(*sign_out_data, sign_buff, v_result);
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_NE(v_result->signatures, nullptr);
+  ASSERT_EQ(std::string(v_result->signatures->fpr),
+            "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
+  ASSERT_EQ(v_result->signatures->next, nullptr);
+}
+
+TEST_F(GpgCoreTest, CoreSignVerifyDetachTest) {
+  auto encrypt_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                         .GetPubkey("467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
+  ByteArray sign_text = "Hello GpgFrontend!";
+  ByteArrayPtr sign_out_data;
+  GpgSignResult s_result;
+  KeyListPtr keys = std::make_unique<KeyArgsList>();
+  keys->push_back(std::move(encrypt_key));
+  auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
+                 .Sign(std::move(keys), sign_text, sign_out_data,
+                       GPGME_SIG_MODE_DETACH, s_result);
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_EQ(s_result->invalid_signers, nullptr);
+
+  GpgVerifyResult v_result;
+  err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
+            .Verify(sign_text, sign_out_data, v_result);
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_NE(v_result->signatures, nullptr);
+  ASSERT_EQ(std::string(v_result->signatures->fpr),
+            "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
+  ASSERT_EQ(v_result->signatures->next, nullptr);
+}
+
+TEST_F(GpgCoreTest, CoreSignVerifyClearTest) {
+  auto sign_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                      .GetKey("467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
+  ByteArray sign_text = "Hello GpgFrontend!";
+  ByteArrayPtr sign_out_data;
+  GpgSignResult s_result;
+  KeyListPtr keys = std::make_unique<KeyArgsList>();
+  keys->push_back(std::move(sign_key));
+  auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
+                 .Sign(std::move(keys), sign_text, sign_out_data,
+                       GPGME_SIG_MODE_CLEAR, s_result);
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_EQ(s_result->invalid_signers, nullptr);
+
+  GpgVerifyResult v_result;
+  ByteArrayPtr sign_buff = nullptr;
+  err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
+            .Verify(*sign_out_data, sign_buff, v_result);
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_NE(v_result->signatures, nullptr);
+  ASSERT_EQ(std::string(v_result->signatures->fpr),
+            "467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
+  ASSERT_EQ(v_result->signatures->next, nullptr);
+}
+
+TEST_F(GpgCoreTest, CoreEncryptSignDecrVerifyTest) {
+  auto encrypt_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                         .GetPubkey("467F14220CE8DCF780CF4BAD8465C55B25C9B7D1");
+  auto sign_key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                      .GetKey("8933EB283A18995F45D61DAC021D89771B680FFB");
+  //   Question?
+  //   ASSERT_FALSE(encrypt_key.is_private_key());
+  ASSERT_TRUE(sign_key.IsPrivateKey());
+  ASSERT_TRUE(sign_key.IsHasActualSigningCapability());
+  ByteArray encrypt_text = "Hello GpgFrontend!";
+  ByteArrayPtr encr_out_data;
+  GpgEncrResult e_result;
+  GpgSignResult s_result;
+
+  KeyListPtr keys = std::make_unique<KeyArgsList>();
+  KeyListPtr sign_keys = std::make_unique<KeyArgsList>();
+
+  keys->push_back(std::move(encrypt_key));
+  sign_keys->push_back(std::move(sign_key));
+
+  auto err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
+                 .EncryptSign(std::move(keys), std::move(sign_keys),
+                              encrypt_text, encr_out_data, e_result, s_result);
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_EQ(e_result->invalid_recipients, nullptr);
+  ASSERT_EQ(s_result->invalid_signers, nullptr);
+
+  GpgDecrResult d_result;
+  GpgVerifyResult v_result;
+  ByteArrayPtr decr_out_data = nullptr;
+  err = GpgBasicOperator::GetInstance(kGpgFrontendDefaultChannel)
+            .DecryptVerify(*encr_out_data, decr_out_data, d_result, v_result);
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_NE(d_result->recipients, nullptr);
+  ASSERT_EQ(std::string(d_result->recipients->keyid), "F89C95A05088CC93");
+  ASSERT_EQ(*decr_out_data, encrypt_text);
+  ASSERT_NE(v_result->signatures, nullptr);
+  ASSERT_EQ(std::string(v_result->signatures->fpr),
+            "8933EB283A18995F45D61DAC021D89771B680FFB");
+  ASSERT_EQ(v_result->signatures->next, nullptr);
+}
 
 }  // namespace GpgFrontend::Test
diff --git a/src/test/core/GpgCoreTestKeyModel.cpp b/src/test/core/GpgCoreTestKeyModel.cpp
index 7e31ea62..3618bcb9 100644
--- a/src/test/core/GpgCoreTestKeyModel.cpp
+++ b/src/test/core/GpgCoreTestKeyModel.cpp
@@ -26,6 +26,8 @@
  *
  */
 
+#include <gtest/gtest.h>
+
 #include "GpgCoreTest.h"
 #include "core/function/gpg/GpgContext.h"
 #include "core/function/gpg/GpgKeyGetter.h"
@@ -35,147 +37,146 @@
 
 namespace GpgFrontend::Test {
 
-// TEST_F(GpgCoreTest, CoreInitTest) {
-//   auto& ctx = GpgContext::GetInstance(kGpgFrontendDefaultChannel);
-//   auto& ctx_default = GpgContext::GetInstance();
-//   ASSERT_TRUE(ctx.Good());
-//   ASSERT_TRUE(ctx_default.Good());
-// }
-
-// TEST_F(GpgCoreTest, GpgDataTest) {
-//   auto data_buff = std::string(
-//       "cqEh8fyKWtmiXrW2zzlszJVGJrpXDDpzgP7ZELGxhfZYFi8rMrSVKDwrpFZBSWMG");
-
-//   GpgData data(data_buff.data(), data_buff.size());
-
-//   auto out_buffer = data.Read2Buffer();
-//   ASSERT_EQ(out_buffer->size(), 64);
-// }
-
-// TEST_F(GpgCoreTest, GpgKeyTest) {
-//   auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
-//                  .GetKey("9490795B78F8AFE9F93BD09281704859182661FB");
-//   ASSERT_TRUE(key.IsGood());
-//   ASSERT_TRUE(key.IsPrivateKey());
-//   ASSERT_TRUE(key.IsHasMasterKey());
-
-//   ASSERT_FALSE(key.IsDisabled());
-//   ASSERT_FALSE(key.IsRevoked());
-
-//   ASSERT_EQ(key.GetProtocol(), "OpenPGP");
-
-//   ASSERT_EQ(key.GetSubKeys()->size(), 2);
-//   ASSERT_EQ(key.GetUIDs()->size(), 1);
-
-//   ASSERT_TRUE(key.IsHasCertificationCapability());
-//   ASSERT_TRUE(key.IsHasEncryptionCapability());
-//   ASSERT_TRUE(key.IsHasSigningCapability());
-//   ASSERT_FALSE(key.IsHasAuthenticationCapability());
-//   ASSERT_TRUE(key.IsHasActualCertificationCapability());
-//   ASSERT_TRUE(key.IsHasActualEncryptionCapability());
-//   ASSERT_TRUE(key.IsHasActualSigningCapability());
-//   ASSERT_FALSE(key.IsHasActualAuthenticationCapability());
-
-//   ASSERT_EQ(key.GetName(), "GpgFrontendTest");
-//   ASSERT_TRUE(key.GetComment().empty());
-//   ASSERT_EQ(key.GetEmail(), "[email protected]");
-//   ASSERT_EQ(key.GetId(), "81704859182661FB");
-//   ASSERT_EQ(key.GetFingerprint(),
-//   "9490795B78F8AFE9F93BD09281704859182661FB"); ASSERT_EQ(key.GetExpireTime(),
-//             boost::posix_time::from_iso_string("20230905T040000"));
-//   ASSERT_EQ(key.GetPublicKeyAlgo(), "RSA");
-//   ASSERT_EQ(key.GetPrimaryKeyLength(), 3072);
-//   ASSERT_EQ(key.GetLastUpdateTime(),
-//             boost::posix_time::from_iso_string("19700101T000000"));
-//   ASSERT_EQ(key.GetCreateTime(),
-//             boost::posix_time::from_iso_string("20210905T060153"));
-
-//   ASSERT_EQ(key.GetOwnerTrust(), "Unknown");
-
-//   ASSERT_EQ(key.IsExpired(), key.GetExpireTime() <
-//                                  boost::posix_time::second_clock::local_time());
-// }
-
-// TEST_F(GpgCoreTest, GpgSubKeyTest) {
-//   auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
-//                  .GetKey("9490795B78F8AFE9F93BD09281704859182661FB");
-//   auto sub_keys = key.GetSubKeys();
-//   ASSERT_EQ(sub_keys->size(), 2);
-
-//   auto& sub_key = sub_keys->back();
-
-//   ASSERT_FALSE(sub_key.IsRevoked());
-//   ASSERT_FALSE(sub_key.IsDisabled());
-//   ASSERT_EQ(sub_key.GetCreateTime(),
-//             boost::posix_time::from_iso_string("20210905T060153"));
-
-//   ASSERT_FALSE(sub_key.IsCardKey());
-//   ASSERT_TRUE(sub_key.IsPrivateKey());
-//   ASSERT_EQ(sub_key.GetID(), "2B36803235B5E25B");
-//   ASSERT_EQ(sub_key.GetFingerprint(),
-//             "50D37E8F8EE7340A6794E0592B36803235B5E25B");
-//   ASSERT_EQ(sub_key.GetKeyLength(), 3072);
-//   ASSERT_EQ(sub_key.GetPubkeyAlgo(), "RSA");
-//   ASSERT_FALSE(sub_key.IsHasCertificationCapability());
-//   ASSERT_FALSE(sub_key.IsHasAuthenticationCapability());
-//   ASSERT_FALSE(sub_key.IsHasSigningCapability());
-//   ASSERT_TRUE(sub_key.IsHasEncryptionCapability());
-//   ASSERT_EQ(key.GetExpireTime(),
-//             boost::posix_time::from_iso_string("20230905T040000"));
-
-//   ASSERT_EQ(
-//       sub_key.IsExpired(),
-//       sub_key.GetExpireTime() <
-//       boost::posix_time::second_clock::local_time());
-// }
-
-// TEST_F(GpgCoreTest, GpgUIDTest) {
-//   auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
-//                  .GetKey("9490795B78F8AFE9F93BD09281704859182661FB");
-//   auto uids = key.GetUIDs();
-//   ASSERT_EQ(uids->size(), 1);
-//   auto& uid = uids->front();
-
-//   ASSERT_EQ(uid.GetName(), "GpgFrontendTest");
-//   ASSERT_TRUE(uid.GetComment().empty());
-//   ASSERT_EQ(uid.GetEmail(), "[email protected]");
-//   ASSERT_EQ(uid.GetUID(),
-//             "GpgFrontendTest <[email protected]>");
-//   ASSERT_FALSE(uid.GetInvalid());
-//   ASSERT_FALSE(uid.GetRevoked());
-// }
-
-// TEST_F(GpgCoreTest, GpgKeySignatureTest) {
-//   auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
-//                  .GetKey("9490795B78F8AFE9F93BD09281704859182661FB");
-//   auto uids = key.GetUIDs();
-//   ASSERT_EQ(uids->size(), 1);
-//   auto& uid = uids->front();
-
-//   auto signatures = uid.GetSignatures();
-//   ASSERT_EQ(signatures->size(), 1);
-//   auto& signature = signatures->front();
-
-//   ASSERT_EQ(signature.GetName(), "GpgFrontendTest");
-//   ASSERT_TRUE(signature.GetComment().empty());
-//   ASSERT_EQ(signature.GetEmail(), "[email protected]");
-//   ASSERT_EQ(signature.GetKeyID(), "81704859182661FB");
-//   ASSERT_EQ(signature.GetPubkeyAlgo(), "RSA");
-
-//   ASSERT_FALSE(signature.IsRevoked());
-//   ASSERT_FALSE(signature.IsInvalid());
-//   ASSERT_EQ(CheckGpgError(signature.GetStatus()), GPG_ERR_NO_ERROR);
-//   ASSERT_EQ(signature.GetUID(),
-//             "GpgFrontendTest <[email protected]>");
-// }
-
-// TEST_F(GpgCoreTest, GpgKeyGetterTest) {
-//   auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
-//                  .GetKey("9490795B78F8AFE9F93BD09281704859182661FB");
-//   ASSERT_TRUE(key.IsGood());
-//   auto keys =
-//   GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).FetchKey();
-//   ASSERT_TRUE(find(keys->begin(), keys->end(), key) != keys->end());
-// }
+TEST_F(GpgCoreTest, CoreInitTest) {
+  auto& ctx = GpgContext::GetInstance(kGpgFrontendDefaultChannel);
+  auto& ctx_default = GpgContext::GetInstance();
+  ASSERT_TRUE(ctx.Good());
+  ASSERT_TRUE(ctx_default.Good());
+}
+
+TEST_F(GpgCoreTest, GpgDataTest) {
+  auto data_buff = std::string(
+      "cqEh8fyKWtmiXrW2zzlszJVGJrpXDDpzgP7ZELGxhfZYFi8rMrSVKDwrpFZBSWMG");
+
+  GpgData data(data_buff.data(), data_buff.size());
+
+  auto out_buffer = data.Read2Buffer();
+  ASSERT_EQ(out_buffer->size(), 64);
+}
+
+TEST_F(GpgCoreTest, GpgKeyTest) {
+  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                 .GetKey("9490795B78F8AFE9F93BD09281704859182661FB");
+  ASSERT_TRUE(key.IsGood());
+  ASSERT_TRUE(key.IsPrivateKey());
+  ASSERT_TRUE(key.IsHasMasterKey());
+
+  ASSERT_FALSE(key.IsDisabled());
+  ASSERT_FALSE(key.IsRevoked());
+
+  ASSERT_EQ(key.GetProtocol(), "OpenPGP");
+
+  ASSERT_EQ(key.GetSubKeys()->size(), 2);
+  ASSERT_EQ(key.GetUIDs()->size(), 1);
+
+  ASSERT_TRUE(key.IsHasCertificationCapability());
+  ASSERT_FALSE(key.IsHasEncryptionCapability());
+  ASSERT_TRUE(key.IsHasSigningCapability());
+  ASSERT_FALSE(key.IsHasAuthenticationCapability());
+  ASSERT_FALSE(key.IsHasActualCertificationCapability());
+  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
+  ASSERT_FALSE(key.IsHasActualSigningCapability());
+  ASSERT_FALSE(key.IsHasActualAuthenticationCapability());
+
+  ASSERT_EQ(key.GetName(), "GpgFrontendTest");
+  ASSERT_TRUE(key.GetComment().empty());
+  ASSERT_EQ(key.GetEmail(), "[email protected]");
+  ASSERT_EQ(key.GetId(), "81704859182661FB");
+  ASSERT_EQ(key.GetFingerprint(), "9490795B78F8AFE9F93BD09281704859182661FB");
+  ASSERT_EQ(key.GetExpireTime(),
+            boost::posix_time::from_iso_string("20230905T040000"));
+  ASSERT_EQ(key.GetPublicKeyAlgo(), "RSA");
+  ASSERT_EQ(key.GetPrimaryKeyLength(), 3072);
+  ASSERT_EQ(key.GetLastUpdateTime(),
+            boost::posix_time::from_iso_string("19700101T000000"));
+  ASSERT_EQ(key.GetCreateTime(),
+            boost::posix_time::from_iso_string("20210905T060153"));
+
+  ASSERT_EQ(key.GetOwnerTrust(), "Unknown");
+
+  ASSERT_EQ(key.IsExpired(), key.GetExpireTime() <
+                                 boost::posix_time::second_clock::local_time());
+}
+
+TEST_F(GpgCoreTest, GpgSubKeyTest) {
+  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                 .GetKey("9490795B78F8AFE9F93BD09281704859182661FB");
+  auto sub_keys = key.GetSubKeys();
+  ASSERT_EQ(sub_keys->size(), 2);
+
+  auto& sub_key = sub_keys->back();
+
+  ASSERT_FALSE(sub_key.IsRevoked());
+  ASSERT_FALSE(sub_key.IsDisabled());
+  ASSERT_EQ(sub_key.GetCreateTime(),
+            boost::posix_time::from_iso_string("20210905T060153"));
+
+  ASSERT_FALSE(sub_key.IsCardKey());
+  ASSERT_TRUE(sub_key.IsPrivateKey());
+  ASSERT_EQ(sub_key.GetID(), "2B36803235B5E25B");
+  ASSERT_EQ(sub_key.GetFingerprint(),
+            "50D37E8F8EE7340A6794E0592B36803235B5E25B");
+  ASSERT_EQ(sub_key.GetKeyLength(), 3072);
+  ASSERT_EQ(sub_key.GetPubkeyAlgo(), "RSA");
+  ASSERT_FALSE(sub_key.IsHasCertificationCapability());
+  ASSERT_FALSE(sub_key.IsHasAuthenticationCapability());
+  ASSERT_FALSE(sub_key.IsHasSigningCapability());
+  ASSERT_TRUE(sub_key.IsHasEncryptionCapability());
+  ASSERT_EQ(key.GetExpireTime(),
+            boost::posix_time::from_iso_string("20230905T040000"));
+
+  ASSERT_EQ(
+      sub_key.IsExpired(),
+      sub_key.GetExpireTime() < boost::posix_time::second_clock::local_time());
+}
+
+TEST_F(GpgCoreTest, GpgUIDTest) {
+  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                 .GetKey("9490795B78F8AFE9F93BD09281704859182661FB");
+  auto uids = key.GetUIDs();
+  ASSERT_EQ(uids->size(), 1);
+  auto& uid = uids->front();
+
+  ASSERT_EQ(uid.GetName(), "GpgFrontendTest");
+  ASSERT_TRUE(uid.GetComment().empty());
+  ASSERT_EQ(uid.GetEmail(), "[email protected]");
+  ASSERT_EQ(uid.GetUID(), "GpgFrontendTest <[email protected]>");
+  ASSERT_FALSE(uid.GetInvalid());
+  ASSERT_FALSE(uid.GetRevoked());
+}
+
+TEST_F(GpgCoreTest, GpgKeySignatureTest) {
+  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                 .GetKey("9490795B78F8AFE9F93BD09281704859182661FB");
+  auto uids = key.GetUIDs();
+  ASSERT_EQ(uids->size(), 1);
+  auto& uid = uids->front();
+
+  auto signatures = uid.GetSignatures();
+  ASSERT_EQ(signatures->size(), 1);
+  auto& signature = signatures->front();
+
+  ASSERT_EQ(signature.GetName(), "GpgFrontendTest");
+  ASSERT_TRUE(signature.GetComment().empty());
+  ASSERT_EQ(signature.GetEmail(), "[email protected]");
+  ASSERT_EQ(signature.GetKeyID(), "81704859182661FB");
+  ASSERT_EQ(signature.GetPubkeyAlgo(), "RSA");
+
+  ASSERT_FALSE(signature.IsRevoked());
+  ASSERT_FALSE(signature.IsInvalid());
+  ASSERT_EQ(CheckGpgError(signature.GetStatus()), GPG_ERR_NO_ERROR);
+  ASSERT_EQ(signature.GetUID(),
+            "GpgFrontendTest <[email protected]>");
+}
+
+TEST_F(GpgCoreTest, GpgKeyGetterTest) {
+  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                 .GetKey("9490795B78F8AFE9F93BD09281704859182661FB");
+  ASSERT_TRUE(key.IsGood());
+  auto keys = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).FetchKey();
+
+  EXPECT_GT(keys->size(), 0);
+  ASSERT_TRUE(find(keys->begin(), keys->end(), key) != keys->end());
+}
 
 }  // namespace GpgFrontend::Test
\ No newline at end of file
diff --git a/src/test/core/GpgCoreTestKeygen.cpp b/src/test/core/GpgCoreTestKeygen.cpp
index 5d0d30ad..aab400cb 100644
--- a/src/test/core/GpgCoreTestKeygen.cpp
+++ b/src/test/core/GpgCoreTestKeygen.cpp
@@ -26,6 +26,8 @@
  *
  */
 
+#include <qeventloop.h>
+
 #include "GpgCoreTest.h"
 #include "core/function/gpg/GpgKeyGetter.h"
 #include "core/function/gpg/GpgKeyOpera.h"
@@ -33,106 +35,160 @@
 #include "core/model/GpgGenKeyInfo.h"
 #include "core/model/GpgKey.h"
 #include "core/utils/GpgUtils.h"
+#include "core/utils/MemoryUtils.h"
 
 namespace GpgFrontend::Test {
 
-// TEST_F(GpgCoreTest, GenerateKeyTest) {
-//   auto& key_opera = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel);
-//   auto keygen_info = std::make_unique<GenKeyInfo>();
-//   keygen_info->SetName("foo");
-//   keygen_info->SetEmail("[email protected]");
-//   keygen_info->SetComment("");
-//   keygen_info->SetKeyLength(1024);
-//   keygen_info->SetAlgo(keygen_info->GetSupportedKeyAlgo()[0]);
-//   keygen_info->SetNonExpired(true);
-//   keygen_info->SetNonPassPhrase(true);
-
-//   GpgGenKeyResult result = nullptr;
-//   // auto err = CheckGpgError(key_opera.GenerateKey(keygen_info, result));
-//   // ASSERT_EQ(err, GPG_ERR_NO_ERROR);
-
-//   // auto* fpr = result->fpr;
-//   // ASSERT_FALSE(fpr == nullptr);
-
-//   // auto key =
-//   // GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).GetKey(fpr);
-//   // ASSERT_TRUE(key.IsGood());
-//   // key_opera.DeleteKey(fpr);
-// }
-
-// TEST_F(GpgCoreTest, GenerateKeyTest_1) {
-//   auto& key_opera = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel);
-//   auto keygen_info = std::make_unique<GenKeyInfo>();
-//   keygen_info->SetName("foo");
-//   keygen_info->SetEmail("[email protected]");
-//   keygen_info->SetComment("hello gpgfrontend");
-//   keygen_info->SetAlgo(keygen_info->GetSupportedKeyAlgo()[0]);
-//   keygen_info->SetKeyLength(4096);
-//   keygen_info->SetNonExpired(false);
-//   keygen_info->SetExpireTime(boost::posix_time::second_clock::local_time() +
-//                              boost::posix_time::hours(24));
-//   keygen_info->SetNonPassPhrase(false);
-
-//   GpgGenKeyResult result = nullptr;
-//   // auto err =
-//   //     CheckGpgError(key_opera.GenerateKey(keygen_info, result));
-//   // ASSERT_EQ(err, GPG_ERR_NO_ERROR);
-
-//   // auto fpr = result->fpr;
-//   // ASSERT_FALSE(fpr == nullptr);
-
-//   // auto key =
-//   //     GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).GetKey(fpr);
-//   // ASSERT_TRUE(key.IsGood());
-//   // key_opera.DeleteKey(fpr);
-// }
-
-// TEST_F(GpgCoreTest, GenerateKeyTest_4) {
-//   auto& key_opera = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel);
-//   auto keygen_info = std::make_unique<GenKeyInfo>();
-//   keygen_info->SetName("foo");
-//   keygen_info->SetEmail("[email protected]");
-//   keygen_info->SetComment("");
-//   keygen_info->SetAlgo(keygen_info->GetSupportedKeyAlgo()[1]);
-//   keygen_info->SetNonExpired(true);
-//   keygen_info->SetNonPassPhrase(false);
-
-//   GpgGenKeyResult result = nullptr;
-//   // auto err =
-//   //     CheckGpgError(key_opera.GenerateKey(keygen_info, result));
-//   // ASSERT_EQ(err, GPG_ERR_NO_ERROR);
-
-//   // auto* fpr = result->fpr;
-//   // ASSERT_FALSE(fpr == nullptr);
-
-//   // auto key =
-//   //     GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).GetKey(fpr);
-//   // ASSERT_TRUE(key.IsGood());
-//   // key_opera.DeleteKey(fpr);
-// }
-
-// TEST_F(GpgCoreTest, GenerateKeyTest_5) {
-//   auto& key_opera = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel);
-//   auto keygen_info = std::make_unique<GenKeyInfo>();
-//   keygen_info->SetName("foo");
-//   keygen_info->SetEmail("[email protected]");
-//   keygen_info->SetComment("");
-//   keygen_info->SetAlgo(keygen_info->GetSupportedKeyAlgo()[2]);
-//   keygen_info->SetNonExpired(true);
-//   keygen_info->SetNonPassPhrase(false);
-
-//   GpgGenKeyResult result = nullptr;
-//   // auto err =
-//   //     CheckGpgError(key_opera.GenerateKey(keygen_info, result));
-//   // ASSERT_EQ(err, GPG_ERR_NO_ERROR);
-
-//   // auto* fpr = result->fpr;
-//   // ASSERT_FALSE(fpr == nullptr);
-
-//   // auto key =
-//   //     GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).GetKey(fpr);
-//   // ASSERT_TRUE(key.IsGood());
-//   // key_opera.DeleteKey(fpr);
-// }
+TEST_F(GpgCoreTest, GenerateKeyTest) {
+  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
+  keygen_info->SetName("foo");
+  keygen_info->SetEmail("[email protected]");
+  keygen_info->SetComment("");
+  keygen_info->SetKeyLength(1024);
+  keygen_info->SetAlgo(keygen_info->GetSupportedKeyAlgo()[0]);
+  keygen_info->SetNonExpired(true);
+  keygen_info->SetNonPassPhrase(true);
+
+  std::atomic_bool callback_called_flag{false};
+
+  GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+      .GenerateKey(keygen_info, [&callback_called_flag](
+                                    GpgError err,
+                                    const DataObjectPtr& data_object) {
+        ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+
+        auto result = ExtractParams<GpgGenKeyResult>(data_object, 0);
+        auto* fpr = result->fpr;
+        auto key =
+            GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).GetKey(fpr);
+        ASSERT_TRUE(key.IsGood());
+
+        GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
+
+        callback_called_flag = true;
+        ASSERT_FALSE(fpr == nullptr);
+      });
+
+  int retry_count = 1000;
+  while (!callback_called_flag && retry_count-- > 0) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+  }
+
+  ASSERT_TRUE(callback_called_flag);
+}
+
+TEST_F(GpgCoreTest, GenerateKeyTest_1) {
+  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
+  keygen_info->SetName("foo");
+  keygen_info->SetEmail("[email protected]");
+  keygen_info->SetComment("hello gpgfrontend");
+  keygen_info->SetAlgo(keygen_info->GetSupportedKeyAlgo()[0]);
+  keygen_info->SetKeyLength(4096);
+  keygen_info->SetNonExpired(false);
+  keygen_info->SetExpireTime(boost::posix_time::second_clock::local_time() +
+                             boost::posix_time::hours(24));
+  keygen_info->SetNonPassPhrase(false);
+
+  std::atomic_bool callback_called_flag{false};
+
+  GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+      .GenerateKey(keygen_info, [&callback_called_flag](
+                                    GpgError err,
+                                    const DataObjectPtr& data_object) {
+        ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+
+        auto result = ExtractParams<GpgGenKeyResult>(data_object, 0);
+        auto* fpr = result->fpr;
+        auto key =
+            GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).GetKey(fpr);
+        ASSERT_TRUE(key.IsGood());
+
+        GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
+
+        callback_called_flag = true;
+        ASSERT_FALSE(fpr == nullptr);
+      });
+
+  int retry_count = 2000;
+  while (!callback_called_flag && retry_count-- > 0) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+  }
+
+  ASSERT_TRUE(callback_called_flag);
+}
+
+TEST_F(GpgCoreTest, GenerateKeyTest_4) {
+  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
+  keygen_info->SetName("foo");
+  keygen_info->SetEmail("[email protected]");
+  keygen_info->SetComment("");
+  keygen_info->SetAlgo(keygen_info->GetSupportedKeyAlgo()[1]);
+  keygen_info->SetNonExpired(true);
+  keygen_info->SetNonPassPhrase(false);
+
+  std::atomic_bool callback_called_flag{false};
+
+  GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+      .GenerateKey(keygen_info, [&callback_called_flag](
+                                    GpgError err,
+                                    const DataObjectPtr& data_object) {
+        ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+
+        auto result = ExtractParams<GpgGenKeyResult>(data_object, 0);
+        auto* fpr = result->fpr;
+        auto key =
+            GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).GetKey(fpr);
+        ASSERT_TRUE(key.IsGood());
+
+        GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
+
+        callback_called_flag = true;
+        ASSERT_FALSE(fpr == nullptr);
+      });
+
+  int retry_count = 2000;
+  while (!callback_called_flag && retry_count-- > 0) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+  }
+
+  ASSERT_TRUE(callback_called_flag);
+}
+
+TEST_F(GpgCoreTest, GenerateKeyTest_5) {
+  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
+  keygen_info->SetName("foo");
+  keygen_info->SetEmail("[email protected]");
+  keygen_info->SetComment("");
+  keygen_info->SetAlgo(keygen_info->GetSupportedKeyAlgo()[2]);
+  keygen_info->SetNonExpired(true);
+  keygen_info->SetNonPassPhrase(false);
+
+  std::atomic_bool callback_called_flag{false};
+
+  GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+      .GenerateKey(keygen_info, [&callback_called_flag](
+                                    GpgError err,
+                                    const DataObjectPtr& data_object) {
+        ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+
+        auto result = ExtractParams<GpgGenKeyResult>(data_object, 0);
+        auto* fpr = result->fpr;
+        auto key =
+            GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).GetKey(fpr);
+        ASSERT_TRUE(key.IsGood());
+
+        GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
+
+        callback_called_flag = true;
+        ASSERT_FALSE(fpr == nullptr);
+      });
+
+  int retry_count = 1000;
+  while (!callback_called_flag && retry_count-- > 0) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+  }
+
+  ASSERT_TRUE(callback_called_flag);
+}
 
 }  // namespace GpgFrontend::Test