[Settings] Split cache_settings into multiple files

Took 9 minutes Took 4 minutes
2026-09-29 17:32:17 -07:00 · 2026-07-17 08:09:36 -04:00 · 2026-07-17 08:09:36 -04:00 · 4d550507f0
commit 4d550507f0
parent 3f9dbdb33b
136 changed files with 5124 additions and 2993 deletions
--- a/tests/settings/CMakeLists.txt
+++ b/tests/settings/CMakeLists.txt
@ -0,0 +1,26 @@
+add_executable(settings_manager_test settings_manager_test.cpp)
+add_executable(settings_defaults_test settings_defaults_test.cpp)
+add_executable(settings_migration_test settings_migration_test.cpp)
+
+target_link_libraries(
+  settings_manager_test libcockatrice_settings Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
+)
+
+target_link_libraries(
+  settings_defaults_test libcockatrice_settings Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
+)
+target_compile_definitions(settings_defaults_test PRIVATE SETTINGS_UNIT_TEST)
+
+target_link_libraries(
+  settings_migration_test libcockatrice_settings Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
+)
+
+add_test(NAME settings_manager_test COMMAND settings_manager_test)
+add_test(NAME settings_defaults_test COMMAND settings_defaults_test)
+add_test(NAME settings_migration_test COMMAND settings_migration_test)
+
+if(NOT GTEST_FOUND)
+  add_dependencies(settings_manager_test gtest)
+  add_dependencies(settings_defaults_test gtest)
+  add_dependencies(settings_migration_test gtest)
+endif()
--- a/tests/settings/settings_defaults_test.cpp
+++ b/tests/settings/settings_defaults_test.cpp
@ -0,0 +1,355 @@
+#include "gtest/gtest.h"
+#include <QSettings>
+#include <QTemporaryDir>
+#include <libcockatrice/settings/cache_storage_settings.h>
+#include <libcockatrice/settings/chat_settings.h>
+#include <libcockatrice/settings/game_settings.h>
+#include <libcockatrice/settings/personal_settings.h>
+#include <libcockatrice/settings/sound_settings.h>
+#include <libcockatrice/settings/tabs_settings.h>
+#include <libcockatrice/settings/updates_settings.h>
+#include <libcockatrice/settings/visual_deck_storage_settings.h>
+
+namespace
+{
+
+class SettingsDefaultsTest : public ::testing::Test
+{
+protected:
+    QTemporaryDir tempDir;
+    QString settingsPath;
+
+    void SetUp() override
+    {
+        settingsPath = tempDir.path() + "/";
+    }
+};
+
+// --- CacheStorageSettings ---
+
+TEST_F(SettingsDefaultsTest, CacheStorage_PixmapCacheSize_Default)
+{
+    CacheStorageSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getPixmapCacheSize(), PIXMAPCACHE_SIZE_DEFAULT);
+}
+
+TEST_F(SettingsDefaultsTest, CacheStorage_PixmapCacheSize_SetAndGet)
+{
+    CacheStorageSettings s(settingsPath, nullptr);
+    s.setPixmapCacheSize(1024);
+    ASSERT_EQ(s.getPixmapCacheSize(), 1024);
+}
+
+TEST_F(SettingsDefaultsTest, CacheStorage_NetworkCacheSizeInMB_Default)
+{
+    CacheStorageSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getNetworkCacheSizeInMB(), NETWORK_CACHE_SIZE_DEFAULT);
+}
+
+TEST_F(SettingsDefaultsTest, CacheStorage_RedirectCacheTtl_Default)
+{
+    CacheStorageSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getRedirectCacheTtl(), NETWORK_REDIRECT_CACHE_TTL_DEFAULT);
+}
+
+TEST_F(SettingsDefaultsTest, CacheStorage_CardPictureLoaderCacheMethod_Default)
+{
+    CacheStorageSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getCardPictureLoaderCacheMethod(), 0);
+}
+
+TEST_F(SettingsDefaultsTest, CacheStorage_LocalCardImageStorageNamingScheme_Default)
+{
+    CacheStorageSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getLocalCardImageStorageNamingScheme(), 0);
+}
+
+// --- GameSettings ---
+
+TEST_F(SettingsDefaultsTest, Game_MaxPlayers_Default)
+{
+    GameSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getMaxPlayers(), 2);
+}
+
+TEST_F(SettingsDefaultsTest, Game_MaxPlayers_SetAndGet)
+{
+    GameSettings s(settingsPath, nullptr);
+    s.setMaxPlayers(4);
+    ASSERT_EQ(s.getMaxPlayers(), 4);
+}
+
+TEST_F(SettingsDefaultsTest, Game_DefaultStartingLifeTotal_Default)
+{
+    GameSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getDefaultStartingLifeTotal(), 20);
+}
+
+TEST_F(SettingsDefaultsTest, Game_RememberGameSettings_Default)
+{
+    GameSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getRememberGameSettings(), true);
+}
+
+TEST_F(SettingsDefaultsTest, Game_LocalGameMaxPlayers_Default)
+{
+    GameSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getLocalGameMaxPlayers(), 1);
+}
+
+TEST_F(SettingsDefaultsTest, Game_LocalGameStartingLifeTotal_Default)
+{
+    GameSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getLocalGameStartingLifeTotal(), 20);
+}
+
+TEST_F(SettingsDefaultsTest, Game_LocalGameRememberSettings_Default)
+{
+    GameSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getLocalGameRememberSettings(), false);
+}
+
+// --- UpdatesSettings ---
+
+TEST_F(SettingsDefaultsTest, Updates_CheckUpdatesOnStartup_Default)
+{
+    UpdatesSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getCheckUpdatesOnStartup(), true);
+}
+
+TEST_F(SettingsDefaultsTest, Updates_StartupCardUpdateCheckPromptForUpdate_Default)
+{
+    UpdatesSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getStartupCardUpdateCheckPromptForUpdate(), true);
+}
+
+TEST_F(SettingsDefaultsTest, Updates_StartupCardUpdateCheckAlwaysUpdate_Default)
+{
+    UpdatesSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getStartupCardUpdateCheckAlwaysUpdate(), false);
+}
+
+TEST_F(SettingsDefaultsTest, Updates_CardUpdateCheckInterval_Default)
+{
+    UpdatesSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getCardUpdateCheckInterval(), 7);
+}
+
+TEST_F(SettingsDefaultsTest, Updates_AlwaysEnableNewSets_Default)
+{
+    UpdatesSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getAlwaysEnableNewSets(), false);
+}
+
+TEST_F(SettingsDefaultsTest, Updates_NotifyAboutUpdates_Default)
+{
+    UpdatesSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getNotifyAboutUpdates(), true);
+}
+
+TEST_F(SettingsDefaultsTest, Updates_NotifyAboutNewVersion_Default)
+{
+    UpdatesSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getNotifyAboutNewVersion(), true);
+}
+
+TEST_F(SettingsDefaultsTest, Updates_UpdateReleaseChannelIndex_Default)
+{
+    UpdatesSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getUpdateReleaseChannelIndex(), 0);
+}
+
+// --- SoundSettings ---
+
+TEST_F(SettingsDefaultsTest, Sound_SoundEnabled_Default)
+{
+    SoundSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getSoundEnabled(), false);
+}
+
+TEST_F(SettingsDefaultsTest, Sound_MasterVolume_Default)
+{
+    SoundSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getMasterVolume(), 100);
+}
+
+TEST_F(SettingsDefaultsTest, Sound_MasterVolume_SetAndGet)
+{
+    SoundSettings s(settingsPath, nullptr);
+    s.setMasterVolume(50);
+    ASSERT_EQ(s.getMasterVolume(), 50);
+}
+
+// --- TabsSettings ---
+
+TEST_F(SettingsDefaultsTest, Tabs_AllTabsOpen_Default)
+{
+    TabsSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getTabVisualDeckStorageOpen(), true);
+    ASSERT_EQ(s.getTabServerOpen(), true);
+    ASSERT_EQ(s.getTabAccountOpen(), true);
+    ASSERT_EQ(s.getTabDeckStorageOpen(), true);
+    ASSERT_EQ(s.getTabReplaysOpen(), true);
+    ASSERT_EQ(s.getTabAdminOpen(), true);
+    ASSERT_EQ(s.getTabLogOpen(), true);
+}
+
+// --- ChatSettings ---
+
+TEST_F(SettingsDefaultsTest, Chat_Mention_Default)
+{
+    ChatSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getChatMention(), true);
+}
+
+TEST_F(SettingsDefaultsTest, Chat_MentionCompleter_Default)
+{
+    ChatSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getChatMentionCompleter(), true);
+}
+
+TEST_F(SettingsDefaultsTest, Chat_MentionColor_Default)
+{
+    ChatSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getChatMentionColor(), QString("A6120D"));
+}
+
+TEST_F(SettingsDefaultsTest, Chat_HighlightColor_Default)
+{
+    ChatSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getChatHighlightColor(), QString("A6120D"));
+}
+
+TEST_F(SettingsDefaultsTest, Chat_MentionForeground_Default)
+{
+    ChatSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getChatMentionForeground(), true);
+}
+
+TEST_F(SettingsDefaultsTest, Chat_HighlightForeground_Default)
+{
+    ChatSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getChatHighlightForeground(), true);
+}
+
+TEST_F(SettingsDefaultsTest, Chat_ShowMessagePopup_Default)
+{
+    ChatSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getShowMessagePopup(), true);
+}
+
+TEST_F(SettingsDefaultsTest, Chat_ShowMentionPopup_Default)
+{
+    ChatSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getShowMentionPopup(), true);
+}
+
+TEST_F(SettingsDefaultsTest, Chat_RoomHistory_Default)
+{
+    ChatSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getRoomHistory(), true);
+}
+
+// --- PersonalSettings ---
+
+TEST_F(SettingsDefaultsTest, Personal_Lang_Default)
+{
+    PersonalSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getLang(), QString("English"));
+}
+
+TEST_F(SettingsDefaultsTest, Personal_ClientID_Default)
+{
+    PersonalSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getClientID(), QString("notset"));
+}
+
+TEST_F(SettingsDefaultsTest, Personal_KeepAlive_Default)
+{
+    PersonalSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getKeepAlive(), 3);
+}
+
+TEST_F(SettingsDefaultsTest, Personal_TimeOut_Default)
+{
+    PersonalSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getTimeOut(), 5);
+}
+
+TEST_F(SettingsDefaultsTest, Personal_PicDownload_Default)
+{
+    PersonalSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getPicDownload(), true);
+}
+
+TEST_F(SettingsDefaultsTest, Personal_ShowStatusBar_Default)
+{
+    PersonalSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getShowStatusBar(), false);
+}
+
+TEST_F(SettingsDefaultsTest, Personal_MaxFontSize_Default)
+{
+    PersonalSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getMaxFontSize(), 12);
+}
+
+TEST_F(SettingsDefaultsTest, Personal_HomeTabBackgroundSource_Default)
+{
+    PersonalSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getHomeTabBackgroundSource(), QString("themed"));
+}
+
+TEST_F(SettingsDefaultsTest, Personal_HomeTabDisplayCardName_Default)
+{
+    PersonalSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getHomeTabDisplayCardName(), true);
+}
+
+TEST_F(SettingsDefaultsTest, Personal_ShowTipsOnStartup_Default)
+{
+    PersonalSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getShowTipsOnStartup(), true);
+}
+
+TEST_F(SettingsDefaultsTest, Personal_DownloadSpoilersStatus_Default)
+{
+    PersonalSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getDownloadSpoilersStatus(), false);
+}
+
+// --- VisualDeckStorageSettings ---
+
+TEST_F(SettingsDefaultsTest, VisualDeckStorage_SortingOrder_Default)
+{
+    VisualDeckStorageSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getVisualDeckStorageSortingOrder(), 0);
+}
+
+TEST_F(SettingsDefaultsTest, VisualDeckStorage_ShowFolders_Default)
+{
+    VisualDeckStorageSettings s(settingsPath, nullptr);
+    ASSERT_EQ(s.getVisualDeckStorageShowFolders(), true);
+}
+
+TEST_F(SettingsDefaultsTest, VisualDeckStorage_DefaultTagsList_NotEmpty)
+{
+    VisualDeckStorageSettings s(settingsPath, nullptr);
+    ASSERT_GT(s.getVisualDeckStorageDefaultTagsList().size(), 0);
+}
+
+TEST_F(SettingsDefaultsTest, VisualDeckStorage_DefaultTagsList_SetAndGet)
+{
+    VisualDeckStorageSettings s(settingsPath, nullptr);
+    QStringList custom = {"Tag1", "Tag2"};
+    s.setVisualDeckStorageDefaultTagsList(custom);
+    ASSERT_EQ(s.getVisualDeckStorageDefaultTagsList(), custom);
+}
+
+} // namespace
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
--- a/tests/settings/settings_manager_test.cpp
+++ b/tests/settings/settings_manager_test.cpp
@ -0,0 +1,171 @@
+#include "gtest/gtest.h"
+#include <QSettings>
+#include <QTemporaryDir>
+#include <libcockatrice/settings/settings_manager.h>
+
+namespace
+{
+
+class SettingsManagerTest : public ::testing::Test
+{
+protected:
+    QTemporaryDir tempDir;
+    QString settingsPath;
+
+    void SetUp() override
+    {
+        settingsPath = tempDir.path() + "/";
+    }
+
+    void writeValue(const QString &file, const QString &key, const QVariant &value)
+    {
+        QSettings qs(file, QSettings::IniFormat);
+        qs.setValue(key, value);
+    }
+};
+
+TEST_F(SettingsManagerTest, GetValueNoDefaultReturnsInvalid)
+{
+    SettingsManager sm(settingsPath + "test.ini");
+    QVariant val = sm.getValue("nonexistent");
+    ASSERT_TRUE(val.isNull());
+}
+
+TEST_F(SettingsManagerTest, GetValueWithDefaultReturnsDefaultWhenMissing)
+{
+    SettingsManager sm(settingsPath + "test.ini");
+    QVariant val = sm.getValue("nonexistent", QString(), QString(), 42);
+    ASSERT_EQ(val.toInt(), 42);
+}
+
+TEST_F(SettingsManagerTest, GetValueWithDefaultReturnsStoredWhenPresent)
+{
+    writeValue(settingsPath + "test.ini", "mykey", 99);
+
+    SettingsManager sm(settingsPath + "test.ini");
+    QVariant val = sm.getValue("mykey", QString(), QString(), 42);
+    ASSERT_EQ(val.toInt(), 99);
+}
+
+TEST_F(SettingsManagerTest, GetValueWithGroup)
+{
+    writeValue(settingsPath + "grouped.ini", "group1/greeting", "world");
+
+    SettingsManager sm(settingsPath + "grouped.ini");
+    QVariant val = sm.getValue("greeting", "group1");
+    ASSERT_EQ(val.toString(), QString("world"));
+}
+
+TEST_F(SettingsManagerTest, GetValueWithGroupAndSubGroup)
+{
+    writeValue(settingsPath + "nested.ini", "outer/inner/depth", 1);
+
+    SettingsManager sm(settingsPath + "nested.ini");
+    QVariant val = sm.getValue("depth", "outer", "inner");
+    ASSERT_EQ(val.toInt(), 1);
+}
+
+TEST_F(SettingsManagerTest, DefaultGroupUsedInGetValue)
+{
+    writeValue(settingsPath + "defgroup.ini", "defaultGroup/key", "val");
+
+    SettingsManager sm(settingsPath + "defgroup.ini", "defaultGroup");
+    QVariant val = sm.getValue("key");
+    ASSERT_EQ(val.toString(), QString("val"));
+}
+
+TEST_F(SettingsManagerTest, DefaultGroupScopesGetValue)
+{
+    writeValue(settingsPath + "scoped.ini", "key", "ungrouped");
+    writeValue(settingsPath + "scoped.ini", "defaultGroup/key", "grouped");
+
+    SettingsManager sm(settingsPath + "scoped.ini", "defaultGroup");
+    QVariant val = sm.getValue("key");
+    ASSERT_EQ(val.toString(), QString("grouped"));
+}
+
+TEST_F(SettingsManagerTest, DefaultSubGroupUsedInGetValue)
+{
+    writeValue(settingsPath + "sub.ini", "top/bottom/key", "nested");
+
+    SettingsManager sm(settingsPath + "sub.ini", "top", "bottom");
+    QVariant val = sm.getValue("key");
+    ASSERT_EQ(val.toString(), QString("nested"));
+}
+
+TEST_F(SettingsManagerTest, BatchWriteWritesAllValues)
+{
+    SettingsManager sm(settingsPath + "batch.ini");
+    sm.batchWrite([&](QSettings &qs) {
+        qs.setValue("a", 1);
+        qs.setValue("b", 2);
+        qs.setValue("c", 3);
+    });
+
+    SettingsManager sm2(settingsPath + "batch.ini");
+    ASSERT_EQ(sm2.getValue("a", QString(), QString(), 0).toInt(), 1);
+    ASSERT_EQ(sm2.getValue("b", QString(), QString(), 0).toInt(), 2);
+    ASSERT_EQ(sm2.getValue("c", QString(), QString(), 0).toInt(), 3);
+}
+
+TEST_F(SettingsManagerTest, BatchWriteWithGroup)
+{
+    SettingsManager sm(settingsPath + "batch_group.ini");
+    sm.batchWrite([&](QSettings &qs) {
+        qs.beginGroup("section");
+        qs.setValue("x", 10);
+        qs.endGroup();
+    });
+
+    SettingsManager sm2(settingsPath + "batch_group.ini");
+    ASSERT_EQ(sm2.getValue("x", "section", QString(), 0).toInt(), 10);
+}
+
+TEST_F(SettingsManagerTest, SyncPersistsToDisk)
+{
+    QString filePath = settingsPath + "sync_test.ini";
+    {
+        SettingsManager sm(filePath);
+        sm.batchWrite([&](QSettings &qs) { qs.setValue("persist", "yes"); });
+    }
+    {
+        QSettings qs(filePath, QSettings::IniFormat);
+        ASSERT_EQ(qs.value("persist").toString(), QString("yes"));
+    }
+}
+
+TEST_F(SettingsManagerTest, MultipleReadsAfterWrite)
+{
+    SettingsManager sm(settingsPath + "multi.ini");
+    sm.batchWrite([&](QSettings &qs) { qs.setValue("k1", 1); });
+
+    QVariant v1 = sm.getValue("k1", QString(), QString(), 0);
+    QVariant v2 = sm.getValue("nonexistent", QString(), QString(), 99);
+
+    ASSERT_EQ(v1.toInt(), 1);
+    ASSERT_EQ(v2.toInt(), 99);
+}
+
+TEST_F(SettingsManagerTest, ValuesDeletedViaQSettingsAreReadAsDefault)
+{
+    writeValue(settingsPath + "del.ini", "deleteMe", "present");
+
+    SettingsManager sm(settingsPath + "del.ini");
+    ASSERT_EQ(sm.getValue("deleteMe", QString(), QString(), "default").toString(), QString("present"));
+
+    // Delete via QSettings directly (deleteValue is protected)
+    {
+        QSettings qs(settingsPath + "del.ini", QSettings::IniFormat);
+        qs.remove("deleteMe");
+    }
+
+    ASSERT_EQ(sm.getValue("deleteMe", QString(), QString(), "default").toString(), QString("default"));
+}
+
+} // namespace
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
--- a/tests/settings/settings_migration_test.cpp
+++ b/tests/settings/settings_migration_test.cpp
@ -0,0 +1,321 @@
+#include "gtest/gtest.h"
+#include <QDir>
+#include <QFile>
+#include <QSettings>
+#include <QStringList>
+#include <QTemporaryDir>
+#include <libcockatrice/settings/settings_migration.h>
+
+namespace
+{
+
+class SettingsMigrationTest : public ::testing::Test
+{
+protected:
+    QTemporaryDir tempDir;
+    QString settingsPath;
+
+    void SetUp() override
+    {
+        settingsPath = tempDir.path() + "/";
+    }
+
+    bool fileExists(const QString &name) const
+    {
+        return QFile::exists(settingsPath + name);
+    }
+
+    QVariant readFromIni(const QString &fileName, const QString &key) const
+    {
+        QSettings ini(settingsPath + fileName, QSettings::IniFormat);
+        return ini.value(key);
+    }
+};
+
+TEST_F(SettingsMigrationTest, NoGlobalIniDoesNothing)
+{
+    bool result = SettingsMigration::migrateSettingsFromGlobalIni(settingsPath);
+    ASSERT_FALSE(result);
+}
+
+TEST_F(SettingsMigrationTest, EmptyGlobalIniGetsBackedUp)
+{
+    {
+        QFile f(settingsPath + "global.ini");
+        ASSERT_TRUE(f.open(QIODevice::WriteOnly));
+        f.close();
+    }
+    bool result = SettingsMigration::migrateSettingsFromGlobalIni(settingsPath);
+    ASSERT_TRUE(result);
+    ASSERT_TRUE(fileExists("global.ini.old"));
+    ASSERT_TRUE(fileExists("global.ini"));
+
+    // No per-file INIs should be created
+    ASSERT_FALSE(fileExists("tabs.ini"));
+    ASSERT_FALSE(fileExists("sound.ini"));
+
+    // Sentinel should be in the new global.ini
+    ASSERT_EQ(readFromIni("global.ini", "migration/perfile_complete"), QVariant(true));
+}
+
+TEST_F(SettingsMigrationTest, MigratesAllSettingsGroups)
+{
+    {
+        QSettings g(settingsPath + "global.ini", QSettings::IniFormat);
+
+        // tabs
+        g.setValue("tabs/visualDeckStorage", false);
+        g.setValue("tabs/server", true);
+        g.setValue("tabs/account", true);
+        g.setValue("tabs/deckStorage", true);
+        g.setValue("tabs/replays", false);
+        g.setValue("tabs/admin", false);
+        g.setValue("tabs/log", true);
+
+        // sound
+        g.setValue("sound/enabled", true);
+        g.setValue("sound/theme", "custom_theme");
+        g.setValue("sound/mastervolume", 75);
+
+        // game
+        g.beginGroup("game");
+        g.setValue("maxplayers", 4);
+        g.setValue("gamedescription", "test game");
+        g.setValue("remembergamesettings", false);
+        g.endGroup();
+
+        // localgameoptions
+        g.beginGroup("localgameoptions");
+        g.setValue("maxplayers", 2);
+        g.setValue("startinglifetotal", 40);
+        g.endGroup();
+
+        // chat
+        g.beginGroup("chat");
+        g.setValue("mention", false);
+        g.setValue("mentioncolor", "FF0000");
+        g.setValue("showmessagepopups", false);
+        g.endGroup();
+
+        // cache storage (under [personal] group)
+        g.setValue("personal/pixmapCacheSize", 1024);
+        g.setValue("personal/networkCacheSize", 2048);
+
+        // updates (under [personal] group)
+        g.setValue("personal/startupUpdateCheck", false);
+        g.setValue("personal/cardUpdateCheckInterval", 14);
+
+        // personal
+        g.setValue("personal/lang", "de");
+        g.setValue("personal/keepalive", 10);
+        g.setValue("personal/timeout", 30);
+        g.setValue("personal/clientid", "test-client-id");
+        g.setValue("personal/picturedownload", true);
+        g.setValue("personal/showStatusBar", true);
+
+        // personal home
+        g.setValue("home/background", "custom_bg");
+        g.setValue("home/background/shuffleTimer", 30);
+
+        // personal tipOfDay
+        g.setValue("tipOfDay/showTips", false);
+
+        // cards
+        g.setValue("cards/displaycardnames", false);
+        g.setValue("cards/tapanimation", true);
+        g.setValue("cards/scaleCards", false);
+
+        // interface
+        g.setValue("interface/usetearoffmenus", true);
+        g.setValue("interface/notificationsenabled", false);
+        g.setValue("interface/startinghandsize", 5);
+
+        // hand/table
+        g.setValue("hand/horizontal", true);
+        g.setValue("table/invert_vertical", true);
+
+        // paths
+        g.beginGroup("paths");
+        g.setValue("decks", "/custom/decks");
+        g.setValue("pics", "/custom/pics");
+        g.endGroup();
+
+        // visual deck storage (under [interface] group)
+        g.setValue("interface/visualdeckstoragecardsize", 150);
+        g.setValue("interface/visualdeckstorageshowfolders", false);
+        g.setValue("interface/visualdeckstorageshowtagfilter", false);
+
+        g.sync();
+    }
+
+    bool result = SettingsMigration::migrateSettingsFromGlobalIni(settingsPath);
+    ASSERT_TRUE(result);
+
+    // Original global.ini should be backed up
+    ASSERT_TRUE(fileExists("global.ini.old"));
+
+    // Verify each per-file INI was created and has correct values
+    ASSERT_TRUE(fileExists("tabs.ini"));
+    ASSERT_EQ(readFromIni("tabs.ini", "tabs/visualDeckStorage"), QVariant(false));
+    ASSERT_EQ(readFromIni("tabs.ini", "tabs/server"), QVariant(true));
+    ASSERT_EQ(readFromIni("tabs.ini", "tabs/log"), QVariant(true));
+
+    ASSERT_TRUE(fileExists("sound.ini"));
+    ASSERT_EQ(readFromIni("sound.ini", "sound/enabled"), QVariant(true));
+    ASSERT_EQ(readFromIni("sound.ini", "sound/theme"), QVariant("custom_theme"));
+    ASSERT_EQ(readFromIni("sound.ini", "sound/mastervolume"), QVariant(75));
+
+    ASSERT_TRUE(fileExists("game.ini"));
+    ASSERT_EQ(readFromIni("game.ini", "game/maxplayers"), QVariant(4));
+    ASSERT_EQ(readFromIni("game.ini", "game/gamedescription"), QVariant("test game"));
+    ASSERT_EQ(readFromIni("game.ini", "game/remembergamesettings"), QVariant(false));
+    ASSERT_EQ(readFromIni("game.ini", "localgameoptions/maxplayers"), QVariant(2));
+    ASSERT_EQ(readFromIni("game.ini", "localgameoptions/startinglifetotal"), QVariant(40));
+
+    ASSERT_TRUE(fileExists("chat.ini"));
+    ASSERT_EQ(readFromIni("chat.ini", "chat/mention"), QVariant(false));
+    ASSERT_EQ(readFromIni("chat.ini", "chat/mentioncolor"), QVariant("FF0000"));
+    ASSERT_EQ(readFromIni("chat.ini", "chat/showmessagepopups"), QVariant(false));
+
+    ASSERT_TRUE(fileExists("cache_storage.ini"));
+    ASSERT_EQ(readFromIni("cache_storage.ini", "personal/pixmapCacheSize"), QVariant(1024));
+    ASSERT_EQ(readFromIni("cache_storage.ini", "personal/networkCacheSize"), QVariant(2048));
+
+    ASSERT_TRUE(fileExists("updates.ini"));
+    ASSERT_EQ(readFromIni("updates.ini", "updates/startupUpdateCheck"), QVariant(false));
+    ASSERT_EQ(readFromIni("updates.ini", "updates/cardUpdateCheckInterval"), QVariant(14));
+
+    ASSERT_TRUE(fileExists("personal.ini"));
+    ASSERT_EQ(readFromIni("personal.ini", "personal/lang"), QVariant("de"));
+    ASSERT_EQ(readFromIni("personal.ini", "personal/keepalive"), QVariant(10));
+    ASSERT_EQ(readFromIni("personal.ini", "personal/clientid"), QVariant("test-client-id"));
+    ASSERT_EQ(readFromIni("personal.ini", "personal/showStatusBar"), QVariant(true));
+    ASSERT_EQ(readFromIni("personal.ini", "home/background"), QVariant("custom_bg"));
+    ASSERT_EQ(readFromIni("personal.ini", "tipOfDay/showTips"), QVariant(false));
+
+    ASSERT_TRUE(fileExists("cards.ini"));
+    ASSERT_EQ(readFromIni("cards.ini", "cards/displaycardnames"), QVariant(false));
+    ASSERT_EQ(readFromIni("cards.ini", "cards/tapanimation"), QVariant(true));
+
+    ASSERT_TRUE(fileExists("interface.ini"));
+    ASSERT_EQ(readFromIni("interface.ini", "interface/usetearoffmenus"), QVariant(true));
+    ASSERT_EQ(readFromIni("interface.ini", "interface/notificationsenabled"), QVariant(false));
+    ASSERT_EQ(readFromIni("interface.ini", "interface/startinghandsize"), QVariant(5));
+    ASSERT_EQ(readFromIni("interface.ini", "hand/horizontal"), QVariant(true));
+    ASSERT_EQ(readFromIni("interface.ini", "table/invert_vertical"), QVariant(true));
+
+    ASSERT_TRUE(fileExists("paths.ini"));
+    ASSERT_EQ(readFromIni("paths.ini", "paths/decks"), QVariant("/custom/decks"));
+    ASSERT_EQ(readFromIni("paths.ini", "paths/pics"), QVariant("/custom/pics"));
+
+    ASSERT_TRUE(fileExists("visual_deck_storage.ini"));
+    ASSERT_EQ(readFromIni("visual_deck_storage.ini", "interface/visualdeckstoragecardsize"), QVariant(150));
+    ASSERT_EQ(readFromIni("visual_deck_storage.ini", "interface/visualdeckstorageshowfolders"), QVariant(false));
+
+    // Verify sentinel was written
+    ASSERT_EQ(readFromIni("global.ini", "migration/perfile_complete"), QVariant(true));
+}
+
+TEST_F(SettingsMigrationTest, SecondCallDoesNothing)
+{
+    {
+        QSettings g(settingsPath + "global.ini", QSettings::IniFormat);
+        g.setValue("tabs/visualDeckStorage", true);
+        g.setValue("sound/enabled", true);
+        g.sync();
+    }
+
+    ASSERT_TRUE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
+    ASSERT_FALSE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
+}
+
+TEST_F(SettingsMigrationTest, SecondCallDoesNotOverwriteUserChanges)
+{
+    {
+        QSettings g(settingsPath + "global.ini", QSettings::IniFormat);
+        g.setValue("tabs/visualDeckStorage", true);
+        g.setValue("sound/enabled", true);
+        g.sync();
+    }
+
+    ASSERT_TRUE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
+
+    // User changes the value after migration
+    {
+        QSettings tabsIni(settingsPath + "tabs.ini", QSettings::IniFormat);
+        tabsIni.setValue("tabs/visualDeckStorage", false);
+        tabsIni.sync();
+    }
+
+    // Second migration should NOT overwrite the user's change
+    ASSERT_FALSE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
+
+    ASSERT_EQ(readFromIni("tabs.ini", "tabs/visualDeckStorage"), QVariant(false));
+}
+
+TEST_F(SettingsMigrationTest, PartialMigrationOnlyMigratesPresentKeys)
+{
+    {
+        QSettings g(settingsPath + "global.ini", QSettings::IniFormat);
+        g.setValue("tabs/visualDeckStorage", true);
+        g.setValue("tabs/server", false);
+        g.sync();
+    }
+
+    ASSERT_TRUE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
+
+    ASSERT_TRUE(fileExists("global.ini.old"));
+    ASSERT_TRUE(fileExists("tabs.ini"));
+    ASSERT_EQ(readFromIni("tabs.ini", "tabs/visualDeckStorage"), QVariant(true));
+    ASSERT_EQ(readFromIni("tabs.ini", "tabs/server"), QVariant(false));
+
+    // Other files should NOT exist since no keys were present for them
+    ASSERT_FALSE(fileExists("sound.ini"));
+    ASSERT_FALSE(fileExists("game.ini"));
+    ASSERT_FALSE(fileExists("chat.ini"));
+}
+
+TEST_F(SettingsMigrationTest, KeyMapTranslationIsCorrect)
+{
+    {
+        QSettings g(settingsPath + "global.ini", QSettings::IniFormat);
+        g.setValue("personal/cardUpdateCheckInterval", 30);
+        g.setValue("personal/updatereleasechannel", 1);
+        g.sync();
+    }
+
+    ASSERT_TRUE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
+
+    ASSERT_TRUE(fileExists("global.ini.old"));
+    ASSERT_TRUE(fileExists("updates.ini"));
+    // The key should be translated from "personal/cardUpdateCheckInterval" to "updates/cardUpdateCheckInterval"
+    ASSERT_EQ(readFromIni("updates.ini", "updates/cardUpdateCheckInterval"), QVariant(30));
+    ASSERT_EQ(readFromIni("updates.ini", "updates/updatereleasechannel"), QVariant(1));
+}
+
+TEST_F(SettingsMigrationTest, CardsKeysKeepGroupPrefix)
+{
+    {
+        QSettings g(settingsPath + "global.ini", QSettings::IniFormat);
+        g.setValue("cards/displaycardnames", false);
+        g.setValue("interface/deckeditorbannercardcomboboxvisible", true);
+        g.sync();
+    }
+
+    ASSERT_TRUE(SettingsMigration::migrateSettingsFromGlobalIni(settingsPath));
+
+    ASSERT_TRUE(fileExists("global.ini.old"));
+    ASSERT_TRUE(fileExists("cards.ini"));
+    // "cards/displaycardnames" should be stored with its group prefix
+    ASSERT_EQ(readFromIni("cards.ini", "cards/displaycardnames"), QVariant(false));
+    // "interface/..." keys should keep their full path
+    ASSERT_EQ(readFromIni("cards.ini", "interface/deckeditorbannercardcomboboxvisible"), QVariant(true));
+}
+
+} // namespace
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}