test: fix and add KeyGen & SubkeyGen test cases

3 files changed, 292 insertions, 149 deletions

diff --git a/src/test/core/GpgCoreTestCache.cpp b/src/test/core/GpgCoreTestCache.cpp
index 696a766d..a791bf8d 100644
--- a/src/test/core/GpgCoreTestCache.cpp
+++ b/src/test/core/GpgCoreTestCache.cpp
@@ -48,8 +48,8 @@ TEST_F(GpgCoreTest, CoreCacheTestB) {
 }
 
 TEST_F(GpgCoreTest, CoreCacheTestC) {
-  CacheManager::GetInstance().SaveCache("ABCDEF", "DEF", 2);
-  ASSERT_EQ(CacheManager::GetInstance().LoadCache("ABCDEF"), QString("DEFG"));
+  CacheManager::GetInstance().SaveCache("ABCDEF", "DEFEEE", 2);
+  ASSERT_EQ(CacheManager::GetInstance().LoadCache("ABCDEF"), QString("DEFEEE"));
   std::this_thread::sleep_for(std::chrono::milliseconds(4000));
   ASSERT_EQ(CacheManager::GetInstance().LoadCache("ABCDEF"), QString(""));
 }
diff --git a/src/test/core/GpgCoreTestKeygen.cpp b/src/test/core/GpgCoreTestKeygen.cpp
index d8fe1cd8..9197e18e 100644
--- a/src/test/core/GpgCoreTestKeygen.cpp
+++ b/src/test/core/GpgCoreTestKeygen.cpp
@@ -42,14 +42,10 @@ TEST_F(GpgCoreTest, GenerateKeyRSA2048Test) {
   keygen_info->SetName("foo_0");
   keygen_info->SetEmail("[email protected]");
   keygen_info->SetComment("foobar");
+  keygen_info->SetAlgo("rsa");
   keygen_info->SetKeyLength(2048);
-  keygen_info->SetAlgo(std::get<1>(keygen_info->GetSupportedKeyAlgo()[0]));
-  keygen_info->SetAllowAuthentication(true);
-  keygen_info->SetAllowCertification(true);
-  keygen_info->SetAllowEncryption(true);
-  keygen_info->SetAllowSigning(true);
   keygen_info->SetNonExpired(true);
-  keygen_info->SetNonPassPhrase(false);
+  keygen_info->SetNonPassPhrase(true);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
                                 .GenerateKeySync(keygen_info);
@@ -87,64 +83,15 @@ TEST_F(GpgCoreTest, GenerateKeyRSA2048Test) {
       .DeleteKey(result.GetFingerprint());
 }
 
-TEST_F(GpgCoreTest, GenerateKeyRSA1024NoPassTest) {
-  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
-  keygen_info->SetName("foo_1");
-  keygen_info->SetEmail("[email protected]");
-  keygen_info->SetComment("foobar_1");
-  keygen_info->SetKeyLength(2048);
-  keygen_info->SetAlgo(std::get<1>(keygen_info->GetSupportedKeyAlgo()[0]));
-  keygen_info->SetAllowAuthentication(false);
-  keygen_info->SetAllowCertification(false);
-  keygen_info->SetAllowEncryption(false);
-  keygen_info->SetAllowSigning(false);
-  keygen_info->SetNonExpired(false);
-  keygen_info->SetNonPassPhrase(true);
-
-  auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-                                .GenerateKeySync(keygen_info);
-
-  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
-  ASSERT_EQ(data_object->GetObjectSize(), 1);
-  ASSERT_TRUE(data_object->Check<GpgGenerateKeyResult>());
-
-  auto result = ExtractParams<GpgGenerateKeyResult>(data_object, 0);
-  ASSERT_TRUE(result.IsGood());
-  ASSERT_FALSE(result.GetFingerprint().isEmpty());
-
-  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
-                 .GetKey(result.GetFingerprint());
-  ASSERT_TRUE(key.IsGood());
-  ASSERT_EQ(key.GetName(), "foo_1");
-  ASSERT_EQ(key.GetEmail(), "[email protected]");
-  ASSERT_EQ(key.GetComment(), "foobar_1");
-  ASSERT_EQ(key.GetPublicKeyAlgo(), "RSA");
-  ASSERT_EQ(key.GetOwnerTrustLevel(), 5);
-  ASSERT_EQ(key.GetPrimaryKeyLength(), 2048);
-  ASSERT_GT(key.GetExpireTime(), QDateTime::currentDateTime());
-
-  ASSERT_TRUE(key.IsHasCertificationCapability());
-  ASSERT_FALSE(key.IsHasAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasEncryptionCapability());
-  ASSERT_FALSE(key.IsHasSigningCapability());
-
-  ASSERT_TRUE(key.IsHasActualCertificationCapability());
-  ASSERT_FALSE(key.IsHasActualAuthenticationCapability());
-  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
-  ASSERT_FALSE(key.IsHasActualSigningCapability());
-
-  GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-      .DeleteKey(result.GetFingerprint());
-}
-
 TEST_F(GpgCoreTest, GenerateKeyRSA4096Test) {
   auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
   keygen_info->SetName("foo_1");
   keygen_info->SetEmail("[email protected]");
   keygen_info->SetComment("hello gpgfrontend");
-  keygen_info->SetAlgo(std::get<1>(keygen_info->GetSupportedKeyAlgo()[0]));
-  keygen_info->SetKeyLength(3072);
+  keygen_info->SetAlgo("rsa");
+  keygen_info->SetKeyLength(4096);
   keygen_info->SetNonExpired(false);
+  keygen_info->SetNonPassPhrase(true);
 
   auto expire_time =
       QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600));
@@ -176,13 +123,10 @@ TEST_F(GpgCoreTest, GenerateKeyDSA2048Test) {
   keygen_info->SetName("foo_1");
   keygen_info->SetEmail("[email protected]");
   keygen_info->SetComment("hello gpgfrontend");
-  keygen_info->SetAlgo(std::get<1>(keygen_info->GetSupportedKeyAlgo()[1]));
+  keygen_info->SetAlgo("dsa");
   keygen_info->SetKeyLength(2048);
-  keygen_info->SetAllowAuthentication(true);
-  keygen_info->SetAllowCertification(true);
-  keygen_info->SetAllowEncryption(true);
-  keygen_info->SetAllowSigning(true);
   keygen_info->SetNonExpired(false);
+  keygen_info->SetNonPassPhrase(true);
 
   auto expire_time =
       QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600));
@@ -229,13 +173,9 @@ TEST_F(GpgCoreTest, GenerateKeyED25519Test) {
   keygen_info->SetName("foo_4");
   keygen_info->SetEmail("[email protected]");
   keygen_info->SetComment("hello gpgfrontend");
-  keygen_info->SetAlgo(std::get<1>(keygen_info->GetSupportedKeyAlgo()[2]));
-  keygen_info->SetKeyLength(0);
-  keygen_info->SetAllowAuthentication(true);
-  keygen_info->SetAllowCertification(true);
-  keygen_info->SetAllowEncryption(true);
-  keygen_info->SetAllowSigning(true);
+  keygen_info->SetAlgo("ed25519");
   keygen_info->SetNonExpired(false);
+  keygen_info->SetNonPassPhrase(true);
 
   auto expire_time =
       QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600));
@@ -282,20 +222,12 @@ TEST_F(GpgCoreTest, GenerateKeyED25519CV25519Test) {
   keygen_info->SetName("foo_ec");
   keygen_info->SetEmail("[email protected]");
   keygen_info->SetComment("ecccc");
-  keygen_info->SetAlgo(std::get<1>(keygen_info->GetSupportedKeyAlgo()[3]));
-  keygen_info->SetAllowAuthentication(true);
-  keygen_info->SetAllowCertification(true);
-  keygen_info->SetAllowEncryption(true);
-  keygen_info->SetAllowSigning(true);
+  keygen_info->SetAlgo("ed25519");
   keygen_info->SetNonExpired(true);
   keygen_info->SetNonPassPhrase(true);
 
   auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo(std::get<2>(keygen_info->GetSupportedKeyAlgo()[3]));
-  subkeygen_info->SetAllowAuthentication(true);
-  subkeygen_info->SetAllowCertification(true);
-  subkeygen_info->SetAllowEncryption(true);
-  subkeygen_info->SetAllowSigning(true);
+  subkeygen_info->SetAlgo("cv25519");
   subkeygen_info->SetNonExpired(true);
   subkeygen_info->SetNonPassPhrase(true);
 
@@ -356,20 +288,12 @@ TEST_F(GpgCoreTest, GenerateKeyED25519NISTP256Test) {
   keygen_info->SetName("foo_ec2");
   keygen_info->SetEmail("[email protected]");
   keygen_info->SetComment("ecccc");
-  keygen_info->SetAlgo(std::get<1>(keygen_info->GetSupportedKeyAlgo()[4]));
-  keygen_info->SetAllowAuthentication(true);
-  keygen_info->SetAllowCertification(true);
-  keygen_info->SetAllowEncryption(true);
-  keygen_info->SetAllowSigning(true);
+  keygen_info->SetAlgo("ed25519");
   keygen_info->SetNonExpired(true);
   keygen_info->SetNonPassPhrase(true);
 
   auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo(std::get<2>(keygen_info->GetSupportedKeyAlgo()[4]));
-  subkeygen_info->SetAllowAuthentication(true);
-  subkeygen_info->SetAllowCertification(true);
-  subkeygen_info->SetAllowEncryption(true);
-  subkeygen_info->SetAllowSigning(true);
+  subkeygen_info->SetAlgo("nistp256");
   subkeygen_info->SetNonExpired(true);
   subkeygen_info->SetNonPassPhrase(true);
 
@@ -430,20 +354,12 @@ TEST_F(GpgCoreTest, GenerateKeyED25519BRAINPOOLP256R1Test) {
   keygen_info->SetName("foo_ec3");
   keygen_info->SetEmail("[email protected]");
   keygen_info->SetComment("ecccc3");
-  keygen_info->SetAlgo(std::get<1>(keygen_info->GetSupportedKeyAlgo()[5]));
-  keygen_info->SetAllowAuthentication(true);
-  keygen_info->SetAllowCertification(true);
-  keygen_info->SetAllowEncryption(true);
-  keygen_info->SetAllowSigning(true);
+  keygen_info->SetAlgo("ed25519");
   keygen_info->SetNonExpired(true);
   keygen_info->SetNonPassPhrase(true);
 
   auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo(std::get<2>(keygen_info->GetSupportedKeyAlgo()[5]));
-  subkeygen_info->SetAllowAuthentication(true);
-  subkeygen_info->SetAllowCertification(true);
-  subkeygen_info->SetAllowEncryption(true);
-  subkeygen_info->SetAllowSigning(true);
+  subkeygen_info->SetAlgo("brainpoolp256r1");
   subkeygen_info->SetNonExpired(true);
   subkeygen_info->SetNonPassPhrase(true);
 
@@ -499,4 +415,154 @@ TEST_F(GpgCoreTest, GenerateKeyED25519BRAINPOOLP256R1Test) {
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
 }
 
+TEST_F(GpgCoreTest, GenerateKeyNISTP256Test) {
+  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
+  keygen_info->SetName("foo_4");
+  keygen_info->SetEmail("[email protected]");
+  keygen_info->SetComment("hello gpgfrontend");
+  keygen_info->SetAlgo("nistp256");
+  keygen_info->SetNonExpired(false);
+  keygen_info->SetNonPassPhrase(true);
+
+  auto expire_time =
+      QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600));
+  keygen_info->SetExpireTime(expire_time);
+  keygen_info->SetNonPassPhrase(false);
+
+  auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+                                .GenerateKeySync(keygen_info);
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_EQ(data_object->GetObjectSize(), 1);
+  ASSERT_TRUE(data_object->Check<GpgGenerateKeyResult>());
+
+  auto result = ExtractParams<GpgGenerateKeyResult>(data_object, 0);
+  ASSERT_TRUE(result.IsGood());
+  ASSERT_FALSE(result.GetFingerprint().isEmpty());
+
+  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                 .GetKey(result.GetFingerprint());
+  ASSERT_TRUE(key.IsGood());
+  ASSERT_EQ(key.GetName(), "foo_4");
+  ASSERT_EQ(key.GetEmail(), "[email protected]");
+  ASSERT_EQ(key.GetComment(), "hello gpgfrontend");
+  ASSERT_EQ(key.GetPublicKeyAlgo(), "ECDSA");
+  ASSERT_EQ(key.GetKeyAlgo(), "NISTP256");
+  ASSERT_EQ(key.GetOwnerTrustLevel(), 5);
+  ASSERT_EQ(key.GetPrimaryKeyLength(), 256);
+  ASSERT_GT(key.GetExpireTime(), QDateTime::currentDateTime());
+
+  ASSERT_TRUE(key.IsHasCertificationCapability());
+  ASSERT_TRUE(key.IsHasAuthenticationCapability());
+  ASSERT_FALSE(key.IsHasEncryptionCapability());
+  ASSERT_TRUE(key.IsHasSigningCapability());
+
+  ASSERT_TRUE(key.IsHasActualCertificationCapability());
+  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
+  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
+  ASSERT_TRUE(key.IsHasActualSigningCapability());
+
+  GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+      .DeleteKey(result.GetFingerprint());
+}
+
+TEST_F(GpgCoreTest, GenerateKeyED448Test) {
+  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
+  keygen_info->SetName("foo_4");
+  keygen_info->SetEmail("[email protected]");
+  keygen_info->SetComment("hello gpgfrontend");
+  keygen_info->SetAlgo("ed448");
+  keygen_info->SetNonExpired(false);
+  keygen_info->SetNonPassPhrase(true);
+
+  auto expire_time =
+      QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600));
+  keygen_info->SetExpireTime(expire_time);
+  keygen_info->SetNonPassPhrase(false);
+
+  auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+                                .GenerateKeySync(keygen_info);
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_EQ(data_object->GetObjectSize(), 1);
+  ASSERT_TRUE(data_object->Check<GpgGenerateKeyResult>());
+
+  auto result = ExtractParams<GpgGenerateKeyResult>(data_object, 0);
+  ASSERT_TRUE(result.IsGood());
+  ASSERT_FALSE(result.GetFingerprint().isEmpty());
+
+  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                 .GetKey(result.GetFingerprint());
+  ASSERT_TRUE(key.IsGood());
+  ASSERT_EQ(key.GetName(), "foo_4");
+  ASSERT_EQ(key.GetEmail(), "[email protected]");
+  ASSERT_EQ(key.GetComment(), "hello gpgfrontend");
+  ASSERT_EQ(key.GetPublicKeyAlgo(), "EdDSA");
+  ASSERT_EQ(key.GetKeyAlgo(), "ED448");
+  ASSERT_EQ(key.GetOwnerTrustLevel(), 5);
+  ASSERT_EQ(key.GetPrimaryKeyLength(), 448);
+  ASSERT_GT(key.GetExpireTime(), QDateTime::currentDateTime());
+
+  ASSERT_TRUE(key.IsHasCertificationCapability());
+  ASSERT_TRUE(key.IsHasAuthenticationCapability());
+  ASSERT_FALSE(key.IsHasEncryptionCapability());
+  ASSERT_TRUE(key.IsHasSigningCapability());
+
+  ASSERT_TRUE(key.IsHasActualCertificationCapability());
+  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
+  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
+  ASSERT_TRUE(key.IsHasActualSigningCapability());
+
+  GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+      .DeleteKey(result.GetFingerprint());
+}
+
+TEST_F(GpgCoreTest, GenerateKeySECP256K1Test) {
+  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
+  keygen_info->SetName("foo_4");
+  keygen_info->SetEmail("[email protected]");
+  keygen_info->SetComment("hello gpgfrontend");
+  keygen_info->SetAlgo("secp256k1");
+  keygen_info->SetNonExpired(false);
+  keygen_info->SetNonPassPhrase(true);
+
+  auto expire_time =
+      QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600));
+  keygen_info->SetExpireTime(expire_time);
+  keygen_info->SetNonPassPhrase(false);
+
+  auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+                                .GenerateKeySync(keygen_info);
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_EQ(data_object->GetObjectSize(), 1);
+  ASSERT_TRUE(data_object->Check<GpgGenerateKeyResult>());
+
+  auto result = ExtractParams<GpgGenerateKeyResult>(data_object, 0);
+  ASSERT_TRUE(result.IsGood());
+  ASSERT_FALSE(result.GetFingerprint().isEmpty());
+
+  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                 .GetKey(result.GetFingerprint());
+  ASSERT_TRUE(key.IsGood());
+  ASSERT_EQ(key.GetName(), "foo_4");
+  ASSERT_EQ(key.GetEmail(), "[email protected]");
+  ASSERT_EQ(key.GetComment(), "hello gpgfrontend");
+  ASSERT_EQ(key.GetPublicKeyAlgo(), "ECDSA");
+  ASSERT_EQ(key.GetKeyAlgo(), "SECP256K1");
+  ASSERT_EQ(key.GetOwnerTrustLevel(), 5);
+  ASSERT_EQ(key.GetPrimaryKeyLength(), 256);
+  ASSERT_GT(key.GetExpireTime(), QDateTime::currentDateTime());
+
+  ASSERT_TRUE(key.IsHasCertificationCapability());
+  ASSERT_TRUE(key.IsHasAuthenticationCapability());
+  ASSERT_FALSE(key.IsHasEncryptionCapability());
+  ASSERT_TRUE(key.IsHasSigningCapability());
+
+  ASSERT_TRUE(key.IsHasActualCertificationCapability());
+  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
+  ASSERT_FALSE(key.IsHasActualEncryptionCapability());
+  ASSERT_TRUE(key.IsHasActualSigningCapability());
+
+  GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+      .DeleteKey(result.GetFingerprint());
+}
+
 }  // namespace GpgFrontend::Test
diff --git a/src/test/core/GpgCoreTestSubkeygen.cpp b/src/test/core/GpgCoreTestSubkeygen.cpp
index 7c826c24..c4fe92b0 100644
--- a/src/test/core/GpgCoreTestSubkeygen.cpp
+++ b/src/test/core/GpgCoreTestSubkeygen.cpp
@@ -43,13 +43,8 @@ TEST_F(GpgCoreTest, GenerateSubkeyRSA2048Test) {
   ASSERT_TRUE(main_key.IsGood());
 
   auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo(
-      std::get<2>(subkeygen_info->GetSupportedSubkeyAlgo()[0]));
+  subkeygen_info->SetAlgo("rsa");
   subkeygen_info->SetKeyLength(2048);
-  subkeygen_info->SetAllowAuthentication(true);
-  subkeygen_info->SetAllowCertification(true);
-  subkeygen_info->SetAllowEncryption(true);
-  subkeygen_info->SetAllowSigning(true);
   subkeygen_info->SetNonExpired(true);
   subkeygen_info->SetNonPassPhrase(true);
 
@@ -87,13 +82,8 @@ TEST_F(GpgCoreTest, GenerateSubkeyDSA2048Test) {
   ASSERT_TRUE(main_key.IsGood());
 
   auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo(
-      std::get<2>(subkeygen_info->GetSupportedSubkeyAlgo()[1]));
+  subkeygen_info->SetAlgo("dsa");
   subkeygen_info->SetKeyLength(2048);
-  subkeygen_info->SetAllowAuthentication(true);
-  subkeygen_info->SetAllowCertification(true);
-  subkeygen_info->SetAllowEncryption(true);
-  subkeygen_info->SetAllowSigning(true);
   subkeygen_info->SetNonExpired(true);
   subkeygen_info->SetNonPassPhrase(true);
 
@@ -125,19 +115,52 @@ TEST_F(GpgCoreTest, GenerateSubkeyDSA2048Test) {
   ASSERT_TRUE(subkey.IsHasSigningCapability());
 }
 
-TEST_F(GpgCoreTest, GenerateSubkeyED25519Test) {
+TEST_F(GpgCoreTest, GenerateSubkeyELG2048Test) {
   auto main_key = GpgKeyGetter::GetInstance().GetKey(
       "E87C6A2D8D95C818DE93B3AE6A2764F8298DEB29");
   ASSERT_TRUE(main_key.IsGood());
 
   auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo(
-      std::get<2>(subkeygen_info->GetSupportedSubkeyAlgo()[2]));
+  subkeygen_info->SetAlgo("elg");
   subkeygen_info->SetKeyLength(2048);
-  subkeygen_info->SetAllowAuthentication(true);
-  subkeygen_info->SetAllowCertification(true);
-  subkeygen_info->SetAllowEncryption(true);
-  subkeygen_info->SetAllowSigning(true);
+  subkeygen_info->SetNonExpired(true);
+  subkeygen_info->SetNonPassPhrase(true);
+
+  auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+                                .GenerateSubkeySync(main_key, subkeygen_info);
+
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_EQ(data_object->GetObjectSize(), 1);
+  ASSERT_TRUE(data_object->Check<GpgGenerateKeyResult>());
+
+  auto result = ExtractParams<GpgGenerateKeyResult>(data_object, 0);
+  ASSERT_TRUE(result.IsGood());
+  ASSERT_FALSE(result.GetFingerprint().isEmpty());
+  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                 .GetKey(result.GetFingerprint());
+  ASSERT_TRUE(key.IsGood());
+
+  auto subkeys = key.GetSubKeys();
+  auto& subkey = subkeys->back();
+
+  ASSERT_EQ(subkey.GetPubkeyAlgo(), "ELG-E");
+  ASSERT_EQ(subkey.GetKeyAlgo(), "ELG2048");
+  ASSERT_EQ(subkey.GetKeyLength(), 2048);
+  ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
+
+  ASSERT_FALSE(subkey.IsHasCertificationCapability());
+  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
+  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
+  ASSERT_FALSE(subkey.IsHasSigningCapability());
+}
+
+TEST_F(GpgCoreTest, GenerateSubkeyED25519Test) {
+  auto main_key = GpgKeyGetter::GetInstance().GetKey(
+      "E87C6A2D8D95C818DE93B3AE6A2764F8298DEB29");
+  ASSERT_TRUE(main_key.IsGood());
+
+  auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
+  subkeygen_info->SetAlgo("ed25519");
   subkeygen_info->SetNonExpired(true);
   subkeygen_info->SetNonPassPhrase(true);
 
@@ -175,13 +198,7 @@ TEST_F(GpgCoreTest, GenerateSubkeyCV25519Test) {
   ASSERT_TRUE(main_key.IsGood());
 
   auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo(
-      std::get<2>(subkeygen_info->GetSupportedSubkeyAlgo()[3]));
-  subkeygen_info->SetKeyLength(2048);
-  subkeygen_info->SetAllowAuthentication(true);
-  subkeygen_info->SetAllowCertification(true);
-  subkeygen_info->SetAllowEncryption(true);
-  subkeygen_info->SetAllowSigning(true);
+  subkeygen_info->SetAlgo("cv25519");
   subkeygen_info->SetNonExpired(true);
   subkeygen_info->SetNonPassPhrase(true);
 
@@ -202,8 +219,8 @@ TEST_F(GpgCoreTest, GenerateSubkeyCV25519Test) {
   auto subkeys = key.GetSubKeys();
   auto& subkey = subkeys->back();
 
-  ASSERT_EQ(subkey.GetPubkeyAlgo(), "ECDH");
-  ASSERT_EQ(subkey.GetKeyAlgo(), "CV25519");
+  ASSERT_EQ(subkey.GetPubkeyAlgo(), QString("ECDH"));
+  ASSERT_EQ(subkey.GetKeyAlgo(), QString("CV25519"));
   ASSERT_EQ(subkey.GetKeyLength(), 255);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
@@ -219,15 +236,8 @@ TEST_F(GpgCoreTest, GenerateSubkeyNISTP256Test) {
   ASSERT_TRUE(main_key.IsGood());
 
   auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo(
-      std::get<2>(subkeygen_info->GetSupportedSubkeyAlgo()[4]));
-  subkeygen_info->SetKeyLength(2048);
-  subkeygen_info->SetAllowAuthentication(true);
-  subkeygen_info->SetAllowCertification(true);
-  subkeygen_info->SetAllowEncryption(true);
-  subkeygen_info->SetAllowSigning(true);
+  subkeygen_info->SetAlgo("nistp256");
   subkeygen_info->SetNonExpired(true);
-  subkeygen_info->SetNonPassPhrase(true);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
                                 .GenerateSubkeySync(main_key, subkeygen_info);
@@ -246,8 +256,8 @@ TEST_F(GpgCoreTest, GenerateSubkeyNISTP256Test) {
   auto subkeys = key.GetSubKeys();
   auto& subkey = subkeys->back();
 
-  ASSERT_EQ(subkey.GetPubkeyAlgo(), "ECDH");
-  ASSERT_EQ(subkey.GetKeyAlgo(), "NISTP256");
+  ASSERT_EQ(subkey.GetPubkeyAlgo(), QString("ECDH"));
+  ASSERT_EQ(subkey.GetKeyAlgo(), QString("NISTP256"));
   ASSERT_EQ(subkey.GetKeyLength(), 256);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
 
@@ -263,15 +273,82 @@ TEST_F(GpgCoreTest, GenerateSubkeyBRAINPOOLP256R1Test) {
   ASSERT_TRUE(main_key.IsGood());
 
   auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
-  subkeygen_info->SetAlgo(
-      std::get<2>(subkeygen_info->GetSupportedSubkeyAlgo()[7]));
-  subkeygen_info->SetKeyLength(2048);
-  subkeygen_info->SetAllowAuthentication(true);
-  subkeygen_info->SetAllowCertification(true);
-  subkeygen_info->SetAllowEncryption(true);
-  subkeygen_info->SetAllowSigning(true);
+  subkeygen_info->SetAlgo("brainpoolp256r1");
+  subkeygen_info->SetNonExpired(true);
+
+  auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+                                .GenerateSubkeySync(main_key, subkeygen_info);
+
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_EQ(data_object->GetObjectSize(), 1);
+  ASSERT_TRUE(data_object->Check<GpgGenerateKeyResult>());
+
+  auto result = ExtractParams<GpgGenerateKeyResult>(data_object, 0);
+  ASSERT_TRUE(result.IsGood());
+  ASSERT_FALSE(result.GetFingerprint().isEmpty());
+  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                 .GetKey(result.GetFingerprint());
+  ASSERT_TRUE(key.IsGood());
+
+  auto subkeys = key.GetSubKeys();
+  auto& subkey = subkeys->back();
+
+  ASSERT_EQ(subkey.GetPubkeyAlgo(), QString("ECDH"));
+  ASSERT_EQ(subkey.GetKeyAlgo(), QString("BRAINPOOLP256R1"));
+  ASSERT_EQ(subkey.GetKeyLength(), 256);
+  ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
+
+  ASSERT_FALSE(subkey.IsHasCertificationCapability());
+  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
+  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
+  ASSERT_FALSE(subkey.IsHasSigningCapability());
+}
+
+TEST_F(GpgCoreTest, GenerateSubkeyX448Test) {
+  auto main_key = GpgKeyGetter::GetInstance().GetKey(
+      "E87C6A2D8D95C818DE93B3AE6A2764F8298DEB29");
+  ASSERT_TRUE(main_key.IsGood());
+
+  auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
+  subkeygen_info->SetAlgo("x448");
+  subkeygen_info->SetNonExpired(true);
+
+  auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+                                .GenerateSubkeySync(main_key, subkeygen_info);
+
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_EQ(data_object->GetObjectSize(), 1);
+  ASSERT_TRUE(data_object->Check<GpgGenerateKeyResult>());
+
+  auto result = ExtractParams<GpgGenerateKeyResult>(data_object, 0);
+  ASSERT_TRUE(result.IsGood());
+  ASSERT_FALSE(result.GetFingerprint().isEmpty());
+  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                 .GetKey(result.GetFingerprint());
+  ASSERT_TRUE(key.IsGood());
+
+  auto subkeys = key.GetSubKeys();
+  auto& subkey = subkeys->back();
+
+  ASSERT_EQ(subkey.GetPubkeyAlgo(), QString("ECDH"));
+  ASSERT_EQ(subkey.GetKeyAlgo(), QString("CV448"));
+  ASSERT_EQ(subkey.GetKeyLength(), 448);
+  ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
+
+  ASSERT_FALSE(subkey.IsHasCertificationCapability());
+  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
+  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
+  ASSERT_FALSE(subkey.IsHasSigningCapability());
+}
+
+TEST_F(GpgCoreTest, GenerateSubkeySECP256K1Test) {
+  auto main_key = GpgKeyGetter::GetInstance().GetKey(
+      "E87C6A2D8D95C818DE93B3AE6A2764F8298DEB29");
+  ASSERT_TRUE(main_key.IsGood());
+
+  auto subkeygen_info = SecureCreateSharedObject<GenKeyInfo>(true);
+  subkeygen_info->SetAlgo("secp256k1");
   subkeygen_info->SetNonExpired(true);
-  subkeygen_info->SetNonPassPhrase(true);
 
   auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
                                 .GenerateSubkeySync(main_key, subkeygen_info);
@@ -290,8 +367,8 @@ TEST_F(GpgCoreTest, GenerateSubkeyBRAINPOOLP256R1Test) {
   auto subkeys = key.GetSubKeys();
   auto& subkey = subkeys->back();
 
-  ASSERT_EQ(subkey.GetPubkeyAlgo(), "ECDH");
-  ASSERT_EQ(subkey.GetKeyAlgo(), "BRAINPOOLP256R1");
+  ASSERT_EQ(subkey.GetPubkeyAlgo(), QString("ECDH"));
+  ASSERT_EQ(subkey.GetKeyAlgo(), QString("SECP256K1"));
   ASSERT_EQ(subkey.GetKeyLength(), 256);
   ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));