| /* |
| * Copyright 2014 Akihiro Sagawa |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #define WIN32_LEAN_AND_MEAN |
| |
| #include <windows.h> |
| #include <vfw.h> |
| #include <wincrypt.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "wine/test.h" |
| |
| #define WIDTH 16 |
| #define HEIGHT 12 |
| |
| static HCRYPTPROV crypt_prov; |
| |
| 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 char *hash_dib(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; |
| |
| 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 init_bmi(BITMAPINFO *bmi, LONG width, LONG height, DWORD size) |
| { |
| memset(bmi, 0, sizeof(*bmi)); |
| bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); |
| bmi->bmiHeader.biWidth = width; |
| bmi->bmiHeader.biHeight = height; |
| bmi->bmiHeader.biPlanes = 1; |
| bmi->bmiHeader.biBitCount = 32; |
| bmi->bmiHeader.biCompression = BI_RGB; |
| bmi->bmiHeader.biSizeImage = size; |
| } |
| |
| static void test_DrawDib_sizeimage(void) |
| { |
| const struct { |
| LONG width, height; |
| DWORD size; |
| char hash[41]; |
| } test_data[] = { |
| /* [0] correct size */ |
| { WIDTH, HEIGHT, WIDTH * HEIGHT * sizeof(RGBQUAD), "bc943d5ab024b8b0118d0a80aa283055d39942b8" }, |
| /* [1] zero size */ |
| { WIDTH, HEIGHT, 0, "bc943d5ab024b8b0118d0a80aa283055d39942b8" }, |
| /* error patterns */ |
| { WIDTH, -HEIGHT, 0, "" }, |
| { -WIDTH, HEIGHT, 0, "" }, |
| { -WIDTH, -HEIGHT, 0, "" }, |
| { 0, 0, 0, "" }, |
| { 0, HEIGHT, 0, "" }, |
| { WIDTH, 0, 0, "" }, |
| /* [8] zero size (to compare [9], [10] ) */ |
| { WIDTH, HEIGHT/2, 0, "8b75bf6d54a8645380114fe77505ee0699ffffaa" }, |
| /* [9] insufficient size */ |
| { WIDTH, HEIGHT/2, sizeof(RGBQUAD), "8b75bf6d54a8645380114fe77505ee0699ffffaa" }, |
| /* [10] too much size */ |
| { WIDTH, HEIGHT/2, WIDTH * HEIGHT * sizeof(RGBQUAD), "8b75bf6d54a8645380114fe77505ee0699ffffaa" }, |
| }; |
| HDC hdc; |
| DWORD src_dib_size, dst_dib_size; |
| BOOL r; |
| HBITMAP dib; |
| BITMAPINFO src_info, dst_info; |
| RGBQUAD *src_bits = NULL, *dst_bits; |
| HDRAWDIB hdd; |
| unsigned int i; |
| |
| hdc = CreateCompatibleDC(NULL); |
| |
| init_bmi(&dst_info, WIDTH, HEIGHT, 0); |
| dib = CreateDIBSection(NULL, &dst_info, DIB_RGB_COLORS, (void **)&dst_bits, NULL, 0); |
| dst_dib_size = get_dib_size(&dst_info); |
| ok(dib != NULL, "CreateDIBSection failed\n"); |
| SelectObject(hdc, dib); |
| |
| init_bmi(&src_info, WIDTH, HEIGHT, 0); |
| src_dib_size = get_dib_size(&src_info); |
| src_bits = HeapAlloc(GetProcessHeap(), 0, src_dib_size); |
| ok(src_bits != NULL, "Can't allocate memory\n"); |
| memset(src_bits, 0x88, src_dib_size); |
| |
| hdd = DrawDibOpen(); |
| ok(hdd != NULL, "DrawDibOpen failed\n"); |
| |
| for (i = 0; i < sizeof(test_data)/sizeof(test_data[0]); i++) { |
| char *hash; |
| memset(dst_bits, 0xff, dst_dib_size); |
| init_bmi(&src_info, test_data[i].width, test_data[i].height, test_data[i].size); |
| r = DrawDibDraw(hdd, hdc, |
| 0, 0, -1, -1, &src_info.bmiHeader, src_bits, |
| 0, 0, test_data[i].width, test_data[i].height, 0); |
| if (test_data[i].hash[0]) |
| ok(r, "[%u] DrawDibDraw failed, expected success\n", i); |
| else |
| ok(!r, "[%u] DrawDibDraw succeeded, expected failed\n", i); |
| if (!r || !test_data[i].hash[0]) |
| continue; |
| |
| hash = hash_dib(&dst_info, dst_bits); |
| if (!hash) { |
| win_skip("This platform doesn't support SHA-1 hash\n"); |
| continue; |
| } |
| ok(strcmp(hash, test_data[i].hash) == 0, |
| "[%u] got %s, expected %s\n", |
| i, hash, test_data[i].hash); |
| HeapFree(GetProcessHeap(), 0, hash); |
| } |
| |
| r = DrawDibClose(hdd); |
| ok(r, "DrawDibClose failed\n"); |
| |
| HeapFree(GetProcessHeap(), 0, src_bits); |
| |
| DeleteDC(hdc); |
| } |
| |
| START_TEST(drawdib) |
| { |
| CryptAcquireContextW(&crypt_prov, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT); |
| test_DrawDib_sizeimage(); |
| CryptReleaseContext(crypt_prov, 0); |
| } |