dlls/dplayx/tests/dplayx.c

   1 /* DirectPlay Conformance Tests
   2  *
   3  * Copyright 2007 - Alessandro Pignotti
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "wine/test.h"
  21 #include <stdio.h>
  22 #define INITGUID
  23 #include <dplay.h>
  24 #include <dplobby.h>
  25
  26
  27 #define check(expected, result)                 \
  28     ok( (expected) == (result),                 \
  29         "expected=%d got=%d\n",                 \
  30         expected, result );
  31 #define checkLP(expected, result)               \
  32     ok( (expected) == (result),                 \
  33         "expected=%p got=%p\n",                 \
  34         expected, result );
  35 #define checkHR(expected, result)                       \
  36     ok( (expected) == (result),                         \
  37         "expected=%s got=%s\n",                         \
  38         dpResult2str(expected), dpResult2str(result) );
  39 #define checkFlags(expected, result, flags)     \
  40     ok( (expected) == (result),                 \
  41         "expected=0x%08x(%s) got=0x%08x(%s)\n", \
  42         expected, dwFlags2str(expected, flags), \
  43         result, dwFlags2str(result, flags) );
  44 #define checkGuid(expected, result)             \
  45     ok( IsEqualGUID(expected, result),          \
  46         "expected=%s got=%s\n",                 \
  47         Guid2str(expected), Guid2str(result) );
  48
  49
  50 DEFINE_GUID(appGuid, 0xbdcfe03e, 0xf0ec, 0x415b, 0x82, 0x11, 0x6f, 0x86, 0xd8, 0x19, 0x7f, 0xe1);
  51 DEFINE_GUID(appGuid2, 0x93417d3f, 0x7d26, 0x46ba, 0xb5, 0x76, 0xfe, 0x4b, 0x20, 0xbb, 0xad, 0x70);
  52 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
  53
  54
  55 typedef struct tagCallbackData
  56 {
  57     LPDIRECTPLAY4 pDP;
  58     UINT dwCounter1, dwCounter2;
  59     DWORD dwFlags;
  60     char szTrace1[1024], szTrace2[1024];
  61     DPID *dpid;
  62     UINT dpidSize;
  63 } CallbackData, *lpCallbackData;
  64
  65
  66 static LPSTR get_temp_buffer(void)
  67 {
  68     static UINT index = 0;
  69     static char buff[10][256];
  70
  71     index = (index + 1) % 10;
  72     *buff[index] = 0;
  73
  74     return buff[index];
  75 }
  76
  77
  78 static LPCSTR Guid2str(const GUID *guid)
  79 {
  80     LPSTR buffer = get_temp_buffer();
  81
  82     if (!guid) return "(null)";
  83
  84     /* Service providers */
  85     if (IsEqualGUID(guid, &DPSPGUID_IPX))
  86         return "DPSPGUID_IPX";
  87     if (IsEqualGUID(guid, &DPSPGUID_TCPIP))
  88         return "DPSPGUID_TCPIP";
  89     if (IsEqualGUID(guid, &DPSPGUID_SERIAL))
  90         return "DPSPGUID_SERIAL";
  91     if (IsEqualGUID(guid, &DPSPGUID_MODEM))
  92         return "DPSPGUID_MODEM";
  93     /* DirectPlay Address ID's */
  94     if (IsEqualGUID(guid, &DPAID_TotalSize))
  95         return "DPAID_TotalSize";
  96     if (IsEqualGUID(guid, &DPAID_ServiceProvider))
  97         return "DPAID_ServiceProvider";
  98     if (IsEqualGUID(guid, &DPAID_LobbyProvider))
  99         return "DPAID_LobbyProvider";
 100     if (IsEqualGUID(guid, &DPAID_Phone))
 101         return "DPAID_Phone";
 102     if (IsEqualGUID(guid, &DPAID_PhoneW))
 103         return "DPAID_PhoneW";
 104     if (IsEqualGUID(guid, &DPAID_Modem))
 105         return "DPAID_Modem";
 106     if (IsEqualGUID(guid, &DPAID_ModemW))
 107         return "DPAID_ModemW";
 108     if (IsEqualGUID(guid, &DPAID_INet))
 109         return "DPAID_INet";
 110     if (IsEqualGUID(guid, &DPAID_INetW))
 111         return "DPAID_INetW";
 112     if (IsEqualGUID(guid, &DPAID_INetPort))
 113         return "DPAID_INetPort";
 114     if (IsEqualGUID(guid, &DPAID_ComPort))
 115         return "DPAID_ComPort";
 116
 117     sprintf( buffer, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
 118              guid->Data1, guid->Data2, guid->Data3,
 119              guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
 120              guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7] );
 121     return buffer;
 122
 123 }
 124
 125
 126 static LPCSTR dpResult2str(HRESULT hr)
 127 {
 128     switch (hr)
 129     {
 130     case DP_OK:                          return "DP_OK";
 131     case DPERR_ALREADYINITIALIZED:       return "DPERR_ALREADYINITIALIZED";
 132     case DPERR_ACCESSDENIED:             return "DPERR_ACCESSDENIED";
 133     case DPERR_ACTIVEPLAYERS:            return "DPERR_ACTIVEPLAYERS";
 134     case DPERR_BUFFERTOOSMALL:           return "DPERR_BUFFERTOOSMALL";
 135     case DPERR_CANTADDPLAYER:            return "DPERR_CANTADDPLAYER";
 136     case DPERR_CANTCREATEGROUP:          return "DPERR_CANTCREATEGROUP";
 137     case DPERR_CANTCREATEPLAYER:         return "DPERR_CANTCREATEPLAYER";
 138     case DPERR_CANTCREATESESSION:        return "DPERR_CANTCREATESESSION";
 139     case DPERR_CAPSNOTAVAILABLEYET:      return "DPERR_CAPSNOTAVAILABLEYET";
 140     case DPERR_EXCEPTION:                return "DPERR_EXCEPTION";
 141     case DPERR_GENERIC:                  return "DPERR_GENERIC";
 142     case DPERR_INVALIDFLAGS:             return "DPERR_INVALIDFLAGS";
 143     case DPERR_INVALIDOBJECT:            return "DPERR_INVALIDOBJECT";
 144     case DPERR_INVALIDPARAMS:            return "DPERR_INVALIDPARAMS";
 145         /*           symbol with the same value: DPERR_INVALIDPARAM */
 146     case DPERR_INVALIDPLAYER:            return "DPERR_INVALIDPLAYER";
 147     case DPERR_INVALIDGROUP:             return "DPERR_INVALIDGROUP";
 148     case DPERR_NOCAPS:                   return "DPERR_NOCAPS";
 149     case DPERR_NOCONNECTION:             return "DPERR_NOCONNECTION";
 150     case DPERR_NOMEMORY:                 return "DPERR_NOMEMORY";
 151         /*           symbol with the same value: DPERR_OUTOFMEMORY */
 152     case DPERR_NOMESSAGES:               return "DPERR_NOMESSAGES";
 153     case DPERR_NONAMESERVERFOUND:        return "DPERR_NONAMESERVERFOUND";
 154     case DPERR_NOPLAYERS:                return "DPERR_NOPLAYERS";
 155     case DPERR_NOSESSIONS:               return "DPERR_NOSESSIONS";
 156     case DPERR_PENDING:                  return "DPERR_PENDING";
 157     case DPERR_SENDTOOBIG:               return "DPERR_SENDTOOBIG";
 158     case DPERR_TIMEOUT:                  return "DPERR_TIMEOUT";
 159     case DPERR_UNAVAILABLE:              return "DPERR_UNAVAILABLE";
 160     case DPERR_UNSUPPORTED:              return "DPERR_UNSUPPORTED";
 161     case DPERR_BUSY:                     return "DPERR_BUSY";
 162     case DPERR_USERCANCEL:               return "DPERR_USERCANCEL";
 163     case DPERR_NOINTERFACE:              return "DPERR_NOINTERFACE";
 164     case DPERR_CANNOTCREATESERVER:       return "DPERR_CANNOTCREATESERVER";
 165     case DPERR_PLAYERLOST:               return "DPERR_PLAYERLOST";
 166     case DPERR_SESSIONLOST:              return "DPERR_SESSIONLOST";
 167     case DPERR_UNINITIALIZED:            return "DPERR_UNINITIALIZED";
 168     case DPERR_NONEWPLAYERS:             return "DPERR_NONEWPLAYERS";
 169     case DPERR_INVALIDPASSWORD:          return "DPERR_INVALIDPASSWORD";
 170     case DPERR_CONNECTING:               return "DPERR_CONNECTING";
 171     case DPERR_CONNECTIONLOST:           return "DPERR_CONNECTIONLOST";
 172     case DPERR_UNKNOWNMESSAGE:           return "DPERR_UNKNOWNMESSAGE";
 173     case DPERR_CANCELFAILED:             return "DPERR_CANCELFAILED";
 174     case DPERR_INVALIDPRIORITY:          return "DPERR_INVALIDPRIORITY";
 175     case DPERR_NOTHANDLED:               return "DPERR_NOTHANDLED";
 176     case DPERR_CANCELLED:                return "DPERR_CANCELLED";
 177     case DPERR_ABORTED:                  return "DPERR_ABORTED";
 178     case DPERR_BUFFERTOOLARGE:           return "DPERR_BUFFERTOOLARGE";
 179     case DPERR_CANTCREATEPROCESS:        return "DPERR_CANTCREATEPROCESS";
 180     case DPERR_APPNOTSTARTED:            return "DPERR_APPNOTSTARTED";
 181     case DPERR_INVALIDINTERFACE:         return "DPERR_INVALIDINTERFACE";
 182     case DPERR_NOSERVICEPROVIDER:        return "DPERR_NOSERVICEPROVIDER";
 183     case DPERR_UNKNOWNAPPLICATION:       return "DPERR_UNKNOWNAPPLICATION";
 184     case DPERR_NOTLOBBIED:               return "DPERR_NOTLOBBIED";
 185     case DPERR_SERVICEPROVIDERLOADED:    return "DPERR_SERVICEPROVIDERLOADED";
 186     case DPERR_ALREADYREGISTERED:        return "DPERR_ALREADYREGISTERED";
 187     case DPERR_NOTREGISTERED:            return "DPERR_NOTREGISTERED";
 188     case DPERR_AUTHENTICATIONFAILED:     return "DPERR_AUTHENTICATIONFAILED";
 189     case DPERR_CANTLOADSSPI:             return "DPERR_CANTLOADSSPI";
 190     case DPERR_ENCRYPTIONFAILED:         return "DPERR_ENCRYPTIONFAILED";
 191     case DPERR_SIGNFAILED:               return "DPERR_SIGNFAILED";
 192     case DPERR_CANTLOADSECURITYPACKAGE:  return "DPERR_CANTLOADSECURITYPACKAGE";
 193     case DPERR_ENCRYPTIONNOTSUPPORTED:   return "DPERR_ENCRYPTIONNOTSUPPORTED";
 194     case DPERR_CANTLOADCAPI:             return "DPERR_CANTLOADCAPI";
 195     case DPERR_NOTLOGGEDIN:              return "DPERR_NOTLOGGEDIN";
 196     case DPERR_LOGONDENIED:              return "DPERR_LOGONDENIED";
 197     case CLASS_E_NOAGGREGATION:          return "CLASS_E_NOAGGREGATION";
 198
 199     default:
 200     {
 201         LPSTR buffer = get_temp_buffer();
 202         sprintf( buffer, "%d", HRESULT_CODE(hr) );
 203         return buffer;
 204     }
 205     }
 206 }
 207
 208 static LPCSTR dwFlags2str(DWORD dwFlags, DWORD flagType)
 209 {
 210
 211 #define FLAGS_DPCONNECTION     (1<<0)
 212 #define FLAGS_DPENUMPLAYERS    (1<<1)
 213 #define FLAGS_DPENUMGROUPS     (1<<2)
 214 #define FLAGS_DPPLAYER         (1<<3)
 215 #define FLAGS_DPGROUP          (1<<4)
 216 #define FLAGS_DPENUMSESSIONS   (1<<5)
 217 #define FLAGS_DPGETCAPS        (1<<6)
 218 #define FLAGS_DPGET            (1<<7)
 219 #define FLAGS_DPRECEIVE        (1<<8)
 220 #define FLAGS_DPSEND           (1<<9)
 221 #define FLAGS_DPSET            (1<<10)
 222 #define FLAGS_DPMESSAGEQUEUE   (1<<11)
 223 #define FLAGS_DPCONNECT        (1<<12)
 224 #define FLAGS_DPOPEN           (1<<13)
 225 #define FLAGS_DPSESSION        (1<<14)
 226 #define FLAGS_DPLCONNECTION    (1<<15)
 227 #define FLAGS_DPESC            (1<<16)
 228 #define FLAGS_DPCAPS           (1<<17)
 229
 230     LPSTR flags = get_temp_buffer();
 231
 232     /* EnumConnections */
 233
 234     if (flagType & FLAGS_DPCONNECTION)
 235     {
 236         if (dwFlags & DPCONNECTION_DIRECTPLAY)
 237             strcat(flags, "DPCONNECTION_DIRECTPLAY,");
 238         if (dwFlags & DPCONNECTION_DIRECTPLAYLOBBY)
 239             strcat(flags, "DPCONNECTION_DIRECTPLAYLOBBY,");
 240     }
 241
 242     /* EnumPlayers,
 243        EnumGroups */
 244
 245     if (flagType & FLAGS_DPENUMPLAYERS)
 246     {
 247         if (dwFlags == DPENUMPLAYERS_ALL)
 248             strcat(flags, "DPENUMPLAYERS_ALL,");
 249         if (dwFlags & DPENUMPLAYERS_LOCAL)
 250             strcat(flags, "DPENUMPLAYERS_LOCAL,");
 251         if (dwFlags & DPENUMPLAYERS_REMOTE)
 252             strcat(flags, "DPENUMPLAYERS_REMOTE,");
 253         if (dwFlags & DPENUMPLAYERS_GROUP)
 254             strcat(flags, "DPENUMPLAYERS_GROUP,");
 255         if (dwFlags & DPENUMPLAYERS_SESSION)
 256             strcat(flags, "DPENUMPLAYERS_SESSION,");
 257         if (dwFlags & DPENUMPLAYERS_SERVERPLAYER)
 258             strcat(flags, "DPENUMPLAYERS_SERVERPLAYER,");
 259         if (dwFlags & DPENUMPLAYERS_SPECTATOR)
 260             strcat(flags, "DPENUMPLAYERS_SPECTATOR,");
 261         if (dwFlags & DPENUMPLAYERS_OWNER)
 262             strcat(flags, "DPENUMPLAYERS_OWNER,");
 263     }
 264     if (flagType & FLAGS_DPENUMGROUPS)
 265     {
 266         if (dwFlags == DPENUMGROUPS_ALL)
 267             strcat(flags, "DPENUMGROUPS_ALL,");
 268         if (dwFlags & DPENUMPLAYERS_LOCAL)
 269             strcat(flags, "DPENUMGROUPS_LOCAL,");
 270         if (dwFlags & DPENUMPLAYERS_REMOTE)
 271             strcat(flags, "DPENUMGROUPS_REMOTE,");
 272         if (dwFlags & DPENUMPLAYERS_GROUP)
 273             strcat(flags, "DPENUMGROUPS_GROUP,");
 274         if (dwFlags & DPENUMPLAYERS_SESSION)
 275             strcat(flags, "DPENUMGROUPS_SESSION,");
 276         if (dwFlags & DPENUMGROUPS_SHORTCUT)
 277             strcat(flags, "DPENUMGROUPS_SHORTCUT,");
 278         if (dwFlags & DPENUMGROUPS_STAGINGAREA)
 279             strcat(flags, "DPENUMGROUPS_STAGINGAREA,");
 280         if (dwFlags & DPENUMGROUPS_HIDDEN)
 281             strcat(flags, "DPENUMGROUPS_HIDDEN,");
 282     }
 283
 284     /* CreatePlayer */
 285
 286     if (flagType & FLAGS_DPPLAYER)
 287     {
 288         if (dwFlags & DPPLAYER_SERVERPLAYER)
 289             strcat(flags, "DPPLAYER_SERVERPLAYER,");
 290         if (dwFlags & DPPLAYER_SPECTATOR)
 291             strcat(flags, "DPPLAYER_SPECTATOR,");
 292         if (dwFlags & DPPLAYER_LOCAL)
 293             strcat(flags, "DPPLAYER_LOCAL,");
 294         if (dwFlags & DPPLAYER_OWNER)
 295             strcat(flags, "DPPLAYER_OWNER,");
 296     }
 297
 298     /* CreateGroup */
 299
 300     if (flagType & FLAGS_DPGROUP)
 301     {
 302         if (dwFlags & DPGROUP_STAGINGAREA)
 303             strcat(flags, "DPGROUP_STAGINGAREA,");
 304         if (dwFlags & DPGROUP_LOCAL)
 305             strcat(flags, "DPGROUP_LOCAL,");
 306         if (dwFlags & DPGROUP_HIDDEN)
 307             strcat(flags, "DPGROUP_HIDDEN,");
 308     }
 309
 310     /* EnumSessions */
 311
 312     if (flagType & FLAGS_DPENUMSESSIONS)
 313     {
 314         if (dwFlags & DPENUMSESSIONS_AVAILABLE)
 315             strcat(flags, "DPENUMSESSIONS_AVAILABLE,");
 316         if (dwFlags &  DPENUMSESSIONS_ALL)
 317             strcat(flags, "DPENUMSESSIONS_ALL,");
 318         if (dwFlags & DPENUMSESSIONS_ASYNC)
 319             strcat(flags, "DPENUMSESSIONS_ASYNC,");
 320         if (dwFlags & DPENUMSESSIONS_STOPASYNC)
 321             strcat(flags, "DPENUMSESSIONS_STOPASYNC,");
 322         if (dwFlags & DPENUMSESSIONS_PASSWORDREQUIRED)
 323             strcat(flags, "DPENUMSESSIONS_PASSWORDREQUIRED,");
 324         if (dwFlags & DPENUMSESSIONS_RETURNSTATUS)
 325             strcat(flags, "DPENUMSESSIONS_RETURNSTATUS,");
 326     }
 327
 328     /* GetCaps,
 329        GetPlayerCaps */
 330
 331     if (flagType & FLAGS_DPGETCAPS)
 332     {
 333         if (dwFlags & DPGETCAPS_GUARANTEED)
 334             strcat(flags, "DPGETCAPS_GUARANTEED,");
 335     }
 336
 337     /* GetGroupData,
 338        GetPlayerData */
 339
 340     if (flagType & FLAGS_DPGET)
 341     {
 342         if (dwFlags == DPGET_REMOTE)
 343             strcat(flags, "DPGET_REMOTE,");
 344         if (dwFlags & DPGET_LOCAL)
 345             strcat(flags, "DPGET_LOCAL,");
 346     }
 347
 348     /* Receive */
 349
 350     if (flagType & FLAGS_DPRECEIVE)
 351     {
 352         if (dwFlags & DPRECEIVE_ALL)
 353             strcat(flags, "DPRECEIVE_ALL,");
 354         if (dwFlags & DPRECEIVE_TOPLAYER)
 355             strcat(flags, "DPRECEIVE_TOPLAYER,");
 356         if (dwFlags & DPRECEIVE_FROMPLAYER)
 357             strcat(flags, "DPRECEIVE_FROMPLAYER,");
 358         if (dwFlags & DPRECEIVE_PEEK)
 359             strcat(flags, "DPRECEIVE_PEEK,");
 360     }
 361
 362     /* Send */
 363
 364     if (flagType & FLAGS_DPSEND)
 365     {
 366         /*if (dwFlags == DPSEND_NONGUARANTEED)
 367           strcat(flags, "DPSEND_NONGUARANTEED,");*/
 368         if (dwFlags == DPSEND_MAX_PRIORITY) /* = DPSEND_MAX_PRI */
 369         {
 370             strcat(flags, "DPSEND_MAX_PRIORITY,");
 371         }
 372         else
 373         {
 374             if (dwFlags & DPSEND_GUARANTEED)
 375                 strcat(flags, "DPSEND_GUARANTEED,");
 376             if (dwFlags & DPSEND_HIGHPRIORITY)
 377                 strcat(flags, "DPSEND_HIGHPRIORITY,");
 378             if (dwFlags & DPSEND_OPENSTREAM)
 379                 strcat(flags, "DPSEND_OPENSTREAM,");
 380             if (dwFlags & DPSEND_CLOSESTREAM)
 381                 strcat(flags, "DPSEND_CLOSESTREAM,");
 382             if (dwFlags & DPSEND_SIGNED)
 383                 strcat(flags, "DPSEND_SIGNED,");
 384             if (dwFlags & DPSEND_ENCRYPTED)
 385                 strcat(flags, "DPSEND_ENCRYPTED,");
 386             if (dwFlags & DPSEND_LOBBYSYSTEMMESSAGE)
 387                 strcat(flags, "DPSEND_LOBBYSYSTEMMESSAGE,");
 388             if (dwFlags & DPSEND_ASYNC)
 389                 strcat(flags, "DPSEND_ASYNC,");
 390             if (dwFlags & DPSEND_NOSENDCOMPLETEMSG)
 391                 strcat(flags, "DPSEND_NOSENDCOMPLETEMSG,");
 392         }
 393     }
 394
 395     /* SetGroupData,
 396        SetGroupName,
 397        SetPlayerData,
 398        SetPlayerName,
 399        SetSessionDesc */
 400
 401     if (flagType & FLAGS_DPSET)
 402     {
 403         if (dwFlags == DPSET_REMOTE)
 404             strcat(flags, "DPSET_REMOTE,");
 405         if (dwFlags & DPSET_LOCAL)
 406             strcat(flags, "DPSET_LOCAL,");
 407         if (dwFlags & DPSET_GUARANTEED)
 408             strcat(flags, "DPSET_GUARANTEED,");
 409     }
 410
 411     /* GetMessageQueue */
 412
 413     if (flagType & FLAGS_DPMESSAGEQUEUE)
 414     {
 415         if (dwFlags & DPMESSAGEQUEUE_SEND)
 416             strcat(flags, "DPMESSAGEQUEUE_SEND,");
 417         if (dwFlags & DPMESSAGEQUEUE_RECEIVE)
 418             strcat(flags, "DPMESSAGEQUEUE_RECEIVE,");
 419     }
 420
 421     /* Connect */
 422
 423     if (flagType & FLAGS_DPCONNECT)
 424     {
 425         if (dwFlags & DPCONNECT_RETURNSTATUS)
 426             strcat(flags, "DPCONNECT_RETURNSTATUS,");
 427     }
 428
 429     /* Open */
 430
 431     if (flagType & FLAGS_DPOPEN)
 432     {
 433         if (dwFlags & DPOPEN_JOIN)
 434             strcat(flags, "DPOPEN_JOIN,");
 435         if (dwFlags & DPOPEN_CREATE)
 436             strcat(flags, "DPOPEN_CREATE,");
 437         if (dwFlags & DPOPEN_RETURNSTATUS)
 438             strcat(flags, "DPOPEN_RETURNSTATUS,");
 439     }
 440
 441     /* DPSESSIONDESC2 */
 442
 443     if (flagType & FLAGS_DPSESSION)
 444     {
 445         if (dwFlags & DPSESSION_NEWPLAYERSDISABLED)
 446             strcat(flags, "DPSESSION_NEWPLAYERSDISABLED,");
 447         if (dwFlags & DPSESSION_MIGRATEHOST)
 448             strcat(flags, "DPSESSION_MIGRATEHOST,");
 449         if (dwFlags & DPSESSION_NOMESSAGEID)
 450             strcat(flags, "DPSESSION_NOMESSAGEID,");
 451         if (dwFlags & DPSESSION_JOINDISABLED)
 452             strcat(flags, "DPSESSION_JOINDISABLED,");
 453         if (dwFlags & DPSESSION_KEEPALIVE)
 454             strcat(flags, "DPSESSION_KEEPALIVE,");
 455         if (dwFlags & DPSESSION_NODATAMESSAGES)
 456             strcat(flags, "DPSESSION_NODATAMESSAGES,");
 457         if (dwFlags & DPSESSION_SECURESERVER)
 458             strcat(flags, "DPSESSION_SECURESERVER,");
 459         if (dwFlags & DPSESSION_PRIVATE)
 460             strcat(flags, "DPSESSION_PRIVATE,");
 461         if (dwFlags & DPSESSION_PASSWORDREQUIRED)
 462             strcat(flags, "DPSESSION_PASSWORDREQUIRED,");
 463         if (dwFlags & DPSESSION_MULTICASTSERVER)
 464             strcat(flags, "DPSESSION_MULTICASTSERVER,");
 465         if (dwFlags & DPSESSION_CLIENTSERVER)
 466             strcat(flags, "DPSESSION_CLIENTSERVER,");
 467
 468         if (dwFlags & DPSESSION_DIRECTPLAYPROTOCOL)
 469             strcat(flags, "DPSESSION_DIRECTPLAYPROTOCOL,");
 470         if (dwFlags & DPSESSION_NOPRESERVEORDER)
 471             strcat(flags, "DPSESSION_NOPRESERVEORDER,");
 472         if (dwFlags & DPSESSION_OPTIMIZELATENCY)
 473             strcat(flags, "DPSESSION_OPTIMIZELATENCY,");
 474
 475     }
 476
 477     /* DPLCONNECTION */
 478
 479     if (flagType & FLAGS_DPLCONNECTION)
 480     {
 481         if (dwFlags & DPLCONNECTION_CREATESESSION)
 482             strcat(flags, "DPLCONNECTION_CREATESESSION,");
 483         if (dwFlags & DPLCONNECTION_JOINSESSION)
 484             strcat(flags, "DPLCONNECTION_JOINSESSION,");
 485     }
 486
 487     /* EnumSessionsCallback2 */
 488
 489     if (flagType & FLAGS_DPESC)
 490     {
 491         if (dwFlags & DPESC_TIMEDOUT)
 492             strcat(flags, "DPESC_TIMEDOUT,");
 493     }
 494
 495     /* GetCaps,
 496        GetPlayerCaps */
 497
 498     if (flagType & FLAGS_DPCAPS)
 499     {
 500         if (dwFlags & DPCAPS_ISHOST)
 501             strcat(flags, "DPCAPS_ISHOST,");
 502         if (dwFlags & DPCAPS_GROUPOPTIMIZED)
 503             strcat(flags, "DPCAPS_GROUPOPTIMIZED,");
 504         if (dwFlags & DPCAPS_KEEPALIVEOPTIMIZED)
 505             strcat(flags, "DPCAPS_KEEPALIVEOPTIMIZED,");
 506         if (dwFlags & DPCAPS_GUARANTEEDOPTIMIZED)
 507             strcat(flags, "DPCAPS_GUARANTEEDOPTIMIZED,");
 508         if (dwFlags & DPCAPS_GUARANTEEDSUPPORTED)
 509             strcat(flags, "DPCAPS_GUARANTEEDSUPPORTED,");
 510         if (dwFlags & DPCAPS_SIGNINGSUPPORTED)
 511             strcat(flags, "DPCAPS_SIGNINGSUPPORTED,");
 512         if (dwFlags & DPCAPS_ENCRYPTIONSUPPORTED)
 513             strcat(flags, "DPCAPS_ENCRYPTIONSUPPORTED,");
 514         if (dwFlags & DPCAPS_ASYNCCANCELSUPPORTED)
 515             strcat(flags, "DPCAPS_ASYNCCANCELSUPPORTED,");
 516         if (dwFlags & DPCAPS_ASYNCCANCELALLSUPPORTED)
 517             strcat(flags, "DPCAPS_ASYNCCANCELALLSUPPORTED,");
 518         if (dwFlags & DPCAPS_SENDTIMEOUTSUPPORTED)
 519             strcat(flags, "DPCAPS_SENDTIMEOUTSUPPORTED,");
 520         if (dwFlags & DPCAPS_SENDPRIORITYSUPPORTED)
 521             strcat(flags, "DPCAPS_SENDPRIORITYSUPPORTED,");
 522         if (dwFlags & DPCAPS_ASYNCSUPPORTED)
 523             strcat(flags, "DPCAPS_ASYNCSUPPORTED,");
 524
 525         if (dwFlags & DPPLAYERCAPS_LOCAL)
 526             strcat(flags, "DPPLAYERCAPS_LOCAL,");
 527     }
 528
 529     if ((strlen(flags) == 0) && (dwFlags != 0))
 530         strcpy(flags, "UNKNOWN");
 531     else
 532         flags[strlen(flags)-1] = '\0';
 533
 534     return flags;
 535 }
 536
 537 static void init_TCPIP_provider( LPDIRECTPLAY4 pDP,
 538                                  LPCSTR strIPAddressString,
 539                                  WORD port )
 540 {
 541
 542     DPCOMPOUNDADDRESSELEMENT addressElements[3];
 543     LPVOID pAddress = NULL;
 544     DWORD dwAddressSize = 0;
 545     LPDIRECTPLAYLOBBY3 pDPL;
 546     HRESULT hr;
 547
 548     CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL,
 549                       &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL );
 550
 551     /* Service provider */
 552     addressElements[0].guidDataType = DPAID_ServiceProvider;
 553     addressElements[0].dwDataSize   = sizeof(GUID);
 554     addressElements[0].lpData       = (LPVOID) &DPSPGUID_TCPIP;
 555
 556     /* IP address string */
 557     addressElements[1].guidDataType = DPAID_INet;
 558     addressElements[1].dwDataSize   = lstrlen(strIPAddressString) + 1;
 559     addressElements[1].lpData       = (LPVOID) strIPAddressString;
 560
 561     /* Optional Port number */
 562     if( port > 0 )
 563     {
 564         addressElements[2].guidDataType = DPAID_INetPort;
 565         addressElements[2].dwDataSize   = sizeof(WORD);
 566         addressElements[2].lpData       = &port;
 567     }
 568
 569
 570     hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2,
 571                                                  NULL, &dwAddressSize );
 572     checkHR( DPERR_BUFFERTOOSMALL, hr );
 573
 574     if( hr == DPERR_BUFFERTOOSMALL )
 575     {
 576         pAddress = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwAddressSize );
 577         hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2,
 578                                                      pAddress, &dwAddressSize );
 579         checkHR( DP_OK, hr );
 580     }
 581
 582     hr = IDirectPlayX_InitializeConnection( pDP, pAddress, 0 );
 583     todo_wine checkHR( DP_OK, hr );
 584
 585 }
 586
 587
 588 /* DirectPlayCreate */
 589
 590 static void test_DirectPlayCreate(void)
 591 {
 592
 593     LPDIRECTPLAY pDP;
 594     HRESULT hr;
 595
 596     /* TODO: Check how it behaves with pUnk!=NULL */
 597
 598     /* pDP==NULL */
 599     hr = DirectPlayCreate( NULL, NULL, NULL );
 600     checkHR( DPERR_INVALIDPARAMS, hr );
 601     hr = DirectPlayCreate( (LPGUID) &GUID_NULL, NULL, NULL );
 602     checkHR( DPERR_INVALIDPARAMS, hr );
 603     hr = DirectPlayCreate( (LPGUID) &DPSPGUID_TCPIP, NULL, NULL );
 604     checkHR( DPERR_INVALIDPARAMS, hr );
 605
 606     /* pUnk==NULL, pDP!=NULL */
 607     hr = DirectPlayCreate( NULL, &pDP, NULL );
 608     checkHR( DPERR_INVALIDPARAMS, hr );
 609     hr = DirectPlayCreate( (LPGUID) &GUID_NULL, &pDP, NULL );
 610     checkHR( DP_OK, hr );
 611     if ( hr == DP_OK )
 612         IDirectPlayX_Release( pDP );
 613     hr = DirectPlayCreate( (LPGUID) &DPSPGUID_TCPIP, &pDP, NULL );
 614     todo_wine checkHR( DP_OK, hr );
 615     if ( hr == DP_OK )
 616         IDirectPlayX_Release( pDP );
 617
 618 }
 619
 620 /* EnumConnections */
 621
 622 static BOOL FAR PASCAL EnumAddress_cb2( REFGUID guidDataType,
 623                                         DWORD dwDataSize,
 624                                         LPCVOID lpData,
 625                                         LPVOID lpContext )
 626 {
 627     lpCallbackData callbackData = (lpCallbackData) lpContext;
 628
 629     static REFGUID types[] = { &DPAID_TotalSize,
 630                                &DPAID_ServiceProvider,
 631                                &GUID_NULL };
 632     static DWORD sizes[] = { 4, 16, 0  };
 633     static REFGUID sps[] = { &DPSPGUID_SERIAL, &DPSPGUID_MODEM,
 634                              &DPSPGUID_IPX, &DPSPGUID_TCPIP };
 635
 636
 637     checkGuid( types[ callbackData->dwCounter2 ], guidDataType );
 638     check( sizes[ callbackData->dwCounter2 ], dwDataSize );
 639
 640     if ( IsEqualGUID( types[0], guidDataType ) )
 641     {
 642         todo_wine check( 80, *((LPDWORD) lpData) );
 643     }
 644     else if ( IsEqualGUID( types[1], guidDataType ) )
 645     {
 646         todo_wine checkGuid( sps[ callbackData->dwCounter1 ], (LPGUID) lpData );
 647     }
 648
 649     callbackData->dwCounter2++;
 650
 651     return TRUE;
 652 }
 653
 654 static BOOL CALLBACK EnumConnections_cb( LPCGUID lpguidSP,
 655                                          LPVOID lpConnection,
 656                                          DWORD dwConnectionSize,
 657                                          LPCDPNAME lpName,
 658                                          DWORD dwFlags,
 659                                          LPVOID lpContext )
 660 {
 661
 662     lpCallbackData callbackData = (lpCallbackData) lpContext;
 663     LPDIRECTPLAYLOBBY pDPL;
 664
 665
 666     if (!callbackData->dwFlags)
 667     {
 668         callbackData->dwFlags = DPCONNECTION_DIRECTPLAY;
 669     }
 670
 671     checkFlags( callbackData->dwFlags, dwFlags, FLAGS_DPCONNECTION );
 672
 673     /* Get info from lpConnection */
 674     CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL,
 675                       &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL );
 676
 677     callbackData->dwCounter2 = 0;
 678     IDirectPlayLobby_EnumAddress( pDPL, EnumAddress_cb2,
 679                                   (LPCVOID) lpConnection,
 680                                   dwConnectionSize,
 681                                   (LPVOID) callbackData );
 682     todo_wine check( 3, callbackData->dwCounter2 );
 683
 684     callbackData->dwCounter1++;
 685
 686     return TRUE;
 687 }
 688
 689 static void test_EnumConnections(void)
 690 {
 691
 692     LPDIRECTPLAY4 pDP;
 693     CallbackData callbackData;
 694     HRESULT hr;
 695
 696
 697     CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
 698                       &IID_IDirectPlay4A, (LPVOID*) &pDP );
 699
 700
 701     callbackData.dwCounter1 = 0;
 702     callbackData.dwFlags = 0;
 703     hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
 704                                        (LPVOID) &callbackData,
 705                                        callbackData.dwFlags );
 706     checkHR( DP_OK, hr );
 707     check( 4, callbackData.dwCounter1 );
 708
 709     callbackData.dwCounter1 = 0;
 710     callbackData.dwFlags = 0;
 711     hr = IDirectPlayX_EnumConnections( pDP, NULL, EnumConnections_cb,
 712                                        (LPVOID) &callbackData,
 713                                        callbackData.dwFlags );
 714     checkHR( DP_OK, hr );
 715     check( 4, callbackData.dwCounter1 );
 716
 717     callbackData.dwCounter1 = 0;
 718     callbackData.dwFlags = 0;
 719     hr = IDirectPlayX_EnumConnections( pDP, &appGuid, NULL,
 720                                        (LPVOID) &callbackData,
 721                                        callbackData.dwFlags );
 722     checkHR( DPERR_INVALIDPARAMS, hr );
 723     check( 0, callbackData.dwCounter1 );
 724
 725
 726     /* Flag tests */
 727     callbackData.dwCounter1 = 0;
 728     callbackData.dwFlags = DPCONNECTION_DIRECTPLAY;
 729     hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
 730                                        (LPVOID) &callbackData,
 731                                        callbackData.dwFlags );
 732     checkHR( DP_OK, hr );
 733     check( 4, callbackData.dwCounter1 );
 734
 735     callbackData.dwCounter1 = 0;
 736     callbackData.dwFlags = DPCONNECTION_DIRECTPLAYLOBBY;
 737     hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
 738                                        (LPVOID) &callbackData,
 739                                        callbackData.dwFlags );
 740     checkHR( DP_OK, hr );
 741     check( 0, callbackData.dwCounter1 );
 742
 743     callbackData.dwCounter1 = 0;
 744     callbackData.dwFlags = ( DPCONNECTION_DIRECTPLAY |
 745                              DPCONNECTION_DIRECTPLAYLOBBY );
 746     hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
 747                                        (LPVOID) &callbackData,
 748                                        callbackData.dwFlags );
 749     checkHR( DP_OK, hr );
 750     check( 4, callbackData.dwCounter1 );
 751
 752     callbackData.dwCounter1 = 0;
 753     callbackData.dwFlags = ~( DPCONNECTION_DIRECTPLAY |
 754                               DPCONNECTION_DIRECTPLAYLOBBY );
 755     hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
 756                                        (LPVOID) &callbackData,
 757                                        callbackData.dwFlags );
 758     checkHR( DPERR_INVALIDFLAGS, hr );
 759     check( 0, callbackData.dwCounter1 );
 760
 761
 762     IDirectPlayX_Release( pDP );
 763 }
 764
 765 /* InitializeConnection */
 766
 767 static BOOL CALLBACK EnumConnections_cb2( LPCGUID lpguidSP,
 768                                           LPVOID lpConnection,
 769                                           DWORD dwConnectionSize,
 770                                           LPCDPNAME lpName,
 771                                           DWORD dwFlags,
 772                                           LPVOID lpContext )
 773 {
 774     LPDIRECTPLAY4 pDP = (LPDIRECTPLAY4) lpContext;
 775     HRESULT hr;
 776
 777     /* Incorrect parameters */
 778     hr = IDirectPlayX_InitializeConnection( pDP, NULL, 1 );
 779     checkHR( DPERR_INVALIDPARAMS, hr );
 780     hr = IDirectPlayX_InitializeConnection( pDP, lpConnection, 1 );
 781     checkHR( DPERR_INVALIDFLAGS, hr );
 782
 783     /* Normal operation.
 784        We're only interested in ensuring that the TCP/IP provider works */
 785
 786     if( IsEqualGUID(lpguidSP, &DPSPGUID_TCPIP) )
 787     {
 788         hr = IDirectPlayX_InitializeConnection( pDP, lpConnection, 0 );
 789         todo_wine checkHR( DP_OK, hr );
 790         hr = IDirectPlayX_InitializeConnection( pDP, lpConnection, 0 );
 791         todo_wine checkHR( DPERR_ALREADYINITIALIZED, hr );
 792     }
 793
 794     return TRUE;
 795 }
 796
 797 static void test_InitializeConnection(void)
 798 {
 799
 800     LPDIRECTPLAY4 pDP;
 801
 802     CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
 803                       &IID_IDirectPlay4A, (LPVOID*) &pDP );
 804
 805     IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb2,
 806                                   (LPVOID) pDP, 0 );
 807
 808     IDirectPlayX_Release( pDP );
 809 }
 810
 811 /* GetCaps */
 812
 813 static void test_GetCaps(void)
 814 {
 815
 816     LPDIRECTPLAY4 pDP;
 817     DPCAPS dpcaps;
 818     DWORD dwFlags;
 819     HRESULT hr;
 820
 821
 822     CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
 823                       &IID_IDirectPlay4A, (LPVOID*) &pDP );
 824     ZeroMemory( &dpcaps, sizeof(DPCAPS) );
 825
 826     /* Service provider not ininitialized */
 827     hr = IDirectPlayX_GetCaps( pDP, &dpcaps, 0 );
 828     checkHR( DPERR_UNINITIALIZED, hr );
 829
 830     init_TCPIP_provider( pDP, "127.0.0.1", 0 );
 831
 832     /* dpcaps not ininitialized */
 833     hr = IDirectPlayX_GetCaps( pDP, &dpcaps, 0 );
 834     todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 835
 836     dpcaps.dwSize = sizeof(DPCAPS);
 837
 838     for (dwFlags=0;
 839          dwFlags<=DPGETCAPS_GUARANTEED;
 840          dwFlags+=DPGETCAPS_GUARANTEED)
 841     {
 842
 843         hr = IDirectPlayX_GetCaps( pDP, &dpcaps, dwFlags );
 844         todo_wine checkHR( DP_OK, hr );
 845
 846
 847         if ( hr == DP_OK )
 848         {
 849             check( sizeof(DPCAPS), dpcaps.dwSize );
 850             check( DPCAPS_ASYNCSUPPORTED |
 851                    DPCAPS_GUARANTEEDOPTIMIZED |
 852                    DPCAPS_GUARANTEEDSUPPORTED,
 853                    dpcaps.dwFlags );
 854             check( 0,     dpcaps.dwMaxQueueSize );
 855             check( 0,     dpcaps.dwHundredBaud );
 856             check( 500,   dpcaps.dwLatency );
 857             check( 65536, dpcaps.dwMaxLocalPlayers );
 858             check( 20,    dpcaps.dwHeaderLength );
 859             check( 5000,  dpcaps.dwTimeout );
 860
 861             switch (dwFlags)
 862             {
 863             case 0:
 864                 check( 65479,   dpcaps.dwMaxBufferSize );
 865                 check( 65536,   dpcaps.dwMaxPlayers );
 866                 break;
 867             case DPGETCAPS_GUARANTEED:
 868                 check( 1048547, dpcaps.dwMaxBufferSize );
 869                 check( 64,      dpcaps.dwMaxPlayers );
 870                 break;
 871             default: break;
 872             }
 873         }
 874     }
 875
 876     IDirectPlayX_Release( pDP );
 877 }
 878
 879 /* Open */
 880
 881 static BOOL FAR PASCAL EnumSessions_cb2( LPCDPSESSIONDESC2 lpThisSD,
 882                                          LPDWORD lpdwTimeOut,
 883                                          DWORD dwFlags,
 884                                          LPVOID lpContext )
 885 {
 886     LPDIRECTPLAY4 pDP = (LPDIRECTPLAY4) lpContext;
 887     DPSESSIONDESC2 dpsd;
 888     HRESULT hr;
 889
 890     if (dwFlags & DPESC_TIMEDOUT)
 891         return FALSE;
 892
 893
 894     ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
 895     dpsd.dwSize = sizeof(DPSESSIONDESC2);
 896     dpsd.guidApplication = appGuid;
 897     dpsd.guidInstance = lpThisSD->guidInstance;
 898
 899     if ( lpThisSD->dwFlags & DPSESSION_PASSWORDREQUIRED )
 900     {
 901         /* Incorrect password */
 902         dpsd.lpszPasswordA = (LPSTR) "sonic boom";
 903         hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
 904         checkHR( DPERR_INVALIDPASSWORD, hr );
 905
 906         /* Correct password */
 907         dpsd.lpszPasswordA = (LPSTR) "hadouken";
 908         hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
 909         checkHR( DP_OK, hr );
 910     }
 911     else
 912     {
 913         hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
 914         checkHR( DP_OK, hr );
 915     }
 916
 917     hr = IDirectPlayX_Close( pDP );
 918     checkHR( DP_OK, hr );
 919
 920     return TRUE;
 921 }
 922
 923 static void test_Open(void)
 924 {
 925
 926     LPDIRECTPLAY4 pDP, pDP_server;
 927     DPSESSIONDESC2 dpsd, dpsd_server;
 928     HRESULT hr;
 929
 930
 931     CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
 932                       &IID_IDirectPlay4A, (LPVOID*) &pDP_server );
 933     CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
 934                       &IID_IDirectPlay4A, (LPVOID*) &pDP );
 935     ZeroMemory( &dpsd_server, sizeof(DPSESSIONDESC2) );
 936     ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
 937
 938     /* Service provider not initialized */
 939     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
 940     todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 941
 942     init_TCPIP_provider( pDP_server, "127.0.0.1", 0 );
 943     init_TCPIP_provider( pDP, "127.0.0.1", 0 );
 944
 945     /* Uninitialized  dpsd */
 946     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
 947     todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 948
 949
 950     dpsd_server.dwSize = sizeof(DPSESSIONDESC2);
 951     dpsd_server.guidApplication = appGuid;
 952     dpsd_server.dwMaxPlayers = 10;
 953
 954
 955     /* Regular operation */
 956     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
 957     todo_wine checkHR( DP_OK, hr );
 958
 959     /* Opening twice */
 960     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
 961     todo_wine checkHR( DPERR_ALREADYINITIALIZED, hr );
 962
 963     /* Session flags */
 964     IDirectPlayX_Close( pDP_server );
 965
 966     dpsd_server.dwFlags = DPSESSION_CLIENTSERVER | DPSESSION_MIGRATEHOST;
 967     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
 968     todo_wine checkHR( DPERR_INVALIDFLAGS, hr );
 969
 970     dpsd_server.dwFlags = DPSESSION_MULTICASTSERVER | DPSESSION_MIGRATEHOST;
 971     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
 972     todo_wine checkHR( DPERR_INVALIDFLAGS, hr );
 973
 974     dpsd_server.dwFlags = DPSESSION_SECURESERVER | DPSESSION_MIGRATEHOST;
 975     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
 976     todo_wine checkHR( DPERR_INVALIDFLAGS, hr );
 977
 978
 979     /* Joining sessions */
 980     /* - Checking how strict dplay is with sizes */
 981     dpsd.dwSize = 0;
 982     hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
 983     todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 984
 985     dpsd.dwSize = sizeof(DPSESSIONDESC2)-1;
 986     hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
 987     todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 988
 989     dpsd.dwSize = sizeof(DPSESSIONDESC2)+1;
 990     hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
 991     todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 992
 993     dpsd.dwSize = sizeof(DPSESSIONDESC2);
 994     hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
 995     todo_wine checkHR( DPERR_NOSESSIONS, hr ); /* Only checks for size, not guids */
 996
 997
 998     dpsd.guidApplication = appGuid;
 999     dpsd.guidInstance = appGuid;
1000
1001
1002     hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
1003     todo_wine checkHR( DPERR_NOSESSIONS, hr );
1004     hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN | DPOPEN_CREATE );
1005     todo_wine checkHR( DPERR_NOSESSIONS, hr ); /* Second flag is ignored */
1006
1007     dpsd_server.dwFlags = 0;
1008
1009
1010     /* Join to normal session */
1011     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
1012     todo_wine checkHR( DP_OK, hr );
1013
1014     IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb2, pDP, 0 );
1015
1016
1017     /* Already initialized session */
1018     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
1019     todo_wine checkHR( DPERR_ALREADYINITIALIZED, hr );
1020
1021
1022     /* Checking which is the error checking order */
1023     dpsd_server.dwSize = 0;
1024
1025     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
1026     todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
1027
1028     dpsd_server.dwSize = sizeof(DPSESSIONDESC2);
1029
1030
1031     /* Join to protected session */
1032     IDirectPlayX_Close( pDP_server );
1033     dpsd_server.lpszPasswordA = (LPSTR) "hadouken";
1034     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
1035     todo_wine checkHR( DP_OK, hr );
1036
1037     IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb2,
1038                                pDP, DPENUMSESSIONS_PASSWORDREQUIRED );
1039
1040
1041     IDirectPlayX_Release( pDP );
1042     IDirectPlayX_Release( pDP_server );
1043
1044 }
1045
1046 /* EnumSessions */
1047
1048 static BOOL FAR PASCAL EnumSessions_cb( LPCDPSESSIONDESC2 lpThisSD,
1049                                         LPDWORD lpdwTimeOut,
1050                                         DWORD dwFlags,
1051                                         LPVOID lpContext )
1052 {
1053     lpCallbackData callbackData = (lpCallbackData) lpContext;
1054     callbackData->dwCounter1++;
1055
1056     if ( dwFlags & DPESC_TIMEDOUT )
1057     {
1058         check( TRUE, lpThisSD == NULL );
1059         return FALSE;
1060     }
1061     check( FALSE, lpThisSD == NULL );
1062
1063
1064     if ( lpThisSD->lpszPasswordA != NULL )
1065     {
1066         check( TRUE, (lpThisSD->dwFlags & DPSESSION_PASSWORDREQUIRED) != 0 );
1067     }
1068
1069     if ( lpThisSD->dwFlags & DPSESSION_NEWPLAYERSDISABLED )
1070     {
1071         check( 0, lpThisSD->dwCurrentPlayers );
1072     }
1073
1074     check( sizeof(*lpThisSD), lpThisSD->dwSize );
1075     checkLP( NULL, lpThisSD->lpszPasswordA );
1076
1077     return TRUE;
1078 }
1079
1080 static LPDIRECTPLAY4 create_session(DPSESSIONDESC2 *lpdpsd)
1081 {
1082
1083     LPDIRECTPLAY4 pDP;
1084     DPNAME name;
1085     DPID dpid;
1086     HRESULT hr;
1087
1088     CoInitialize(NULL);
1089
1090     CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
1091                       &IID_IDirectPlay4A, (LPVOID*) &pDP );
1092
1093     init_TCPIP_provider( pDP, "127.0.0.1", 0 );
1094
1095     hr = IDirectPlayX_Open( pDP, lpdpsd, DPOPEN_CREATE );
1096     todo_wine checkHR( DP_OK, hr );
1097
1098     if ( ! (lpdpsd->dwFlags & DPSESSION_NEWPLAYERSDISABLED) )
1099     {
1100         ZeroMemory( &name, sizeof(DPNAME) );
1101         name.dwSize = sizeof(DPNAME);
1102         name.lpszShortNameA = (LPSTR) "bofh";
1103
1104         hr = IDirectPlayX_CreatePlayer( pDP, &dpid, &name, NULL, NULL,
1105                                         0, DPPLAYER_SERVERPLAYER );
1106         todo_wine checkHR( DP_OK, hr );
1107     }
1108
1109     return pDP;
1110
1111 }
1112
1113 static void test_EnumSessions(void)
1114 {
1115
1116 #define N_SESSIONS 6
1117
1118     LPDIRECTPLAY4 pDP, pDPserver[N_SESSIONS];
1119     DPSESSIONDESC2 dpsd, dpsd_server[N_SESSIONS];
1120     CallbackData callbackData;
1121     HRESULT hr;
1122     UINT i;
1123
1124
1125     CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
1126                       &IID_IDirectPlay4A, (LPVOID*) &pDP );
1127     ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
1128     callbackData.dwCounter1 = -1; /* So that after a call to EnumSessions
1129                                      we get the exact number of sessions */
1130     callbackData.dwFlags = 0;
1131
1132
1133     /* Service provider not initialized */
1134     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1135                                     (LPVOID) &callbackData, 0 );
1136     checkHR( DPERR_UNINITIALIZED, hr );
1137
1138
1139     init_TCPIP_provider( pDP, "127.0.0.1", 0 );
1140
1141
1142     /* Session with no size */
1143     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1144                                     (LPVOID) &callbackData, 0 );
1145     todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
1146
1147     if ( hr == DPERR_UNINITIALIZED )
1148     {
1149         skip( "EnumSessions not implemented\n" );
1150         return;
1151     }
1152
1153     dpsd.dwSize = sizeof(DPSESSIONDESC2);
1154
1155
1156     /* No sessions */
1157     callbackData.dwCounter1 = -1;
1158     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1159                                     (LPVOID) &callbackData, 0 );
1160     checkHR( DP_OK, hr );
1161     check( 0, callbackData.dwCounter1 );
1162
1163
1164     dpsd.guidApplication = appGuid;
1165
1166     /* Set up sessions */
1167     for (i=0; i<N_SESSIONS; i++)
1168     {
1169         memcpy( &dpsd_server[i], &dpsd, sizeof(DPSESSIONDESC2) );
1170     }
1171
1172     dpsd_server[0].lpszSessionNameA = (LPSTR) "normal";
1173     dpsd_server[0].dwFlags = ( DPSESSION_CLIENTSERVER |
1174                                DPSESSION_DIRECTPLAYPROTOCOL );
1175     dpsd_server[0].dwMaxPlayers = 10;
1176
1177     dpsd_server[1].lpszSessionNameA = (LPSTR) "full";
1178     dpsd_server[1].dwFlags = ( DPSESSION_CLIENTSERVER |
1179                                DPSESSION_DIRECTPLAYPROTOCOL );
1180     dpsd_server[1].dwMaxPlayers = 1;
1181
1182     dpsd_server[2].lpszSessionNameA = (LPSTR) "no new";
1183     dpsd_server[2].dwFlags = ( DPSESSION_CLIENTSERVER |
1184                                DPSESSION_DIRECTPLAYPROTOCOL |
1185                                DPSESSION_NEWPLAYERSDISABLED );
1186     dpsd_server[2].dwMaxPlayers = 10;
1187
1188     dpsd_server[3].lpszSessionNameA = (LPSTR) "no join";
1189     dpsd_server[3].dwFlags = ( DPSESSION_CLIENTSERVER |
1190                                DPSESSION_DIRECTPLAYPROTOCOL |
1191                                DPSESSION_JOINDISABLED );
1192     dpsd_server[3].dwMaxPlayers = 10;
1193
1194     dpsd_server[4].lpszSessionNameA = (LPSTR) "private";
1195     dpsd_server[4].dwFlags = ( DPSESSION_CLIENTSERVER |
1196                                DPSESSION_DIRECTPLAYPROTOCOL |
1197                                DPSESSION_PRIVATE );
1198     dpsd_server[4].dwMaxPlayers = 10;
1199     dpsd_server[4].lpszPasswordA = (LPSTR) "password";
1200
1201     dpsd_server[5].lpszSessionNameA = (LPSTR) "protected";
1202     dpsd_server[5].dwFlags = ( DPSESSION_CLIENTSERVER |
1203                                DPSESSION_DIRECTPLAYPROTOCOL |
1204                                DPSESSION_PASSWORDREQUIRED );
1205     dpsd_server[5].dwMaxPlayers = 10;
1206     dpsd_server[5].lpszPasswordA = (LPSTR) "password";
1207
1208
1209     for (i=0; i<N_SESSIONS; i++)
1210     {
1211         pDPserver[i] = create_session( &dpsd_server[i] );
1212     }
1213
1214
1215     /* Invalid params */
1216     callbackData.dwCounter1 = -1;
1217     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1218                                     (LPVOID) &callbackData, -1 );
1219     checkHR( DPERR_INVALIDPARAMS, hr );
1220
1221     hr = IDirectPlayX_EnumSessions( pDP, NULL, 0, EnumSessions_cb,
1222                                     (LPVOID) &callbackData, 0 );
1223     checkHR( DPERR_INVALIDPARAMS, hr );
1224
1225     check( -1, callbackData.dwCounter1 );
1226
1227
1228     /* Flag tests */
1229     callbackData.dwFlags = DPENUMSESSIONS_ALL; /* Doesn't list private,
1230                                                   protected */
1231     callbackData.dwCounter1 = -1;
1232     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1233                                     (LPVOID) &callbackData,
1234                                     callbackData.dwFlags );
1235     check( N_SESSIONS-2, callbackData.dwCounter1 );
1236
1237     /* Doesn't list private */
1238     callbackData.dwFlags = ( DPENUMSESSIONS_ALL |
1239                              DPENUMSESSIONS_PASSWORDREQUIRED );
1240     callbackData.dwCounter1 = -1;
1241     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1242                                     (LPVOID) &callbackData,
1243                                     callbackData.dwFlags );
1244     check( N_SESSIONS-1, callbackData.dwCounter1 );
1245
1246     /* Doesn't list full, no new, no join, private, protected */
1247     callbackData.dwFlags = DPENUMSESSIONS_AVAILABLE;
1248     callbackData.dwCounter1 = -1;
1249     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1250                                     (LPVOID) &callbackData,
1251                                     callbackData.dwFlags );
1252     check( N_SESSIONS-5, callbackData.dwCounter1 );
1253
1254     /* Like with DPENUMSESSIONS_AVAILABLE */
1255     callbackData.dwFlags = 0;
1256     callbackData.dwCounter1 = -1;
1257     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1258                                     (LPVOID) &callbackData,
1259                                     callbackData.dwFlags );
1260     check( N_SESSIONS-5, callbackData.dwCounter1 );
1261
1262     /* Doesn't list full, no new, no join, private */
1263     callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED;
1264     callbackData.dwCounter1 = -1;
1265     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1266                                     (LPVOID) &callbackData,
1267                                     callbackData.dwFlags );
1268     check( N_SESSIONS-4, callbackData.dwCounter1 );
1269
1270
1271     /* Async enumeration */
1272     callbackData.dwFlags = DPENUMSESSIONS_ASYNC;
1273     callbackData.dwCounter1 = -1;
1274     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1275                                     (LPVOID) &callbackData,
1276                                     callbackData.dwFlags );
1277     check( N_SESSIONS-4, callbackData.dwCounter1 ); /* Read cache of last
1278                                                        sync enumeration */
1279
1280     callbackData.dwFlags = DPENUMSESSIONS_STOPASYNC;
1281     callbackData.dwCounter1 = -1;
1282     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1283                                     (LPVOID) &callbackData,
1284                                     callbackData.dwFlags );
1285     check( 0, callbackData.dwCounter1 ); /* Stop enumeration */
1286
1287     callbackData.dwFlags = DPENUMSESSIONS_ASYNC;
1288     callbackData.dwCounter1 = -1;
1289     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1290                                     (LPVOID) &callbackData,
1291                                     callbackData.dwFlags );
1292     check( 0, callbackData.dwCounter1 ); /* Start enumeration */
1293
1294     Sleep(500); /* Give time to fill the cache */
1295
1296     callbackData.dwFlags = DPENUMSESSIONS_ASYNC;
1297     callbackData.dwCounter1 = -1;
1298     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1299                                     (LPVOID) &callbackData,
1300                                     callbackData.dwFlags );
1301     check( N_SESSIONS-5, callbackData.dwCounter1 ); /* Retrieve results */
1302
1303     callbackData.dwFlags = DPENUMSESSIONS_STOPASYNC;
1304     callbackData.dwCounter1 = -1;
1305     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1306                                     (LPVOID) &callbackData,
1307                                     callbackData.dwFlags );
1308     check( 0, callbackData.dwCounter1 ); /* Stop enumeration */
1309
1310
1311     /* Specific tests for passworded sessions */
1312
1313     for (i=0; i<N_SESSIONS; i++)
1314     {
1315         IDirectPlayX_Release( pDPserver[i] );
1316     }
1317
1318     /* - Only session password set */
1319     for (i=4;i<=5;i++)
1320     {
1321         dpsd_server[i].lpszPasswordA = (LPSTR) "password";
1322         dpsd_server[i].dwFlags = 0;
1323         pDPserver[i] = create_session( &dpsd_server[i] );
1324     }
1325
1326     callbackData.dwFlags = 0;
1327     callbackData.dwCounter1 = -1;
1328     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1329                                     (LPVOID) &callbackData,
1330                                     callbackData.dwFlags );
1331     check( 0, callbackData.dwCounter1 );
1332
1333     callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED;
1334     callbackData.dwCounter1 = -1;
1335     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1336                                     (LPVOID) &callbackData,
1337                                     callbackData.dwFlags );
1338     check( 2, callbackData.dwCounter1 ); /* Both sessions automatically
1339                                             set DPSESSION_PASSWORDREQUIRED */
1340
1341     /* - Only session flag set */
1342     for (i=4; i<=5; i++)
1343     {
1344         IDirectPlayX_Release( pDPserver[i] );
1345         dpsd_server[i].lpszPasswordA = NULL;
1346     }
1347     dpsd_server[4].dwFlags = DPSESSION_PRIVATE;
1348     dpsd_server[5].dwFlags = DPSESSION_PASSWORDREQUIRED;
1349     for (i=4; i<=5; i++)
1350     {
1351         pDPserver[i] = create_session( &dpsd_server[i] );
1352     }
1353
1354     callbackData.dwFlags = 0;
1355     callbackData.dwCounter1 = -1;
1356     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1357                                     (LPVOID) &callbackData,
1358                                     callbackData.dwFlags );
1359     check( 2, callbackData.dwCounter1 ); /* Without password,
1360                                             the flag is ignored */
1361
1362     /* - Both session flag and password set */
1363     for (i=4; i<=5; i++)
1364     {
1365         IDirectPlayX_Release( pDPserver[i] );
1366         dpsd_server[i].lpszPasswordA = (LPSTR) "password";
1367     }
1368     dpsd_server[4].dwFlags = DPSESSION_PRIVATE;
1369     dpsd_server[5].dwFlags = DPSESSION_PASSWORDREQUIRED;
1370     for (i=4; i<=5; i++)
1371     {
1372         pDPserver[i] = create_session( &dpsd_server[i] );
1373     }
1374
1375     /* - Listing without password */
1376     callbackData.dwCounter1 = -1;
1377     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1378                                     (LPVOID) &callbackData,
1379                                     callbackData.dwFlags );
1380     check( 0, callbackData.dwCounter1 );
1381
1382     callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED;
1383     callbackData.dwCounter1 = -1;
1384     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1385                                     (LPVOID) &callbackData,
1386                                     callbackData.dwFlags );
1387     check( 1, callbackData.dwCounter1 );
1388
1389     /* - Listing with incorrect password */
1390     dpsd.lpszPasswordA = (LPSTR) "bad_password";
1391     callbackData.dwFlags = 0;
1392     callbackData.dwCounter1 = -1;
1393     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1394                                     (LPVOID) &callbackData,
1395                                     callbackData.dwFlags );
1396     check( 0, callbackData.dwCounter1 );
1397
1398     callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED;
1399     callbackData.dwCounter1 = -1;
1400     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1401                                     (LPVOID) &callbackData,
1402                                     callbackData.dwFlags );
1403     check( 1, callbackData.dwCounter1 );
1404
1405     /* - Listing with  correct password */
1406     dpsd.lpszPasswordA = (LPSTR) "password";
1407     callbackData.dwCounter1 = -1;
1408     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1409                                     (LPVOID) &callbackData,
1410                                     callbackData.dwFlags );
1411     check( 2, callbackData.dwCounter1 );
1412
1413
1414     dpsd.lpszPasswordA = NULL;
1415     callbackData.dwFlags = DPENUMSESSIONS_ASYNC;
1416     callbackData.dwCounter1 = -1;
1417     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1418                                     (LPVOID) &callbackData,
1419                                     callbackData.dwFlags );
1420     check( 2, callbackData.dwCounter1 ); /* Read cache of last sync enumeration,
1421                                             even private sessions */
1422
1423
1424     /* GUID tests */
1425
1426     /* - Creating two servers with different application GUIDs */
1427     for (i=4; i<=5; i++)
1428     {
1429         IDirectPlayX_Release( pDPserver[i] );
1430         dpsd_server[i].dwFlags = ( DPSESSION_CLIENTSERVER |
1431                                    DPSESSION_DIRECTPLAYPROTOCOL );
1432         dpsd_server[i].lpszPasswordA = NULL;
1433         dpsd_server[i].dwMaxPlayers = 10;
1434     }
1435     dpsd_server[4].lpszSessionNameA = (LPSTR) "normal1";
1436     dpsd_server[4].guidApplication = appGuid;
1437     dpsd_server[5].lpszSessionNameA = (LPSTR) "normal2";
1438     dpsd_server[5].guidApplication = appGuid2;
1439     for (i=4; i<=5; i++)
1440     {
1441         pDPserver[i] = create_session( &dpsd_server[i] );
1442     }
1443
1444     callbackData.dwFlags = 0;
1445
1446     dpsd.guidApplication = appGuid2;
1447     callbackData.dwCounter1 = -1;
1448     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1449                                     (LPVOID) &callbackData,
1450                                     callbackData.dwFlags );
1451     check( 1, callbackData.dwCounter1 ); /* Only one of the sessions */
1452
1453     dpsd.guidApplication = appGuid;
1454     callbackData.dwCounter1 = -1;
1455     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1456                                     (LPVOID) &callbackData,
1457                                     callbackData.dwFlags );
1458     check( 1, callbackData.dwCounter1 ); /* The other session */
1459     /* FIXME:
1460        For some reason, if we enum 1st with appGuid and 2nd with appGuid2,
1461        in the second enum we get the 2 sessions. Dplay fault? Elves? */
1462
1463     dpsd.guidApplication = GUID_NULL;
1464     callbackData.dwCounter1 = -1;
1465     hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1466                                     (LPVOID) &callbackData,
1467                                     callbackData.dwFlags );
1468     check( 2, callbackData.dwCounter1 ); /* Both sessions */
1469
1470     for (i=4; i<=5; i++)
1471     {
1472         IDirectPlayX_Release( pDPserver[i] );
1473     }
1474     IDirectPlayX_Release( pDP );
1475
1476 }
1477
1478
1479 START_TEST(dplayx)
1480 {
1481     CoInitialize( NULL );
1482
1483     test_DirectPlayCreate();
1484     test_EnumConnections();
1485     test_InitializeConnection();
1486
1487     test_GetCaps();
1488     test_Open();
1489     test_EnumSessions();
1490
1491     CoUninitialize();
1492 }