xref: /reactos/modules/rostests/apitests/user32/ScrollBarRedraw.c (revision a9b77d89)

/*
 * PROJECT:     ReactOS API tests
 * LICENSE:     MIT (https://spdx.org/licenses/MIT)
 * PURPOSE:     Tests window redrawing when scrollbars appear or disappear
 * COPYRIGHT:   Copyright 2024 Marek Benc <benc.marek.elektro98@proton.me>
 */

#include "precomp.h"

#define TEST_CLASS_NAME   L"ScrollBarRedraw"
#define TEST_WINDOW_TITLE L"ScrollBarRedraw"

static LRESULT CALLBACK WindowProc(HWND Window, UINT Message, WPARAM wParam, LPARAM lParam);

#define TEST_COLOR_COUNT 16

/* Standard Windows 16-Color VGA Color palette. */
static COLORREF Colors[] =
{
    RGB(0x00, 0x00, 0x00),  /* Black */
    RGB(0x00, 0x00, 0x80),  /* Dark Blue */
    RGB(0x00, 0x80, 0x00),  /* Dark Green */
    RGB(0x00, 0x80, 0x80),  /* Dark Cyan */
    RGB(0x80, 0x00, 0x00),  /* Dark Red */
    RGB(0x80, 0x00, 0x80),  /* Dark Magenta */
    RGB(0x80, 0x80, 0x00),  /* Dark Yellow */
    RGB(0xC0, 0xC0, 0xC0),  /* Light Gray */
    RGB(0x80, 0x80, 0x80),  /* Dark Gray */
    RGB(0x00, 0x00, 0xFF),  /* Blue */
    RGB(0x00, 0xFF, 0x00),  /* Green */
    RGB(0x00, 0xFF, 0xFF),  /* Cyan */
    RGB(0xFF, 0x00, 0x00),  /* Red */
    RGB(0xFF, 0x00, 0xFF),  /* Magenta */
    RGB(0xFF, 0xFF, 0x00),  /* Yellow */
    RGB(0xFF, 0xFF, 0xFF)   /* White */
};
static HBRUSH ColorBrushes[TEST_COLOR_COUNT] = { 0 };

static BOOL HaveHRedraw = FALSE;
static BOOL HaveVRedraw = FALSE;
static BOOL WindowCreatedOk = FALSE;

typedef enum _FSM_STATE
{
    FSM_STATE_START,
    FSM_STATE_VSCR_SHOWN,
    FSM_STATE_VSCR_HIDDEN,
    FSM_STATE_HSCR_SHOWN,
    FSM_STATE_HSCR_HIDDEN,
    FSM_STATE_BSCR_SHOWN,
    FSM_STATE_BSCR_HIDDEN,
    FSM_STATE_WIDTH_SHRUNK,
    FSM_STATE_WIDTH_EXPANDED,
    FSM_STATE_HEIGHT_SHRUNK,
    FSM_STATE_HEIGHT_EXPANDED,
    FSM_STATE_BOTH_SHRUNK,
    FSM_STATE_BOTH_EXPANDED,
    FSM_STATE_END
} FSM_STATE;

#define FSM_STEP_PERIOD_MS 250

static UINT_PTR FsmTimer = 0;
static UINT CurrentColor = 0;
static FSM_STATE FsmState = FSM_STATE_START;

static int ClientWidth = 0;
static int ClientHeight = 0;

static int OrigWidth = 0;
static int OrigHeight = 0;
static int SmallWidth = 0;
static int SmallHeight = 0;

static void ColorsCleanup(void)
{
    UINT Iter;

    for (Iter = 0; Iter < _countof(ColorBrushes); Iter++)
    {
        if (ColorBrushes[Iter] != NULL)
        {
            DeleteObject(ColorBrushes[Iter]);
            ColorBrushes[Iter] = NULL;
        }
    }
}

static BOOL ColorsInit(void)
{
    UINT Iter;

    assert(_countof(Colors) == _countof(ColorBrushes));

    for (Iter = 0; Iter < _countof(ColorBrushes); Iter++)
    {
        ColorBrushes[Iter] = CreateSolidBrush(Colors[Iter]);
        if (ColorBrushes[Iter] == NULL)
        {
            ColorsCleanup();
            return FALSE;
        }
    }

    return TRUE;
}

static void RunTestWindow(PCWSTR ClassName, PCWSTR WindowTitle, UINT ClassStyle)
{
    WNDCLASSW Class = { 0 };
    HWND Window;
    MSG  Message;
    HINSTANCE hInst;

    CurrentColor = 0;
    hInst = GetModuleHandleW(NULL);

    Class.style         = ClassStyle;
    Class.lpfnWndProc   = WindowProc;
    Class.cbClsExtra    = 0;
    Class.cbWndExtra    = 0;
    Class.hInstance     = hInst;
    Class.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
    Class.hCursor       = LoadCursor(NULL, IDC_ARROW);
    Class.hbrBackground = ColorBrushes[CurrentColor];
    Class.lpszMenuName  = NULL;
    Class.lpszClassName = ClassName;

    if (!RegisterClassW(&Class))
    {
        skip("Failed to register window class '%ls', code: %ld\n",
             ClassName, GetLastError());
        return;
    }

    Window = CreateWindowW(ClassName,
                           WindowTitle,
                           WS_OVERLAPPEDWINDOW | WS_VSCROLL | WS_HSCROLL,
                           CW_USEDEFAULT,
                           CW_USEDEFAULT,
                           CW_USEDEFAULT,
                           CW_USEDEFAULT,
                           NULL,
                           NULL,
                           hInst,
                           NULL);
    if (Window == NULL)
    {
        skip("Failed to create window of class '%ls', code: %ld\n",
             ClassName, GetLastError());
        return;
    }

    ShowWindow(Window, SW_SHOWNORMAL);
    UpdateWindow(Window);

    while (GetMessageW(&Message, NULL, 0, 0))
    {
        TranslateMessage(&Message);
        DispatchMessageW(&Message);
    }
}

START_TEST(ScrollBarRedraw)
{
    if (!ColorsInit())
    {
        skip("Failed to initialize colors and solid color brushes\n");
        return;
    }

    trace("Running test without specifying either CS_HREDRAW or CS_HREDRAW\n");
    HaveHRedraw = FALSE;
    HaveVRedraw = FALSE;
    RunTestWindow(TEST_CLASS_NAME   L"NoRedraw",
                  TEST_WINDOW_TITLE L" (No Redraw Flags)",
                  0);

    trace("Running test with CS_HREDRAW\n");
    HaveHRedraw = TRUE;
    HaveVRedraw = FALSE;
    RunTestWindow(TEST_CLASS_NAME   L"HRedraw",
                  TEST_WINDOW_TITLE L" (CS_HREDRAW)",
                  CS_HREDRAW);

    trace("Running test with CS_VREDRAW\n");
    HaveHRedraw = FALSE;
    HaveVRedraw = TRUE;
    RunTestWindow(TEST_CLASS_NAME   L"VRedraw",
                  TEST_WINDOW_TITLE L" (CS_VREDRAW)",
                  CS_VREDRAW);

    trace("Running test with both CS_HREDRAW and CS_VREDRAW\n");
    HaveHRedraw = TRUE;
    HaveVRedraw = TRUE;
    RunTestWindow(TEST_CLASS_NAME   L"HRedrawVRedraw",
                  TEST_WINDOW_TITLE L" (CS_HREDRAW | CS_VREDRAW)",
                  CS_HREDRAW | CS_VREDRAW);

    trace("Test complete\n");
    ColorsCleanup();
}

static void HideVertScrollBar(HWND Window)
{
    SCROLLINFO ScrollInfo;

    ScrollInfo.cbSize = sizeof(ScrollInfo);
    ScrollInfo.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
    ScrollInfo.nPage = ClientHeight;

    ScrollInfo.nMin = 0;
    ScrollInfo.nMax = ClientHeight - 1;
    ScrollInfo.nPos = 0;

    SetScrollInfo(Window, SB_VERT, &ScrollInfo, TRUE);
}

static void ShowVertScrollBar(HWND Window)
{
    SCROLLINFO ScrollInfo;

    ScrollInfo.cbSize = sizeof(ScrollInfo);
    ScrollInfo.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
    ScrollInfo.nPage = ClientHeight;

    ScrollInfo.nMin = 0;
    ScrollInfo.nMax = (3 * ClientHeight) - 1;
    ScrollInfo.nPos = 0;

    SetScrollInfo(Window, SB_VERT, &ScrollInfo, TRUE);
}

static void HideHorzScrollBar(HWND Window)
{
    SCROLLINFO ScrollInfo;

    ScrollInfo.cbSize = sizeof(ScrollInfo);
    ScrollInfo.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
    ScrollInfo.nPage = ClientWidth;

    ScrollInfo.nMin = 0;
    ScrollInfo.nMax = ClientWidth - 1;
    ScrollInfo.nPos = 0;

    SetScrollInfo(Window, SB_HORZ, &ScrollInfo, TRUE);
}

static void ShowHorzScrollBar(HWND Window)
{
    SCROLLINFO ScrollInfo;

    ScrollInfo.cbSize = sizeof(ScrollInfo);
    ScrollInfo.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
    ScrollInfo.nPage = ClientWidth;

    ScrollInfo.nMin = 0;
    ScrollInfo.nMax = (3 * ClientWidth) - 1;
    ScrollInfo.nPos = 0;

    SetScrollInfo(Window, SB_HORZ, &ScrollInfo, TRUE);
}

static int FsmStep(HWND Window)
{
    static COLORREF PrevColor = CLR_INVALID;
    COLORREF Color = CLR_INVALID;
    HDC hdc = NULL;

    if (FsmState != FSM_STATE_END)
    {
        hdc = GetDC(Window);
        if (hdc == NULL)
        {
            skip("Failed to get device context\n");

            FsmState = FSM_STATE_END;
            DestroyWindow(Window);

            return 0;
        }
        Color = GetPixel(hdc, ClientWidth / 4, ClientHeight / 4);

        ReleaseDC(Window, hdc);
        hdc = NULL;

        if (Color == CLR_INVALID)
        {
            skip("Failed to get window color\n");

            FsmState = FSM_STATE_END;
            DestroyWindow(Window);

            return 0;
        }
    }

    trace("FsmState: %d, Color: 0x%.8lX\n", FsmState, Color);

    switch (FsmState)
    {
        case FSM_STATE_START:
            ShowVertScrollBar(Window);
            FsmState = FSM_STATE_VSCR_SHOWN;
            break;

        case FSM_STATE_VSCR_SHOWN:
            if (HaveHRedraw)
            {
                ok(Color != PrevColor,
                   "CS_HREDRAW specified, but appearence of vertical scroll bar"
                   " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }
            else
            {
                ok(Color == PrevColor,
                   "CS_HREDRAW not specified, but appearence of vertical scroll bar"
                   " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }

            HideVertScrollBar(Window);
            FsmState = FSM_STATE_VSCR_HIDDEN;
            break;

        case FSM_STATE_VSCR_HIDDEN:
            if (HaveHRedraw)
            {
                ok(Color != PrevColor,
                   "CS_HREDRAW specified, but disappearence of vertical scroll bar"
                   " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }
            else
            {
                ok(Color == PrevColor,
                   "CS_HREDRAW not specified, but disappearence of vertical scroll bar"
                   " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }

            ShowHorzScrollBar(Window);
            FsmState = FSM_STATE_HSCR_SHOWN;
            break;

        case FSM_STATE_HSCR_SHOWN:
            if (HaveVRedraw)
            {
                ok(Color != PrevColor,
                   "CS_VREDRAW specified, but appearence of horizontal scroll bar"
                   " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }
            else
            {
                ok(Color == PrevColor,
                   "CS_VREDRAW not specified, but appearence of horizontal scroll bar"
                   " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }

            HideHorzScrollBar(Window);
            FsmState = FSM_STATE_HSCR_HIDDEN;
            break;

        case FSM_STATE_HSCR_HIDDEN:
            if (HaveVRedraw)
            {
                ok(Color != PrevColor,
                   "CS_VREDRAW specified, but disappearence of horizontal scroll bar"
                   " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }
            else
            {
                ok(Color == PrevColor,
                   "CS_VREDRAW not specified, but disappearence of horizontal scroll bar"
                   " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }

            ShowVertScrollBar(Window);
            ShowHorzScrollBar(Window);

            FsmState = FSM_STATE_BSCR_SHOWN;
            break;

        case FSM_STATE_BSCR_SHOWN:
            if (HaveHRedraw || HaveVRedraw)
            {
                ok(Color != PrevColor,
                   "CS_HREDRAW or CS_VREDRAW specified, but appearence of both scroll bars"
                   " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }
            else
            {
                ok(Color == PrevColor,
                   "Neither CS_HREDRAW nor CS_VREDRAW specified, but appearence"
                   " of both scroll bars triggered unneccessary redraw,"
                   " PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }

            HideVertScrollBar(Window);
            HideHorzScrollBar(Window);

            FsmState = FSM_STATE_BSCR_HIDDEN;
            break;

        case FSM_STATE_BSCR_HIDDEN:
            if (HaveHRedraw || HaveVRedraw)
            {
                ok(Color != PrevColor,
                   "CS_HREDRAW or CS_VREDRAW specified, but disappearence of both scroll bars"
                   " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }
            else
            {
                ok(Color == PrevColor,
                   "Neither CS_HREDRAW nor CS_VREDRAW specified, but disappearence"
                   " of both scroll bars triggered unneccessary redraw,"
                   " PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }

            SetWindowPos(Window, HWND_TOPMOST, 0, 0, SmallWidth, OrigHeight, SWP_NOMOVE);
            FsmState = FSM_STATE_WIDTH_SHRUNK;
            break;

        case FSM_STATE_WIDTH_SHRUNK:
            if (HaveHRedraw)
            {
                ok(Color != PrevColor,
                   "CS_HREDRAW specified, but horizontal window shrinkage"
                   " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }
            else
            {
                ok(Color == PrevColor,
                   "CS_HREDRAW not specified, but horizontal window shrinkage"
                   " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }

            SetWindowPos(Window, HWND_TOPMOST, 0, 0, OrigWidth, OrigHeight, SWP_NOMOVE);
            FsmState = FSM_STATE_WIDTH_EXPANDED;
            break;

        case FSM_STATE_WIDTH_EXPANDED:
            if (HaveHRedraw)
            {
                ok(Color != PrevColor,
                   "CS_HREDRAW specified, but horizontal window expansion"
                   " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }
            else
            {
                ok(Color == PrevColor,
                   "CS_HREDRAW not specified, but horizontal window expansion"
                   " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }

            SetWindowPos(Window, HWND_TOPMOST, 0, 0, OrigWidth, SmallHeight, SWP_NOMOVE);
            FsmState = FSM_STATE_HEIGHT_SHRUNK;
            break;

        case FSM_STATE_HEIGHT_SHRUNK:
            if (HaveVRedraw)
            {
                ok(Color != PrevColor,
                   "CS_VREDRAW specified, but vertical window shrinkage"
                   " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }
            else
            {
                ok(Color == PrevColor,
                   "CS_VREDRAW not specified, but vertical window shrinkage"
                   " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }

            SetWindowPos(Window, HWND_TOPMOST, 0, 0, OrigWidth, OrigHeight, SWP_NOMOVE);
            FsmState = FSM_STATE_HEIGHT_EXPANDED;
            break;

        case FSM_STATE_HEIGHT_EXPANDED:
            if (HaveVRedraw)
            {
                ok(Color != PrevColor,
                   "CS_VREDRAW specified, but vertical window expansion"
                   " didn't trigger redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }
            else
            {
                ok(Color == PrevColor,
                   "CS_VREDRAW not specified, but vertical window expansion"
                   " triggered unneccessary redraw, PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }

            SetWindowPos(Window, HWND_TOPMOST, 0, 0, SmallWidth, SmallHeight, SWP_NOMOVE);

            FsmState = FSM_STATE_BOTH_SHRUNK;
            break;

        case FSM_STATE_BOTH_SHRUNK:
            if (HaveHRedraw || HaveVRedraw)
            {
                ok(Color != PrevColor,
                   "CS_HREDRAW or CS_VREDRAW specified, but combined"
                   " vertical/horizontal shrinkage didn't trigger redraw,"
                   " PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }
            else
            {
                ok(Color == PrevColor,
                   "Neither CS_HREDRAW nor CS_VREDRAW specified, but combined"
                   " vertical/horizontal shrinkage triggered unneccessary redraw,"
                   " PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }

            SetWindowPos(Window, HWND_TOPMOST, 0, 0, OrigWidth, OrigHeight, SWP_NOMOVE);

            FsmState = FSM_STATE_BOTH_EXPANDED;
            break;

        case FSM_STATE_BOTH_EXPANDED:
            if (HaveHRedraw || HaveVRedraw)
            {
                ok(Color != PrevColor,
                   "CS_HREDRAW or CS_VREDRAW specified, but combined"
                   " vertical/horizontal expansion didn't trigger redraw,"
                   " PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }
            else
            {
                ok(Color == PrevColor,
                   "Neither CS_HREDRAW nor CS_VREDRAW specified, but combined"
                   " vertical/horizontal expansion triggered unneccessary redraw,"
                   " PrevColor: 0x%.8lX, Color: 0x%.8lX\n",
                   PrevColor, Color);
            }

            FsmState = FSM_STATE_END;
            DestroyWindow(Window);
            break;

        case FSM_STATE_END:
            break;
    }

    PrevColor = Color;
    return 0;
}

static int OnPaint(HWND Window)
{
    HRGN Region;
    HDC hdc;
    PAINTSTRUCT ps;

    hdc = BeginPaint(Window, &ps);
    if (hdc == NULL)
    {
        skip("Failed to get device context\n");
        DestroyWindow(Window);
        return 0;
    }

    Region = CreateRectRgn(ps.rcPaint.left,
                           ps.rcPaint.top,
                           ps.rcPaint.right,
                           ps.rcPaint.bottom);
    if (Region == NULL)
    {
        skip("Failed to create drawing region\n");
        EndPaint(Window, &ps);
        DestroyWindow(Window);
        return 0;
    }

    if (!FillRgn(hdc, Region, ColorBrushes[CurrentColor]))
    {
        skip("Failed to paint the window\n");
        DeleteObject(Region);
        EndPaint(Window, &ps);
        DestroyWindow(Window);
        return 0;
    }

    DeleteObject(Region);
    EndPaint(Window, &ps);

    return 0;
}

static LRESULT CALLBACK WindowProc(HWND Window, UINT Message, WPARAM wParam, LPARAM lParam)
{
    switch (Message)
    {
        case WM_CREATE:
        {
            RECT Rect;
            WindowCreatedOk = FALSE;

            /* It's important for the test that the entire Window is visible. */
            if (!SetWindowPos(Window, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE))
            {
                skip("Failed to set window as top-most, code: %ld\n", GetLastError());
                return -1;
            }

            if (!GetClientRect(Window, &Rect))
            {
                skip("Failed to retrieve client area dimensions, code: %ld\n", GetLastError());
                return -1;
            }
            ClientWidth = Rect.right;
            ClientHeight = Rect.bottom;

            if (!GetWindowRect(Window, &Rect))
            {
                skip("Failed to retrieve window dimensions, code: %ld\n", GetLastError());
                return -1;
            }
            OrigWidth  = Rect.right - Rect.left;
            OrigHeight = Rect.bottom - Rect.top;

            SmallWidth  = max((OrigWidth  * 3) / 4, 1);
            SmallHeight = max((OrigHeight * 3) / 4, 1);
            OrigWidth   = max(OrigWidth,  SmallWidth  + 1);
            OrigHeight  = max(OrigHeight, SmallHeight + 1);

            trace("OrigWidth: %d, OrigHeight: %d, SmallWidth: %d, SmallHeight: %d\n",
                  OrigWidth, OrigHeight, SmallWidth, SmallHeight);

            HideVertScrollBar(Window);
            HideHorzScrollBar(Window);

            FsmState = FSM_STATE_START;
            FsmTimer = 0;
            WindowCreatedOk = TRUE;
            return 0;
        }

        case WM_PAINT:
            if (FsmTimer == 0 && WindowCreatedOk)
            {
                FsmTimer = SetTimer(Window, 1, FSM_STEP_PERIOD_MS, NULL);
                if (FsmTimer == 0)
                {
                    skip("Failed to initialize FSM timer, code: %ld\n", GetLastError());
                    WindowCreatedOk = FALSE;
                    DestroyWindow(Window);
                    return 0;
                }
            }
            return OnPaint(Window);

        case WM_SIZE:
        {
            int NewWidth = LOWORD(lParam);
            int NewHeight = HIWORD(lParam);

            if (NewWidth != 0 && NewHeight != 0 &&
                (NewWidth != ClientWidth || NewHeight != ClientHeight))
            {
                CurrentColor = (CurrentColor + 1) % TEST_COLOR_COUNT;
                SetClassLongPtrW(Window,
                                 GCLP_HBRBACKGROUND,
                                 (LONG_PTR)ColorBrushes[CurrentColor]);

                trace("New window size: %d x %d, new color: 0x%.8lX\n",
                      NewWidth, NewHeight, Colors[CurrentColor]);

                ClientWidth = NewWidth;
                ClientHeight = NewHeight;
            }
            return 0;
        }

        case WM_ERASEBKGND:
            /* We use WM_PAINT instead, since WM_ERASEBKGND is issued before WM_SIZE. */
            return 1;

        case WM_TIMER:
            if (wParam != 0 && wParam == FsmTimer)
            {
                return FsmStep(Window);
            }
            break;

        case WM_NCDESTROY:
            if (FsmTimer != 0)
            {
                KillTimer(Window, FsmTimer);
                FsmTimer = 0;

                if (FsmState != FSM_STATE_END)
                {
                    skip("Window closed before test concluded, FsmState: %d, FSM_STATE_END: %d.\n",
                         FsmState, FSM_STATE_END);
                }
            }
            else if (WindowCreatedOk)
            {
                skip("Window closed before test began.\n");
            }
            return 0;

        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
    }
    return DefWindowProcW(Window, Message, wParam, lParam);
}