rostests/apitests/win32nt/ntdd/NtGdiDdQueryDirectDrawObject.c

   1 /*
   2  * PROJECT:         ReactOS api tests
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * PURPOSE:         Test for NtGdiDdCreateDirectDrawObject
   5  * PROGRAMMERS:
   6  */
   7
   8 #include <win32nt.h>
   9
  10 /* Note : OsThunkDdQueryDirectDrawObject is the usermode name of NtGdiDdQueryDirectDrawObject
  11  *        it lives in d3d8thk.dll and in windows 2000 it doing syscall direcly to win32k.sus
  12  *        in windows xp and higher it call to gdi32.dll to DdEntry41 and it doing the syscall
  13  */
  14 START_TEST(NtGdiDdQueryDirectDrawObject)
  15 {
  16     HANDLE  hDirectDraw = NULL;
  17     DD_HALINFO *pHalInfo = NULL;
  18     DWORD *pCallBackFlags = NULL;
  19     LPD3DNTHAL_CALLBACKS puD3dCallbacks = NULL;
  20     LPD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData = NULL;
  21     PDD_D3DBUFCALLBACKS puD3dBufferCallbacks = NULL;
  22     LPDDSURFACEDESC puD3dTextureFormats = NULL;
  23     DWORD *puNumHeaps = NULL;
  24     VIDEOMEMORY *puvmList = NULL;
  25     DWORD *puNumFourCC = NULL;
  26     DWORD *puFourCC = NULL;
  27
  28     DD_HALINFO HalInfo;
  29     DD_HALINFO oldHalInfo;
  30     DWORD CallBackFlags[4];
  31
  32     D3DNTHAL_CALLBACKS D3dCallbacks;
  33     D3DNTHAL_CALLBACKS oldD3dCallbacks;
  34
  35     D3DNTHAL_GLOBALDRIVERDATA D3dDriverData;
  36     D3DNTHAL_GLOBALDRIVERDATA oldD3dDriverData;
  37
  38     DD_D3DBUFCALLBACKS D3dBufferCallbacks;
  39     DD_D3DBUFCALLBACKS oldD3dBufferCallbacks;
  40
  41     DDSURFACEDESC2 D3dTextureFormats[100];
  42     DWORD NumHeaps = 0;
  43     VIDEOMEMORY vmList;
  44     //DWORD NumFourCC = 0;
  45     //DWORD FourCC = 0;
  46     DEVMODE devmode;
  47     HDC hdc;
  48
  49     DWORD dwTextureCounter = 0;
  50     DDSURFACEDESC *myDesc = NULL;
  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     /* Get current display mode */
  62     EnumDisplaySettingsA(NULL, ENUM_CURRENT_SETTINGS, &devmode);
  63
  64     /* Create hdc that we can use */
  65     hdc = CreateDCW(L"DISPLAY",NULL,NULL,NULL);
  66     ASSERT(hdc != NULL);
  67
  68
  69     /* Create ReactX handle */
  70     hDirectDraw = (HANDLE) NtGdiDdCreateDirectDrawObject(hdc);
  71     ASSERT(hDirectDraw != NULL);
  72
  73     /* Start Test ReactX NtGdiDdQueryDirectDrawObject function */
  74
  75     /* testing  OsThunkDdQueryDirectDrawObject( NULL, ....  */
  76     RTEST(NtGdiDdQueryDirectDrawObject( NULL, pHalInfo,
  77                                         pCallBackFlags, puD3dCallbacks,
  78                                         puD3dDriverData, puD3dBufferCallbacks,
  79                                         puD3dTextureFormats, puNumHeaps,
  80                                         puvmList, puNumFourCC,
  81                                         puFourCC) == FALSE);
  82
  83     RTEST(pHalInfo == NULL);
  84     RTEST(pCallBackFlags == NULL);
  85     RTEST(puD3dCallbacks == NULL);
  86     RTEST(puD3dDriverData == NULL);
  87     RTEST(puD3dBufferCallbacks == NULL);
  88     RTEST(puD3dTextureFormats == NULL);
  89     RTEST(puNumFourCC == NULL);
  90     RTEST(puFourCC == NULL);
  91     RTEST(puNumHeaps == NULL);
  92     RTEST(puvmList == NULL);
  93
  94     /* testing  NtGdiDdQueryDirectDrawObject( hDirectDrawLocal, NULL, ....  */
  95     RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
  96                                         pCallBackFlags, puD3dCallbacks,
  97                                         puD3dDriverData, puD3dBufferCallbacks,
  98                                         puD3dTextureFormats, puNumHeaps,
  99                                         puvmList, puNumFourCC,
 100                                         puFourCC) == FALSE);
 101
 102     RTEST(pHalInfo == NULL);
 103     RTEST(pCallBackFlags == NULL);
 104     RTEST(puD3dCallbacks == NULL);
 105     RTEST(puD3dDriverData == NULL);
 106     RTEST(puD3dBufferCallbacks == NULL);
 107     RTEST(puD3dTextureFormats == NULL);
 108     RTEST(puNumFourCC == NULL);
 109     RTEST(puFourCC == NULL);
 110     RTEST(puNumHeaps == NULL);
 111     RTEST(puvmList == NULL);
 112
 113     /* testing  NtGdiDdQueryDirectDrawObject( hDirectDrawLocal, pHalInfo, NULL, ....  */
 114     pHalInfo = &HalInfo;
 115     RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
 116                                         pCallBackFlags, puD3dCallbacks,
 117                                         puD3dDriverData, puD3dBufferCallbacks,
 118                                         puD3dTextureFormats, puNumHeaps,
 119                                         puvmList, puNumFourCC,
 120                                         puFourCC)== FALSE);
 121
 122     RTEST(pHalInfo != NULL);
 123     ASSERT(pHalInfo != NULL);
 124
 125     RTEST(pCallBackFlags == NULL);
 126     RTEST(puD3dCallbacks == NULL);
 127     RTEST(puD3dDriverData == NULL);
 128     RTEST(puD3dBufferCallbacks == NULL);
 129     RTEST(puD3dTextureFormats == NULL);
 130     RTEST(puNumFourCC == NULL);
 131     RTEST(puFourCC == NULL);
 132     RTEST(puNumHeaps == NULL);
 133     RTEST(puvmList == NULL);
 134
 135     if ((pHalInfo->dwSize != sizeof(DD_HALINFO)) &&
 136         (pHalInfo->dwSize != sizeof(DD_HALINFO_V4)))
 137     {
 138         RTEST(pHalInfo->dwSize != sizeof(DD_HALINFO));
 139         ASSERT(pHalInfo->dwSize != sizeof(DD_HALINFO));
 140     }
 141
 142     if (pHalInfo->dwSize == sizeof(DD_HALINFO))
 143     {
 144         /*the offset, in bytes, to primary surface in the display memory  */
 145         /* some graphic card like  sis 760 GX, Nvida GF7900GS does not set any offset at all */
 146         // RTEST(pHalInfo->vmiData.fpPrimary != 0 );
 147
 148         /* unsuse always 0 */
 149         RTEST(pHalInfo->vmiData.dwFlags == 0 );
 150
 151         /* Check the res */
 152         RTEST(pHalInfo->vmiData.dwDisplayWidth == devmode.dmPelsWidth );
 153         RTEST(pHalInfo->vmiData.dwDisplayHeight == devmode.dmPelsHeight );
 154
 155         /*  This can never be test for it is who big the line is after it been align displayPitch */
 156         RTEST(pHalInfo->vmiData.lDisplayPitch != 0);
 157
 158         RTEST(pHalInfo->vmiData.ddpfDisplay.dwSize == sizeof(DDPIXELFORMAT) );
 159         ASSERT(pHalInfo->vmiData.ddpfDisplay.dwSize == sizeof(DDPIXELFORMAT));
 160
 161         /* We can not check if it DDPF_RGB flags been set for primary surface
 162          * for it can be DDPF_PALETTEINDEXED1,DDPF_PALETTEINDEXED2,DDPF_PALETTEINDEXED4,DDPF_PALETTEINDEXED8, DDPF_PALETTEINDEXEDTO8, DDPF_RGB, DDPF_YUV
 163          */
 164         RTEST( (pHalInfo->vmiData.ddpfDisplay.dwFlags & (DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2 | DDPF_PALETTEINDEXED4 |
 165                                                          DDPF_PALETTEINDEXED8 | DDPF_PALETTEINDEXEDTO8 | DDPF_RGB | DDPF_YUV)) != 0);
 166
 167
 168         /* No fourcc are use on primary screen */
 169         RTEST(pHalInfo->vmiData.ddpfDisplay.dwFourCC == 0 );
 170
 171         /* Count RGB Bits 8/16/24/32 */
 172         RTEST(pHalInfo->vmiData.ddpfDisplay.dwRGBBitCount == devmode.dmBitsPerPel );
 173
 174         /* The rgb mask can not be detected in user mode, for it can be 15Bpp convert to 16Bpp mode, so we have no way detect correct mask
 175          * But the mask can never be Zero
 176          */
 177         RTEST(pHalInfo->vmiData.ddpfDisplay.dwRBitMask  !=  0 );
 178         RTEST(pHalInfo->vmiData.ddpfDisplay.dwGBitMask !=  0 );
 179         RTEST(pHalInfo->vmiData.ddpfDisplay.dwBBitMask != 0 );
 180
 181         /* primary never set the alpha blend mask */
 182         RTEST(pHalInfo->vmiData.ddpfDisplay.dwRGBAlphaBitMask ==  0 );
 183
 184         /* This can not be test at usermode it is each hardware drv that fill in it,
 185          * only way to found them is to use this call  */
 186         // pHalInfo->vmiData->dwOffscreenAlign
 187         // pHalInfo->vmiData->dwOverlayAlign
 188         // pHalInfo->vmiData->dwTextureAlign
 189         // pHalInfo->vmiData->dwZBufferAlign
 190         // pHalInfo->vmiData->dwAlphaAlign
 191
 192         /* the primary display address */
 193         RTEST( ( (DWORD)pHalInfo->vmiData.pvPrimary & (~0x80000000)) != 0 );
 194
 195         /* test see if we got back the pvmList here
 196          * acording msdn vmiData.dwNumHeaps and vmiData.pvmList
 197          * exists for _VIDEOMEMORYINFO but they do not, it reviews
 198          * in ddk and wdk and own testcase
 199          */
 200          // RTEST(pHalInfo->vmiData.dwNumHeaps  != 0 );
 201          // RTEST(pHalInfo->vmiData.pvmList  != 0 );
 202
 203         /* Test see if we got any hardware acclartions for 2d or 3d, this always fill in
 204          * that mean we found a bugi drv and dx does not work on this drv
 205          */
 206
 207         /* the SIS 760 GX will never fill it in, it is a bugi drv */
 208         RTEST(pHalInfo->ddCaps.dwSize == sizeof(DDCORECAPS));
 209
 210         /* Testing see if we got any hw support for
 211          * This test can fail on video card that does not support 2d/overlay/3d
 212          */
 213         RTEST( pHalInfo->ddCaps.dwCaps != 0);
 214         RTEST( pHalInfo->ddCaps.ddsCaps.dwCaps != 0);
 215
 216         /* This flags is obsolete and should not be used by the driver */
 217         RTEST( pHalInfo->ddCaps.dwFXAlphaCaps == 0);
 218
 219
 220         /* basic dx 2 is found if this flags not set
 221          * if this fail we do not have a dx driver install acodring ms, some version of windows it
 222          * is okay this fail and drv does then only support basic dx
 223          *
 224          */
 225         if (pHalInfo->dwFlags != 0)
 226         {
 227             RTEST( (pHalInfo->dwFlags & (DDHALINFO_GETDRIVERINFOSET | DDHALINFO_GETDRIVERINFO2)) != 0 );
 228             RTEST( ( (DWORD)pHalInfo->GetDriverInfo & 0x80000000) != 0 );
 229             ASSERT( ((DWORD)pHalInfo->GetDriverInfo & 0x80000000) != 0 );
 230         }
 231
 232         /* point to kmode direcly to the graphic drv, the drv is kmode and it is kmode address we getting back*/
 233
 234
 235        /* the pHalInfo->ddCaps.ddsCaps.dwCaps & DDSCAPS_3DDEVICE will be ignore, only way detect it proper follow code,
 236         * this will be fill in of all drv, it is not only for 3d stuff, this always fill by win32k.sys or dxg.sys depns
 237         * if it windows 2000 or windows xp/2003
 238         *
 239         * point to kmode direcly to the win32k.sys, win32k.sys is kmode and it is kmode address we getting back
 240         */
 241         RTEST( ( (DWORD)pHalInfo->lpD3DGlobalDriverData & (~0x80000000)) != 0 );
 242         RTEST( ( (DWORD)pHalInfo->lpD3DHALCallbacks & (~0x80000000)) != 0 );
 243         RTEST( ( (DWORD)pHalInfo->lpD3DHALCallbacks & (~0x80000000)) != 0 );
 244     }
 245
 246     /* Backup DD_HALINFO so we do not need resting it */
 247     RtlCopyMemory(&oldHalInfo, &HalInfo, sizeof(DD_HALINFO));
 248
 249     /* testing  NtGdiDdQueryDirectDrawObject( hDirectDrawLocal, pHalInfo, pCallBackFlags, NULL, ....  */
 250     pHalInfo = &HalInfo;
 251     pCallBackFlags = CallBackFlags;
 252     RtlZeroMemory(pHalInfo,sizeof(DD_HALINFO));
 253
 254     RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
 255                                         pCallBackFlags, puD3dCallbacks,
 256                                         puD3dDriverData, puD3dBufferCallbacks,
 257                                         puD3dTextureFormats, puNumHeaps,
 258                                         puvmList, puNumFourCC,
 259                                         puFourCC)== FALSE);
 260     RTEST(pHalInfo != NULL);
 261     ASSERT(pHalInfo != NULL);
 262
 263     RTEST(pCallBackFlags != NULL);
 264     ASSERT(pCallBackFlags != NULL);
 265
 266     RTEST(puD3dCallbacks == NULL);
 267     RTEST(puD3dDriverData == NULL);
 268     RTEST(puD3dBufferCallbacks == NULL);
 269     RTEST(puD3dTextureFormats == NULL);
 270     RTEST(puNumFourCC == NULL);
 271     RTEST(puFourCC == NULL);
 272     RTEST(puNumHeaps == NULL);
 273     RTEST(puvmList == NULL);
 274
 275     /* We do not retesting DD_HALINFO, instead we compare it */
 276     RTEST(memcmp(&oldHalInfo, pHalInfo, sizeof(DD_HALINFO)) == 0);
 277
 278     /* Rember on some nivida drv the pCallBackFlags will not be set even they api exists in the drv
 279      * known workaround is to check if the drv really return a kmode pointer for the drv functions
 280      * we want to use.
 281      */
 282     RTEST(pCallBackFlags[0] != 0);
 283     RTEST(pCallBackFlags[1] != 0);
 284     RTEST(pCallBackFlags[2] == 0);
 285
 286     /* testing  NtGdiDdQueryDirectDrawObject( hDirectDrawLocal, pHalInfo, pCallBackFlags, D3dCallbacks, NULL, ....  */
 287     pHalInfo = &HalInfo;
 288     pCallBackFlags = CallBackFlags;
 289     puD3dCallbacks = &D3dCallbacks;
 290
 291     RtlZeroMemory(pHalInfo,sizeof(DD_HALINFO));
 292     RtlZeroMemory(pCallBackFlags,sizeof(DWORD)*3);
 293
 294     RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
 295                                         pCallBackFlags, puD3dCallbacks,
 296                                         puD3dDriverData, puD3dBufferCallbacks,
 297                                         puD3dTextureFormats, puNumHeaps,
 298                                         puvmList, puNumFourCC,
 299                                         puFourCC)== FALSE);
 300     RTEST(pHalInfo != NULL);
 301     ASSERT(pHalInfo != NULL);
 302
 303     RTEST(pCallBackFlags != NULL);
 304     ASSERT(pCallBackFlags != NULL);
 305
 306     /* rember puD3dCallbacks shall never return NULL */
 307     RTEST(puD3dCallbacks != NULL);
 308     ASSERT(puD3dCallbacks != NULL);
 309
 310     /* the pHalInfo->ddCaps.ddsCaps.dwCaps & DDSCAPS_3DDEVICE will be ignore, only way detect it proper follow code,
 311      * this will be fill in of all drv, it is not only for 3d stuff, this always fill by win32k.sys or dxg.sys depns
 312      * if it windows 2000 or windows xp/2003
 313      */
 314     RTEST(puD3dCallbacks->dwSize == sizeof(D3DNTHAL_CALLBACKS));
 315
 316     /* Nivda like GF7900GS will not follow ms design rule here,
 317      * ContextDestroyAll must alwyas be NULL for it is not longer inuse in windows 2000 and higher
 318      */
 319     RTEST(puD3dCallbacks->ContextDestroyAll == NULL);
 320
 321     /* Nivda like GF7900GS will not follow ms design rule here,
 322      * SceneCapture must alwyas be NULL for it is not longer inuse in windows 2000 and higher
 323      */
 324     RTEST(puD3dCallbacks->SceneCapture  == NULL);
 325     RTEST(puD3dCallbacks->dwReserved10 == 0);
 326     RTEST(puD3dCallbacks->dwReserved11 == 0);
 327     RTEST(puD3dCallbacks->dwReserved22 == 0);
 328     RTEST(puD3dCallbacks->dwReserved23 == 0);
 329     RTEST(puD3dCallbacks->dwReserved == 0);
 330     RTEST(puD3dCallbacks->TextureCreate  == NULL);
 331     RTEST(puD3dCallbacks->TextureDestroy  == NULL);
 332     RTEST(puD3dCallbacks->TextureSwap  == NULL);
 333     RTEST(puD3dCallbacks->TextureGetSurf  == NULL);
 334     RTEST(puD3dCallbacks->dwReserved12 == 0);
 335     RTEST(puD3dCallbacks->dwReserved13 == 0);
 336     RTEST(puD3dCallbacks->dwReserved14 == 0);
 337     RTEST(puD3dCallbacks->dwReserved15 == 0);
 338     RTEST(puD3dCallbacks->dwReserved16 == 0);
 339     RTEST(puD3dCallbacks->dwReserved17 == 0);
 340     RTEST(puD3dCallbacks->dwReserved18 == 0);
 341     RTEST(puD3dCallbacks->dwReserved19 == 0);
 342     RTEST(puD3dCallbacks->dwReserved20 == 0);
 343     RTEST(puD3dCallbacks->dwReserved21 == 0);
 344     RTEST(puD3dCallbacks->dwReserved24 == 0);
 345     RTEST(puD3dCallbacks->dwReserved0 == 0);
 346     RTEST(puD3dCallbacks->dwReserved1 == 0);
 347     RTEST(puD3dCallbacks->dwReserved2 == 0);
 348     RTEST(puD3dCallbacks->dwReserved3 == 0);
 349     RTEST(puD3dCallbacks->dwReserved4 == 0);
 350     RTEST(puD3dCallbacks->dwReserved5 == 0);
 351     RTEST(puD3dCallbacks->dwReserved6 == 0);
 352     RTEST(puD3dCallbacks->dwReserved7 == 0);
 353     RTEST(puD3dCallbacks->dwReserved8 == 0);
 354     RTEST(puD3dCallbacks->dwReserved9 == 0);
 355
 356     /* how detect puD3dCallbacks->ContextCreate and puD3dCallbacks->ContextDestroy shall be set for bugi drv like nivda ? */
 357     /* pointer direcly to the graphic drv, it is kmode pointer */
 358     // RTEST( ( (DWORD)puD3dCallbacks->ContextCreate & (~0x80000000)) != 0 );
 359     // RTEST( ( (DWORD)puD3dCallbacks->ContextDestroy & (~0x80000000)) != 0 );
 360
 361     RTEST(puD3dDriverData == NULL);
 362     RTEST(puD3dBufferCallbacks == NULL);
 363     RTEST(puD3dTextureFormats == NULL);
 364     RTEST(puNumFourCC == NULL);
 365     RTEST(puFourCC == NULL);
 366     RTEST(puNumHeaps == NULL);
 367     RTEST(puvmList == NULL);
 368
 369     /* We do not retesting DD_HALINFO, instead we compare it */
 370     RTEST(memcmp(&oldHalInfo, pHalInfo, sizeof(DD_HALINFO)) == 0);
 371     RTEST(pCallBackFlags[0] != 0);
 372     RTEST(pCallBackFlags[1] != 0);
 373     RTEST(pCallBackFlags[2] == 0);
 374
 375     /* Backup D3DNTHAL_CALLBACKS so we do not need resting it */
 376     RtlCopyMemory(&oldD3dCallbacks, &D3dCallbacks, sizeof(D3DNTHAL_CALLBACKS));
 377
 378
 379 /* testing  NtGdiDdQueryDirectDrawObject( hDD, pHalInfo, pCallBackFlags, puD3dCallbacks, puD3dDriverData, NULL, */
 380     pHalInfo = &HalInfo;
 381     pCallBackFlags = CallBackFlags;
 382     puD3dCallbacks = &D3dCallbacks;
 383     puD3dDriverData = &D3dDriverData;
 384
 385     RtlZeroMemory(pHalInfo,sizeof(DD_HALINFO));
 386     RtlZeroMemory(pCallBackFlags,sizeof(DWORD)*3);
 387     RtlZeroMemory(puD3dCallbacks,sizeof(D3DNTHAL_CALLBACKS));
 388
 389     RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
 390                                         pCallBackFlags, puD3dCallbacks,
 391                                         puD3dDriverData, puD3dBufferCallbacks,
 392                                         puD3dTextureFormats, puNumHeaps,
 393                                         puvmList, puNumFourCC,
 394                                         puFourCC)== FALSE);
 395     RTEST(pHalInfo != NULL);
 396     ASSERT(pHalInfo != NULL);
 397
 398     RTEST(pCallBackFlags != NULL);
 399     ASSERT(pCallBackFlags != NULL);
 400
 401     RTEST(puD3dCallbacks != NULL);
 402     ASSERT(puD3dCallbacks != NULL);
 403
 404     RTEST(puD3dDriverData != NULL);
 405     ASSERT(puD3dDriverData != NULL);
 406
 407     RTEST(puD3dBufferCallbacks == NULL);
 408     RTEST(puD3dTextureFormats == NULL);
 409     RTEST(puNumFourCC == NULL);
 410     RTEST(puFourCC == NULL);
 411     RTEST(puNumHeaps == NULL);
 412     RTEST(puvmList == NULL);
 413
 414     /* We retesting pCallBackFlags  */
 415     RTEST(pCallBackFlags[0] != 0);
 416     RTEST(pCallBackFlags[1] != 0);
 417     RTEST(pCallBackFlags[2] == 0);
 418
 419     /* We do not retesting instead we compare it */
 420     RTEST(memcmp(&oldHalInfo, pHalInfo, sizeof(DD_HALINFO)) == 0);
 421     RTEST(memcmp(&oldD3dCallbacks, puD3dCallbacks, sizeof(D3DNTHAL_CALLBACKS)) == 0);
 422
 423     /* start test of puD3dDriverData */
 424
 425     RTEST(puD3dDriverData->dwSize == sizeof(D3DNTHAL_GLOBALDRIVERDATA));
 426     RTEST(puD3dDriverData->hwCaps.dwSize == sizeof(D3DNTHALDEVICEDESC_V1));
 427     RTEST(puD3dDriverData->hwCaps.dtcTransformCaps.dwSize == sizeof(D3DTRANSFORMCAPS));
 428     RTEST(puD3dDriverData->hwCaps.dlcLightingCaps.dwSize == sizeof(D3DLIGHTINGCAPS));
 429     RTEST(puD3dDriverData->hwCaps.dpcLineCaps.dwSize == sizeof(D3DPRIMCAPS));
 430     RTEST(puD3dDriverData->hwCaps.dpcTriCaps.dwSize  == sizeof(D3DPRIMCAPS));
 431     RTEST(puD3dDriverData->hwCaps.dwMaxBufferSize == 0);
 432     RTEST(puD3dDriverData->hwCaps.dwMaxVertexCount == 0);
 433
 434     /* Backup D3DHAL_GLOBALDRIVERDATA so we do not need resting it */
 435     RtlCopyMemory(&oldD3dDriverData, &D3dDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA));
 436
 437 /* testing  NtGdiDdQueryDirectDrawObject( hDD, pHalInfo, pCallBackFlags, puD3dCallbacks, puD3dDriverData, puD3dBufferCallbacks, NULL, */
 438     pHalInfo = &HalInfo;
 439     pCallBackFlags = CallBackFlags;
 440     puD3dCallbacks = &D3dCallbacks;
 441     puD3dDriverData = &D3dDriverData;
 442     puD3dBufferCallbacks = &D3dBufferCallbacks;
 443
 444     RtlZeroMemory(pHalInfo,sizeof(DD_HALINFO));
 445     RtlZeroMemory(pCallBackFlags,sizeof(DWORD)*3);
 446     RtlZeroMemory(puD3dCallbacks,sizeof(D3DNTHAL_CALLBACKS));
 447     RtlZeroMemory(puD3dDriverData,sizeof(D3DNTHAL_CALLBACKS));
 448
 449     RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
 450                                         pCallBackFlags, puD3dCallbacks,
 451                                         puD3dDriverData, puD3dBufferCallbacks,
 452                                         puD3dTextureFormats, puNumHeaps,
 453                                         puvmList, puNumFourCC,
 454                                         puFourCC)== FALSE);
 455     RTEST(pHalInfo != NULL);
 456     RTEST(pCallBackFlags != NULL);
 457
 458     if (pHalInfo->ddCaps.ddsCaps.dwCaps  & DDSCAPS_3DDEVICE )
 459     {
 460         RTEST(puD3dCallbacks != NULL);
 461         RTEST(puD3dDriverData != NULL);
 462         RTEST(puD3dBufferCallbacks != NULL);
 463     }
 464
 465     RTEST(pHalInfo != NULL);
 466     ASSERT(pHalInfo != NULL);
 467
 468     RTEST(pCallBackFlags != NULL);
 469     ASSERT(pCallBackFlags != NULL);
 470
 471     RTEST(puD3dCallbacks != NULL);
 472     ASSERT(puD3dCallbacks != NULL);
 473
 474     RTEST(puD3dDriverData != NULL);
 475     ASSERT(puD3dDriverData != NULL);
 476
 477     RTEST(puD3dBufferCallbacks != NULL);
 478     ASSERT(puD3dDriverData != NULL);
 479
 480     RTEST(puD3dTextureFormats == NULL);
 481     RTEST(puNumFourCC == NULL);
 482     RTEST(puFourCC == NULL);
 483     RTEST(puNumHeaps == NULL);
 484     RTEST(puvmList == NULL);
 485
 486     /* We retesting the flags */
 487     RTEST(pCallBackFlags[0] != 0);
 488     RTEST(pCallBackFlags[1] != 0);
 489     RTEST(pCallBackFlags[2] == 0);
 490
 491     /* We do not retesting instead we compare it */
 492     RTEST(memcmp(&oldHalInfo, pHalInfo, sizeof(DD_HALINFO)) == 0);
 493     RTEST(memcmp(&oldD3dCallbacks, puD3dCallbacks, sizeof(D3DNTHAL_CALLBACKS)) == 0);
 494     RTEST(memcmp(&oldD3dDriverData, puD3dDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA)) == 0);
 495
 496     /* start test of puD3dBufferCallbacks */
 497     RTEST(puD3dBufferCallbacks->dwSize == sizeof(DD_D3DBUFCALLBACKS));
 498     if (puD3dBufferCallbacks->dwFlags & DDHAL_D3DBUFCB32_CANCREATED3DBUF)
 499     {
 500         /* point to kmode direcly to the graphic drv, the drv is kmode and it is kmode address we getting back*/
 501         RTEST( ( (DWORD)puD3dBufferCallbacks->CanCreateD3DBuffer & (~0x80000000)) != 0 );
 502     }
 503     else
 504     {
 505         RTEST( puD3dBufferCallbacks->CanCreateD3DBuffer == NULL);
 506     }
 507
 508     if (puD3dBufferCallbacks->dwFlags & DDHAL_D3DBUFCB32_CREATED3DBUF)
 509     {
 510         /* point to kmode direcly to the graphic drv, the drv is kmode and it is kmode address we getting back*/
 511         RTEST( ( (DWORD)puD3dBufferCallbacks->CreateD3DBuffer & (~0x80000000)) != 0 );
 512     }
 513     else
 514     {
 515         RTEST( puD3dBufferCallbacks->CreateD3DBuffer == NULL);
 516     }
 517
 518     if (puD3dBufferCallbacks->dwFlags & DDHAL_D3DBUFCB32_DESTROYD3DBUF)
 519     {
 520         /* point to kmode direcly to the graphic drv, the drv is kmode and it is kmode address we getting back*/
 521         RTEST( ( (DWORD)puD3dBufferCallbacks->DestroyD3DBuffer & (~0x80000000)) != 0 );
 522     }
 523     else
 524     {
 525         RTEST( puD3dBufferCallbacks->DestroyD3DBuffer == NULL);
 526     }
 527
 528     if (puD3dBufferCallbacks->dwFlags & DDHAL_D3DBUFCB32_LOCKD3DBUF)
 529     {
 530         /* point to kmode direcly to the graphic drv, the drv is kmode and it is kmode address we getting back*/
 531         RTEST( ( (DWORD)puD3dBufferCallbacks->LockD3DBuffer & (~0x80000000)) != 0 );
 532     }
 533     else
 534     {
 535         RTEST( puD3dBufferCallbacks->LockD3DBuffer == NULL);
 536     }
 537
 538     if (puD3dBufferCallbacks->dwFlags & DDHAL_D3DBUFCB32_UNLOCKD3DBUF)
 539     {
 540         /* point to kmode direcly to the graphic drv, the drv is kmode and it is kmode address we getting back*/
 541         RTEST( ( (DWORD)puD3dBufferCallbacks->UnlockD3DBuffer & (~0x80000000)) != 0 );
 542     }
 543     else
 544     {
 545         RTEST( puD3dBufferCallbacks->UnlockD3DBuffer == NULL);
 546     }
 547
 548     /* Backup DD_D3DBUFCALLBACKS so we do not need resting it */
 549     RtlCopyMemory(&oldD3dBufferCallbacks, &D3dBufferCallbacks, sizeof(DD_D3DBUFCALLBACKS));
 550
 551
 552 /* testing  NtGdiDdQueryDirectDrawObject( hDD, pHalInfo, pCallBackFlags, puD3dCallbacks, puD3dDriverData, puD3dBufferCallbacks, puD3dTextureFormats, NULL, */
 553     pHalInfo = &HalInfo;
 554     pCallBackFlags = CallBackFlags;
 555     puD3dCallbacks = &D3dCallbacks;
 556     puD3dDriverData = &D3dDriverData;
 557     puD3dBufferCallbacks = &D3dBufferCallbacks;
 558
 559     /* It is forbein to return a  DDSURFACEDESC2 it should always be DDSURFACEDESC
 560         This is only for detected bad drivers that does not follow the rules, if they
 561         does not follow tthe rules, not everthing being copy then in gdi32.dll
 562         gdi32.dll always assume it is DDSURFACEDESC size
 563     */
 564     if (puD3dDriverData->dwNumTextureFormats != 0)
 565     {
 566         puD3dTextureFormats = malloc (puD3dDriverData->dwNumTextureFormats * sizeof(DDSURFACEDESC2));
 567     }
 568
 569     RtlZeroMemory(pHalInfo,sizeof(DD_HALINFO));
 570     RtlZeroMemory(pCallBackFlags,sizeof(DWORD)*3);
 571     RtlZeroMemory(puD3dCallbacks,sizeof(D3DNTHAL_CALLBACKS));
 572     RtlZeroMemory(puD3dDriverData,sizeof(D3DNTHAL_GLOBALDRIVERDATA));
 573     RtlZeroMemory(&D3dBufferCallbacks,sizeof(DD_D3DBUFCALLBACKS));
 574
 575     RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
 576                                         pCallBackFlags, puD3dCallbacks,
 577                                         puD3dDriverData, puD3dBufferCallbacks,
 578                                         puD3dTextureFormats, puNumHeaps,
 579                                         puvmList, puNumFourCC,
 580                                         puFourCC)== FALSE);
 581
 582     RTEST(pHalInfo != NULL);
 583     ASSERT(pHalInfo != NULL);
 584
 585     RTEST(pCallBackFlags != NULL);
 586     ASSERT(pCallBackFlags != NULL);
 587
 588     RTEST(puD3dCallbacks != NULL);
 589     ASSERT(puD3dCallbacks != NULL);
 590
 591     RTEST(puD3dDriverData != NULL);
 592     ASSERT(puD3dDriverData != NULL);
 593
 594     RTEST(puD3dBufferCallbacks != NULL);
 595     ASSERT(puD3dDriverData != NULL);
 596
 597     RTEST(puD3dTextureFormats != NULL);
 598     ASSERT(puD3dTextureFormats != NULL);
 599
 600     RTEST(puNumFourCC == NULL);
 601     RTEST(puFourCC == NULL);
 602     RTEST(puNumHeaps == NULL);
 603     RTEST(puvmList == NULL);
 604
 605     /* We retesting the flags */
 606     RTEST(pCallBackFlags[0] != 0);
 607     RTEST(pCallBackFlags[1] != 0);
 608     RTEST(pCallBackFlags[2] == 0);
 609
 610     /* We do not retesting instead we compare it */
 611     RTEST(memcmp(&oldHalInfo, pHalInfo, sizeof(DD_HALINFO)) == 0);
 612     RTEST(memcmp(&oldD3dCallbacks, puD3dCallbacks, sizeof(D3DNTHAL_CALLBACKS)) == 0);
 613     RTEST(memcmp(&oldD3dDriverData, puD3dDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA)) == 0);
 614     RTEST(memcmp(&oldD3dBufferCallbacks, puD3dBufferCallbacks, sizeof(DD_D3DBUFCALLBACKS)) == 0);
 615
 616     /* start test of dwNumTextureFormats */
 617     if (puD3dDriverData->dwNumTextureFormats != 0)
 618     {
 619         myDesc = puD3dTextureFormats;
 620         for (dwTextureCounter=0;dwTextureCounter<puD3dDriverData->dwNumTextureFormats;dwTextureCounter++)
 621         {
 622             RTEST(myDesc->dwSize == sizeof(DDSURFACEDESC));
 623             ASSERT(myDesc->dwSize == sizeof(DDSURFACEDESC));
 624
 625             RTEST( (myDesc->dwFlags & (~(DDSD_CAPS|DDSD_PIXELFORMAT))) == 0);
 626             RTEST(myDesc->dwHeight == 0);
 627             RTEST(myDesc->dwWidth == 0);
 628             RTEST(myDesc->dwLinearSize == 0);
 629             RTEST(myDesc->dwBackBufferCount == 0);
 630             RTEST(myDesc->dwZBufferBitDepth == 0);
 631             RTEST(myDesc->dwAlphaBitDepth == 0);
 632             RTEST(myDesc->dwReserved == 0);
 633             RTEST(myDesc->lpSurface == 0);
 634             RTEST(myDesc->ddckCKDestOverlay.dwColorSpaceLowValue == 0);
 635             RTEST(myDesc->ddckCKDestOverlay.dwColorSpaceHighValue == 0);
 636             RTEST(myDesc->ddckCKDestBlt.dwColorSpaceLowValue == 0);
 637             RTEST(myDesc->ddckCKDestBlt.dwColorSpaceHighValue == 0);
 638             RTEST(myDesc->ddckCKSrcOverlay.dwColorSpaceLowValue == 0);
 639             RTEST(myDesc->ddckCKSrcOverlay.dwColorSpaceHighValue == 0);
 640             RTEST(myDesc->ddckCKSrcBlt.dwColorSpaceLowValue == 0);
 641             RTEST(myDesc->ddckCKSrcBlt.dwColorSpaceHighValue == 0);
 642             RTEST(myDesc->ddpfPixelFormat.dwSize == sizeof(DDPIXELFORMAT));
 643             RTEST(myDesc->ddpfPixelFormat.dwFlags != 0);
 644             if (myDesc->ddpfPixelFormat.dwFlags & DDPF_FOURCC)
 645             {
 646                 RTEST(myDesc->ddpfPixelFormat.dwFourCC != 0);
 647             }
 648             RTEST(myDesc->ddsCaps.dwCaps == DDSCAPS_TEXTURE);
 649
 650             myDesc = (DDSURFACEDESC *) (((DWORD) myDesc) + sizeof(DDSURFACEDESC));
 651         }
 652     }
 653
 654
 655     /* testing  NtGdiDdQueryDirectDrawObject( hDD, pHalInfo, pCallBackFlags, puD3dCallbacks, puD3dDriverData, puD3dBufferCallbacks, puD3dTextureFormats, puNumHeaps, NULL, */
 656     pHalInfo = &HalInfo;
 657     pCallBackFlags = CallBackFlags;
 658     puD3dCallbacks = &D3dCallbacks;
 659     puD3dDriverData = &D3dDriverData;
 660     puD3dBufferCallbacks = &D3dBufferCallbacks;
 661     puNumHeaps = &NumHeaps;
 662
 663     if (puD3dDriverData->dwNumTextureFormats != 0)
 664     {
 665         RtlZeroMemory(puD3dTextureFormats, puD3dDriverData->dwNumTextureFormats * sizeof(DDSURFACEDESC2));
 666     }
 667     RtlZeroMemory(pHalInfo,sizeof(DD_HALINFO));
 668     RtlZeroMemory(pCallBackFlags,sizeof(DWORD)*3);
 669     RtlZeroMemory(puD3dCallbacks,sizeof(D3DNTHAL_CALLBACKS));
 670     RtlZeroMemory(puD3dDriverData,sizeof(D3DNTHAL_GLOBALDRIVERDATA));
 671     RtlZeroMemory(&D3dBufferCallbacks,sizeof(DD_D3DBUFCALLBACKS));
 672
 673     RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
 674                                         pCallBackFlags, puD3dCallbacks,
 675                                         puD3dDriverData, puD3dBufferCallbacks,
 676                                         puD3dTextureFormats, puNumHeaps,
 677                                         puvmList, puNumFourCC,
 678                                         puFourCC)== FALSE);
 679
 680     RTEST(pHalInfo != NULL);
 681     ASSERT(pHalInfo != NULL);
 682
 683     RTEST(pCallBackFlags != NULL);
 684     ASSERT(pCallBackFlags != NULL);
 685
 686     RTEST(puD3dCallbacks != NULL);
 687     ASSERT(puD3dCallbacks != NULL);
 688
 689     RTEST(puD3dDriverData != NULL);
 690     ASSERT(puD3dDriverData != NULL);
 691
 692     RTEST(puD3dBufferCallbacks != NULL);
 693     ASSERT(puD3dDriverData != NULL);
 694
 695     RTEST(puD3dTextureFormats != NULL);
 696     ASSERT(puD3dTextureFormats != NULL);
 697
 698     RTEST(puNumHeaps != NULL);
 699     ASSERT(puNumHeaps != NULL);
 700     RTEST(NumHeaps == 0);
 701
 702     RTEST(puNumFourCC == NULL);
 703     RTEST(puFourCC == NULL);
 704
 705     RTEST(puvmList == NULL);
 706
 707     /* We retesting the flags */
 708     RTEST(pCallBackFlags[0] != 0);
 709     RTEST(pCallBackFlags[1] != 0);
 710     RTEST(pCallBackFlags[2] == 0);
 711
 712     /* We do not retesting instead we compare it */
 713     RTEST(memcmp(&oldHalInfo, pHalInfo, sizeof(DD_HALINFO)) == 0);
 714     RTEST(memcmp(&oldD3dCallbacks, puD3dCallbacks, sizeof(D3DNTHAL_CALLBACKS)) == 0);
 715     RTEST(memcmp(&oldD3dDriverData, puD3dDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA)) == 0);
 716     RTEST(memcmp(&oldD3dBufferCallbacks, puD3dBufferCallbacks, sizeof(DD_D3DBUFCALLBACKS)) == 0);
 717     /* we skip resting texture */
 718
 719
 720     /* testing  NtGdiDdQueryDirectDrawObject( hDD, pHalInfo, pCallBackFlags, puD3dCallbacks, puD3dDriverData, puD3dBufferCallbacks, puD3dTextureFormats, puNumHeaps, puvmList, NULL, */
 721     pHalInfo = &HalInfo;
 722     pCallBackFlags = CallBackFlags;
 723     puD3dCallbacks = &D3dCallbacks;
 724     puD3dDriverData = &D3dDriverData;
 725     puD3dBufferCallbacks = &D3dBufferCallbacks;
 726     puNumHeaps = &NumHeaps;
 727     puvmList = &vmList;
 728
 729     if (puD3dDriverData->dwNumTextureFormats != 0)
 730     {
 731         RtlZeroMemory(puD3dTextureFormats, puD3dDriverData->dwNumTextureFormats * sizeof(DDSURFACEDESC2));
 732     }
 733     RtlZeroMemory(pHalInfo,sizeof(DD_HALINFO));
 734     RtlZeroMemory(pCallBackFlags,sizeof(DWORD)*3);
 735     RtlZeroMemory(puD3dCallbacks,sizeof(D3DNTHAL_CALLBACKS));
 736     RtlZeroMemory(puD3dDriverData,sizeof(D3DNTHAL_GLOBALDRIVERDATA));
 737     RtlZeroMemory(&D3dBufferCallbacks,sizeof(DD_D3DBUFCALLBACKS));
 738
 739     RTEST(NtGdiDdQueryDirectDrawObject( hDirectDraw, pHalInfo,
 740                                         pCallBackFlags, puD3dCallbacks,
 741                                         puD3dDriverData, puD3dBufferCallbacks,
 742                                         puD3dTextureFormats, puNumHeaps,
 743                                         puvmList, puNumFourCC,
 744                                         puFourCC)== FALSE);
 745
 746     RTEST(pHalInfo != NULL);
 747     ASSERT(pHalInfo != NULL);
 748
 749     RTEST(pCallBackFlags != NULL);
 750     ASSERT(pCallBackFlags != NULL);
 751
 752     RTEST(puD3dCallbacks != NULL);
 753     ASSERT(puD3dCallbacks != NULL);
 754
 755     RTEST(puD3dDriverData != NULL);
 756     ASSERT(puD3dDriverData != NULL);
 757
 758     RTEST(puD3dBufferCallbacks != NULL);
 759     ASSERT(puD3dDriverData != NULL);
 760
 761     RTEST(puD3dTextureFormats != NULL);
 762     ASSERT(puD3dTextureFormats != NULL);
 763
 764     RTEST(puNumHeaps != NULL);
 765     ASSERT(puNumHeaps != NULL);
 766     RTEST(NumHeaps == 0);
 767
 768     RTEST(puvmList != NULL);
 769
 770     RTEST(puNumFourCC == NULL);
 771     RTEST(puFourCC == NULL);
 772
 773
 774
 775     /* We retesting the flags */
 776     RTEST(pCallBackFlags[0] != 0);
 777     RTEST(pCallBackFlags[1] != 0);
 778     RTEST(pCallBackFlags[2] == 0);
 779
 780     /* We do not retesting instead we compare it */
 781     RTEST(memcmp(&oldHalInfo, pHalInfo, sizeof(DD_HALINFO)) == 0);
 782     RTEST(memcmp(&oldD3dCallbacks, puD3dCallbacks, sizeof(D3DNTHAL_CALLBACKS)) == 0);
 783     RTEST(memcmp(&oldD3dDriverData, puD3dDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA)) == 0);
 784     RTEST(memcmp(&oldD3dBufferCallbacks, puD3dBufferCallbacks, sizeof(DD_D3DBUFCALLBACKS)) == 0);
 785     /* we skip resting texture */
 786
 787     /* Todo
 788     * adding test for
 789     * puNumFourCC
 790     * puFourCC
 791     */
 792
 793     /* Cleanup ReactX setup */
 794     DeleteDC(hdc);
 795     NtGdiDdDeleteDirectDrawObject(hDirectDraw);
 796 }