Fix all the TerminalCore unit tests

microsoft · Nov 1, 2023 · 454e36d · 454e36d
1 parent cc6037d
commit 454e36d
Show file tree

Hide file tree

Showing 9 changed files with 79 additions and 72 deletions.
diff --git a/src/cascadia/TerminalCore/Terminal.cpp b/src/cascadia/TerminalCore/Terminal.cpp
@@ -30,6 +30,15 @@ Terminal::Terminal()
     _renderSettings.SetColorAlias(ColorAlias::DefaultBackground, TextColor::DEFAULT_BACKGROUND, RGB(0, 0, 0));
 }
 
+#pragma warning(suppress : 26455) // default constructor is throwing, too much effort to rearrange at this time.
+Terminal::Terminal(TestDummyMarker) :
+    Terminal{}
+{
+#ifndef NDEBUG
+    _suppressLockChecks = true;
+#endif
+}
+
 void Terminal::Create(til::size viewportSize, til::CoordType scrollbackLines, Renderer& renderer)
 {
     _mutableViewport = Viewport::FromDimensions({ 0, 0 }, viewportSize);
@@ -901,7 +910,7 @@ WORD Terminal::_TakeVirtualKeyFromLastKeyEvent(const WORD scanCode) noexcept
 void Terminal::_assertLocked() const noexcept
 {
 #ifndef NDEBUG
-    if (!_readWriteLock.is_locked())
+    if (!_suppressLockChecks && !_readWriteLock.is_locked())
     {
         // __debugbreak() has the benefit over assert() that the debugger jumps right here to this line.
         // That way there's no need to first click any dialogues, etc. The disadvantage of course is that the
@@ -914,7 +923,7 @@ void Terminal::_assertLocked() const noexcept
 void Terminal::_assertUnlocked() const noexcept
 {
 #ifndef NDEBUG
-    if (_readWriteLock.is_locked())
+    if (!_suppressLockChecks && _readWriteLock.is_locked())
     {
         __debugbreak();
     }

diff --git a/src/cascadia/TerminalCore/Terminal.hpp b/src/cascadia/TerminalCore/Terminal.hpp
@@ -60,6 +60,10 @@ class Microsoft::Terminal::Core::Terminal final :
     using RenderSettings = Microsoft::Console::Render::RenderSettings;
 
 public:
+    struct TestDummyMarker
+    {
+    };
+
     static constexpr bool IsInputKey(WORD vkey)
     {
         return vkey != VK_CONTROL &&
@@ -77,6 +81,7 @@ class Microsoft::Terminal::Core::Terminal final :
     }
 
     Terminal();
+    Terminal(TestDummyMarker);
 
     void Create(til::size viewportSize,
                 til::CoordType scrollbackLines,
@@ -307,6 +312,10 @@ class Microsoft::Terminal::Core::Terminal final :
     const TextBuffer::TextAndColor RetrieveSelectedTextFromBuffer(bool trimTrailingWhitespace);
 #pragma endregion
 
+#ifndef NDEBUG
+    bool _suppressLockChecks = false;
+#endif
+
 private:
     std::function<void(std::wstring_view)> _pfnWriteInput;
     std::function<void()> _pfnWarningBell;

diff --git a/src/cascadia/UnitTests_TerminalCore/ConptyRoundtripTests.cpp b/src/cascadia/UnitTests_TerminalCore/ConptyRoundtripTests.cpp
@@ -87,7 +87,7 @@ class TerminalCoreUnitTests::ConptyRoundtripTests final
     TEST_METHOD_SETUP(MethodSetup)
     {
         // STEP 1: Set up the Terminal
-        term = std::make_unique<Terminal>();
+        term = std::make_unique<Terminal>(Terminal::TestDummyMarker{});
         emptyRenderer = std::make_unique<DummyRenderer>(term.get());
         term->Create({ TerminalViewWidth, TerminalViewHeight }, 100, *emptyRenderer);
 

diff --git a/src/cascadia/UnitTests_TerminalCore/InputTest.cpp b/src/cascadia/UnitTests_TerminalCore/InputTest.cpp
@@ -5,62 +5,51 @@
 #include <WexTestClass.h>
 
 #include "../cascadia/TerminalCore/Terminal.hpp"
-#include "../renderer/inc/DummyRenderer.hpp"
-#include "consoletaeftemplates.hpp"
 
 using namespace WEX::Logging;
 using namespace WEX::TestExecution;
 
 using namespace Microsoft::Terminal::Core;
-using namespace Microsoft::Console::Render;
+
+constexpr Microsoft::Console::VirtualTerminal::TerminalInput::OutputType unhandled()
+{
+    return {};
+}
+
+constexpr Microsoft::Console::VirtualTerminal::TerminalInput::OutputType escChar(const wchar_t wch)
+{
+    const wchar_t buffer[2]{ L'\x1b', wch };
+    return { { &buffer[0], 2 } };
+}
 
 namespace TerminalCoreUnitTests
 {
     class InputTest
     {
         TEST_CLASS(InputTest);
-        TEST_CLASS_SETUP(ClassSetup)
-        {
-            DummyRenderer renderer;
-            term.Create({ 100, 100 }, 0, renderer);
-            auto inputFn = std::bind(&InputTest::_VerifyExpectedInput, this, std::placeholders::_1);
-            term.SetWriteInputCallback(inputFn);
-            return true;
-        };
 
         TEST_METHOD(AltShiftKey);
         TEST_METHOD(InvalidKeyEvent);
 
-        void _VerifyExpectedInput(std::wstring_view actualInput)
-        {
-            VERIFY_ARE_EQUAL(expectedinput.size(), actualInput.size());
-            VERIFY_ARE_EQUAL(expectedinput, actualInput);
-        };
-
-        Terminal term{};
-        std::wstring expectedinput{};
+        Terminal term{ Terminal::TestDummyMarker{} };
     };
 
     void InputTest::AltShiftKey()
     {
         // Tests GH:637
 
         // Verify that Alt+a generates a lowercase a on the input
-        expectedinput = L"\x1b"
-                        "a";
-        VERIFY_IS_TRUE(term.SendCharEvent(L'a', 0, ControlKeyStates::LeftAltPressed));
+        VERIFY_ARE_EQUAL(escChar(L'a'), term.SendCharEvent(L'a', 0, ControlKeyStates::LeftAltPressed));
 
         // Verify that Alt+shift+a generates a uppercase a on the input
-        expectedinput = L"\x1b"
-                        "A";
-        VERIFY_IS_TRUE(term.SendCharEvent(L'A', 0, ControlKeyStates::LeftAltPressed | ControlKeyStates::ShiftPressed));
+        VERIFY_ARE_EQUAL(escChar(L'A'), term.SendCharEvent(L'A', 0, ControlKeyStates::LeftAltPressed | ControlKeyStates::ShiftPressed));
     }
 
     void InputTest::InvalidKeyEvent()
     {
         // Certain applications like AutoHotKey and its keyboard remapping feature,
         // send us key events using SendInput() whose values are outside of the valid range.
-        VERIFY_IS_FALSE(term.SendKeyEvent(0, 123, {}, true));
-        VERIFY_IS_FALSE(term.SendKeyEvent(255, 123, {}, true));
+        VERIFY_ARE_EQUAL(unhandled(), term.SendKeyEvent(0, 123, {}, true));
+        VERIFY_ARE_EQUAL(unhandled(), term.SendKeyEvent(255, 123, {}, true));
     }
 }
diff --git a/src/cascadia/UnitTests_TerminalCore/ScreenSizeLimitsTest.cpp b/src/cascadia/UnitTests_TerminalCore/ScreenSizeLimitsTest.cpp
@@ -38,7 +38,7 @@ void ScreenSizeLimitsTest::ScreenWidthAndHeightAreClampedToBounds()
     // Negative values for initial visible row count or column count
     // are clamped to 1. Too-large positive values are clamped to SHRT_MAX.
     auto negativeColumnsSettings = winrt::make<MockTermSettings>(10000, 9999999, -1234);
-    Terminal negativeColumnsTerminal;
+    Terminal negativeColumnsTerminal{ Terminal::TestDummyMarker{} };
     DummyRenderer renderer{ &negativeColumnsTerminal };
     negativeColumnsTerminal.CreateFromSettings(negativeColumnsSettings, renderer);
     auto actualDimensions = negativeColumnsTerminal.GetViewport().Dimensions();
@@ -47,7 +47,7 @@ void ScreenSizeLimitsTest::ScreenWidthAndHeightAreClampedToBounds()
 
     // Zero values are clamped to 1 as well.
     auto zeroRowsSettings = winrt::make<MockTermSettings>(10000, 0, 9999999);
-    Terminal zeroRowsTerminal;
+    Terminal zeroRowsTerminal{ Terminal::TestDummyMarker{} };
     zeroRowsTerminal.CreateFromSettings(zeroRowsSettings, renderer);
     actualDimensions = zeroRowsTerminal.GetViewport().Dimensions();
     VERIFY_ARE_EQUAL(actualDimensions.height, 1, L"Row count clamped to 1");
@@ -64,32 +64,32 @@ void ScreenSizeLimitsTest::ScrollbackHistorySizeIsClampedToBounds()
 
     // Zero history size is acceptable.
     auto noHistorySettings = winrt::make<MockTermSettings>(0, visibleRowCount, 100);
-    Terminal noHistoryTerminal;
+    Terminal noHistoryTerminal{ Terminal::TestDummyMarker{} };
     DummyRenderer renderer{ &noHistoryTerminal };
     noHistoryTerminal.CreateFromSettings(noHistorySettings, renderer);
     VERIFY_ARE_EQUAL(noHistoryTerminal.GetTextBuffer().TotalRowCount(), visibleRowCount, L"History size of 0 is accepted");
 
     // Negative history sizes are clamped to zero.
     auto negativeHistorySizeSettings = winrt::make<MockTermSettings>(-100, visibleRowCount, 100);
-    Terminal negativeHistorySizeTerminal;
+    Terminal negativeHistorySizeTerminal{ Terminal::TestDummyMarker{} };
     negativeHistorySizeTerminal.CreateFromSettings(negativeHistorySizeSettings, renderer);
     VERIFY_ARE_EQUAL(negativeHistorySizeTerminal.GetTextBuffer().TotalRowCount(), visibleRowCount, L"Negative history size is clamped to 0");
 
     // History size + initial visible rows == SHRT_MAX is acceptable.
     auto maxHistorySizeSettings = winrt::make<MockTermSettings>(SHRT_MAX - visibleRowCount, visibleRowCount, 100);
-    Terminal maxHistorySizeTerminal;
+    Terminal maxHistorySizeTerminal{ Terminal::TestDummyMarker{} };
     maxHistorySizeTerminal.CreateFromSettings(maxHistorySizeSettings, renderer);
     VERIFY_ARE_EQUAL(maxHistorySizeTerminal.GetTextBuffer().TotalRowCount(), SHRT_MAX, L"History size == SHRT_MAX - initial row count is accepted");
 
     // History size + initial visible rows == SHRT_MAX + 1 will be clamped slightly.
     auto justTooBigHistorySizeSettings = winrt::make<MockTermSettings>(SHRT_MAX - visibleRowCount + 1, visibleRowCount, 100);
-    Terminal justTooBigHistorySizeTerminal;
+    Terminal justTooBigHistorySizeTerminal{ Terminal::TestDummyMarker{} };
     justTooBigHistorySizeTerminal.CreateFromSettings(justTooBigHistorySizeSettings, renderer);
     VERIFY_ARE_EQUAL(justTooBigHistorySizeTerminal.GetTextBuffer().TotalRowCount(), SHRT_MAX, L"History size == 1 + SHRT_MAX - initial row count is clamped to SHRT_MAX - initial row count");
 
     // Ridiculously large history sizes are also clamped.
     auto farTooBigHistorySizeSettings = winrt::make<MockTermSettings>(99999999, visibleRowCount, 100);
-    Terminal farTooBigHistorySizeTerminal;
+    Terminal farTooBigHistorySizeTerminal{ Terminal::TestDummyMarker{} };
     farTooBigHistorySizeTerminal.CreateFromSettings(farTooBigHistorySizeSettings, renderer);
     VERIFY_ARE_EQUAL(farTooBigHistorySizeTerminal.GetTextBuffer().TotalRowCount(), SHRT_MAX, L"History size that is far too large is clamped to SHRT_MAX - initial row count");
 }
@@ -111,7 +111,7 @@ void ScreenSizeLimitsTest::ResizeIsClampedToBounds()
 
     auto settings = winrt::make<MockTermSettings>(historySize, initialVisibleRowCount, initialVisibleColCount);
     Log::Comment(L"First create a terminal with fewer than SHRT_MAX lines");
-    Terminal terminal;
+    Terminal terminal{ Terminal::TestDummyMarker{} };
     DummyRenderer renderer{ &terminal };
     terminal.CreateFromSettings(settings, renderer);
     VERIFY_ARE_EQUAL(terminal.GetTextBuffer().TotalRowCount(), historySize + initialVisibleRowCount);

diff --git a/src/cascadia/UnitTests_TerminalCore/ScrollTest.cpp b/src/cascadia/UnitTests_TerminalCore/ScrollTest.cpp
@@ -107,7 +107,7 @@ class TerminalCoreUnitTests::ScrollTest final
 
     TEST_METHOD_SETUP(MethodSetup)
     {
-        _term = std::make_unique<::Microsoft::Terminal::Core::Terminal>();
+        _term = std::make_unique<::Microsoft::Terminal::Core::Terminal>(Terminal::TestDummyMarker{});
 
         _scrollBarNotification = std::make_shared<std::optional<ScrollBarNotification>>();
         _term->SetScrollPositionChangedCallback([scrollBarNotification = _scrollBarNotification](const int top, const int height, const int bottom) {