<refactor, fix, test>(core, test): test key generation for standalone mode

1. add key generation test for standalone mode
2. add supported algos in standalone mode
3. changed support algo vectors from static value to static getter
4. modified name of some variables.

5 files changed, 306 insertions, 85 deletions

diff --git a/.gitignore b/.gitignore
index 243ab625..8d75fe32 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,7 @@
 src/GpgFrontend.h
 src/GpgFrontendBuildInfo.h
 src/GpgFrontendBuildInstallInfo.h
+third_party/AppImageUpdate
 
 # gettext
 *.mo
diff --git a/src/gpg/GpgGenKeyInfo.cpp b/src/gpg/GpgGenKeyInfo.cpp
index 4a0a99fc..124c66e8 100644
--- a/src/gpg/GpgGenKeyInfo.cpp
+++ b/src/gpg/GpgGenKeyInfo.cpp
@@ -32,18 +32,41 @@
 #include <string>
 #include <vector>
 
-const std::vector<std::string> GpgFrontend::GenKeyInfo::SupportedKeyAlgo = {
-    "RSA", "DSA", "ED25519"};
-
-const std::vector<std::string> GpgFrontend::GenKeyInfo::SupportedSubkeyAlgo = {
-    "RSA", "DSA", "ED25519", "ELG"};
-
 void GpgFrontend::GenKeyInfo::setAlgo(const std::string &m_algo) {
-  LOG(INFO) << "GpgFrontend::GenKeyInfo::setAlgo m_algo" << m_algo;
+  LOG(INFO) << "set algo" << m_algo;
+  // Check algo if supported
+  std::string algo_args = std::string(m_algo);
+  boost::algorithm::to_upper(algo_args);
+  if (standalone_) {
+    if (!subkey_) {
+      auto support_algo = getSupportedKeyAlgoStandalone();
+      auto it = std::find(support_algo.begin(), support_algo.end(), algo_args);
+      // Algo Not Supported
+      if (it == support_algo.end()) return;
+    } else {
+      auto support_algo = getSupportedSubkeyAlgoStandalone();
+      auto it = std::find(support_algo.begin(), support_algo.end(), algo_args);
+      // Algo Not Supported
+      if (it == support_algo.end()) return;
+    }
+  } else {
+    if (!subkey_) {
+      auto support_algo = getSupportedKeyAlgo();
+      auto it = std::find(support_algo.begin(), support_algo.end(), algo_args);
+      // Algo Not Supported
+      if (it == support_algo.end()) return;
+    } else {
+      auto support_algo = getSupportedSubkeyAlgo();
+      auto it = std::find(support_algo.begin(), support_algo.end(), algo_args);
+      // Algo Not Supported
+      if (it == support_algo.end()) return;
+    }
+  }
 
+  // reset all options
   reset_options();
 
-  if (!this->subKey) {
+  if (!this->subkey_) {
     this->setAllowCertification(true);
   } else {
     this->setAllowCertification(false);
@@ -51,23 +74,20 @@ void GpgFrontend::GenKeyInfo::setAlgo(const std::string &m_algo) {
 
   this->allowChangeCertification = false;
 
-  std::string lower_algo = std::string(m_algo);
-  boost::algorithm::to_lower(lower_algo);
-
-  LOG(INFO) << "GpgFrontend::GenKeyInfo::setAlgo lower_algo" << lower_algo;
+  if (!standalone_) boost::algorithm::to_lower(algo_args);
 
-  if (lower_algo == "rsa") {
+  if (algo_args == "rsa") {
     /**
      * RSA is the world’s premier asymmetric cryptographic algorithm,
      * and is built on the difficulty of factoring extremely large composites.
      * GnuPG supports RSA with key sizes of between 1024 and 4096 bits.
      */
-    suggestMinKeySize = 1024;
-    suggestMaxKeySize = 4096;
-    suggestSizeAdditionStep = 1024;
+    suggest_min_key_size_ = 1024;
+    suggest_max_key_size_ = 4096;
+    suggest_size_addition_step_ = 1024;
     setKeySize(2048);
 
-  } else if (lower_algo == "dsa") {
+  } else if (algo_args == "dsa") {
     /**
      * Algorithm (DSA) as a government standard for digital signatures.
      * Originally, it supported key lengths between 512 and 1024 bits.
@@ -77,42 +97,40 @@ void GpgFrontend::GenKeyInfo::setAlgo(const std::string &m_algo) {
     setAllowEncryption(false);
     allowChangeEncryption = false;
 
-    suggestMinKeySize = 1024;
-    suggestMaxKeySize = 3072;
-    suggestSizeAdditionStep = 1024;
+    suggest_min_key_size_ = 1024;
+    suggest_max_key_size_ = 3072;
+    suggest_size_addition_step_ = 1024;
     setKeySize(2048);
 
-  } else if (lower_algo == "ed25519") {
+  } else if (algo_args == "ed25519") {
     /**
      * GnuPG supports the Elgamal asymmetric encryption algorithm in key lengths
      * ranging from 1024 to 4096 bits.
      */
-
     setAllowEncryption(false);
     allowChangeEncryption = false;
 
-    suggestMinKeySize = -1;
-    suggestMaxKeySize = -1;
-    suggestSizeAdditionStep = -1;
+    suggest_min_key_size_ = -1;
+    suggest_max_key_size_ = -1;
+    suggest_size_addition_step_ = -1;
     setKeySize(-1);
-  } else if (lower_algo == "elg") {
+  } else if (algo_args == "elg") {
     /**
      * GnuPG supports the Elgamal asymmetric encryption algorithm in key lengths
      * ranging from 1024 to 4096 bits.
      */
-
     setAllowAuthentication(false);
     allowChangeAuthentication = false;
 
     setAllowSigning(false);
     allowChangeSigning = false;
 
-    suggestMinKeySize = 1024;
-    suggestMaxKeySize = 4096;
-    suggestSizeAdditionStep = 1024;
+    suggest_min_key_size_ = 1024;
+    suggest_max_key_size_ = 4096;
+    suggest_size_addition_step_ = 1024;
     setKeySize(2048);
   }
-  this->algo = lower_algo;
+  this->algo_ = algo_args;
 }
 
 void GpgFrontend::GenKeyInfo::reset_options() {
@@ -128,37 +146,38 @@ void GpgFrontend::GenKeyInfo::reset_options() {
   allowChangeAuthentication = true;
   setAllowAuthentication(true);
 
-  passPhrase.clear();
+  passphrase_.clear();
 }
 
 std::string GpgFrontend::GenKeyInfo::getKeySizeStr() const {
-  if (keySize > 0) {
-    return std::to_string(keySize);
+  if (key_size_ > 0) {
+    return std::to_string(key_size_);
   } else {
     return {};
   }
 }
 
 void GpgFrontend::GenKeyInfo::setKeySize(int m_key_size) {
-  if (m_key_size < suggestMinKeySize || m_key_size > suggestMaxKeySize) {
+  if (m_key_size < suggest_min_key_size_ ||
+      m_key_size > suggest_max_key_size_) {
     return;
   }
-  GenKeyInfo::keySize = m_key_size;
+  GenKeyInfo::key_size_ = m_key_size;
 }
 
 void GpgFrontend::GenKeyInfo::setExpired(
     const boost::posix_time::ptime &m_expired) {
   using namespace boost::gregorian;
   auto current = boost::posix_time::second_clock::local_time();
-  if (isNonExpired() && m_expired < current + years(2)) {
-    GenKeyInfo::expired = m_expired;
+  if (!isNonExpired()) {
+    GenKeyInfo::expired_ = m_expired;
   }
 }
 
 void GpgFrontend::GenKeyInfo::setNonExpired(bool m_non_expired) {
   using namespace boost::posix_time;
-  if (!m_non_expired) this->expired = from_time_t(0);
-  GenKeyInfo::nonExpired = m_non_expired;
+  if (!m_non_expired) this->expired_ = from_time_t(0);
+  GenKeyInfo::non_expired_ = m_non_expired;
 }
 
 void GpgFrontend::GenKeyInfo::setAllowEncryption(bool m_allow_encryption) {
@@ -170,3 +189,35 @@ void GpgFrontend::GenKeyInfo::setAllowCertification(
   if (allowChangeCertification)
     GenKeyInfo::allowCertification = m_allow_certification;
 }
+
+GpgFrontend::GenKeyInfo::GenKeyInfo(bool m_is_sub_key, bool m_standalone)
+    : standalone_(m_standalone), subkey_(m_is_sub_key) {
+  setAlgo("rsa");
+}
+
+const std::vector<std::string> &GpgFrontend::GenKeyInfo::getSupportedKeyAlgo() {
+  static const std::vector<std::string> support_key_algo = {"RSA", "DSA",
+                                                            "ED25519"};
+  return support_key_algo;
+}
+
+const std::vector<std::string>
+    &GpgFrontend::GenKeyInfo::getSupportedSubkeyAlgo() {
+  static const std::vector<std::string> support_subkey_algo = {"RSA", "DSA",
+                                                               "ED25519"};
+  return support_subkey_algo;
+}
+
+const std::vector<std::string>
+    &GpgFrontend::GenKeyInfo::getSupportedKeyAlgoStandalone() {
+  static const std::vector<std::string> support_subkey_algo_standalone = {
+      "RSA", "DSA"};
+  return support_subkey_algo_standalone;
+}
+
+const std::vector<std::string>
+    &GpgFrontend::GenKeyInfo::getSupportedSubkeyAlgoStandalone() {
+  static const std::vector<std::string> support_subkey_algo_standalone = {
+      "RSA", "DSA", "ELG-E"};
+  return support_subkey_algo_standalone;
+}
diff --git a/src/gpg/GpgGenKeyInfo.h b/src/gpg/GpgGenKeyInfo.h
index cc679656..8f7d19ea 100644
--- a/src/gpg/GpgGenKeyInfo.h
+++ b/src/gpg/GpgGenKeyInfo.h
@@ -34,83 +34,90 @@
 namespace GpgFrontend {
 
 class GenKeyInfo {
-  bool subKey = true;
-  std::string name;
-  std::string email;
-  std::string comment;
-
-  std::string algo;
-  int keySize = 2048;
-  boost::posix_time::ptime expired =
+  bool standalone_ = false;
+  bool subkey_ = false;
+  std::string name_;
+  std::string email_;
+  std::string comment_;
+
+  std::string algo_;
+  int key_size_ = 2048;
+  boost::posix_time::ptime expired_ =
       boost::posix_time::second_clock::local_time() +
       boost::gregorian::years(2);
-  bool nonExpired = false;
+  bool non_expired_ = false;
 
-  bool noPassPhrase = false;
-  bool allowNoPassPhrase = true;
+  bool no_passphrase_ = false;
+  bool allow_no_pass_phrase_ = true;
 
-  int suggestMaxKeySize = 4096;
-  int suggestSizeAdditionStep = 1024;
-  int suggestMinKeySize = 1024;
+  int suggest_max_key_size_ = 4096;
+  int suggest_size_addition_step_ = 1024;
+  int suggest_min_key_size_ = 1024;
 
-  std::string passPhrase;
+  std::string passphrase_;
 
  public:
-  static const std::vector<std::string> SupportedKeyAlgo;
+  static const std::vector<std::string> &getSupportedKeyAlgo();
 
-  static const std::vector<std::string> SupportedSubkeyAlgo;
+  static const std::vector<std::string> &getSupportedSubkeyAlgo();
 
-  [[nodiscard]] bool isSubKey() const { return subKey; }
+  static const std::vector<std::string> &getSupportedKeyAlgoStandalone();
 
-  void setIsSubKey(bool m_sub_key) { GenKeyInfo::subKey = m_sub_key; }
+  static const std::vector<std::string> &getSupportedSubkeyAlgoStandalone();
+
+  [[nodiscard]] bool isSubKey() const { return subkey_; }
+
+  void setIsSubKey(bool m_sub_key) { GenKeyInfo::subkey_ = m_sub_key; }
 
   [[nodiscard]] std::string getUserid() const {
-    auto uid_format = boost::format("%1%(%2%)<%3%>") % this->name %
-                      this->comment % this->email;
+    auto uid_format = boost::format("%1%(%2%)<%3%>") % this->name_ %
+                      this->comment_ % this->email_;
     return uid_format.str();
   }
 
-  void setName(const std::string &m_name) { this->name = m_name; }
+  void setName(const std::string &m_name) { this->name_ = m_name; }
 
-  void setEmail(const std::string &m_email) { this->email = m_email; }
+  void setEmail(const std::string &m_email) { this->email_ = m_email; }
 
-  void setComment(const std::string &m_comment) { this->comment = m_comment; }
+  void setComment(const std::string &m_comment) { this->comment_ = m_comment; }
 
-  [[nodiscard]] std::string getName() const { return name; }
+  [[nodiscard]] std::string getName() const { return name_; }
 
-  [[nodiscard]] std::string getEmail() const { return email; }
+  [[nodiscard]] std::string getEmail() const { return email_; }
 
-  [[nodiscard]] std::string getComment() const { return comment; }
+  [[nodiscard]] std::string getComment() const { return comment_; }
 
-  [[nodiscard]] const std::string &getAlgo() const { return algo; }
+  [[nodiscard]] const std::string &getAlgo() const { return algo_; }
 
   void setAlgo(const std::string &m_algo);
 
   [[nodiscard]] std::string getKeySizeStr() const;
 
-  [[nodiscard]] int getKeySize() const { return keySize; }
+  [[nodiscard]] int getKeySize() const { return key_size_; }
 
   void setKeySize(int m_key_size);
 
   [[nodiscard]] const boost::posix_time::ptime &getExpired() const {
-    return expired;
+    return expired_;
   }
 
   void setExpired(const boost::posix_time::ptime &m_expired);
 
-  [[nodiscard]] bool isNonExpired() const { return nonExpired; }
+  [[nodiscard]] bool isNonExpired() const { return non_expired_; }
 
   void setNonExpired(bool m_non_expired);
 
-  [[nodiscard]] bool isNoPassPhrase() const { return this->noPassPhrase; }
+  [[nodiscard]] bool isNoPassPhrase() const { return this->no_passphrase_; }
 
   void setNonPassPhrase(bool m_non_pass_phrase) {
-    GenKeyInfo::noPassPhrase = m_non_pass_phrase;
+    GenKeyInfo::no_passphrase_ = m_non_pass_phrase;
   }
 
   [[nodiscard]] bool isAllowSigning() const { return allowSigning; }
 
-  [[nodiscard]] bool isAllowNoPassPhrase() const { return allowNoPassPhrase; }
+  [[nodiscard]] bool isAllowNoPassPhrase() const {
+    return allow_no_pass_phrase_;
+  }
 
   void setAllowSigning(bool m_allow_signing) {
     if (allowChangeSigning) GenKeyInfo::allowSigning = m_allow_signing;
@@ -133,10 +140,10 @@ class GenKeyInfo {
       GenKeyInfo::allowAuthentication = m_allow_authentication;
   }
 
-  [[nodiscard]] const std::string &getPassPhrase() const { return passPhrase; }
+  [[nodiscard]] const std::string &getPassPhrase() const { return passphrase_; }
 
   void setPassPhrase(const std::string &m_pass_phrase) {
-    GenKeyInfo::passPhrase = m_pass_phrase;
+    GenKeyInfo::passphrase_ = m_pass_phrase;
   }
 
   [[nodiscard]] bool isAllowChangeSigning() const { return allowChangeSigning; }
@@ -152,12 +159,16 @@ class GenKeyInfo {
     return allowChangeAuthentication;
   }
 
-  [[nodiscard]] int getSuggestMaxKeySize() const { return suggestMaxKeySize; }
+  [[nodiscard]] int getSuggestMaxKeySize() const {
+    return suggest_max_key_size_;
+  }
 
-  [[nodiscard]] int getSuggestMinKeySize() const { return suggestMinKeySize; }
+  [[nodiscard]] int getSuggestMinKeySize() const {
+    return suggest_min_key_size_;
+  }
 
   [[nodiscard]] int getSizeChangeStep() const {
-    return suggestSizeAdditionStep;
+    return suggest_size_addition_step_;
   }
 
  private:
@@ -176,9 +187,7 @@ class GenKeyInfo {
   void reset_options();
 
  public:
-  explicit GenKeyInfo(bool m_is_sub_key = false) : subKey(m_is_sub_key) {
-    setAlgo("rsa");
-  }
+  explicit GenKeyInfo(bool m_is_sub_key = false, bool m_standalone = false);
 };
 
 }  // namespace GpgFrontend
diff --git a/src/gpg/function/GpgKeyOpera.cpp b/src/gpg/function/GpgKeyOpera.cpp
index 4cbc1d0a..df89c6f5 100644
--- a/src/gpg/function/GpgKeyOpera.cpp
+++ b/src/gpg/function/GpgKeyOpera.cpp
@@ -187,7 +187,8 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::GenerateKey(
         boost::format{
             "<GnupgKeyParms format=\"internal\">\n"
             "Key-Type: %1%\n"
-            "Subkey-Type: %2%\n"
+            "Key-Usage: sign\n"
+            "Key-Length: %2%\n"
             "Name-Real: %3%\n"
             "Name-Comment: %4%\n"
             "Name-Email: %5%\n"} %
@@ -195,8 +196,11 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::GenerateKey(
         params->getComment() % params->getEmail();
     ss << param_format;
 
-    if (!params->isNonExpired())
-      ss << boost::format{"Expire-Date: %1%\n"} % expires;
+    if (!params->isNonExpired()) {
+      auto date = params->getExpired().date();
+      ss << boost::format{"Expire-Date: %1%\n"} % to_iso_string(date);
+    } else
+      ss << boost::format{"Expire-Date: 0\n"};
     if (!params->isNoPassPhrase())
       ss << boost::format{"Passphrase: %1%\n"} % params->getPassPhrase();
 
diff --git a/test/GpgCoreTestKeygenAlone.cpp b/test/GpgCoreTestKeygenAlone.cpp
new file mode 100644
index 00000000..4a725ba7
--- /dev/null
+++ b/test/GpgCoreTestKeygenAlone.cpp
@@ -0,0 +1,156 @@
+/**
+ * This file is part of GpgFrontend.
+ *
+ * GpgFrontend is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Foobar is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * The initial version of the source code is inherited from gpg4usb-team.
+ * Their source code version also complies with GNU General Public License.
+ *
+ * The source code version of this software was modified and released
+ * by Saturneric<[email protected]> starting on May 12, 2021.
+ *
+ */
+
+#include "GpgFrontendTest.h"
+#include "gpg/GpgGenKeyInfo.h"
+#include "gpg/function/GpgKeyGetter.h"
+#include "gpg/function/GpgKeyOpera.h"
+
+TEST_F(GpgCoreTest, GenerateKeyTestAlone) {
+  auto& key_opera = GpgFrontend::GpgKeyOpera::GetInstance(gpg_alone_channel);
+  auto keygen_info = std::make_unique<GpgFrontend::GenKeyInfo>(false, true);
+  keygen_info->setName("foobar");
+  keygen_info->setEmail("[email protected]");
+  keygen_info->setComment("hello");
+  keygen_info->setAlgo("rsa");
+  keygen_info->setNonExpired(true);
+  keygen_info->setNonPassPhrase(true);
+
+  GpgFrontend::GpgGenKeyResult result = nullptr;
+  auto err = GpgFrontend::check_gpg_error_2_err_code(
+      key_opera.GenerateKey(keygen_info, result));
+  ASSERT_EQ(err, GPG_ERR_NO_ERROR);
+
+  auto fpr = result->fpr;
+  ASSERT_FALSE(fpr == nullptr);
+
+  auto key =
+      GpgFrontend::GpgKeyGetter::GetInstance(gpg_alone_channel).GetKey(fpr);
+  ASSERT_TRUE(key.good());
+  key_opera.DeleteKey(fpr);
+}
+
+TEST_F(GpgCoreTest, GenerateKeyTestAlone_1) {
+  auto& key_opera = GpgFrontend::GpgKeyOpera::GetInstance(gpg_alone_channel);
+  auto keygen_info = std::make_unique<GpgFrontend::GenKeyInfo>(false, true);
+  keygen_info->setName("foobar");
+  keygen_info->setEmail("[email protected]");
+  keygen_info->setComment("hello gpgfrontend");
+  keygen_info->setAlgo("rsa");
+  keygen_info->setNonExpired(false);
+  keygen_info->setPassPhrase("abcdefg");
+  keygen_info->setExpired(boost::posix_time::second_clock::local_time() +
+                          boost::posix_time::hours(24));
+  keygen_info->setNonPassPhrase(false);
+
+  GpgFrontend::GpgGenKeyResult result = nullptr;
+  auto err = GpgFrontend::check_gpg_error_2_err_code(
+      key_opera.GenerateKey(keygen_info, result));
+  ASSERT_EQ(err, GPG_ERR_NO_ERROR);
+
+  auto fpr = result->fpr;
+  ASSERT_FALSE(fpr == nullptr);
+
+  auto key =
+      GpgFrontend::GpgKeyGetter::GetInstance(gpg_alone_channel).GetKey(fpr);
+  ASSERT_TRUE(key.good());
+  key_opera.DeleteKey(fpr);
+}
+
+TEST_F(GpgCoreTest, GenerateKeyTestAlone_2) {
+  auto& key_opera = GpgFrontend::GpgKeyOpera::GetInstance(gpg_alone_channel);
+  auto keygen_info = std::make_unique<GpgFrontend::GenKeyInfo>(false, true);
+  keygen_info->setName("foobar");
+  keygen_info->setEmail("[email protected]");
+  keygen_info->setComment("hi");
+  keygen_info->setAlgo("rsa");
+  keygen_info->setKeySize(3072);
+  keygen_info->setNonExpired(true);
+  keygen_info->setNonPassPhrase(false);
+  keygen_info->setPassPhrase("abcdefg");
+
+  GpgFrontend::GpgGenKeyResult result = nullptr;
+  auto err = GpgFrontend::check_gpg_error_2_err_code(
+      key_opera.GenerateKey(keygen_info, result));
+  ASSERT_EQ(err, GPG_ERR_NO_ERROR);
+
+  auto fpr = result->fpr;
+  ASSERT_FALSE(fpr == nullptr);
+
+  auto key =
+      GpgFrontend::GpgKeyGetter::GetInstance(gpg_alone_channel).GetKey(fpr);
+  ASSERT_TRUE(key.good());
+  key_opera.DeleteKey(fpr);
+}
+
+TEST_F(GpgCoreTest, GenerateKeyTestAlone_3) {
+  auto& key_opera = GpgFrontend::GpgKeyOpera::GetInstance(gpg_alone_channel);
+  auto keygen_info = std::make_unique<GpgFrontend::GenKeyInfo>(false, true);
+  keygen_info->setName("foo");
+  keygen_info->setEmail("[email protected]");
+  keygen_info->setComment("hello");
+  keygen_info->setAlgo("rsa");
+  keygen_info->setKeySize(4096);
+  keygen_info->setNonExpired(true);
+  keygen_info->setNonPassPhrase(false);
+  keygen_info->setPassPhrase("abcdefg");
+
+  GpgFrontend::GpgGenKeyResult result = nullptr;
+  auto err = GpgFrontend::check_gpg_error_2_err_code(
+      key_opera.GenerateKey(keygen_info, result));
+  ASSERT_EQ(err, GPG_ERR_NO_ERROR);
+
+  auto fpr = result->fpr;
+  ASSERT_FALSE(fpr == nullptr);
+
+  auto key =
+      GpgFrontend::GpgKeyGetter::GetInstance(gpg_alone_channel).GetKey(fpr);
+  ASSERT_TRUE(key.good());
+  key_opera.DeleteKey(fpr);
+}
+
+TEST_F(GpgCoreTest, GenerateKeyTestAlone_4) {
+  auto& key_opera = GpgFrontend::GpgKeyOpera::GetInstance(gpg_alone_channel);
+  auto keygen_info = std::make_unique<GpgFrontend::GenKeyInfo>(false, true);
+  keygen_info->setName("foobar");
+  keygen_info->setEmail("[email protected]");
+  keygen_info->setComment("hello");
+  keygen_info->setAlgo("dsa");
+  keygen_info->setNonExpired(true);
+  keygen_info->setNonPassPhrase(false);
+  keygen_info->setPassPhrase("abcdefg");
+
+  GpgFrontend::GpgGenKeyResult result = nullptr;
+  auto err = GpgFrontend::check_gpg_error_2_err_code(
+      key_opera.GenerateKey(keygen_info, result));
+  ASSERT_EQ(err, GPG_ERR_NO_ERROR);
+
+  auto fpr = result->fpr;
+  ASSERT_FALSE(fpr == nullptr);
+
+  auto key =
+      GpgFrontend::GpgKeyGetter::GetInstance(gpg_alone_channel).GetKey(fpr);
+  ASSERT_TRUE(key.good());
+  key_opera.DeleteKey(fpr);
+}
\ No newline at end of file