diff --git a/src/plugins/filemanager/dfmplugin-vault/utils/encryption/operatorcenter.cpp b/src/plugins/filemanager/dfmplugin-vault/utils/encryption/operatorcenter.cpp index 05dc304670..f79e12223f 100644 --- a/src/plugins/filemanager/dfmplugin-vault/utils/encryption/operatorcenter.cpp +++ b/src/plugins/filemanager/dfmplugin-vault/utils/encryption/operatorcenter.cpp @@ -204,7 +204,7 @@ bool OperatorCenter::createDirAndFile() if (!configDir.exists()) { bool ok = configDir.mkpath(strConfigDir); if (!ok) { - qDebug() << "create config dir failure!"; + qCritical() << "Vault: create config dir failed!"; return false; } } @@ -218,7 +218,7 @@ bool OperatorCenter::createDirAndFile() configFile.setPermissions(QFileDevice::ReadOwner | QFileDevice::WriteOwner | QFileDevice::ReadGroup); configFile.close(); } else { - qInfo() << "保险箱：创建配置文件失败！"; + qCritical() << "Vault：create config file failed!"; } } @@ -226,7 +226,7 @@ bool OperatorCenter::createDirAndFile() QString strPriKeyFile = makeVaultLocalPath(kRSAPUBKeyFileName); QFile prikeyFile(strPriKeyFile); if (!prikeyFile.open(QIODevice::WriteOnly | QIODevice::Append)) { - qDebug() << "create rsa private key file failure!"; + qCritical() << "Vault: create rsa private key file failed!"; return false; } prikeyFile.setPermissions(QFileDevice::ReadOwner | QFileDevice::WriteOwner | QFileDevice::ReadGroup); @@ -236,7 +236,7 @@ bool OperatorCenter::createDirAndFile() QString strRsaCiphertext = makeVaultLocalPath(kRSACiphertextFileName); QFile rsaCiphertextFile(strRsaCiphertext); if (!rsaCiphertextFile.open(QIODevice::WriteOnly | QIODevice::Append)) { - qDebug() << "create rsa ciphertext file failure!"; + qCritical() << "Vault: create rsa ciphertext file failed!"; return false; } rsaCiphertextFile.setPermissions(QFileDevice::ReadOwner | QFileDevice::WriteOwner | QFileDevice::ReadGroup); @@ -246,7 +246,7 @@ bool OperatorCenter::createDirAndFile() QString strPasswordHintFilePath = makeVaultLocalPath(kPasswordHintFileName); QFile passwordHintFile(strPasswordHintFilePath); if (!passwordHintFile.open(QIODevice::WriteOnly | QIODevice::Append)) { - qDebug() << "create password hint file failure!"; + qCritical() << "Vault: create password hint file failed!"; return false; } passwordHintFile.setPermissions(QFileDevice::ReadOwner | QFileDevice::WriteOwner | QFileDevice::ReadGroup); @@ -271,7 +271,7 @@ bool OperatorCenter::savePasswordAndPasswordHint(const QString &password, const const QString &strPasswordHintFilePath = makeVaultLocalPath(kPasswordHintFileName); QFile passwordHintFile(strPasswordHintFilePath); if (!passwordHintFile.open(QIODevice::Text | QIODevice::WriteOnly | QIODevice::Truncate)) { - qDebug() << "write password hint failure"; + qCritical() << "Vault: open password hint file failed!"; return false; } QTextStream out2(&passwordHintFile); @@ -305,7 +305,7 @@ bool OperatorCenter::createKey(const QString &password, int bytes) // 将公钥分成两部分（一部分用于保存到本地，一部分生成二维码，提供给用户） QString strSaveToLocal(""); if (strPubKey.length() < 2 * kUserKeyInterceptIndex + bytes) { - qDebug() << "USER_KEY_LENGTH is to long!"; + qCritical() << "Vault: USER_KEY_LENGTH is too long!"; return false; } QString strPart1 = strPubKey.mid(0, kUserKeyInterceptIndex); @@ -318,7 +318,7 @@ bool OperatorCenter::createKey(const QString &password, int bytes) QString publicFilePath = makeVaultLocalPath(kRSAPUBKeyFileName); QFile publicFile(publicFilePath); if (!publicFile.open(QIODevice::Text | QIODevice::WriteOnly | QIODevice::Truncate)) { - qDebug() << "open public key file failure!"; + qCritical() << "Vault: open public key file failure!"; return false; } QTextStream out(&publicFile); @@ -329,7 +329,7 @@ bool OperatorCenter::createKey(const QString &password, int bytes) QString strCipherFilePath = makeVaultLocalPath(kRSACiphertextFileName); QFile cipherFile(strCipherFilePath); if (!cipherFile.open(QIODevice::Text | QIODevice::WriteOnly | QIODevice::Truncate)) { - qDebug() << "open rsa cipher file failure!"; + qCritical() << "Vault: open rsa cipher file failure!"; return false; } QTextStream out2(&cipherFile); @@ -358,7 +358,7 @@ bool OperatorCenter::checkPassword(const QString &password, QString &cipher) QString strNewCipher2 = pbkdf2::pbkdf2EncrypyPassword(strNewSaltAndCipher, strSalt, kIterationTwo, kPasswordCipherLength); if (strCipher != strNewCipher2) { - qDebug() << "password error!"; + qCritical() << "Vault: password error!"; return false; } @@ -373,7 +373,7 @@ bool OperatorCenter::checkPassword(const QString &password, QString &cipher) QString strfilePath = makeVaultLocalPath(kPasswordFileName); QFile file(strfilePath); if (!file.open(QIODevice::Text | QIODevice::ReadOnly)) { - qDebug() << "open pbkdf2cipher file failure!"; + qCritical() << "Vault: open pbkdf2cipher file failed!"; return false; } QString strSaltAndCipher = QString(file.readAll()); @@ -385,7 +385,7 @@ bool OperatorCenter::checkPassword(const QString &password, QString &cipher) QString strNewCipher = pbkdf2::pbkdf2EncrypyPassword(password, strSalt, kIteration, kPasswordCipherLength); QString strNewSaltAndCipher = strSalt + strNewCipher; if (strNewSaltAndCipher != strSaltAndCipher) { - qDebug() << "password error!"; + qCritical() << "Vault: password error!"; return false; } @@ -393,7 +393,7 @@ bool OperatorCenter::checkPassword(const QString &password, QString &cipher) // 保存第二次加密后的密文,并更新保险箱版本信息 if (!secondSaveSaltAndCiphertext(strNewSaltAndCipher, strSalt, kConfigVaultVersion)) { - qDebug() << "第二次加密密文失败！"; + qCritical() << "Vault: the second encrypt failed!"; return false; } @@ -406,7 +406,7 @@ bool OperatorCenter::checkPassword(const QString &password, QString &cipher) bool OperatorCenter::checkUserKey(const QString &userKey, QString &cipher) { if (userKey.length() != kUserKeyLength) { - qDebug() << "user key length error!"; + qCritical() << "Vault: user key length error!"; return false; } @@ -414,7 +414,7 @@ bool OperatorCenter::checkUserKey(const QString &userKey, QString &cipher) QString strLocalPubKeyFilePath = makeVaultLocalPath(kRSAPUBKeyFileName); QFile localPubKeyfile(strLocalPubKeyFilePath); if (!localPubKeyfile.open(QIODevice::Text | QIODevice::ReadOnly)) { - qDebug() << "cant't open local public key file!"; + qCritical() << "Vault: cant't open local public key file!"; return false; } QString strLocalPubKey(localPubKeyfile.readAll()); @@ -426,7 +426,7 @@ bool OperatorCenter::checkUserKey(const QString &userKey, QString &cipher) QString strRSACipherFilePath = makeVaultLocalPath(kRSACiphertextFileName); QFile rsaCipherfile(strRSACipherFilePath); if (!rsaCipherfile.open(QIODevice::Text | QIODevice::ReadOnly)) { - qDebug() << "cant't open rsa cipher file!"; + qCritical() << "Vault: cant't open rsa cipher file!"; return false; } QString strRsaCipher(rsaCipherfile.readAll()); @@ -436,7 +436,7 @@ bool OperatorCenter::checkUserKey(const QString &userKey, QString &cipher) // 判断密码的正确性，如果密码正确，则用户密钥正确，否则用户密钥错误 if (!checkPassword(strNewPassword, cipher)) { - qDebug() << "user key error!"; + qCritical() << "Vault: user key error!"; return false; } @@ -453,7 +453,7 @@ bool OperatorCenter::getPasswordHint(QString &passwordHint) QString strPasswordHintFilePath = makeVaultLocalPath(kPasswordHintFileName); QFile passwordHintFile(strPasswordHintFilePath); if (!passwordHintFile.open(QIODevice::Text | QIODevice::ReadOnly)) { - qDebug() << "open password hint file failure"; + qCritical() << "open password hint file failure"; return false; } passwordHint = QString(passwordHintFile.readAll()); @@ -542,13 +542,13 @@ int OperatorCenter::executionShellCommand(const QString &strCmd, QStringList &ls // 命令为空 if (strCmd.isEmpty()) { - qDebug() << "cmd is empty!"; + qCritical() << "Vault: the shell cmd is empty!"; return -1; } if ((fp = popen(cmd, "r")) == nullptr) { perror("popen"); - qDebug() << QString("popen error: %s").arg(strerror(errno)); + qCritical() << QString("Vault: popen error: %s").arg(strerror(errno)); return -1; } else { char buf[kBuffterMaxLine] = { '\0' }; @@ -561,12 +561,12 @@ int OperatorCenter::executionShellCommand(const QString &strCmd, QStringList &ls int res; if ((res = pclose(fp)) == -1) { - qDebug() << "close popen file pointer fp error!"; + qCritical() << "Vault: close popen file pointer fp failed!"; return res; } else if (res == 0) { return res; } else { - qDebug() << QString("popen res is : %1").arg(res); + qCritical() << QString("Vault: popen res is : %1").arg(res); return res; } } diff --git a/src/plugins/filemanager/dfmplugin-vault/utils/operator/pbkdf2.cpp b/src/plugins/filemanager/dfmplugin-vault/utils/operator/pbkdf2.cpp index cce1fb3349..10070c4881 100644 --- a/src/plugins/filemanager/dfmplugin-vault/utils/operator/pbkdf2.cpp +++ b/src/plugins/filemanager/dfmplugin-vault/utils/operator/pbkdf2.cpp @@ -56,7 +56,7 @@ QString pbkdf2::createRandomSalt(int byte) QString pbkdf2::pbkdf2EncrypyPassword(const QString &password, const QString &randSalt, int iteration, int cipherByteNum) { if (cipherByteNum < 0 || cipherByteNum % 2 != 0) { - qDebug() << "cipherByteNum can't less than zero and must be even!"; + qCritical() << "Vault: cipherByteNum can't less than zero and must be even!"; return ""; } // 字节长度 @@ -90,7 +90,7 @@ QString pbkdf2::pbkdf2EncrypyPassword(const QString &password, const QString &ra if (pstr) free(pstr); } else { - qDebug() << "PKCS5_PBKDF2_HMAC_SHA1 failed"; + qCritical() << "Vault: the function of PKCS5_PBKDF2_HMAC_SHA1 failed"; } free(out); return strCipherText; diff --git a/src/plugins/filemanager/dfmplugin-vault/utils/operator/rsam.cpp b/src/plugins/filemanager/dfmplugin-vault/utils/operator/rsam.cpp index 0b50ea3233..ee519d3d75 100644 --- a/src/plugins/filemanager/dfmplugin-vault/utils/operator/rsam.cpp +++ b/src/plugins/filemanager/dfmplugin-vault/utils/operator/rsam.cpp @@ -18,7 +18,7 @@ bool rsam::createPublicAndPrivateKey(QString &publicKey, QString &privateKey) BN_set_word(pNum, RSA_F4); int nRet = RSA_generate_key_ex(pRsa, kKeyLength, pNum, nullptr); if (nRet != 1) { - qDebug() << "RSA_generate_key_ex 失败！"; + qCritical() << "Vault: the function of RSA_generate_key_ex run failed!"; return false; } @@ -66,7 +66,7 @@ QString rsam::privateKeyEncrypt(const QString &password, const QString &privateK uchar *pPrivateKey = reinterpret_cast(privateKeyArry.data()); BIO *pPrivateKeyBio = BIO_new_mem_buf(pPrivateKey, privateKey.length()); if (pPrivateKeyBio == nullptr) { - qDebug() << "BIO_new_mem_buf 失败！"; + qCritical() << "Vault: the function of BIO_new_mem_buf run failed!"; return ""; } @@ -74,7 +74,7 @@ QString rsam::privateKeyEncrypt(const QString &password, const QString &privateK pRsa = PEM_read_bio_RSAPrivateKey(pPrivateKeyBio, &pRsa, nullptr, nullptr); if (pRsa == nullptr) { BIO_free_all(pPrivateKeyBio); - qDebug() << "PEM_read_bio_RSAPrivateKey 失败！"; + qCritical() << "Vault: the function of PEM_read_bio_RSAPrivateKey run failed!"; return ""; } @@ -111,7 +111,7 @@ QString rsam::publicKeyDecrypt(const QString &ciphertext, const QString &publicK uchar *pPublicKey = reinterpret_cast(publickKeyArry.data()); BIO *pPublicKeyBio = BIO_new_mem_buf(pPublicKey, publicKey.length()); if (pPublicKeyBio == nullptr) { - qDebug() << "BIO_new_mem_buf 失败！"; + qCritical() << "Vault: the function of BIO_new_mem_buf run failed!"; return ""; } @@ -123,7 +123,7 @@ QString rsam::publicKeyDecrypt(const QString &ciphertext, const QString &publicK } if (!pRsa) { - qDebug() << "PEM_read_bio_RSAPublicKey 失败！"; + qCritical() << "Vault: the function of PEM_read_bio_RSAPublicKey run failed!"; return ""; } diff --git a/tests/plugins/filemanager/core/dfmplugin-workspace/bug/ut_workspacepluginbugtest.cpp b/tests/plugins/filemanager/core/dfmplugin-workspace/bug/ut_workspacepluginbugtest.cpp index e680c24142..dfae21a557 100644 --- a/tests/plugins/filemanager/core/dfmplugin-workspace/bug/ut_workspacepluginbugtest.cpp +++ b/tests/plugins/filemanager/core/dfmplugin-workspace/bug/ut_workspacepluginbugtest.cpp @@ -32,22 +32,22 @@ TEST(UT_WorkspacePluginBugTest, bug_169379_NotInit) FileView view(QUrl("/home")); + view.d->delegates.insert(static_cast(Global::ViewMode::kListMode), nullptr); view.setViewMode(Global::ViewMode::kListMode); EXPECT_TRUE(isInit); } TEST(UT_WorkspacePluginBugTest, bug_140799_desktopFilter) { - bool isExcuDesktopFileCheck { false }; stub_ext::StubExt stub; typedef QVariant(*FuncType)(Application::ApplicationAttribute); stub.set_lamda(static_cast(&Application::appAttribute), [] {return QVariant(false); }); - stub.set_lamda(&FileSortWorker::checkNameFilters, [ &isExcuDesktopFileCheck ] { isExcuDesktopFileCheck = true; }); + stub.set_lamda(&FileSortWorker::checkNameFilters, []{}); FileViewModel model; FileInfoPointer info(new FileInfo(QUrl("file:///home"))); - FileSortWorker *work = new FileSortWorker(QUrl("file:///home"), "1234"); + FileSortWorker *work = new FileSortWorker(QUrl("file:///home"), "1234", nullptr, {"*.desktop"}); model.nameFilters = QStringList { "*.desktop" }; model.filterSortWorker.reset(work); - EXPECT_TRUE(isExcuDesktopFileCheck); + EXPECT_TRUE(model.nameFilters == work->nameFilters); } diff --git a/tests/plugins/filemanager/dfmplugin-vault/bug/ut_vaultpluginbugtest.cpp b/tests/plugins/filemanager/dfmplugin-vault/bug/ut_vaultpluginbugtest.cpp index 870ab54af8..e471d54d09 100644 --- a/tests/plugins/filemanager/dfmplugin-vault/bug/ut_vaultpluginbugtest.cpp +++ b/tests/plugins/filemanager/dfmplugin-vault/bug/ut_vaultpluginbugtest.cpp @@ -23,6 +23,7 @@ #include #include +#include DPVAULT_USE_NAMESPACE DWIDGET_USE_NAMESPACE @@ -42,6 +43,14 @@ TEST(UT_VaultPluginBugTest, bug_178305_NotRegisterService) bool isRegisterService { false }; stub_ext::StubExt stub; stub.set_lamda(&VaultVisibleManager::pluginServiceRegister, [ &isRegisterService ] { __DBG_STUB_INVOKE__ isRegisterService = true; }); + typedef bool(QDBusConnection::*FuncType)(const QString &, const QString &, const QString &, const QString &, QObject *, const char *); + stub.set_lamda(static_cast(&QDBusConnection::connect), []{ + return true; + }); + typedef bool(QDBusConnection::*FuncType2)(const QString &, const QString &, const QString &, const QString &, const QString &, QObject *, const char *); + stub.set_lamda(static_cast(&QDBusConnection::connect), []{ + return true; + }); Vault plugin; plugin.initialize(); diff --git a/tests/plugins/filemanager/dfmplugin-vault/utils/encryption/ut_operatorcenter.cpp b/tests/plugins/filemanager/dfmplugin-vault/utils/encryption/ut_operatorcenter.cpp index 641c6fa488..eecb72b8ee 100644 --- a/tests/plugins/filemanager/dfmplugin-vault/utils/encryption/ut_operatorcenter.cpp +++ b/tests/plugins/filemanager/dfmplugin-vault/utils/encryption/ut_operatorcenter.cpp @@ -223,3 +223,503 @@ TEST(UT_OperatorCenter, verificationRetrievePassword_three) EXPECT_TRUE(isOk); } + +TEST(UT_OperatorCenter, createDirAndFile_one) +{ + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::makeVaultLocalPath, []{ + return "/UT_TEST"; + }); + stub.set_lamda(&QDir::mkpath, []{ + return false; + }); + + bool isOk = OperatorCenter::getInstance()->createDirAndFile(); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, createDirAndFile_two) +{ + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::makeVaultLocalPath, []{ + return "/UT_TEST"; + }); + typedef bool(QDir::*FuncType1)()const; + stub.set_lamda(static_cast(&QDir::exists), []{ + return false; + }); + stub.set_lamda(&QDir::mkpath, []{ + return true; + }); + typedef bool(*FuncType2)(QIODevice::OpenMode); + stub.set_lamda((FuncType2)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return false; + }); + + bool isOk = OperatorCenter::getInstance()->createDirAndFile(); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, createDirAndFile_three) +{ + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::makeVaultLocalPath, []{ + return "/UT_TEST"; + }); + typedef bool(QDir::*FuncType1)()const; + stub.set_lamda(static_cast(&QDir::exists), []{ + return false; + }); + stub.set_lamda(&QDir::mkpath, []{ + return true; + }); + typedef bool(*FuncType2)(QIODevice::OpenMode); + stub.set_lamda((FuncType2)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return true; + }); + typedef bool(*FuncType3)(QFileDevice::Permissions); + stub.set_lamda((FuncType3)(bool(QFile::*)(QFileDevice::Permissions))(&QFile::setPermissions), []{ + return true; + }); + + bool isOk = OperatorCenter::getInstance()->createDirAndFile(); + + EXPECT_TRUE(isOk); +} + +TEST(UT_OperatorCenter, savePasswordAndPasswordHint_one) +{ + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::secondSaveSaltAndCiphertext, []{ + return true; + }); + stub.set_lamda(&OperatorCenter::makeVaultLocalPath, []{ + return "/UT_TEST"; + }); + typedef bool(*FuncType1)(QIODevice::OpenMode); + stub.set_lamda((FuncType1)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return false; + }); + + bool isOk = OperatorCenter::getInstance()->savePasswordAndPasswordHint("UT_TEST", "UT_TEST"); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, savePasswordAndPasswordHint_two) +{ + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::secondSaveSaltAndCiphertext, []{ + return true; + }); + stub.set_lamda(&OperatorCenter::makeVaultLocalPath, []{ + return "/UT_TEST"; + }); + typedef bool(*FuncType1)(QIODevice::OpenMode); + stub.set_lamda((FuncType1)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return true; + }); + typedef QVariant(VaultConfig::*FuncType2)(const QString &, const QString &, const QVariant &); + stub.set_lamda(static_cast(&VaultConfig::get), []{ + return QVariant::fromValue(kConfigKeyNotExist); + }); + + bool isOk = OperatorCenter::getInstance()->savePasswordAndPasswordHint("UT_TEST", "UT_TEST"); + + EXPECT_TRUE(isOk); +} + +TEST(UT_OperatorCenter, savePasswordAndPasswordHint_three) +{ + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::secondSaveSaltAndCiphertext, []{ + return true; + }); + stub.set_lamda(&OperatorCenter::makeVaultLocalPath, []{ + return "/UT_TEST"; + }); + typedef bool(*FuncType1)(QIODevice::OpenMode); + stub.set_lamda((FuncType1)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return true; + }); + typedef QVariant(VaultConfig::*FuncType2)(const QString &, const QString &, const QVariant &); + stub.set_lamda(static_cast(&VaultConfig::get), []{ + return QVariant::fromValue("UT_TEST"); + }); + + bool isOk = OperatorCenter::getInstance()->savePasswordAndPasswordHint("UT_TEST", "UT_TEST"); + + EXPECT_TRUE(isOk); +} + +TEST(UT_OperatorCenter, createKey_one) +{ + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::makeVaultLocalPath, []{ + return "/UT_TEST"; + }); + typedef bool(*FuncType1)(QIODevice::OpenMode); + stub.set_lamda((FuncType1)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return false; + }); + + bool isOk = OperatorCenter::getInstance()->createKey("UT_TEST", 7); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, createKey_two) +{ + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::makeVaultLocalPath, []{ + return "/UT_TEST"; + }); + typedef bool(*FuncType1)(QIODevice::OpenMode); + stub.set_lamda((FuncType1)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return true; + }); + + bool isOk = OperatorCenter::getInstance()->createKey("UT_TEST", 7); + + EXPECT_TRUE(isOk); +} + +TEST(UT_OperatorCenter, checkPassword_one) +{ + stub_ext::StubExt stub; + typedef QVariant(VaultConfig::*FuncType)(const QString &, const QString &); + stub.set_lamda(static_cast(&VaultConfig::get), []{ + return QVariant::fromValue(kConfigVaultVersion); + }); + + QString cipher; + bool isOk = OperatorCenter::getInstance()->checkPassword("UT_TEST", cipher); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, checkPassword_two) +{ + stub_ext::StubExt stub; + typedef QVariant(VaultConfig::*FuncType)(const QString &, const QString &); + stub.set_lamda(static_cast(&VaultConfig::get), []{ + return QVariant::fromValue(kConfigVaultVersion); + }); + stub.set_lamda(&pbkdf2::pbkdf2EncrypyPassword, []{ + return ""; + }); + typedef QVariant(VaultConfig::*FuncType2)(const QString &, const QString &, const QVariant &); + stub.set_lamda(static_cast(&VaultConfig::get), []{ + return QVariant::fromValue(kConfigKeyNotExist); + }); + + QString cipher; + bool isOk = OperatorCenter::getInstance()->checkPassword("UT_TEST", cipher); + + EXPECT_TRUE(isOk); +} + +TEST(UT_OperatorCenter, checkPassword_three) +{ + stub_ext::StubExt stub; + typedef QVariant(VaultConfig::*FuncType)(const QString &, const QString &); + stub.set_lamda(static_cast(&VaultConfig::get), []{ + return QVariant::fromValue(kConfigVaultVersion); + }); + stub.set_lamda(&pbkdf2::pbkdf2EncrypyPassword, []{ + return ""; + }); + typedef QVariant(VaultConfig::*FuncType2)(const QString &, const QString &, const QVariant &); + stub.set_lamda(static_cast(&VaultConfig::get), []{ + return QVariant::fromValue(kConfigVaultVersion); + }); + + QString cipher; + bool isOk = OperatorCenter::getInstance()->checkPassword("UT_TEST", cipher); + + EXPECT_TRUE(isOk); +} + +TEST(UT_OperatorCenter, checkPassword_four) +{ + stub_ext::StubExt stub; + typedef QVariant(VaultConfig::*FuncType)(const QString &, const QString &); + stub.set_lamda(static_cast(&VaultConfig::get), []{ + return QVariant::fromValue("UT_TEST"); + }); + typedef bool(*FuncType1)(QIODevice::OpenMode); + stub.set_lamda((FuncType1)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return false; + }); + + QString cipher; + bool isOk = OperatorCenter::getInstance()->checkPassword("UT_TEST", cipher); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, checkPassword_five) +{ + stub_ext::StubExt stub; + typedef QVariant(VaultConfig::*FuncType)(const QString &, const QString &); + stub.set_lamda(static_cast(&VaultConfig::get), []{ + return QVariant::fromValue("UT_TEST"); + }); + typedef bool(*FuncType1)(QIODevice::OpenMode); + stub.set_lamda((FuncType1)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return true; + }); + stub.set_lamda(&pbkdf2::pbkdf2EncrypyPassword, []{ + return "UT_TEST"; + }); + + QString cipher; + bool isOk = OperatorCenter::getInstance()->checkPassword("UT_TEST", cipher); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, checkPassword_six) +{ + stub_ext::StubExt stub; + typedef QVariant(VaultConfig::*FuncType)(const QString &, const QString &); + stub.set_lamda(static_cast(&VaultConfig::get), []{ + return QVariant::fromValue("UT_TEST"); + }); + typedef bool(*FuncType1)(QIODevice::OpenMode); + stub.set_lamda((FuncType1)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return true; + }); + stub.set_lamda(&pbkdf2::pbkdf2EncrypyPassword, []{ + return ""; + }); + stub.set_lamda(&OperatorCenter::secondSaveSaltAndCiphertext, []{ + return false; + }); + + QString cipher; + bool isOk = OperatorCenter::getInstance()->checkPassword("UT_TEST", cipher); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, checkPassword_seven) +{ + stub_ext::StubExt stub; + typedef QVariant(VaultConfig::*FuncType)(const QString &, const QString &); + stub.set_lamda(static_cast(&VaultConfig::get), []{ + return QVariant::fromValue("UT_TEST"); + }); + typedef bool(*FuncType1)(QIODevice::OpenMode); + stub.set_lamda((FuncType1)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return true; + }); + stub.set_lamda(&pbkdf2::pbkdf2EncrypyPassword, []{ + return ""; + }); + stub.set_lamda(&OperatorCenter::secondSaveSaltAndCiphertext, []{ + return true; + }); + typedef bool(*FuncType2)(const QString &); + stub.set_lamda(static_cast(&QFile::remove), []{ + return true; + }); + + QString cipher; + bool isOk = OperatorCenter::getInstance()->checkPassword("UT_TEST", cipher); + + EXPECT_TRUE(isOk); +} + +TEST(UT_OperatorCenter, checkUserKey_one) +{ + stub_ext::StubExt stub; + + QString cipher; + bool isOk = OperatorCenter::getInstance()->checkUserKey("UT_TESTUT_TESTUT_TESTUT_TESTUT_", cipher); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, checkUserKey_two) +{ + stub_ext::StubExt stub; + typedef bool(*FuncType1)(QIODevice::OpenMode); + stub.set_lamda((FuncType1)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return false; + }); + + QString cipher; + bool isOk = OperatorCenter::getInstance()->checkUserKey("UT_TESTUT_TESTUT_TESTUT_TESTUT_U", cipher); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, checkUserKey_three) +{ + stub_ext::StubExt stub; + typedef bool(*FuncType1)(QIODevice::OpenMode); + stub.set_lamda((FuncType1)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return true; + }); + stub.set_lamda(&OperatorCenter::checkPassword, []{ + return false; + }); + + QString cipher; + bool isOk = OperatorCenter::getInstance()->checkUserKey("UT_TESTUT_TESTUT_TESTUT_TESTUT_U", cipher); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, checkUserKey_four) +{ + stub_ext::StubExt stub; + typedef bool(*FuncType1)(QIODevice::OpenMode); + stub.set_lamda((FuncType1)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return true; + }); + stub.set_lamda(&OperatorCenter::checkPassword, []{ + return true; + }); + + QString cipher; + bool isOk = OperatorCenter::getInstance()->checkUserKey("UT_TESTUT_TESTUT_TESTUT_TESTUT_U", cipher); + + EXPECT_TRUE(isOk); +} + +TEST(UT_OperatorCenter, getUserKey) +{ + OperatorCenter::getInstance()->strUserKey = "UT_TEST"; + QString key = OperatorCenter::getInstance()->getUserKey(); + + EXPECT_TRUE(key == "UT_TEST"); +} + +TEST(UT_OperatorCenter, getPasswordHint_one) +{ + stub_ext::StubExt stub; + typedef bool(*FuncType1)(QIODevice::OpenMode); + stub.set_lamda((FuncType1)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return false; + }); + + QString hint; + bool isOk = OperatorCenter::getInstance()->getPasswordHint(hint); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, getPasswordHint_two) +{ + stub_ext::StubExt stub; + typedef bool(*FuncType1)(QIODevice::OpenMode); + stub.set_lamda((FuncType1)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return true; + }); + + QString hint; + OperatorCenter::getInstance()->getPasswordHint(hint); + + EXPECT_TRUE(hint.isEmpty()); +} + +TEST(UT_OperatorCenter, getSaltAndPasswordCipher) +{ + OperatorCenter::getInstance()->strCryfsPassword = "UT_TEST"; + QString cipher = OperatorCenter::getInstance()->getSaltAndPasswordCipher(); + + EXPECT_TRUE(cipher == "UT_TEST"); +} + +TEST(UT_OperatorCenter, clearSaltAndPasswordCipher) +{ + OperatorCenter::getInstance()->strCryfsPassword = "UT_TEST"; + OperatorCenter::getInstance()->clearSaltAndPasswordCipher(); + + EXPECT_TRUE(OperatorCenter::getInstance()->strCryfsPassword.isEmpty()); +} + +TEST(UT_OperatorCenter, getEncryptDirPath) +{ + EXPECT_FALSE(OperatorCenter::getInstance()->getEncryptDirPath().isEmpty()); +} + +TEST(UT_OperatorCenter, getdecryptDirPath) +{ + EXPECT_FALSE(OperatorCenter::getInstance()->getdecryptDirPath().isEmpty()); +} + +TEST(UT_OperatorCenter, getConfigFilePath) +{ + EXPECT_FALSE(OperatorCenter::getInstance()->getConfigFilePath().isEmpty()); +} + +TEST(UT_OperatorCenter, autoGeneratePassword) +{ + EXPECT_TRUE(OperatorCenter::getInstance()->autoGeneratePassword(20).length() == 20); +} + +TEST(UT_OperatorCenter, getRootPassword_one) +{ + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::runCmd, []{ + return true; + }); + + OperatorCenter::getInstance()->standOutput == "root"; + bool isOk = OperatorCenter::getInstance()->getRootPassword(); + + EXPECT_TRUE(isOk); +} + +TEST(UT_OperatorCenter, getRootPassword_two) +{ + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::runCmd, []{ + return false; + }); + stub.set_lamda(&OperatorCenter::executeProcess, []{ + return false; + }); + + + bool isOk = OperatorCenter::getInstance()->getRootPassword(); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, getRootPassword_three) +{ + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::runCmd, []{ + return false; + }); + stub.set_lamda(&OperatorCenter::executeProcess, []{ + return true; + }); + + + bool isOk = OperatorCenter::getInstance()->getRootPassword(); + + EXPECT_TRUE(isOk); +} + +TEST(UT_OperatorCenter, executionShellCommand_one) +{ + QStringList output; + int result = OperatorCenter::getInstance()->executionShellCommand("", output); + + EXPECT_TRUE(result == -1); +} + +TEST(UT_OperatorCenter, executionShellCommand_two) +{ + QStringList output; + int result = OperatorCenter::getInstance()->executionShellCommand("UT_TEST", output); + + EXPECT_TRUE(result != -1); +} diff --git a/tests/plugins/filemanager/dfmplugin-vault/utils/encryption/ut_vaultconfig.cpp b/tests/plugins/filemanager/dfmplugin-vault/utils/encryption/ut_vaultconfig.cpp new file mode 100644 index 0000000000..8f07b90859 --- /dev/null +++ b/tests/plugins/filemanager/dfmplugin-vault/utils/encryption/ut_vaultconfig.cpp @@ -0,0 +1,53 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" +#include "utils/encryption/vaultconfig.h" + +#include + +#include + +DPVAULT_USE_NAMESPACE + +TEST(UT_VaultConfig, set) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&QSettings::setValue, [ &isOk ]{ + isOk = true; + }); + + VaultConfig config; + config.set("UT_TEST", "UT_TEST", "UT_TEST"); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultConfig, get_one) +{ + stub_ext::StubExt stub; + stub.set_lamda(&QSettings::value, []{ + return QVariant::fromValue("isOk"); + }); + + VaultConfig config; + QVariant re = config.get("UT_TEST", "UT_TEST"); + + EXPECT_TRUE(re.value() == "isOk"); +} + +TEST(UT_VaultConfig, get_two) +{ + stub_ext::StubExt stub; + stub.set_lamda(&QSettings::value, []{ + return QVariant::fromValue("isOk"); + }); + + VaultConfig config; + QVariant re = config.get("UT_TEST", "UT_TEST", "UT_TEST"); + + EXPECT_TRUE(re.value() == "isOk"); +} diff --git a/tests/plugins/filemanager/dfmplugin-vault/utils/operator/ut_pbkgf2.cpp b/tests/plugins/filemanager/dfmplugin-vault/utils/operator/ut_pbkgf2.cpp new file mode 100644 index 0000000000..7d14a5da0f --- /dev/null +++ b/tests/plugins/filemanager/dfmplugin-vault/utils/operator/ut_pbkgf2.cpp @@ -0,0 +1,38 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" +#include "utils/operator/pbkdf2.h" + +#include + +#include + +TEST(UT_PBKDF2, octalToHexadecimal) +{ + char *re = pbkdf2::octalToHexadecimal("123", 3); + + EXPECT_TRUE(QString(re) == "313233"); +} + +TEST(UT_PBKDF2, createRandomSalt) +{ + QString re = pbkdf2::createRandomSalt(10); + + EXPECT_TRUE(re.length() == 10); +} + +TEST(UT_PBKDF2, pbkdf2EncrypyPassword_one) +{ + QString re = pbkdf2::pbkdf2EncrypyPassword("UT_TEST", "UT_TEST", 1020, 19); + + EXPECT_TRUE(re.isEmpty()); +} + +TEST(UT_PBKDF2, pbkdf2EncrypyPassword_two) +{ + QString re = pbkdf2::pbkdf2EncrypyPassword("UT_TEST", "UT_TEST", 1020, 10); + + EXPECT_TRUE(re == "d889b52a4a"); +} diff --git a/tests/plugins/filemanager/dfmplugin-vault/utils/operator/ut_rsam.cpp b/tests/plugins/filemanager/dfmplugin-vault/utils/operator/ut_rsam.cpp new file mode 100644 index 0000000000..1eea393b91 --- /dev/null +++ b/tests/plugins/filemanager/dfmplugin-vault/utils/operator/ut_rsam.cpp @@ -0,0 +1,18 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" +#include "utils/operator/rsam.h" + +#include + +TEST(UT_RSAM, privateKey_encrypt_publicKey_decrypt) +{ + QString publicKey, privateKey; + rsam::createPublicAndPrivateKey(publicKey, privateKey); + QString cipher = rsam::privateKeyEncrypt("UT_TEST", privateKey); + QString password = rsam::publicKeyDecrypt(cipher, publicKey); + + EXPECT_TRUE(password == "UT_TEST"); +} diff --git a/tests/plugins/filemanager/dfmplugin-vault/utils/policy/ut_policymanager.cpp b/tests/plugins/filemanager/dfmplugin-vault/utils/policy/ut_policymanager.cpp new file mode 100644 index 0000000000..a1cb36f0fc --- /dev/null +++ b/tests/plugins/filemanager/dfmplugin-vault/utils/policy/ut_policymanager.cpp @@ -0,0 +1,167 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" +#include "utils/policy/policymanager.h" +#include "utils/vaultvisiblemanager.h" +#include "utils/vaulthelper.h" +#include "dbus/vaultdbusutils.h" + +#include + +#include + +DPVAULT_USE_NAMESPACE + +TEST(UT_PolicyManager, getVaultPolicy) +{ + stub_ext::StubExt stub; + typedef bool(QDBusConnection::*FuncType)(const QString &, const QString &, const QString &, const QString &, QObject *, const char *); + stub.set_lamda(static_cast(&QDBusConnection::connect), []{ + return true; + }); + stub.set_lamda(&VaultDBusUtils::getVaultPolicy, []{ + return VaultPolicyState::kNotEnable; + }); + + VaultPolicyState state = PolicyManager::instance()->getVaultPolicy(); + + EXPECT_TRUE(state == VaultPolicyState::kNotEnable); +} + +TEST(UT_PolicyManager, setVaultPolicyState) +{ + stub_ext::StubExt stub; + stub.set_lamda(&VaultDBusUtils::setVaultPolicyState, []{ + return true; + }); + + bool isOk = PolicyManager::instance()->setVaultPolicyState(VaultPolicyState::kNotEnable); + + EXPECT_TRUE(isOk); +} + +TEST(UT_PolicyManager, getVaultCurrentPageMark) +{ + PolicyManager::instance()->recordVaultPageMark = PolicyManager::VaultPageMark::kUnknown; + PolicyManager::VaultPageMark state = PolicyManager::instance()->getVaultCurrentPageMark(); + + EXPECT_TRUE(state == PolicyManager::VaultPageMark::kUnknown); +} + +TEST(UT_PolicyManager, setVauleCurrentPageMark) +{ + PolicyManager::instance()->setVauleCurrentPageMark(PolicyManager::VaultPageMark::kUnknown); + + EXPECT_TRUE(PolicyManager::instance()->recordVaultPageMark == PolicyManager::VaultPageMark::kUnknown); +} + +TEST(UT_PolicyManager, isVaultVisiable) +{ + PolicyManager::instance()->vaultVisiable = false; + EXPECT_FALSE(PolicyManager::instance()->isVaultVisiable()); +} + +TEST(UT_PolicyManager, slotVaultPolicy_one) +{ + stub_ext::StubExt stub; + stub.set_lamda(&PolicyManager::getVaultPolicy, []{ + return VaultPolicyState::kNotEnable; + }); + stub.set_lamda(&PolicyManager::getVaultCurrentPageMark, []{ + return PolicyManager::VaultPageMark::kUnknown; + }); + + PolicyManager::instance()->slotVaultPolicy(); + + EXPECT_FALSE(PolicyManager::instance()->vaultVisiable); +} + +TEST(UT_PolicyManager, slotVaultPolicy_two) +{ + stub_ext::StubExt stub; + stub.set_lamda(&PolicyManager::getVaultPolicy, []{ + return VaultPolicyState::kNotEnable; + }); + stub.set_lamda(&PolicyManager::getVaultCurrentPageMark, []{ + return PolicyManager::VaultPageMark::kClipboardPage; + }); + stub.set_lamda(&VaultVisibleManager::removeSideBarVaultItem, []{}); + stub.set_lamda(&VaultVisibleManager::removeComputerVaultItem, []{}); + + PolicyManager::instance()->vaultVisiable = true; + PolicyManager::instance()->slotVaultPolicy(); + + EXPECT_FALSE(PolicyManager::instance()->vaultVisiable); +} + +TEST(UT_PolicyManager, slotVaultPolicy_three) +{ + stub_ext::StubExt stub; + stub.set_lamda(&PolicyManager::getVaultPolicy, []{ + return VaultPolicyState::kNotEnable; + }); + stub.set_lamda(&PolicyManager::getVaultCurrentPageMark, []{ + return PolicyManager::VaultPageMark::kCopyFilePage; + }); + stub.set_lamda(&VaultHelper::lockVault, []{}); + stub.set_lamda(&VaultVisibleManager::removeSideBarVaultItem, []{}); + stub.set_lamda(&VaultVisibleManager::removeComputerVaultItem, []{}); + + PolicyManager::instance()->vaultVisiable = true; + PolicyManager::instance()->slotVaultPolicy(); + + EXPECT_FALSE(PolicyManager::instance()->vaultVisiable); +} + +TEST(UT_PolicyManager, slotVaultPolicy_four) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&PolicyManager::getVaultPolicy, []{ + return VaultPolicyState::kNotEnable; + }); + stub.set_lamda(&PolicyManager::getVaultCurrentPageMark, []{ + return PolicyManager::VaultPageMark::kCreateVaultPage1; + }); + stub.set_lamda(&PolicyManager::setVaultPolicyState, [ &isOk ]{ + isOk = true; + return true; + }); + + PolicyManager::instance()->slotVaultPolicy(); + + EXPECT_TRUE(isOk); +} + +TEST(UT_PolicyManager, slotVaultPolicy_five) +{ + stub_ext::StubExt stub; + stub.set_lamda(&PolicyManager::getVaultPolicy, []{ + return VaultPolicyState::kEnable; + }); + stub.set_lamda(&VaultVisibleManager::infoRegister, []{}); + stub.set_lamda(&VaultVisibleManager::pluginServiceRegister, []{}); + stub.set_lamda(&VaultVisibleManager::addSideBarVaultItem, []{}); + stub.set_lamda(&VaultVisibleManager::addComputer, []{}); + + PolicyManager::instance()->vaultVisiable = false; + PolicyManager::instance()->slotVaultPolicy(); + + EXPECT_TRUE(PolicyManager::instance()->vaultVisiable); +} + +TEST(UT_PolicyManager, slotVaultPolicy_six) +{ + stub_ext::StubExt stub; + stub.set_lamda(&PolicyManager::getVaultPolicy, []{ + return VaultPolicyState::kUnkonw; + }); + + PolicyManager::instance()->vaultVisiable = false; + PolicyManager::instance()->slotVaultPolicy(); + + EXPECT_FALSE(PolicyManager::instance()->vaultVisiable); +} diff --git a/tests/plugins/filemanager/dfmplugin-vault/utils/ut_fileencrypthandle.cpp b/tests/plugins/filemanager/dfmplugin-vault/utils/ut_fileencrypthandle.cpp new file mode 100644 index 0000000000..b219b208aa --- /dev/null +++ b/tests/plugins/filemanager/dfmplugin-vault/utils/ut_fileencrypthandle.cpp @@ -0,0 +1,98 @@ +// SPDX-FileCopyrightText: 2020 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" +#include "utils/fileencrypthandle.h" +#include "utils/encryption/vaultconfig.h" + +#include + +#include +#include +#include + +#include + +DPVAULT_USE_NAMESPACE +DFMBASE_USE_NAMESPACE + +TEST(UT_FileEncryptHandle, init) +{ + stub_ext::StubExt stub; + typedef bool(QDBusConnection::*FuncType2)(const QString &, const QString &, const QString &, const QString &, const QString &, QObject *, const char *); + stub.set_lamda(static_cast(&QDBusConnection::connect), []{ + return true; + }); + + FileEncryptHandle::instance(); +} + +TEST(UT_FileEncryptHandle, connectLockScreenToUpdateVaultState_one) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&QDBusConnection::isConnected, [ &isOk ]{ + isOk = true; + return false; + }); + + FileEncryptHandle::instance()->connectLockScreenToUpdateVaultState(); + + EXPECT_TRUE(isOk); +} + +TEST(UT_FileEncryptHandle, connectLockScreenToUpdateVaultState_two) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&QDBusConnection::isConnected, []{ + return true; + }); + stub.set_lamda(&QDBusConnectionInterface::isServiceRegistered, [ &isOk ]{ + isOk = true; + QDBusMessage me; + return QDBusReply(me); + }); + + FileEncryptHandle::instance()->connectLockScreenToUpdateVaultState(); + + EXPECT_TRUE(isOk); +} + +TEST(UT_FileEncryptHandle, createVault_one) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&FileEncryptHandle::createDirIfNotExist, [ &isOk ]{ + isOk = true; + return false; + }); + + FileEncryptHandle::instance()->createVault("/UT_TEST1", "/UT_TEST2", "TU_PASSWORD"); + + EXPECT_TRUE(isOk); +} + +TEST(UT_FileEncryptHandle, createVault_two) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&FileEncryptHandle::createDirIfNotExist, []{ + return true; + }); + stub.set_lamda(&DConfigManager::setValue, []{}); + stub.set_lamda(&VaultConfig::set, []{}); + typedef void(QProcess::*FuncType)(const QString &, const QStringList &, QIODevice::OpenMode); + stub.set_lamda(static_cast(&QProcess::start), [ &isOk ]{ + isOk = true; + }); + + FileEncryptHandle::instance()->createVault("/UT_TEST1", "/UT_TEST2", "TU_PASSWORD"); + + EXPECT_TRUE(isOk); +}