1 files changed, 413 insertions, 123 deletions

diff --git a/src/test/core/GpgCoreTestKeygen.cpp b/src/test/core/GpgCoreTestKeygen.cpp
index 57e7cbb9..8a473aea 100644
--- a/src/test/core/GpgCoreTestKeygen.cpp
+++ b/src/test/core/GpgCoreTestKeygen.cpp
@@ -26,15 +26,9 @@
  *
  */
 
-#include <gtest/gtest.h>
-#include <qeventloop.h>
-
-#include <cstddef>
-
 #include "GpgCoreTest.h"
 #include "core/function/gpg/GpgKeyGetter.h"
 #include "core/function/gpg/GpgKeyOpera.h"
-#include "core/function/result_analyse/GpgResultAnalyse.h"
 #include "core/model/GpgGenKeyInfo.h"
 #include "core/model/GpgGenerateKeyResult.h"
 #include "core/model/GpgKey.h"
@@ -43,170 +37,466 @@
 
 namespace GpgFrontend::Test {
 
-TEST_F(GpgCoreTest, GenerateKeyTest) {
+TEST_F(GpgCoreTest, GenerateKeyRSA2048Test) {
   auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
   keygen_info->SetName("foo_0");
   keygen_info->SetEmail("[email protected]");
-  keygen_info->SetComment("");
-  keygen_info->SetKeyLength(1024);
+  keygen_info->SetComment("foobar");
+  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(true);
+  keygen_info->SetNonPassPhrase(false);
 
-  std::atomic_bool callback_called_flag{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_0");
+  ASSERT_EQ(key.GetEmail(), "[email protected]");
+  ASSERT_EQ(key.GetComment(), "foobar");
+  ASSERT_EQ(key.GetPublicKeyAlgo(), "RSA");
+  ASSERT_EQ(key.GetOwnerTrustLevel(), 5);
+  ASSERT_EQ(key.GetPrimaryKeyLength(), 2048);
+  ASSERT_EQ(key.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
+
+  ASSERT_TRUE(key.IsHasCertificationCapability());
+  ASSERT_TRUE(key.IsHasAuthenticationCapability());
+  ASSERT_TRUE(key.IsHasEncryptionCapability());
+  ASSERT_TRUE(key.IsHasSigningCapability());
+
+  ASSERT_TRUE(key.IsHasActualCertificationCapability());
+  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
+  ASSERT_TRUE(key.IsHasActualEncryptionCapability());
+  ASSERT_TRUE(key.IsHasActualSigningCapability());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
-      .GenerateKey(keygen_info, [&callback_called_flag](
-                                    GpgError err,
-                                    const DataObjectPtr& data_object) {
-        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());
-        auto fpr = result.GetFingerprint();
-
-        auto key =
-            GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).GetKey(fpr);
-        ASSERT_TRUE(key.IsGood());
-
-        GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
-
-        callback_called_flag = true;
-        ASSERT_FALSE(fpr.isEmpty());
-      });
-
-  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);
+      .DeleteKey(result.GetFingerprint());
 }
 
-TEST_F(GpgCoreTest, GenerateKeyTest_1) {
+TEST_F(GpgCoreTest, GenerateKeyRSA1024NoPassTest) {
   auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
   keygen_info->SetName("foo_1");
   keygen_info->SetEmail("[email protected]");
-  keygen_info->SetComment("hello gpgfrontend");
+  keygen_info->SetComment("foobar_1");
+  keygen_info->SetKeyLength(2048);
   keygen_info->SetAlgo(std::get<1>(keygen_info->GetSupportedKeyAlgo()[0]));
-  keygen_info->SetKeyLength(4096);
+  keygen_info->SetAllowAuthentication(false);
+  keygen_info->SetAllowCertification(false);
+  keygen_info->SetAllowEncryption(false);
+  keygen_info->SetAllowSigning(false);
   keygen_info->SetNonExpired(false);
-  keygen_info->SetExpireTime(
-      QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600)));
-  keygen_info->SetNonPassPhrase(false);
+  keygen_info->SetNonPassPhrase(true);
 
-  std::atomic_bool callback_called_flag{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_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)
-      .GenerateKey(keygen_info, [&callback_called_flag](
-                                    GpgError err,
-                                    const DataObjectPtr& data_object) {
-        ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+      .DeleteKey(result.GetFingerprint());
+}
 
-        ASSERT_EQ(data_object->GetObjectSize(), 1);
-        ASSERT_TRUE(data_object->Check<GpgGenerateKeyResult>());
+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->SetNonExpired(false);
 
-        auto result = ExtractParams<GpgGenerateKeyResult>(data_object, 0);
-        ASSERT_TRUE(result.IsGood());
-        auto fpr = result.GetFingerprint();
+  auto expire_time =
+      QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600));
+  keygen_info->SetExpireTime(expire_time);
+  keygen_info->SetNonPassPhrase(false);
 
-        auto key =
-            GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).GetKey(fpr);
-        ASSERT_TRUE(key.IsGood());
+  auto [err, data_object] = GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+                                .GenerateKeySync(keygen_info);
 
-        GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_EQ(data_object->GetObjectSize(), 1);
+  ASSERT_TRUE(data_object->Check<GpgGenerateKeyResult>());
 
-        callback_called_flag = true;
-        ASSERT_FALSE(fpr.isEmpty());
-      });
+  auto result = ExtractParams<GpgGenerateKeyResult>(data_object, 0);
+  ASSERT_TRUE(result.IsGood());
+  ASSERT_FALSE(result.GetFingerprint().isEmpty());
 
-  int retry_count = 2000;
-  while (!callback_called_flag && retry_count-- > 0) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
-  }
+  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
+                 .GetKey(result.GetFingerprint());
+  ASSERT_TRUE(key.IsGood());
+  ASSERT_EQ(key.GetExpireTime().date(), expire_time.date());
 
-  ASSERT_TRUE(callback_called_flag);
+  GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+      .DeleteKey(result.GetFingerprint());
 }
 
-TEST_F(GpgCoreTest, GenerateKeyTest_4) {
+TEST_F(GpgCoreTest, GenerateKeyDSA2048Test) {
   auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
-  keygen_info->SetName("foo_2");
-  keygen_info->SetEmail("[email protected]");
-  keygen_info->SetComment("");
+  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->SetNonExpired(true);
+  keygen_info->SetKeyLength(2048);
+  keygen_info->SetAllowAuthentication(true);
+  keygen_info->SetAllowCertification(true);
+  keygen_info->SetAllowEncryption(true);
+  keygen_info->SetAllowSigning(true);
+  keygen_info->SetNonExpired(false);
+
+  auto expire_time =
+      QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600));
+  keygen_info->SetExpireTime(expire_time);
   keygen_info->SetNonPassPhrase(false);
 
-  std::atomic_bool callback_called_flag{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_1");
+  ASSERT_EQ(key.GetEmail(), "[email protected]");
+  ASSERT_EQ(key.GetComment(), "hello gpgfrontend");
+  ASSERT_EQ(key.GetPublicKeyAlgo(), "DSA");
+  ASSERT_EQ(key.GetOwnerTrustLevel(), 5);
+  ASSERT_EQ(key.GetPrimaryKeyLength(), 2048);
+  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)
-      .GenerateKey(keygen_info, [&callback_called_flag](
-                                    GpgError err,
-                                    const DataObjectPtr& data_object) {
-        ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
-
-        auto result = ExtractParams<GpgGenerateKeyResult>(data_object, 0);
-        ASSERT_TRUE(result.IsGood());
-        auto fpr = result.GetFingerprint();
-
-        auto key =
-            GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).GetKey(fpr);
-        ASSERT_TRUE(key.IsGood());
-
-        GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
-
-        callback_called_flag = true;
-        ASSERT_FALSE(fpr.isEmpty());
-      });
-
-  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);
+      .DeleteKey(result.GetFingerprint());
 }
 
-TEST_F(GpgCoreTest, GenerateKeyTest_5) {
+TEST_F(GpgCoreTest, GenerateKeyED25519Test) {
   auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
-  keygen_info->SetName("foo_3");
-  keygen_info->SetEmail("[email protected]");
-  keygen_info->SetComment("");
+  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->SetNonExpired(true);
+  keygen_info->SetKeyLength(0);
+  keygen_info->SetAllowAuthentication(true);
+  keygen_info->SetAllowCertification(true);
+  keygen_info->SetAllowEncryption(true);
+  keygen_info->SetAllowSigning(true);
+  keygen_info->SetNonExpired(false);
+
+  auto expire_time =
+      QDateTime::currentDateTime().addSecs(static_cast<qint64>(24 * 3600));
+  keygen_info->SetExpireTime(expire_time);
   keygen_info->SetNonPassPhrase(false);
 
-  std::atomic_bool callback_called_flag{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.GetOwnerTrustLevel(), 5);
+  ASSERT_EQ(key.GetPrimaryKeyLength(), 255);
+  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)
-      .GenerateKey(keygen_info, [&callback_called_flag](
-                                    GpgError err,
-                                    const DataObjectPtr& data_object) {
-        ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+      .DeleteKey(result.GetFingerprint());
+}
 
-        auto result = ExtractParams<GpgGenerateKeyResult>(data_object, 0);
-        ASSERT_TRUE(result.IsGood());
-        auto fpr = result.GetFingerprint();
+TEST_F(GpgCoreTest, GenerateKeyED25519CV25519Test) {
+  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
+  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->SetNonExpired(true);
+  keygen_info->SetNonPassPhrase(true);
 
-        auto key =
-            GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).GetKey(fpr);
-        ASSERT_TRUE(key.IsGood());
+  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->SetNonExpired(true);
+  subkeygen_info->SetNonPassPhrase(true);
+
+  auto [err, data_object] =
+      GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+          .GenerateKeyWithSubkeySync(keygen_info, subkeygen_info);
+
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_TRUE(
+      (data_object->Check<GpgGenerateKeyResult, GpgGenerateKeyResult>()));
+  auto result = ExtractParams<GpgGenerateKeyResult>(data_object, 0);
+  ASSERT_TRUE(result.IsGood());
+  auto fpr = result.GetFingerprint();
+  ASSERT_FALSE(fpr.isEmpty());
+
+  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).GetKey(fpr);
+  ASSERT_TRUE(key.IsGood());
+
+  ASSERT_EQ(key.GetName(), "foo_ec");
+  ASSERT_EQ(key.GetEmail(), "[email protected]");
+  ASSERT_EQ(key.GetComment(), "ecccc");
+  ASSERT_EQ(key.GetPublicKeyAlgo(), "EdDSA");
+  ASSERT_EQ(key.GetKeyAlgo(), "ED25519");
+  ASSERT_EQ(key.GetOwnerTrustLevel(), 5);
+  ASSERT_EQ(key.GetPrimaryKeyLength(), 255);
+  ASSERT_EQ(key.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
+
+  ASSERT_TRUE(key.IsHasCertificationCapability());
+  ASSERT_TRUE(key.IsHasAuthenticationCapability());
+  ASSERT_TRUE(key.IsHasEncryptionCapability());
+  ASSERT_TRUE(key.IsHasSigningCapability());
+
+  ASSERT_FALSE(key.GetSubKeys()->empty());
+  ASSERT_EQ(key.GetSubKeys()->size(), 2);
+
+  auto subkeys = key.GetSubKeys();
+  auto& subkey = subkeys->back();
+  ASSERT_EQ(subkey.GetPubkeyAlgo(), "ECDH");
+  ASSERT_EQ(subkey.GetKeyAlgo(), "CV25519");
+  ASSERT_EQ(subkey.GetKeyLength(), 255);
+  ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
+
+  ASSERT_FALSE(subkey.IsHasCertificationCapability());
+  ASSERT_FALSE(subkey.IsHasAuthenticationCapability());
+  ASSERT_TRUE(subkey.IsHasEncryptionCapability());
+  ASSERT_FALSE(subkey.IsHasSigningCapability());
+
+  ASSERT_TRUE(key.IsHasActualCertificationCapability());
+  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
+  ASSERT_TRUE(key.IsHasActualEncryptionCapability());
+  ASSERT_TRUE(key.IsHasActualSigningCapability());
+
+  GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
+}
 
-        GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
+TEST_F(GpgCoreTest, GenerateKeyED25519NISTP256Test) {
+  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
+  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->SetNonExpired(true);
+  keygen_info->SetNonPassPhrase(true);
 
-        callback_called_flag = true;
-        ASSERT_FALSE(fpr.isEmpty());
-      });
+  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->SetNonExpired(true);
+  subkeygen_info->SetNonPassPhrase(true);
+
+  auto [err, data_object] =
+      GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+          .GenerateKeyWithSubkeySync(keygen_info, subkeygen_info);
+
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_TRUE(
+      (data_object->Check<GpgGenerateKeyResult, GpgGenerateKeyResult>()));
+  auto result = ExtractParams<GpgGenerateKeyResult>(data_object, 0);
+  ASSERT_TRUE(result.IsGood());
+  auto fpr = result.GetFingerprint();
+  ASSERT_FALSE(fpr.isEmpty());
+
+  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).GetKey(fpr);
+  ASSERT_TRUE(key.IsGood());
+
+  ASSERT_EQ(key.GetName(), "foo_ec2");
+  ASSERT_EQ(key.GetEmail(), "[email protected]");
+  ASSERT_EQ(key.GetComment(), "ecccc");
+  ASSERT_EQ(key.GetPublicKeyAlgo(), "EdDSA");
+  ASSERT_EQ(key.GetKeyAlgo(), "ED25519");
+  ASSERT_EQ(key.GetOwnerTrustLevel(), 5);
+  ASSERT_EQ(key.GetPrimaryKeyLength(), 255);
+  ASSERT_EQ(key.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
+
+  ASSERT_TRUE(key.IsHasCertificationCapability());
+  ASSERT_TRUE(key.IsHasAuthenticationCapability());
+  ASSERT_TRUE(key.IsHasEncryptionCapability());
+  ASSERT_TRUE(key.IsHasSigningCapability());
+
+  ASSERT_FALSE(key.GetSubKeys()->empty());
+  ASSERT_EQ(key.GetSubKeys()->size(), 2);
+
+  auto subkeys = key.GetSubKeys();
+  auto& subkey = subkeys->back();
+  ASSERT_EQ(subkey.GetPubkeyAlgo(), "ECDH");
+  ASSERT_EQ(subkey.GetKeyAlgo(), "NISTP256");
+  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());
+
+  ASSERT_TRUE(key.IsHasActualCertificationCapability());
+  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
+  ASSERT_TRUE(key.IsHasActualEncryptionCapability());
+  ASSERT_TRUE(key.IsHasActualSigningCapability());
+
+  GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
+}
 
-  int retry_count = 1000;
-  while (!callback_called_flag && retry_count-- > 0) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
-  }
+TEST_F(GpgCoreTest, GenerateKeyED25519BRAINPOOLP256R1Test) {
+  auto keygen_info = SecureCreateSharedObject<GenKeyInfo>();
+  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->SetNonExpired(true);
+  keygen_info->SetNonPassPhrase(true);
 
-  ASSERT_TRUE(callback_called_flag);
+  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->SetNonExpired(true);
+  subkeygen_info->SetNonPassPhrase(true);
+
+  auto [err, data_object] =
+      GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
+          .GenerateKeyWithSubkeySync(keygen_info, subkeygen_info);
+
+  ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
+  ASSERT_TRUE(
+      (data_object->Check<GpgGenerateKeyResult, GpgGenerateKeyResult>()));
+  auto result = ExtractParams<GpgGenerateKeyResult>(data_object, 0);
+  ASSERT_TRUE(result.IsGood());
+  auto fpr = result.GetFingerprint();
+  ASSERT_FALSE(fpr.isEmpty());
+
+  auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel).GetKey(fpr);
+  ASSERT_TRUE(key.IsGood());
+
+  ASSERT_EQ(key.GetName(), "foo_ec3");
+  ASSERT_EQ(key.GetEmail(), "[email protected]");
+  ASSERT_EQ(key.GetComment(), "ecccc3");
+  ASSERT_EQ(key.GetPublicKeyAlgo(), "EdDSA");
+  ASSERT_EQ(key.GetKeyAlgo(), "ED25519");
+  ASSERT_EQ(key.GetOwnerTrustLevel(), 5);
+  ASSERT_EQ(key.GetPrimaryKeyLength(), 255);
+  ASSERT_EQ(key.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
+
+  ASSERT_TRUE(key.IsHasCertificationCapability());
+  ASSERT_TRUE(key.IsHasAuthenticationCapability());
+  ASSERT_TRUE(key.IsHasEncryptionCapability());
+  ASSERT_TRUE(key.IsHasSigningCapability());
+
+  ASSERT_FALSE(key.GetSubKeys()->empty());
+  ASSERT_EQ(key.GetSubKeys()->size(), 2);
+
+  auto subkeys = key.GetSubKeys();
+  auto& subkey = subkeys->back();
+  ASSERT_EQ(subkey.GetPubkeyAlgo(), "ECDH");
+  ASSERT_EQ(subkey.GetKeyAlgo(), "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());
+
+  ASSERT_TRUE(key.IsHasActualCertificationCapability());
+  ASSERT_TRUE(key.IsHasActualAuthenticationCapability());
+  ASSERT_TRUE(key.IsHasActualEncryptionCapability());
+  ASSERT_TRUE(key.IsHasActualSigningCapability());
+
+  GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel).DeleteKey(fpr);
 }
 
 }  // namespace GpgFrontend::Test