wine-devel February 2021

wine-devel@winehq.org

81 participants
640 discussions

[tools] testbot: Increase the full test suite timeout to 45 minutes.
by Francois Gouget 08 Feb '21

08 Feb '21

30 minutes is really too short to run the 700+ tests nowadays. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- Here are the average 32-bit WineTest run times per host (not counting wineprefix creation and file transfers): cw-gtx560 36.1 mn cw-rx460 30.2 mn debiant 34.5 mn debiant2 43.6 mn fg-debian10 34.5 mn Even though the top 13 tests account for 50% of the current 30 minute timeout I doubt we'll get the TestBot VMs run time significantly down. Most of the 13 are 3D tests and so the suffer from the lack of acceleration or, maybe, of X11 1.7.0 bugs. The 3 exceptions are cmd.exe:batch and mlang:mlang (which almost don't touch the screen but still manage to be slow); and user32:msg. For reference here is a breakdown: Test Time Cumulative % of 30 mn cmd.exe:batch 120.0 s 6.7% user32:monitor 99.8 s 12.2% dxgi:dxgi 78.6 s 16.6% d3d9:device 75.4 s 20.8% mlang:mlang 73.2 s 24.8% ddraw:ddraw7 73.0 s 28.9% ddraw:ddraw4 72.0 s 32.9% d3d11:d3d11 71.2 s 36.8% ddraw:ddraw2 62.2 s 40.3% user32:msg 55.6 s 43.4% d3d9:visual 54.4 s 46.4% ddraw:ddraw1 54.0 s 49.4% d3d8:device 49.8 s 52.2% The top 8 tests that push debiant2 higher than debiant are: Test Additional time dwrite:font +84 s regedit.exe:regedit +58 s dwrite:analyzer +55 s dwrite:layout +49 s reg.exe:reg +29 s dxgi:dxgi +23 s shell32:shlexec +22 s comctl32:status +19 s * The 3 dwrite tests are because debiant2 has more fonts for the Chinese, Japanese and other locales. * The regedit and reg tests might be related to that too. * The remainder are a mystery though debiant2 has X11 1.7.0 instead of X11 1.6.7 so that may be a factor for some tests. If you want to dig, you can get all the data at the URL below: http://fgouget.free.fr/tmp/winetest-times-20210205.xls testbot/lib/WineTestBot/Config.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testbot/lib/WineTestBot/Config.pm b/testbot/lib/WineTestBot/Config.pm index 2f01e951b..312797229 100644 --- a/testbot/lib/WineTestBot/Config.pm +++ b/testbot/lib/WineTestBot/Config.pm @@ -130,7 +130,7 @@ $TimeoutMargin = 2 * 60; # Test timeouts (in seconds) # - For the whole test suite -$SuiteTimeout = 30 * 60; +$SuiteTimeout = 45 * 60; # - For the first two tests $SingleTimeout = 2 * 60; # - For extra tests -- 2.20.1

1 0

[PATCH 1/3] user32/tests: Add more tests for GetKeyState from background thread.
by Rémi Bernon 08 Feb '21

08 Feb '21

It looks like that GetKeyState is supposed to catch key presses when called from a background thread even after its thread message queue and thread input structures have been created. This happens in Bioshock 2 Remaster, and causes the game to stay forever on a "Press space to continue" screen, as the thread checking for space key press calls GetKeyState repeatedly (and PeekMessage), although it's in background. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=26269 Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/user32/tests/input.c | 138 ++++++++++++++++++++++++++++---------- 1 file changed, 104 insertions(+), 34 deletions(-) diff --git a/dlls/user32/tests/input.c b/dlls/user32/tests/input.c index 1249f8cf5a1..18b38968f39 100644 --- a/dlls/user32/tests/input.c +++ b/dlls/user32/tests/input.c @@ -3715,74 +3715,144 @@ static void test_attach_input(void) DestroyWindow(Wnd2); } +struct get_key_state_test_desc +{ + BOOL peek_message; + BOOL peek_message_main; +}; + +struct get_key_state_test_desc get_key_state_tests[] = +{ + /* 0: not peeking in thread, no msg queue: GetKeyState misses key press */ + {FALSE, TRUE}, + /* 1: peeking on thread init, not in main: GetKeyState catches key press */ + { TRUE, FALSE}, + /* 2: peeking on thread init, and in main: GetKeyState catches key press */ + { TRUE, TRUE}, +}; + +struct get_key_state_thread_params +{ + HANDLE semaphores[2]; + int index; +}; + static DWORD WINAPI get_key_state_thread(void *arg) { - HANDLE *semaphores = arg; + struct get_key_state_thread_params *params = arg; + struct get_key_state_test_desc* test; + HANDLE *semaphores = params->semaphores; DWORD result; + BOOL has_queue; + MSG msg; + int i = params->index; + + test = get_key_state_tests + i; + has_queue = test->peek_message; + + if (test->peek_message) + { + while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) + ok(!is_keyboard_message(msg.message), "%d: PeekMessageA got keyboard message.\n", i); + } + /* initialization */ ReleaseSemaphore(semaphores[0], 1, NULL); result = WaitForSingleObject(semaphores[1], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "%d: WaitForSingleObject returned %u\n", i, result); - result = GetKeyState('X'); - ok((result & 0x8000) || broken(!(result & 0x8000)), /* > Win 2003 */ - "expected that highest bit is set, got %x\n", result); + /* key pressed */ + ReleaseSemaphore(semaphores[0], 1, NULL); + result = WaitForSingleObject(semaphores[1], 1000); + ok(result == WAIT_OBJECT_0, "%d: WaitForSingleObject returned %u\n", i, result); - ok((SHORT)(result & 0x007e) == 0, - "expected that undefined bits are unset, got %x\n", result); + result = GetKeyState('X'); + if (!has_queue) todo_wine ok(!(result & 0x8000), "%d: expected that highest bit is unset, got %#x\n", i, result); + else todo_wine ok((result & 0x8000), "%d: expected that highest bit is set, got %#x\n", i, result); + ok(!(result & 0x007e), "%d: expected that undefined bits are unset, got %#x\n", i, result); + /* key released */ ReleaseSemaphore(semaphores[0], 1, NULL); result = WaitForSingleObject(semaphores[1], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(result == WAIT_OBJECT_0, "%d: WaitForSingleObject returned %u\n", i, result); result = GetKeyState('X'); - ok(!(result & 0x8000), "expected that highest bit is unset, got %x\n", result); - - ok((SHORT)(result & 0x007e) == 0, - "expected that undefined bits are unset, got %x\n", result); + ok(!(result & 0x8000), "%d: expected that highest bit is unset, got %#x\n", i, result); + ok(!(result & 0x007e), "%d: expected that undefined bits are unset, got %#x\n", i, result); return 0; } static void test_GetKeyState(void) { - HANDLE semaphores[2]; + struct get_key_state_thread_params params; HANDLE thread; DWORD result; HWND hwnd; + MSG msg; + int i; - semaphores[0] = CreateSemaphoreA(NULL, 0, 1, NULL); - ok(semaphores[0] != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); - semaphores[1] = CreateSemaphoreA(NULL, 0, 1, NULL); - ok(semaphores[1] != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); + params.semaphores[0] = CreateSemaphoreA(NULL, 0, 1, NULL); + ok(params.semaphores[0] != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); + params.semaphores[1] = CreateSemaphoreA(NULL, 0, 1, NULL); + ok(params.semaphores[1] != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); hwnd = CreateWindowA("static", "Title", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 10, 10, 200, 200, NULL, NULL, NULL, NULL); ok(hwnd != NULL, "CreateWindowA failed %u\n", GetLastError()); + empty_message_queue(); - thread = CreateThread(NULL, 0, get_key_state_thread, semaphores, 0, NULL); - ok(thread != NULL, "CreateThread failed %u\n", GetLastError()); - result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + for (i = 0; i < ARRAY_SIZE(get_key_state_tests); ++i) + { + struct get_key_state_test_desc* test = get_key_state_tests + i; - SetForegroundWindow(hwnd); - SetFocus(hwnd); - keybd_event('X', 0, 0, 0); + params.index = i; + thread = CreateThread(NULL, 0, get_key_state_thread, &params, 0, NULL); + ok(thread != NULL, "CreateThread failed %u\n", GetLastError()); - ReleaseSemaphore(semaphores[1], 1, NULL); - result = WaitForSingleObject(semaphores[0], 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + /* initialization */ + result = WaitForSingleObject(params.semaphores[0], 1000); + ok(result == WAIT_OBJECT_0, "%d: WaitForSingleObject returned %u\n", i, result); - keybd_event('X', 0, KEYEVENTF_KEYUP, 0); + SetForegroundWindow(hwnd); + SetFocus(hwnd); + empty_message_queue(); - ReleaseSemaphore(semaphores[1], 1, NULL); - result = WaitForSingleObject(thread, 1000); - ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); - CloseHandle(thread); + ReleaseSemaphore(params.semaphores[1], 1, NULL); + + /* key pressed */ + result = WaitForSingleObject(params.semaphores[0], 1000); + ok(result == WAIT_OBJECT_0, "%d: WaitForSingleObject returned %u\n", i, result); + + keybd_event('X', 0, 0, 0); + if (test->peek_message_main) while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg); + + result = GetKeyState('X'); + if (test->peek_message_main) ok((result & 0x8000), "%d: expected that highest bit is set, got %#x\n", i, result); + else ok(!(result & 0x8000), "%d: expected that highest bit is unset, got %#x\n", i, result); + + ReleaseSemaphore(params.semaphores[1], 1, NULL); + + /* key released */ + result = WaitForSingleObject(params.semaphores[0], 1000); + ok(result == WAIT_OBJECT_0, "%d: WaitForSingleObject returned %u\n", i, result); + + keybd_event('X', 0, KEYEVENTF_KEYUP, 0); + if (test->peek_message_main) while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg); + + result = GetKeyState('X'); + ok(!(result & 0x8000), "%d: expected that highest bit is unset, got %#x\n", i, result); + + ReleaseSemaphore(params.semaphores[1], 1, NULL); + + result = WaitForSingleObject(thread, 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + CloseHandle(thread); + } DestroyWindow(hwnd); - CloseHandle(semaphores[0]); - CloseHandle(semaphores[1]); + CloseHandle(params.semaphores[0]); + CloseHandle(params.semaphores[1]); } static void test_OemKeyScan(void) -- 2.30.0

2 6

[PATCH 4/4] d3d11/tests: Add input layout alignment tests.
by Henri Verbeet 08 Feb '21

08 Feb '21

From: Jan Sikorski <jsikorski(a)codeweavers.com> Signed-off-by: Jan Sikorski <jsikorski(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- v3: Minor formatting changes. dlls/d3d11/tests/d3d11.c | 93 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index d7a49f4af3ac..a1a215858a2c 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -17879,6 +17879,98 @@ static void test_create_input_layout(void) ok(!refcount, "Device has %u references left.\n", refcount); } +static void test_input_layout_alignment(void) +{ + ID3D11InputLayout *layout; + ID3D11Device *device; + unsigned int i; + ULONG refcount; + HRESULT hr; + + static const DWORD vs_code[] = + { +#if 0 + float4 main(float4 position : POSITION) : SV_POSITION + { + return position; + } +#endif + 0x43425844, 0xa7a2f22d, 0x83ff2560, 0xe61638bd, 0x87e3ce90, 0x00000001, 0x000000d8, 0x00000003, + 0x0000002c, 0x00000060, 0x00000094, 0x4e475349, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, + 0x00000000, 0x00000000, 0x00000003, 0x00000000, 0x00000f0f, 0x49534f50, 0x4e4f4954, 0xababab00, + 0x4e47534f, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000001, 0x00000003, + 0x00000000, 0x0000000f, 0x505f5653, 0x5449534f, 0x004e4f49, 0x52444853, 0x0000003c, 0x00010040, + 0x0000000f, 0x0300005f, 0x001010f2, 0x00000000, 0x04000067, 0x001020f2, 0x00000000, 0x00000001, + 0x05000036, 0x001020f2, 0x00000000, 0x00101e46, 0x00000000, 0x0100003e, + }; + + static const struct + { + D3D11_INPUT_ELEMENT_DESC elements[2]; + HRESULT hr; + } + test_data[] = + { + {{ + {"POSITION", 0, DXGI_FORMAT_R8_UINT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R16_UINT, 0, 2, D3D11_INPUT_PER_VERTEX_DATA, 0}, + }, S_OK}, + {{ + {"POSITION", 0, DXGI_FORMAT_R8_UINT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R16_UINT, 0, 1, D3D11_INPUT_PER_VERTEX_DATA, 0}, + }, E_INVALIDARG}, + {{ + {"POSITION", 0, DXGI_FORMAT_R8_UINT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R8_UINT, 0, 1, D3D11_INPUT_PER_VERTEX_DATA, 0}, + }, S_OK}, + {{ + {"POSITION", 0, DXGI_FORMAT_R16_UINT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32_UINT, 0, 2, D3D11_INPUT_PER_VERTEX_DATA, 0}, + }, E_INVALIDARG}, + {{ + {"POSITION", 0, DXGI_FORMAT_R16_UINT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 2, D3D11_INPUT_PER_VERTEX_DATA, 0}, + }, E_INVALIDARG}, + {{ + {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 16, D3D11_INPUT_PER_VERTEX_DATA, 0}, + }, S_OK}, + {{ + {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 17, D3D11_INPUT_PER_VERTEX_DATA, 0}, + }, E_INVALIDARG}, + {{ + {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 18, D3D11_INPUT_PER_VERTEX_DATA, 0}, + }, E_INVALIDARG}, + {{ + {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 19, D3D11_INPUT_PER_VERTEX_DATA, 0}, + }, E_INVALIDARG}, + {{ + {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 20, D3D11_INPUT_PER_VERTEX_DATA, 0}, + }, S_OK}, + }; + + if (!(device = create_device(NULL))) + { + skip("Failed to create device.\n"); + return; + } + + for (i = 0; i < ARRAY_SIZE(test_data); ++i) + { + hr = ID3D11Device_CreateInputLayout(device, test_data[i].elements, 2, vs_code, sizeof(vs_code), &layout); + ok(hr == test_data[i].hr, "Test %u: Got unexpected hr %#x, expected %#x.\n", i, hr, test_data[i].hr); + if (SUCCEEDED(hr)) + ID3D11InputLayout_Release(layout); + } + + refcount = ID3D11Device_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); +} + static void test_input_assembler(void) { enum layout_id @@ -31759,6 +31851,7 @@ START_TEST(d3d11) queue_test(test_sm4_discard_instruction); queue_test(test_sm5_swapc_instruction); queue_test(test_create_input_layout); + queue_test(test_input_layout_alignment); queue_test(test_input_assembler); queue_test(test_null_sampler); queue_test(test_check_feature_support); -- 2.20.1

2 1

[PATCH 1/2] cmd: Fix handling of nested if-for expressions on a single line.
by Roman Pišl 08 Feb '21

08 Feb '21

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=50641 Signed-off-by: Roman Pišl <rpisl(a)seznam.cz> --- programs/cmd/builtins.c | 10 ++++++++-- programs/cmd/tests/test_builtins.cmd | 4 ++++ programs/cmd/tests/test_builtins.cmd.exp | 2 ++ 3 files changed, 14 insertions(+), 2 deletions(-) diff --git a/programs/cmd/builtins.c b/programs/cmd/builtins.c index e99dd24ac72..0fb40d94e49 100644 --- a/programs/cmd/builtins.c +++ b/programs/cmd/builtins.c @@ -1599,8 +1599,14 @@ static void WCMD_part_execute(CMD_LIST **cmdList, const WCHAR *firstcmd, the same bracket depth as the IF, then the IF statement is over. This is required to handle nested ifs properly */ } else if (isIF && (*cmdList)->bracketDepth == myDepth) { - WINE_TRACE("Found end of this nested IF statement, ending this if\n"); - break; + static const WCHAR doW[] = {'d','o'}; + if (WCMD_keyword_ws_found(doW, ARRAY_SIZE(doW), (*cmdList)->command)) { + WINE_TRACE("Still inside FOR-loop, not an end of IF statement\n"); + *cmdList = (*cmdList)->nextcommand; + } else { + WINE_TRACE("Found end of this nested IF statement, ending this if\n"); + break; + } } else if (!processThese) { if (curPosition == *cmdList) *cmdList = (*cmdList)->nextcommand; WINE_TRACE("Skipping this command, as in not process mode (next = %p)\n", *cmdList); diff --git a/programs/cmd/tests/test_builtins.cmd b/programs/cmd/tests/test_builtins.cmd index c7418b759e4..4019c51ba73 100644 --- a/programs/cmd/tests/test_builtins.cmd +++ b/programs/cmd/tests/test_builtins.cmd @@ -1242,6 +1242,10 @@ goto :eof set WINE_STR_PARMS= set WINE_INT_PARMS= +echo ------------ Testing if/for ------------ +if ""=="" for %%i in (A) DO (echo %%i) +if not ""=="" for %%i in (B) DO (echo %%i) + echo ------------ Testing for ------------ echo --- plain FOR for %%i in (A B C) do echo %%i diff --git a/programs/cmd/tests/test_builtins.cmd.exp b/programs/cmd/tests/test_builtins.cmd.exp index f75839fdbe8..129e5313d90 100644 --- a/programs/cmd/tests/test_builtins.cmd.exp +++ b/programs/cmd/tests/test_builtins.cmd.exp @@ -914,6 +914,8 @@ x@space@ --- x@space@ --- +------------ Testing if/for ------------ +A ------------ Testing for ------------ --- plain FOR A -- 2.20.1

1 1

[PATCH 3/4] d3d10core/tests: Add input layout alignment tests.
by Henri Verbeet 08 Feb '21

08 Feb '21

From: Jan Sikorski <jsikorski(a)codeweavers.com> Signed-off-by: Jan Sikorski <jsikorski(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- v3: Minor formatting changes. dlls/d3d10core/tests/d3d10core.c | 93 ++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) diff --git a/dlls/d3d10core/tests/d3d10core.c b/dlls/d3d10core/tests/d3d10core.c index 4332ce2dcf22..9e116729e829 100644 --- a/dlls/d3d10core/tests/d3d10core.c +++ b/dlls/d3d10core/tests/d3d10core.c @@ -12270,6 +12270,98 @@ static void test_create_input_layout(void) ok(!refcount, "Device has %u references left.\n", refcount); } +static void test_input_layout_alignment(void) +{ + ID3D10InputLayout *layout; + ID3D10Device *device; + unsigned int i; + ULONG refcount; + HRESULT hr; + + static const DWORD vs_code[] = + { +#if 0 + float4 main(float4 position : POSITION) : SV_POSITION + { + return position; + } +#endif + 0x43425844, 0xa7a2f22d, 0x83ff2560, 0xe61638bd, 0x87e3ce90, 0x00000001, 0x000000d8, 0x00000003, + 0x0000002c, 0x00000060, 0x00000094, 0x4e475349, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, + 0x00000000, 0x00000000, 0x00000003, 0x00000000, 0x00000f0f, 0x49534f50, 0x4e4f4954, 0xababab00, + 0x4e47534f, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000001, 0x00000003, + 0x00000000, 0x0000000f, 0x505f5653, 0x5449534f, 0x004e4f49, 0x52444853, 0x0000003c, 0x00010040, + 0x0000000f, 0x0300005f, 0x001010f2, 0x00000000, 0x04000067, 0x001020f2, 0x00000000, 0x00000001, + 0x05000036, 0x001020f2, 0x00000000, 0x00101e46, 0x00000000, 0x0100003e, + }; + + static const struct + { + D3D10_INPUT_ELEMENT_DESC elements[2]; + HRESULT hr; + } + test_data[] = + { + {{ + {"POSITION", 0, DXGI_FORMAT_R8_UINT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R16_UINT, 0, 2, D3D10_INPUT_PER_VERTEX_DATA, 0}, + }, S_OK}, + {{ + {"POSITION", 0, DXGI_FORMAT_R8_UINT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R16_UINT, 0, 1, D3D10_INPUT_PER_VERTEX_DATA, 0}, + }, E_INVALIDARG}, + {{ + {"POSITION", 0, DXGI_FORMAT_R8_UINT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R8_UINT, 0, 1, D3D10_INPUT_PER_VERTEX_DATA, 0}, + }, S_OK}, + {{ + {"POSITION", 0, DXGI_FORMAT_R16_UINT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32_UINT, 0, 2, D3D10_INPUT_PER_VERTEX_DATA, 0}, + }, E_INVALIDARG}, + {{ + {"POSITION", 0, DXGI_FORMAT_R16_UINT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 2, D3D10_INPUT_PER_VERTEX_DATA, 0}, + }, E_INVALIDARG}, + {{ + {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 16, D3D10_INPUT_PER_VERTEX_DATA, 0}, + }, S_OK}, + {{ + {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 17, D3D10_INPUT_PER_VERTEX_DATA, 0}, + }, E_INVALIDARG}, + {{ + {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 18, D3D10_INPUT_PER_VERTEX_DATA, 0}, + }, E_INVALIDARG}, + {{ + {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 19, D3D10_INPUT_PER_VERTEX_DATA, 0}, + }, E_INVALIDARG}, + {{ + {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0}, + {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 20, D3D10_INPUT_PER_VERTEX_DATA, 0}, + }, S_OK}, + }; + + if (!(device = create_device())) + { + skip("Failed to create device.\n"); + return; + } + + for (i = 0; i < ARRAY_SIZE(test_data); ++i) + { + hr = ID3D10Device_CreateInputLayout(device, test_data[i].elements, 2, vs_code, sizeof(vs_code), &layout); + ok(hr == test_data[i].hr, "Test %u: Got unexpected hr %#x, expected %#x.\n", i, hr, test_data[i].hr); + if (SUCCEEDED(hr)) + ID3D10InputLayout_Release(layout); + } + + refcount = ID3D10Device_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); +} + static void test_input_assembler(void) { enum layout_id @@ -18511,6 +18603,7 @@ START_TEST(d3d10core) queue_test(test_sm4_continuec_instruction); queue_test(test_sm4_discard_instruction); queue_test(test_create_input_layout); + queue_test(test_input_layout_alignment); queue_test(test_input_assembler); queue_test(test_null_sampler); queue_test(test_immediate_constant_buffer); -- 2.20.1

1 0

[PATCH 2/4] wined3d: Return E_INVALIDARG from vertexdeclaration_init() on validation failure.
by Henri Verbeet 08 Feb '21

08 Feb '21

From: Jan Sikorski <jsikorski(a)codeweavers.com> Signed-off-by: Jan Sikorski <jsikorski(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- v3: Minor formatting changes. dlls/d3d8/vertexdeclaration.c | 4 ++++ dlls/d3d9/vertexdeclaration.c | 2 ++ dlls/wined3d/vertexdeclaration.c | 6 +++--- 3 files changed, 9 insertions(+), 3 deletions(-) diff --git a/dlls/d3d8/vertexdeclaration.c b/dlls/d3d8/vertexdeclaration.c index 525666d680e9..d0e733b9e376 100644 --- a/dlls/d3d8/vertexdeclaration.c +++ b/dlls/d3d8/vertexdeclaration.c @@ -358,6 +358,8 @@ HRESULT d3d8_vertex_declaration_init(struct d3d8_vertex_declaration *declaration { WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr); heap_free(declaration->elements); + if (hr == E_INVALIDARG) + hr = E_FAIL; return hr; } @@ -379,6 +381,8 @@ HRESULT d3d8_vertex_declaration_init_fvf(struct d3d8_vertex_declaration *declara if (FAILED(hr)) { WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr); + if (hr == E_INVALIDARG) + hr = E_FAIL; return hr; } diff --git a/dlls/d3d9/vertexdeclaration.c b/dlls/d3d9/vertexdeclaration.c index c30a84313fbf..60701a9a9105 100644 --- a/dlls/d3d9/vertexdeclaration.c +++ b/dlls/d3d9/vertexdeclaration.c @@ -406,6 +406,8 @@ static HRESULT vertexdeclaration_init(struct d3d9_vertex_declaration *declaratio { heap_free(declaration->elements); WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr); + if (hr == E_INVALIDARG) + hr = E_FAIL; return hr; } diff --git a/dlls/wined3d/vertexdeclaration.c b/dlls/wined3d/vertexdeclaration.c index e96216db380d..b17059f5e644 100644 --- a/dlls/wined3d/vertexdeclaration.c +++ b/dlls/wined3d/vertexdeclaration.c @@ -226,10 +226,10 @@ static HRESULT vertexdeclaration_init(struct wined3d_vertex_declaration *declara if (!(e->format->flags[WINED3D_GL_RES_TYPE_BUFFER] & WINED3DFMT_FLAG_VERTEX_ATTRIBUTE)) { - FIXME("The application tries to use an unsupported format (%s), returning E_FAIL.\n", + FIXME("The application tries to use an unsupported format (%s).\n", debug_d3dformat(elements[i].format)); heap_free(declaration->elements); - return E_FAIL; + return E_INVALIDARG; } if (e->offset == WINED3D_APPEND_ALIGNED_ELEMENT) @@ -254,7 +254,7 @@ static HRESULT vertexdeclaration_init(struct wined3d_vertex_declaration *declara WARN("Declaration element %u with format %s and offset %u is not %u byte aligned.\n", i, debug_d3dformat(elements[i].format), e->offset, alignment); heap_free(declaration->elements); - return E_FAIL; + return E_INVALIDARG; } } -- 2.20.1

1 0

[PATCH 1/4] wined3d: Align vertex attribute offsets to their size, if smaller than 4.
by Henri Verbeet 08 Feb '21

08 Feb '21

From: Jan Sikorski <jsikorski(a)codeweavers.com> This should not change behaviour for d3d9 and earlier, where all formats have sizes that are multiples of 4. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=43422 Signed-off-by: Jan Sikorski <jsikorski(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- v3: Minor formatting changes. dlls/wined3d/vertexdeclaration.c | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/dlls/wined3d/vertexdeclaration.c b/dlls/wined3d/vertexdeclaration.c index c5df45541e4d..e96216db380d 100644 --- a/dlls/wined3d/vertexdeclaration.c +++ b/dlls/wined3d/vertexdeclaration.c @@ -200,6 +200,7 @@ static HRESULT vertexdeclaration_init(struct wined3d_vertex_declaration *declara for (i = 0; i < element_count; ++i) { struct wined3d_vertex_declaration_element *e = &declaration->elements[i]; + unsigned int alignment; e->format = wined3d_get_format(adapter, elements[i].format, 0); e->ffp_valid = declaration_element_valid_ffp(&elements[i]); @@ -212,6 +213,9 @@ static HRESULT vertexdeclaration_init(struct wined3d_vertex_declaration *declara e->usage = elements[i].usage; e->usage_idx = elements[i].usage_idx; + if ((alignment = e->format->byte_count) > 4) + alignment = 4; + if (e->usage == WINED3D_DECL_USAGE_POSITIONT) declaration->position_transformed = TRUE; @@ -239,15 +243,16 @@ static HRESULT vertexdeclaration_init(struct wined3d_vertex_declaration *declara prev = &declaration->elements[i - j]; if (prev->input_slot == e->input_slot) { - e->offset = (prev->offset + prev->format->byte_count + 3) & ~3; + e->offset = (prev->offset + prev->format->byte_count + alignment - 1) & ~(alignment - 1); break; } } } - if (e->offset & 0x3) + if (e->offset & (alignment - 1)) { - WARN("Declaration element %u is not 4 byte aligned(%u), returning E_FAIL.\n", i, e->offset); + WARN("Declaration element %u with format %s and offset %u is not %u byte aligned.\n", + i, debug_d3dformat(elements[i].format), e->offset, alignment); heap_free(declaration->elements); return E_FAIL; } -- 2.20.1

1 0

[PATCH] user32: Fix a typo in a comment.
by Francois Gouget 08 Feb '21

08 Feb '21

Signed-off-by: Francois Gouget <fgouget(a)free.fr> --- dlls/user32/winproc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/user32/winproc.c b/dlls/user32/winproc.c index 0be51779f69..f83d8b61a63 100644 --- a/dlls/user32/winproc.c +++ b/dlls/user32/winproc.c @@ -172,7 +172,7 @@ static inline WINDOWPROC *alloc_winproc( WNDPROC func, BOOL unicode ) } #ifdef __i386__ -/* Some window procedures modify register they shouldn't, or are not +/* Some window procedures modify registers they shouldn't, or are not * properly declared stdcall; so we need a small assembly wrapper to * call them. */ extern LRESULT WINPROC_wrapper( WNDPROC proc, HWND hwnd, UINT msg, -- 2.20.1

1 0

[PATCH] windowscodecs/tests: Fix a typo in a variable name.
by Francois Gouget 08 Feb '21

08 Feb '21

Signed-off-by: Francois Gouget <fgouget(a)free.fr> --- dlls/windowscodecs/tests/metadata.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/windowscodecs/tests/metadata.c b/dlls/windowscodecs/tests/metadata.c index e6e46c389f9..b597e5490c6 100644 --- a/dlls/windowscodecs/tests/metadata.c +++ b/dlls/windowscodecs/tests/metadata.c @@ -3056,7 +3056,7 @@ static void test_metadata_writer(void) REFCLSID rclsid; BOOL wine_supports_encoder; BOOL metadata_supported; - BOOL succeeds_unitialized; + BOOL succeeds_uninitialized; } tests[] = { @@ -3106,7 +3106,7 @@ static void test_metadata_writer(void) ok(hr == (tests[i].metadata_supported ? S_OK : E_INVALIDARG), "Got unexpected hr %#x, i %u.\n", hr, i); hr = IWICBitmapFrameEncode_GetMetadataQueryWriter(frameencode, &querywriter2); - ok(hr == (tests[i].succeeds_unitialized ? S_OK : WINCODEC_ERR_NOTINITIALIZED), + ok(hr == (tests[i].succeeds_uninitialized ? S_OK : WINCODEC_ERR_NOTINITIALIZED), "Got unexpected hr %#x, i %u.\n", hr, i); if (hr == S_OK) IWICMetadataQueryWriter_Release(querywriter2); -- 2.20.1

1 0

[PATCH 1/2] gdi32/tests: Move out common functions into a separate file named misc.c|h
by Ralf Habacker 08 Feb '21

08 Feb '21

This is used to avoid code duplication for adding an 'advanced' gdi32 test. Signed-off-by: Ralf Habacker <ralf.habacker(a)freenet.de> --- dlls/gdi32/tests/Makefile.in | 1 + dlls/gdi32/tests/dib.c | 338 +--------------------------- dlls/gdi32/tests/misc.c | 425 +++++++++++++++++++++++++++++++++++ dlls/gdi32/tests/misc.h | 31 +++ 4 files changed, 460 insertions(+), 335 deletions(-) create mode 100644 dlls/gdi32/tests/misc.c create mode 100644 dlls/gdi32/tests/misc.h diff --git a/dlls/gdi32/tests/Makefile.in b/dlls/gdi32/tests/Makefile.in index 876f6a376a2..ad8f0ce8bad 100644 --- a/dlls/gdi32/tests/Makefile.in +++ b/dlls/gdi32/tests/Makefile.in @@ -14,6 +14,7 @@ C_SRCS = \ icm.c \ mapping.c \ metafile.c \ + misc.c \ palette.c \ path.c \ pen.c diff --git a/dlls/gdi32/tests/dib.c b/dlls/gdi32/tests/dib.c index bdc3d9ed55b..96ac0b69271 100644 --- a/dlls/gdi32/tests/dib.c +++ b/dlls/gdi32/tests/dib.c @@ -31,7 +31,9 @@ #include "wine/test.h" -static HCRYPTPROV crypt_prov; +#include "misc.h" + +static const char *dst_format; static const DWORD rop3[256] = { @@ -1263,217 +1265,6 @@ static const char *sha1_graphics_1_ddb_inverted[] = NULL }; -static const RECT graphics_bounds[] = -{ - { 0, 0, 0, 0 }, - { 10, 3, 219, 101 }, - { 100, 100, 301, 301 }, - { 0, 0, 201, 201 }, - { 10, 10, 110, 320 }, - { 10, 99, 300, 200 }, - { 99, 12, 201, 200 }, - { 90, 110, 300, 200 }, - { 90, 90, 210, 200 }, - { 10, 99, 300, 200 }, - { 10, 99, 300, 200 }, - { 99, 12, 201, 200 }, - { 99, 11, 201, 200 }, - { 90, 110, 300, 200 }, - { 90, 110, 300, 200 }, - { 10, 10, 365, 405 }, - { 10, 10, 365, 405 }, - { 10, 10, 365, 405 }, - { 10, 10, 365, 405 }, - { 10, 10, 365, 405 }, - { 10, 10, 365, 405 }, - { 10, 10, 365, 405 }, - { 10, 10, 365, 405 }, - { 10, 10, 350, 251 }, - { 10, 10, 300, 200 }, - { 300, 10, 9, 260 }, - { 10, 10, 435, 405 }, - { 10, 10, 120, 120 }, - { 10, 10, 110, 110 }, - { 10, 10, 120, 110 }, - { 10, 10, 110, 120 }, - { 10, 10, 120, 120 }, - { 10, 10, 110, 110 }, - { 10, 10, 120, 110 }, - { 10, 10, 110, 120 }, - { 0, 4, 356, 356 }, - { 100, 100, 356, 356 }, - { 50, 50, 306, 306 }, - { 100, 100, 356, 356 }, - { 100, 100, 356, 356 }, - { 100, 100, 356, 356 }, - { 100, 100, 356, 356 }, - { 100, 100, 356, 356 }, - { 100, 100, 356, 356 }, - { 100, 100, 356, 356 }, - { 100, 100, 356, 356 }, - { 100, 100, 356, 356 }, - { 10, 10, 356, 356 }, - { 100, 100, 356, 356 }, - { 0, 0, 260, 39 }, - { 0, 0, 16, 16 }, - { 10, 10, 416, 26 }, - { 10, 8, 60, 104 }, - { 0, 0, 512, 512 }, - { 0, 10, 511, 306 }, - { 0, 0, 512, 336 }, - { 1, 1, 300, 512 }, - { 0, 0, 500, 512 }, - { 5, 5, 206, 206 }, - { 45, 45, 256, 256 }, - { 86, 86, 215, 215 }, - { 45, 45, 256, 256 }, - { 8, 0, 392, 231 }, - { 8, 0, 392, 231 }, - { 0, 0, 60, 20 }, - { 0, 0, 512, 512 }, - { -1, -1, -1, -1 } /* the end */ -}; - -static const char **current_sha1; -static const RECT *current_bounds; -static const char *dst_format; - -static inline DWORD get_stride(const BITMAPINFO *bmi) -{ - return ((bmi->bmiHeader.biBitCount * bmi->bmiHeader.biWidth + 31) >> 3) & ~3; -} - -static inline DWORD get_dib_size(const BITMAPINFO *bmi) -{ - return get_stride(bmi) * abs(bmi->bmiHeader.biHeight); -} - -static void reset_bits( HDC hdc, const BITMAPINFO *bmi, BYTE *bits ) -{ - DWORD size = get_dib_size( bmi ); - if (bits) memset( bits, 0xcc, size ); - else - { - void *ddb_bits = HeapAlloc( GetProcessHeap(), 0, size ); - memset( ddb_bits, 0xcc, size ); - SetBitmapBits( GetCurrentObject(hdc, OBJ_BITMAP), size, ddb_bits ); - HeapFree( GetProcessHeap(), 0, ddb_bits ); - } -} - -static char *hash_dib(HDC hdc, const BITMAPINFO *bmi, const void *bits) -{ - DWORD dib_size = get_dib_size(bmi); - HCRYPTHASH hash; - char *buf; - BYTE hash_buf[20]; - DWORD hash_size = sizeof(hash_buf); - int i; - static const char *hex = "0123456789abcdef"; - - if(!crypt_prov) return NULL; - - if(!CryptCreateHash(crypt_prov, CALG_SHA1, 0, 0, &hash)) return NULL; - - if (!bits) - { - void *ddb_bits = HeapAlloc( GetProcessHeap(), 0, dib_size ); - GetBitmapBits( GetCurrentObject(hdc, OBJ_BITMAP), dib_size, ddb_bits ); - CryptHashData(hash, ddb_bits, dib_size, 0); - HeapFree( GetProcessHeap(), 0, ddb_bits ); - } - else CryptHashData(hash, bits, dib_size, 0); - - CryptGetHashParam(hash, HP_HASHVAL, NULL, &hash_size, 0); - if(hash_size != sizeof(hash_buf)) return NULL; - - CryptGetHashParam(hash, HP_HASHVAL, hash_buf, &hash_size, 0); - CryptDestroyHash(hash); - - buf = HeapAlloc(GetProcessHeap(), 0, hash_size * 2 + 1); - - for(i = 0; i < hash_size; i++) - { - buf[i * 2] = hex[hash_buf[i] >> 4]; - buf[i * 2 + 1] = hex[hash_buf[i] & 0xf]; - } - buf[i * 2] = '\0'; - - return buf; -} - -static void reset_bounds( HDC hdc ) -{ - current_bounds = graphics_bounds; - SetBoundsRect( hdc, NULL, DCB_RESET | DCB_ENABLE ); -} - -static void compare_bounds( HDC hdc, const char *info ) -{ - RECT rect; - - GetBoundsRect( hdc, &rect, DCB_RESET ); - - if (current_bounds->left == -1 && - current_bounds->top == -1 && - current_bounds->right == -1 && - current_bounds->bottom == -1) - { - ok( 0, "missing bounds, got %s,\n", wine_dbgstr_rect( &rect )); - return; - } - - ok( EqualRect( current_bounds, &rect ), "%s: %s: expected bounds %s got %s\n", dst_format, info, - wine_dbgstr_rect( current_bounds ), wine_dbgstr_rect( &rect )); - current_bounds++; -} - -static void compare_hash_broken_todo(HDC hdc, const BITMAPINFO *bmi, BYTE *bits, const char *info, int num_broken, BOOL todo) -{ - char *hash = hash_dib(hdc, bmi, bits); - BOOL ok_cond; - int i; - - /* reset the bits for the next test */ - reset_bits( hdc, bmi, bits ); - - if(!hash) - { - skip("SHA1 hashing unavailable on this platform\n"); - return; - } - - for(i = 0; i <= num_broken; i++) - { - if(current_sha1[i] == NULL) - { - ok(current_sha1[i] != NULL, "missing hash, got \"%s\",\n", hash); - HeapFree(GetProcessHeap(), 0, hash); - return; - } - } - - ok_cond = !strcmp(hash, *current_sha1); - - for(i = 1; i <= num_broken; i++) - ok_cond = ok_cond || broken( !strcmp(hash, current_sha1[i]) ); - - todo_wine_if(todo) - ok( ok_cond, "%s: %s: expected hash %s got %s\n", - dst_format, info, *current_sha1, hash ); - - current_sha1 += num_broken + 1; - - HeapFree(GetProcessHeap(), 0, hash); - - compare_bounds( hdc, info ); -} - -static void compare_hash(HDC hdc, const BITMAPINFO *bmi, BYTE *bits, const char *info) -{ - compare_hash_broken_todo(hdc, bmi, bits, info, 0, FALSE); -} - static const RECT bias_check[] = { {100, 100, 200, 150}, @@ -1621,129 +1412,6 @@ static const DWORD four_by_four_data[16] = { 0x000000, 0xff0000, 0x00ff00, 0x000 static const DWORD ddb_brush_bits[8] = { 0x11112222, 0x33334444, 0x55556666, 0x77778888, 0xaaaaaaaa, 0x00000000, 0x98765432, 0xabcdef00 }; -static const RGBQUAD default_palette_1[2] = -{ - { 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff } -}; - -static const RGBQUAD default_palette_4[16] = -{ - { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x80 }, { 0x00, 0x80, 0x00 }, { 0x00, 0x80, 0x80 }, - { 0x80, 0x00, 0x00 }, { 0x80, 0x00, 0x80 }, { 0x80, 0x80, 0x00 }, { 0x80, 0x80, 0x80 }, - { 0xc0, 0xc0, 0xc0 }, { 0x00, 0x00, 0xff }, { 0x00, 0xff, 0x00 }, { 0x00, 0xff, 0xff }, - { 0xff, 0x00, 0x00 }, { 0xff, 0x00, 0xff }, { 0xff, 0xff, 0x00 }, { 0xff, 0xff, 0xff }, -}; - -static const RGBQUAD default_palette_8[256] = -{ - { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x80 }, { 0x00, 0x80, 0x00 }, { 0x00, 0x80, 0x80 }, - { 0x80, 0x00, 0x00 }, { 0x80, 0x00, 0x80 }, { 0x80, 0x80, 0x00 }, { 0xc0, 0xc0, 0xc0 }, - { 0xc0, 0xdc, 0xc0 }, { 0xf0, 0xca, 0xa6 }, { 0x00, 0x20, 0x40 }, { 0x00, 0x20, 0x60 }, - { 0x00, 0x20, 0x80 }, { 0x00, 0x20, 0xa0 }, { 0x00, 0x20, 0xc0 }, { 0x00, 0x20, 0xe0 }, - { 0x00, 0x40, 0x00 }, { 0x00, 0x40, 0x20 }, { 0x00, 0x40, 0x40 }, { 0x00, 0x40, 0x60 }, - { 0x00, 0x40, 0x80 }, { 0x00, 0x40, 0xa0 }, { 0x00, 0x40, 0xc0 }, { 0x00, 0x40, 0xe0 }, - { 0x00, 0x60, 0x00 }, { 0x00, 0x60, 0x20 }, { 0x00, 0x60, 0x40 }, { 0x00, 0x60, 0x60 }, - { 0x00, 0x60, 0x80 }, { 0x00, 0x60, 0xa0 }, { 0x00, 0x60, 0xc0 }, { 0x00, 0x60, 0xe0 }, - { 0x00, 0x80, 0x00 }, { 0x00, 0x80, 0x20 }, { 0x00, 0x80, 0x40 }, { 0x00, 0x80, 0x60 }, - { 0x00, 0x80, 0x80 }, { 0x00, 0x80, 0xa0 }, { 0x00, 0x80, 0xc0 }, { 0x00, 0x80, 0xe0 }, - { 0x00, 0xa0, 0x00 }, { 0x00, 0xa0, 0x20 }, { 0x00, 0xa0, 0x40 }, { 0x00, 0xa0, 0x60 }, - { 0x00, 0xa0, 0x80 }, { 0x00, 0xa0, 0xa0 }, { 0x00, 0xa0, 0xc0 }, { 0x00, 0xa0, 0xe0 }, - { 0x00, 0xc0, 0x00 }, { 0x00, 0xc0, 0x20 }, { 0x00, 0xc0, 0x40 }, { 0x00, 0xc0, 0x60 }, - { 0x00, 0xc0, 0x80 }, { 0x00, 0xc0, 0xa0 }, { 0x00, 0xc0, 0xc0 }, { 0x00, 0xc0, 0xe0 }, - { 0x00, 0xe0, 0x00 }, { 0x00, 0xe0, 0x20 }, { 0x00, 0xe0, 0x40 }, { 0x00, 0xe0, 0x60 }, - { 0x00, 0xe0, 0x80 }, { 0x00, 0xe0, 0xa0 }, { 0x00, 0xe0, 0xc0 }, { 0x00, 0xe0, 0xe0 }, - { 0x40, 0x00, 0x00 }, { 0x40, 0x00, 0x20 }, { 0x40, 0x00, 0x40 }, { 0x40, 0x00, 0x60 }, - { 0x40, 0x00, 0x80 }, { 0x40, 0x00, 0xa0 }, { 0x40, 0x00, 0xc0 }, { 0x40, 0x00, 0xe0 }, - { 0x40, 0x20, 0x00 }, { 0x40, 0x20, 0x20 }, { 0x40, 0x20, 0x40 }, { 0x40, 0x20, 0x60 }, - { 0x40, 0x20, 0x80 }, { 0x40, 0x20, 0xa0 }, { 0x40, 0x20, 0xc0 }, { 0x40, 0x20, 0xe0 }, - { 0x40, 0x40, 0x00 }, { 0x40, 0x40, 0x20 }, { 0x40, 0x40, 0x40 }, { 0x40, 0x40, 0x60 }, - { 0x40, 0x40, 0x80 }, { 0x40, 0x40, 0xa0 }, { 0x40, 0x40, 0xc0 }, { 0x40, 0x40, 0xe0 }, - { 0x40, 0x60, 0x00 }, { 0x40, 0x60, 0x20 }, { 0x40, 0x60, 0x40 }, { 0x40, 0x60, 0x60 }, - { 0x40, 0x60, 0x80 }, { 0x40, 0x60, 0xa0 }, { 0x40, 0x60, 0xc0 }, { 0x40, 0x60, 0xe0 }, - { 0x40, 0x80, 0x00 }, { 0x40, 0x80, 0x20 }, { 0x40, 0x80, 0x40 }, { 0x40, 0x80, 0x60 }, - { 0x40, 0x80, 0x80 }, { 0x40, 0x80, 0xa0 }, { 0x40, 0x80, 0xc0 }, { 0x40, 0x80, 0xe0 }, - { 0x40, 0xa0, 0x00 }, { 0x40, 0xa0, 0x20 }, { 0x40, 0xa0, 0x40 }, { 0x40, 0xa0, 0x60 }, - { 0x40, 0xa0, 0x80 }, { 0x40, 0xa0, 0xa0 }, { 0x40, 0xa0, 0xc0 }, { 0x40, 0xa0, 0xe0 }, - { 0x40, 0xc0, 0x00 }, { 0x40, 0xc0, 0x20 }, { 0x40, 0xc0, 0x40 }, { 0x40, 0xc0, 0x60 }, - { 0x40, 0xc0, 0x80 }, { 0x40, 0xc0, 0xa0 }, { 0x40, 0xc0, 0xc0 }, { 0x40, 0xc0, 0xe0 }, - { 0x40, 0xe0, 0x00 }, { 0x40, 0xe0, 0x20 }, { 0x40, 0xe0, 0x40 }, { 0x40, 0xe0, 0x60 }, - { 0x40, 0xe0, 0x80 }, { 0x40, 0xe0, 0xa0 }, { 0x40, 0xe0, 0xc0 }, { 0x40, 0xe0, 0xe0 }, - { 0x80, 0x00, 0x00 }, { 0x80, 0x00, 0x20 }, { 0x80, 0x00, 0x40 }, { 0x80, 0x00, 0x60 }, - { 0x80, 0x00, 0x80 }, { 0x80, 0x00, 0xa0 }, { 0x80, 0x00, 0xc0 }, { 0x80, 0x00, 0xe0 }, - { 0x80, 0x20, 0x00 }, { 0x80, 0x20, 0x20 }, { 0x80, 0x20, 0x40 }, { 0x80, 0x20, 0x60 }, - { 0x80, 0x20, 0x80 }, { 0x80, 0x20, 0xa0 }, { 0x80, 0x20, 0xc0 }, { 0x80, 0x20, 0xe0 }, - { 0x80, 0x40, 0x00 }, { 0x80, 0x40, 0x20 }, { 0x80, 0x40, 0x40 }, { 0x80, 0x40, 0x60 }, - { 0x80, 0x40, 0x80 }, { 0x80, 0x40, 0xa0 }, { 0x80, 0x40, 0xc0 }, { 0x80, 0x40, 0xe0 }, - { 0x80, 0x60, 0x00 }, { 0x80, 0x60, 0x20 }, { 0x80, 0x60, 0x40 }, { 0x80, 0x60, 0x60 }, - { 0x80, 0x60, 0x80 }, { 0x80, 0x60, 0xa0 }, { 0x80, 0x60, 0xc0 }, { 0x80, 0x60, 0xe0 }, - { 0x80, 0x80, 0x00 }, { 0x80, 0x80, 0x20 }, { 0x80, 0x80, 0x40 }, { 0x80, 0x80, 0x60 }, - { 0x80, 0x80, 0x80 }, { 0x80, 0x80, 0xa0 }, { 0x80, 0x80, 0xc0 }, { 0x80, 0x80, 0xe0 }, - { 0x80, 0xa0, 0x00 }, { 0x80, 0xa0, 0x20 }, { 0x80, 0xa0, 0x40 }, { 0x80, 0xa0, 0x60 }, - { 0x80, 0xa0, 0x80 }, { 0x80, 0xa0, 0xa0 }, { 0x80, 0xa0, 0xc0 }, { 0x80, 0xa0, 0xe0 }, - { 0x80, 0xc0, 0x00 }, { 0x80, 0xc0, 0x20 }, { 0x80, 0xc0, 0x40 }, { 0x80, 0xc0, 0x60 }, - { 0x80, 0xc0, 0x80 }, { 0x80, 0xc0, 0xa0 }, { 0x80, 0xc0, 0xc0 }, { 0x80, 0xc0, 0xe0 }, - { 0x80, 0xe0, 0x00 }, { 0x80, 0xe0, 0x20 }, { 0x80, 0xe0, 0x40 }, { 0x80, 0xe0, 0x60 }, - { 0x80, 0xe0, 0x80 }, { 0x80, 0xe0, 0xa0 }, { 0x80, 0xe0, 0xc0 }, { 0x80, 0xe0, 0xe0 }, - { 0xc0, 0x00, 0x00 }, { 0xc0, 0x00, 0x20 }, { 0xc0, 0x00, 0x40 }, { 0xc0, 0x00, 0x60 }, - { 0xc0, 0x00, 0x80 }, { 0xc0, 0x00, 0xa0 }, { 0xc0, 0x00, 0xc0 }, { 0xc0, 0x00, 0xe0 }, - { 0xc0, 0x20, 0x00 }, { 0xc0, 0x20, 0x20 }, { 0xc0, 0x20, 0x40 }, { 0xc0, 0x20, 0x60 }, - { 0xc0, 0x20, 0x80 }, { 0xc0, 0x20, 0xa0 }, { 0xc0, 0x20, 0xc0 }, { 0xc0, 0x20, 0xe0 }, - { 0xc0, 0x40, 0x00 }, { 0xc0, 0x40, 0x20 }, { 0xc0, 0x40, 0x40 }, { 0xc0, 0x40, 0x60 }, - { 0xc0, 0x40, 0x80 }, { 0xc0, 0x40, 0xa0 }, { 0xc0, 0x40, 0xc0 }, { 0xc0, 0x40, 0xe0 }, - { 0xc0, 0x60, 0x00 }, { 0xc0, 0x60, 0x20 }, { 0xc0, 0x60, 0x40 }, { 0xc0, 0x60, 0x60 }, - { 0xc0, 0x60, 0x80 }, { 0xc0, 0x60, 0xa0 }, { 0xc0, 0x60, 0xc0 }, { 0xc0, 0x60, 0xe0 }, - { 0xc0, 0x80, 0x00 }, { 0xc0, 0x80, 0x20 }, { 0xc0, 0x80, 0x40 }, { 0xc0, 0x80, 0x60 }, - { 0xc0, 0x80, 0x80 }, { 0xc0, 0x80, 0xa0 }, { 0xc0, 0x80, 0xc0 }, { 0xc0, 0x80, 0xe0 }, - { 0xc0, 0xa0, 0x00 }, { 0xc0, 0xa0, 0x20 }, { 0xc0, 0xa0, 0x40 }, { 0xc0, 0xa0, 0x60 }, - { 0xc0, 0xa0, 0x80 }, { 0xc0, 0xa0, 0xa0 }, { 0xc0, 0xa0, 0xc0 }, { 0xc0, 0xa0, 0xe0 }, - { 0xc0, 0xc0, 0x00 }, { 0xc0, 0xc0, 0x20 }, { 0xc0, 0xc0, 0x40 }, { 0xc0, 0xc0, 0x60 }, - { 0xc0, 0xc0, 0x80 }, { 0xc0, 0xc0, 0xa0 }, { 0xf0, 0xfb, 0xff }, { 0xa4, 0xa0, 0xa0 }, - { 0x80, 0x80, 0x80 }, { 0x00, 0x00, 0xff }, { 0x00, 0xff, 0x00 }, { 0x00, 0xff, 0xff }, - { 0xff, 0x00, 0x00 }, { 0xff, 0x00, 0xff }, { 0xff, 0xff, 0x00 }, { 0xff, 0xff, 0xff } -}; - -static HPALETTE create_default_palette( int bpp ) -{ - char pal_buffer[sizeof(LOGPALETTE) + 255 * sizeof(PALETTEENTRY)]; - LOGPALETTE *pal = (LOGPALETTE *)pal_buffer; - PALETTEENTRY *entries = pal->palPalEntry; - int i; - - pal->palVersion = 0x300; - pal->palNumEntries = 1 << bpp; - switch (bpp) - { - case 1: - for (i = 0; i < 2; i++) - { - entries[i].peRed = default_palette_1[i].rgbRed; - entries[i].peGreen = default_palette_1[i].rgbGreen; - entries[i].peBlue = default_palette_1[i].rgbBlue; - entries[i].peFlags = 0; - } - break; - case 4: - for (i = 0; i < 16; i++) - { - entries[i].peRed = default_palette_4[i].rgbRed; - entries[i].peGreen = default_palette_4[i].rgbGreen; - entries[i].peBlue = default_palette_4[i].rgbBlue; - entries[i].peFlags = 0; - } - break; - case 8: - for (i = 0; i < 256; i++) - { - entries[i].peRed = default_palette_8[i].rgbRed; - entries[i].peGreen = default_palette_8[i].rgbGreen; - entries[i].peBlue = default_palette_8[i].rgbBlue; - entries[i].peFlags = 0; - } - break; - } - return CreatePalette( pal ); -} - static inline void solid_patblt( HDC hdc, int x, int y, int width, int height, COLORREF color ) { HBRUSH brush = CreateSolidBrush( color ); diff --git a/dlls/gdi32/tests/misc.c b/dlls/gdi32/tests/misc.c new file mode 100644 index 00000000000..828be2745a0 --- /dev/null +++ b/dlls/gdi32/tests/misc.c @@ -0,0 +1,425 @@ + + +#include <stdarg.h> +#include <stdio.h> +#include <math.h> + +#include "windef.h" +#include "winbase.h" +#include "wingdi.h" +#include "winuser.h" +#include "wincrypt.h" +#include "mmsystem.h" /* DIBINDEX */ + +#include "wine/test.h" +#include "misc.h" + +const char **current_sha1; +const RECT *current_bounds; +const char *dst_format; +HCRYPTPROV crypt_prov; + +static const RECT graphics_bounds[] = +{ + { 0, 0, 0, 0 }, + { 10, 3, 219, 101 }, + { 100, 100, 301, 301 }, + { 0, 0, 201, 201 }, + { 10, 10, 110, 320 }, + { 10, 99, 300, 200 }, + { 99, 12, 201, 200 }, + { 90, 110, 300, 200 }, + { 90, 90, 210, 200 }, + { 10, 99, 300, 200 }, + { 10, 99, 300, 200 }, + { 99, 12, 201, 200 }, + { 99, 11, 201, 200 }, + { 90, 110, 300, 200 }, + { 90, 110, 300, 200 }, + { 10, 10, 365, 405 }, + { 10, 10, 365, 405 }, + { 10, 10, 365, 405 }, + { 10, 10, 365, 405 }, + { 10, 10, 365, 405 }, + { 10, 10, 365, 405 }, + { 10, 10, 365, 405 }, + { 10, 10, 365, 405 }, + { 10, 10, 350, 251 }, + { 10, 10, 300, 200 }, + { 300, 10, 9, 260 }, + { 10, 10, 435, 405 }, + { 10, 10, 120, 120 }, + { 10, 10, 110, 110 }, + { 10, 10, 120, 110 }, + { 10, 10, 110, 120 }, + { 10, 10, 120, 120 }, + { 10, 10, 110, 110 }, + { 10, 10, 120, 110 }, + { 10, 10, 110, 120 }, + { 0, 4, 356, 356 }, + { 100, 100, 356, 356 }, + { 50, 50, 306, 306 }, + { 100, 100, 356, 356 }, + { 100, 100, 356, 356 }, + { 100, 100, 356, 356 }, + { 100, 100, 356, 356 }, + { 100, 100, 356, 356 }, + { 100, 100, 356, 356 }, + { 100, 100, 356, 356 }, + { 100, 100, 356, 356 }, + { 100, 100, 356, 356 }, + { 10, 10, 356, 356 }, + { 100, 100, 356, 356 }, + { 0, 0, 260, 39 }, + { 0, 0, 16, 16 }, + { 10, 10, 416, 26 }, + { 10, 8, 60, 104 }, + { 0, 0, 512, 512 }, + { 0, 10, 511, 306 }, + { 0, 0, 512, 336 }, + { 1, 1, 300, 512 }, + { 0, 0, 500, 512 }, + { 5, 5, 206, 206 }, + { 45, 45, 256, 256 }, + { 86, 86, 215, 215 }, + { 45, 45, 256, 256 }, + { 8, 0, 392, 231 }, + { 8, 0, 392, 231 }, + { 0, 0, 60, 20 }, + { 0, 0, 512, 512 }, + { -1, -1, -1, -1 } /* the end */ +}; + +static const RGBQUAD default_palette_1[2] = +{ + { 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff } +}; + +static const RGBQUAD default_palette_4[16] = +{ + { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x80 }, { 0x00, 0x80, 0x00 }, { 0x00, 0x80, 0x80 }, + { 0x80, 0x00, 0x00 }, { 0x80, 0x00, 0x80 }, { 0x80, 0x80, 0x00 }, { 0x80, 0x80, 0x80 }, + { 0xc0, 0xc0, 0xc0 }, { 0x00, 0x00, 0xff }, { 0x00, 0xff, 0x00 }, { 0x00, 0xff, 0xff }, + { 0xff, 0x00, 0x00 }, { 0xff, 0x00, 0xff }, { 0xff, 0xff, 0x00 }, { 0xff, 0xff, 0xff }, +}; + +static const RGBQUAD default_palette_8[256] = +{ + { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x80 }, { 0x00, 0x80, 0x00 }, { 0x00, 0x80, 0x80 }, + { 0x80, 0x00, 0x00 }, { 0x80, 0x00, 0x80 }, { 0x80, 0x80, 0x00 }, { 0xc0, 0xc0, 0xc0 }, + { 0xc0, 0xdc, 0xc0 }, { 0xf0, 0xca, 0xa6 }, { 0x00, 0x20, 0x40 }, { 0x00, 0x20, 0x60 }, + { 0x00, 0x20, 0x80 }, { 0x00, 0x20, 0xa0 }, { 0x00, 0x20, 0xc0 }, { 0x00, 0x20, 0xe0 }, + { 0x00, 0x40, 0x00 }, { 0x00, 0x40, 0x20 }, { 0x00, 0x40, 0x40 }, { 0x00, 0x40, 0x60 }, + { 0x00, 0x40, 0x80 }, { 0x00, 0x40, 0xa0 }, { 0x00, 0x40, 0xc0 }, { 0x00, 0x40, 0xe0 }, + { 0x00, 0x60, 0x00 }, { 0x00, 0x60, 0x20 }, { 0x00, 0x60, 0x40 }, { 0x00, 0x60, 0x60 }, + { 0x00, 0x60, 0x80 }, { 0x00, 0x60, 0xa0 }, { 0x00, 0x60, 0xc0 }, { 0x00, 0x60, 0xe0 }, + { 0x00, 0x80, 0x00 }, { 0x00, 0x80, 0x20 }, { 0x00, 0x80, 0x40 }, { 0x00, 0x80, 0x60 }, + { 0x00, 0x80, 0x80 }, { 0x00, 0x80, 0xa0 }, { 0x00, 0x80, 0xc0 }, { 0x00, 0x80, 0xe0 }, + { 0x00, 0xa0, 0x00 }, { 0x00, 0xa0, 0x20 }, { 0x00, 0xa0, 0x40 }, { 0x00, 0xa0, 0x60 }, + { 0x00, 0xa0, 0x80 }, { 0x00, 0xa0, 0xa0 }, { 0x00, 0xa0, 0xc0 }, { 0x00, 0xa0, 0xe0 }, + { 0x00, 0xc0, 0x00 }, { 0x00, 0xc0, 0x20 }, { 0x00, 0xc0, 0x40 }, { 0x00, 0xc0, 0x60 }, + { 0x00, 0xc0, 0x80 }, { 0x00, 0xc0, 0xa0 }, { 0x00, 0xc0, 0xc0 }, { 0x00, 0xc0, 0xe0 }, + { 0x00, 0xe0, 0x00 }, { 0x00, 0xe0, 0x20 }, { 0x00, 0xe0, 0x40 }, { 0x00, 0xe0, 0x60 }, + { 0x00, 0xe0, 0x80 }, { 0x00, 0xe0, 0xa0 }, { 0x00, 0xe0, 0xc0 }, { 0x00, 0xe0, 0xe0 }, + { 0x40, 0x00, 0x00 }, { 0x40, 0x00, 0x20 }, { 0x40, 0x00, 0x40 }, { 0x40, 0x00, 0x60 }, + { 0x40, 0x00, 0x80 }, { 0x40, 0x00, 0xa0 }, { 0x40, 0x00, 0xc0 }, { 0x40, 0x00, 0xe0 }, + { 0x40, 0x20, 0x00 }, { 0x40, 0x20, 0x20 }, { 0x40, 0x20, 0x40 }, { 0x40, 0x20, 0x60 }, + { 0x40, 0x20, 0x80 }, { 0x40, 0x20, 0xa0 }, { 0x40, 0x20, 0xc0 }, { 0x40, 0x20, 0xe0 }, + { 0x40, 0x40, 0x00 }, { 0x40, 0x40, 0x20 }, { 0x40, 0x40, 0x40 }, { 0x40, 0x40, 0x60 }, + { 0x40, 0x40, 0x80 }, { 0x40, 0x40, 0xa0 }, { 0x40, 0x40, 0xc0 }, { 0x40, 0x40, 0xe0 }, + { 0x40, 0x60, 0x00 }, { 0x40, 0x60, 0x20 }, { 0x40, 0x60, 0x40 }, { 0x40, 0x60, 0x60 }, + { 0x40, 0x60, 0x80 }, { 0x40, 0x60, 0xa0 }, { 0x40, 0x60, 0xc0 }, { 0x40, 0x60, 0xe0 }, + { 0x40, 0x80, 0x00 }, { 0x40, 0x80, 0x20 }, { 0x40, 0x80, 0x40 }, { 0x40, 0x80, 0x60 }, + { 0x40, 0x80, 0x80 }, { 0x40, 0x80, 0xa0 }, { 0x40, 0x80, 0xc0 }, { 0x40, 0x80, 0xe0 }, + { 0x40, 0xa0, 0x00 }, { 0x40, 0xa0, 0x20 }, { 0x40, 0xa0, 0x40 }, { 0x40, 0xa0, 0x60 }, + { 0x40, 0xa0, 0x80 }, { 0x40, 0xa0, 0xa0 }, { 0x40, 0xa0, 0xc0 }, { 0x40, 0xa0, 0xe0 }, + { 0x40, 0xc0, 0x00 }, { 0x40, 0xc0, 0x20 }, { 0x40, 0xc0, 0x40 }, { 0x40, 0xc0, 0x60 }, + { 0x40, 0xc0, 0x80 }, { 0x40, 0xc0, 0xa0 }, { 0x40, 0xc0, 0xc0 }, { 0x40, 0xc0, 0xe0 }, + { 0x40, 0xe0, 0x00 }, { 0x40, 0xe0, 0x20 }, { 0x40, 0xe0, 0x40 }, { 0x40, 0xe0, 0x60 }, + { 0x40, 0xe0, 0x80 }, { 0x40, 0xe0, 0xa0 }, { 0x40, 0xe0, 0xc0 }, { 0x40, 0xe0, 0xe0 }, + { 0x80, 0x00, 0x00 }, { 0x80, 0x00, 0x20 }, { 0x80, 0x00, 0x40 }, { 0x80, 0x00, 0x60 }, + { 0x80, 0x00, 0x80 }, { 0x80, 0x00, 0xa0 }, { 0x80, 0x00, 0xc0 }, { 0x80, 0x00, 0xe0 }, + { 0x80, 0x20, 0x00 }, { 0x80, 0x20, 0x20 }, { 0x80, 0x20, 0x40 }, { 0x80, 0x20, 0x60 }, + { 0x80, 0x20, 0x80 }, { 0x80, 0x20, 0xa0 }, { 0x80, 0x20, 0xc0 }, { 0x80, 0x20, 0xe0 }, + { 0x80, 0x40, 0x00 }, { 0x80, 0x40, 0x20 }, { 0x80, 0x40, 0x40 }, { 0x80, 0x40, 0x60 }, + { 0x80, 0x40, 0x80 }, { 0x80, 0x40, 0xa0 }, { 0x80, 0x40, 0xc0 }, { 0x80, 0x40, 0xe0 }, + { 0x80, 0x60, 0x00 }, { 0x80, 0x60, 0x20 }, { 0x80, 0x60, 0x40 }, { 0x80, 0x60, 0x60 }, + { 0x80, 0x60, 0x80 }, { 0x80, 0x60, 0xa0 }, { 0x80, 0x60, 0xc0 }, { 0x80, 0x60, 0xe0 }, + { 0x80, 0x80, 0x00 }, { 0x80, 0x80, 0x20 }, { 0x80, 0x80, 0x40 }, { 0x80, 0x80, 0x60 }, + { 0x80, 0x80, 0x80 }, { 0x80, 0x80, 0xa0 }, { 0x80, 0x80, 0xc0 }, { 0x80, 0x80, 0xe0 }, + { 0x80, 0xa0, 0x00 }, { 0x80, 0xa0, 0x20 }, { 0x80, 0xa0, 0x40 }, { 0x80, 0xa0, 0x60 }, + { 0x80, 0xa0, 0x80 }, { 0x80, 0xa0, 0xa0 }, { 0x80, 0xa0, 0xc0 }, { 0x80, 0xa0, 0xe0 }, + { 0x80, 0xc0, 0x00 }, { 0x80, 0xc0, 0x20 }, { 0x80, 0xc0, 0x40 }, { 0x80, 0xc0, 0x60 }, + { 0x80, 0xc0, 0x80 }, { 0x80, 0xc0, 0xa0 }, { 0x80, 0xc0, 0xc0 }, { 0x80, 0xc0, 0xe0 }, + { 0x80, 0xe0, 0x00 }, { 0x80, 0xe0, 0x20 }, { 0x80, 0xe0, 0x40 }, { 0x80, 0xe0, 0x60 }, + { 0x80, 0xe0, 0x80 }, { 0x80, 0xe0, 0xa0 }, { 0x80, 0xe0, 0xc0 }, { 0x80, 0xe0, 0xe0 }, + { 0xc0, 0x00, 0x00 }, { 0xc0, 0x00, 0x20 }, { 0xc0, 0x00, 0x40 }, { 0xc0, 0x00, 0x60 }, + { 0xc0, 0x00, 0x80 }, { 0xc0, 0x00, 0xa0 }, { 0xc0, 0x00, 0xc0 }, { 0xc0, 0x00, 0xe0 }, + { 0xc0, 0x20, 0x00 }, { 0xc0, 0x20, 0x20 }, { 0xc0, 0x20, 0x40 }, { 0xc0, 0x20, 0x60 }, + { 0xc0, 0x20, 0x80 }, { 0xc0, 0x20, 0xa0 }, { 0xc0, 0x20, 0xc0 }, { 0xc0, 0x20, 0xe0 }, + { 0xc0, 0x40, 0x00 }, { 0xc0, 0x40, 0x20 }, { 0xc0, 0x40, 0x40 }, { 0xc0, 0x40, 0x60 }, + { 0xc0, 0x40, 0x80 }, { 0xc0, 0x40, 0xa0 }, { 0xc0, 0x40, 0xc0 }, { 0xc0, 0x40, 0xe0 }, + { 0xc0, 0x60, 0x00 }, { 0xc0, 0x60, 0x20 }, { 0xc0, 0x60, 0x40 }, { 0xc0, 0x60, 0x60 }, + { 0xc0, 0x60, 0x80 }, { 0xc0, 0x60, 0xa0 }, { 0xc0, 0x60, 0xc0 }, { 0xc0, 0x60, 0xe0 }, + { 0xc0, 0x80, 0x00 }, { 0xc0, 0x80, 0x20 }, { 0xc0, 0x80, 0x40 }, { 0xc0, 0x80, 0x60 }, + { 0xc0, 0x80, 0x80 }, { 0xc0, 0x80, 0xa0 }, { 0xc0, 0x80, 0xc0 }, { 0xc0, 0x80, 0xe0 }, + { 0xc0, 0xa0, 0x00 }, { 0xc0, 0xa0, 0x20 }, { 0xc0, 0xa0, 0x40 }, { 0xc0, 0xa0, 0x60 }, + { 0xc0, 0xa0, 0x80 }, { 0xc0, 0xa0, 0xa0 }, { 0xc0, 0xa0, 0xc0 }, { 0xc0, 0xa0, 0xe0 }, + { 0xc0, 0xc0, 0x00 }, { 0xc0, 0xc0, 0x20 }, { 0xc0, 0xc0, 0x40 }, { 0xc0, 0xc0, 0x60 }, + { 0xc0, 0xc0, 0x80 }, { 0xc0, 0xc0, 0xa0 }, { 0xf0, 0xfb, 0xff }, { 0xa4, 0xa0, 0xa0 }, + { 0x80, 0x80, 0x80 }, { 0x00, 0x00, 0xff }, { 0x00, 0xff, 0x00 }, { 0x00, 0xff, 0xff }, + { 0xff, 0x00, 0x00 }, { 0xff, 0x00, 0xff }, { 0xff, 0xff, 0x00 }, { 0xff, 0xff, 0xff } +}; + +HPALETTE create_default_palette( int bpp ) +{ + char pal_buffer[sizeof(LOGPALETTE) + 255 * sizeof(PALETTEENTRY)]; + LOGPALETTE *pal = (LOGPALETTE *)pal_buffer; + PALETTEENTRY *entries = pal->palPalEntry; + int i; + + pal->palVersion = 0x300; + pal->palNumEntries = 1 << bpp; + switch (bpp) + { + case 1: + for (i = 0; i < 2; i++) + { + entries[i].peRed = default_palette_1[i].rgbRed; + entries[i].peGreen = default_palette_1[i].rgbGreen; + entries[i].peBlue = default_palette_1[i].rgbBlue; + entries[i].peFlags = 0; + } + break; + case 4: + for (i = 0; i < 16; i++) + { + entries[i].peRed = default_palette_4[i].rgbRed; + entries[i].peGreen = default_palette_4[i].rgbGreen; + entries[i].peBlue = default_palette_4[i].rgbBlue; + entries[i].peFlags = 0; + } + break; + case 8: + for (i = 0; i < 256; i++) + { + entries[i].peRed = default_palette_8[i].rgbRed; + entries[i].peGreen = default_palette_8[i].rgbGreen; + entries[i].peBlue = default_palette_8[i].rgbBlue; + entries[i].peFlags = 0; + } + break; + } + return CreatePalette( pal ); +} + +void reset_bits( HDC hdc, const BITMAPINFO *bmi, BYTE *bits ) +{ + DWORD size = get_dib_size( bmi ); + if (bits) memset( bits, 0xcc, size ); + else + { + void *ddb_bits = HeapAlloc( GetProcessHeap(), 0, size ); + memset( ddb_bits, 0xcc, size ); + SetBitmapBits( GetCurrentObject(hdc, OBJ_BITMAP), size, ddb_bits ); + HeapFree( GetProcessHeap(), 0, ddb_bits ); + } +} + +char *hash_dib(HDC hdc, const BITMAPINFO *bmi, const void *bits) +{ + DWORD dib_size = get_dib_size(bmi); + HCRYPTHASH hash; + char *buf; + BYTE hash_buf[20]; + DWORD hash_size = sizeof(hash_buf); + int i; + static const char *hex = "0123456789abcdef"; + + if(!crypt_prov) return NULL; + + if(!CryptCreateHash(crypt_prov, CALG_SHA1, 0, 0, &hash)) return NULL; + + if (!bits) + { + void *ddb_bits = HeapAlloc( GetProcessHeap(), 0, dib_size ); + GetBitmapBits( GetCurrentObject(hdc, OBJ_BITMAP), dib_size, ddb_bits ); + CryptHashData(hash, ddb_bits, dib_size, 0); + HeapFree( GetProcessHeap(), 0, ddb_bits ); + } + else CryptHashData(hash, bits, dib_size, 0); + + CryptGetHashParam(hash, HP_HASHVAL, NULL, &hash_size, 0); + if(hash_size != sizeof(hash_buf)) return NULL; + + CryptGetHashParam(hash, HP_HASHVAL, hash_buf, &hash_size, 0); + CryptDestroyHash(hash); + + buf = HeapAlloc(GetProcessHeap(), 0, hash_size * 2 + 1); + + for(i = 0; i < hash_size; i++) + { + buf[i * 2] = hex[hash_buf[i] >> 4]; + buf[i * 2 + 1] = hex[hash_buf[i] & 0xf]; + } + buf[i * 2] = '\0'; + + return buf; +} + +void reset_bounds( HDC hdc ) +{ + current_bounds = graphics_bounds; + SetBoundsRect( hdc, NULL, DCB_RESET | DCB_ENABLE ); +} + +void compare_bounds( HDC hdc, const char *info ) +{ + RECT rect; + + GetBoundsRect( hdc, &rect, DCB_RESET ); + + if (current_bounds->left == -1 && + current_bounds->top == -1 && + current_bounds->right == -1 && + current_bounds->bottom == -1) + { + ok( 0, "missing bounds, got %s,\n", wine_dbgstr_rect( &rect )); + return; + } + + ok( EqualRect( current_bounds, &rect ), "%s: %s: expected bounds %s got %s\n", dst_format, info, + wine_dbgstr_rect( current_bounds ), wine_dbgstr_rect( &rect )); + current_bounds++; +} + +void compare_hash_broken_todo(HDC hdc, const BITMAPINFO *bmi, BYTE *bits, const char *info, int num_broken, BOOL todo) +{ + char *hash = hash_dib(hdc, bmi, bits); + BOOL ok_cond; + int i; + + /* reset the bits for the next test */ + reset_bits( hdc, bmi, bits ); + + if(!hash) + { + skip("SHA1 hashing unavailable on this platform\n"); + return; + } + + for(i = 0; i <= num_broken; i++) + { + if(current_sha1[i] == NULL) + { + ok(current_sha1[i] != NULL, "missing hash, got \"%s\",\n", hash); + HeapFree(GetProcessHeap(), 0, hash); + return; + } + } + + ok_cond = !strcmp(hash, *current_sha1); + + for(i = 1; i <= num_broken; i++) + ok_cond = ok_cond || broken( !strcmp(hash, current_sha1[i]) ); + + todo_wine_if(todo) + ok( ok_cond, "%s: %s: expected hash %s got %s\n", + dst_format, info, *current_sha1, hash ); + + current_sha1 += num_broken + 1; + + HeapFree(GetProcessHeap(), 0, hash); + + compare_bounds( hdc, info ); +} + +void compare_hash(HDC hdc, const BITMAPINFO *bmi, BYTE *bits, const char *info) +{ + compare_hash_broken_todo(hdc, bmi, bits, info, 0, FALSE); +} + +BOOL SaveHBITMAPToFile(HBITMAP hBitmap, LPSTR lpszFileName) +{ + HDC hDC; + int iBits; + WORD wBitCount; + DWORD dwPaletteSize = 0, dwBmBitsSize = 0, dwDIBSize = 0, dwWritten = 0; + BITMAP Bitmap0; + BITMAPFILEHEADER bmfHdr; + BITMAPINFOHEADER bi; + LPBITMAPINFOHEADER lpbi; + HANDLE fh, hDib, hPal, hOldPal2 = NULL; + hDC = CreateDCA("DISPLAY", NULL, NULL, NULL); + iBits = GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES); + DeleteDC(hDC); + if (iBits <= 1) + wBitCount = 1; + else if (iBits <= 4) + wBitCount = 4; + else if (iBits <= 8) + wBitCount = 8; + else + wBitCount = 24; + GetObjectA(hBitmap, sizeof(Bitmap0), (LPSTR)&Bitmap0); + bi.biSize = sizeof(BITMAPINFOHEADER); + bi.biWidth = Bitmap0.bmWidth; + bi.biHeight = -Bitmap0.bmHeight; + bi.biPlanes = 1; + bi.biBitCount = wBitCount; + bi.biCompression = BI_RGB; + bi.biSizeImage = 0; + bi.biXPelsPerMeter = 0; + bi.biYPelsPerMeter = 0; + bi.biClrImportant = 0; + bi.biClrUsed = 256; + dwBmBitsSize = ((Bitmap0.bmWidth * wBitCount + 31) & ~31) / 8 + * Bitmap0.bmHeight; + hDib = GlobalAlloc(GHND, dwBmBitsSize + dwPaletteSize + sizeof(BITMAPINFOHEADER)); + lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDib); + *lpbi = bi; + + hPal = GetStockObject(DEFAULT_PALETTE); + if (hPal) + { + hDC = GetDC(NULL); + hOldPal2 = SelectPalette(hDC, (HPALETTE)hPal, FALSE); + RealizePalette(hDC); + } + + + GetDIBits(hDC, hBitmap, 0, (UINT)Bitmap0.bmHeight, (LPSTR)lpbi + sizeof(BITMAPINFOHEADER) + + dwPaletteSize, (BITMAPINFO *)lpbi, DIB_RGB_COLORS); + + if (hOldPal2) + { + SelectPalette(hDC, (HPALETTE)hOldPal2, TRUE); + RealizePalette(hDC); + ReleaseDC(NULL, hDC); + } + + fh = CreateFileA(lpszFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL); + + if (fh == INVALID_HANDLE_VALUE) + return FALSE; + + bmfHdr.bfType = 0x4D42; // "BM" + dwDIBSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dwPaletteSize + dwBmBitsSize; + bmfHdr.bfSize = dwDIBSize; + bmfHdr.bfReserved1 = 0; + bmfHdr.bfReserved2 = 0; + bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + (DWORD)sizeof(BITMAPINFOHEADER) + dwPaletteSize; + + WriteFile(fh, (LPSTR)&bmfHdr, sizeof(BITMAPFILEHEADER), &dwWritten, NULL); + + WriteFile(fh, (LPSTR)lpbi, dwDIBSize, &dwWritten, NULL); + GlobalUnlock(hDib); + GlobalFree(hDib); + CloseHandle(fh); + return TRUE; +} + +void func_misc() +{ +} diff --git a/dlls/gdi32/tests/misc.h b/dlls/gdi32/tests/misc.h new file mode 100644 index 00000000000..719a360d23d --- /dev/null +++ b/dlls/gdi32/tests/misc.h @@ -0,0 +1,31 @@ + +#ifndef MISC_H +#define MISC_H + +#include "windef.h" + +extern const char **current_sha1; +extern const RECT *current_bounds; +extern HCRYPTPROV crypt_prov; + +HPALETTE create_default_palette( int bpp ); + +static inline DWORD get_stride(const BITMAPINFO *bmi) +{ + return ((bmi->bmiHeader.biBitCount * bmi->bmiHeader.biWidth + 31) >> 3) & ~3; +} + +static inline DWORD get_dib_size(const BITMAPINFO *bmi) +{ + return get_stride(bmi) * abs(bmi->bmiHeader.biHeight); +} + +void reset_bits( HDC hdc, const BITMAPINFO *bmi, BYTE *bits ); +char *hash_dib(HDC hdc, const BITMAPINFO *bmi, const void *bits); +void reset_bounds( HDC hdc ); +void compare_bounds( HDC hdc, const char *info ); +void compare_hash_broken_todo(HDC hdc, const BITMAPINFO *bmi, BYTE *bits, const char *info, int num_broken, BOOL todo); +void compare_hash(HDC hdc, const BITMAPINFO *bmi, BYTE *bits, const char *info); + +BOOL SaveHBITMAPToFile(HBITMAP hBitmap, LPSTR lpszFileName); +#endif -- 2.26.2

3 4

← Newer
1
...
44
45
46
47
48
49
50
...
64
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel February 2021