mirror of
https://github.com/keepassxreboot/keepassxc.git
synced 2026-11-20 09:01:36 -08:00
* Fix #13073: Respect password generator settings for new entries --------- Co-authored-by: Jonathan White <[email protected]>
418 lines
21 KiB
C++
418 lines
21 KiB
C++
/*
|
|
* Copyright (C) 2026 KeePassXC Team <[email protected]>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 2 or (at your option)
|
|
* version 3 of the License.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "TestPasswordGenerator.h"
|
|
#include "core/Config.h"
|
|
#include "crypto/Crypto.h"
|
|
|
|
#include <QRegularExpression>
|
|
#include <QScopeGuard>
|
|
#include <QTest>
|
|
|
|
QTEST_GUILESS_MAIN(TestPasswordGenerator)
|
|
|
|
Q_DECLARE_METATYPE(PasswordGenerator::CharClasses)
|
|
Q_DECLARE_METATYPE(PasswordGenerator::GeneratorFlags)
|
|
|
|
namespace
|
|
{
|
|
PasswordGenerator::CharClasses to_flags(PasswordGenerator::CharClass x)
|
|
{
|
|
return x;
|
|
}
|
|
|
|
PasswordGenerator::GeneratorFlags to_flags(PasswordGenerator::GeneratorFlag x)
|
|
{
|
|
return x;
|
|
}
|
|
} // namespace
|
|
|
|
void TestPasswordGenerator::initTestCase()
|
|
{
|
|
QVERIFY(Crypto::init());
|
|
QLocale::setDefault(QLocale::c());
|
|
}
|
|
|
|
void TestPasswordGenerator::init()
|
|
{
|
|
m_generator.reset();
|
|
}
|
|
|
|
void TestPasswordGenerator::testCustomCharacterSet_data()
|
|
{
|
|
QTest::addColumn<PasswordGenerator::CharClasses>("activeCharacterClasses");
|
|
QTest::addColumn<QString>("customCharacterSet");
|
|
QTest::addColumn<QRegularExpression>("expected");
|
|
|
|
QTest::addRow("With active classes") << to_flags(PasswordGenerator::CharClass::UpperLetters) << "abc"
|
|
<< QRegularExpression("^[abcA-Z]{2000}$");
|
|
QTest::addRow("Without any active class")
|
|
<< to_flags(PasswordGenerator::CharClass::NoClass) << "abc" << QRegularExpression("^[abc]{2000}$");
|
|
}
|
|
|
|
void TestPasswordGenerator::testCustomCharacterSet()
|
|
{
|
|
QFETCH(PasswordGenerator::CharClasses, activeCharacterClasses);
|
|
QFETCH(QString, customCharacterSet);
|
|
QFETCH(QRegularExpression, expected);
|
|
|
|
m_generator.setCharClasses(activeCharacterClasses);
|
|
m_generator.setCustomCharacterSet(customCharacterSet);
|
|
m_generator.setLength(2000);
|
|
|
|
QVERIFY(m_generator.isValid());
|
|
QString password = m_generator.generatePassword();
|
|
QCOMPARE(password.size(), 2000);
|
|
QVERIFY(expected.match(password).hasMatch());
|
|
}
|
|
|
|
void TestPasswordGenerator::testCharClasses_data()
|
|
{
|
|
QTest::addColumn<PasswordGenerator::CharClasses>("activeCharacterClasses");
|
|
QTest::addColumn<QRegularExpression>("expected");
|
|
|
|
QTest::addRow("Lower Letters") << to_flags(PasswordGenerator::CharClass::LowerLetters)
|
|
<< QRegularExpression(R"(^[a-z]{2000}$)");
|
|
QTest::addRow("Upper Letters") << to_flags(PasswordGenerator::CharClass::UpperLetters)
|
|
<< QRegularExpression(R"(^[A-Z]{2000}$)");
|
|
QTest::addRow("Numbers") << to_flags(PasswordGenerator::CharClass::Numbers) << QRegularExpression(R"(^\d{2000}$)");
|
|
QTest::addRow("Braces") << to_flags(PasswordGenerator::CharClass::Braces)
|
|
<< QRegularExpression(R"(^[\(\)\[\]\{\}]{2000}$)");
|
|
QTest::addRow("Punctuation") << to_flags(PasswordGenerator::CharClass::Punctuation)
|
|
<< QRegularExpression(R"(^[\.,:;]{2000}$)");
|
|
QTest::addRow("Quotes") << to_flags(PasswordGenerator::CharClass::Quotes) << QRegularExpression(R"(^["']{2000}$)");
|
|
QTest::addRow("Dashes") << to_flags(PasswordGenerator::CharClass::Dashes)
|
|
<< QRegularExpression(R"(^[\-/\\_|]{2000}$)");
|
|
QTest::addRow("Math") << to_flags(PasswordGenerator::CharClass::Math) << QRegularExpression(R"(^[!\*\+\-<=>\?]+$)");
|
|
QTest::addRow("Logograms") << to_flags(PasswordGenerator::CharClass::Logograms)
|
|
<< QRegularExpression(R"(^[#`~%&^$@]{2000}$)");
|
|
QTest::addRow("Extended ASCII") << to_flags(PasswordGenerator::CharClass::EASCII)
|
|
<< QRegularExpression(R"(^[^a-zA-Z0-9\.,:;"'\-/\\_|!\*\+\-<=>\?#`~%&^$@]{2000}$)");
|
|
QTest::addRow("Combinations 1") << (PasswordGenerator::CharClass::LowerLetters
|
|
| PasswordGenerator::CharClass::UpperLetters
|
|
| PasswordGenerator::CharClass::Braces)
|
|
<< QRegularExpression(R"(^[a-zA-Z\(\)\[\]\{\}]{2000}$)");
|
|
QTest::addRow("Combinations 2") << (PasswordGenerator::CharClass::Quotes | PasswordGenerator::CharClass::Numbers
|
|
| PasswordGenerator::CharClass::Dashes)
|
|
<< QRegularExpression(R"(^["'\d\-/\\_|]{2000}$)");
|
|
}
|
|
|
|
void TestPasswordGenerator::testCharClasses()
|
|
{
|
|
|
|
QFETCH(PasswordGenerator::CharClasses, activeCharacterClasses);
|
|
QFETCH(QRegularExpression, expected);
|
|
|
|
m_generator.setCharClasses(activeCharacterClasses);
|
|
m_generator.setLength(2000);
|
|
|
|
QVERIFY(m_generator.isValid());
|
|
QString password = m_generator.generatePassword();
|
|
QCOMPARE(password.size(), 2000);
|
|
QVERIFY(expected.match(password).hasMatch());
|
|
}
|
|
|
|
void TestPasswordGenerator::testLookalikeExclusion_data()
|
|
{
|
|
QTest::addColumn<PasswordGenerator::CharClasses>("activeCharacterClasses");
|
|
QTest::addColumn<QRegularExpression>("expected");
|
|
QTest::addRow("Upper Letters") << (PasswordGenerator::CharClass::LowerLetters
|
|
| PasswordGenerator::CharClass::UpperLetters)
|
|
<< QRegularExpression("^[^lBGIO]{2000}$");
|
|
|
|
QTest::addRow("Letters and Numbers") << (PasswordGenerator::CharClass::LowerLetters
|
|
| PasswordGenerator::CharClass::UpperLetters
|
|
| PasswordGenerator::CharClass::Numbers)
|
|
<< QRegularExpression("^[^lBGIO0168]{2000}$");
|
|
|
|
QTest::addRow("Letters, Numbers and extended ASCII")
|
|
<< (PasswordGenerator::CharClass::LowerLetters | PasswordGenerator::CharClass::UpperLetters
|
|
| PasswordGenerator::CharClass::Numbers | PasswordGenerator::CharClass::EASCII)
|
|
<< QRegularExpression("^[^lBGIO0168﹒]{2000}$");
|
|
}
|
|
|
|
void TestPasswordGenerator::testLookalikeExclusion()
|
|
{
|
|
QFETCH(PasswordGenerator::CharClasses, activeCharacterClasses);
|
|
QFETCH(QRegularExpression, expected);
|
|
|
|
m_generator.setFlags(PasswordGenerator::ExcludeLookAlike);
|
|
m_generator.setCharClasses(activeCharacterClasses);
|
|
m_generator.setLength(2000);
|
|
|
|
QVERIFY(m_generator.isValid());
|
|
QString password = m_generator.generatePassword();
|
|
QCOMPARE(password.size(), 2000);
|
|
QVERIFY(expected.match(password).hasMatch());
|
|
}
|
|
|
|
void TestPasswordGenerator::testValidity_data()
|
|
{
|
|
QTest::addColumn<PasswordGenerator::CharClasses>("activeCharacterClasses");
|
|
QTest::addColumn<PasswordGenerator::GeneratorFlags>("generatorFlags");
|
|
QTest::addColumn<QString>("customCharacterSet");
|
|
QTest::addColumn<QString>("excludedCharacters");
|
|
QTest::addColumn<int>("length");
|
|
QTest::addColumn<bool>("isValid");
|
|
|
|
QTest::addRow("No active class") << to_flags(PasswordGenerator::CharClass::NoClass)
|
|
<< PasswordGenerator::GeneratorFlags() << QString() << QString()
|
|
<< PasswordGenerator::DefaultLength << false;
|
|
QTest::addRow("0 length") << to_flags(PasswordGenerator::CharClass::DefaultCharset)
|
|
<< PasswordGenerator::GeneratorFlags() << QString() << QString() << 0 << false;
|
|
QTest::addRow("All active classes excluded")
|
|
<< to_flags(PasswordGenerator::CharClass::Numbers) << PasswordGenerator::GeneratorFlags() << QString()
|
|
<< QString("0123456789") << PasswordGenerator::DefaultLength << false;
|
|
QTest::addRow("All active classes excluded")
|
|
<< to_flags(PasswordGenerator::CharClass::NoClass) << PasswordGenerator::GeneratorFlags() << QString()
|
|
<< QString("0123456789") << PasswordGenerator::DefaultLength << false;
|
|
QTest::addRow("One from every class with too few classes")
|
|
<< (PasswordGenerator::CharClass::LowerLetters | PasswordGenerator::CharClass::UpperLetters)
|
|
<< to_flags(PasswordGenerator::GeneratorFlag::CharFromEveryGroup) << QString() << QString() << 1 << false;
|
|
QTest::addRow("One from every class with excluded classes")
|
|
<< (PasswordGenerator::CharClass::LowerLetters | PasswordGenerator::CharClass::UpperLetters
|
|
| PasswordGenerator::CharClass::Numbers)
|
|
<< to_flags(PasswordGenerator::GeneratorFlag::CharFromEveryGroup) << QString() << QString("0123456789") << 2
|
|
<< true;
|
|
QTest::addRow("Defaults valid") << to_flags(PasswordGenerator::CharClass::DefaultCharset)
|
|
<< to_flags(PasswordGenerator::GeneratorFlag::DefaultFlags)
|
|
<< PasswordGenerator::DefaultCustomCharacterSet
|
|
<< PasswordGenerator::DefaultExcludedChars << PasswordGenerator::DefaultLength
|
|
<< true;
|
|
QTest::addRow("No active classes but custom charset")
|
|
<< to_flags(PasswordGenerator::CharClass::NoClass) << to_flags(PasswordGenerator::GeneratorFlag::DefaultFlags)
|
|
<< QString("a") << QString() << 1 << true;
|
|
}
|
|
|
|
void TestPasswordGenerator::testValidity()
|
|
{
|
|
QFETCH(PasswordGenerator::CharClasses, activeCharacterClasses);
|
|
QFETCH(PasswordGenerator::GeneratorFlags, generatorFlags);
|
|
QFETCH(QString, customCharacterSet);
|
|
QFETCH(QString, excludedCharacters);
|
|
QFETCH(int, length);
|
|
QFETCH(bool, isValid);
|
|
|
|
m_generator.setCharClasses(activeCharacterClasses);
|
|
m_generator.setFlags(generatorFlags);
|
|
m_generator.setCustomCharacterSet(customCharacterSet);
|
|
m_generator.setExcludedCharacterSet(excludedCharacters);
|
|
m_generator.setLength(length);
|
|
QCOMPARE(m_generator.isValid(), isValid);
|
|
}
|
|
|
|
void TestPasswordGenerator::testMinLength_data()
|
|
{
|
|
QTest::addColumn<PasswordGenerator::CharClasses>("activeCharacterClasses");
|
|
QTest::addColumn<PasswordGenerator::GeneratorFlags>("generatorFlags");
|
|
QTest::addColumn<QString>("customCharacterSet");
|
|
QTest::addColumn<QString>("excludedCharacters");
|
|
QTest::addColumn<int>("expectedMinLength");
|
|
|
|
QTest::addRow("No restriction without charsFromEveryGroup")
|
|
<< to_flags(PasswordGenerator::CharClass::Numbers)
|
|
<< to_flags(PasswordGenerator::GeneratorFlag::CharFromEveryGroup)
|
|
<< PasswordGenerator::DefaultCustomCharacterSet << PasswordGenerator::DefaultExcludedChars << 1;
|
|
|
|
QTest::addRow("Min length should equal number of active classes")
|
|
<< (PasswordGenerator::CharClass::LowerLetters | PasswordGenerator::CharClass::UpperLetters
|
|
| PasswordGenerator::CharClass::Numbers)
|
|
<< to_flags(PasswordGenerator::GeneratorFlag::CharFromEveryGroup) << QString() << QString() << 3;
|
|
QTest::addRow("Classes fully excluded by excluded characters do not count towards min length")
|
|
<< (PasswordGenerator::CharClass::Numbers | PasswordGenerator::LowerLetters
|
|
| PasswordGenerator::CharClass::UpperLetters)
|
|
<< to_flags(PasswordGenerator::GeneratorFlag::CharFromEveryGroup) << QString() << QString("0123456789") << 2;
|
|
|
|
QTest::addRow("Custom charset counts as class")
|
|
<< to_flags(PasswordGenerator::CharClass::UpperLetters)
|
|
<< to_flags(PasswordGenerator::GeneratorFlag::CharFromEveryGroup) << QString("a") << QString() << 2;
|
|
QTest::addRow("Custom characters count even if included by an active class already")
|
|
<< (PasswordGenerator::CharClass::LowerLetters | PasswordGenerator::CharClass::UpperLetters
|
|
| PasswordGenerator::CharClass::Numbers)
|
|
<< to_flags(PasswordGenerator::GeneratorFlag::CharFromEveryGroup) << QString("012345") << QString() << 4;
|
|
}
|
|
|
|
void TestPasswordGenerator::testMinLength()
|
|
{
|
|
QFETCH(PasswordGenerator::CharClasses, activeCharacterClasses);
|
|
QFETCH(PasswordGenerator::GeneratorFlags, generatorFlags);
|
|
QFETCH(QString, customCharacterSet);
|
|
QFETCH(QString, excludedCharacters);
|
|
QFETCH(int, expectedMinLength);
|
|
|
|
m_generator.setCharClasses(activeCharacterClasses);
|
|
m_generator.setFlags(generatorFlags);
|
|
m_generator.setCustomCharacterSet(customCharacterSet);
|
|
m_generator.setExcludedCharacterSet(excludedCharacters);
|
|
QCOMPARE(m_generator.getMinLength(), expectedMinLength);
|
|
}
|
|
|
|
void TestPasswordGenerator::testReset()
|
|
{
|
|
PasswordGenerator default_generator;
|
|
|
|
// Modify generator
|
|
m_generator.setCharClasses(PasswordGenerator::CharClass::NoClass);
|
|
m_generator.setFlags(PasswordGenerator::GeneratorFlag::NoFlags);
|
|
m_generator.setCustomCharacterSet("avc");
|
|
m_generator.setExcludedCharacterSet("asdv");
|
|
m_generator.setLength(m_generator.getLength() + 1);
|
|
|
|
Q_ASSERT(m_generator.getActiveClasses() != default_generator.getActiveClasses());
|
|
Q_ASSERT(m_generator.getFlags() != default_generator.getFlags());
|
|
Q_ASSERT(m_generator.getCustomCharacterSet() != default_generator.getCustomCharacterSet());
|
|
Q_ASSERT(m_generator.getExcludedCharacterSet() != default_generator.getExcludedCharacterSet());
|
|
|
|
m_generator.reset();
|
|
QCOMPARE(m_generator.getActiveClasses(), default_generator.getActiveClasses());
|
|
QCOMPARE(m_generator.getFlags(), default_generator.getFlags());
|
|
QCOMPARE(m_generator.getCustomCharacterSet(), default_generator.getCustomCharacterSet());
|
|
QCOMPARE(m_generator.getExcludedCharacterSet(), default_generator.getExcludedCharacterSet());
|
|
QCOMPARE(m_generator.getLength(), default_generator.getLength());
|
|
}
|
|
|
|
void TestPasswordGenerator::testCreateFromConfig()
|
|
{
|
|
// Save current config values and restore on scope exit
|
|
auto savedLower = config()->get(Config::PasswordGenerator_LowerCase);
|
|
auto savedUpper = config()->get(Config::PasswordGenerator_UpperCase);
|
|
auto savedNumbers = config()->get(Config::PasswordGenerator_Numbers);
|
|
auto savedEASCII = config()->get(Config::PasswordGenerator_EASCII);
|
|
auto savedAdvanced = config()->get(Config::PasswordGenerator_AdvancedMode);
|
|
auto savedSpecialChars = config()->get(Config::PasswordGenerator_SpecialChars);
|
|
auto savedBraces = config()->get(Config::PasswordGenerator_Braces);
|
|
auto savedPunctuation = config()->get(Config::PasswordGenerator_Punctuation);
|
|
auto savedQuotes = config()->get(Config::PasswordGenerator_Quotes);
|
|
auto savedDashes = config()->get(Config::PasswordGenerator_Dashes);
|
|
auto savedMath = config()->get(Config::PasswordGenerator_Math);
|
|
auto savedLogograms = config()->get(Config::PasswordGenerator_Logograms);
|
|
auto savedAdditionalChars = config()->get(Config::PasswordGenerator_AdditionalChars);
|
|
auto savedExcludedChars = config()->get(Config::PasswordGenerator_ExcludedChars);
|
|
auto savedExcludeAlike = config()->get(Config::PasswordGenerator_ExcludeAlike);
|
|
auto savedEnsureEvery = config()->get(Config::PasswordGenerator_EnsureEvery);
|
|
auto savedLength = config()->get(Config::PasswordGenerator_Length);
|
|
|
|
QScopeGuard guard([savedLower,
|
|
savedUpper,
|
|
savedNumbers,
|
|
savedEASCII,
|
|
savedAdvanced,
|
|
savedSpecialChars,
|
|
savedBraces,
|
|
savedPunctuation,
|
|
savedQuotes,
|
|
savedDashes,
|
|
savedMath,
|
|
savedLogograms,
|
|
savedAdditionalChars,
|
|
savedExcludedChars,
|
|
savedExcludeAlike,
|
|
savedEnsureEvery,
|
|
savedLength]() {
|
|
config()->set(Config::PasswordGenerator_LowerCase, savedLower);
|
|
config()->set(Config::PasswordGenerator_UpperCase, savedUpper);
|
|
config()->set(Config::PasswordGenerator_Numbers, savedNumbers);
|
|
config()->set(Config::PasswordGenerator_EASCII, savedEASCII);
|
|
config()->set(Config::PasswordGenerator_AdvancedMode, savedAdvanced);
|
|
config()->set(Config::PasswordGenerator_SpecialChars, savedSpecialChars);
|
|
config()->set(Config::PasswordGenerator_Braces, savedBraces);
|
|
config()->set(Config::PasswordGenerator_Punctuation, savedPunctuation);
|
|
config()->set(Config::PasswordGenerator_Quotes, savedQuotes);
|
|
config()->set(Config::PasswordGenerator_Dashes, savedDashes);
|
|
config()->set(Config::PasswordGenerator_Math, savedMath);
|
|
config()->set(Config::PasswordGenerator_Logograms, savedLogograms);
|
|
config()->set(Config::PasswordGenerator_AdditionalChars, savedAdditionalChars);
|
|
config()->set(Config::PasswordGenerator_ExcludedChars, savedExcludedChars);
|
|
config()->set(Config::PasswordGenerator_ExcludeAlike, savedExcludeAlike);
|
|
config()->set(Config::PasswordGenerator_EnsureEvery, savedEnsureEvery);
|
|
config()->set(Config::PasswordGenerator_Length, savedLength);
|
|
});
|
|
|
|
// Test non-advanced mode with special chars
|
|
config()->set(Config::PasswordGenerator_LowerCase, false);
|
|
config()->set(Config::PasswordGenerator_UpperCase, true);
|
|
config()->set(Config::PasswordGenerator_Numbers, true);
|
|
config()->set(Config::PasswordGenerator_EASCII, false);
|
|
config()->set(Config::PasswordGenerator_AdvancedMode, false);
|
|
config()->set(Config::PasswordGenerator_SpecialChars, true);
|
|
config()->set(Config::PasswordGenerator_ExcludeAlike, true);
|
|
config()->set(Config::PasswordGenerator_EnsureEvery, true);
|
|
config()->set(Config::PasswordGenerator_Length, 20);
|
|
|
|
{
|
|
PasswordGenerator generator;
|
|
generator.loadSettingsFromConfig();
|
|
QCOMPARE(generator.getLength(), 20);
|
|
QVERIFY(!(generator.getActiveClasses() & PasswordGenerator::LowerLetters));
|
|
QVERIFY(generator.getActiveClasses() & PasswordGenerator::UpperLetters);
|
|
QVERIFY(generator.getActiveClasses() & PasswordGenerator::Numbers);
|
|
QVERIFY(generator.getActiveClasses() & PasswordGenerator::SpecialCharacters);
|
|
QVERIFY(!(generator.getFlags() & PasswordGenerator::ExcludeLookAlike));
|
|
QVERIFY(!(generator.getFlags() & PasswordGenerator::CharFromEveryGroup));
|
|
}
|
|
|
|
// Test advanced mode with specific character classes
|
|
config()->set(Config::PasswordGenerator_AdvancedMode, true);
|
|
config()->set(Config::PasswordGenerator_SpecialChars, false);
|
|
config()->set(Config::PasswordGenerator_Braces, true);
|
|
config()->set(Config::PasswordGenerator_Punctuation, true);
|
|
config()->set(Config::PasswordGenerator_Quotes, false);
|
|
config()->set(Config::PasswordGenerator_Dashes, true);
|
|
config()->set(Config::PasswordGenerator_Math, false);
|
|
config()->set(Config::PasswordGenerator_Logograms, true);
|
|
config()->set(Config::PasswordGenerator_AdditionalChars, "abc");
|
|
config()->set(Config::PasswordGenerator_ExcludedChars, "xyz");
|
|
config()->set(Config::PasswordGenerator_ExcludeAlike, false);
|
|
config()->set(Config::PasswordGenerator_EnsureEvery, false);
|
|
config()->set(Config::PasswordGenerator_Length, 16);
|
|
|
|
{
|
|
PasswordGenerator generator;
|
|
generator.loadSettingsFromConfig();
|
|
QCOMPARE(generator.getLength(), 16);
|
|
QVERIFY(!(generator.getActiveClasses() & PasswordGenerator::LowerLetters));
|
|
QVERIFY(generator.getActiveClasses() & PasswordGenerator::UpperLetters);
|
|
QVERIFY(generator.getActiveClasses() & PasswordGenerator::Numbers);
|
|
QVERIFY(generator.getActiveClasses() & PasswordGenerator::Braces);
|
|
QVERIFY(generator.getActiveClasses() & PasswordGenerator::Punctuation);
|
|
QVERIFY(!(generator.getActiveClasses() & PasswordGenerator::Quotes));
|
|
QVERIFY(generator.getActiveClasses() & PasswordGenerator::Dashes);
|
|
QVERIFY(!(generator.getActiveClasses() & PasswordGenerator::Math));
|
|
QVERIFY(generator.getActiveClasses() & PasswordGenerator::Logograms);
|
|
QVERIFY(!(generator.getFlags() & PasswordGenerator::ExcludeLookAlike));
|
|
QVERIFY(!(generator.getFlags() & PasswordGenerator::CharFromEveryGroup));
|
|
QCOMPARE(generator.getCustomCharacterSet(), QString("abc"));
|
|
QCOMPARE(generator.getExcludedCharacterSet(), QString("xyz"));
|
|
}
|
|
|
|
// Test invalid config (no classes, no custom chars) — generator should be invalid
|
|
config()->set(Config::PasswordGenerator_LowerCase, false);
|
|
config()->set(Config::PasswordGenerator_UpperCase, false);
|
|
config()->set(Config::PasswordGenerator_Numbers, false);
|
|
config()->set(Config::PasswordGenerator_EASCII, false);
|
|
config()->set(Config::PasswordGenerator_AdvancedMode, false);
|
|
config()->set(Config::PasswordGenerator_SpecialChars, false);
|
|
config()->set(Config::PasswordGenerator_AdditionalChars, QString());
|
|
config()->set(Config::PasswordGenerator_Length, 32);
|
|
|
|
{
|
|
PasswordGenerator generator;
|
|
generator.loadSettingsFromConfig();
|
|
QVERIFY(!generator.isValid());
|
|
}
|
|
}
|