rostests/apitests/w32knapi/ntdd/NtGdiDdQueryDirectDrawObject.c

   1 #include "../w32knapi.h"
   2
   3 W32KAPI
   4 BOOL STDCALL
   5 NtGdiDdQueryDirectDrawObject(
   6     HANDLE hDirectDrawLocal,
   7     DD_HALINFO  *pHalInfo,
   8     DWORD *pCallBackFlags,
   9     LPD3DNTHAL_CALLBACKS puD3dCallbacks,
  10     LPD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData,
  11     PDD_D3DBUFCALLBACKS puD3dBufferCallbacks,
  12     LPDDSURFACEDESC puD3dTextureFormats,
  13     DWORD *puNumHeaps,
  14     VIDEOMEMORY *puvmList,
  15     DWORD *puNumFourCC,
  16     DWORD *puFourCC
  17 )
  18 {
  19         return (BOOL)Syscall(L"NtGdiDdQueryDirectDrawObject", 11, &hDirectDrawLocal);
  20 }
  21
  22 INT
  23 Test_NtGdiDdQueryDirectDrawObject(PTESTINFO pti)
  24 {
  25         HANDLE  hDirectDraw = NULL;
  26         DD_HALINFO *pHalInfo = NULL;
  27         DWORD *pCallBackFlags = NULL;
  28         LPD3DNTHAL_CALLBACKS puD3dCallbacks = NULL;
  29         LPD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData = NULL;
  30         PDD_D3DBUFCALLBACKS puD3dBufferCallbacks = NULL;
  31         LPDDSURFACEDESC puD3dTextureFormats = NULL;
  32         DWORD *puNumHeaps = NULL;
  33         VIDEOMEMORY *puvmList = NULL;
  34         DWORD *puNumFourCC = NULL;
  35         DWORD *puFourCC = NULL;
  36
  37         DD_HALINFO HalInfo;
  38         DD_HALINFO oldHalInfo;
  39         DWORD CallBackFlags[4];
  40         D3DNTHAL_CALLBACKS D3dCallbacks;
  41         D3DNTHAL_GLOBALDRIVERDATA D3dDriverData;
  42         DD_D3DBUFCALLBACKS D3dBufferCallbacks;
  43         DDSURFACEDESC2 D3dTextureFormats[100];
  44         //DWORD NumHeaps = 0;
  45         VIDEOMEMORY vmList;
  46         //DWORD NumFourCC = 0;
  47         //DWORD FourCC = 0;
  48         DEVMODE devmode;
  49         HDC hdc;
  50
  51
  52         /* clear data */
  53         memset(&vmList,0,sizeof(VIDEOMEMORY));
  54         memset(&D3dTextureFormats,0,sizeof(DDSURFACEDESC));
  55         memset(&D3dBufferCallbacks,0,sizeof(DD_D3DBUFCALLBACKS));
  56         memset(&D3dDriverData,0,sizeof(D3DNTHAL_GLOBALDRIVERDATA));
  57         memset(&D3dCallbacks,0,sizeof(D3DNTHAL_CALLBACKS));
  58         memset(&HalInfo,0,sizeof(DD_HALINFO));
  59         memset(CallBackFlags,0,sizeof(DWORD)*3);
  60
  61
  62
  63         /* Get currenet display mode */
  64         EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devmode);
  65
  66         hdc = CreateDCW(L"DISPLAY",NULL,NULL,NULL);
  67         ASSERT(hdc != NULL);
  68
  69         hDirectDraw = (HANDLE) Syscall(L"NtGdiDdCreateDirectDrawObject", 1, &hdc);
  70         ASSERT(hDirectDraw != NULL);
  71
  72         /* Test ReactX */
  73         hDirectDraw = (HANDLE) Syscall(L"NtGdiDdCreateDirectDrawObject", 1, &hdc);
  74
  75         RTEST(NtGdiDdQueryDirectDrawObject( NULL, pHalInfo,
  76                                                                                 pCallBackFlags, puD3dCallbacks,
  77                                                                                 puD3dDriverData, puD3dBufferCallbacks,
  78                                                                                 puD3dTextureFormats, puNumHeaps,
  79                                                                                 puvmList, puNumFourCC,
  80                                                                                 puFourCC) == FALSE);
  81
  82         RTEST(pHalInfo == NULL);
  83         RTEST(pCallBackFlags == NULL);
  84         RTEST(puD3dCallbacks == NULL);
  85         RTEST(puD3dDriverData == NULL);
  86         RTEST(puD3dBufferCallbacks == NULL);
  87         RTEST(puD3dTextureFormats == NULL);
  88         RTEST(puNumFourCC == NULL);
  89         RTEST(puFourCC == NULL);
  90         RTEST(puNumHeaps == NULL);
  91         RTEST(puvmList == NULL);
  92
  93         RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
  94                                                                                 pCallBackFlags, puD3dCallbacks,
  95                                                                                 puD3dDriverData, puD3dBufferCallbacks,
  96                                                                                 puD3dTextureFormats, puNumHeaps,
  97                                                                                 puvmList, puNumFourCC,
  98                                                                                 puFourCC) == FALSE);
  99
 100         RTEST(pHalInfo == NULL);
 101         RTEST(pCallBackFlags == NULL);
 102         RTEST(puD3dCallbacks == NULL);
 103         RTEST(puD3dDriverData == NULL);
 104         RTEST(puD3dBufferCallbacks == NULL);
 105         RTEST(puD3dTextureFormats == NULL);
 106         RTEST(puNumFourCC == NULL);
 107         RTEST(puFourCC == NULL);
 108         RTEST(puNumHeaps == NULL);
 109         RTEST(puvmList == NULL);
 110
 111         pHalInfo = &HalInfo;
 112         RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
 113                                                                                 pCallBackFlags, puD3dCallbacks,
 114                                                                                 puD3dDriverData, puD3dBufferCallbacks,
 115                                                                                 puD3dTextureFormats, puNumHeaps,
 116                                                                                 puvmList, puNumFourCC,
 117                                                                                 puFourCC)== FALSE);
 118         RTEST(pHalInfo != NULL);
 119         RTEST(pCallBackFlags == NULL);
 120         RTEST(puD3dCallbacks == NULL);
 121         RTEST(puD3dDriverData == NULL);
 122         RTEST(puD3dBufferCallbacks == NULL);
 123         RTEST(puD3dTextureFormats == NULL);
 124         RTEST(puNumFourCC == NULL);
 125         RTEST(puFourCC == NULL);
 126         ASSERT(pHalInfo != NULL);
 127         RTEST(puNumHeaps == NULL);
 128         RTEST(puvmList == NULL);
 129
 130         if ((pHalInfo->dwSize != sizeof(DD_HALINFO)) &&
 131                 (pHalInfo->dwSize != sizeof(DD_HALINFO_V4)))
 132         {
 133                 RTEST(pHalInfo->dwSize != sizeof(DD_HALINFO));
 134                 ASSERT(pHalInfo->dwSize != sizeof(DD_HALINFO));
 135         }
 136
 137         if (pHalInfo->dwSize == sizeof(DD_HALINFO))
 138         {
 139                 /*the offset, in bytes, to primary surface in the display memory  */
 140                 RTEST(pHalInfo->vmiData.fpPrimary != 0 );
 141
 142                 /* unsuse always 0 */
 143                 RTEST(pHalInfo->vmiData.dwFlags == 0 );
 144
 145                 /* Check the res */
 146                 RTEST(pHalInfo->vmiData.dwDisplayWidth == devmode.dmPelsWidth );
 147                 RTEST(pHalInfo->vmiData.dwDisplayHeight == devmode.dmPelsHeight );
 148                 /* FIXME
 149                         RTEST(pHalInfo->vmiData.lDisplayPitch == 0x1700;
 150                 */
 151                 RTEST(pHalInfo->vmiData.ddpfDisplay.dwSize == sizeof(DDPIXELFORMAT) );
 152                 ASSERT(pHalInfo->vmiData.ddpfDisplay.dwSize == sizeof(DDPIXELFORMAT));
 153
 154                 /* Fail on 8bit screen deep */
 155                 RTEST(pHalInfo->vmiData.ddpfDisplay.dwFlags  == DDPF_RGB);
 156
 157
 158                 /* No fourcc are use on primary screen */
 159                 RTEST(pHalInfo->vmiData.ddpfDisplay.dwFourCC == 0 );
 160
 161                 /* Count RGB Bits 8/16/24/32 */
 162                 RTEST(pHalInfo->vmiData.ddpfDisplay.dwRGBBitCount == devmode.dmBitsPerPel );
 163
 164                 /* FIXME RGB mask */
 165                 //RTEST(pHalInfo->vmiData.ddpfDisplay.dwRBitMask  ==  0 );
 166                 //RTEST(pHalInfo->vmiData.ddpfDisplay.dwGBitMask ==  0 );
 167                 //RTEST(pHalInfo->vmiData.ddpfDisplay.dwBBitMask == 0 );
 168
 169                 /* primary never set the alpha blend mask */
 170                 RTEST(pHalInfo->vmiData.ddpfDisplay.dwRGBAlphaBitMask ==  0 );
 171
 172                 /* FIXME do not known how test follow thing, for it is diffent for each drv */
 173                 // pHalInfo->vmiData->dwOffscreenAlign               : 0x00000100
 174                 // pHalInfo->vmiData->dwOverlayAlign                 : 0x00000010
 175                 // pHalInfo->vmiData->dwTextureAlign                 : 0x00000020
 176                 // pHalInfo->vmiData->dwZBufferAlign                 : 0x00001000
 177                 // pHalInfo->vmiData->dwAlphaAlign                   : 0x00000000
 178
 179                 /* the primary display address */
 180                 /* test see if it in kmode memory or not */
 181                 RTEST(pHalInfo->vmiData.pvPrimary != 0 );
 182
 183                 /* Test see if we got any hardware acclartions for 2d or 3d */
 184                 //RTEST(pHalInfo->ddCaps.dwSize == sizeof(DDCORECAPS));
 185
 186                 /* Testing see if we got any hw support for
 187                  * This test can fail on video card that does not support 2d/overlay/3d
 188                  */
 189                 RTEST( pHalInfo->ddCaps.dwCaps != 0);
 190                 RTEST( pHalInfo->ddCaps.ddsCaps.dwCaps != 0);
 191
 192                 /* if this fail we do not have a dx driver install acodring ms, some version of windows it
 193                  * is okay this fail and drv does then only support basic dx
 194                  */
 195                 RTEST( (pHalInfo->dwFlags & (DDHALINFO_GETDRIVERINFOSET | DDHALINFO_GETDRIVERINFO2)) != 0 );
 196
 197                 if (pHalInfo->ddCaps.ddsCaps.dwCaps  & DDSCAPS_3DDEVICE )
 198                 {
 199                         RTEST( pHalInfo->lpD3DGlobalDriverData != 0);
 200                         RTEST( pHalInfo->lpD3DHALCallbacks != 0);
 201                         RTEST( pHalInfo->lpD3DBufCallbacks != 0);
 202                 }
 203         }
 204
 205         /* FIXME DD_HALINFO_V4 test */
 206
 207 /* Next Start 2 */
 208         RtlCopyMemory(&oldHalInfo, &HalInfo, sizeof(DD_HALINFO));
 209
 210         pHalInfo = &HalInfo;
 211         pCallBackFlags = CallBackFlags;
 212         RtlZeroMemory(pHalInfo,sizeof(DD_HALINFO));
 213
 214         RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
 215                                                                                 pCallBackFlags, puD3dCallbacks,
 216                                                                                 puD3dDriverData, puD3dBufferCallbacks,
 217                                                                                 puD3dTextureFormats, puNumHeaps,
 218                                                                                 puvmList, puNumFourCC,
 219                                                                                 puFourCC)== FALSE);
 220         RTEST(pHalInfo != NULL);
 221         RTEST(pCallBackFlags != NULL);
 222         RTEST(puD3dCallbacks == NULL);
 223         RTEST(puD3dDriverData == NULL);
 224         RTEST(puD3dBufferCallbacks == NULL);
 225         RTEST(puD3dTextureFormats == NULL);
 226         RTEST(puNumFourCC == NULL);
 227         RTEST(puFourCC == NULL);
 228         ASSERT(pHalInfo != NULL);
 229         RTEST(puNumHeaps == NULL);
 230         RTEST(puvmList == NULL);
 231
 232         /* We do not retesting DD_HALINFO, instead we compare it */
 233         RTEST(memcmp(&oldHalInfo, pHalInfo, sizeof(DD_HALINFO)) == 0);
 234         RTEST(pCallBackFlags[0] != 0);
 235         RTEST(pCallBackFlags[1] != 0);
 236
 237         /* NT4 this will fail */
 238         RTEST(pCallBackFlags[2] == 0);
 239
 240 /* Next Start 3 */
 241         pHalInfo = &HalInfo;
 242         pCallBackFlags = CallBackFlags;
 243         puD3dCallbacks = &D3dCallbacks;
 244
 245         RtlZeroMemory(pHalInfo,sizeof(DD_HALINFO));
 246         RtlZeroMemory(pCallBackFlags,sizeof(DWORD)*3);
 247
 248         RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
 249                                                                                 pCallBackFlags, puD3dCallbacks,
 250                                                                                 puD3dDriverData, puD3dBufferCallbacks,
 251                                                                                 puD3dTextureFormats, puNumHeaps,
 252                                                                                 puvmList, puNumFourCC,
 253                                                                                 puFourCC)== FALSE);
 254         RTEST(pHalInfo != NULL);
 255         RTEST(pCallBackFlags != NULL);
 256
 257         if (pHalInfo->ddCaps.ddsCaps.dwCaps  & DDSCAPS_3DDEVICE )
 258         {
 259                 RTEST(puD3dCallbacks != NULL);
 260         }
 261
 262         RTEST(puD3dDriverData == NULL);
 263         RTEST(puD3dBufferCallbacks == NULL);
 264         RTEST(puD3dTextureFormats == NULL);
 265         RTEST(puNumFourCC == NULL);
 266         RTEST(puFourCC == NULL);
 267         RTEST(puNumHeaps == NULL);
 268         RTEST(puvmList == NULL);
 269         ASSERT(pHalInfo != NULL);
 270
 271         /* We do not retesting DD_HALINFO, instead we compare it */
 272         RTEST(memcmp(&oldHalInfo, pHalInfo, sizeof(DD_HALINFO)) == 0);
 273         RTEST(pCallBackFlags[0] != 0);
 274         RTEST(pCallBackFlags[1] != 0);
 275
 276         /* NT4 this will fail */
 277         RTEST(pCallBackFlags[2] == 0);
 278
 279 /* Next Start 4 */
 280         pHalInfo = &HalInfo;
 281         pCallBackFlags = CallBackFlags;
 282         puD3dCallbacks = &D3dCallbacks;
 283         puD3dDriverData = &D3dDriverData;
 284
 285         RtlZeroMemory(pHalInfo,sizeof(DD_HALINFO));
 286         RtlZeroMemory(pCallBackFlags,sizeof(DWORD)*3);
 287         RtlZeroMemory(puD3dCallbacks,sizeof(D3DNTHAL_CALLBACKS));
 288
 289         RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
 290                                                                                 pCallBackFlags, puD3dCallbacks,
 291                                                                                 puD3dDriverData, puD3dBufferCallbacks,
 292                                                                                 puD3dTextureFormats, puNumHeaps,
 293                                                                                 puvmList, puNumFourCC,
 294                                                                                 puFourCC)== FALSE);
 295         RTEST(pHalInfo != NULL);
 296         RTEST(pCallBackFlags != NULL);
 297
 298         if (pHalInfo->ddCaps.ddsCaps.dwCaps  & DDSCAPS_3DDEVICE )
 299         {
 300                 RTEST(puD3dCallbacks != NULL);
 301                 RTEST(puD3dDriverData != NULL);
 302         }
 303
 304         RTEST(puD3dBufferCallbacks == NULL);
 305         RTEST(puD3dTextureFormats == NULL);
 306         RTEST(puNumFourCC == NULL);
 307         RTEST(puFourCC == NULL);
 308         RTEST(puNumHeaps == NULL);
 309         RTEST(puvmList == NULL);
 310         ASSERT(pHalInfo != NULL);
 311
 312         /* We do not retesting DD_HALINFO, instead we compare it */
 313         RTEST(memcmp(&oldHalInfo, pHalInfo, sizeof(DD_HALINFO)) == 0);
 314         RTEST(pCallBackFlags[0] != 0);
 315         RTEST(pCallBackFlags[1] != 0);
 316
 317         /* NT4 this will fail */
 318         RTEST(pCallBackFlags[2] == 0);
 319
 320 /* Next Start 5 */
 321         pHalInfo = &HalInfo;
 322         pCallBackFlags = CallBackFlags;
 323         puD3dCallbacks = &D3dCallbacks;
 324         puD3dDriverData = &D3dDriverData;
 325         puD3dBufferCallbacks = &D3dBufferCallbacks;
 326
 327         RtlZeroMemory(pHalInfo,sizeof(DD_HALINFO));
 328         RtlZeroMemory(pCallBackFlags,sizeof(DWORD)*3);
 329         RtlZeroMemory(puD3dCallbacks,sizeof(D3DNTHAL_CALLBACKS));
 330         RtlZeroMemory(puD3dDriverData,sizeof(D3DNTHAL_CALLBACKS));
 331
 332         RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
 333                                                                                 pCallBackFlags, puD3dCallbacks,
 334                                                                                 puD3dDriverData, puD3dBufferCallbacks,
 335                                                                                 puD3dTextureFormats, puNumHeaps,
 336                                                                                 puvmList, puNumFourCC,
 337                                                                                 puFourCC)== FALSE);
 338         RTEST(pHalInfo != NULL);
 339         RTEST(pCallBackFlags != NULL);
 340
 341         if (pHalInfo->ddCaps.ddsCaps.dwCaps  & DDSCAPS_3DDEVICE )
 342         {
 343                 RTEST(puD3dCallbacks != NULL);
 344                 RTEST(puD3dDriverData != NULL);
 345                 RTEST(puD3dBufferCallbacks != NULL);
 346         }
 347
 348
 349         RTEST(puD3dTextureFormats == NULL);
 350         RTEST(puNumFourCC == NULL);
 351         RTEST(puFourCC == NULL);
 352         RTEST(puNumHeaps == NULL);
 353         RTEST(puvmList == NULL);
 354         ASSERT(pHalInfo != NULL);
 355
 356         /* We do not retesting DD_HALINFO, instead we compare it */
 357         RTEST(memcmp(&oldHalInfo, pHalInfo, sizeof(DD_HALINFO)) == 0);
 358         RTEST(pCallBackFlags[0] != 0);
 359         RTEST(pCallBackFlags[1] != 0);
 360
 361         /* NT4 this will fail */
 362         RTEST(pCallBackFlags[2] == 0);
 363
 364 /* Next Start 6 */
 365         pHalInfo = &HalInfo;
 366         pCallBackFlags = CallBackFlags;
 367         puD3dCallbacks = &D3dCallbacks;
 368         puD3dDriverData = &D3dDriverData;
 369         puD3dBufferCallbacks = &D3dBufferCallbacks;
 370
 371         RtlZeroMemory(pHalInfo,sizeof(DD_HALINFO));
 372         RtlZeroMemory(pCallBackFlags,sizeof(DWORD)*3);
 373         RtlZeroMemory(puD3dCallbacks,sizeof(D3DNTHAL_CALLBACKS));
 374         RtlZeroMemory(puD3dDriverData,sizeof(D3DNTHAL_GLOBALDRIVERDATA));
 375         RtlZeroMemory(&D3dBufferCallbacks,sizeof(DD_D3DBUFCALLBACKS));
 376
 377         RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
 378                                                                                 pCallBackFlags, puD3dCallbacks,
 379                                                                                 puD3dDriverData, puD3dBufferCallbacks,
 380                                                                                 puD3dTextureFormats, puNumHeaps,
 381                                                                                 puvmList, puNumFourCC,
 382                                                                                 puFourCC)== FALSE);
 383         RTEST(pHalInfo != NULL);
 384         RTEST(pCallBackFlags != NULL);
 385
 386         if (pHalInfo->ddCaps.ddsCaps.dwCaps  & DDSCAPS_3DDEVICE )
 387         {
 388                 RTEST(puD3dCallbacks != NULL);
 389                 RTEST(puD3dDriverData != NULL);
 390                 RTEST(puD3dBufferCallbacks != NULL);
 391         }
 392
 393         RTEST(puD3dTextureFormats == NULL);
 394         RTEST(puNumFourCC == NULL);
 395         RTEST(puFourCC == NULL);
 396         RTEST(puNumHeaps == NULL);
 397         RTEST(puvmList == NULL);
 398         ASSERT(pHalInfo != NULL);
 399
 400         /* We do not retesting DD_HALINFO, instead we compare it */
 401         RTEST(memcmp(&oldHalInfo, pHalInfo, sizeof(DD_HALINFO)) == 0);
 402         RTEST(pCallBackFlags[0] != 0);
 403         RTEST(pCallBackFlags[1] != 0);
 404
 405         /* NT4 this will fail */
 406         RTEST(pCallBackFlags[2] == 0);
 407
 408 /* Next Start 7 */
 409         pHalInfo = &HalInfo;
 410         pCallBackFlags = CallBackFlags;
 411         puD3dCallbacks = &D3dCallbacks;
 412         puD3dDriverData = &D3dDriverData;
 413         puD3dBufferCallbacks = &D3dBufferCallbacks;
 414
 415         /* It is forbein to return a  DDSURFACEDESC2 it should always be DDSURFACEDESC
 416                 This is only for detected bad drivers that does not follow the rules, if they
 417                 does not follow tthe rules only not everthing being copy then in gdi32.dll
 418                 gdi32.dll always assume it is DDSURFACEDESC size
 419         */
 420         if (puD3dDriverData->dwNumTextureFormats != 0)
 421         {
 422                 puD3dTextureFormats = malloc (puD3dDriverData->dwNumTextureFormats * sizeof(DDSURFACEDESC2));
 423         }
 424
 425         RtlZeroMemory(pHalInfo,sizeof(DD_HALINFO));
 426         RtlZeroMemory(pCallBackFlags,sizeof(DWORD)*3);
 427         RtlZeroMemory(puD3dCallbacks,sizeof(D3DNTHAL_CALLBACKS));
 428         RtlZeroMemory(puD3dDriverData,sizeof(D3DNTHAL_GLOBALDRIVERDATA));
 429         RtlZeroMemory(&D3dBufferCallbacks,sizeof(DD_D3DBUFCALLBACKS));
 430
 431         RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
 432                                                                                 pCallBackFlags, puD3dCallbacks,
 433                                                                                 puD3dDriverData, puD3dBufferCallbacks,
 434                                                                                 puD3dTextureFormats, puNumHeaps,
 435                                                                                 puvmList, puNumFourCC,
 436                                                                                 puFourCC)== FALSE);
 437         RTEST(pHalInfo != NULL);
 438         RTEST(pCallBackFlags != NULL);
 439
 440         if (pHalInfo->ddCaps.ddsCaps.dwCaps  & DDSCAPS_3DDEVICE )
 441         {
 442                 RTEST(puD3dCallbacks != NULL);
 443                 RTEST(puD3dDriverData != NULL);
 444                 RTEST(puD3dBufferCallbacks != NULL);
 445                 if (puD3dDriverData->dwNumTextureFormats != 0)
 446                 {
 447                         /* FIXME add a better test for texture */
 448                         RTEST(puD3dTextureFormats != NULL);
 449                 }
 450         }
 451
 452         RTEST(puNumFourCC == NULL);
 453         RTEST(puFourCC == NULL);
 454         RTEST(puNumHeaps == NULL);
 455         RTEST(puvmList == NULL);
 456         ASSERT(pHalInfo != NULL);
 457
 458         /* We do not retesting DD_HALINFO, instead we compare it */
 459         RTEST(memcmp(&oldHalInfo, pHalInfo, sizeof(DD_HALINFO)) == 0);
 460         RTEST(pCallBackFlags[0] != 0);
 461         RTEST(pCallBackFlags[1] != 0);
 462
 463         /* NT4 this will fail */
 464         RTEST(pCallBackFlags[2] == 0);
 465
 466
 467
 468         /* Todo
 469         * adding test for
 470         * puD3dCallbacks
 471         * puD3dDriverData
 472         * puD3dBufferCallbacks
 473         * puNumFourCC
 474         * puFourCC
 475         * puNumHeaps
 476         * puvmList
 477         */
 478
 479         /* Cleanup ReactX setup */
 480         DeleteDC(hdc);
 481         Syscall(L"NtGdiDdDeleteDirectDrawObject", 1, &hDirectDraw);
 482
 483         return APISTATUS_NORMAL;
 484 }