refactor: GpgKey and GpgSubKey

6 files changed, 296 insertions, 297 deletions

diff --git a/src/test/core/GpgCoreTestKeyManagement.cpp b/src/test/core/GpgCoreTestKeyManagement.cpp
index 4d80f7d0..6ba24b80 100644
--- a/src/test/core/GpgCoreTestKeyManagement.cpp
+++ b/src/test/core/GpgCoreTestKeyManagement.cpp
@@ -119,10 +119,10 @@ TEST_F(GpgCoreTest, CoreDeleteSubkeyTestA) {
                  .GetKey("822D7E13F5B85D7D");
   ASSERT_TRUE(key.IsGood());
 
-  auto subkeys = key.GetSubKeys();
+  auto s_key = key.SubKeys();
 
-  ASSERT_EQ(subkeys->size(), 5);
-  ASSERT_EQ((*subkeys)[2].GetID(), "2D1F9FC59B568A8C");
+  ASSERT_EQ(s_key.size(), 5);
+  ASSERT_EQ(s_key[2].ID(), "2D1F9FC59B568A8C");
 
   auto res = GpgKeyManager::GetInstance().DeleteSubkey(key, 2);
 
@@ -133,12 +133,12 @@ TEST_F(GpgCoreTest, CoreDeleteSubkeyTestA) {
             .GetKey("822D7E13F5B85D7D");
   ASSERT_TRUE(key.IsGood());
 
-  subkeys = key.GetSubKeys();
+  s_key = key.SubKeys();
 
-  ASSERT_EQ(subkeys->size(), 4);
-  ASSERT_EQ((*subkeys)[2].GetID(), "CE038203C4D03C3D");
+  ASSERT_EQ(s_key.size(), 4);
+  ASSERT_EQ(s_key[2].ID(), "CE038203C4D03C3D");
 
-  GpgKeyOpera::GetInstance().DeleteKey(key.GetId());
+  GpgKeyOpera::GetInstance().DeleteKey(key.ID());
 }
 
 TEST_F(GpgCoreTest, CoreSetOwnerTrustA) {
@@ -161,7 +161,7 @@ TEST_F(GpgCoreTest, CoreSetOwnerTrustA) {
   ASSERT_TRUE(key.IsGood());
 
   // why?
-  ASSERT_EQ(key.GetOwnerTrustLevel(), 0);
+  ASSERT_EQ(key.OwnerTrustLevel(), 0);
 
   res = GpgKeyManager::GetInstance().SetOwnerTrustLevel(key, 2);
   ASSERT_TRUE(res);
@@ -171,7 +171,7 @@ TEST_F(GpgCoreTest, CoreSetOwnerTrustA) {
             .GetKey("822D7E13F5B85D7D");
   ASSERT_TRUE(key.IsGood());
 
-  ASSERT_EQ(key.GetOwnerTrustLevel(), 2);
+  ASSERT_EQ(key.OwnerTrustLevel(), 2);
 
   res = GpgKeyManager::GetInstance().SetOwnerTrustLevel(key, 3);
   ASSERT_TRUE(res);
@@ -181,7 +181,7 @@ TEST_F(GpgCoreTest, CoreSetOwnerTrustA) {
             .GetKey("822D7E13F5B85D7D");
   ASSERT_TRUE(key.IsGood());
 
-  ASSERT_EQ(key.GetOwnerTrustLevel(), 3);
+  ASSERT_EQ(key.OwnerTrustLevel(), 3);
 
   res = GpgKeyManager::GetInstance().SetOwnerTrustLevel(key, 4);
   ASSERT_TRUE(res);
@@ -191,7 +191,7 @@ TEST_F(GpgCoreTest, CoreSetOwnerTrustA) {
             .GetKey("822D7E13F5B85D7D");
   ASSERT_TRUE(key.IsGood());
 
-  ASSERT_EQ(key.GetOwnerTrustLevel(), 4);
+  ASSERT_EQ(key.OwnerTrustLevel(), 4);
 
   res = GpgKeyManager::GetInstance().SetOwnerTrustLevel(key, 5);
   ASSERT_TRUE(res);
@@ -201,7 +201,7 @@ TEST_F(GpgCoreTest, CoreSetOwnerTrustA) {
             .GetKey("822D7E13F5B85D7D");
   ASSERT_TRUE(key.IsGood());
 
-  ASSERT_EQ(key.GetOwnerTrustLevel(), 5);
+  ASSERT_EQ(key.OwnerTrustLevel(), 5);
 
   res = GpgKeyManager::GetInstance().SetOwnerTrustLevel(key, 0);
   ASSERT_FALSE(res);
@@ -212,7 +212,7 @@ TEST_F(GpgCoreTest, CoreSetOwnerTrustA) {
   res = GpgKeyManager::GetInstance().SetOwnerTrustLevel(key, 6);
   ASSERT_FALSE(res);
 
-  GpgKeyOpera::GetInstance().DeleteKey(key.GetId());
+  GpgKeyOpera::GetInstance().DeleteKey(key.ID());
 }
 
 TEST_F(GpgCoreTest, CoreRevokeSubkeyTestA) {
@@ -226,10 +226,10 @@ TEST_F(GpgCoreTest, CoreRevokeSubkeyTestA) {
                  .GetKey("822D7E13F5B85D7D");
   ASSERT_TRUE(key.IsGood());
 
-  auto subkeys = key.GetSubKeys();
+  auto s_key = key.SubKeys();
 
-  ASSERT_EQ(subkeys->size(), 5);
-  ASSERT_EQ((*subkeys)[2].GetID(), "2D1F9FC59B568A8C");
+  ASSERT_EQ(s_key.size(), 5);
+  ASSERT_EQ(s_key[2].ID(), "2D1F9FC59B568A8C");
 
   auto res = GpgKeyManager::GetInstance().RevokeSubkey(
       key, 2, 2, QString("H\nE\nLL\nO\n\n"));
@@ -241,14 +241,14 @@ TEST_F(GpgCoreTest, CoreRevokeSubkeyTestA) {
             .GetKey("822D7E13F5B85D7D");
   ASSERT_TRUE(key.IsGood());
 
-  subkeys = key.GetSubKeys();
+  s_key = key.SubKeys();
 
-  ASSERT_EQ(subkeys->size(), 5);
-  ASSERT_EQ((*subkeys)[2].GetID(), "2D1F9FC59B568A8C");
+  ASSERT_EQ(s_key.size(), 5);
+  ASSERT_EQ(s_key[2].ID(), "2D1F9FC59B568A8C");
 
-  ASSERT_TRUE((*subkeys)[2].IsRevoked());
+  ASSERT_TRUE(s_key[2].IsRevoked());
 
-  GpgKeyOpera::GetInstance().DeleteKey(key.GetId());
+  GpgKeyOpera::GetInstance().DeleteKey(key.ID());
 }
 
 }  // namespace GpgFrontend::Test
\ No newline at end of file
diff --git a/src/test/core/GpgCoreTestKeyModel.cpp b/src/test/core/GpgCoreTestKeyModel.cpp
index 622d7009..878ea953 100644
--- a/src/test/core/GpgCoreTestKeyModel.cpp
+++ b/src/test/core/GpgCoreTestKeyModel.cpp
@@ -64,10 +64,10 @@ TEST_F(GpgCoreTest, GpgKeyTest) {
   ASSERT_FALSE(key.IsDisabled());
   ASSERT_FALSE(key.IsRevoked());
 
-  ASSERT_EQ(key.GetProtocol(), "OpenPGP");
+  ASSERT_EQ(key.Protocol(), "OpenPGP");
 
-  ASSERT_EQ(key.GetSubKeys()->size(), 2);
-  ASSERT_EQ(key.GetUIDs()->size(), 1);
+  ASSERT_EQ(key.SubKeys().size(), 2);
+  ASSERT_EQ(key.UIDs().size(), 1);
 
   ASSERT_TRUE(key.IsHasCertCap());
   ASSERT_FALSE(key.IsHasEncrCap());
@@ -78,78 +78,76 @@ TEST_F(GpgCoreTest, GpgKeyTest) {
   ASSERT_FALSE(key.IsHasActualSignCap());
   ASSERT_FALSE(key.IsHasActualAuthCap());
 
-  ASSERT_EQ(key.GetName(), "GpgFrontendTest");
-  ASSERT_TRUE(key.GetComment().isEmpty());
-  ASSERT_EQ(key.GetEmail(), "[email protected]");
-  ASSERT_EQ(key.GetId(), "81704859182661FB");
-  ASSERT_EQ(key.GetFingerprint(), "9490795B78F8AFE9F93BD09281704859182661FB");
-  ASSERT_EQ(key.GetExpireTime(),
+  ASSERT_EQ(key.Name(), "GpgFrontendTest");
+  ASSERT_TRUE(key.Comment().isEmpty());
+  ASSERT_EQ(key.Email(), "[email protected]");
+  ASSERT_EQ(key.ID(), "81704859182661FB");
+  ASSERT_EQ(key.Fingerprint(), "9490795B78F8AFE9F93BD09281704859182661FB");
+  ASSERT_EQ(key.ExpirationTime(),
             QDateTime::fromString("2023-09-05T04:00:00Z", Qt::ISODate));
-  ASSERT_EQ(key.GetPublicKeyAlgo(), "RSA");
-  ASSERT_EQ(key.GetKeyAlgo(), "RSA3072");
-  ASSERT_EQ(key.GetPrimaryKeyLength(), 3072);
-  ASSERT_EQ(key.GetLastUpdateTime(),
+  ASSERT_EQ(key.PublicKeyAlgo(), "RSA");
+  ASSERT_EQ(key.Algo(), "RSA3072");
+  ASSERT_EQ(key.PrimaryKeyLength(), 3072);
+  ASSERT_EQ(key.LastUpdateTime(),
             QDateTime::fromString("1970-01-01T00:00:00Z", Qt::ISODate));
-  ASSERT_EQ(key.GetCreateTime(),
+  ASSERT_EQ(key.CreationTime(),
             QDateTime::fromString("2021-09-05T06:01:53Z", Qt::ISODate));
 
-  ASSERT_EQ(key.GetOwnerTrust(), "Unknown");
+  ASSERT_EQ(key.OwnerTrust(), "Unknown");
   ASSERT_EQ(key.IsExpired(),
-            key.GetExpireTime() < QDateTime::currentDateTime());
+            key.ExpirationTime() < QDateTime::currentDateTime());
 }
 
 TEST_F(GpgCoreTest, GpgSubKeyTest) {
   auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
                  .GetKey("9490795B78F8AFE9F93BD09281704859182661FB");
-  auto sub_keys = key.GetSubKeys();
-  ASSERT_EQ(sub_keys->size(), 2);
+  auto s_keys = key.SubKeys();
+  ASSERT_EQ(s_keys.size(), 2);
 
-  auto& main_key = sub_keys->front();
+  auto& p_key = s_keys.front();
 
-  ASSERT_EQ(main_key.GetID(), "81704859182661FB");
-  ASSERT_EQ(main_key.GetFingerprint(),
-            "9490795B78F8AFE9F93BD09281704859182661FB");
-  ASSERT_EQ(main_key.GetExpireTime(),
+  ASSERT_EQ(p_key.ID(), "81704859182661FB");
+  ASSERT_EQ(p_key.Fingerprint(), "9490795B78F8AFE9F93BD09281704859182661FB");
+  ASSERT_EQ(p_key.ExpirationTime(),
             QDateTime::fromString("2023-09-05T04:00:00Z", Qt::ISODate));
-  ASSERT_EQ(main_key.GetPubkeyAlgo(), "RSA");
-  ASSERT_EQ(main_key.GetKeyAlgo(), "RSA3072");
-  ASSERT_EQ(main_key.GetKeyLength(), 3072);
-  ASSERT_EQ(main_key.GetCreateTime(),
+  ASSERT_EQ(p_key.PublicKeyAlgo(), "RSA");
+  ASSERT_EQ(p_key.Algo(), "RSA3072");
+  ASSERT_EQ(p_key.KeyLength(), 3072);
+  ASSERT_EQ(p_key.CreationTime(),
             QDateTime::fromString("2021-09-05T06:01:53Z", Qt::ISODate));
-  ASSERT_FALSE(main_key.IsCardKey());
+  ASSERT_FALSE(p_key.IsCardKey());
 
-  auto& sub_key = sub_keys->back();
+  auto& s_key = s_keys.back();
 
-  ASSERT_FALSE(sub_key.IsRevoked());
-  ASSERT_FALSE(sub_key.IsDisabled());
-  ASSERT_EQ(sub_key.GetCreateTime(),
+  ASSERT_FALSE(s_key.IsRevoked());
+  ASSERT_FALSE(s_key.IsDisabled());
+  ASSERT_EQ(s_key.CreationTime(),
             QDateTime::fromString("2021-09-05T06:01:53Z", Qt::ISODate));
 
-  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.GetKeyAlgo(), "RSA3072");
-  ASSERT_EQ(sub_key.GetPubkeyAlgo(), "RSA");
-  ASSERT_FALSE(sub_key.IsHasCertCap());
-  ASSERT_FALSE(sub_key.IsHasAuthCap());
-  ASSERT_FALSE(sub_key.IsHasSignCap());
-  ASSERT_TRUE(sub_key.IsHasEncrCap());
-  ASSERT_EQ(sub_key.GetExpireTime(),
+  ASSERT_FALSE(s_key.IsCardKey());
+  ASSERT_TRUE(s_key.IsPrivateKey());
+  ASSERT_EQ(s_key.ID(), "2B36803235B5E25B");
+  ASSERT_EQ(s_key.Fingerprint(), "50D37E8F8EE7340A6794E0592B36803235B5E25B");
+  ASSERT_EQ(s_key.KeyLength(), 3072);
+  ASSERT_EQ(s_key.Algo(), "RSA3072");
+  ASSERT_EQ(s_key.PublicKeyAlgo(), "RSA");
+  ASSERT_FALSE(s_key.IsHasCertCap());
+  ASSERT_FALSE(s_key.IsHasAuthCap());
+  ASSERT_FALSE(s_key.IsHasSignCap());
+  ASSERT_TRUE(s_key.IsHasEncrCap());
+  ASSERT_EQ(s_key.ExpirationTime(),
             QDateTime::fromString("2023-09-05T04:00:00Z", Qt::ISODate));
 
-  ASSERT_EQ(sub_key.IsExpired(),
-            sub_key.GetExpireTime() < QDateTime::currentDateTime());
+  ASSERT_EQ(s_key.IsExpired(),
+            s_key.ExpirationTime() < QDateTime::currentDateTime());
 }
 
 TEST_F(GpgCoreTest, GpgUIDTest) {
   auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
                  .GetKey("9490795B78F8AFE9F93BD09281704859182661FB");
-  auto uids = key.GetUIDs();
-  ASSERT_EQ(uids->size(), 1);
-  auto& uid = uids->front();
+  auto uids = key.UIDs();
+  ASSERT_EQ(uids.size(), 1);
+  auto& uid = uids.front();
 
   ASSERT_EQ(uid.GetName(), "GpgFrontendTest");
   ASSERT_TRUE(uid.GetComment().isEmpty());
@@ -162,9 +160,9 @@ TEST_F(GpgCoreTest, GpgUIDTest) {
 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 uids = key.UIDs();
+  ASSERT_EQ(uids.size(), 1);
+  auto& uid = uids.front();
 
   auto signatures = uid.GetSignatures();
   ASSERT_EQ(signatures->size(), 1);
diff --git a/src/test/core/GpgCoreTestKeyOpera.cpp b/src/test/core/GpgCoreTestKeyOpera.cpp
index 6f1f41d5..84aa29f9 100644
--- a/src/test/core/GpgCoreTestKeyOpera.cpp
+++ b/src/test/core/GpgCoreTestKeyOpera.cpp
@@ -28,9 +28,9 @@
 
 #include "GpgCoreTest.h"
 #include "core/GpgConstants.h"
+#include "core/function/gpg/GpgKeyImportExporter.h"
 #include "core/function/gpg/GpgKeyOpera.h"
 #include "core/model/GpgGenerateKeyResult.h"
-#include "core/function/gpg/GpgKeyImportExporter.h"
 #include "core/model/GpgImportInformation.h"
 #include "core/utils/GpgUtils.h"
 
@@ -88,10 +88,11 @@ TEST_F(GpgCoreTest, CoreAddADSKTestA) {
   ASSERT_TRUE(key_b.IsPrivateKey());
   ASSERT_TRUE(key_b.IsHasMasterKey());
 
-  auto key_b_subkeys = key_b.GetSubKeys();
-  ASSERT_EQ(key_b_subkeys->size(), 2);
+  auto key_b_s_keys = key_b.SubKeys();
+  ASSERT_EQ(key_b_s_keys.size(), 2);
 
-  auto [err, data_object] = GpgKeyOpera::GetInstance().AddADSKSync(key, key_b_subkeys->last());
+  auto [err, data_object] =
+      GpgKeyOpera::GetInstance().AddADSKSync(key, key_b_s_keys.last());
 
   ASSERT_EQ(CheckGpgError(err), GPG_ERR_NO_ERROR);
   ASSERT_EQ(data_object->GetObjectSize(), 1);
@@ -107,11 +108,11 @@ TEST_F(GpgCoreTest, CoreAddADSKTestA) {
   ASSERT_TRUE(key.IsPrivateKey());
   ASSERT_TRUE(key.IsHasMasterKey());
 
-  auto key_subkeys = key.GetSubKeys();
-  ASSERT_EQ(key_subkeys->size(), 2);
-  ASSERT_EQ(key_subkeys->last().GetID(), "F89C95A05088CC93");
-  ASSERT_EQ(key_subkeys->last().IsADSK(), true);
+  auto s_keys = key.SubKeys();
+  ASSERT_EQ(s_keys.size(), 2);
+  ASSERT_EQ(s_keys.last().ID(), "F89C95A05088CC93");
+  ASSERT_EQ(s_keys.last().IsADSK(), true);
 
-  GpgKeyOpera::GetInstance().DeleteKey(key.GetId());
+  GpgKeyOpera::GetInstance().DeleteKey(key.ID());
 }
-};
\ No newline at end of file
+};  // namespace GpgFrontend::Test
\ No newline at end of file
diff --git a/src/test/core/GpgCoreTestKeyUIDOpera.cpp b/src/test/core/GpgCoreTestKeyUIDOpera.cpp
index b4177dea..7b141670 100644
--- a/src/test/core/GpgCoreTestKeyUIDOpera.cpp
+++ b/src/test/core/GpgCoreTestKeyUIDOpera.cpp
@@ -73,10 +73,10 @@ TEST_F(GpgCoreTest, CoreDeleteUIDTestA) {
                  .GetKey("F2D8DFA5F109DE47");
   ASSERT_TRUE(key.IsGood());
 
-  auto uids = key.GetUIDs();
+  auto uids = key.UIDs();
 
-  ASSERT_EQ(uids->size(), 4);
-  ASSERT_EQ((*uids)[2].GetUID(), "gggggg(ggggg)<[email protected]>");
+  ASSERT_EQ(uids.size(), 4);
+  ASSERT_EQ(uids[2].GetUID(), "gggggg(ggggg)<[email protected]>");
 
   auto res = GpgUIDOperator::GetInstance().DeleteUID(key, 3);
 
@@ -87,12 +87,12 @@ TEST_F(GpgCoreTest, CoreDeleteUIDTestA) {
             .GetKey("F2D8DFA5F109DE47");
   ASSERT_TRUE(key.IsGood());
 
-  uids = key.GetUIDs();
+  uids = key.UIDs();
 
-  ASSERT_EQ(uids->size(), 3);
-  ASSERT_EQ((*uids)[2].GetUID(), "hhhhhh(hhhhhhh)<[email protected]>");
+  ASSERT_EQ(uids.size(), 3);
+  ASSERT_EQ(uids[2].GetUID(), "hhhhhh(hhhhhhh)<[email protected]>");
 
-  GpgKeyOpera::GetInstance().DeleteKey(key.GetId());
+  GpgKeyOpera::GetInstance().DeleteKey(key.ID());
   GpgKeyGetter::GetInstance().FlushKeyCache();
 }
 
@@ -108,10 +108,10 @@ TEST_F(GpgCoreTest, CoreRevokeUIDTestA) {
                  .GetKey("F2D8DFA5F109DE47");
   ASSERT_TRUE(key.IsGood());
 
-  auto uids = key.GetUIDs();
+  auto uids = key.UIDs();
 
-  ASSERT_EQ(uids->size(), 4);
-  ASSERT_EQ((*uids)[2].GetUID(), "gggggg(ggggg)<[email protected]>");
+  ASSERT_EQ(uids.size(), 4);
+  ASSERT_EQ(uids[2].GetUID(), "gggggg(ggggg)<[email protected]>");
 
   auto res = GpgUIDOperator::GetInstance().RevokeUID(
       key, 3, 4, "H\nEEEEEL\n\n\n\nL   \n0\n");
@@ -123,13 +123,13 @@ TEST_F(GpgCoreTest, CoreRevokeUIDTestA) {
             .GetKey("F2D8DFA5F109DE47");
   ASSERT_TRUE(key.IsGood());
 
-  uids = key.GetUIDs();
+  uids = key.UIDs();
 
-  ASSERT_EQ(uids->size(), 4);
-  ASSERT_EQ((*uids)[2].GetUID(), "gggggg(ggggg)<[email protected]>");
-  ASSERT_TRUE((*uids)[2].GetRevoked());
+  ASSERT_EQ(uids.size(), 4);
+  ASSERT_EQ(uids[2].GetUID(), "gggggg(ggggg)<[email protected]>");
+  ASSERT_TRUE(uids[2].GetRevoked());
 
-  GpgKeyOpera::GetInstance().DeleteKey(key.GetId());
+  GpgKeyOpera::GetInstance().DeleteKey(key.ID());
   GpgKeyGetter::GetInstance().FlushKeyCache();
 }
 
diff --git a/src/test/core/GpgCoreTestKeygen.cpp b/src/test/core/GpgCoreTestKeygen.cpp
index a6c28219..a8ad7005 100644
--- a/src/test/core/GpgCoreTestKeygen.cpp
+++ b/src/test/core/GpgCoreTestKeygen.cpp
@@ -84,13 +84,13 @@ TEST_F(GpgCoreTest, GenerateKeyRSA2048Test) {
                  .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_EQ(key.Name(), "foo_0");
+  ASSERT_EQ(key.Email(), "[email protected]");
+  ASSERT_EQ(key.Comment(), "foobar");
+  ASSERT_EQ(key.PublicKeyAlgo(), "RSA");
+  ASSERT_EQ(key.OwnerTrustLevel(), 5);
+  ASSERT_EQ(key.PrimaryKeyLength(), 2048);
+  ASSERT_EQ(key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
 
   ASSERT_TRUE(key.IsHasCertCap());
   ASSERT_TRUE(key.IsHasAuthCap());
@@ -139,7 +139,7 @@ TEST_F(GpgCoreTest, GenerateKeyRSA4096Test) {
   auto key = GpgKeyGetter::GetInstance(kGpgFrontendDefaultChannel)
                  .GetKey(result.GetFingerprint());
   ASSERT_TRUE(key.IsGood());
-  ASSERT_EQ(key.GetExpireTime().date(), expire_time.date());
+  ASSERT_EQ(key.ExpirationTime().date(), expire_time.date());
 
   GpgKeyOpera::GetInstance(kGpgFrontendDefaultChannel)
       .DeleteKey(result.GetFingerprint());
@@ -177,13 +177,13 @@ TEST_F(GpgCoreTest, GenerateKeyDSA2048Test) {
   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_EQ(key.Name(), "foo_1");
+  ASSERT_EQ(key.Email(), "[email protected]");
+  ASSERT_EQ(key.Comment(), "hello gpgfrontend");
+  ASSERT_EQ(key.PublicKeyAlgo(), "DSA");
+  ASSERT_EQ(key.OwnerTrustLevel(), 5);
+  ASSERT_EQ(key.PrimaryKeyLength(), 2048);
+  ASSERT_GT(key.ExpirationTime(), QDateTime::currentDateTime());
 
   ASSERT_TRUE(key.IsHasCertCap());
   ASSERT_TRUE(key.IsHasAuthCap());
@@ -231,13 +231,13 @@ TEST_F(GpgCoreTest, GenerateKeyED25519Test) {
   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_EQ(key.Name(), "foo_4");
+  ASSERT_EQ(key.Email(), "[email protected]");
+  ASSERT_EQ(key.Comment(), "hello gpgfrontend");
+  ASSERT_EQ(key.PublicKeyAlgo(), "EdDSA");
+  ASSERT_EQ(key.OwnerTrustLevel(), 5);
+  ASSERT_EQ(key.PrimaryKeyLength(), 255);
+  ASSERT_GT(key.ExpirationTime(), QDateTime::currentDateTime());
 
   ASSERT_TRUE(key.IsHasCertCap());
   ASSERT_TRUE(key.IsHasAuthCap());
@@ -291,34 +291,34 @@ TEST_F(GpgCoreTest, GenerateKeyED25519CV25519Test) {
   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_EQ(key.Name(), "foo_ec");
+  ASSERT_EQ(key.Email(), "[email protected]");
+  ASSERT_EQ(key.Comment(), "ecccc");
+  ASSERT_EQ(key.PublicKeyAlgo(), "EdDSA");
+  ASSERT_EQ(key.Algo(), "ED25519");
+  ASSERT_EQ(key.OwnerTrustLevel(), 5);
+  ASSERT_EQ(key.PrimaryKeyLength(), 255);
+  ASSERT_EQ(key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
 
   ASSERT_TRUE(key.IsHasCertCap());
   ASSERT_TRUE(key.IsHasAuthCap());
   ASSERT_TRUE(key.IsHasEncrCap());
   ASSERT_TRUE(key.IsHasSignCap());
 
-  ASSERT_FALSE(key.GetSubKeys()->empty());
-  ASSERT_EQ(key.GetSubKeys()->size(), 2);
+  ASSERT_FALSE(key.SubKeys().empty());
+  ASSERT_EQ(key.SubKeys().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));
+  auto s_keys = key.SubKeys();
+  auto& s_key = s_keys.back();
+  ASSERT_EQ(s_key.PublicKeyAlgo(), "ECDH");
+  ASSERT_EQ(s_key.Algo(), "CV25519");
+  ASSERT_EQ(s_key.KeyLength(), 255);
+  ASSERT_EQ(s_key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertCap());
-  ASSERT_FALSE(subkey.IsHasAuthCap());
-  ASSERT_TRUE(subkey.IsHasEncrCap());
-  ASSERT_FALSE(subkey.IsHasSignCap());
+  ASSERT_FALSE(s_key.IsHasCertCap());
+  ASSERT_FALSE(s_key.IsHasAuthCap());
+  ASSERT_TRUE(s_key.IsHasEncrCap());
+  ASSERT_FALSE(s_key.IsHasSignCap());
 
   ASSERT_TRUE(key.IsHasActualCertCap());
   ASSERT_TRUE(key.IsHasActualAuthCap());
@@ -366,34 +366,34 @@ TEST_F(GpgCoreTest, GenerateKeyED25519NISTP256Test) {
   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_EQ(key.Name(), "foo_ec2");
+  ASSERT_EQ(key.Email(), "[email protected]");
+  ASSERT_EQ(key.Comment(), "ecccc");
+  ASSERT_EQ(key.PublicKeyAlgo(), "EdDSA");
+  ASSERT_EQ(key.Algo(), "ED25519");
+  ASSERT_EQ(key.OwnerTrustLevel(), 5);
+  ASSERT_EQ(key.PrimaryKeyLength(), 255);
+  ASSERT_EQ(key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
 
   ASSERT_TRUE(key.IsHasCertCap());
   ASSERT_TRUE(key.IsHasAuthCap());
   ASSERT_TRUE(key.IsHasEncrCap());
   ASSERT_TRUE(key.IsHasSignCap());
 
-  ASSERT_FALSE(key.GetSubKeys()->empty());
-  ASSERT_EQ(key.GetSubKeys()->size(), 2);
+  ASSERT_FALSE(key.SubKeys().empty());
+  ASSERT_EQ(key.SubKeys().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));
+  auto s_keys = key.SubKeys();
+  auto& s_key = s_keys.back();
+  ASSERT_EQ(s_key.PublicKeyAlgo(), "ECDH");
+  ASSERT_EQ(s_key.Algo(), "NISTP256");
+  ASSERT_EQ(s_key.KeyLength(), 256);
+  ASSERT_EQ(s_key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertCap());
-  ASSERT_FALSE(subkey.IsHasAuthCap());
-  ASSERT_TRUE(subkey.IsHasEncrCap());
-  ASSERT_FALSE(subkey.IsHasSignCap());
+  ASSERT_FALSE(s_key.IsHasCertCap());
+  ASSERT_FALSE(s_key.IsHasAuthCap());
+  ASSERT_TRUE(s_key.IsHasEncrCap());
+  ASSERT_FALSE(s_key.IsHasSignCap());
 
   ASSERT_TRUE(key.IsHasActualCertCap());
   ASSERT_TRUE(key.IsHasActualAuthCap());
@@ -441,34 +441,34 @@ TEST_F(GpgCoreTest, GenerateKeyED25519BRAINPOOLP256R1Test) {
   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_EQ(key.Name(), "foo_ec3");
+  ASSERT_EQ(key.Email(), "[email protected]");
+  ASSERT_EQ(key.Comment(), "ecccc3");
+  ASSERT_EQ(key.PublicKeyAlgo(), "EdDSA");
+  ASSERT_EQ(key.Algo(), "ED25519");
+  ASSERT_EQ(key.OwnerTrustLevel(), 5);
+  ASSERT_EQ(key.PrimaryKeyLength(), 255);
+  ASSERT_EQ(key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
 
   ASSERT_TRUE(key.IsHasCertCap());
   ASSERT_TRUE(key.IsHasAuthCap());
   ASSERT_TRUE(key.IsHasEncrCap());
   ASSERT_TRUE(key.IsHasSignCap());
 
-  ASSERT_FALSE(key.GetSubKeys()->empty());
-  ASSERT_EQ(key.GetSubKeys()->size(), 2);
+  ASSERT_FALSE(key.SubKeys().empty());
+  ASSERT_EQ(key.SubKeys().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));
+  auto s_keys = key.SubKeys();
+  auto& s_key = s_keys.back();
+  ASSERT_EQ(s_key.PublicKeyAlgo(), "ECDH");
+  ASSERT_EQ(s_key.Algo(), "BRAINPOOLP256R1");
+  ASSERT_EQ(s_key.KeyLength(), 256);
+  ASSERT_EQ(s_key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertCap());
-  ASSERT_FALSE(subkey.IsHasAuthCap());
-  ASSERT_TRUE(subkey.IsHasEncrCap());
-  ASSERT_FALSE(subkey.IsHasSignCap());
+  ASSERT_FALSE(s_key.IsHasCertCap());
+  ASSERT_FALSE(s_key.IsHasAuthCap());
+  ASSERT_TRUE(s_key.IsHasEncrCap());
+  ASSERT_FALSE(s_key.IsHasSignCap());
 
   ASSERT_TRUE(key.IsHasActualCertCap());
   ASSERT_TRUE(key.IsHasActualAuthCap());
@@ -510,14 +510,14 @@ TEST_F(GpgCoreTest, GenerateKeyNISTP256Test) {
   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_EQ(key.Name(), "foo_4");
+  ASSERT_EQ(key.Email(), "[email protected]");
+  ASSERT_EQ(key.Comment(), "hello gpgfrontend");
+  ASSERT_EQ(key.PublicKeyAlgo(), "ECDSA");
+  ASSERT_EQ(key.Algo(), "NISTP256");
+  ASSERT_EQ(key.OwnerTrustLevel(), 5);
+  ASSERT_EQ(key.PrimaryKeyLength(), 256);
+  ASSERT_GT(key.ExpirationTime(), QDateTime::currentDateTime());
 
   ASSERT_TRUE(key.IsHasCertCap());
   ASSERT_TRUE(key.IsHasAuthCap());
@@ -565,14 +565,14 @@ TEST_F(GpgCoreTest, GenerateKeyED448Test) {
   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_EQ(key.Name(), "foo_4");
+  ASSERT_EQ(key.Email(), "[email protected]");
+  ASSERT_EQ(key.Comment(), "hello gpgfrontend");
+  ASSERT_EQ(key.PublicKeyAlgo(), "EdDSA");
+  ASSERT_EQ(key.Algo(), "ED448");
+  ASSERT_EQ(key.OwnerTrustLevel(), 5);
+  ASSERT_EQ(key.PrimaryKeyLength(), 448);
+  ASSERT_GT(key.ExpirationTime(), QDateTime::currentDateTime());
 
   ASSERT_TRUE(key.IsHasCertCap());
   ASSERT_TRUE(key.IsHasAuthCap());
@@ -620,14 +620,14 @@ TEST_F(GpgCoreTest, GenerateKeySECP256K1Test) {
   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_EQ(key.Name(), "foo_4");
+  ASSERT_EQ(key.Email(), "[email protected]");
+  ASSERT_EQ(key.Comment(), "hello gpgfrontend");
+  ASSERT_EQ(key.PublicKeyAlgo(), "ECDSA");
+  ASSERT_EQ(key.Algo(), "SECP256K1");
+  ASSERT_EQ(key.OwnerTrustLevel(), 5);
+  ASSERT_EQ(key.PrimaryKeyLength(), 256);
+  ASSERT_GT(key.ExpirationTime(), QDateTime::currentDateTime());
 
   ASSERT_TRUE(key.IsHasCertCap());
   ASSERT_TRUE(key.IsHasAuthCap());
diff --git a/src/test/core/GpgCoreTestSubkeygen.cpp b/src/test/core/GpgCoreTestSubkeygen.cpp
index bbaa2be0..09c47903 100644
--- a/src/test/core/GpgCoreTestSubkeygen.cpp
+++ b/src/test/core/GpgCoreTestSubkeygen.cpp
@@ -66,18 +66,18 @@ TEST_F(GpgCoreTest, GenerateSubkeyRSA2048Test) {
                  .GetKey(result.GetFingerprint());
   ASSERT_TRUE(key.IsGood());
 
-  auto subkeys = key.GetSubKeys();
-  auto& subkey = subkeys->back();
-
-  ASSERT_EQ(subkey.GetPubkeyAlgo(), "RSA");
-  ASSERT_EQ(subkey.GetKeyAlgo(), "RSA2048");
-  ASSERT_EQ(subkey.GetKeyLength(), 2048);
-  ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
-
-  ASSERT_FALSE(subkey.IsHasCertCap());
-  ASSERT_TRUE(subkey.IsHasAuthCap());
-  ASSERT_TRUE(subkey.IsHasEncrCap());
-  ASSERT_TRUE(subkey.IsHasSignCap());
+  auto s_keys = key.SubKeys();
+  auto& s_key = s_keys.back();
+
+  ASSERT_EQ(s_key.PublicKeyAlgo(), "RSA");
+  ASSERT_EQ(s_key.Algo(), "RSA2048");
+  ASSERT_EQ(s_key.KeyLength(), 2048);
+  ASSERT_EQ(s_key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
+
+  ASSERT_FALSE(s_key.IsHasCertCap());
+  ASSERT_TRUE(s_key.IsHasAuthCap());
+  ASSERT_TRUE(s_key.IsHasEncrCap());
+  ASSERT_TRUE(s_key.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyDSA2048Test) {
@@ -109,18 +109,18 @@ TEST_F(GpgCoreTest, GenerateSubkeyDSA2048Test) {
                  .GetKey(result.GetFingerprint());
   ASSERT_TRUE(key.IsGood());
 
-  auto subkeys = key.GetSubKeys();
-  auto& subkey = subkeys->back();
+  auto s_keys = key.SubKeys();
+  auto& s_key = s_keys.back();
 
-  ASSERT_EQ(subkey.GetPubkeyAlgo(), "DSA");
-  ASSERT_EQ(subkey.GetKeyAlgo(), "DSA2048");
-  ASSERT_EQ(subkey.GetKeyLength(), 2048);
-  ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
+  ASSERT_EQ(s_key.PublicKeyAlgo(), "DSA");
+  ASSERT_EQ(s_key.Algo(), "DSA2048");
+  ASSERT_EQ(s_key.KeyLength(), 2048);
+  ASSERT_EQ(s_key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertCap());
-  ASSERT_TRUE(subkey.IsHasAuthCap());
-  ASSERT_FALSE(subkey.IsHasEncrCap());
-  ASSERT_TRUE(subkey.IsHasSignCap());
+  ASSERT_FALSE(s_key.IsHasCertCap());
+  ASSERT_TRUE(s_key.IsHasAuthCap());
+  ASSERT_FALSE(s_key.IsHasEncrCap());
+  ASSERT_TRUE(s_key.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyELG2048Test) {
@@ -152,18 +152,18 @@ TEST_F(GpgCoreTest, GenerateSubkeyELG2048Test) {
                  .GetKey(result.GetFingerprint());
   ASSERT_TRUE(key.IsGood());
 
-  auto subkeys = key.GetSubKeys();
-  auto& subkey = subkeys->back();
+  auto s_keys = key.SubKeys();
+  auto& s_key = s_keys.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_EQ(s_key.PublicKeyAlgo(), "ELG-E");
+  ASSERT_EQ(s_key.Algo(), "ELG2048");
+  ASSERT_EQ(s_key.KeyLength(), 2048);
+  ASSERT_EQ(s_key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertCap());
-  ASSERT_FALSE(subkey.IsHasAuthCap());
-  ASSERT_TRUE(subkey.IsHasEncrCap());
-  ASSERT_FALSE(subkey.IsHasSignCap());
+  ASSERT_FALSE(s_key.IsHasCertCap());
+  ASSERT_FALSE(s_key.IsHasAuthCap());
+  ASSERT_TRUE(s_key.IsHasEncrCap());
+  ASSERT_FALSE(s_key.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyED25519Test) {
@@ -195,18 +195,18 @@ TEST_F(GpgCoreTest, GenerateSubkeyED25519Test) {
                  .GetKey(result.GetFingerprint());
   ASSERT_TRUE(key.IsGood());
 
-  auto subkeys = key.GetSubKeys();
-  auto& subkey = subkeys->back();
+  auto s_keys = key.SubKeys();
+  auto& s_key = s_keys.back();
 
-  ASSERT_EQ(subkey.GetPubkeyAlgo(), "EdDSA");
-  ASSERT_EQ(subkey.GetKeyAlgo(), "ED25519");
-  ASSERT_EQ(subkey.GetKeyLength(), 255);
-  ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
+  ASSERT_EQ(s_key.PublicKeyAlgo(), "EdDSA");
+  ASSERT_EQ(s_key.Algo(), "ED25519");
+  ASSERT_EQ(s_key.KeyLength(), 255);
+  ASSERT_EQ(s_key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertCap());
-  ASSERT_TRUE(subkey.IsHasAuthCap());
-  ASSERT_FALSE(subkey.IsHasEncrCap());
-  ASSERT_TRUE(subkey.IsHasSignCap());
+  ASSERT_FALSE(s_key.IsHasCertCap());
+  ASSERT_TRUE(s_key.IsHasAuthCap());
+  ASSERT_FALSE(s_key.IsHasEncrCap());
+  ASSERT_TRUE(s_key.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyCV25519Test) {
@@ -238,18 +238,18 @@ TEST_F(GpgCoreTest, GenerateSubkeyCV25519Test) {
                  .GetKey(result.GetFingerprint());
   ASSERT_TRUE(key.IsGood());
 
-  auto subkeys = key.GetSubKeys();
-  auto& subkey = subkeys->back();
+  auto s_keys = key.SubKeys();
+  auto& s_key = s_keys.back();
 
-  ASSERT_EQ(subkey.GetPubkeyAlgo(), QString("ECDH"));
-  ASSERT_EQ(subkey.GetKeyAlgo(), QString("CV25519"));
-  ASSERT_EQ(subkey.GetKeyLength(), 255);
-  ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
+  ASSERT_EQ(s_key.PublicKeyAlgo(), QString("ECDH"));
+  ASSERT_EQ(s_key.Algo(), QString("CV25519"));
+  ASSERT_EQ(s_key.KeyLength(), 255);
+  ASSERT_EQ(s_key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertCap());
-  ASSERT_FALSE(subkey.IsHasAuthCap());
-  ASSERT_TRUE(subkey.IsHasEncrCap());
-  ASSERT_FALSE(subkey.IsHasSignCap());
+  ASSERT_FALSE(s_key.IsHasCertCap());
+  ASSERT_FALSE(s_key.IsHasAuthCap());
+  ASSERT_TRUE(s_key.IsHasEncrCap());
+  ASSERT_FALSE(s_key.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyNISTP256Test) {
@@ -280,18 +280,18 @@ TEST_F(GpgCoreTest, GenerateSubkeyNISTP256Test) {
                  .GetKey(result.GetFingerprint());
   ASSERT_TRUE(key.IsGood());
 
-  auto subkeys = key.GetSubKeys();
-  auto& subkey = subkeys->back();
+  auto s_keys = key.SubKeys();
+  auto& s_key = s_keys.back();
 
-  ASSERT_EQ(subkey.GetPubkeyAlgo(), QString("ECDH"));
-  ASSERT_EQ(subkey.GetKeyAlgo(), QString("NISTP256"));
-  ASSERT_EQ(subkey.GetKeyLength(), 256);
-  ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
+  ASSERT_EQ(s_key.PublicKeyAlgo(), QString("ECDH"));
+  ASSERT_EQ(s_key.Algo(), QString("NISTP256"));
+  ASSERT_EQ(s_key.KeyLength(), 256);
+  ASSERT_EQ(s_key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertCap());
-  ASSERT_FALSE(subkey.IsHasAuthCap());
-  ASSERT_TRUE(subkey.IsHasEncrCap());
-  ASSERT_FALSE(subkey.IsHasSignCap());
+  ASSERT_FALSE(s_key.IsHasCertCap());
+  ASSERT_FALSE(s_key.IsHasAuthCap());
+  ASSERT_TRUE(s_key.IsHasEncrCap());
+  ASSERT_FALSE(s_key.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyBRAINPOOLP256R1Test) {
@@ -322,18 +322,18 @@ TEST_F(GpgCoreTest, GenerateSubkeyBRAINPOOLP256R1Test) {
                  .GetKey(result.GetFingerprint());
   ASSERT_TRUE(key.IsGood());
 
-  auto subkeys = key.GetSubKeys();
-  auto& subkey = subkeys->back();
+  auto s_keys = key.SubKeys();
+  auto& s_key = s_keys.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_EQ(s_key.PublicKeyAlgo(), QString("ECDH"));
+  ASSERT_EQ(s_key.Algo(), QString("BRAINPOOLP256R1"));
+  ASSERT_EQ(s_key.KeyLength(), 256);
+  ASSERT_EQ(s_key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertCap());
-  ASSERT_FALSE(subkey.IsHasAuthCap());
-  ASSERT_TRUE(subkey.IsHasEncrCap());
-  ASSERT_FALSE(subkey.IsHasSignCap());
+  ASSERT_FALSE(s_key.IsHasCertCap());
+  ASSERT_FALSE(s_key.IsHasAuthCap());
+  ASSERT_TRUE(s_key.IsHasEncrCap());
+  ASSERT_FALSE(s_key.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeyX448Test) {
@@ -364,18 +364,18 @@ TEST_F(GpgCoreTest, GenerateSubkeyX448Test) {
                  .GetKey(result.GetFingerprint());
   ASSERT_TRUE(key.IsGood());
 
-  auto subkeys = key.GetSubKeys();
-  auto& subkey = subkeys->back();
+  auto s_keys = key.SubKeys();
+  auto& s_key = s_keys.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_EQ(s_key.PublicKeyAlgo(), QString("ECDH"));
+  ASSERT_EQ(s_key.Algo(), QString("CV448"));
+  ASSERT_EQ(s_key.KeyLength(), 448);
+  ASSERT_EQ(s_key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertCap());
-  ASSERT_FALSE(subkey.IsHasAuthCap());
-  ASSERT_TRUE(subkey.IsHasEncrCap());
-  ASSERT_FALSE(subkey.IsHasSignCap());
+  ASSERT_FALSE(s_key.IsHasCertCap());
+  ASSERT_FALSE(s_key.IsHasAuthCap());
+  ASSERT_TRUE(s_key.IsHasEncrCap());
+  ASSERT_FALSE(s_key.IsHasSignCap());
 }
 
 TEST_F(GpgCoreTest, GenerateSubkeySECP256K1Test) {
@@ -406,18 +406,18 @@ TEST_F(GpgCoreTest, GenerateSubkeySECP256K1Test) {
                  .GetKey(result.GetFingerprint());
   ASSERT_TRUE(key.IsGood());
 
-  auto subkeys = key.GetSubKeys();
-  auto& subkey = subkeys->back();
+  auto s_keys = key.SubKeys();
+  auto& s_key = s_keys.back();
 
-  ASSERT_EQ(subkey.GetPubkeyAlgo(), QString("ECDH"));
-  ASSERT_EQ(subkey.GetKeyAlgo(), QString("SECP256K1"));
-  ASSERT_EQ(subkey.GetKeyLength(), 256);
-  ASSERT_EQ(subkey.GetExpireTime(), QDateTime::fromMSecsSinceEpoch(0));
+  ASSERT_EQ(s_key.PublicKeyAlgo(), QString("ECDH"));
+  ASSERT_EQ(s_key.Algo(), QString("SECP256K1"));
+  ASSERT_EQ(s_key.KeyLength(), 256);
+  ASSERT_EQ(s_key.ExpirationTime(), QDateTime::fromMSecsSinceEpoch(0));
 
-  ASSERT_FALSE(subkey.IsHasCertCap());
-  ASSERT_FALSE(subkey.IsHasAuthCap());
-  ASSERT_TRUE(subkey.IsHasEncrCap());
-  ASSERT_FALSE(subkey.IsHasSignCap());
+  ASSERT_FALSE(s_key.IsHasCertCap());
+  ASSERT_FALSE(s_key.IsHasAuthCap());
+  ASSERT_TRUE(s_key.IsHasEncrCap());
+  ASSERT_FALSE(s_key.IsHasSignCap());
 }
 
 }  // namespace GpgFrontend::Test
\ No newline at end of file