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