git.oblomov.eu Git - wine/blob - dlls/d3dcompiler_43/tests/asm.c

   1 /*
   2  * Copyright (C) 2010 Matteo Bruni
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18 #define COBJMACROS
  19 #include "wine/test.h"
  20
  21 #include <d3d9types.h>
  22 #include <d3dcommon.h>
  23 #include <d3dcompiler.h>
  24
  25 /* TODO: maybe this is defined in some header file,
  26    perhaps with a different name? */
  27 #define D3DXERR_INVALIDDATA                      0x88760b59
  28
  29 HRESULT WINAPI D3DAssemble(LPCVOID data, SIZE_T datasize, LPCSTR filename,
  30                            const D3D_SHADER_MACRO *defines, LPD3DINCLUDE include,
  31                            UINT flags,
  32                            LPD3DBLOB* shader, LPD3DBLOB* error_messages);
  33
  34 struct shader_test {
  35     const char *text;
  36     const DWORD bytes[128];
  37 };
  38
  39 static void dump_shader(DWORD *shader) {
  40     unsigned int i = 0, j = 0;
  41     do {
  42         trace("0x%08x ", shader[i]);
  43         j++;
  44         i++;
  45         if(j == 6) trace("\n");
  46     } while(shader[i - 1] != D3DSIO_END);
  47     if(j != 6) trace("\n");
  48 }
  49
  50 static void exec_tests(const char *name, struct shader_test tests[], unsigned int count) {
  51     HRESULT hr;
  52     DWORD *res;
  53     unsigned int i, j;
  54     BOOL diff;
  55     LPD3DBLOB shader, messages;
  56
  57     for(i = 0; i < count; i++) {
  58         /* D3DAssemble sets messages to 0 if there aren't error messages */
  59         messages = NULL;
  60         hr = D3DAssemble(tests[i].text, strlen(tests[i].text), NULL,
  61                          NULL, NULL, D3DCOMPILE_SKIP_VALIDATION,
  62                          &shader, &messages);
  63         ok(hr == S_OK, "Test %s, shader %d: D3DAssemble failed with error 0x%x - %d\n", name, i, hr, hr & 0x0000FFFF);
  64         if(messages) {
  65             trace("D3DAssemble messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages));
  66             ID3D10Blob_Release(messages);
  67         }
  68         if(FAILED(hr)) continue;
  69
  70         j = 0;
  71         diff = FALSE;
  72         res = ID3D10Blob_GetBufferPointer(shader);
  73         while(res[j] != D3DSIO_END && tests[i].bytes[j] != D3DSIO_END) {
  74             if(res[j] != tests[i].bytes[j]) diff = TRUE;
  75             j++;
  76         };
  77         /* Both must have an end token */
  78         if(res[j] != tests[i].bytes[j]) diff = TRUE;
  79
  80         if(diff) {
  81             ok(FALSE, "Test %s, shader %d: Generated code differs\n", name, i);
  82             dump_shader(res);
  83         }
  84         ID3D10Blob_Release(shader);
  85     }
  86 }
  87
  88 static void preproc_test(void) {
  89     struct shader_test tests[] = {
  90         {   /* shader 0 */
  91             "vs.1.1\r\n"
  92             "//some comments\r\n"
  93             "//other comments\n"
  94             "; yet another comment\r\n"
  95             "add r0, r0, r1\n",
  96             {0xfffe0101, 0x00000002, 0x800f0000, 0x80e40000, 0x80e40001, 0x0000ffff}
  97         },
  98         {   /* shader 1 */
  99             "#line 1 \"vertex.vsh\"\n"
 100             "vs.1.1\n",
 101             {0xfffe0101, 0x0000ffff}
 102         },
 103         {   /* shader 2 */
 104             "#define REG 1 + 2 +\\\n"
 105             "3 + 4\n"
 106             "vs.1.1\n"
 107             "mov r0, c0[ REG ]\n",
 108             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e4000a, 0x0000ffff}
 109         },
 110     };
 111
 112     exec_tests("preproc", tests, sizeof(tests) / sizeof(tests[0]));
 113 }
 114
 115 static void ps_1_1_test(void) {
 116     struct shader_test tests[] = {
 117         {   /* shader 0 */
 118             "ps.1.1\r\n"
 119             "tex t0\r\n"
 120             "add r0.rgb, r0, r1\r\n"
 121             "+mov r0.a, t0\r\n",
 122             {0xffff0101, 0x00000042, 0xb00f0000, 0x00000002, 0x80070000, 0x80e40000,
 123              0x80e40001, 0x40000001, 0x80080000, 0xb0e40000, 0x0000ffff}
 124         },
 125         {   /* shader 1 */
 126             "ps.1.1\n"
 127             "mov_d4 r0, r1\n",
 128             {0xffff0101, 0x00000001, 0x8e0f0000, 0x80e40001, 0x0000ffff}
 129         },
 130         {   /* shader 2 */
 131             "ps.1.1\n"
 132             "def c2, 0, 0., 0, 0.\n",
 133             {0xffff0101, 0x00000051, 0xa00f0002, 0x00000000, 0x00000000, 0x00000000,
 134              0x00000000, 0x0000ffff}
 135         },
 136     };
 137
 138     exec_tests("ps_1_1", tests, sizeof(tests) / sizeof(tests[0]));
 139 }
 140
 141 static void vs_1_1_test(void) {
 142     struct shader_test tests[] = {
 143         /* Basic instruction tests */
 144         {   /* shader 0 */
 145             "vs_1_1\n"
 146             "add r0, r1, r2\n",
 147             {0xfffe0101, 0x00000002, 0x800f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
 148         },
 149         {   /* shader 1 */
 150             "vs_1_1\n"
 151             "nop\n",
 152             {0xfffe0101, 0x00000000, 0x0000ffff}
 153         },
 154         /* Output register tests */
 155         {   /* shader 2 */
 156             "vs_1_1\n"
 157             "mov oPos, c0\n",
 158             {0xfffe0101, 0x00000001, 0xc00f0000, 0xa0e40000, 0x0000ffff}
 159         },
 160         {   /* shader 3 */
 161             "vs_1_1\n"
 162             "mov oT0, c0\n",
 163             {0xfffe0101, 0x00000001, 0xe00f0000, 0xa0e40000, 0x0000ffff}
 164         },
 165         {   /* shader 4 */
 166             "vs_1_1\n"
 167             "mov oT5, c0\n",
 168             {0xfffe0101, 0x00000001, 0xe00f0005, 0xa0e40000, 0x0000ffff}
 169         },
 170         {   /* shader 5 */
 171             "vs_1_1\n"
 172             "mov oD0, c0\n",
 173             {0xfffe0101, 0x00000001, 0xd00f0000, 0xa0e40000, 0x0000ffff}
 174         },
 175         {   /* shader 6 */
 176             "vs_1_1\n"
 177             "mov oD1, c0\n",
 178             {0xfffe0101, 0x00000001, 0xd00f0001, 0xa0e40000, 0x0000ffff}
 179         },
 180         {   /* shader 7 */
 181             "vs_1_1\n"
 182             "mov oFog, c0.x\n",
 183             {0xfffe0101, 0x00000001, 0xc00f0001, 0xa0000000, 0x0000ffff}
 184         },
 185         {   /* shader 8 */
 186             "vs_1_1\n"
 187             "mov oPts, c0.x\n",
 188             {0xfffe0101, 0x00000001, 0xc00f0002, 0xa0000000, 0x0000ffff}
 189         },
 190         /* A bunch of tests for declarations */
 191         {   /* shader 9 */
 192             "vs_1_1\n"
 193             "dcl_position0 v0",
 194             {0xfffe0101, 0x0000001f, 0x80000000, 0x900f0000, 0x0000ffff}
 195         },
 196         {   /* shader 10 */
 197             "vs_1_1\n"
 198             "dcl_position v1",
 199             {0xfffe0101, 0x0000001f, 0x80000000, 0x900f0001, 0x0000ffff}
 200         },
 201         {   /* shader 11 */
 202             "vs_1_1\n"
 203             "dcl_normal12 v15",
 204             {0xfffe0101, 0x0000001f, 0x800c0003, 0x900f000f, 0x0000ffff}
 205         },
 206         {   /* shader 12 */
 207             "vs_1_1\n"
 208             "add r0, v0, v1\n",
 209             {0xfffe0101, 0x00000002, 0x800f0000, 0x90e40000, 0x90e40001, 0x0000ffff}
 210         },
 211         {   /* shader 13 */
 212             "vs_1_1\n"
 213             "def c12, 0, -1, -0.5, 1024\n",
 214             {0xfffe0101, 0x00000051, 0xa00f000c, 0x00000000, 0xbf800000, 0xbf000000,
 215              0x44800000, 0x0000ffff}
 216         },
 217         {   /* shader 14: writemasks, swizzles */
 218             "vs_1_1\n"
 219             "dp4 r0.xw, r1.wzyx, r2.xxww\n",
 220             {0xfffe0101, 0x00000009, 0x80090000, 0x801b0001, 0x80f00002, 0x0000ffff}
 221         },
 222         {   /* shader 15: negation input modifier. Other modifiers not supprted in vs_1_1 */
 223             "vs_1_1\n"
 224             "add r0, -r0.x, -r1\n",
 225             {0xfffe0101, 0x00000002, 0x800f0000, 0x81000000, 0x81e40001, 0x0000ffff}
 226         },
 227         {   /* shader 16: relative addressing */
 228             "vs_1_1\n"
 229             "mov r0, c0[a0.x]\n",
 230             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e42000, 0x0000ffff}
 231         },
 232         {   /* shader 17: relative addressing */
 233             "vs_1_1\n"
 234             "mov r0, c1[a0.x + 2]\n",
 235             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e42003, 0x0000ffff}
 236         },
 237         {   /* shader 18 */
 238             "vs_1_1\n"
 239             "def c0, 1.0f, 1.0f, 1.0f, 0.5f\n",
 240             {0xfffe0101, 0x00000051, 0xa00f0000, 0x3f800000, 0x3f800000, 0x3f800000,
 241              0x3f000000, 0x0000ffff}
 242         },
 243         /* Other relative addressing tests */
 244         {   /* shader 19 */
 245             "vs_1_1\n"
 246             "mov r0, c[ a0.x + 12 ]\n",
 247             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e4200c, 0x0000ffff}
 248         },
 249         {   /* shader 20 */
 250             "vs_1_1\n"
 251             "mov r0, c[ 2 + a0.x ]\n",
 252             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e42002, 0x0000ffff}
 253         },
 254         {   /* shader 21 */
 255             "vs_1_1\n"
 256             "mov r0, c[ 2 + a0.x + 12 ]\n",
 257             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e4200e, 0x0000ffff}
 258         },
 259         {   /* shader 22 */
 260             "vs_1_1\n"
 261             "mov r0, c[ 2 + 10 + 12 ]\n",
 262             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e40018, 0x0000ffff}
 263         },
 264         {   /* shader 23 */
 265             "vs_1_1\n"
 266             "mov r0, c4[ 2 ]\n",
 267             {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e40006, 0x0000ffff}
 268         },
 269         {   /* shader 24 */
 270             "vs_1_1\n"
 271             "rcp r0, v0.x\n",
 272             {0xfffe0101, 0x00000006, 0x800f0000, 0x90000000, 0x0000ffff}
 273         },
 274         {   /* shader 25 */
 275             "vs_1_1\n"
 276             "rsq r0, v0.x\n",
 277             {0xfffe0101, 0x00000007, 0x800f0000, 0x90000000, 0x0000ffff}
 278         },
 279     };
 280
 281     exec_tests("vs_1_1", tests, sizeof(tests) / sizeof(tests[0]));
 282 }
 283
 284 static void ps_1_3_test(void) {
 285     struct shader_test tests[] = {
 286         /* Basic instruction tests */
 287         {   /* shader 0 */
 288             "ps_1_3\n"
 289             "mov r0, r1\n",
 290             {0xffff0103, 0x00000001, 0x800f0000, 0x80e40001, 0x0000ffff}
 291         },
 292         {   /* shader 1 */
 293             "ps_1_3\n"
 294             "add r0, r1, r0\n",
 295             {0xffff0103, 0x00000002, 0x800f0000, 0x80e40001, 0x80e40000, 0x0000ffff}
 296         },
 297         /* Color interpolator tests */
 298         {   /* shader 2 */
 299             "ps_1_3\n"
 300             "mov r0, v0\n",
 301             {0xffff0103, 0x00000001, 0x800f0000, 0x90e40000, 0x0000ffff}
 302         },
 303         {   /* shader 3 */
 304             "ps_1_3\n"
 305             "mov r0, v1\n",
 306             {0xffff0103, 0x00000001, 0x800f0000, 0x90e40001, 0x0000ffff}
 307         },
 308         /* Texture sampling instructions */
 309         {   /* shader 4 */
 310             "ps_1_3\n"
 311             "tex t0\n",
 312             {0xffff0103, 0x00000042, 0xb00f0000, 0x0000ffff}
 313         },
 314         {   /* shader 5 */
 315             "ps_1_3\n"
 316             "tex t0\n"
 317             "texreg2ar t1, t0\n",
 318             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000045, 0xb00f0001, 0xb0e40000,
 319              0x0000ffff}
 320         },
 321         {   /* shader 6 */
 322             "ps_1_3\n"
 323             "tex t0\n"
 324             "texreg2gb t1, t0\n",
 325             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000046, 0xb00f0001, 0xb0e40000,
 326              0x0000ffff}
 327         },
 328         {   /* shader 7 */
 329             "ps_1_3\n"
 330             "tex t0\n"
 331             "texreg2rgb t1, t0\n",
 332             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000052, 0xb00f0001, 0xb0e40000,
 333              0x0000ffff}
 334         },
 335         {   /* shader 8 */
 336             "ps_1_3\n"
 337             "cnd r0, r1, r0, v0\n",
 338             {0xffff0103, 0x00000050, 0x800f0000, 0x80e40001, 0x80e40000, 0x90e40000,
 339              0x0000ffff}
 340         },
 341         {   /* shader 9 */
 342             "ps_1_3\n"
 343             "cmp r0, r1, r0, v0\n",
 344             {0xffff0103, 0x00000058, 0x800f0000, 0x80e40001, 0x80e40000, 0x90e40000,
 345              0x0000ffff}
 346         },
 347         {   /* shader 10 */
 348             "ps_1_3\n"
 349             "texkill t0\n",
 350             {0xffff0103, 0x00000041, 0xb00f0000, 0x0000ffff}
 351         },
 352         {   /* shader 11 */
 353             "ps_1_3\n"
 354             "tex t0\n"
 355             "texm3x2pad t1, t0\n"
 356             "texm3x2tex t2, t0\n",
 357             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000047, 0xb00f0001, 0xb0e40000,
 358              0x00000048, 0xb00f0002, 0xb0e40000, 0x0000ffff}
 359         },
 360         {   /* shader 12 */
 361             "ps_1_3\n"
 362             "tex t0\n"
 363             "texm3x2pad t1, t0\n"
 364             "texm3x2depth t2, t0\n",
 365             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000047, 0xb00f0001, 0xb0e40000,
 366              0x00000054, 0xb00f0002, 0xb0e40000, 0x0000ffff}
 367         },
 368         {   /* shader 13 */
 369             "ps_1_3\n"
 370             "tex t0\n"
 371             "texbem t1, t0\n",
 372             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000043, 0xb00f0001, 0xb0e40000,
 373              0x0000ffff}
 374         },
 375         {   /* shader 14 */
 376             "ps_1_3\n"
 377             "tex t0\n"
 378             "texbeml t1, t0\n",
 379             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000044, 0xb00f0001, 0xb0e40000,
 380              0x0000ffff}
 381         },
 382         {   /* shader 15 */
 383             "ps_1_3\n"
 384             "tex t0\n"
 385             "texdp3tex t1, t0\n",
 386             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000053, 0xb00f0001, 0xb0e40000,
 387              0x0000ffff}
 388         },
 389         {   /* shader 16 */
 390             "ps_1_3\n"
 391             "tex t0\n"
 392             "texdp3 t1, t0\n",
 393             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000055, 0xb00f0001, 0xb0e40000,
 394              0x0000ffff}
 395         },
 396         {   /* shader 17 */
 397             "ps_1_3\n"
 398             "tex t0\n"
 399             "texm3x3pad t1, t0\n"
 400             "texm3x3pad t2, t0\n"
 401             "texm3x3tex t3, t0\n",
 402             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
 403              0x00000049, 0xb00f0002, 0xb0e40000, 0x0000004a, 0xb00f0003, 0xb0e40000,
 404              0x0000ffff}
 405         },
 406         {   /* shader 18 */
 407             "ps_1_3\n"
 408             "tex t0\n"
 409             "texm3x3pad t1, t0\n"
 410             "texm3x3pad t2, t0\n"
 411             "texm3x3 t3, t0\n",
 412             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
 413              0x00000049, 0xb00f0002, 0xb0e40000, 0x00000056, 0xb00f0003, 0xb0e40000,
 414              0x0000ffff}
 415         },
 416         {   /* shader 19 */
 417             "ps_1_3\n"
 418             "tex t0\n"
 419             "texm3x3pad t1, t0\n"
 420             "texm3x3pad t2, t0\n"
 421             "texm3x3spec t3, t0, c0\n",
 422             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
 423              0x00000049, 0xb00f0002, 0xb0e40000, 0x0000004c, 0xb00f0003, 0xb0e40000,
 424              0xa0e40000, 0x0000ffff}
 425         },
 426         {   /* shader 20 */
 427             "ps_1_3\n"
 428             "tex t0\n"
 429             "texm3x3pad t1, t0\n"
 430             "texm3x3pad t2, t0\n"
 431             "texm3x3vspec t3, t0\n",
 432             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
 433              0x00000049, 0xb00f0002, 0xb0e40000, 0x0000004d, 0xb00f0003, 0xb0e40000,
 434              0x0000ffff}
 435         },
 436         {   /* shader 21 */
 437             "ps_1_3\n"
 438             "texcoord t0\n",
 439             {0xffff0103, 0x00000040, 0xb00f0000, 0x0000ffff}
 440         },
 441         /* Modifiers, shifts */
 442         {   /* shader 22 */
 443             "ps_1_3\n"
 444             "mov_x2_sat r0, 1 - r1\n",
 445             {0xffff0103, 0x00000001, 0x811f0000, 0x86e40001, 0x0000ffff}
 446         },
 447         {   /* shader 23 */
 448             "ps_1_3\n"
 449             "mov_d8 r0, -r1\n",
 450             {0xffff0103, 0x00000001, 0x8d0f0000, 0x81e40001, 0x0000ffff}
 451         },
 452         {   /* shader 24 */
 453             "ps_1_3\n"
 454             "mov_sat r0, r1_bx2\n",
 455             {0xffff0103, 0x00000001, 0x801f0000, 0x84e40001, 0x0000ffff}
 456         },
 457         {   /* shader 25 */
 458             "ps_1_3\n"
 459             "mov_sat r0, r1_bias\n",
 460             {0xffff0103, 0x00000001, 0x801f0000, 0x82e40001, 0x0000ffff}
 461         },
 462         {   /* shader 26 */
 463             "ps_1_3\n"
 464             "mov_sat r0, -r1_bias\n",
 465             {0xffff0103, 0x00000001, 0x801f0000, 0x83e40001, 0x0000ffff}
 466         },
 467         {   /* shader 27 */
 468             "ps_1_3\n"
 469             "mov_sat r0, -r1_bx2\n",
 470             {0xffff0103, 0x00000001, 0x801f0000, 0x85e40001, 0x0000ffff}
 471         },
 472         {   /* shader 28 */
 473             "ps_1_3\n"
 474             "mov_sat r0, -r1_x2\n",
 475             {0xffff0103, 0x00000001, 0x801f0000, 0x88e40001, 0x0000ffff}
 476         },
 477         {   /* shader 29 */
 478             "ps_1_3\n"
 479             "mov_x4_sat r0.a, -r1_bx2.a\n",
 480             {0xffff0103, 0x00000001, 0x82180000, 0x85ff0001, 0x0000ffff}
 481         },
 482         {   /* shader 30 */
 483             "ps_1_3\n"
 484             "texcoord_x2 t0\n",
 485             {0xffff0103, 0x00000040, 0xb10f0000, 0x0000ffff}
 486         },
 487         {   /* shader 31 */
 488             "ps_1_3\n"
 489             "tex_x2 t0\n",
 490             {0xffff0103, 0x00000042, 0xb10f0000, 0x0000ffff}
 491         },
 492         {   /* shader 32 */
 493             "ps_1_3\n"
 494             "texreg2ar_x4 t0, t1\n",
 495             {0xffff0103, 0x00000045, 0xb20f0000, 0xb0e40001, 0x0000ffff}
 496         },
 497         {   /* shader 33 */
 498             "ps_1_3\n"
 499             "texbem_d4 t1, t0\n",
 500             {0xffff0103, 0x00000043, 0xbe0f0001, 0xb0e40000, 0x0000ffff}
 501         },
 502         {   /* shader 34 */
 503             "ps_1_3\n"
 504             "tex t0\n"
 505             "texm3x3pad_x2 t1, t0\n"
 506             "texm3x3pad_x2 t2, t0\n"
 507             "texm3x3tex_x2 t3, t0\n",
 508             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb10f0001, 0xb0e40000,
 509              0x00000049, 0xb10f0002, 0xb0e40000, 0x0000004a, 0xb10f0003, 0xb0e40000,
 510              0x0000ffff}
 511         },
 512         {   /* shader 35 */
 513             "ps_1_3\n"
 514             "tex t0\n"
 515             "texdp3tex_x8 t1, t0\n",
 516             {0xffff0103, 0x00000042, 0xb00f0000, 0x00000053, 0xb30f0001, 0xb0e40000,
 517              0x0000ffff}
 518         },
 519     };
 520
 521     exec_tests("ps_1_3", tests, sizeof(tests) / sizeof(tests[0]));
 522 }
 523
 524 static void ps_1_4_test(void) {
 525     struct shader_test tests[] = {
 526         /* Basic instruction tests */
 527         {   /* shader 0 */
 528             "ps_1_4\n"
 529             "mov r0, r1\n",
 530             {0xffff0104, 0x00000001, 0x800f0000, 0x80e40001, 0x0000ffff}
 531         },
 532         {   /* shader 1 */
 533             "ps_1_4\n"
 534             "mov r0, r5\n",
 535             {0xffff0104, 0x00000001, 0x800f0000, 0x80e40005, 0x0000ffff}
 536         },
 537         {   /* shader 2 */
 538             "ps_1_4\n"
 539             "mov r0, c7\n",
 540             {0xffff0104, 0x00000001, 0x800f0000, 0xa0e40007, 0x0000ffff}
 541         },
 542         {   /* shader 3 */
 543             "ps_1_4\n"
 544             "mov r0, v1\n",
 545             {0xffff0104, 0x00000001, 0x800f0000, 0x90e40001, 0x0000ffff}
 546         },
 547         {   /* shader 4 */
 548             "ps_1_4\n"
 549             "phase\n",
 550             {0xffff0104, 0x0000fffd, 0x0000ffff}
 551         },
 552         {   /* shader 5 */
 553             "ps_1_4\n"
 554             "texcrd r0, t0\n",
 555             {0xffff0104, 0x00000040, 0x800f0000, 0xb0e40000, 0x0000ffff}
 556         },
 557         {   /* shader 6 */
 558             "ps_1_4\n"
 559             "texcrd r4, t3\n",
 560             {0xffff0104, 0x00000040, 0x800f0004, 0xb0e40003, 0x0000ffff}
 561         },
 562         {   /* shader 7 */
 563             "ps_1_4\n"
 564             "texcrd_sat r4, t3\n",
 565             {0xffff0104, 0x00000040, 0x801f0004, 0xb0e40003, 0x0000ffff}
 566         },
 567         {   /* shader 8 */
 568             "ps_1_4\n"
 569             "texld r0, t0\n",
 570             {0xffff0104, 0x00000042, 0x800f0000, 0xb0e40000, 0x0000ffff}
 571         },
 572         {   /* shader 9 */
 573             "ps_1_4\n"
 574             "texld r1, t4\n",
 575             {0xffff0104, 0x00000042, 0x800f0001, 0xb0e40004, 0x0000ffff}
 576         },
 577         {   /* shader 10 */
 578             "ps_1_4\n"
 579             "texld r5, r0\n",
 580             {0xffff0104, 0x00000042, 0x800f0005, 0x80e40000, 0x0000ffff}
 581         },
 582         {   /* shader 11 */
 583             "ps_1_4\n"
 584             "texld r5, c0\n", /* Assembly succeeds, validation fails */
 585             {0xffff0104, 0x00000042, 0x800f0005, 0xa0e40000, 0x0000ffff}
 586         },
 587         {   /* shader 12 */
 588             "ps_1_4\n"
 589             "texld r5, r2_dz\n",
 590             {0xffff0104, 0x00000042, 0x800f0005, 0x89e40002, 0x0000ffff}
 591         },
 592         {   /* shader 13 */
 593             "ps_1_4\n"
 594             "bem r1.rg, c0, r0\n",
 595             {0xffff0104, 0x00000059, 0x80030001, 0xa0e40000, 0x80e40000, 0x0000ffff}
 596         },
 597         {   /* shader 14 */
 598             "ps_1_4\n"
 599             "texdepth r5\n",
 600             {0xffff0104, 0x00000057, 0x800f0005, 0x0000ffff}
 601         },
 602         {   /* shader 15 */
 603             "ps_1_4\n"
 604             "add r0, r1, r2_bx2\n",
 605             {0xffff0104, 0x00000002, 0x800f0000, 0x80e40001, 0x84e40002, 0x0000ffff}
 606         },
 607         {   /* shader 16 */
 608             "ps_1_4\n"
 609             "add_x4 r0, r1, r2\n",
 610             {0xffff0104, 0x00000002, 0x820f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
 611         },
 612         {   /* shader 17 */
 613             "ps_1_4\n"
 614             "add r0.rgb, r1, r2\n"
 615             "+add r0.a, r1, r2\n",
 616             {0xffff0104, 0x00000002, 0x80070000, 0x80e40001, 0x80e40002, 0x40000002,
 617              0x80080000, 0x80e40001, 0x80e40002, 0x0000ffff}
 618         },
 619         {   /* shader 18 */
 620             "ps_1_4\n"
 621             "texdepth_x2 r5\n",
 622             {0xffff0104, 0x00000057, 0x810f0005, 0x0000ffff}
 623         },
 624         {   /* shader 18 */
 625             "ps_1_4\n"
 626             "bem_d2 r1, c0, r0\n",
 627             {0xffff0104, 0x00000059, 0x8f0f0001, 0xa0e40000, 0x80e40000, 0x0000ffff}
 628         },
 629     };
 630
 631     exec_tests("ps_1_4", tests, sizeof(tests) / sizeof(tests[0]));
 632 }
 633
 634 static void vs_2_0_test(void) {
 635     struct shader_test tests[] = {
 636         /* Basic instruction tests */
 637         {   /* shader 0 */
 638             "vs_2_0\n"
 639             "mov r0, r1\n",
 640             {0xfffe0200, 0x02000001, 0x800f0000, 0x80e40001, 0x0000ffff}
 641         },
 642         {   /* shader 1 */
 643             "vs_2_0\n"
 644             "lrp r0, v0, c0, r1\n",
 645             {0xfffe0200, 0x04000012, 0x800f0000, 0x90e40000, 0xa0e40000, 0x80e40001,
 646              0x0000ffff}
 647         },
 648         {   /* shader 2 */
 649             "vs_2_0\n"
 650             "dp4 oPos, v0, c0\n",
 651             {0xfffe0200, 0x03000009, 0xc00f0000, 0x90e40000, 0xa0e40000, 0x0000ffff}
 652         },
 653         {   /* shader 3 */
 654             "vs_2_0\n"
 655             "mov r0, c0[a0.x]\n",
 656             {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0000000, 0x0000ffff}
 657         },
 658         {   /* shader 4 */
 659             "vs_2_0\n"
 660             "mov r0, c0[a0.y]\n",
 661             {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0550000, 0x0000ffff}
 662         },
 663         {   /* shader 5 */
 664             "vs_2_0\n"
 665             "mov r0, c0[a0.z]\n",
 666             {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0aa0000, 0x0000ffff}
 667         },
 668         {   /* shader 6 */
 669             "vs_2_0\n"
 670             "mov r0, c0[a0.w]\n",
 671             {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0ff0000, 0x0000ffff}
 672         },
 673         {   /* shader 7 */
 674             "vs_2_0\n"
 675             "mov r0, c0[a0.w].x\n",
 676             {0xfffe0200, 0x03000001, 0x800f0000, 0xa0002000, 0xb0ff0000, 0x0000ffff}
 677         },
 678         {   /* shader 8 */
 679             "vs_2_0\n"
 680             "mov r0, -c0[a0.w+5].x\n",
 681             {0xfffe0200, 0x03000001, 0x800f0000, 0xa1002005, 0xb0ff0000, 0x0000ffff}
 682         },
 683         {   /* shader 9 */
 684             "vs_2_0\n"
 685             "mov r0, c0[a0]\n",
 686             {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0e40000, 0x0000ffff}
 687         },
 688         {   /* shader 10 */
 689             "vs_2_0\n"
 690             "mov r0, c0[a0.xyww]\n",
 691             {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0f40000, 0x0000ffff}
 692         },
 693         {   /* shader 11 */
 694             "vs_2_0\n"
 695             "add r0, c0[a0.x], c1[a0.y]\n", /* validation would fail on this line */
 696             {0xfffe0200, 0x05000002, 0x800f0000, 0xa0e42000, 0xb0000000, 0xa0e42001,
 697              0xb0550000, 0x0000ffff}
 698         },
 699         {   /* shader 12 */
 700             "vs_2_0\n"
 701             "rep i0\n"
 702             "endrep\n",
 703             {0xfffe0200, 0x01000026, 0xf0e40000, 0x00000027, 0x0000ffff}
 704         },
 705         {   /* shader 13 */
 706             "vs_2_0\n"
 707             "if b0\n"
 708             "else\n"
 709             "endif\n",
 710             {0xfffe0200, 0x01000028, 0xe0e40800, 0x0000002a, 0x0000002b, 0x0000ffff}
 711         },
 712         {   /* shader 14 */
 713             "vs_2_0\n"
 714             "loop aL, i0\n"
 715             "endloop\n",
 716             {0xfffe0200, 0x0200001b, 0xf0e40800, 0xf0e40000, 0x0000001d, 0x0000ffff}
 717         },
 718         {   /* shader 15 */
 719             "vs_2_0\n"
 720             "nrm r0, c0\n",
 721             {0xfffe0200, 0x02000024, 0x800f0000, 0xa0e40000, 0x0000ffff}
 722         },
 723         {   /* shader 16 */
 724             "vs_2_0\n"
 725             "crs r0, r1, r2\n",
 726             {0xfffe0200, 0x03000021, 0x800f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
 727         },
 728         {   /* shader 17 */
 729             "vs_2_0\n"
 730             "sgn r0, r1, r2, r3\n",
 731             {0xfffe0200, 0x04000022, 0x800f0000, 0x80e40001, 0x80e40002, 0x80e40003,
 732              0x0000ffff}
 733         },
 734         {   /* shader 18 */
 735             "vs_2_0\n"
 736             "sincos r0, r1, r2, r3\n",
 737             {0xfffe0200, 0x04000025, 0x800f0000, 0x80e40001, 0x80e40002, 0x80e40003,
 738              0x0000ffff}
 739         },
 740         {   /* shader 19 */
 741             "vs_2_0\n"
 742             "pow r0, r1, r2\n",
 743             {0xfffe0200, 0x03000020, 0x800f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
 744         },
 745         {   /* shader 20 */
 746             "vs_2_0\n"
 747             "mova a0.y, c0.z\n",
 748             {0xfffe0200, 0x0200002e, 0xb0020000, 0xa0aa0000, 0x0000ffff}
 749         },
 750         {   /* shader 21 */
 751             "vs_2_0\n"
 752             "defb b0, true\n"
 753             "defb b1, false\n",
 754             {0xfffe0200, 0x0200002f, 0xe00f0800, 0x00000001, 0x0200002f, 0xe00f0801,
 755              0x00000000, 0x0000ffff}
 756         },
 757         {   /* shader 22 */
 758             "vs_2_0\n"
 759             "defi i0, -1, 1, 10, 0\n"
 760             "defi i1, 0, 40, 30, 10\n",
 761             {0xfffe0200, 0x05000030, 0xf00f0000, 0xffffffff, 0x00000001, 0x0000000a,
 762              0x00000000, 0x05000030, 0xf00f0001, 0x00000000, 0x00000028, 0x0000001e,
 763              0x0000000a, 0x0000ffff}
 764         },
 765         {   /* shader 23 */
 766             "vs_2_0\n"
 767             "loop aL, i0\n"
 768             "mov r0, c0[aL]\n"
 769             "endloop\n",
 770             {0xfffe0200, 0x0200001b, 0xf0e40800, 0xf0e40000, 0x03000001, 0x800f0000,
 771              0xa0e42000, 0xf0e40800, 0x0000001d, 0x0000ffff}
 772         },
 773         {   /* shader 24 */
 774             "vs_2_0\n"
 775             "call l0\n"
 776             "ret\n"
 777             "label l0\n"
 778             "ret\n",
 779             {0xfffe0200, 0x01000019, 0xa0e41000, 0x0000001c, 0x0100001e, 0xa0e41000,
 780              0x0000001c, 0x0000ffff}
 781         },
 782         {   /* shader 25 */
 783             "vs_2_0\n"
 784             "callnz l0, b0\n"
 785             "ret\n"
 786             "label l0\n"
 787             "ret\n",
 788             {0xfffe0200, 0x0200001a, 0xa0e41000, 0xe0e40800, 0x0000001c, 0x0100001e,
 789              0xa0e41000, 0x0000001c, 0x0000ffff}
 790         },
 791         {   /* shader 26 */
 792             "vs_2_0\n"
 793             "callnz l0, !b0\n"
 794             "ret\n"
 795             "label l0\n"
 796             "ret\n",
 797             {0xfffe0200, 0x0200001a, 0xa0e41000, 0xede40800, 0x0000001c, 0x0100001e,
 798              0xa0e41000, 0x0000001c, 0x0000ffff}
 799         },
 800         {   /* shader 27 */
 801             "vs_2_0\n"
 802             "if !b0\n"
 803             "else\n"
 804             "endif\n",
 805             {0xfffe0200, 0x01000028, 0xede40800, 0x0000002a, 0x0000002b, 0x0000ffff}
 806         },
 807         {   /* shader 28 */
 808             "vs_2_0\n"
 809             "call l3\n"
 810             "ret\n"
 811             "label l3\n"
 812             "ret\n",
 813             {0xfffe0200, 0x01000019, 0xa0e41003, 0x0000001c, 0x0100001e, 0xa0e41003, 0x0000001c, 0x0000ffff}
 814         },
 815         {   /* shader 29: labels up to 2047 are accepted even in vs_2_0 */
 816             "vs_2_0\n"
 817             "call l2047\n",
 818             {0xfffe0200, 0x01000019, 0xa0e417ff, 0x0000ffff}
 819         },
 820     };
 821
 822     exec_tests("vs_2_0", tests, sizeof(tests) / sizeof(tests[0]));
 823 }
 824
 825 static void vs_2_x_test(void) {
 826     struct shader_test tests[] = {
 827         {   /* shader 0 */
 828             "vs_2_x\n"
 829             "rep i0\n"
 830             "break\n"
 831             "endrep\n",
 832             {0xfffe0201, 0x01000026, 0xf0e40000, 0x0000002c, 0x00000027, 0x0000ffff}
 833         },
 834         {   /* shader 1 */
 835             "vs_2_x\n"
 836             "if_ge r0, r1\n"
 837             "endif\n",
 838             {0xfffe0201, 0x02030029, 0x80e40000, 0x80e40001, 0x0000002b, 0x0000ffff}
 839         },
 840         {   /* shader 2 */
 841             "vs_2_x\n"
 842             "rep i0\n"
 843             "break_ne r0, r1\n"
 844             "endrep",
 845             {0xfffe0201, 0x01000026, 0xf0e40000, 0x0205002d, 0x80e40000, 0x80e40001,
 846              0x00000027, 0x0000ffff}
 847         },
 848
 849         /* predicates */
 850         {   /* shader 3 */
 851             "vs_2_x\n"
 852             "setp_gt p0, r0, r1\n"
 853             "(!p0) add r2, r2, r3\n",
 854             {0xfffe0201, 0x0301005e, 0xb00f1000, 0x80e40000, 0x80e40001, 0x14000002,
 855              0x800f0002, 0xbde41000, 0x80e40002, 0x80e40003, 0x0000ffff}
 856         },
 857         {   /* shader 4 */
 858             "vs_2_x\n"
 859             "if p0.x\n"
 860             "else\n"
 861             "endif\n",
 862             {0xfffe0201, 0x01000028, 0xb0001000, 0x0000002a, 0x0000002b, 0x0000ffff}
 863         },
 864         {   /* shader 5 */
 865             "vs_2_x\n"
 866             "callnz l0, !p0.z\n"
 867             "ret\n"
 868             "label l0\n"
 869             "ret\n",
 870             {0xfffe0201, 0x0200001a, 0xa0e41000, 0xbdaa1000, 0x0000001c,
 871              0x0100001e, 0xa0e41000, 0x0000001c, 0x0000ffff}
 872         },
 873         {   /* shader 6 */
 874             "vs_2_x\n"
 875             "rep i0\n"
 876             "breakp p0.w\n"
 877             "endrep\n",
 878             {0xfffe0201, 0x01000026, 0xf0e40000, 0x01000060, 0xb0ff1000,
 879              0x00000027, 0x0000ffff}
 880         },
 881     };
 882
 883     exec_tests("vs_2_x", tests, sizeof(tests) / sizeof(tests[0]));
 884 }
 885
 886 static void ps_2_0_test(void) {
 887     struct shader_test tests[] = {
 888         {   /* shader 0 */
 889             "ps_2_0\n"
 890             "dcl_2d s0\n",
 891             {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0800, 0x0000ffff}
 892         },
 893         {   /* shader 1 */
 894             "ps_2_0\n"
 895             "dcl_cube s0\n",
 896             {0xffff0200, 0x0200001f, 0x98000000, 0xa00f0800, 0x0000ffff}
 897         },
 898         {   /* shader 2 */
 899             "ps_2_0\n"
 900             "dcl_volume s0\n",
 901             {0xffff0200, 0x0200001f, 0xa0000000, 0xa00f0800, 0x0000ffff}
 902         },
 903         {   /* shader 3 */
 904             "ps_2_0\n"
 905             "dcl_volume s0\n"
 906             "dcl_cube s1\n"
 907             "dcl_2d s2\n",
 908             {0xffff0200, 0x0200001f, 0xa0000000, 0xa00f0800, 0x0200001f, 0x98000000,
 909              0xa00f0801, 0x0200001f, 0x90000000, 0xa00f0802, 0x0000ffff}
 910         },
 911         {   /* shader 4 */
 912             "ps_2_0\n"
 913             "mov r0, t0\n",
 914             {0xffff0200, 0x02000001, 0x800f0000, 0xb0e40000, 0x0000ffff}
 915         },
 916         {   /* shader 5 */
 917             "ps_2_0\n"
 918             "dcl_2d s2\n"
 919             "texld r0, t1, s2\n",
 920             {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0802, 0x03000042, 0x800f0000,
 921              0xb0e40001, 0xa0e40802, 0x0000ffff}
 922         },
 923         {   /* shader 6 */
 924             "ps_2_0\n"
 925             "texkill t0\n",
 926             {0xffff0200, 0x01000041, 0xb00f0000, 0x0000ffff}
 927         },
 928         {   /* shader 7 */
 929             "ps_2_0\n"
 930             "mov oC0, c0\n"
 931             "mov oC1, c1\n",
 932             {0xffff0200, 0x02000001, 0x800f0800, 0xa0e40000, 0x02000001, 0x800f0801,
 933              0xa0e40001, 0x0000ffff}
 934         },
 935         {   /* shader 8 */
 936             "ps_2_0\n"
 937             "mov oDepth, c0.x\n",
 938             {0xffff0200, 0x02000001, 0x900f0800, 0xa0000000, 0x0000ffff}
 939         },
 940         {   /* shader 9 */
 941             "ps_2_0\n"
 942             "dcl_2d s2\n"
 943             "texldp r0, t1, s2\n",
 944             {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0802, 0x03010042, 0x800f0000,
 945              0xb0e40001, 0xa0e40802, 0x0000ffff}
 946         },
 947         {   /* shader 10 */
 948             "ps_2_0\n"
 949             "dcl_2d s2\n"
 950             "texldb r0, t1, s2\n",
 951             {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0802, 0x03020042, 0x800f0000,
 952              0xb0e40001, 0xa0e40802, 0x0000ffff}
 953         },
 954     };
 955
 956     exec_tests("ps_2_0", tests, sizeof(tests) / sizeof(tests[0]));
 957 }
 958
 959 static void ps_2_x_test(void) {
 960     struct shader_test tests[] = {
 961         /* defb and defi are not supposed to work in ps_2_0 (even if defb actually works in ps_2_0 with native) */
 962         {   /* shader 0 */
 963             "ps_2_x\n"
 964             "defb b0, true\n"
 965             "defb b1, false\n",
 966             {0xffff0201, 0x0200002f, 0xe00f0800, 0x00000001, 0x0200002f, 0xe00f0801,
 967              0x00000000, 0x0000ffff}
 968         },
 969         {   /* shader 1 */
 970             "ps_2_x\n"
 971             "defi i0, -1, 1, 10, 0\n"
 972             "defi i1, 0, 40, 30, 10\n",
 973             {0xffff0201, 0x05000030, 0xf00f0000, 0xffffffff, 0x00000001, 0x0000000a,
 974              0x00000000, 0x05000030, 0xf00f0001, 0x00000000, 0x00000028, 0x0000001e,
 975              0x0000000a, 0x0000ffff}
 976         },
 977         {   /* shader 2 */
 978             "ps_2_x\n"
 979             "dsx r0, r0\n",
 980             {0xffff0201, 0x0200005b, 0x800f0000, 0x80e40000, 0x0000ffff}
 981         },
 982         {   /* shader 3 */
 983             "ps_2_x\n"
 984             "dsy r0, r0\n",
 985             {0xffff0201, 0x0200005c, 0x800f0000, 0x80e40000, 0x0000ffff}
 986         },
 987         {   /* shader 4 */
 988             "ps_2_x\n"
 989             "dcl_2d s2\n"
 990             "texldd r0, v1, s2, r3, r4\n",
 991             {0xffff0201, 0x0200001f, 0x90000000, 0xa00f0802, 0x0500005d, 0x800f0000,
 992              0x90e40001, 0xa0e40802, 0x80e40003, 0x80e40004, 0x0000ffff}
 993         },
 994         /* Static flow control tests */
 995         {   /* shader 5 */
 996             "ps_2_x\n"
 997             "call l0\n"
 998             "ret\n"
 999             "label l0\n"
1000             "ret\n",
1001             {0xffff0201, 0x01000019, 0xa0e41000, 0x0000001c, 0x0100001e, 0xa0e41000,
1002              0x0000001c, 0x0000ffff}
1003         },
1004         {   /* shader 6 */
1005             "ps_2_x\n"
1006             "callnz l0, b0\n"
1007             "ret\n"
1008             "label l0\n"
1009             "ret\n",
1010             {0xffff0201, 0x0200001a, 0xa0e41000, 0xe0e40800, 0x0000001c, 0x0100001e,
1011              0xa0e41000, 0x0000001c, 0x0000ffff}
1012         },
1013         {   /* shader 7 */
1014             "ps_2_x\n"
1015             "callnz l0, !b0\n"
1016             "ret\n"
1017             "label l0\n"
1018             "ret\n",
1019             {0xffff0201, 0x0200001a, 0xa0e41000, 0xede40800, 0x0000001c, 0x0100001e,
1020              0xa0e41000, 0x0000001c, 0x0000ffff}
1021         },
1022         {   /* shader 8 */
1023             "ps_2_x\n"
1024             "if !b0\n"
1025             "else\n"
1026             "endif\n",
1027             {0xffff0201, 0x01000028, 0xede40800, 0x0000002a, 0x0000002b, 0x0000ffff}
1028         },
1029         /* Dynamic flow control tests */
1030         {   /* shader 9 */
1031             "ps_2_x\n"
1032             "rep i0\n"
1033             "break\n"
1034             "endrep\n",
1035             {0xffff0201, 0x01000026, 0xf0e40000, 0x0000002c, 0x00000027, 0x0000ffff}
1036         },
1037         {   /* shader 10 */
1038             "ps_2_x\n"
1039             "if_ge r0, r1\n"
1040             "endif\n",
1041             {0xffff0201, 0x02030029, 0x80e40000, 0x80e40001, 0x0000002b, 0x0000ffff}
1042         },
1043         {   /* shader 11 */
1044             "ps_2_x\n"
1045             "rep i0\n"
1046             "break_ne r0, r1\n"
1047             "endrep",
1048             {0xffff0201, 0x01000026, 0xf0e40000, 0x0205002d, 0x80e40000, 0x80e40001,
1049              0x00000027, 0x0000ffff}
1050         },
1051         /* Predicates */
1052         {   /* shader 12 */
1053             "ps_2_x\n"
1054             "setp_gt p0, r0, r1\n"
1055             "(!p0) add r2, r2, r3\n",
1056             {0xffff0201, 0x0301005e, 0xb00f1000, 0x80e40000, 0x80e40001, 0x14000002,
1057              0x800f0002, 0xbde41000, 0x80e40002, 0x80e40003, 0x0000ffff}
1058         },
1059         {   /* shader 13 */
1060             "ps_2_x\n"
1061             "if p0.x\n"
1062             "else\n"
1063             "endif\n",
1064             {0xffff0201, 0x01000028, 0xb0001000, 0x0000002a, 0x0000002b, 0x0000ffff}
1065         },
1066         {   /* shader 14 */
1067             "ps_2_x\n"
1068             "callnz l0, !p0.z\n"
1069             "ret\n"
1070             "label l0\n"
1071             "ret\n",
1072             {0xffff0201, 0x0200001a, 0xa0e41000, 0xbdaa1000, 0x0000001c,
1073              0x0100001e, 0xa0e41000, 0x0000001c, 0x0000ffff}
1074         },
1075         {   /* shader 15 */
1076             "ps_2_x\n"
1077             "rep i0\n"
1078             "breakp p0.w\n"
1079             "endrep\n",
1080             {0xffff0201, 0x01000026, 0xf0e40000, 0x01000060, 0xb0ff1000,
1081              0x00000027, 0x0000ffff}
1082         },
1083         {   /* shader 16 */
1084             "ps_2_x\n"
1085             "call l2047\n"
1086             "ret\n"
1087             "label l2047\n"
1088             "ret\n",
1089             {0xffff0201, 0x01000019, 0xa0e417ff, 0x0000001c, 0x0100001e, 0xa0e417ff,
1090              0x0000001c, 0x0000ffff}
1091         },
1092     };
1093
1094     exec_tests("ps_2_x", tests, sizeof(tests) / sizeof(tests[0]));
1095 }
1096
1097 static void vs_3_0_test(void) {
1098     struct shader_test tests[] = {
1099         {   /* shader 0 */
1100             "vs_3_0\n"
1101             "mov r0, c0\n",
1102             {0xfffe0300, 0x02000001, 0x800f0000, 0xa0e40000, 0x0000ffff}
1103         },
1104         {   /* shader 1 */
1105             "vs_3_0\n"
1106             "dcl_2d s0\n",
1107             {0xfffe0300, 0x0200001f, 0x90000000, 0xa00f0800, 0x0000ffff}
1108         },
1109         {   /* shader 2 */
1110             "vs_3_0\n"
1111             "dcl_position o0\n",
1112             {0xfffe0300, 0x0200001f, 0x80000000, 0xe00f0000, 0x0000ffff}
1113         },
1114         {   /* shader 3 */
1115             "vs_3_0\n"
1116             "dcl_texcoord12 o11\n",
1117             {0xfffe0300, 0x0200001f, 0x800c0005, 0xe00f000b, 0x0000ffff}
1118         },
1119         {   /* shader 4 */
1120             "vs_3_0\n"
1121             "texldl r0, v0, s0\n",
1122             {0xfffe0300, 0x0300005f, 0x800f0000, 0x90e40000, 0xa0e40800, 0x0000ffff}
1123         },
1124         {   /* shader 5 */
1125             "vs_3_0\n"
1126             "mov r0, c0[aL]\n",
1127             {0xfffe0300, 0x03000001, 0x800f0000, 0xa0e42000, 0xf0e40800, 0x0000ffff}
1128         },
1129         {   /* shader 6 */
1130             "vs_3_0\n"
1131             "mov o[ a0.x + 12 ], r0\n",
1132             {0xfffe0300, 0x03000001, 0xe00f200c, 0xb0000000, 0x80e40000, 0x0000ffff}
1133         },
1134         {   /* shader 7 */
1135             "vs_3_0\n"
1136             "add_sat r0, r0, r1\n",
1137             {0xfffe0300, 0x03000002, 0x801f0000, 0x80e40000, 0x80e40001, 0x0000ffff}
1138         },
1139         {   /* shader 8 */
1140             "vs_3_0\n"
1141             "mov r2, r1_abs\n",
1142             {0xfffe0300, 0x02000001, 0x800f0002, 0x8be40001, 0x0000ffff}
1143         },
1144         {   /* shader 9 */
1145             "vs_3_0\n"
1146             "mov r2, r1.xygb\n",
1147             {0xfffe0300, 0x02000001, 0x800f0002, 0x80940001, 0x0000ffff}
1148         },
1149         {   /* shader 10 */
1150             "vs_3_0\n"
1151             "mov r2.xyb, r1\n",
1152             {0xfffe0300, 0x02000001, 0x80070002, 0x80e40001, 0x0000ffff}
1153         },
1154         {   /* shader 11 */
1155             "vs_3_0\n"
1156             "mova_sat a0.x, r1\n",
1157             {0xfffe0300, 0x0200002e, 0xb0110000, 0x80e40001, 0x0000ffff}
1158         },
1159         {   /* shader 12 */
1160             "vs_3_0\n"
1161             "sincos r0, r1\n",
1162             {0xfffe0300, 0x02000025, 0x800f0000, 0x80e40001, 0x0000ffff}
1163         },
1164         {   /* shader 13 */
1165             "vs_3_0\n"
1166             "def c0, 1.0f, 1.0f, 1.0f, 0.5f\n",
1167             {0xfffe0300, 0x05000051, 0xa00f0000, 0x3f800000, 0x3f800000, 0x3f800000,
1168              0x3f000000, 0x0000ffff}
1169         },
1170         {   /* shader 14: no register number checks with relative addressing */
1171             "vs_3_0\n"
1172             "add r0, v20[aL], r2\n",
1173             {0xfffe0300, 0x04000002, 0x800f0000, 0x90e42014, 0xf0e40800, 0x80e40002,
1174              0x0000ffff}
1175         },
1176
1177     };
1178
1179     exec_tests("vs_3_0", tests, sizeof(tests) / sizeof(tests[0]));
1180 }
1181
1182 static void ps_3_0_test(void) {
1183     struct shader_test tests[] = {
1184         {   /* shader 0 */
1185             "ps_3_0\n"
1186             "mov r0, c0\n",
1187             {0xffff0300, 0x02000001, 0x800f0000, 0xa0e40000, 0x0000ffff}
1188         },
1189         {   /* shader 1 */
1190             "ps_3_0\n"
1191             "dcl_normal5 v0\n",
1192             {0xffff0300, 0x0200001f, 0x80050003, 0x900f0000, 0x0000ffff}
1193         },
1194         {   /* shader 2 */
1195             "ps_3_0\n"
1196             "mov r0, vPos\n",
1197             {0xffff0300, 0x02000001, 0x800f0000, 0x90e41000, 0x0000ffff}
1198         },
1199         {   /* shader 3 */
1200             "ps_3_0\n"
1201             "mov r0, vFace\n",
1202             {0xffff0300, 0x02000001, 0x800f0000, 0x90e41001, 0x0000ffff}
1203         },
1204         {   /* shader 4 */
1205             "ps_3_0\n"
1206             "mov r0, v[ aL + 12 ]\n",
1207             {0xffff0300, 0x03000001, 0x800f0000, 0x90e4200c, 0xf0e40800, 0x0000ffff}
1208         },
1209         {   /* shader 5 */
1210             "ps_3_0\n"
1211             "loop aL, i0\n"
1212             "mov r0, v0[aL]\n"
1213             "endloop\n",
1214             {0xffff0300, 0x0200001b, 0xf0e40800, 0xf0e40000, 0x03000001, 0x800f0000,
1215              0x90e42000, 0xf0e40800, 0x0000001d, 0x0000ffff}
1216         },
1217         {   /* shader 6 */
1218             "ps_3_0\n"
1219             "texldl r0, v0, s0\n",
1220             {0xffff0300, 0x0300005f, 0x800f0000, 0x90e40000, 0xa0e40800, 0x0000ffff}
1221         },
1222         {   /* shader 7 */
1223             "ps_3_0\n"
1224             "add_pp r0, r0, r1\n",
1225             {0xffff0300, 0x03000002, 0x802f0000, 0x80e40000, 0x80e40001, 0x0000ffff}
1226         },
1227         {   /* shader 8 */
1228             "ps_3_0\n"
1229             "dsx_sat r0, r1\n",
1230             {0xffff0300, 0x0200005b, 0x801f0000, 0x80e40001, 0x0000ffff}
1231         },
1232         {   /* shader 9 */
1233             "ps_3_0\n"
1234             "texldd_pp r0, r1, r2, r3, r4\n",
1235             {0xffff0300, 0x0500005d, 0x802f0000, 0x80e40001, 0x80e40002, 0x80e40003,
1236              0x80e40004, 0x0000ffff}
1237         },
1238         {   /* shader 10 */
1239             "ps_3_0\n"
1240             "texkill v0\n",
1241             {0xffff0300, 0x01000041, 0x900f0000, 0x0000ffff}
1242         },
1243         {   /* shader 11 */
1244             "ps_3_0\n"
1245             "add oC3, r0, r1\n",
1246             {0xffff0300, 0x03000002, 0x800f0803, 0x80e40000, 0x80e40001, 0x0000ffff}
1247         },
1248         {   /* shader 12 */
1249             "ps_3_0\n"
1250             "dcl_texcoord0_centroid v0\n",
1251             {0xffff0300, 0x0200001f, 0x80000005, 0x904f0000, 0x0000ffff}
1252         },
1253         {   /* shader 13 */
1254             "ps_3_0\n"
1255             "dcl_2d_centroid s0\n",
1256             {0xffff0300, 0x0200001f, 0x90000000, 0xa04f0800, 0x0000ffff}
1257         },
1258         {   /* shader 14 */
1259             "ps_3_0\n"
1260             "dcl_2d_pp s0\n",
1261             {0xffff0300, 0x0200001f, 0x90000000, 0xa02f0800, 0x0000ffff}
1262         },
1263     };
1264
1265     exec_tests("ps_3_0", tests, sizeof(tests) / sizeof(tests[0]));
1266 }
1267
1268 static void failure_test(void) {
1269     const char * tests[] = {
1270         /* shader 0: instruction modifier not allowed */
1271         "ps_3_0\n"
1272         "dcl_2d s2\n"
1273         "texldd_x2 r0, v1, s2, v3, v4\n",
1274         /* shader 1: coissue not supported in vertex shaders */
1275         "vs.1.1\r\n"
1276         "add r0.rgb, r0, r1\n"
1277         "+add r0.a, r0, r2\n",
1278         /* shader 2: coissue not supported in pixel shader version >= 2.0 */
1279         "ps_2_0\n"
1280         "texld r0, t0, s0\n"
1281         "add r0.rgb, r0, r1\n"
1282         "+add r0.a, r0, v1\n",
1283         /* shader 3: predicates not supported in vertex shader < 2.0 */
1284         "vs_1_1\n"
1285         "(p0) add r0, r0, v0\n",
1286         /* shader 4: register a0 doesn't exist in pixel shaders */
1287         "ps_3_0\n"
1288         "mov r0, v[ a0 + 12 ]\n",
1289         /* shader 5: s0 doesn't exist in vs_1_1 */
1290         "vs_1_1\n"
1291         "mov r0, s0\n",
1292         /* shader 6: aL is a scalar register, no swizzles allowed */
1293         "ps_3_0\n"
1294         "mov r0, v[ aL.x + 12 ]\n",
1295         /* shader 7: tn doesn't exist in ps_3_0 */
1296         "ps_3_0\n"
1297         "dcl_2d s2\n"
1298         "texldd r0, t1, s2, v3, v4\n",
1299         /* shader 8: two shift modifiers */
1300         "ps_1_3\n"
1301         "mov_x2_x2 r0, r1\n",
1302         /* shader 9: too many source registers for mov instruction */
1303         "vs_1_1\n"
1304         "mov r0, r1, r2\n",
1305         /* shader 10: invalid combination of negate and divide modifiers */
1306         "ps_1_4\n"
1307         "texld r5, -r2_dz\n",
1308         /* shader 11: complement modifier not allowed in >= PS 2 */
1309         "ps_2_0\n"
1310         "mov r2, 1 - r0\n",
1311         /* shader 12: invalid modifier */
1312         "vs_3_0\n"
1313         "mov r2, 2 - r0\n",
1314         /* shader 13: float value in relative addressing */
1315         "vs_3_0\n"
1316         "mov r2, c[ aL + 3.4 ]\n",
1317         /* shader 14: complement modifier not available in VS */
1318         "vs_3_0\n"
1319         "mov r2, 1 - r1\n",
1320         /* shader 15: _x2 modifier not available in VS */
1321         "vs_1_1\n"
1322         "mov r2, r1_x2\n",
1323         /* shader 16: _abs modifier not available in < VS 3.0 */
1324         "vs_1_1\n"
1325         "mov r2, r1_abs\n",
1326         /* shader 17: _x2 modifier not available in >= PS 2.0 */
1327         "ps_2_0\n"
1328         "mov r0, r1_x2\n",
1329         /* shader 18: wrong swizzle */
1330         "vs_2_0\n"
1331         "mov r0, r1.abcd\n",
1332         /* shader 19: wrong swizzle */
1333         "vs_2_0\n"
1334         "mov r0, r1.xyzwx\n",
1335         /* shader 20: wrong swizzle */
1336         "vs_2_0\n"
1337         "mov r0, r1.\n",
1338         /* shader 21: invalid writemask */
1339         "vs_2_0\n"
1340         "mov r0.xxyz, r1\n",
1341         /* shader 22: register r5 doesn't exist in PS < 1.4 */
1342         "ps_1_3\n"
1343         "mov r5, r0\n",
1344         /* shader 23: can't declare output registers in a pixel shader */
1345         "ps_3_0\n"
1346         "dcl_positiont o0\n",
1347         /* shader 24: _pp instruction modifier not allowed in vertex shaders */
1348         "vs_3_0\n"
1349         "add_pp r0, r0, r1\n",
1350         /* shader 25: _x4 instruction modified not allowed in > ps_1_x */
1351         "ps_3_0\n"
1352         "add_x4 r0, r0, r1\n",
1353         /* shader 26: there aren't oCx registers in ps_1_x */
1354         "ps_1_3\n"
1355         "add oC0, r0, r1\n",
1356         /* shader 27: oC3 is the max in >= ps_2_0 */
1357         "ps_3_0\n"
1358         "add oC4, r0, r1\n",
1359         /* shader 28: register v17 doesn't exist */
1360         "vs_3_0\n"
1361         "add r0, r0, v17\n",
1362         /* shader 29: register o13 doesn't exist */
1363         "vs_3_0\n"
1364         "add o13, r0, r1\n",
1365         /* shader 30: label > 2047 not allowed */
1366         "vs_3_0\n"
1367         "call l2048\n",
1368         /* shader 31: s20 register does not exist */
1369         "ps_3_0\n"
1370         "texld r0, r1, s20\n",
1371         /* shader 32: t5 not allowed in ps_1_3 */
1372         "ps_1_3\n"
1373         "tex t5\n",
1374         /* shader 33: no temporary registers relative addressing */
1375         "vs_3_0\n"
1376         "add r0, r0[ a0.x ], r1\n",
1377         /* shader 34: no input registers relative addressing in vs_2_0 */
1378         "vs_2_0\n"
1379         "add r0, v[ a0.x ], r1\n",
1380         /* shader 35: no aL register in ps_2_0 */
1381         "ps_2_0\n"
1382         "add r0, v[ aL ], r1\n",
1383         /* shader 36: no relative addressing in ps_2_0 */
1384         "ps_2_0\n"
1385         "add r0, v[ r0 ], r1\n",
1386         /* shader 37: no a0 register in ps_3_0 */
1387         "ps_3_0\n"
1388         "add r0, v[ a0.x ], r1\n",
1389         /* shader 38: only a0.x accepted in vs_1_1 */
1390         "vs_1_1\n"
1391         "mov r0, c0[ a0 ]\n",
1392         /* shader 39: invalid modifier for dcl instruction */
1393         "ps_3_0\n"
1394         "dcl_texcoord0_sat v0\n",
1395         /* shader 40: shift not allowed */
1396         "ps_3_0\n"
1397         "dcl_texcoord0_x2 v0\n",
1398         /* shader 41: no modifier allowed with dcl instruction in vs */
1399         "vs_3_0\n"
1400         "dcl_texcoord0_centroid v0\n",
1401         /* shader 42: no modifiers with vs dcl sampler instruction */
1402         "vs_3_0\n"
1403         "dcl_2d_pp s0\n",
1404         /* shader 43: */
1405         "ps_2_0\n"
1406         "texm3x3vspec t3, t0\n",
1407     };
1408     HRESULT hr;
1409     unsigned int i;
1410     LPD3DBLOB shader, messages;
1411
1412     for(i = 0; i < (sizeof(tests) / sizeof(tests[0])); i++) {
1413         shader = NULL;
1414         messages = NULL;
1415         hr = D3DAssemble(tests[i], strlen(tests[i]), NULL,
1416                          NULL, NULL, D3DCOMPILE_SKIP_VALIDATION,
1417                          &shader, &messages);
1418         ok(hr == D3DXERR_INVALIDDATA, "Failure test, shader %d: "
1419            "expected D3DAssemble failure with D3DXERR_INVALIDDATA, "
1420            "got 0x%x - %d\n", i, hr, hr & 0x0000FFFF);
1421         if(messages) {
1422             trace("D3DAssemble messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages));
1423             ID3D10Blob_Release(messages);
1424         }
1425         if(shader) {
1426             DWORD *res = ID3D10Blob_GetBufferPointer(shader);
1427             dump_shader(res);
1428             ID3D10Blob_Release(shader);
1429         }
1430     }
1431 }
1432
1433 static HRESULT WINAPI testD3DInclude_open(ID3DInclude *iface, D3D_INCLUDE_TYPE include_type,
1434         const char *filename, const void *parent_data, const void **data, UINT *bytes)
1435 {
1436     char *buffer;
1437     char include[] = "#define REGISTER r0\nvs.1.1\n";
1438     char include2[] = "#include \"incl3.vsh\"\n";
1439     char include3[] = "vs.1.1\n";
1440
1441     trace("filename %s\n", filename);
1442     trace("parent_data (%p) -> %s\n", parent_data, (char *)parent_data);
1443
1444     if (!strcmp(filename, "incl.vsh"))
1445     {
1446         buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(include));
1447         CopyMemory(buffer, include, sizeof(include));
1448         *bytes = sizeof(include);
1449     }
1450     else if (!strcmp(filename, "incl3.vsh"))
1451     {
1452         buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(include3));
1453         CopyMemory(buffer, include3, sizeof(include3));
1454         *bytes = sizeof(include3);
1455         /* Also check for the correct parent_data content */
1456         ok(parent_data != NULL && !strncmp(include2, parent_data, strlen(include2)), "wrong parent_data value\n");
1457     }
1458     else
1459     {
1460         buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(include2));
1461         CopyMemory(buffer, include2, sizeof(include2));
1462         *bytes = sizeof(include2);
1463     }
1464
1465     *data = buffer;
1466
1467     return S_OK;
1468 }
1469
1470 static HRESULT WINAPI testD3DInclude_close(ID3DInclude *iface, const void *data)
1471 {
1472     HeapFree(GetProcessHeap(), 0, (LPVOID)data);
1473     return S_OK;
1474 }
1475
1476 static const struct ID3DIncludeVtbl D3DInclude_Vtbl =
1477 {
1478     testD3DInclude_open,
1479     testD3DInclude_close
1480 };
1481
1482 struct D3DIncludeImpl {
1483     const ID3DIncludeVtbl *lpVtbl;
1484 };
1485
1486 static void assembleshader_test(void) {
1487     const char test1[] = {
1488         "vs.1.1\n"
1489         "mov DEF2, v0\n"
1490     };
1491     const char testshader[] = {
1492         "#include \"incl.vsh\"\n"
1493         "mov REGISTER, v0\n"
1494     };
1495     HRESULT hr;
1496     LPD3DBLOB shader, messages;
1497     D3D_SHADER_MACRO defines[] = {
1498         {
1499             "DEF1", "10 + 15"
1500         },
1501         {
1502             "DEF2", "r0"
1503         },
1504         {
1505             NULL, NULL
1506         }
1507     };
1508     struct D3DIncludeImpl include;
1509
1510     /* defines test */
1511     shader = NULL;
1512     messages = NULL;
1513     hr = D3DAssemble(test1, strlen(test1), NULL,
1514                      defines, NULL, D3DCOMPILE_SKIP_VALIDATION,
1515                      &shader, &messages);
1516     ok(hr == S_OK, "defines test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1517     if(messages) {
1518         trace("D3DAssemble messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages));
1519         ID3D10Blob_Release(messages);
1520     }
1521     if(shader) ID3D10Blob_Release(shader);
1522
1523     /* NULL messages test */
1524     shader = NULL;
1525     hr = D3DAssemble(test1, strlen(test1), NULL,
1526                      defines, NULL, D3DCOMPILE_SKIP_VALIDATION,
1527                      &shader, NULL);
1528     ok(hr == S_OK, "NULL messages test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1529     if(shader) ID3D10Blob_Release(shader);
1530
1531     /* NULL shader test */
1532     messages = NULL;
1533     hr = D3DAssemble(test1, strlen(test1), NULL,
1534                      defines, NULL, D3DCOMPILE_SKIP_VALIDATION,
1535                      NULL, &messages);
1536     ok(hr == S_OK, "NULL shader test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1537     if(messages) {
1538         trace("D3DAssemble messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages));
1539         ID3D10Blob_Release(messages);
1540     }
1541
1542     /* D3DInclude test */
1543     shader = NULL;
1544     messages = NULL;
1545     include.lpVtbl = &D3DInclude_Vtbl;
1546     hr = D3DAssemble(testshader, strlen(testshader), NULL,
1547                      NULL, (LPD3DINCLUDE)&include, D3DCOMPILE_SKIP_VALIDATION,
1548                      &shader, &messages);
1549     ok(hr == S_OK, "D3DInclude test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1550     if(messages) {
1551         trace("D3DAssemble messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages));
1552         ID3D10Blob_Release(messages);
1553     }
1554     if(shader) ID3D10Blob_Release(shader);
1555
1556     /* NULL shader tests */
1557     shader = NULL;
1558     messages = NULL;
1559     hr = D3DAssemble(NULL, 0, NULL,
1560                      NULL, NULL, D3DCOMPILE_SKIP_VALIDATION,
1561                      &shader, &messages);
1562     ok(hr == D3DXERR_INVALIDDATA, "NULL shader test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1563     if(messages) {
1564         trace("D3DAssemble messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages));
1565         ID3D10Blob_Release(messages);
1566     }
1567     if(shader) ID3D10Blob_Release(shader);
1568 }
1569
1570 static void d3dpreprocess_test(void)
1571 {
1572     const char test1[] =
1573     {
1574         "vs.1.1\n"
1575         "mov DEF2, v0\n"
1576     };
1577     const char testshader[] =
1578     {
1579         "#include \"incl.vsh\"\n"
1580         "mov REGISTER, v0\n"
1581     };
1582     const char testshader2[] =
1583     {
1584         "#include \"incl2.vsh\"\n"
1585         "mov REGISTER, v0\n"
1586     };
1587     HRESULT hr;
1588     ID3DBlob *shader, *messages;
1589     D3D_SHADER_MACRO defines[] =
1590     {
1591         {
1592             "DEF1", "10 + 15"
1593         },
1594         {
1595             "DEF2", "r0"
1596         },
1597         {
1598             NULL, NULL
1599         }
1600     };
1601     struct D3DIncludeImpl include;
1602
1603     /* pDefines test */
1604     shader = NULL;
1605     messages = NULL;
1606     hr = D3DPreprocess(test1, strlen(test1), NULL,
1607             defines, NULL, &shader, &messages);
1608     ok(hr == S_OK, "pDefines test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1609     if (messages)
1610     {
1611         trace("D3DPreprocess messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages));
1612         ID3D10Blob_Release(messages);
1613     }
1614     if (shader) ID3D10Blob_Release(shader);
1615
1616     /* NULL messages test */
1617     shader = NULL;
1618     hr = D3DPreprocess(test1, strlen(test1), NULL,
1619             defines, NULL, &shader, NULL);
1620     ok(hr == S_OK, "NULL messages test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1621     if (shader) ID3D10Blob_Release(shader);
1622
1623     /* NULL shader test */
1624     messages = NULL;
1625     hr = D3DPreprocess(test1, strlen(test1), NULL,
1626             defines, NULL, NULL, &messages);
1627     ok(hr == E_INVALIDARG, "NULL shader test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1628     if (messages)
1629     {
1630         trace("D3DPreprocess messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages));
1631         ID3D10Blob_Release(messages);
1632     }
1633
1634     /* pInclude test */
1635     shader = NULL;
1636     messages = NULL;
1637     include.lpVtbl = &D3DInclude_Vtbl;
1638     hr = D3DPreprocess(testshader, strlen(testshader), NULL,
1639             NULL, (ID3DInclude *)&include, &shader, &messages);
1640     ok(hr == S_OK, "pInclude test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1641     if (messages)
1642     {
1643         trace("D3DPreprocess messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages));
1644         ID3D10Blob_Release(messages);
1645     }
1646     if (shader) ID3D10Blob_Release(shader);
1647
1648     /* recursive #include test */
1649     shader = NULL;
1650     messages = NULL;
1651     hr = D3DPreprocess(testshader2, strlen(testshader2), NULL,
1652             NULL, (ID3DInclude *)&include, &shader, &messages);
1653     ok(hr == S_OK, "D3DPreprocess test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1654     if (messages)
1655     {
1656         trace("recursive D3DPreprocess messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages));
1657         ID3D10Blob_Release(messages);
1658     }
1659     if (shader) ID3D10Blob_Release(shader);
1660
1661     /* NULL shader tests */
1662     shader = NULL;
1663     messages = NULL;
1664     hr = D3DPreprocess(NULL, 0, NULL,
1665             NULL, NULL, &shader, &messages);
1666     ok(hr == E_INVALIDARG, "NULL shader test failed with error 0x%x - %d\n", hr, hr & 0x0000FFFF);
1667     if (messages)
1668     {
1669         trace("D3DPreprocess messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages));
1670         ID3D10Blob_Release(messages);
1671     }
1672     if (shader) ID3D10Blob_Release(shader);
1673 }
1674
1675 START_TEST(asm)
1676 {
1677     preproc_test();
1678     ps_1_1_test();
1679     vs_1_1_test();
1680     ps_1_3_test();
1681     ps_1_4_test();
1682     vs_2_0_test();
1683     vs_2_x_test();
1684     ps_2_0_test();
1685     ps_2_x_test();
1686     vs_3_0_test();
1687     ps_3_0_test();
1688
1689     failure_test();
1690
1691     assembleshader_test();
1692
1693     d3dpreprocess_test();
1694 }