diff --git a/src/app/CMakeLists.txt b/src/app/CMakeLists.txt
index d111d37..334aaae 100644
--- a/src/app/CMakeLists.txt
+++ b/src/app/CMakeLists.txt
@@ -93,3 +93,31 @@ if (LT_WINDOWS)
 endif()
 
 set_code_analysis(lt_module_app ${LT_ENABLE_CODE_ANALYSIS})
+
+if (LT_ENABLE_TEST AND BUILD_TESTING)
+    add_executable(test_friendly_error_code
+        ${CMAKE_CURRENT_SOURCE_DIR}/views/friendly_error_code_tests.cpp
+    )
+    target_link_libraries(test_friendly_error_code
+        GTest::gtest
+        GTest::gtest_main
+        lt_module_app
+        ltproto
+        protobuf::libprotobuf-lite
+        Qt6::Widgets
+        Qt6::Gui
+    )
+    add_test(NAME test_friendly_error_code COMMAND test_friendly_error_code)
+
+    add_executable(test_access_token_validator
+        ${CMAKE_CURRENT_SOURCE_DIR}/views/components/access_token_validator_tests.cpp
+    )
+    target_link_libraries(test_access_token_validator
+        GTest::gtest
+        GTest::gtest_main
+        lt_module_app
+        Qt6::Widgets
+        Qt6::Gui
+    )
+    add_test(NAME test_access_token_validator COMMAND test_access_token_validator)
+endif()
diff --git a/src/app/views/components/access_token_validator_tests.cpp b/src/app/views/components/access_token_validator_tests.cpp
new file mode 100644
index 0000000..8db61b3
--- /dev/null
+++ b/src/app/views/components/access_token_validator_tests.cpp
@@ -0,0 +1,50 @@
+#include <gtest/gtest.h>
+
+#include <app/views/components/access_token_validator.h>
+
+namespace {
+
+TEST(AccessTokenValidatorTest, ValidateTrimsTruncatesAndLowercases) {
+    AccesstokenValidator validator(nullptr);
+    QString input = QStringLiteral("  AbC1239  ");
+    int pos = 10;
+
+    const auto state = validator.validate(input, pos);
+
+    EXPECT_EQ(state, QValidator::State::Acceptable);
+    EXPECT_EQ(input, QStringLiteral("abc123"));
+    EXPECT_EQ(pos, 6);
+}
+
+TEST(AccessTokenValidatorTest, ValidateReturnsInvalidForIllegalCharacter) {
+    AccesstokenValidator validator(nullptr);
+    QString input = QStringLiteral("ab-12");
+    int pos = 0;
+
+    const auto state = validator.validate(input, pos);
+
+    EXPECT_EQ(state, QValidator::State::Invalid);
+    EXPECT_EQ(input, QStringLiteral("ab-12"));
+}
+
+TEST(AccessTokenValidatorTest, ValidateAllowsEmptyInputAfterTrim) {
+    AccesstokenValidator validator(nullptr);
+    QString input = QStringLiteral("   ");
+    int pos = 3;
+
+    const auto state = validator.validate(input, pos);
+
+    EXPECT_EQ(state, QValidator::State::Acceptable);
+    EXPECT_TRUE(input.isEmpty());
+}
+
+TEST(AccessTokenValidatorTest, FixupUppercasesInput) {
+    AccesstokenValidator validator(nullptr);
+    QString input = QStringLiteral("ab12cd");
+
+    validator.fixup(input);
+
+    EXPECT_EQ(input, QStringLiteral("AB12CD"));
+}
+
+} // namespace
diff --git a/src/app/views/friendly_error_code_tests.cpp b/src/app/views/friendly_error_code_tests.cpp
new file mode 100644
index 0000000..c794005
--- /dev/null
+++ b/src/app/views/friendly_error_code_tests.cpp
@@ -0,0 +1,35 @@
+#include <gtest/gtest.h>
+
+#include <app/views/friendly_error_code.h>
+
+#include <ltproto/error_code.pb.h>
+
+namespace {
+
+QString friendlySuffix(const QString& message) {
+    constexpr auto kSeparator = "\n    ";
+    const int idx = message.indexOf(kSeparator);
+    if (idx < 0) {
+        return message;
+    }
+
+    return message.mid(idx + 5);
+}
+
+TEST(FriendlyErrorCodeTest, KnownErrorCodeHasSpecificFriendlySuffix) {
+    const auto message = errorCode2FriendlyMessage(ltproto::ErrorCode::InvalidParameter);
+
+    EXPECT_TRUE(message.startsWith(QString("Error code: %1").arg(ltproto::ErrorCode::InvalidParameter)));
+    EXPECT_EQ(friendlySuffix(message), QStringLiteral("Invalid parameters"));
+}
+
+TEST(FriendlyErrorCodeTest, UnknownCodeFallsBackToUnknownMessage) {
+    constexpr int32_t kUnknownCode = 123456789;
+    const auto unknown_baseline = errorCode2FriendlyMessage(ltproto::ErrorCode::Unknown);
+    const auto message = errorCode2FriendlyMessage(kUnknownCode);
+
+    EXPECT_TRUE(message.startsWith(QString("Error code: %1").arg(kUnknownCode)));
+    EXPECT_EQ(friendlySuffix(message), friendlySuffix(unknown_baseline));
+}
+
+} // namespace
diff --git a/src/audio/CMakeLists.txt b/src/audio/CMakeLists.txt
index ec689bb..62d634d 100644
--- a/src/audio/CMakeLists.txt
+++ b/src/audio/CMakeLists.txt
@@ -40,3 +40,18 @@ target_link_libraries(lt_module_audio
 )
 
 set_code_analysis(lt_module_audio ${LT_ENABLE_CODE_ANALYSIS})
+
+if (LT_ENABLE_TEST AND BUILD_TESTING)
+    add_executable(test_fake_audio_capturer
+        ${CMAKE_CURRENT_SOURCE_DIR}/capturer/fake_audio_capturer_tests.cpp
+    )
+    target_link_libraries(test_fake_audio_capturer
+        GTest::gtest
+        GTest::gtest_main
+        protobuf::libprotobuf-lite
+        transport_api
+        lt_module_ltlib
+        lt_module_audio
+    )
+    add_test(NAME test_fake_audio_capturer COMMAND test_fake_audio_capturer)
+endif()
diff --git a/src/audio/capturer/fake_audio_capturer_tests.cpp b/src/audio/capturer/fake_audio_capturer_tests.cpp
new file mode 100644
index 0000000..4390972
--- /dev/null
+++ b/src/audio/capturer/fake_audio_capturer_tests.cpp
@@ -0,0 +1,31 @@
+#include <gtest/gtest.h>
+
+#include <audio/capturer/fake_audio_capturer.h>
+
+TEST(FakeAudioCapturerTest, DefaultParametersAreInitialized) {
+    lt::audio::Capturer::Params params;
+    params.type = lt::AudioCodecType::PCM;
+    params.on_audio_data = [](const std::shared_ptr<google::protobuf::MessageLite>&) {};
+
+    lt::audio::FakeAudioCapturer capturer{params};
+
+    EXPECT_EQ(capturer.bytesPerFrame(), 8U);
+    EXPECT_EQ(capturer.framesPerSec(), 48000U);
+    EXPECT_EQ(capturer.channels(), 2U);
+    EXPECT_EQ(capturer.framesPer10ms(), 480U);
+    EXPECT_EQ(capturer.bytesPer10ms(), 3840U);
+}
+
+TEST(FakeAudioCapturerTest, InitPlatformSucceedsAndCaptureLoopIsNoop) {
+    lt::audio::Capturer::Params params;
+    params.type = lt::AudioCodecType::PCM;
+    params.on_audio_data = [](const std::shared_ptr<google::protobuf::MessageLite>&) {};
+
+    lt::audio::FakeAudioCapturer capturer{params};
+
+    EXPECT_TRUE(capturer.initPlatform());
+
+    int alive_call_count = 0;
+    capturer.captureLoop([&alive_call_count]() { ++alive_call_count; });
+    EXPECT_EQ(alive_call_count, 0);
+}
diff --git a/src/inputs/CMakeLists.txt b/src/inputs/CMakeLists.txt
index 34a885d..5ea2c97 100644
--- a/src/inputs/CMakeLists.txt
+++ b/src/inputs/CMakeLists.txt
@@ -47,3 +47,15 @@ if (LT_WINDOWS)
 endif()
 
 set_code_analysis(lt_module_inputs ${LT_ENABLE_CODE_ANALYSIS})
+
+if (LT_ENABLE_TEST AND BUILD_TESTING)
+    add_executable(test_input_event
+        ${CMAKE_CURRENT_SOURCE_DIR}/capturer/input_event_tests.cpp
+    )
+    target_link_libraries(test_input_event
+        GTest::gtest
+        GTest::gtest_main
+        lt_module_inputs
+    )
+    add_test(NAME test_input_event COMMAND test_input_event)
+endif()
diff --git a/src/inputs/capturer/input_event_tests.cpp b/src/inputs/capturer/input_event_tests.cpp
new file mode 100644
index 0000000..2fd0cb3
--- /dev/null
+++ b/src/inputs/capturer/input_event_tests.cpp
@@ -0,0 +1,99 @@
+#include <gtest/gtest.h>
+
+#include <inputs/capturer/input_event.h>
+
+TEST(InputEventTest, KeyboardEventTypeAndPayload) {
+    const lt::input::KeyboardEvent source{42, true};
+    const lt::input::InputEvent event{source};
+
+    EXPECT_EQ(event.type, lt::input::InputEventType::Keyboard);
+    ASSERT_TRUE(std::holds_alternative<lt::input::KeyboardEvent>(event.ev));
+
+    const auto& payload = std::get<lt::input::KeyboardEvent>(event.ev);
+    EXPECT_EQ(payload.scan_code, 42);
+    EXPECT_TRUE(payload.is_pressed);
+}
+
+TEST(InputEventTest, MouseButtonEventTypeAndPayload) {
+    const lt::input::MouseButtonEvent source{lt::input::MouseButtonEvent::Button::Right, false, 11,
+                                             22, 1280, 720};
+    const lt::input::InputEvent event{source};
+
+    EXPECT_EQ(event.type, lt::input::InputEventType::MouseButton);
+    ASSERT_TRUE(std::holds_alternative<lt::input::MouseButtonEvent>(event.ev));
+
+    const auto& payload = std::get<lt::input::MouseButtonEvent>(event.ev);
+    EXPECT_EQ(payload.button, lt::input::MouseButtonEvent::Button::Right);
+    EXPECT_FALSE(payload.is_pressed);
+    EXPECT_EQ(payload.x, 11);
+    EXPECT_EQ(payload.y, 22);
+    EXPECT_EQ(payload.window_width, 1280U);
+    EXPECT_EQ(payload.window_height, 720U);
+}
+
+TEST(InputEventTest, MouseMoveEventTypeAndPayload) {
+    const lt::input::MouseMoveEvent source{100, 80, -2, 3, 1920, 1080};
+    const lt::input::InputEvent event{source};
+
+    EXPECT_EQ(event.type, lt::input::InputEventType::MouseMove);
+    ASSERT_TRUE(std::holds_alternative<lt::input::MouseMoveEvent>(event.ev));
+
+    const auto& payload = std::get<lt::input::MouseMoveEvent>(event.ev);
+    EXPECT_EQ(payload.x, 100);
+    EXPECT_EQ(payload.y, 80);
+    EXPECT_EQ(payload.delta_x, -2);
+    EXPECT_EQ(payload.delta_y, 3);
+    EXPECT_EQ(payload.window_width, 1920U);
+    EXPECT_EQ(payload.window_height, 1080U);
+}
+
+TEST(InputEventTest, MouseWheelEventTypeAndPayload) {
+    const lt::input::MouseWheelEvent source{-120};
+    const lt::input::InputEvent event{source};
+
+    EXPECT_EQ(event.type, lt::input::InputEventType::MouseWheel);
+    ASSERT_TRUE(std::holds_alternative<lt::input::MouseWheelEvent>(event.ev));
+
+    const auto& payload = std::get<lt::input::MouseWheelEvent>(event.ev);
+    EXPECT_EQ(payload.amount, -120);
+}
+
+TEST(InputEventTest, ControllerAddedRemovedEventTypeAndPayload) {
+    const lt::input::ControllerAddedRemovedEvent source{7, true};
+    const lt::input::InputEvent event{source};
+
+    EXPECT_EQ(event.type, lt::input::InputEventType::ControllerAddedRemoved);
+    ASSERT_TRUE(std::holds_alternative<lt::input::ControllerAddedRemovedEvent>(event.ev));
+
+    const auto& payload = std::get<lt::input::ControllerAddedRemovedEvent>(event.ev);
+    EXPECT_EQ(payload.index, 7U);
+    EXPECT_TRUE(payload.is_added);
+}
+
+TEST(InputEventTest, ControllerButtonEventTypeAndPayload) {
+    const lt::input::ControllerButtonEvent source{1, lt::input::ControllerButtonEvent::Button::A,
+                                                   false};
+    const lt::input::InputEvent event{source};
+
+    EXPECT_EQ(event.type, lt::input::InputEventType::ControllerButton);
+    ASSERT_TRUE(std::holds_alternative<lt::input::ControllerButtonEvent>(event.ev));
+
+    const auto& payload = std::get<lt::input::ControllerButtonEvent>(event.ev);
+    EXPECT_EQ(payload.index, 1U);
+    EXPECT_EQ(payload.button, lt::input::ControllerButtonEvent::Button::A);
+    EXPECT_FALSE(payload.is_pressed);
+}
+
+TEST(InputEventTest, ControllerAxisEventTypeAndPayload) {
+    const lt::input::ControllerAxisEvent source{2, lt::input::ControllerAxisEvent::AxisType::RightThumbY,
+                                                -16384};
+    const lt::input::InputEvent event{source};
+
+    EXPECT_EQ(event.type, lt::input::InputEventType::ControllerAxis);
+    ASSERT_TRUE(std::holds_alternative<lt::input::ControllerAxisEvent>(event.ev));
+
+    const auto& payload = std::get<lt::input::ControllerAxisEvent>(event.ev);
+    EXPECT_EQ(payload.index, 2U);
+    EXPECT_EQ(payload.axis_type, lt::input::ControllerAxisEvent::AxisType::RightThumbY);
+    EXPECT_EQ(payload.value, -16384);
+}
diff --git a/src/ltlib/CMakeLists.txt b/src/ltlib/CMakeLists.txt
index 08ec284..3242c9b 100644
--- a/src/ltlib/CMakeLists.txt
+++ b/src/ltlib/CMakeLists.txt
@@ -123,6 +123,39 @@ if (LT_ENABLE_TEST AND BUILD_TESTING)
         set(LT_MODULE_LTLIB_TEST_PLAT_LIBS)
     endif()
 
+    add_executable(test_reconnect_interval
+        ${CMAKE_CURRENT_SOURCE_DIR}/reconnect_interval_tests.cpp
+    )
+    target_link_libraries(test_reconnect_interval
+        GTest::gtest
+        GTest::gtest_main
+        lt_module_ltlib
+        ${LT_MODULE_LTLIB_TEST_PLAT_LIBS}
+    )
+    add_test(NAME test_reconnect_interval COMMAND test_reconnect_interval)
+
+    add_executable(test_transform
+        ${CMAKE_CURRENT_SOURCE_DIR}/transform_tests.cpp
+    )
+    target_link_libraries(test_transform
+        GTest::gtest
+        GTest::gtest_main
+        lt_module_ltlib
+        ${LT_MODULE_LTLIB_TEST_PLAT_LIBS}
+    )
+    add_test(NAME test_transform COMMAND test_transform)
+
+    add_executable(test_strings
+        ${CMAKE_CURRENT_SOURCE_DIR}/strings_tests.cpp
+    )
+    target_link_libraries(test_strings
+        GTest::gtest
+        GTest::gtest_main
+        lt_module_ltlib
+        ${LT_MODULE_LTLIB_TEST_PLAT_LIBS}
+    )
+    add_test(NAME test_strings COMMAND test_strings)
+
     add_executable(test_settings
         ${CMAKE_CURRENT_SOURCE_DIR}/settings_tests.cpp
     )
diff --git a/src/ltlib/reconnect_interval_tests.cpp b/src/ltlib/reconnect_interval_tests.cpp
new file mode 100644
index 0000000..c9fc5a1
--- /dev/null
+++ b/src/ltlib/reconnect_interval_tests.cpp
@@ -0,0 +1,39 @@
+#include <array>
+
+#include <gtest/gtest.h>
+
+#include <ltlib/reconnect_interval.h>
+
+namespace {
+
+TEST(ReconnectIntervalTest, FirstValueIsInitialBackoff) {
+    ltlib::ReconnectInterval reconnect;
+    EXPECT_EQ(reconnect.next(), 100);
+}
+
+TEST(ReconnectIntervalTest, SequenceSaturatesAtUpperBound) {
+    ltlib::ReconnectInterval reconnect;
+    constexpr std::array<int64_t, 8> kExpected{100, 500, 1000, 2000, 5000, 10000, 30000, 60000};
+
+    for (size_t i = 0; i < kExpected.size(); ++i) {
+        EXPECT_EQ(reconnect.next(), kExpected[i]);
+    }
+
+    for (int i = 0; i < 16; ++i) {
+        EXPECT_EQ(reconnect.next(), 60000);
+    }
+}
+
+TEST(ReconnectIntervalTest, ResetRestartsFromFirstValue) {
+    ltlib::ReconnectInterval reconnect;
+    (void)reconnect.next();
+    (void)reconnect.next();
+    (void)reconnect.next();
+
+    reconnect.reset();
+
+    EXPECT_EQ(reconnect.next(), 100);
+    EXPECT_EQ(reconnect.next(), 500);
+}
+
+} // namespace
\ No newline at end of file
diff --git a/src/ltlib/settings_tests.cpp b/src/ltlib/settings_tests.cpp
index b4b3d2e..79619b9 100644
--- a/src/ltlib/settings_tests.cpp
+++ b/src/ltlib/settings_tests.cpp
@@ -2,6 +2,13 @@
 #include <ltlib/settings.h>
 #include <ltlib/times.h>
 
+#include <algorithm>
+#include <cstdio>
+#include <fstream>
+#include <string>
+#include <thread>
+#include <vector>
+
 static const char* DBName = "SettingsSqlite.db";
 
 class SettingsSqliteTest : public testing::Test {
@@ -68,4 +75,91 @@ TEST_F(SettingsSqliteTest, UpdateTime) {
     auto updated_at = settings_->getUpdateTime("int_key");
     ASSERT_TRUE(updated_at.has_value());
     EXPECT_TRUE(updated_at.value() >= now - 1 && updated_at.value() <= now + 1);
+}
+
+TEST_F(SettingsSqliteTest, KeysStartWithAndDeleteKey) {
+    settings_->setInteger("pref.alpha", 1);
+    settings_->setInteger("pref.beta", 2);
+    settings_->setInteger("other.gamma", 3);
+
+    auto keys = settings_->getKeysStartWith("pref.");
+    std::sort(keys.begin(), keys.end());
+    ASSERT_EQ(keys.size(), 2U);
+    EXPECT_EQ(keys[0], "pref.alpha");
+    EXPECT_EQ(keys[1], "pref.beta");
+
+    settings_->deleteKey("pref.alpha");
+    EXPECT_EQ(settings_->getInteger("pref.alpha"), std::nullopt);
+    EXPECT_EQ(settings_->getInteger("pref.beta"), 2);
+}
+
+TEST_F(SettingsSqliteTest, EmptyKeyIsIgnored) {
+    settings_->setInteger("", 123);
+    settings_->setBoolean("", true);
+    settings_->setString("", "value");
+
+    EXPECT_EQ(settings_->getInteger(""), std::nullopt);
+    EXPECT_EQ(settings_->getBoolean(""), std::nullopt);
+    EXPECT_EQ(settings_->getString(""), std::nullopt);
+    EXPECT_TRUE(settings_->getKeysStartWith("").empty());
+}
+
+TEST_F(SettingsSqliteTest, MismatchedValueTypeReturnsNullopt) {
+    settings_->setString("mixed", "text");
+    settings_->setInteger("int_only", 42);
+
+    EXPECT_EQ(settings_->getInteger("mixed"), std::nullopt);
+    EXPECT_EQ(settings_->getBoolean("int_only"), std::nullopt);
+}
+
+TEST_F(SettingsSqliteTest, ConcurrentWritesRemainReadable) {
+    constexpr int kThreadCount = 8;
+    constexpr int kLoopCount = 100;
+
+    std::vector<std::thread> workers;
+    workers.reserve(kThreadCount);
+
+    for (int tid = 0; tid < kThreadCount; ++tid) {
+        workers.emplace_back([this, tid]() {
+            const std::string key = "concurrent." + std::to_string(tid);
+            for (int i = 0; i < kLoopCount; ++i) {
+                settings_->setInteger(key, tid * 1000 + i);
+            }
+        });
+    }
+
+    for (auto& worker : workers) {
+        worker.join();
+    }
+
+    for (int tid = 0; tid < kThreadCount; ++tid) {
+        const std::string key = "concurrent." + std::to_string(tid);
+        const auto value = settings_->getInteger(key);
+        ASSERT_TRUE(value.has_value());
+        EXPECT_EQ(value.value(), tid * 1000 + (kLoopCount - 1));
+    }
+}
+
+TEST(SettingsSqliteStandaloneTest, CorruptedFileNeedsRecreateToRecover) {
+    static const char* kCorruptedDbName = "SettingsSqliteCorrupted.db";
+
+    {
+        std::ofstream out(kCorruptedDbName, std::ios::binary | std::ios::trunc);
+        ASSERT_TRUE(out.is_open());
+        out << "not a sqlite database";
+    }
+
+    auto broken = ltlib::Settings::createWithPathForTest(ltlib::Settings::Storage::Sqlite,
+                                                         kCorruptedDbName);
+    EXPECT_EQ(broken, nullptr);
+
+    std::remove(kCorruptedDbName);
+
+    auto recovered = ltlib::Settings::createWithPathForTest(ltlib::Settings::Storage::Sqlite,
+                                                            kCorruptedDbName);
+    ASSERT_NE(recovered, nullptr);
+    recovered->setString("ok", "1");
+    EXPECT_EQ(recovered->getString("ok"), "1");
+
+    std::remove(kCorruptedDbName);
 }
\ No newline at end of file
diff --git a/src/ltlib/strings_tests.cpp b/src/ltlib/strings_tests.cpp
new file mode 100644
index 0000000..e6fa910
--- /dev/null
+++ b/src/ltlib/strings_tests.cpp
@@ -0,0 +1,57 @@
+#include <array>
+#include <string>
+
+#include <gtest/gtest.h>
+
+#include <ltlib/strings.h>
+
+namespace {
+
+TEST(StringsTest, Utf8AndUtf16RoundTripAsciiCjkAndEmoji) {
+    const std::array<std::string, 4> cases{
+        "",
+        "hello, world",
+        "\xE4\xBD\xA0\xE5\xA5\xBD",
+        "\xF0\x9F\x99\x82",
+    };
+
+    for (const auto& utf8 : cases) {
+        const std::wstring utf16 = ltlib::utf8To16(utf8);
+        EXPECT_EQ(ltlib::utf16To8(utf16), utf8);
+    }
+}
+
+TEST(StringsTest, Utf16AndUtf8RoundTripAsciiCjkAndEmoji) {
+    const std::array<std::wstring, 4> cases{
+        L"",
+        L"hello",
+        std::wstring{0x4F60, 0x597D},
+        std::wstring{0xD83D, 0xDE42},
+    };
+
+    for (const auto& utf16 : cases) {
+        const std::string utf8 = ltlib::utf16To8(utf16);
+        EXPECT_EQ(ltlib::utf8To16(utf8), utf16);
+    }
+}
+
+TEST(StringsTest, Base64EncodeDecodeRoundTrip) {
+    const std::string raw{"abc\0xyz", 7};
+
+    const std::string encoded = ltlib::base64Encode(raw);
+    EXPECT_EQ(encoded, "YWJjAHh5eg==");
+    EXPECT_EQ(ltlib::base64Decode(encoded), raw);
+}
+
+TEST(StringsTest, Base64DecodeStopsAtInvalidCharacter) {
+    const std::string withInvalid = "aGVs#bG8=";
+
+    EXPECT_EQ(ltlib::base64Decode(withInvalid), ltlib::base64Decode("aGVs"));
+}
+
+TEST(StringsTest, Base64HandlesEmptyInput) {
+    EXPECT_TRUE(ltlib::base64Encode("").empty());
+    EXPECT_TRUE(ltlib::base64Decode("").empty());
+}
+
+} // namespace
\ No newline at end of file
diff --git a/src/ltlib/transform_tests.cpp b/src/ltlib/transform_tests.cpp
new file mode 100644
index 0000000..5c9a11c
--- /dev/null
+++ b/src/ltlib/transform_tests.cpp
@@ -0,0 +1,59 @@
+#include <gtest/gtest.h>
+
+#include <ltlib/transform.h>
+
+namespace {
+
+void expectRectEq(const ltlib::Rect& actual, const ltlib::Rect& expected) {
+    EXPECT_EQ(actual.x, expected.x);
+    EXPECT_EQ(actual.y, expected.y);
+    EXPECT_EQ(actual.w, expected.w);
+    EXPECT_EQ(actual.h, expected.h);
+}
+
+TEST(TransformTest, FitFourByThreeIntoSixteenByNineContainer) {
+    const ltlib::Rect outer{0, 0, 1920, 1080};
+    const ltlib::Rect innerOriginal{0, 0, 1024, 768};
+
+    const ltlib::Rect actual = ltlib::calcMaxInnerRect(outer, innerOriginal);
+
+    expectRectEq(actual, ltlib::Rect{240, 0, 1440, 1080});
+}
+
+TEST(TransformTest, FitSixteenByNineIntoFourByThreeContainer) {
+    const ltlib::Rect outer{0, 0, 1024, 768};
+    const ltlib::Rect innerOriginal{0, 0, 1920, 1080};
+
+    const ltlib::Rect actual = ltlib::calcMaxInnerRect(outer, innerOriginal);
+
+    expectRectEq(actual, ltlib::Rect{0, 96, 1024, 576});
+}
+
+TEST(TransformTest, FitLandscapeIntoPortraitContainer) {
+    const ltlib::Rect outer{0, 0, 1080, 1920};
+    const ltlib::Rect innerOriginal{0, 0, 1920, 1080};
+
+    const ltlib::Rect actual = ltlib::calcMaxInnerRect(outer, innerOriginal);
+
+    expectRectEq(actual, ltlib::Rect{0, 656, 1080, 607});
+}
+
+TEST(TransformTest, HandlesZeroOuterWidthBoundary) {
+    const ltlib::Rect outer{0, 0, 0, 1080};
+    const ltlib::Rect innerOriginal{0, 0, 1920, 1080};
+
+    const ltlib::Rect actual = ltlib::calcMaxInnerRect(outer, innerOriginal);
+
+    expectRectEq(actual, ltlib::Rect{0, 540, 0, 0});
+}
+
+TEST(TransformTest, HandlesZeroInnerWidthBoundary) {
+    const ltlib::Rect outer{0, 0, 1920, 1080};
+    const ltlib::Rect innerOriginal{0, 0, 0, 1080};
+
+    const ltlib::Rect actual = ltlib::calcMaxInnerRect(outer, innerOriginal);
+
+    expectRectEq(actual, ltlib::Rect{960, 0, 0, 1080});
+}
+
+} // namespace
\ No newline at end of file