void
Test_DIBBrush(void)
{
struct
{
BITMAPINFOHEADER bmiHeader;
WORD wColors[4];
BYTE jBuffer[16];
} PackedDIB =
{
{sizeof(BITMAPINFOHEADER), 4, 4, 1, 8, BI_RGB, 0, 1, 1, 4, 0},
{1, 7, 3, 1},
{0,1,2,3, 1,2,3,0, 2,3,0,1, 3,0,1,2},
};
LOGBRUSH logbrush;
HBRUSH hBrush;
/* Create a DIB brush */
hBrush = CreateDIBPatternBrushPt(&PackedDIB, DIB_PAL_COLORS);
ok(hBrush != 0, "CreateSolidBrush failed, skipping tests.\n");
if (!hBrush) return;
FillMemory(&logbrush, sizeof(LOGBRUSH), 0x77);
SetLastError(ERROR_SUCCESS);
ok_long(GetObject(hBrush, sizeof(LOGBRUSH), &logbrush), sizeof(LOGBRUSH));
ok_long(logbrush.lbStyle, BS_DIBPATTERN);
ok_long(logbrush.lbColor, 0);
ok_long(logbrush.lbHatch, (ULONG_PTR)&PackedDIB);
ok_err(ERROR_SUCCESS);
DeleteObject(hBrush);
/* Create a DIB brush with undocumented iUsage 2 */
hBrush = CreateDIBPatternBrushPt(&PackedDIB, 2);
ok(hBrush != 0, "CreateSolidBrush failed, skipping tests.\n");
if (!hBrush) return;
FillMemory(&logbrush, sizeof(LOGBRUSH), 0x77);
SetLastError(ERROR_SUCCESS);
ok_long(GetObject(hBrush, sizeof(LOGBRUSH), &logbrush), sizeof(LOGBRUSH));
ok_long(logbrush.lbStyle, BS_DIBPATTERN);
ok_long(logbrush.lbColor, 0);
ok_long(logbrush.lbHatch, (ULONG_PTR)&PackedDIB);
ok_err(ERROR_SUCCESS);
DeleteObject(hBrush);
}
static int MakeService(SC_HANDLE hScm, const wchar_t *serviceName, SC_HANDLE *hService, DWORD *tag)
{
DWORD ret;
HKEY hKey = NULL;
DWORD type = 0, tagData = 0, tagSize;
wchar_t keyName[256];
SetLastError(DNS_ERROR_RCODE_NXRRSET);
*hService = CreateServiceW(
hScm,
serviceName,
NULL,
DELETE,
SERVICE_KERNEL_DRIVER,
SERVICE_BOOT_START,
SERVICE_ERROR_IGNORE,
L"%systemroot%\\drivers\\win32k.sys",
L"advapi32_apitest_CreateService_Test_Group",
tag,
NULL,
NULL,
NULL);
ok(*hService != NULL, "Failed to create service, error=0x%08lx\n", GetLastError());
if (!*hService)
{
skip("No service; cannot proceed with CreateService test\n");
return 1;
}
ok_err(ERROR_SUCCESS);
ok(*tag != 0, "tag is zero, expected nonzero\n");
StringCbPrintfW(keyName, sizeof keyName, L"System\\CurrentControlSet\\Services\\%ls", serviceName);
ret = RegOpenKeyW(HKEY_LOCAL_MACHINE, keyName, &hKey);
ok(ret == ERROR_SUCCESS, "RegOpenKeyW failed with 0x%08lx\n", ret);
if (ret)
{
skip("No regkey; cannot proceed with CreateService test\n");
return 2;
}
tagSize = sizeof tagData;
ret = RegQueryValueExW(hKey, L"Tag", NULL, &type, (PBYTE)&tagData, &tagSize);
ok(ret == ERROR_SUCCESS, "RegQueryValueExW returned 0x%08lx\n", ret);
ok(type == REG_DWORD, "type=%lu, expected REG_DWORD\n", type);
ok(tagSize == sizeof tagData, "tagSize=%lu, expected 4\n", tagSize);
ok(tagData == *tag, "tag=%lu, but registry says %lu\n", *tag, tagData);
RegCloseKey(hKey);
return 0;
}
void
Test_Colorspace(void)
{
UCHAR buffer[1000];
SetLastError(ERROR_SUCCESS);
GetObjectA((HANDLE)GDI_OBJECT_TYPE_COLORSPACE, 0, NULL);
//ok(GetObjectA((HANDLE)GDI_OBJECT_TYPE_COLORSPACE, 0, NULL) == 60, "\n");// FIXME: what structure? fails on win7
ok_err(ERROR_INSUFFICIENT_BUFFER);
SetLastError(ERROR_SUCCESS);
ok(GetObjectW((HANDLE)GDI_OBJECT_TYPE_COLORSPACE, 0, NULL) == 0, "\n");
ok_err(ERROR_INSUFFICIENT_BUFFER);
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)GDI_OBJECT_TYPE_COLORSPACE, 327, buffer) == 0, "\n");
ok_err(ERROR_INSUFFICIENT_BUFFER);
ok(GetObjectA((HANDLE)GDI_OBJECT_TYPE_COLORSPACE, 328, buffer) == 0, "\n");
ok_err(ERROR_INVALID_PARAMETER);
//ok_long(GetObjectA((HANDLE)GDI_OBJECT_TYPE_COLORSPACE, 328, NULL), 0); // FIXME: fails on WHS
//ok_err(ERROR_INSUFFICIENT_BUFFER);
}
void
Test_Dibsection(void)
{
BITMAPINFO bmi = {{sizeof(BITMAPINFOHEADER), 10, 9, 1, 16, BI_RGB, 0, 10, 10, 0,0}};
HBITMAP hBitmap;
BITMAP bitmap;
DIBSECTION dibsection;
PVOID pData;
HDC hDC;
FillMemory(&dibsection, sizeof(DIBSECTION), 0x77);
hDC = GetDC(0);
hBitmap = CreateDIBSection(hDC, &bmi, DIB_RGB_COLORS, &pData, NULL, 0);
ok(hBitmap != 0, "CreateDIBSection failed with %ld, skipping tests.\n", GetLastError());
if (!hBitmap) return;
ok(GetObjectA((HANDLE)((UINT_PTR)hBitmap & 0x0000ffff), 0, NULL) == sizeof(BITMAP), "\n");
ok(GetObjectW((HANDLE)((UINT_PTR)hBitmap & 0x0000ffff), 0, NULL) == sizeof(BITMAP), "\n");
SetLastError(ERROR_SUCCESS);
ok_long(GetObject(hBitmap, sizeof(DIBSECTION), NULL), sizeof(BITMAP));
ok_long(GetObject(hBitmap, 0, NULL), sizeof(BITMAP));
ok_long(GetObject(hBitmap, 5, NULL), sizeof(BITMAP));
ok_long(GetObject(hBitmap, -5, NULL), sizeof(BITMAP));
ok_long(GetObject(hBitmap, 0, &dibsection), 0);
ok_long(GetObject(hBitmap, 5, &dibsection), 0);
ok_long(GetObject(hBitmap, sizeof(BITMAP), &bitmap), sizeof(BITMAP));
ok_long(GetObject(hBitmap, sizeof(BITMAP)+2, &bitmap), sizeof(BITMAP));
ok_long(bitmap.bmType, 0);
ok_long(bitmap.bmWidth, 10);
ok_long(bitmap.bmHeight, 9);
ok_long(bitmap.bmWidthBytes, 20);
ok_long(bitmap.bmPlanes, 1);
ok_long(bitmap.bmBitsPixel, 16);
ok(bitmap.bmBits == pData, "\n");
ok_long(GetObject(hBitmap, sizeof(DIBSECTION), &dibsection), sizeof(DIBSECTION));
ok_long(GetObject(hBitmap, sizeof(DIBSECTION)+2, &dibsection), sizeof(DIBSECTION));
ok_long(GetObject(hBitmap, -5, &dibsection), sizeof(DIBSECTION));
ok_err(ERROR_SUCCESS);
DeleteObject(hBitmap);
ReleaseDC(0, hDC);
}
void Test_CreateBitmap_Params()
{
HBITMAP hbmp;
/* All of these should get us the default bitmap */
hbmp = CreateBitmap(0, 0, 0, 0, NULL);
ok(hbmp == GetStockObject(21), "should get the default bitmap\n");
hbmp = CreateBitmap(1, 0, 0, 0, NULL);
ok(hbmp == GetStockObject(21), "should get the default bitmap\n");
hbmp = CreateBitmap(0, 1, 0, 0, NULL);
ok(hbmp == GetStockObject(21), "should get the default bitmap\n");
hbmp = CreateBitmap(0, 1, 1, 0, NULL);
ok(hbmp == GetStockObject(21), "should get the default bitmap\n");
hbmp = CreateBitmap(0, 1, 63, 33, NULL);
ok(hbmp == GetStockObject(21), "should get the default bitmap\n");
hbmp = CreateBitmap(0, -4, -32, 233, NULL);
ok(hbmp == GetStockObject(21), "should get the default bitmap\n");
SetLastError(0);
hbmp = CreateBitmap(1, -1, 1, 0, NULL);
ok(hbmp == 0, "CreateBitmap should fail\n");
ok_err(ERROR_INVALID_PARAMETER);
SetLastError(0);
hbmp = CreateBitmap(-1, 1, 1, 0, NULL);
ok(hbmp == 0, "CreateBitmap should fail\n");
ok_err(ERROR_INVALID_PARAMETER);
SetLastError(0);
hbmp = CreateBitmap(-1, 1, 1, 1, NULL);
ok(hbmp == 0, "CreateBitmap should fail\n");
ok_err(ERROR_INVALID_PARAMETER);
SetLastError(0);
hbmp = CreateBitmap(1, -1, 1, 1, NULL);
ok(hbmp == 0, "CreateBitmap should fail\n");
ok_err(ERROR_INVALID_PARAMETER);
/* Check if an overflow in cPlanes * cBitsPixel is handled */
SetLastError(0);
hbmp = CreateBitmap(1, 1, 2, 0x80000004, NULL);
ok(hbmp == 0, "CreateBitmap should fail\n");
ok_err(ERROR_INVALID_PARAMETER);
/* Check for maximum width */
hbmp = CreateBitmap(0x7FFFFFF, 1, 1, 1, NULL);
ok(hbmp != 0, "CreateBitmap failed\n");
DeleteObject(hbmp);
SetLastError(0);
hbmp = CreateBitmap(0x8000000, 1, 1, 1, NULL);
ok(hbmp == 0, "CreateBitmap should fail\n");
ok_err(ERROR_INVALID_PARAMETER);
/* Check for maximum height */
hbmp = CreateBitmap(1, 0x1FFFFF00, 1, 1, NULL);
//ok(hbmp != 0, "\n"); // fails on windows 2003
DeleteObject(hbmp);
SetLastError(0);
hbmp = CreateBitmap(1, 0x1FFFFFFF, 1, 1, NULL);
ok(hbmp == 0, "CreateBitmap should fail\n");
ok_err(0);
SetLastError(0);
hbmp = CreateBitmap(1, -1, 1, 1, NULL);
ok(hbmp == 0, "CreateBitmap should fail\n");
ok_err(ERROR_INVALID_PARAMETER);
/* Test huge allocation (256 GB) */
SetLastError(0);
hbmp = CreateBitmap(0x40000, 0x40000, 32, 1, NULL);
ok(hbmp == 0, "CreateBitmap should fail\n");
ok_err(ERROR_INVALID_PARAMETER);
/* Test planes / bpp */
hbmp = CreateBitmap(10, 10, 32, 1, NULL);
ok(hbmp != 0, "CreateBitmap failed\n");
DeleteObject(hbmp);
hbmp = CreateBitmap(10, 10, 5, 5, NULL);
ok(hbmp != 0, "CreateBitmap failed\n");
DeleteObject(hbmp);
SetLastError(0);
hbmp = CreateBitmap(10, 10, 33, 1, NULL);
ok(hbmp == 0, "CreateBitmap should fail\n");
ok_err(ERROR_INVALID_PARAMETER);
SetLastError(0);
hbmp = CreateBitmap(10, 10, 1, 33, NULL);
ok(hbmp == 0, "CreateBitmap should fail\n");
ok_err(ERROR_INVALID_PARAMETER);
SetLastError(0);
hbmp = CreateBitmap(10, 10, 6, 6, NULL);
ok(hbmp == 0, "CreateBitmap should fail\n");
ok_err(ERROR_INVALID_PARAMETER);
SetLastError(0);
hbmp = CreateBitmap(10, 10, 8, 8, NULL);
ok(hbmp == 0, "CreateBitmap should fail\n");
ok_err(ERROR_INVALID_PARAMETER);
}
void Test_GetRandomRgn_Params()
{
HDC hdc;
HRGN hrgn;
INT ret;
hdc = CreateCompatibleDC(0);
if (!hdc)
{
printf("Coun't create a dc\n");
return;
}
hrgn = CreateRectRgn(11, 17, 23, 42);
if (!hrgn)
{
printf("Coun't create a region\n");
return;
}
SetLastError(0xbadbad00);
ret = GetRandomRgn(NULL, NULL, 0);
ok_int(ret, -1);
ok((GetLastError() == 0xbadbad00) || (GetLastError() == ERROR_INVALID_HANDLE), "wrong error: %ld\n", GetLastError());
SetLastError(0xbadbad00);
ret = GetRandomRgn(NULL, NULL, CLIPRGN);
ok_int(ret, -1);
ok((GetLastError() == 0xbadbad00) || (GetLastError() == ERROR_INVALID_HANDLE), "wrong error: %ld\n", GetLastError());
SetLastError(0xbadbad00);
ret = GetRandomRgn(NULL, hrgn, 0);
ok_int(ret, -1);
ok((GetLastError() == 0xbadbad00) || (GetLastError() == ERROR_INVALID_HANDLE), "wrong error: %ld\n", GetLastError());
SetLastError(0xbadbad00);
ret = GetRandomRgn(NULL, hrgn, CLIPRGN);
ok_int(ret, -1);
ok((GetLastError() == 0xbadbad00) || (GetLastError() == ERROR_INVALID_HANDLE), "wrong error: %ld\n", GetLastError());
SetLastError(0xbadbad00);
ret = GetRandomRgn(hdc, NULL, 0);
ok_int(ret, 0);
ok_err(0xbadbad00);
SetLastError(0xbadbad00);
ret = GetRandomRgn(hdc, NULL, CLIPRGN);
ok_int(ret, 0);
ok_err(0xbadbad00);
SetLastError(0xbadbad00);
ret = GetRandomRgn(hdc, hrgn, 0);
ok_int(ret, 0);
ok_err(0xbadbad00);
#if 0 // this is vista+
SetLastError(0xbadbad00);
ret = GetRandomRgn(hdc, hrgn, 5);
ok_int(ret, 1);
ok_err(0xbadbad00);
#endif
SetLastError(0xbadbad00);
ret = GetRandomRgn(hdc, hrgn, 6);
ok_int(ret, 0);
ok_err(0xbadbad00);
SetLastError(0xbadbad00);
ret = GetRandomRgn(hdc, hrgn, 27);
ok_int(ret, 0);
ok_err(0xbadbad00);
SetLastError(0xbadbad00);
ret = GetRandomRgn(hdc, hrgn, -1);
ok_int(ret, 0);
ok_err(0xbadbad00);
SetLastError(0xbadbad00);
ret = GetRandomRgn(hdc, hrgn, CLIPRGN);
ok_int(ret, 0);
ok_err(0xbadbad00);
SetLastError(0xbadbad00);
ret = GetRandomRgn((HDC)0x123, hrgn, CLIPRGN);
ok_int(ret, -1);
ok((GetLastError() == 0xbadbad00) || (GetLastError() == ERROR_INVALID_HANDLE), "wrong error: %ld\n", GetLastError());
DeleteObject(hrgn);
DeleteDC(hdc);
}
void Test_PatBlt_Params()
{
BOOL ret;
ULONG i, rop;
HDC hdc;
/* Test a rop that contains only the operation index */
ret = PatBlt(hdcTarget, 0, 0, 1, 1, PATCOPY & 0x00FF0000);
ok_long(ret, 1);
/* Test a rop that contains arbitrary values outside the operation index */
ret = PatBlt(hdcTarget, 0, 0, 1, 1, (PATCOPY & 0x00FF0000) | 0xab00cdef);
ok_long(ret, 1);
/* Test an invalid rop */
SetLastError(0);
ok_long(PatBlt(hdcTarget, 0, 0, 1, 1, SRCCOPY) , 0);
ok_err(0);
/* Test all rops */
for (i = 0; i < 256; i++)
{
rop = i << 16;
ret = PatBlt(hdcTarget, 0, 0, 1, 1, rop);
/* Only these should succeed (they use no source) */
if ((i == 0) || (i == 5) || (i == 10) || (i == 15) || (i == 80) ||
(i == 85) || (i == 90) || (i == 95) || (i == 160) || (i == 165) ||
(i == 170) || (i == 175) || (i == 240) || (i == 245) ||
(i == 250) || (i == 255))
{
ok(ret == 1, "index %ld failed, but should succeed\n", i);
}
else
{
ok(ret == 0, "index %ld succeeded, but should fail\n", i);
}
}
/* Test quaternary rop, the background part is simply ignored */
ret = PatBlt(hdcTarget, 0, 0, 1, 1, MAKEROP4(PATCOPY, PATINVERT));
ok_long(ret, 1);
ret = PatBlt(hdcTarget, 0, 0, 1, 1, MAKEROP4(PATCOPY, SRCCOPY));
ok_long(ret, 1);
ret = PatBlt(hdcTarget, 0, 0, 1, 1, MAKEROP4(SRCCOPY, PATCOPY));
ok_long(ret, 0);
/* Test an info DC */
hdc = CreateICA("DISPLAY", NULL, NULL, NULL);
ok(hdc != 0, "\n");
SetLastError(0);
ok_long(PatBlt(hdc, 0, 0, 1, 1, PATCOPY), 1);
ok_err(0);
DeleteDC(hdc);
/* Test a mem DC without selecting a bitmap */
hdc = CreateCompatibleDC(NULL);
ok(hdc != 0, "\n");
ok_long(PatBlt(hdc, 0, 0, 1, 1, PATCOPY), 1);
ok_err(0);
DeleteDC(hdc);
}
void
Test_CreateDIBitmap_Params(void)
{
HBITMAP hbmp;
HDC hdc;
BITMAPINFO bmi =
{{sizeof(BITMAPINFOHEADER), 4, 4, 1, 8, BI_RGB, 0, 1, 1, 1, 0}, {{0,0,0,0}}};
BITMAPINFO bmiBroken =
{{0, -2, -4, 55, 42, 21, 0, 1, 1, 1, 0}, {{0,0,0,0}}};
BYTE ajBits[10];
hdc = CreateCompatibleDC(0);
ok(hdc != 0, "failed\n");
hbmp = CreateDIBitmap(hdc, &bmi.bmiHeader, CBM_INIT, ajBits, &bmi, DIB_PAL_COLORS);
ok(hbmp != 0, "\n");
hbmp = CreateDIBitmap(hdc, &bmi.bmiHeader, CBM_INIT, NULL, &bmi, DIB_PAL_COLORS);
ok(hbmp != 0, "\n");
hbmp = CreateDIBitmap(hdc, &bmi.bmiHeader, CBM_INIT, NULL, NULL, DIB_PAL_COLORS);
ok(hbmp != 0, "\n");
hbmp = CreateDIBitmap(hdc, &bmi.bmiHeader, 0, (PVOID)0xc0000000, &bmi, DIB_PAL_COLORS);
ok(hbmp != 0, "\n");
hbmp = CreateDIBitmap(NULL, &bmi.bmiHeader, CBM_INIT, NULL, &bmi, DIB_PAL_COLORS);
ok(hbmp != 0, "\n");
hbmp = CreateDIBitmap(hdc, &bmi.bmiHeader, CBM_INIT, NULL, &bmiBroken, DIB_PAL_COLORS);
ok(hbmp != 0, "\n");
hbmp = CreateDIBitmap(NULL, NULL, 2, NULL, &bmi, 0);
ok(hbmp != 0, "\n");
SetLastError(0xbadbad00);
hbmp = CreateDIBitmap(hdc, NULL, CBM_INIT, ajBits, &bmi, DIB_PAL_COLORS);
ok(hbmp == 0, "\n");
ok_err(ERROR_INVALID_PARAMETER);
SetLastError(0xbadbad00);
hbmp = CreateDIBitmap(hdc, NULL, CBM_INIT, NULL, &bmiBroken, DIB_PAL_COLORS);
ok(hbmp == 0, "\n");
ok_err(ERROR_INVALID_PARAMETER);
SetLastError(0xbadbad00);
hbmp = CreateDIBitmap(hdc, &bmi.bmiHeader, CBM_INIT, ajBits, &bmi, 2);
ok(hbmp == 0, "\n");
ok_err(ERROR_INVALID_PARAMETER);
SetLastError(0xbadbad00);
hbmp = CreateDIBitmap(hdc, &bmi.bmiHeader, CBM_INIT, ajBits, NULL, DIB_PAL_COLORS);
ok(hbmp == 0, "\n");
ok_err(0xbadbad00);
SetLastError(0xbadbad00);
hbmp = CreateDIBitmap(hdc, &bmi.bmiHeader, CBM_INIT, (PVOID)0xc0000000, &bmi, DIB_PAL_COLORS);
ok(hbmp == 0, "\n");
ok_err(0xbadbad00);
SetLastError(0xbadbad00);
_SEH2_TRY
{
hbmp = CreateDIBitmap(hdc, &bmi.bmiHeader, 0, ajBits, (PVOID)0xc0000000, DIB_PAL_COLORS);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
hbmp = (HBITMAP)-1;
}
_SEH2_END;
ok(hbmp == (HBITMAP)-1, "\n");
ok_err(0xbadbad00);
SetLastError(0xbadbad00);
hbmp = CreateDIBitmap(hdc, &bmi.bmiHeader, CBM_INIT, NULL, NULL, 5);
ok(hbmp == 0, "\n");
ok_err(ERROR_INVALID_PARAMETER);
SetLastError(0xbadbad00);
hbmp = CreateDIBitmap((HDC)-1, &bmi.bmiHeader, CBM_INIT, NULL, &bmi, DIB_PAL_COLORS);
ok(hbmp == 0, "\n");
ok_err(0xbadbad00);
SetLastError(0xbadbad00);
hbmp = CreateDIBitmap(hdc, &bmiBroken.bmiHeader, CBM_INIT, NULL, &bmi, DIB_PAL_COLORS);
ok(hbmp == 0, "\n");
ok_err(ERROR_INVALID_PARAMETER);
if (1)
{
ULONG i1, i2, i3, i4, i5, i6;
HDC ahdc[3] = {0, hdc, (HDC)-1};
PBITMAPINFOHEADER apbih[4] = {NULL, &bmi.bmiHeader, &bmiBroken.bmiHeader, (PVOID)0xC0000000};
ULONG afInitf[12] = {0, 1, 2, 3, CBM_INIT, 4, 5, 6, 7, 8, 0x10, 0x20};
PVOID apvBits[3] = {NULL, ajBits, (PVOID)0xc0000000};
PBITMAPINFO apbmi[4] = {NULL, &bmi, &bmiBroken, (PVOID)0xC0000000};
ULONG aiUsage[5] = {0, 1, 2, 3, 23};
DWORD dwExpError;
BOOL bExpSuccess;
for (i1 = 0; i1 < 3; i1++)
{
for (i2 = 0; i2 < 4; i2++)
{
for (i3 = 0; i3 < 8; i3++)
{
for (i4 = 0; i4 < 3; i4++)
{
for (i5 = 0; i5 < 4; i5++)
{
for (i6 = 0; i6 < 5; i6++)
{
SetLastError(0xbadbad00);
dwExpError = 0xbadbad00;
bExpSuccess = GetExpected(&dwExpError, ahdc[i1], apbih[i2], afInitf[i3], apvBits[i4], apbmi[i5], aiUsage[i6]);
_SEH2_TRY
{
hbmp = CreateDIBitmap(ahdc[i1], apbih[i2], afInitf[i3], apvBits[i4], apbmi[i5], aiUsage[i6]);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
hbmp = (HBITMAP)0;
}
_SEH2_END;
if (bExpSuccess)
{
ok(hbmp != 0, "Expected success for (%ld,%ld,%ld,%ld,%ld,%ld) CreateDIBitmap(%p, %p, 0x%lx, %p, %p, %ld)\n",
i1, i2, i3, i4, i5, i6,
ahdc[i1], apbih[i2], afInitf[i3], apvBits[i4], apbmi[i5], aiUsage[i6]);
}
else
{
ok(hbmp == 0, "Expected failure for (%ld,%ld,%ld,%ld,%ld,%ld) CreateDIBitmap(%p, %p, 0x%lx, %p, %p, %ld)\n",
i1, i2, i3, i4, i5, i6,
ahdc[i1], apbih[i2], afInitf[i3], apvBits[i4], apbmi[i5], aiUsage[i6]);
}
// ok(GetLastError() == dwExpError, "Expected error %ld got %ld for (%ld,%ld,%ld,%ld,%ld,%ld) CreateDIBitmap(%p, %p, 0x%lx, %p, %p, %ld)\n",
// dwExpError, GetLastError(), i1, i2, i3, i4, i5, i6,
// ahdc[i1], apbih[i2], afInitf[i3], apvBits[i4], apbmi[i5], aiUsage[i6]);
}
}
}
}
}
}
}
static void Test_CreateService(void)
{
SC_HANDLE hScm = NULL;
SC_HANDLE hService1 = NULL, hService2 = NULL;
SC_HANDLE hService3 = NULL;
DWORD tag1 = 0, tag2 = 0;
DWORD tag3 = 785;
SetLastError(DNS_ERROR_RCODE_NXRRSET);
hScm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
if (!hScm)
{
skip("No service control manager; cannot proceed with CreateService test\n");
goto cleanup;
}
ok_err(ERROR_SUCCESS);
if (MakeService(hScm, L"advapi32_apitest_CreateService_Test_Service1", &hService1, &tag1))
goto cleanup;
if (MakeService(hScm, L"advapi32_apitest_CreateService_Test_Service2", &hService2, &tag2))
goto cleanup;
ok(tag1 != tag2, "tag1=%lu, tag2=%lu\n", tag1, tag2);
/* ask for a tag, but don't have a group */
hService3 = CreateServiceW(
hScm,
L"advapi32_apitest_CreateService_Test_Service2",
NULL,
DELETE,
SERVICE_KERNEL_DRIVER,
SERVICE_BOOT_START,
SERVICE_ERROR_IGNORE,
L"%systemroot%\\drivers\\win32k.sys",
NULL,
&tag3,
NULL,
NULL,
NULL);
ok(hService3 == NULL, "hService3=%p\n", hService3);
ok(GetLastError() == ERROR_INVALID_PARAMETER, "error=%lu\n", GetLastError());
ok(tag3 == 785, "tag3=%lu\n", tag3);
DestroyService(hService3);
hService3 = CreateServiceW(
hScm,
L"advapi32_apitest_CreateService_Test_Service2",
NULL,
DELETE,
SERVICE_KERNEL_DRIVER,
SERVICE_BOOT_START,
SERVICE_ERROR_IGNORE,
L"%systemroot%\\drivers\\win32k.sys",
L"",
&tag3,
NULL,
NULL,
NULL);
ok(hService3 == NULL, "hService3=%p\n", hService3);
ok(GetLastError() == ERROR_INVALID_PARAMETER, "error=%lu\n", GetLastError());
ok(tag3 == 785, "tag3=%lu\n", tag3);
DestroyService(hService3);
cleanup:
DestroyService(hService2);
DestroyService(hService1);
if (hScm)
CloseServiceHandle(hScm);
}
static void Test_QueryLockStatusA(void)
{
BOOL bError = FALSE;
SC_HANDLE hScm = NULL;
SC_LOCK hLock = NULL;
LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus = NULL;
DWORD dwRequiredSize = 0;
/* Firstly try to get lock status with invalid handles */
SetLastError(0xdeadbeef);
bError = QueryServiceLockStatusA(hScm,
NULL,
0,
&dwRequiredSize);
ok(bError == FALSE && GetLastError() == ERROR_INVALID_HANDLE, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INVALID_HANDLE);
ok(dwRequiredSize == 0, "dwRequiredSize is non-zero, expected zero\n");
/* Open the services database without having rights */
SetLastError(0xdeadbeef);
hScm = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
if (!hScm)
{
skip("No service control manager; cannot proceed with QueryLockStatusA test\n");
goto cleanup;
}
ok_err(ERROR_SUCCESS);
/* Try to get lock status */
SetLastError(0xdeadbeef);
bError = QueryServiceLockStatusA(hScm,
NULL,
0,
&dwRequiredSize);
ok(bError == FALSE && GetLastError() == ERROR_ACCESS_DENIED, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_ACCESS_DENIED);
ok(dwRequiredSize == 0, "dwRequiredSize is non-zero, expected zero\n");
CloseServiceHandle(hScm);
/*
* Query only the lock status.
*/
SetLastError(0xdeadbeef);
hScm = OpenSCManagerA(NULL, NULL, SC_MANAGER_QUERY_LOCK_STATUS);
ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
if (!hScm)
{
skip("No service control manager; cannot proceed with QueryLockStatusA test\n");
goto cleanup;
}
ok_err(ERROR_SUCCESS);
/* Get the needed size */
SetLastError(0xdeadbeef);
bError = QueryServiceLockStatusA(hScm,
NULL,
0,
&dwRequiredSize);
ok(bError == FALSE && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INSUFFICIENT_BUFFER);
ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
if (dwRequiredSize == 0)
{
skip("Required size is null; cannot proceed with QueryLockStatusA test\n");
goto cleanup;
}
/* Allocate memory */
lpLockStatus = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
if (lpLockStatus == NULL)
{
skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
goto cleanup;
}
/* Get the actual value */
SetLastError(0xdeadbeef);
bError = QueryServiceLockStatusA(hScm,
lpLockStatus,
dwRequiredSize,
&dwRequiredSize);
ok(bError, "bError = %u, expected TRUE\n", bError);
/* These conditions must be verified iff the services database wasn't previously locked */
ok(lpLockStatus->fIsLocked == 0, "lpLockStatus->fIsLocked = %lu, expected 0\n", lpLockStatus->fIsLocked);
ok(lpLockStatus->lpLockOwner != NULL, "lpLockStatus->lpLockOwner is null, expected non-null\n");
ok(lpLockStatus->lpLockOwner && *lpLockStatus->lpLockOwner == 0, "*lpLockStatus->lpLockOwner != \"\\0\", expected \"\\0\"\n");
ok(lpLockStatus->dwLockDuration == 0, "lpLockStatus->dwLockDuration = %lu, expected 0\n", lpLockStatus->dwLockDuration);
HeapFree(GetProcessHeap(), 0, lpLockStatus);
CloseServiceHandle(hScm);
/*
* Now, try to lock the database and check its lock status.
*/
SetLastError(0xdeadbeef);
hScm = OpenSCManagerA(NULL, NULL, SC_MANAGER_LOCK | SC_MANAGER_QUERY_LOCK_STATUS);
ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
if (!hScm)
{
skip("No service control manager; cannot proceed with QueryLockStatusA test\n");
goto cleanup;
}
ok_err(ERROR_SUCCESS);
/* Get the needed size */
SetLastError(0xdeadbeef);
bError = QueryServiceLockStatusA(hScm,
NULL,
0,
&dwRequiredSize);
ok(bError == FALSE && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INSUFFICIENT_BUFFER);
ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
if (dwRequiredSize == 0)
{
skip("Required size is null; cannot proceed with QueryLockStatusA test\n");
goto cleanup;
}
/* Allocate memory */
lpLockStatus = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
if (lpLockStatus == NULL)
{
skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
goto cleanup;
}
/* Get the actual value */
SetLastError(0xdeadbeef);
bError = QueryServiceLockStatusA(hScm,
lpLockStatus,
dwRequiredSize,
&dwRequiredSize);
ok(bError, "bError = %u, expected TRUE\n", bError);
/* These conditions must be verified iff the services database wasn't previously locked */
ok(lpLockStatus->fIsLocked == 0, "lpLockStatus->fIsLocked = %lu, expected 0\n", lpLockStatus->fIsLocked);
ok(lpLockStatus->lpLockOwner != NULL, "lpLockStatus->lpLockOwner is null, expected non-null\n");
ok(lpLockStatus->lpLockOwner && *lpLockStatus->lpLockOwner == 0, "*lpLockStatus->lpLockOwner != \"\\0\", expected \"\\0\"\n");
ok(lpLockStatus->dwLockDuration == 0, "lpLockStatus->dwLockDuration = %lu, expected 0\n", lpLockStatus->dwLockDuration);
HeapFree(GetProcessHeap(), 0, lpLockStatus);
/*
* Try again, this time with the database locked.
*/
SetLastError(0xdeadbeef);
hLock = LockServiceDatabase(hScm);
ok(hLock != NULL, "hLock = 0x%p, expected non-zero\n", hLock);
ok_err(ERROR_SUCCESS);
Sleep(1000); /* Wait 1 second to let lpLockStatus->dwLockDuration increment */
/* Get the needed size */
SetLastError(0xdeadbeef);
bError = QueryServiceLockStatusA(hScm,
NULL,
0,
&dwRequiredSize);
ok(bError == FALSE && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INSUFFICIENT_BUFFER);
ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
if (dwRequiredSize == 0)
{
skip("Required size is null; cannot proceed with QueryLockStatusA test\n");
goto cleanup;
}
/* Allocate memory */
lpLockStatus = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
if (lpLockStatus == NULL)
{
skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
goto cleanup;
}
/* Get the actual value */
SetLastError(0xdeadbeef);
bError = QueryServiceLockStatusA(hScm,
lpLockStatus,
dwRequiredSize,
&dwRequiredSize);
ok(bError, "bError = %u, expected TRUE\n", bError);
/* These conditions must be verified iff the services database is locked */
ok(lpLockStatus->fIsLocked != 0, "lpLockStatus->fIsLocked = %lu, expected non-zero\n", lpLockStatus->fIsLocked);
ok(lpLockStatus->lpLockOwner != NULL, "lpLockStatus->lpLockOwner is null, expected non-null\n");
ok(lpLockStatus->lpLockOwner && *lpLockStatus->lpLockOwner != 0, "*lpLockStatus->lpLockOwner = \"\\0\", expected non-zero\n");
ok(lpLockStatus->dwLockDuration != 0, "lpLockStatus->dwLockDuration = %lu, expected non-zero\n", lpLockStatus->dwLockDuration);
HeapFree(GetProcessHeap(), 0, lpLockStatus);
/*
* Last try, with the database again unlocked.
*/
SetLastError(0xdeadbeef);
bError = UnlockServiceDatabase(hLock);
ok(bError == TRUE, "bError = %u, expected TRUE\n", bError);
ok_err(ERROR_SUCCESS);
hLock = NULL;
/* Get the needed size */
SetLastError(0xdeadbeef);
bError = QueryServiceLockStatusA(hScm,
NULL,
0,
&dwRequiredSize);
ok(bError == FALSE && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INSUFFICIENT_BUFFER);
ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
if (dwRequiredSize == 0)
{
skip("Required size is null; cannot proceed with QueryLockStatusA test\n");
goto cleanup;
}
/* Allocate memory */
lpLockStatus = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
if (lpLockStatus == NULL)
{
skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
goto cleanup;
}
/* Get the actual value */
SetLastError(0xdeadbeef);
bError = QueryServiceLockStatusA(hScm,
lpLockStatus,
dwRequiredSize,
&dwRequiredSize);
ok(bError, "bError = %u, expected TRUE\n", bError);
/* These conditions must be verified iff the services database is unlocked */
ok(lpLockStatus->fIsLocked == 0, "lpLockStatus->fIsLocked = %lu, expected 0\n", lpLockStatus->fIsLocked);
ok(lpLockStatus->lpLockOwner != NULL, "lpLockStatus->lpLockOwner is null, expected non-null\n");
ok(lpLockStatus->lpLockOwner && *lpLockStatus->lpLockOwner == 0, "*lpLockStatus->lpLockOwner != \"\\0\", expected \"\\0\"\n");
ok(lpLockStatus->dwLockDuration == 0, "lpLockStatus->dwLockDuration = %lu, expected 0\n", lpLockStatus->dwLockDuration);
HeapFree(GetProcessHeap(), 0, lpLockStatus);
cleanup:
if (hLock)
UnlockServiceDatabase(hLock);
if (hScm)
CloseServiceHandle(hScm);
return;
}
static void Test_LockUnlockServiceDatabase(void)
{
BOOL bError = FALSE;
SC_HANDLE hScm = NULL;
SC_LOCK hLock = NULL;
/* First of all, try to lock / unlock the services database with invalid handles */
SetLastError(0xdeadbeef);
hScm = NULL;
hLock = LockServiceDatabase(hScm);
ok(hLock == NULL, "hLock = 0x%p, expected 0\n", hLock);
ok_err(ERROR_INVALID_HANDLE);
SetLastError(0xdeadbeef);
hScm = (SC_HANDLE)0xdeadbeef;
hLock = LockServiceDatabase(hScm);
ok(hLock == NULL, "hLock = 0x%p, expected 0\n", hLock);
ok_err(ERROR_INVALID_HANDLE);
/** This test seems to make this application crash on Windows 7... I do not know why... **/
SetLastError(0xdeadbeef);
hLock = NULL;
bError = UnlockServiceDatabase(hLock);
ok(bError == FALSE, "bError = %u, expected FALSE\n", bError);
ok_err(ERROR_INVALID_SERVICE_LOCK);
/*****************************************************************************************/
SetLastError(0xdeadbeef);
hLock = (SC_LOCK)0xdeadbeef;
bError = UnlockServiceDatabase(hLock);
ok(bError == FALSE, "bError = %u, expected FALSE\n", bError);
ok_err(ERROR_INVALID_SERVICE_LOCK);
/* Then, try to lock the services database without having rights */
SetLastError(0xdeadbeef);
hScm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
if (!hScm)
{
skip("No service control manager; cannot proceed with LockUnlockServiceDatabase test\n");
goto cleanup;
}
ok_err(ERROR_SUCCESS);
SetLastError(0xdeadbeef);
hLock = LockServiceDatabase(hScm);
ok(hLock == NULL, "hLock = 0x%p, expected 0\n", hLock);
ok_err(ERROR_ACCESS_DENIED);
if (hLock)
UnlockServiceDatabase(hLock);
CloseServiceHandle(hScm);
/* Try to lock the services database with good rights */
SetLastError(0xdeadbeef);
hScm = OpenSCManagerW(NULL, NULL, SC_MANAGER_LOCK);
ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
if (!hScm)
{
skip("No service control manager; cannot proceed with LockUnlockServiceDatabase test\n");
goto cleanup;
}
ok_err(ERROR_SUCCESS);
SetLastError(0xdeadbeef);
hLock = LockServiceDatabase(hScm);
ok(hLock != NULL, "hLock = 0x%p, expected non-zero\n", hLock);
ok_err(ERROR_SUCCESS);
/* Now unlock it */
if (hLock)
{
SetLastError(0xdeadbeef);
bError = UnlockServiceDatabase(hLock);
ok(bError == TRUE, "bError = %u, expected TRUE\n", bError);
ok_err(ERROR_SUCCESS);
}
cleanup:
if (hScm)
CloseServiceHandle(hScm);
return;
}
static void Test_LockUnlockServiceDatabaseWithServiceStart(void)
{
BOOL bError = FALSE;
SC_HANDLE hScm = NULL;
SC_HANDLE hSvc = NULL;
SC_LOCK hLock = NULL;
LPQUERY_SERVICE_CONFIGW lpConfig = NULL;
DWORD dwRequiredSize = 0;
SERVICE_STATUS status;
BOOL bWasRunning = FALSE;
DWORD dwOldStartType = 0;
/* Open the services database */
SetLastError(0xdeadbeef);
hScm = OpenSCManagerW(NULL, NULL, SC_MANAGER_LOCK);
ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
if (!hScm)
{
skip("No service control manager; cannot proceed with LockUnlockServiceDatabaseWithServiceStart test\n");
goto cleanup;
}
ok_err(ERROR_SUCCESS);
/* Grab a handle to the testing service */
SetLastError(0xdeadbeef);
hSvc = OpenServiceW(hScm, TESTING_SERVICE, SERVICE_START | SERVICE_STOP | SERVICE_CHANGE_CONFIG | SERVICE_QUERY_CONFIG | SERVICE_QUERY_STATUS);
ok(hSvc != NULL, "hSvc = 0x%p, expected non-null, error=0x%08lx\n", hSvc, GetLastError());
if (!hSvc)
{
skip("Cannot open a handle to service %S; cannot proceed with LockUnlockServiceDatabaseWithServiceStart test\n", TESTING_SERVICE);
goto cleanup;
}
ok_err(ERROR_SUCCESS);
/* Lock the services database */
SetLastError(0xdeadbeef);
hLock = LockServiceDatabase(hScm);
ok(hLock != NULL, "hLock = 0x%p, expected non-zero, error=0x%08lx\n", hLock, GetLastError());
if (!hLock)
{
skip("Cannot lock the services database; cannot proceed with LockUnlockServiceDatabaseWithServiceStart test\n");
goto cleanup;
}
ok_err(ERROR_SUCCESS);
/* To proceed further, firstly attempt to stop the testing service */
QueryServiceConfigW(hSvc, NULL, 0, &dwRequiredSize);
lpConfig = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
QueryServiceConfigW(hSvc, lpConfig, dwRequiredSize, &dwRequiredSize);
dwOldStartType = lpConfig->dwStartType;
HeapFree(GetProcessHeap(), 0, lpConfig);
if (dwOldStartType == SERVICE_DISABLED)
{
ChangeServiceConfigW(hSvc,
SERVICE_NO_CHANGE,
SERVICE_DEMAND_START,
SERVICE_NO_CHANGE,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL);
}
QueryServiceStatus(hSvc, &status);
bWasRunning = (status.dwCurrentState != SERVICE_STOPPED);
if (bWasRunning)
{
ControlService(hSvc, SERVICE_CONTROL_STOP, &status);
Sleep(1000); /* Wait 1 second for the service to stop */
}
/* Now try to start it (this test won't work under Windows Vista / 7 / 8) */
SetLastError(0xdeadbeef);
bError = StartServiceW(hSvc, 0, NULL);
ok(bError == FALSE, "bError = %u, expected FALSE\n", bError);
ok_err(ERROR_SERVICE_DATABASE_LOCKED);
Sleep(1000); /* Wait 1 second for the service to start */
/* Stop the testing service */
ControlService(hSvc, SERVICE_CONTROL_STOP, &status);
Sleep(1000); /* Wait 1 second for the service to stop */
/* Now unlock the services database */
SetLastError(0xdeadbeef);
bError = UnlockServiceDatabase(hLock);
ok(bError == TRUE, "bError = %u, expected TRUE\n", bError);
ok_err(ERROR_SUCCESS);
/* Try to start again the service, this time the database unlocked */
SetLastError(0xdeadbeef);
bError = StartServiceW(hSvc, 0, NULL);
ok(bError == TRUE, "bError = %u, expected TRUE\n", bError);
ok_err(ERROR_SUCCESS);
Sleep(1000); /* Wait 1 second for the service to start */
/* Stop the testing service */
ControlService(hSvc, SERVICE_CONTROL_STOP, &status);
Sleep(1000); /* Wait 1 second for the service to stop */
/* Restore its original state */
if (bWasRunning)
{
StartServiceW(hSvc, 0, NULL);
}
if (dwOldStartType == SERVICE_DISABLED)
{
ChangeServiceConfigW(hSvc,
SERVICE_NO_CHANGE,
SERVICE_DISABLED,
SERVICE_NO_CHANGE,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL);
}
cleanup:
if (hSvc)
CloseServiceHandle(hSvc);
if (hScm)
CloseServiceHandle(hScm);
return;
}
void
Test_General(void)
{
struct
{
LOGBRUSH logbrush;
BYTE additional[600];
} TestStruct;
PLOGBRUSH plogbrush;
HBRUSH hBrush;
HPEN hpen;
INT ret;
/* Test null pointer and invalid handles */
SetLastError(ERROR_SUCCESS);
ok(GetObjectA(0, 0, NULL) == 0, "\n");
ok(GetObjectA((HANDLE)-1, 0, NULL) == 0, "\n");
/* Test invalid habdles of different types */
ok(GetObjectA((HANDLE)0x00380000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
ok(GetObjectA((HANDLE)0x00380000, 10, &TestStruct) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x00010000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_INVALID_HANDLE, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x00020000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x00030000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x00040000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_INVALID_HANDLE, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x00060000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x00070000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x000B0000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x000C0000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x000D0000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x000E0000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x000F0000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x00110000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x00120000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x00130000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x00140000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x00150000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)0x00160000, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_SUCCESS, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)GDI_OBJECT_TYPE_DC, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_INVALID_HANDLE, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectW((HANDLE)GDI_OBJECT_TYPE_DC, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_INVALID_HANDLE, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)GDI_OBJECT_TYPE_REGION, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_INVALID_HANDLE, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectW((HANDLE)GDI_OBJECT_TYPE_REGION, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_INVALID_HANDLE, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)GDI_OBJECT_TYPE_EMF, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_INVALID_HANDLE, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectW((HANDLE)GDI_OBJECT_TYPE_EMF, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_INVALID_HANDLE, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)GDI_OBJECT_TYPE_METAFILE, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_INVALID_HANDLE, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectW((HANDLE)GDI_OBJECT_TYPE_METAFILE, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_INVALID_HANDLE, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectA((HANDLE)GDI_OBJECT_TYPE_ENHMETAFILE, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_INVALID_HANDLE, "\n");
SetLastError(ERROR_SUCCESS);
ok(GetObjectW((HANDLE)GDI_OBJECT_TYPE_ENHMETAFILE, 0, NULL) == 0, "\n");
ok(GetLastError() == ERROR_INVALID_HANDLE, "\n");
/* Test need of alignment */
SetLastError(ERROR_SUCCESS);
hBrush = GetStockObject(WHITE_BRUSH);
plogbrush = (PVOID)((ULONG_PTR)&TestStruct.logbrush);
ok(GetObject(hBrush, sizeof(LOGBRUSH), plogbrush) == sizeof(LOGBRUSH), "\n");
plogbrush = (PVOID)((ULONG_PTR)&TestStruct.logbrush + 2);
ok(GetObject(hBrush, sizeof(LOGBRUSH), plogbrush) == sizeof(LOGBRUSH), "\n");
plogbrush = (PVOID)((ULONG_PTR)&TestStruct.logbrush + 1);
//ok(GetObject(hBrush, sizeof(LOGBRUSH), plogbrush) == 0, "\n"); // fails on win7
/* Test invalid buffer */
SetLastError(0xbadbad00);
ok(GetObjectA(GetStockObject(WHITE_BRUSH), sizeof(LOGBRUSH), (PVOID)0xc0000000) == 0, "\n");
ok((GetLastError() == 0xbadbad00) || (GetLastError() == ERROR_NOACCESS), "wrong error: %ld\n", GetLastError());
SetLastError(0xbadbad00);
ok(GetObjectW(GetStockObject(BLACK_PEN), sizeof(LOGPEN), (PVOID)0xc0000000) == 0, "\n");
ok((GetLastError() == 0xbadbad00) || (GetLastError() == ERROR_NOACCESS), "wrong error: %ld\n", GetLastError());
SetLastError(0xbadbad00);
ok(GetObjectW(GetStockObject(21), sizeof(BITMAP), (PVOID)0xc0000000) == 0, "\n");
ok((GetLastError() == 0xbadbad00) || (GetLastError() == ERROR_NOACCESS), "wrong error: %ld\n", GetLastError());
SetLastError(0xbadbad00);
ok(GetObjectW(GetStockObject(SYSTEM_FONT), sizeof(LOGFONT), (PVOID)0xc0000000) == 0, "\n");
ok(GetLastError() == 0xbadbad00, "wrong error: %ld\n", GetLastError());
SetLastError(ERROR_SUCCESS);
_SEH2_TRY
{
ret = GetObjectA(GetStockObject(SYSTEM_FONT), sizeof(LOGFONT), (PVOID)0xc0000000);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
ret = -1;
}
_SEH2_END
ok(ret == -1, "should have got an exception\n");
ok(GetObjectW(GetStockObject(SYSTEM_FONT), 0x50000000, &TestStruct) == 356, "\n");
ok(GetObjectW(GetStockObject(WHITE_BRUSH), 0x50000000, &TestStruct) == sizeof(LOGBRUSH), "\n");
/* Test buffer size of 0 */
SetLastError(0xbadbad00);
hBrush = CreateSolidBrush(123);
ok(hBrush != NULL, "Failed to create brush\n");
ok_long(GetObjectA(hBrush, 0, &TestStruct), sizeof(LOGBRUSH));
ok_err(0xbadbad00);
DeleteObject(hBrush);
SetLastError(0xbadbad00);
hpen = CreatePen(PS_SOLID, 1, 123);
ok(hpen != NULL, "Failed to create pen\n");
ok_long(GetObjectA(hpen, 0, &TestStruct), 0);
ok((GetLastError() == 0xbadbad00) || (GetLastError() == ERROR_NOACCESS), "wrong error: %ld\n", GetLastError());
SetLastError(0xbadbad00);
TestStruct.logbrush.lbStyle = BS_SOLID;
TestStruct.logbrush.lbColor = RGB(1,2,3);
TestStruct.logbrush.lbHatch = 0;
hpen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID, 1, &TestStruct.logbrush, 0, NULL);
ok(hpen != NULL, "Failed to create pen\n");
ok_long(GetObjectA(hpen, 0, &TestStruct), 0);
ok((GetLastError() == 0xbadbad00) || (GetLastError() == ERROR_NOACCESS), "wrong error: %ld\n", GetLastError());
SetLastError(0xbadbad00);
ok(GetObjectW(GetStockObject(SYSTEM_FONT), 0, &TestStruct) == 0, "\n");
ok_err(0xbadbad00);
SetLastError(0xbadbad00);
ok(GetObjectW(GetStockObject(21), 0, &TestStruct) == 0, "\n");
ok_err(0xbadbad00);
}
