git.oblomov.eu Git - wine/blob - dlls/rpcrt4/tests/server.c

   1 /*
   2  * Tests for WIDL and RPC server/clients.
   3  *
   4  * Copyright (C) Google 2007 (Dan Hipschman)
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <windows.h>
  22 #include "wine/test.h"
  23 #include "server.h"
  24 #include "server_defines.h"
  25
  26 #include <stddef.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29
  30 #define PORT "4114"
  31 #define PIPE "\\pipe\\wine_rpcrt4_test"
  32
  33 #define INT_CODE 4198
  34
  35 static const char *progname;
  36 static BOOL old_windows_version;
  37
  38 static HANDLE stop_event;
  39
  40 static void (WINAPI *pNDRSContextMarshall2)(RPC_BINDING_HANDLE, NDR_SCONTEXT, void*, NDR_RUNDOWN, void*, ULONG);
  41 static NDR_SCONTEXT (WINAPI *pNDRSContextUnmarshall2)(RPC_BINDING_HANDLE, void*, ULONG, void*, ULONG);
  42 static RPC_STATUS (WINAPI *pRpcServerRegisterIfEx)(RPC_IF_HANDLE,UUID*, RPC_MGR_EPV*, unsigned int,
  43                    unsigned int,RPC_IF_CALLBACK_FN*);
  44
  45 /* type check statements generated in header file */
  46 fnprintf *p_printf = printf;
  47
  48 static void InitFunctionPointers(void)
  49 {
  50     HMODULE hrpcrt4 = GetModuleHandleA("rpcrt4.dll");
  51
  52     pNDRSContextMarshall2 = (void *)GetProcAddress(hrpcrt4, "NDRSContextMarshall2");
  53     pNDRSContextUnmarshall2 = (void *)GetProcAddress(hrpcrt4, "NDRSContextUnmarshall2");
  54     pRpcServerRegisterIfEx = (void *)GetProcAddress(hrpcrt4, "RpcServerRegisterIfEx");
  55
  56     if (!pNDRSContextMarshall2) old_windows_version = TRUE;
  57 }
  58
  59 void __RPC_FAR *__RPC_USER
  60 midl_user_allocate(SIZE_T n)
  61 {
  62   return HeapAlloc(GetProcessHeap(), 0, n);
  63 }
  64
  65 void __RPC_USER
  66 midl_user_free(void __RPC_FAR *p)
  67 {
  68   HeapFree(GetProcessHeap(), 0, p);
  69 }
  70
  71 static char *
  72 xstrdup(const char *s)
  73 {
  74   char *d = HeapAlloc(GetProcessHeap(), 0, strlen(s) + 1);
  75   strcpy(d, s);
  76   return d;
  77 }
  78
  79 int
  80 s_int_return(void)
  81 {
  82   return INT_CODE;
  83 }
  84
  85 int
  86 s_square(int x)
  87 {
  88   return x * x;
  89 }
  90
  91 int
  92 s_sum(int x, int y)
  93 {
  94   return x + y;
  95 }
  96
  97 void
  98 s_square_out(int x, int *y)
  99 {
 100   *y = s_square(x);
 101 }
 102
 103 void
 104 s_square_ref(int *x)
 105 {
 106   *x = s_square(*x);
 107 }
 108
 109 int
 110 s_str_length(const char *s)
 111 {
 112   return strlen(s);
 113 }
 114
 115 int
 116 s_str_t_length(str_t s)
 117 {
 118   return strlen(s);
 119 }
 120
 121 int
 122 s_cstr_length(const char *s, int n)
 123 {
 124   int len = 0;
 125   while (0 < n-- && *s++)
 126     ++len;
 127   return len;
 128 }
 129
 130 int
 131 s_dot_self(vector_t *v)
 132 {
 133   return s_square(v->x) + s_square(v->y) + s_square(v->z);
 134 }
 135
 136 double
 137 s_square_half(double x, double *y)
 138 {
 139   *y = x / 2.0;
 140   return x * x;
 141 }
 142
 143 float
 144 s_square_half_float(float x, float *y)
 145 {
 146   *y = x / 2.0f;
 147   return x * x;
 148 }
 149
 150 LONG
 151 s_square_half_long(LONG x, LONG *y)
 152 {
 153   *y = x / 2;
 154   return x * x;
 155 }
 156
 157 int
 158 s_sum_fixed_array(int a[5])
 159 {
 160   return a[0] + a[1] + a[2] + a[3] + a[4];
 161 }
 162
 163 int
 164 s_pints_sum(pints_t *pints)
 165 {
 166   return *pints->pi + **pints->ppi + ***pints->pppi;
 167 }
 168
 169 double
 170 s_ptypes_sum(ptypes_t *pt)
 171 {
 172   return *pt->pc + *pt->ps + *pt->pl + *pt->pf + *pt->pd;
 173 }
 174
 175 int
 176 s_dot_pvectors(pvectors_t *p)
 177 {
 178   return p->pu->x * (*p->pv)->x + p->pu->y * (*p->pv)->y + p->pu->z * (*p->pv)->z;
 179 }
 180
 181 int
 182 s_sum_sp(sp_t *sp)
 183 {
 184   return sp->x + sp->s->x;
 185 }
 186
 187 double
 188 s_square_sun(sun_t *su)
 189 {
 190   switch (su->s)
 191   {
 192   case SUN_I: return su->u.i * su->u.i;
 193   case SUN_F1:
 194   case SUN_F2: return su->u.f * su->u.f;
 195   case SUN_PI: return (*su->u.pi) * (*su->u.pi);
 196   default:
 197     return 0.0;
 198   }
 199 }
 200
 201 int
 202 s_test_list_length(test_list_t *list)
 203 {
 204   return (list->t == TL_LIST
 205           ? 1 + s_test_list_length(list->u.tail)
 206           : 0);
 207 }
 208
 209 int
 210 s_sum_fixed_int_3d(int m[2][3][4])
 211 {
 212   int i, j, k;
 213   int sum = 0;
 214
 215   for (i = 0; i < 2; ++i)
 216     for (j = 0; j < 3; ++j)
 217       for (k = 0; k < 4; ++k)
 218         sum += m[i][j][k];
 219
 220   return sum;
 221 }
 222
 223 int
 224 s_sum_conf_array(int x[], int n)
 225 {
 226   int *p = x, *end = p + n;
 227   int sum = 0;
 228
 229   while (p < end)
 230     sum += *p++;
 231
 232   return sum;
 233 }
 234
 235 int
 236 s_sum_conf_ptr_by_conf_ptr(int n1, int *n2_then_x1, int *x2)
 237 {
 238   int i;
 239   int sum = 0;
 240   if(n1 == 0)
 241     return 0;
 242
 243   for(i = 1; i < n1; ++i)
 244     sum += n2_then_x1[i];
 245
 246   for(i = 0; i < *n2_then_x1; ++i)
 247     sum += x2[i];
 248
 249   return sum;
 250 }
 251
 252 int
 253 s_sum_unique_conf_array(int x[], int n)
 254 {
 255   return s_sum_conf_array(x, n);
 256 }
 257
 258 int
 259 s_sum_unique_conf_ptr(int *x, int n)
 260 {
 261   return x ? s_sum_conf_array(x, n) : 0;
 262 }
 263
 264 int
 265 s_sum_var_array(int x[20], int n)
 266 {
 267   ok(0 <= n, "RPC sum_var_array\n");
 268   ok(n <= 20, "RPC sum_var_array\n");
 269
 270   return s_sum_conf_array(x, n);
 271 }
 272
 273 int
 274 s_dot_two_vectors(vector_t vs[2])
 275 {
 276   return vs[0].x * vs[1].x + vs[0].y * vs[1].y + vs[0].z * vs[1].z;
 277 }
 278
 279 int
 280 s_sum_cs(cs_t *cs)
 281 {
 282   return s_sum_conf_array(cs->ca, cs->n);
 283 }
 284
 285 int
 286 s_sum_cps(cps_t *cps)
 287 {
 288   int sum = 0;
 289   int i;
 290
 291   for (i = 0; i < *cps->pn; ++i)
 292     sum += cps->ca1[i];
 293
 294   for (i = 0; i < 2 * cps->n; ++i)
 295     sum += cps->ca2[i];
 296
 297   return sum;
 298 }
 299
 300 int
 301 s_sum_cpsc(cpsc_t *cpsc)
 302 {
 303   int sum = 0;
 304   int i;
 305   for (i = 0; i < (cpsc->c ? cpsc->a : cpsc->b); ++i)
 306     sum += cpsc->ca[i];
 307   return sum;
 308 }
 309
 310 int
 311 s_square_puint(puint_t p)
 312 {
 313   int n = atoi(p);
 314   return n * n;
 315 }
 316
 317 int
 318 s_sum_puints(puints_t *p)
 319 {
 320   int sum = 0;
 321   int i;
 322   for (i = 0; i < p->n; ++i)
 323     sum += atoi(p->ps[i]);
 324   return sum;
 325 }
 326
 327 int
 328 s_sum_cpuints(cpuints_t *p)
 329 {
 330   int sum = 0;
 331   int i;
 332   for (i = 0; i < p->n; ++i)
 333     sum += atoi(p->ps[i]);
 334   return sum;
 335 }
 336
 337 int
 338 s_dot_copy_vectors(vector_t u, vector_t v)
 339 {
 340   return u.x * v.x + u.y * v.y + u.z * v.z;
 341 }
 342
 343 int
 344 s_square_test_us(test_us_t *tus)
 345 {
 346   int n = atoi(tus->us.x);
 347   return n * n;
 348 }
 349
 350 double
 351 s_square_encu(encu_t *eu)
 352 {
 353   switch (eu->t)
 354   {
 355   case ENCU_I: return eu->tagged_union.i * eu->tagged_union.i;
 356   case ENCU_F: return eu->tagged_union.f * eu->tagged_union.f;
 357   default:
 358     return 0.0;
 359   }
 360 }
 361
 362 double
 363 s_square_unencu(int t, unencu_t *eu)
 364 {
 365   switch (t)
 366   {
 367   case ENCU_I: return eu->i * eu->i;
 368   case ENCU_F: return eu->f * eu->f;
 369   default:
 370     return 0.0;
 371   }
 372 }
 373
 374 void
 375 s_check_se2(se_t *s)
 376 {
 377   ok(s->f == E2, "check_se2\n");
 378 }
 379
 380 int
 381 s_sum_parr(int *a[3])
 382 {
 383   return s_sum_pcarr(a, 3);
 384 }
 385
 386 int
 387 s_sum_pcarr(int *a[], int n)
 388 {
 389   int i, s = 0;
 390   for (i = 0; i < n; ++i)
 391     s += *a[i];
 392   return s;
 393 }
 394
 395 int
 396 s_enum_ord(e_t e)
 397 {
 398   switch (e)
 399   {
 400   case E1: return 1;
 401   case E2: return 2;
 402   case E3: return 3;
 403   case E4: return 4;
 404   default:
 405     return 0;
 406   }
 407 }
 408
 409 double
 410 s_square_encue(encue_t *eue)
 411 {
 412   switch (eue->t)
 413   {
 414   case E1: return eue->tagged_union.i1 * eue->tagged_union.i1;
 415   case E2: return eue->tagged_union.f2 * eue->tagged_union.f2;
 416   default:
 417     return 0.0;
 418   }
 419 }
 420
 421 int
 422 s_sum_toplev_conf_2n(int *x, int n)
 423 {
 424   int sum = 0;
 425   int i;
 426   for (i = 0; i < 2 * n; ++i)
 427     sum += x[i];
 428   return sum;
 429 }
 430
 431 int
 432 s_sum_toplev_conf_cond(int *x, int a, int b, int c)
 433 {
 434   int sum = 0;
 435   int n = c ? a : b;
 436   int i;
 437   for (i = 0; i < n; ++i)
 438     sum += x[i];
 439   return sum;
 440 }
 441
 442 double
 443 s_sum_aligns(aligns_t *a)
 444 {
 445   return a->c + a->i + a->s + a->d;
 446 }
 447
 448 int
 449 s_sum_padded(padded_t *p)
 450 {
 451   return p->i + p->c;
 452 }
 453
 454 int
 455 s_sum_padded2(padded_t ps[2])
 456 {
 457   return s_sum_padded(&ps[0]) + s_sum_padded(&ps[1]);
 458 }
 459
 460 int
 461 s_sum_padded_conf(padded_t *ps, int n)
 462 {
 463   int sum = 0;
 464   int i;
 465   for (i = 0; i < n; ++i)
 466     sum += s_sum_padded(&ps[i]);
 467   return sum;
 468 }
 469
 470 int
 471 s_sum_bogus(bogus_t *b)
 472 {
 473   return *b->h.p1 + *b->p2 + *b->p3 + b->c;
 474 }
 475
 476 void
 477 s_check_null(int *null)
 478 {
 479   ok(!null, "RPC check_null\n");
 480 }
 481
 482 int
 483 s_str_struct_len(str_struct_t *s)
 484 {
 485   return lstrlenA(s->s);
 486 }
 487
 488 int
 489 s_wstr_struct_len(wstr_struct_t *s)
 490 {
 491   return lstrlenW(s->s);
 492 }
 493
 494 int
 495 s_sum_doub_carr(doub_carr_t *dc)
 496 {
 497   int i, j;
 498   int sum = 0;
 499   for (i = 0; i < dc->n; ++i)
 500     for (j = 0; j < dc->a[i]->n; ++j)
 501       sum += dc->a[i]->a[j];
 502   return sum;
 503 }
 504
 505 void
 506 s_make_pyramid_doub_carr(unsigned char n, doub_carr_t **dc)
 507 {
 508   doub_carr_t *t;
 509   int i, j;
 510   t = MIDL_user_allocate(FIELD_OFFSET(doub_carr_t, a[n]));
 511   t->n = n;
 512   for (i = 0; i < n; ++i)
 513   {
 514     int v = i + 1;
 515     t->a[i] = MIDL_user_allocate(FIELD_OFFSET(doub_carr_1_t, a[v]));
 516     t->a[i]->n = v;
 517     for (j = 0; j < v; ++j)
 518       t->a[i]->a[j] = j + 1;
 519   }
 520   *dc = t;
 521 }
 522
 523 unsigned
 524 s_hash_bstr(bstr_t b)
 525 {
 526   short n = b[-1];
 527   short *s = b;
 528   unsigned hash = 0;
 529   short i;
 530   for (i = 0; i < n; ++i)
 531     hash = 5 * hash + (unsigned) s[i];
 532   return hash;
 533 }
 534
 535 void
 536 s_get_name(name_t *name)
 537 {
 538   const char bossman[] = "Jeremy White";
 539   memcpy(name->name, bossman, min(name->size, sizeof(bossman)));
 540   /* ensure nul-termination */
 541   if (name->size < sizeof(bossman))
 542     name->name[name->size - 1] = 0;
 543 }
 544
 545 int
 546 s_sum_pcarr2(int n, int **pa)
 547 {
 548   return s_sum_conf_array(*pa, n);
 549 }
 550
 551 int
 552 s_sum_L1_norms(int n, vector_t *vs)
 553 {
 554   int i;
 555   int sum = 0;
 556   for (i = 0; i < n; ++i)
 557     sum += abs(vs[i].x) + abs(vs[i].y) + abs(vs[i].z);
 558   return sum;
 559 }
 560
 561 s123_t *
 562 s_get_s123(void)
 563 {
 564   s123_t *s = MIDL_user_allocate(sizeof *s);
 565   s->f1 = 1;
 566   s->f2 = 2;
 567   s->f3 = 3;
 568   return s;
 569 }
 570
 571 str_t
 572 s_get_filename(void)
 573 {
 574     return (char *)__FILE__;
 575 }
 576
 577 int s_echo_ranged_int(int n)
 578 {
 579     return n;
 580 }
 581
 582 void s_get_ranged_enum(renum_t *re)
 583 {
 584     *re = RE3;
 585 }
 586
 587 void
 588 s_context_handle_test(void)
 589 {
 590     NDR_SCONTEXT h;
 591     RPC_BINDING_HANDLE binding;
 592     RPC_STATUS status;
 593     unsigned char buf[20];
 594     static RPC_SERVER_INTERFACE server_if =
 595     {
 596         sizeof(RPC_SERVER_INTERFACE),
 597         {{0x00000000,0x4114,0x0704,{0x23,0x01,0x00,0x00,0x00,0x00,0x00,0x00}},{1,0}},
 598         {{0x8a885d04,0x1ceb,0x11c9,{0x9f,0xe8,0x08,0x00,0x2b,0x10,0x48,0x60}},{2,0}},
 599         NULL,
 600         0,
 601         0,
 602         0,
 603         0,
 604         0,
 605     };
 606
 607     binding = I_RpcGetCurrentCallHandle();
 608     ok(binding != NULL, "I_RpcGetCurrentCallHandle returned NULL\n");
 609
 610     if (!pNDRSContextMarshall2 || !pNDRSContextUnmarshall2)
 611     {
 612         win_skip("NDRSContextMarshall2 or NDRSContextUnmarshall2 not exported from rpcrt4.dll\n");
 613         return;
 614     }
 615
 616     h = pNDRSContextUnmarshall2(binding, NULL, NDR_LOCAL_DATA_REPRESENTATION, NULL, 0);
 617     ok(h != NULL, "NDRSContextUnmarshall2 returned NULL\n");
 618
 619     /* marshal a context handle with NULL userContext */
 620     memset(buf, 0xcc, sizeof(buf));
 621     pNDRSContextMarshall2(binding, h, buf, NULL, NULL, 0);
 622     ok(*(ULONG *)buf == 0, "attributes should have been set to 0 instead of 0x%x\n", *(ULONG *)buf);
 623     ok(UuidIsNil((UUID *)&buf[4], &status), "uuid should have been nil\n");
 624
 625     h = pNDRSContextUnmarshall2(binding, NULL, NDR_LOCAL_DATA_REPRESENTATION, NULL, 0);
 626     ok(h != NULL, "NDRSContextUnmarshall2 returned NULL\n");
 627
 628     /* marshal a context handle with non-NULL userContext */
 629     memset(buf, 0xcc, sizeof(buf));
 630     h->userContext = (void *)0xdeadbeef;
 631     pNDRSContextMarshall2(binding, h, buf, NULL, NULL, 0);
 632     ok(*(ULONG *)buf == 0, "attributes should have been set to 0 instead of 0x%x\n", *(ULONG *)buf);
 633     ok(!UuidIsNil((UUID *)&buf[4], &status), "uuid should not have been nil\n");
 634
 635     /* raises ERROR_INVALID_HANDLE exception on Vista upwards */
 636     if (0)
 637     {
 638     h = pNDRSContextUnmarshall2(binding, buf, NDR_LOCAL_DATA_REPRESENTATION, NULL, 0);
 639     ok(h != NULL, "NDRSContextUnmarshall2 returned NULL\n");
 640     ok(h->userContext == (void *)0xdeadbeef, "userContext of interface didn't unmarshal properly: %p\n", h->userContext);
 641
 642     /* marshal a context handle with an interface specified */
 643     h = pNDRSContextUnmarshall2(binding, NULL, NDR_LOCAL_DATA_REPRESENTATION, &server_if.InterfaceId, 0);
 644     ok(h != NULL, "NDRSContextUnmarshall2 returned NULL\n");
 645
 646     memset(buf, 0xcc, sizeof(buf));
 647     h->userContext = (void *)0xcafebabe;
 648     pNDRSContextMarshall2(binding, h, buf, NULL, &server_if.InterfaceId, 0);
 649     ok(*(ULONG *)buf == 0, "attributes should have been set to 0 instead of 0x%x\n", *(ULONG *)buf);
 650     ok(!UuidIsNil((UUID *)&buf[4], &status), "uuid should not have been nil\n");
 651
 652     h = pNDRSContextUnmarshall2(binding, buf, NDR_LOCAL_DATA_REPRESENTATION, &server_if.InterfaceId, 0);
 653     ok(h != NULL, "NDRSContextUnmarshall2 returned NULL\n");
 654     ok(h->userContext == (void *)0xcafebabe, "userContext of interface didn't unmarshal properly: %p\n", h->userContext);
 655     }
 656
 657     /* test same interface data, but different pointer */
 658     /* raises ERROR_INVALID_HANDLE exception */
 659     if (0)
 660     {
 661         RPC_SERVER_INTERFACE server_if_clone = server_if;
 662
 663         pNDRSContextUnmarshall2(binding, buf, NDR_LOCAL_DATA_REPRESENTATION, &server_if_clone.InterfaceId, 0);
 664     }
 665
 666     /* test different interface data, but different pointer */
 667     /* raises ERROR_INVALID_HANDLE exception */
 668     if (0)
 669     {
 670         static RPC_SERVER_INTERFACE server_if2 =
 671         {
 672             sizeof(RPC_SERVER_INTERFACE),
 673             {{0x00000000,0x4114,0x0704,{0x23,0x01,0x00,0x00,0x00,0x00,0x00,0x00}},{1,0}},
 674             {{0x8a885d04,0x1ceb,0x11c9,{0x9f,0xe8,0x08,0x00,0x2b,0x10,0x48,0x60}},{2,0}},
 675             NULL,
 676             0,
 677             0,
 678             0,
 679             0,
 680             0,
 681         };
 682         pNDRSContextMarshall2(binding, h, buf, NULL, &server_if.InterfaceId, 0);
 683
 684         pNDRSContextUnmarshall2(binding, buf, NDR_LOCAL_DATA_REPRESENTATION, &server_if2.InterfaceId, 0);
 685     }
 686 }
 687
 688 void
 689 s_get_numbers(int length, int size, pints_t n[])
 690 {
 691     int i;
 692     for (i = 0; i < length; i++)
 693     {
 694         n[i].pi = midl_user_allocate(sizeof(*n[i].pi));
 695         *n[i].pi = i;
 696         n[i].ppi = NULL;
 697         n[i].pppi = NULL;
 698     }
 699 }
 700
 701 void
 702 s_get_numbers_struct(numbers_struct_t **ns)
 703 {
 704     int i;
 705     *ns = midl_user_allocate(FIELD_OFFSET(numbers_struct_t, numbers[5]));
 706     if (!*ns) return;
 707     (*ns)->length = 5;
 708     (*ns)->size = 5;
 709     for (i = 0; i < (*ns)->length; i++)
 710     {
 711         (*ns)->numbers[i].pi = NULL;
 712         (*ns)->numbers[i].ppi = NULL;
 713         (*ns)->numbers[i].pppi = NULL;
 714     }
 715     (*ns)->numbers[0].pi = midl_user_allocate(sizeof(*(*ns)->numbers[i].pi));
 716     *(*ns)->numbers[0].pi = 5;
 717 }
 718
 719 void
 720 s_full_pointer_test(int *a, int *b)
 721 {
 722     ok(*a == 42, "Expected *a to be 42 instead of %d\n", *a);
 723     ok(*b == 42, "Expected *b to be 42 instead of %d\n", *a);
 724     ok(a == b, "Expected a (%p) to point to the same memory as b (%p)\n", a, b);
 725 }
 726
 727 void
 728 s_full_pointer_null_test(int *a, int *b)
 729 {
 730     ok(*a == 42, "Expected *a to be 42 instead of %d\n", *a);
 731     ok(b == NULL, "Expected b to be NULL instead of %p\n", b);
 732 }
 733
 734 void
 735 s_stop(void)
 736 {
 737   ok(RPC_S_OK == RpcMgmtStopServerListening(NULL), "RpcMgmtStopServerListening\n");
 738   ok(RPC_S_OK == RpcServerUnregisterIf(NULL, NULL, FALSE), "RpcServerUnregisterIf\n");
 739   ok(SetEvent(stop_event), "SetEvent\n");
 740 }
 741
 742 static void
 743 make_cmdline(char buffer[MAX_PATH], const char *test)
 744 {
 745   sprintf(buffer, "%s server %s", progname, test);
 746 }
 747
 748 static void
 749 run_client(const char *test)
 750 {
 751   char cmdline[MAX_PATH];
 752   PROCESS_INFORMATION info;
 753   STARTUPINFOA startup;
 754
 755   memset(&startup, 0, sizeof startup);
 756   startup.cb = sizeof startup;
 757
 758   make_cmdline(cmdline, test);
 759   ok(CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0L, NULL, NULL, &startup, &info), "CreateProcess\n");
 760   winetest_wait_child_process( info.hProcess );
 761   ok(CloseHandle(info.hProcess), "CloseHandle\n");
 762   ok(CloseHandle(info.hThread), "CloseHandle\n");
 763 }
 764
 765 static void
 766 basic_tests(void)
 767 {
 768   char string[] = "I am a string";
 769   WCHAR wstring[] = {'I',' ','a','m',' ','a',' ','w','s','t','r','i','n','g', 0};
 770   int f[5] = {1, 3, 0, -2, -4};
 771   vector_t a = {1, 3, 7};
 772   vector_t vec1 = {4, -2, 1}, vec2 = {-5, 2, 3}, *pvec2 = &vec2;
 773   pvectors_t pvecs = {&vec1, &pvec2};
 774   sp_inner_t spi = {42};
 775   sp_t sp = {-13, &spi};
 776   aligns_t aligns;
 777   pints_t pints;
 778   ptypes_t ptypes;
 779   padded_t padded;
 780   padded_t padded2[2];
 781   bogus_t bogus;
 782   int i1, i2, i3, *pi2, *pi3, **ppi3;
 783   double u, v;
 784   float s, t;
 785   LONG q, r;
 786   short h;
 787   char c;
 788   int x;
 789   str_struct_t ss = {string};
 790   wstr_struct_t ws = {wstring};
 791   str_t str;
 792   se_t se;
 793   renum_t re;
 794
 795   ok(int_return() == INT_CODE, "RPC int_return\n");
 796
 797   ok(square(7) == 49, "RPC square\n");
 798   ok(sum(23, -4) == 19, "RPC sum\n");
 799
 800   x = 0;
 801   square_out(11, &x);
 802   ok(x == 121, "RPC square_out\n");
 803
 804   x = 5;
 805   square_ref(&x);
 806   ok(x == 25, "RPC square_ref\n");
 807
 808   ok(str_length(string) == strlen(string), "RPC str_length\n");
 809   ok(str_t_length(string) == strlen(string), "RPC str_length\n");
 810   ok(dot_self(&a) == 59, "RPC dot_self\n");
 811
 812   ok(str_struct_len(&ss) == lstrlenA(string), "RPC str_struct_len\n");
 813   ok(wstr_struct_len(&ws) == lstrlenW(wstring), "RPC str_struct_len\n");
 814
 815   v = 0.0;
 816   u = square_half(3.0, &v);
 817   ok(u == 9.0, "RPC square_half\n");
 818   ok(v == 1.5, "RPC square_half\n");
 819
 820   t = 0.0f;
 821   s = square_half_float(3.0f, &t);
 822   ok(s == 9.0f, "RPC square_half_float\n");
 823   ok(t == 1.5f, "RPC square_half_float\n");
 824
 825   r = 0;
 826   q = square_half_long(3, &r);
 827   ok(q == 9, "RPC square_half_long\n");
 828   ok(r == 1, "RPC square_half_long\n");
 829
 830   i1 = 19;
 831   i2 = -3;
 832   i3 = -29;
 833   pi2 = &i2;
 834   pi3 = &i3;
 835   ppi3 = &pi3;
 836   pints.pi = &i1;
 837   pints.ppi = &pi2;
 838   pints.pppi = &ppi3;
 839   ok(pints_sum(&pints) == -13, "RPC pints_sum\n");
 840
 841   c = 10;
 842   h = 3;
 843   q = 14;
 844   s = -5.0f;
 845   u = 11.0;
 846   ptypes.pc = &c;
 847   ptypes.ps = &h;
 848   ptypes.pl = &q;
 849   ptypes.pf = &s;
 850   ptypes.pd = &u;
 851   ok(ptypes_sum(&ptypes) == 33.0, "RPC ptypes_sum\n");
 852
 853   ok(dot_pvectors(&pvecs) == -21, "RPC dot_pvectors\n");
 854   ok(dot_copy_vectors(vec1, vec2) == -21, "RPC dot_copy_vectors\n");
 855   ok(sum_fixed_array(f) == -2, "RPC sum_fixed_array\n");
 856   ok(sum_sp(&sp) == 29, "RPC sum_sp\n");
 857
 858   ok(enum_ord(E1) == 1, "RPC enum_ord\n");
 859   ok(enum_ord(E2) == 2, "RPC enum_ord\n");
 860   ok(enum_ord(E3) == 3, "RPC enum_ord\n");
 861   ok(enum_ord(E4) == 4, "RPC enum_ord\n");
 862
 863   se.f = E2;
 864   check_se2(&se);
 865
 866   memset(&aligns, 0, sizeof(aligns));
 867   aligns.c = 3;
 868   aligns.i = 4;
 869   aligns.s = 5;
 870   aligns.d = 6.0;
 871   ok(sum_aligns(&aligns) == 18.0, "RPC sum_aligns\n");
 872
 873   padded.i = -3;
 874   padded.c = 8;
 875   ok(sum_padded(&padded) == 5, "RPC sum_padded\n");
 876   padded2[0].i = -5;
 877   padded2[0].c = 1;
 878   padded2[1].i = 3;
 879   padded2[1].c = 7;
 880   ok(sum_padded2(padded2) == 6, "RPC sum_padded2\n");
 881   padded2[0].i = -5;
 882   padded2[0].c = 1;
 883   padded2[1].i = 3;
 884   padded2[1].c = 7;
 885   ok(sum_padded_conf(padded2, 2) == 6, "RPC sum_padded_conf\n");
 886
 887   i1 = 14;
 888   i2 = -7;
 889   i3 = -4;
 890   bogus.h.p1 = &i1;
 891   bogus.p2 = &i2;
 892   bogus.p3 = &i3;
 893   bogus.c = 9;
 894   ok(sum_bogus(&bogus) == 12, "RPC sum_bogus\n");
 895
 896   check_null(NULL);
 897
 898   str = get_filename();
 899   ok(!strcmp(str, __FILE__), "get_filename() returned %s instead of %s\n", str, __FILE__);
 900   midl_user_free(str);
 901
 902   x = echo_ranged_int(0);
 903   ok(x == 0, "echo_ranged_int() returned %d instead of 0\n", x);
 904   x = echo_ranged_int(100);
 905   ok(x == 100, "echo_ranged_int() returned %d instead of 100\n", x);
 906
 907   get_ranged_enum(&re);
 908   ok(re == RE3, "get_ranged_enum() returned %d instead of RE3\n", re);
 909 }
 910
 911 static void
 912 union_tests(void)
 913 {
 914   encue_t eue;
 915   encu_t eu;
 916   unencu_t uneu;
 917   sun_t su;
 918   int i;
 919
 920   su.s = SUN_I;
 921   su.u.i = 9;
 922   ok(square_sun(&su) == 81.0, "RPC square_sun\n");
 923
 924   su.s = SUN_F1;
 925   su.u.f = 5.0;
 926   ok(square_sun(&su) == 25.0, "RPC square_sun\n");
 927
 928   su.s = SUN_F2;
 929   su.u.f = -2.0;
 930   ok(square_sun(&su) == 4.0, "RPC square_sun\n");
 931
 932   su.s = SUN_PI;
 933   su.u.pi = &i;
 934   i = 11;
 935   ok(square_sun(&su) == 121.0, "RPC square_sun\n");
 936
 937   eu.t = ENCU_I;
 938   eu.tagged_union.i = 7;
 939   ok(square_encu(&eu) == 49.0, "RPC square_encu\n");
 940
 941   eu.t = ENCU_F;
 942   eu.tagged_union.f = 3.0;
 943   ok(square_encu(&eu) == 9.0, "RPC square_encu\n");
 944
 945   uneu.i = 4;
 946   ok(square_unencu(ENCU_I, &uneu) == 16.0, "RPC square_unencu\n");
 947
 948   uneu.f = 5.0;
 949   ok(square_unencu(ENCU_F, &uneu) == 25.0, "RPC square_unencu\n");
 950
 951   eue.t = E1;
 952   eue.tagged_union.i1 = 8;
 953   ok(square_encue(&eue) == 64.0, "RPC square_encue\n");
 954
 955   eue.t = E2;
 956   eue.tagged_union.f2 = 10.0;
 957   ok(square_encue(&eue) == 100.0, "RPC square_encue\n");
 958 }
 959
 960 static test_list_t *
 961 null_list(void)
 962 {
 963   test_list_t *n = HeapAlloc(GetProcessHeap(), 0, sizeof *n);
 964   n->t = TL_NULL;
 965   n->u.x = 0;
 966   return n;
 967 }
 968
 969 static test_list_t *
 970 make_list(test_list_t *tail)
 971 {
 972   test_list_t *n = HeapAlloc(GetProcessHeap(), 0, sizeof *n);
 973   n->t = TL_LIST;
 974   n->u.tail = tail;
 975   return n;
 976 }
 977
 978 static void
 979 free_list(test_list_t *list)
 980 {
 981   if (list->t == TL_LIST)
 982     free_list(list->u.tail);
 983   HeapFree(GetProcessHeap(), 0, list);
 984 }
 985
 986 ULONG __RPC_USER
 987 puint_t_UserSize(ULONG *flags, ULONG start, puint_t *p)
 988 {
 989   return start + sizeof(int);
 990 }
 991
 992 unsigned char * __RPC_USER
 993 puint_t_UserMarshal(ULONG *flags, unsigned char *buffer, puint_t *p)
 994 {
 995   int n = atoi(*p);
 996   memcpy(buffer, &n, sizeof n);
 997   return buffer + sizeof n;
 998 }
 999
1000 unsigned char * __RPC_USER
1001 puint_t_UserUnmarshal(ULONG *flags, unsigned char *buffer, puint_t *p)
1002 {
1003   int n;
1004   memcpy(&n, buffer, sizeof n);
1005   *p = HeapAlloc(GetProcessHeap(), 0, 10);
1006   sprintf(*p, "%d", n);
1007   return buffer + sizeof n;
1008 }
1009
1010 void __RPC_USER
1011 puint_t_UserFree(ULONG *flags, puint_t *p)
1012 {
1013   HeapFree(GetProcessHeap(), 0, *p);
1014 }
1015
1016 ULONG __RPC_USER
1017 us_t_UserSize(ULONG *flags, ULONG start, us_t *pus)
1018 {
1019   return start + sizeof(struct wire_us);
1020 }
1021
1022 unsigned char * __RPC_USER
1023 us_t_UserMarshal(ULONG *flags, unsigned char *buffer, us_t *pus)
1024 {
1025   struct wire_us wus;
1026   wus.x = atoi(pus->x);
1027   memcpy(buffer, &wus, sizeof wus);
1028   return buffer + sizeof wus;
1029 }
1030
1031 unsigned char * __RPC_USER
1032 us_t_UserUnmarshal(ULONG *flags, unsigned char *buffer, us_t *pus)
1033 {
1034   struct wire_us wus;
1035   memcpy(&wus, buffer, sizeof wus);
1036   pus->x = HeapAlloc(GetProcessHeap(), 0, 10);
1037   sprintf(pus->x, "%d", wus.x);
1038   return buffer + sizeof wus;
1039 }
1040
1041 void __RPC_USER
1042 us_t_UserFree(ULONG *flags, us_t *pus)
1043 {
1044   HeapFree(GetProcessHeap(), 0, pus->x);
1045 }
1046
1047 ULONG __RPC_USER
1048 bstr_t_UserSize(ULONG *flags, ULONG start, bstr_t *b)
1049 {
1050   return start + FIELD_OFFSET(user_bstr_t, data[(*b)[-1]]);
1051 }
1052
1053 unsigned char * __RPC_USER
1054 bstr_t_UserMarshal(ULONG *flags, unsigned char *buffer, bstr_t *b)
1055 {
1056   wire_bstr_t wb = (wire_bstr_t) buffer;
1057   wb->n = (*b)[-1];
1058   memcpy(&wb->data, *b, wb->n * sizeof wb->data[0]);
1059   return buffer + FIELD_OFFSET(user_bstr_t, data[wb->n]);
1060 }
1061
1062 unsigned char * __RPC_USER
1063 bstr_t_UserUnmarshal(ULONG *flags, unsigned char *buffer, bstr_t *b)
1064 {
1065   wire_bstr_t wb = (wire_bstr_t) buffer;
1066   short *data = HeapAlloc(GetProcessHeap(), 0, (wb->n + 1) * sizeof *data);
1067   data[0] = wb->n;
1068   memcpy(&data[1], wb->data, wb->n * sizeof data[1]);
1069   *b = &data[1];
1070   return buffer + FIELD_OFFSET(user_bstr_t, data[wb->n]);
1071 }
1072
1073 void __RPC_USER
1074 bstr_t_UserFree(ULONG *flags, bstr_t *b)
1075 {
1076   HeapFree(GetProcessHeap(), 0, &((*b)[-1]));
1077 }
1078
1079 static void
1080 pointer_tests(void)
1081 {
1082   int a[] = {1, 2, 3, 4};
1083   char p1[] = "11";
1084   test_list_t *list = make_list(make_list(make_list(null_list())));
1085   test_us_t tus = {{p1}};
1086   int *pa[4];
1087   puints_t pus;
1088   cpuints_t cpus;
1089   short bstr_data[] = { 5, 'H', 'e', 'l', 'l', 'o' };
1090   bstr_t bstr = &bstr_data[1];
1091   name_t name;
1092   void *buffer;
1093   int *pa2;
1094   s123_t *s123;
1095   int val = 42;
1096
1097   ok(test_list_length(list) == 3, "RPC test_list_length\n");
1098   ok(square_puint(p1) == 121, "RPC square_puint\n");
1099   pus.n = 4;
1100   pus.ps = HeapAlloc(GetProcessHeap(), 0, pus.n * sizeof pus.ps[0]);
1101   pus.ps[0] = xstrdup("5");
1102   pus.ps[1] = xstrdup("6");
1103   pus.ps[2] = xstrdup("7");
1104   pus.ps[3] = xstrdup("8");
1105   ok(sum_puints(&pus) == 26, "RPC sum_puints\n");
1106   HeapFree(GetProcessHeap(), 0, pus.ps[0]);
1107   HeapFree(GetProcessHeap(), 0, pus.ps[1]);
1108   HeapFree(GetProcessHeap(), 0, pus.ps[2]);
1109   HeapFree(GetProcessHeap(), 0, pus.ps[3]);
1110   HeapFree(GetProcessHeap(), 0, pus.ps);
1111   cpus.n = 4;
1112   cpus.ps = HeapAlloc(GetProcessHeap(), 0, cpus.n * sizeof cpus.ps[0]);
1113   cpus.ps[0] = xstrdup("5");
1114   cpus.ps[1] = xstrdup("6");
1115   cpus.ps[2] = xstrdup("7");
1116   cpus.ps[3] = xstrdup("8");
1117   ok(sum_cpuints(&cpus) == 26, "RPC sum_puints\n");
1118   HeapFree(GetProcessHeap(), 0, cpus.ps[0]);
1119   HeapFree(GetProcessHeap(), 0, cpus.ps[1]);
1120   HeapFree(GetProcessHeap(), 0, cpus.ps[2]);
1121   HeapFree(GetProcessHeap(), 0, cpus.ps[3]);
1122   HeapFree(GetProcessHeap(), 0, cpus.ps);
1123   ok(square_test_us(&tus) == 121, "RPC square_test_us\n");
1124
1125   pa[0] = &a[0];
1126   pa[1] = &a[1];
1127   pa[2] = &a[2];
1128   ok(sum_parr(pa) == 6, "RPC sum_parr\n");
1129
1130   pa[0] = &a[0];
1131   pa[1] = &a[1];
1132   pa[2] = &a[2];
1133   pa[3] = &a[3];
1134   ok(sum_pcarr(pa, 4) == 10, "RPC sum_pcarr\n");
1135
1136   ok(hash_bstr(bstr) == s_hash_bstr(bstr), "RPC hash_bstr_data\n");
1137
1138   free_list(list);
1139
1140   if (!old_windows_version)
1141   {
1142       name.size = 10;
1143       name.name = buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, name.size);
1144       get_name(&name);
1145       ok(name.name == buffer, "[in,out] pointer should have stayed as %p but instead changed to %p\n", name.name, buffer);
1146       ok(!strcmp(name.name, "Jeremy Wh"), "name didn't unmarshall properly, expected \"Jeremy Wh\", but got \"%s\"\n", name.name);
1147       HeapFree(GetProcessHeap(), 0, name.name);
1148   }
1149
1150   pa2 = a;
1151   ok(sum_pcarr2(4, &pa2) == 10, "RPC sum_pcarr2\n");
1152
1153   s123 = get_s123();
1154   ok(s123->f1 == 1 && s123->f2 == 2 && s123->f3 == 3, "RPC get_s123\n");
1155   MIDL_user_free(s123);
1156
1157   full_pointer_test(&val, &val);
1158   full_pointer_null_test(&val, NULL);
1159 }
1160
1161 static int
1162 check_pyramid_doub_carr(doub_carr_t *dc)
1163 {
1164   int i, j;
1165   for (i = 0; i < dc->n; ++i)
1166     for (j = 0; j < dc->a[i]->n; ++j)
1167       if (dc->a[i]->a[j] != j + 1)
1168         return FALSE;
1169   return TRUE;
1170 }
1171
1172 static void
1173 free_pyramid_doub_carr(doub_carr_t *dc)
1174 {
1175   int i;
1176   for (i = 0; i < dc->n; ++i)
1177     MIDL_user_free(dc->a[i]);
1178   MIDL_user_free(dc);
1179 }
1180
1181 static void
1182 array_tests(void)
1183 {
1184   int m[2][3][4] =
1185   {
1186     {{1, 2, 3, 4}, {-1, -3, -5, -7}, {0, 2, 4, 6}},
1187     {{1, -2, 3, -4}, {2, 3, 5, 7}, {-4, -1, -14, 4114}}
1188   };
1189   int c[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
1190   int c2[] = {10, 100, 200};
1191   vector_t vs[2] = {{1, -2, 3}, {4, -5, -6}};
1192   cps_t cps;
1193   cpsc_t cpsc;
1194   cs_t *cs;
1195   int n;
1196   int ca[5] = {1, -2, 3, -4, 5};
1197   doub_carr_t *dc;
1198   int *pi;
1199   pints_t api[5];
1200   numbers_struct_t *ns;
1201
1202   if (!old_windows_version)
1203   {
1204       const char str1[25] = "Hello";
1205       ok(cstr_length(str1, sizeof str1) == strlen(str1), "RPC cstr_length\n");
1206   }
1207
1208   ok(sum_fixed_int_3d(m) == 4116, "RPC sum_fixed_int_3d\n");
1209
1210   ok(sum_conf_array(c, 10) == 45, "RPC sum_conf_array\n");
1211   ok(sum_conf_array(&c[5], 2) == 11, "RPC sum_conf_array\n");
1212   ok(sum_conf_array(&c[7], 1) == 7, "RPC sum_conf_array\n");
1213   ok(sum_conf_array(&c[2], 0) == 0, "RPC sum_conf_array\n");
1214
1215   ok(sum_conf_ptr_by_conf_ptr(1, c2, c) == 45, "RPC sum_conf_ptr_by_conf_ptr\n");
1216   ok(sum_conf_ptr_by_conf_ptr(3, c2, c) == 345, "RPC sum_conf_ptr_by_conf_ptr\n");
1217   c2[0] = 0;
1218   ok(sum_conf_ptr_by_conf_ptr(3, c2, c) == 300, "RPC sum_conf_ptr_by_conf_ptr\n");
1219
1220   ok(sum_unique_conf_array(ca, 4) == -2, "RPC sum_unique_conf_array\n");
1221   ok(sum_unique_conf_ptr(ca, 5) == 3, "RPC sum_unique_conf_array\n");
1222   ok(sum_unique_conf_ptr(NULL, 10) == 0, "RPC sum_unique_conf_array\n");
1223
1224   ok(sum_var_array(c, 10) == 45, "RPC sum_conf_array\n");
1225   ok(sum_var_array(&c[5], 2) == 11, "RPC sum_conf_array\n");
1226   ok(sum_var_array(&c[7], 1) == 7, "RPC sum_conf_array\n");
1227   ok(sum_var_array(&c[2], 0) == 0, "RPC sum_conf_array\n");
1228
1229   ok(dot_two_vectors(vs) == -4, "RPC dot_two_vectors\n");
1230   cs = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(cs_t, ca[5]));
1231   cs->n = 5;
1232   cs->ca[0] = 3;
1233   cs->ca[1] = 5;
1234   cs->ca[2] = -2;
1235   cs->ca[3] = -1;
1236   cs->ca[4] = -4;
1237   ok(sum_cs(cs) == 1, "RPC sum_cs\n");
1238   HeapFree(GetProcessHeap(), 0, cs);
1239
1240   n = 5;
1241   cps.pn = &n;
1242   cps.ca1 = &c[2];
1243   cps.n = 3;
1244   cps.ca2 = &c[3];
1245   ok(sum_cps(&cps) == 53, "RPC sum_cps\n");
1246
1247   cpsc.a = 4;
1248   cpsc.b = 5;
1249   cpsc.c = 1;
1250   cpsc.ca = c;
1251   ok(sum_cpsc(&cpsc) == 6, "RPC sum_cpsc\n");
1252   cpsc.a = 4;
1253   cpsc.b = 5;
1254   cpsc.c = 0;
1255   cpsc.ca = c;
1256   ok(sum_cpsc(&cpsc) == 10, "RPC sum_cpsc\n");
1257
1258   ok(sum_toplev_conf_2n(c, 3) == 15, "RPC sum_toplev_conf_2n\n");
1259   ok(sum_toplev_conf_cond(c, 5, 6, 1) == 10, "RPC sum_toplev_conf_cond\n");
1260   ok(sum_toplev_conf_cond(c, 5, 6, 0) == 15, "RPC sum_toplev_conf_cond\n");
1261
1262   dc = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(doub_carr_t, a[2]));
1263   dc->n = 2;
1264   dc->a[0] = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(doub_carr_1_t, a[3]));
1265   dc->a[0]->n = 3;
1266   dc->a[0]->a[0] = 5;
1267   dc->a[0]->a[1] = 1;
1268   dc->a[0]->a[2] = 8;
1269   dc->a[1] = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(doub_carr_1_t, a[2]));
1270   dc->a[1]->n = 2;
1271   dc->a[1]->a[0] = 2;
1272   dc->a[1]->a[1] = 3;
1273   ok(sum_doub_carr(dc) == 19, "RPC sum_doub_carr\n");
1274   HeapFree(GetProcessHeap(), 0, dc->a[0]);
1275   HeapFree(GetProcessHeap(), 0, dc->a[1]);
1276   HeapFree(GetProcessHeap(), 0, dc);
1277
1278   dc = NULL;
1279   make_pyramid_doub_carr(4, &dc);
1280   ok(check_pyramid_doub_carr(dc), "RPC make_pyramid_doub_carr\n");
1281   free_pyramid_doub_carr(dc);
1282
1283   ok(sum_L1_norms(2, vs) == 21, "RPC sum_L1_norms\n");
1284
1285   memset(api, 0, sizeof(api));
1286   pi = HeapAlloc(GetProcessHeap(), 0, sizeof(*pi));
1287   *pi = -1;
1288   api[0].pi = pi;
1289   get_numbers(1, 1, api);
1290   ok(api[0].pi == pi, "RPC conformant varying array [out] pointer changed from %p to %p\n", pi, api[0].pi);
1291   ok(*api[0].pi == 0, "pi unmarshalled incorrectly %d\n", *api[0].pi);
1292
1293   if (!old_windows_version)
1294   {
1295       ns = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, FIELD_OFFSET(numbers_struct_t, numbers[5]));
1296       ns->length = 5;
1297       ns->size = 5;
1298       ns->numbers[0].pi = pi;
1299       get_numbers_struct(&ns);
1300       ok(ns->numbers[0].pi == pi, "RPC conformant varying struct embedded pointer changed from %p to %p\n", pi, ns->numbers[0].pi);
1301       ok(*ns->numbers[0].pi == 5, "pi unmarshalled incorrectly %d\n", *ns->numbers[0].pi);
1302       HeapFree(GetProcessHeap(), 0, ns);
1303   }
1304   HeapFree(GetProcessHeap(), 0, pi);
1305 }
1306
1307 static void
1308 run_tests(void)
1309 {
1310   basic_tests();
1311   union_tests();
1312   pointer_tests();
1313   array_tests();
1314   context_handle_test();
1315 }
1316
1317 static void
1318 client(const char *test)
1319 {
1320   if (strcmp(test, "tcp_basic") == 0)
1321   {
1322     static unsigned char iptcp[] = "ncacn_ip_tcp";
1323     static unsigned char address[] = "127.0.0.1";
1324     static unsigned char port[] = PORT;
1325     unsigned char *binding;
1326
1327     ok(RPC_S_OK == RpcStringBindingCompose(NULL, iptcp, address, port, NULL, &binding), "RpcStringBindingCompose\n");
1328     ok(RPC_S_OK == RpcBindingFromStringBinding(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
1329
1330     run_tests();
1331
1332     ok(RPC_S_OK == RpcStringFree(&binding), "RpcStringFree\n");
1333     ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
1334   }
1335   else if (strcmp(test, "ncalrpc_basic") == 0)
1336   {
1337     static unsigned char ncalrpc[] = "ncalrpc";
1338     static unsigned char guid[] = "00000000-4114-0704-2301-000000000000";
1339     unsigned char *binding;
1340
1341     ok(RPC_S_OK == RpcStringBindingCompose(NULL, ncalrpc, NULL, guid, NULL, &binding), "RpcStringBindingCompose\n");
1342     ok(RPC_S_OK == RpcBindingFromStringBinding(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
1343
1344     run_tests();
1345
1346     ok(RPC_S_OK == RpcStringFree(&binding), "RpcStringFree\n");
1347     ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
1348   }
1349   else if (strcmp(test, "np_basic") == 0)
1350   {
1351     static unsigned char np[] = "ncacn_np";
1352     static unsigned char address[] = "\\\\.";
1353     static unsigned char pipe[] = PIPE;
1354     unsigned char *binding;
1355
1356     ok(RPC_S_OK == RpcStringBindingCompose(NULL, np, address, pipe, NULL, &binding), "RpcStringBindingCompose\n");
1357     ok(RPC_S_OK == RpcBindingFromStringBinding(binding, &IServer_IfHandle), "RpcBindingFromStringBinding\n");
1358
1359     run_tests();
1360     stop();
1361
1362     ok(RPC_S_OK == RpcStringFree(&binding), "RpcStringFree\n");
1363     ok(RPC_S_OK == RpcBindingFree(&IServer_IfHandle), "RpcBindingFree\n");
1364   }
1365 }
1366
1367 static void
1368 server(void)
1369 {
1370   static unsigned char iptcp[] = "ncacn_ip_tcp";
1371   static unsigned char port[] = PORT;
1372   static unsigned char np[] = "ncacn_np";
1373   static unsigned char pipe[] = PIPE;
1374   static unsigned char ncalrpc[] = "ncalrpc";
1375   static unsigned char guid[] = "00000000-4114-0704-2301-000000000000";
1376   RPC_STATUS status, iptcp_status, np_status, ncalrpc_status;
1377   DWORD ret;
1378
1379   iptcp_status = RpcServerUseProtseqEp(iptcp, 20, port, NULL);
1380   ok(iptcp_status == RPC_S_OK, "RpcServerUseProtseqEp(ncacn_ip_tcp) failed with status %d\n", iptcp_status);
1381
1382   ncalrpc_status = RpcServerUseProtseqEp(ncalrpc, 0, guid, NULL);
1383   ok(ncalrpc_status == RPC_S_OK, "RpcServerUseProtseqEp(ncalrpc) failed with status %d\n", ncalrpc_status);
1384
1385   np_status = RpcServerUseProtseqEp(np, 0, pipe, NULL);
1386   if (np_status == RPC_S_PROTSEQ_NOT_SUPPORTED)
1387     skip("Protocol sequence ncacn_np is not supported\n");
1388   else
1389     ok(np_status == RPC_S_OK, "RpcServerUseProtseqEp(ncacn_np) failed with status %d\n", np_status);
1390
1391   if (pRpcServerRegisterIfEx)
1392   {
1393     trace("Using RpcServerRegisterIfEx\n");
1394     status = pRpcServerRegisterIfEx(s_IServer_v0_0_s_ifspec, NULL, NULL,
1395                                     RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH,
1396                                     RPC_C_LISTEN_MAX_CALLS_DEFAULT, NULL);
1397   }
1398   else
1399     status = RpcServerRegisterIf(s_IServer_v0_0_s_ifspec, NULL, NULL);
1400   ok(status == RPC_S_OK, "RpcServerRegisterIf failed with status %d\n", status);
1401   status = RpcServerListen(1, 20, TRUE);
1402   ok(status == RPC_S_OK, "RpcServerListen failed with status %d\n", status);
1403   stop_event = CreateEvent(NULL, FALSE, FALSE, NULL);
1404   ok(stop_event != NULL, "CreateEvent failed with error %d\n", GetLastError());
1405
1406   if (iptcp_status == RPC_S_OK)
1407     run_client("tcp_basic");
1408   else
1409     skip("tcp_basic tests skipped due to earlier failure\n");
1410
1411   if (ncalrpc_status == RPC_S_OK)
1412     run_client("ncalrpc_basic");
1413   else
1414     skip("ncalrpc_basic tests skipped due to earlier failure\n");
1415
1416   if (np_status == RPC_S_OK)
1417     run_client("np_basic");
1418   else
1419   {
1420     skip("np_basic tests skipped due to earlier failure\n");
1421     /* np client is what signals stop_event, so bail out if we didn't run do it */
1422     return;
1423   }
1424
1425   ret = WaitForSingleObject(stop_event, 1000);
1426   ok(WAIT_OBJECT_0 == ret, "WaitForSingleObject\n");
1427   /* if the stop event didn't fire then RpcMgmtWaitServerListen will wait
1428    * forever, so don't bother calling it in this case */
1429   if (ret == WAIT_OBJECT_0)
1430   {
1431     status = RpcMgmtWaitServerListen();
1432     todo_wine {
1433       ok(status == RPC_S_OK, "RpcMgmtWaitServerListening failed with status %d\n", status);
1434     }
1435   }
1436 }
1437
1438 START_TEST(server)
1439 {
1440   int argc;
1441   char **argv;
1442
1443   InitFunctionPointers();
1444
1445   argc = winetest_get_mainargs(&argv);
1446   progname = argv[0];
1447
1448   if (argc == 3)
1449   {
1450     RpcTryExcept
1451     {
1452       client(argv[2]);
1453     }
1454     RpcExcept(TRUE)
1455     {
1456       trace("Exception %d\n", RpcExceptionCode());
1457     }
1458     RpcEndExcept
1459   }
1460   else
1461     server();
1462 }