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 checkHR(expected, result)                       \
  32     ok( (expected) == (result),                         \
  33         "expected=%s got=%s\n",                         \
  34         dpResult2str(expected), dpResult2str(result) );
  35 #define checkFlags(expected, result, flags)     \
  36     ok( (expected) == (result),                 \
  37         "expected=0x%08x(%s) got=0x%08x(%s)\n", \
  38         expected, dwFlags2str(expected, flags), \
  39         result, dwFlags2str(result, flags) );
  40 #define checkGuid(expected, result)             \
  41     ok( IsEqualGUID(expected, result),          \
  42         "expected=%s got=%s\n",                 \
  43         Guid2str(expected), Guid2str(result) );
  44
  45
  46 DEFINE_GUID(appGuid, 0xbdcfe03e, 0xf0ec, 0x415b, 0x82, 0x11, 0x6f, 0x86, 0xd8, 0x19, 0x7f, 0xe1);
  47 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
  48
  49
  50 typedef struct tagCallbackData
  51 {
  52     LPDIRECTPLAY4 pDP;
  53     UINT dwCounter1, dwCounter2;
  54     DWORD dwFlags;
  55     char szTrace1[1024], szTrace2[1024];
  56     DPID *dpid;
  57     UINT dpidSize;
  58 } CallbackData, *lpCallbackData;
  59
  60
  61 static LPSTR get_temp_buffer(void)
  62 {
  63     static UINT index = 0;
  64     static char buff[10][256];
  65
  66     index = (index + 1) % 10;
  67     *buff[index] = 0;
  68
  69     return buff[index];
  70 }
  71
  72
  73 static LPCSTR Guid2str(const GUID *guid)
  74 {
  75     LPSTR buffer = get_temp_buffer();
  76
  77     if (!guid) return "(null)";
  78
  79     /* Service providers */
  80     if (IsEqualGUID(guid, &DPSPGUID_IPX))
  81         return "DPSPGUID_IPX";
  82     if (IsEqualGUID(guid, &DPSPGUID_TCPIP))
  83         return "DPSPGUID_TCPIP";
  84     if (IsEqualGUID(guid, &DPSPGUID_SERIAL))
  85         return "DPSPGUID_SERIAL";
  86     if (IsEqualGUID(guid, &DPSPGUID_MODEM))
  87         return "DPSPGUID_MODEM";
  88     /* DirectPlay Address ID's */
  89     if (IsEqualGUID(guid, &DPAID_TotalSize))
  90         return "DPAID_TotalSize";
  91     if (IsEqualGUID(guid, &DPAID_ServiceProvider))
  92         return "DPAID_ServiceProvider";
  93     if (IsEqualGUID(guid, &DPAID_LobbyProvider))
  94         return "DPAID_LobbyProvider";
  95     if (IsEqualGUID(guid, &DPAID_Phone))
  96         return "DPAID_Phone";
  97     if (IsEqualGUID(guid, &DPAID_PhoneW))
  98         return "DPAID_PhoneW";
  99     if (IsEqualGUID(guid, &DPAID_Modem))
 100         return "DPAID_Modem";
 101     if (IsEqualGUID(guid, &DPAID_ModemW))
 102         return "DPAID_ModemW";
 103     if (IsEqualGUID(guid, &DPAID_INet))
 104         return "DPAID_INet";
 105     if (IsEqualGUID(guid, &DPAID_INetW))
 106         return "DPAID_INetW";
 107     if (IsEqualGUID(guid, &DPAID_INetPort))
 108         return "DPAID_INetPort";
 109     if (IsEqualGUID(guid, &DPAID_ComPort))
 110         return "DPAID_ComPort";
 111
 112     sprintf( buffer, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
 113              guid->Data1, guid->Data2, guid->Data3,
 114              guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
 115              guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7] );
 116     return buffer;
 117
 118 }
 119
 120
 121 static LPCSTR dpResult2str(HRESULT hr)
 122 {
 123     switch (hr)
 124     {
 125     case DP_OK:                          return "DP_OK";
 126     case DPERR_ALREADYINITIALIZED:       return "DPERR_ALREADYINITIALIZED";
 127     case DPERR_ACCESSDENIED:             return "DPERR_ACCESSDENIED";
 128     case DPERR_ACTIVEPLAYERS:            return "DPERR_ACTIVEPLAYERS";
 129     case DPERR_BUFFERTOOSMALL:           return "DPERR_BUFFERTOOSMALL";
 130     case DPERR_CANTADDPLAYER:            return "DPERR_CANTADDPLAYER";
 131     case DPERR_CANTCREATEGROUP:          return "DPERR_CANTCREATEGROUP";
 132     case DPERR_CANTCREATEPLAYER:         return "DPERR_CANTCREATEPLAYER";
 133     case DPERR_CANTCREATESESSION:        return "DPERR_CANTCREATESESSION";
 134     case DPERR_CAPSNOTAVAILABLEYET:      return "DPERR_CAPSNOTAVAILABLEYET";
 135     case DPERR_EXCEPTION:                return "DPERR_EXCEPTION";
 136     case DPERR_GENERIC:                  return "DPERR_GENERIC";
 137     case DPERR_INVALIDFLAGS:             return "DPERR_INVALIDFLAGS";
 138     case DPERR_INVALIDOBJECT:            return "DPERR_INVALIDOBJECT";
 139     case DPERR_INVALIDPARAMS:            return "DPERR_INVALIDPARAMS";
 140         /*           symbol with the same value: DPERR_INVALIDPARAM */
 141     case DPERR_INVALIDPLAYER:            return "DPERR_INVALIDPLAYER";
 142     case DPERR_INVALIDGROUP:             return "DPERR_INVALIDGROUP";
 143     case DPERR_NOCAPS:                   return "DPERR_NOCAPS";
 144     case DPERR_NOCONNECTION:             return "DPERR_NOCONNECTION";
 145     case DPERR_NOMEMORY:                 return "DPERR_NOMEMORY";
 146         /*           symbol with the same value: DPERR_OUTOFMEMORY */
 147     case DPERR_NOMESSAGES:               return "DPERR_NOMESSAGES";
 148     case DPERR_NONAMESERVERFOUND:        return "DPERR_NONAMESERVERFOUND";
 149     case DPERR_NOPLAYERS:                return "DPERR_NOPLAYERS";
 150     case DPERR_NOSESSIONS:               return "DPERR_NOSESSIONS";
 151     case DPERR_PENDING:                  return "DPERR_PENDING";
 152     case DPERR_SENDTOOBIG:               return "DPERR_SENDTOOBIG";
 153     case DPERR_TIMEOUT:                  return "DPERR_TIMEOUT";
 154     case DPERR_UNAVAILABLE:              return "DPERR_UNAVAILABLE";
 155     case DPERR_UNSUPPORTED:              return "DPERR_UNSUPPORTED";
 156     case DPERR_BUSY:                     return "DPERR_BUSY";
 157     case DPERR_USERCANCEL:               return "DPERR_USERCANCEL";
 158     case DPERR_NOINTERFACE:              return "DPERR_NOINTERFACE";
 159     case DPERR_CANNOTCREATESERVER:       return "DPERR_CANNOTCREATESERVER";
 160     case DPERR_PLAYERLOST:               return "DPERR_PLAYERLOST";
 161     case DPERR_SESSIONLOST:              return "DPERR_SESSIONLOST";
 162     case DPERR_UNINITIALIZED:            return "DPERR_UNINITIALIZED";
 163     case DPERR_NONEWPLAYERS:             return "DPERR_NONEWPLAYERS";
 164     case DPERR_INVALIDPASSWORD:          return "DPERR_INVALIDPASSWORD";
 165     case DPERR_CONNECTING:               return "DPERR_CONNECTING";
 166     case DPERR_CONNECTIONLOST:           return "DPERR_CONNECTIONLOST";
 167     case DPERR_UNKNOWNMESSAGE:           return "DPERR_UNKNOWNMESSAGE";
 168     case DPERR_CANCELFAILED:             return "DPERR_CANCELFAILED";
 169     case DPERR_INVALIDPRIORITY:          return "DPERR_INVALIDPRIORITY";
 170     case DPERR_NOTHANDLED:               return "DPERR_NOTHANDLED";
 171     case DPERR_CANCELLED:                return "DPERR_CANCELLED";
 172     case DPERR_ABORTED:                  return "DPERR_ABORTED";
 173     case DPERR_BUFFERTOOLARGE:           return "DPERR_BUFFERTOOLARGE";
 174     case DPERR_CANTCREATEPROCESS:        return "DPERR_CANTCREATEPROCESS";
 175     case DPERR_APPNOTSTARTED:            return "DPERR_APPNOTSTARTED";
 176     case DPERR_INVALIDINTERFACE:         return "DPERR_INVALIDINTERFACE";
 177     case DPERR_NOSERVICEPROVIDER:        return "DPERR_NOSERVICEPROVIDER";
 178     case DPERR_UNKNOWNAPPLICATION:       return "DPERR_UNKNOWNAPPLICATION";
 179     case DPERR_NOTLOBBIED:               return "DPERR_NOTLOBBIED";
 180     case DPERR_SERVICEPROVIDERLOADED:    return "DPERR_SERVICEPROVIDERLOADED";
 181     case DPERR_ALREADYREGISTERED:        return "DPERR_ALREADYREGISTERED";
 182     case DPERR_NOTREGISTERED:            return "DPERR_NOTREGISTERED";
 183     case DPERR_AUTHENTICATIONFAILED:     return "DPERR_AUTHENTICATIONFAILED";
 184     case DPERR_CANTLOADSSPI:             return "DPERR_CANTLOADSSPI";
 185     case DPERR_ENCRYPTIONFAILED:         return "DPERR_ENCRYPTIONFAILED";
 186     case DPERR_SIGNFAILED:               return "DPERR_SIGNFAILED";
 187     case DPERR_CANTLOADSECURITYPACKAGE:  return "DPERR_CANTLOADSECURITYPACKAGE";
 188     case DPERR_ENCRYPTIONNOTSUPPORTED:   return "DPERR_ENCRYPTIONNOTSUPPORTED";
 189     case DPERR_CANTLOADCAPI:             return "DPERR_CANTLOADCAPI";
 190     case DPERR_NOTLOGGEDIN:              return "DPERR_NOTLOGGEDIN";
 191     case DPERR_LOGONDENIED:              return "DPERR_LOGONDENIED";
 192     case CLASS_E_NOAGGREGATION:          return "CLASS_E_NOAGGREGATION";
 193
 194     default:
 195     {
 196         LPSTR buffer = get_temp_buffer();
 197         sprintf( buffer, "%d", HRESULT_CODE(hr) );
 198         return buffer;
 199     }
 200     }
 201 }
 202
 203 static LPCSTR dwFlags2str(DWORD dwFlags, DWORD flagType)
 204 {
 205
 206 #define FLAGS_DPCONNECTION     (1<<0)
 207 #define FLAGS_DPENUMPLAYERS    (1<<1)
 208 #define FLAGS_DPENUMGROUPS     (1<<2)
 209 #define FLAGS_DPPLAYER         (1<<3)
 210 #define FLAGS_DPGROUP          (1<<4)
 211 #define FLAGS_DPENUMSESSIONS   (1<<5)
 212 #define FLAGS_DPGETCAPS        (1<<6)
 213 #define FLAGS_DPGET            (1<<7)
 214 #define FLAGS_DPRECEIVE        (1<<8)
 215 #define FLAGS_DPSEND           (1<<9)
 216 #define FLAGS_DPSET            (1<<10)
 217 #define FLAGS_DPMESSAGEQUEUE   (1<<11)
 218 #define FLAGS_DPCONNECT        (1<<12)
 219 #define FLAGS_DPOPEN           (1<<13)
 220 #define FLAGS_DPSESSION        (1<<14)
 221 #define FLAGS_DPLCONNECTION    (1<<15)
 222 #define FLAGS_DPESC            (1<<16)
 223 #define FLAGS_DPCAPS           (1<<17)
 224
 225     LPSTR flags = get_temp_buffer();
 226
 227     /* EnumConnections */
 228
 229     if (flagType & FLAGS_DPCONNECTION)
 230     {
 231         if (dwFlags & DPCONNECTION_DIRECTPLAY)
 232             strcat(flags, "DPCONNECTION_DIRECTPLAY,");
 233         if (dwFlags & DPCONNECTION_DIRECTPLAYLOBBY)
 234             strcat(flags, "DPCONNECTION_DIRECTPLAYLOBBY,");
 235     }
 236
 237     /* EnumPlayers,
 238        EnumGroups */
 239
 240     if (flagType & FLAGS_DPENUMPLAYERS)
 241     {
 242         if (dwFlags == DPENUMPLAYERS_ALL)
 243             strcat(flags, "DPENUMPLAYERS_ALL,");
 244         if (dwFlags & DPENUMPLAYERS_LOCAL)
 245             strcat(flags, "DPENUMPLAYERS_LOCAL,");
 246         if (dwFlags & DPENUMPLAYERS_REMOTE)
 247             strcat(flags, "DPENUMPLAYERS_REMOTE,");
 248         if (dwFlags & DPENUMPLAYERS_GROUP)
 249             strcat(flags, "DPENUMPLAYERS_GROUP,");
 250         if (dwFlags & DPENUMPLAYERS_SESSION)
 251             strcat(flags, "DPENUMPLAYERS_SESSION,");
 252         if (dwFlags & DPENUMPLAYERS_SERVERPLAYER)
 253             strcat(flags, "DPENUMPLAYERS_SERVERPLAYER,");
 254         if (dwFlags & DPENUMPLAYERS_SPECTATOR)
 255             strcat(flags, "DPENUMPLAYERS_SPECTATOR,");
 256         if (dwFlags & DPENUMPLAYERS_OWNER)
 257             strcat(flags, "DPENUMPLAYERS_OWNER,");
 258     }
 259     if (flagType & FLAGS_DPENUMGROUPS)
 260     {
 261         if (dwFlags == DPENUMGROUPS_ALL)
 262             strcat(flags, "DPENUMGROUPS_ALL,");
 263         if (dwFlags & DPENUMPLAYERS_LOCAL)
 264             strcat(flags, "DPENUMGROUPS_LOCAL,");
 265         if (dwFlags & DPENUMPLAYERS_REMOTE)
 266             strcat(flags, "DPENUMGROUPS_REMOTE,");
 267         if (dwFlags & DPENUMPLAYERS_GROUP)
 268             strcat(flags, "DPENUMGROUPS_GROUP,");
 269         if (dwFlags & DPENUMPLAYERS_SESSION)
 270             strcat(flags, "DPENUMGROUPS_SESSION,");
 271         if (dwFlags & DPENUMGROUPS_SHORTCUT)
 272             strcat(flags, "DPENUMGROUPS_SHORTCUT,");
 273         if (dwFlags & DPENUMGROUPS_STAGINGAREA)
 274             strcat(flags, "DPENUMGROUPS_STAGINGAREA,");
 275         if (dwFlags & DPENUMGROUPS_HIDDEN)
 276             strcat(flags, "DPENUMGROUPS_HIDDEN,");
 277     }
 278
 279     /* CreatePlayer */
 280
 281     if (flagType & FLAGS_DPPLAYER)
 282     {
 283         if (dwFlags & DPPLAYER_SERVERPLAYER)
 284             strcat(flags, "DPPLAYER_SERVERPLAYER,");
 285         if (dwFlags & DPPLAYER_SPECTATOR)
 286             strcat(flags, "DPPLAYER_SPECTATOR,");
 287         if (dwFlags & DPPLAYER_LOCAL)
 288             strcat(flags, "DPPLAYER_LOCAL,");
 289         if (dwFlags & DPPLAYER_OWNER)
 290             strcat(flags, "DPPLAYER_OWNER,");
 291     }
 292
 293     /* CreateGroup */
 294
 295     if (flagType & FLAGS_DPGROUP)
 296     {
 297         if (dwFlags & DPGROUP_STAGINGAREA)
 298             strcat(flags, "DPGROUP_STAGINGAREA,");
 299         if (dwFlags & DPGROUP_LOCAL)
 300             strcat(flags, "DPGROUP_LOCAL,");
 301         if (dwFlags & DPGROUP_HIDDEN)
 302             strcat(flags, "DPGROUP_HIDDEN,");
 303     }
 304
 305     /* EnumSessions */
 306
 307     if (flagType & FLAGS_DPENUMSESSIONS)
 308     {
 309         if (dwFlags & DPENUMSESSIONS_AVAILABLE)
 310             strcat(flags, "DPENUMSESSIONS_AVAILABLE,");
 311         if (dwFlags &  DPENUMSESSIONS_ALL)
 312             strcat(flags, "DPENUMSESSIONS_ALL,");
 313         if (dwFlags & DPENUMSESSIONS_ASYNC)
 314             strcat(flags, "DPENUMSESSIONS_ASYNC,");
 315         if (dwFlags & DPENUMSESSIONS_STOPASYNC)
 316             strcat(flags, "DPENUMSESSIONS_STOPASYNC,");
 317         if (dwFlags & DPENUMSESSIONS_PASSWORDREQUIRED)
 318             strcat(flags, "DPENUMSESSIONS_PASSWORDREQUIRED,");
 319         if (dwFlags & DPENUMSESSIONS_RETURNSTATUS)
 320             strcat(flags, "DPENUMSESSIONS_RETURNSTATUS,");
 321     }
 322
 323     /* GetCaps,
 324        GetPlayerCaps */
 325
 326     if (flagType & FLAGS_DPGETCAPS)
 327     {
 328         if (dwFlags & DPGETCAPS_GUARANTEED)
 329             strcat(flags, "DPGETCAPS_GUARANTEED,");
 330     }
 331
 332     /* GetGroupData,
 333        GetPlayerData */
 334
 335     if (flagType & FLAGS_DPGET)
 336     {
 337         if (dwFlags == DPGET_REMOTE)
 338             strcat(flags, "DPGET_REMOTE,");
 339         if (dwFlags & DPGET_LOCAL)
 340             strcat(flags, "DPGET_LOCAL,");
 341     }
 342
 343     /* Receive */
 344
 345     if (flagType & FLAGS_DPRECEIVE)
 346     {
 347         if (dwFlags & DPRECEIVE_ALL)
 348             strcat(flags, "DPRECEIVE_ALL,");
 349         if (dwFlags & DPRECEIVE_TOPLAYER)
 350             strcat(flags, "DPRECEIVE_TOPLAYER,");
 351         if (dwFlags & DPRECEIVE_FROMPLAYER)
 352             strcat(flags, "DPRECEIVE_FROMPLAYER,");
 353         if (dwFlags & DPRECEIVE_PEEK)
 354             strcat(flags, "DPRECEIVE_PEEK,");
 355     }
 356
 357     /* Send */
 358
 359     if (flagType & FLAGS_DPSEND)
 360     {
 361         /*if (dwFlags == DPSEND_NONGUARANTEED)
 362           strcat(flags, "DPSEND_NONGUARANTEED,");*/
 363         if (dwFlags == DPSEND_MAX_PRIORITY) /* = DPSEND_MAX_PRI */
 364         {
 365             strcat(flags, "DPSEND_MAX_PRIORITY,");
 366         }
 367         else
 368         {
 369             if (dwFlags & DPSEND_GUARANTEED)
 370                 strcat(flags, "DPSEND_GUARANTEED,");
 371             if (dwFlags & DPSEND_HIGHPRIORITY)
 372                 strcat(flags, "DPSEND_HIGHPRIORITY,");
 373             if (dwFlags & DPSEND_OPENSTREAM)
 374                 strcat(flags, "DPSEND_OPENSTREAM,");
 375             if (dwFlags & DPSEND_CLOSESTREAM)
 376                 strcat(flags, "DPSEND_CLOSESTREAM,");
 377             if (dwFlags & DPSEND_SIGNED)
 378                 strcat(flags, "DPSEND_SIGNED,");
 379             if (dwFlags & DPSEND_ENCRYPTED)
 380                 strcat(flags, "DPSEND_ENCRYPTED,");
 381             if (dwFlags & DPSEND_LOBBYSYSTEMMESSAGE)
 382                 strcat(flags, "DPSEND_LOBBYSYSTEMMESSAGE,");
 383             if (dwFlags & DPSEND_ASYNC)
 384                 strcat(flags, "DPSEND_ASYNC,");
 385             if (dwFlags & DPSEND_NOSENDCOMPLETEMSG)
 386                 strcat(flags, "DPSEND_NOSENDCOMPLETEMSG,");
 387         }
 388     }
 389
 390     /* SetGroupData,
 391        SetGroupName,
 392        SetPlayerData,
 393        SetPlayerName,
 394        SetSessionDesc */
 395
 396     if (flagType & FLAGS_DPSET)
 397     {
 398         if (dwFlags == DPSET_REMOTE)
 399             strcat(flags, "DPSET_REMOTE,");
 400         if (dwFlags & DPSET_LOCAL)
 401             strcat(flags, "DPSET_LOCAL,");
 402         if (dwFlags & DPSET_GUARANTEED)
 403             strcat(flags, "DPSET_GUARANTEED,");
 404     }
 405
 406     /* GetMessageQueue */
 407
 408     if (flagType & FLAGS_DPMESSAGEQUEUE)
 409     {
 410         if (dwFlags & DPMESSAGEQUEUE_SEND)
 411             strcat(flags, "DPMESSAGEQUEUE_SEND,");
 412         if (dwFlags & DPMESSAGEQUEUE_RECEIVE)
 413             strcat(flags, "DPMESSAGEQUEUE_RECEIVE,");
 414     }
 415
 416     /* Connect */
 417
 418     if (flagType & FLAGS_DPCONNECT)
 419     {
 420         if (dwFlags & DPCONNECT_RETURNSTATUS)
 421             strcat(flags, "DPCONNECT_RETURNSTATUS,");
 422     }
 423
 424     /* Open */
 425
 426     if (flagType & FLAGS_DPOPEN)
 427     {
 428         if (dwFlags & DPOPEN_JOIN)
 429             strcat(flags, "DPOPEN_JOIN,");
 430         if (dwFlags & DPOPEN_CREATE)
 431             strcat(flags, "DPOPEN_CREATE,");
 432         if (dwFlags & DPOPEN_RETURNSTATUS)
 433             strcat(flags, "DPOPEN_RETURNSTATUS,");
 434     }
 435
 436     /* DPSESSIONDESC2 */
 437
 438     if (flagType & FLAGS_DPSESSION)
 439     {
 440         if (dwFlags & DPSESSION_NEWPLAYERSDISABLED)
 441             strcat(flags, "DPSESSION_NEWPLAYERSDISABLED,");
 442         if (dwFlags & DPSESSION_MIGRATEHOST)
 443             strcat(flags, "DPSESSION_MIGRATEHOST,");
 444         if (dwFlags & DPSESSION_NOMESSAGEID)
 445             strcat(flags, "DPSESSION_NOMESSAGEID,");
 446         if (dwFlags & DPSESSION_JOINDISABLED)
 447             strcat(flags, "DPSESSION_JOINDISABLED,");
 448         if (dwFlags & DPSESSION_KEEPALIVE)
 449             strcat(flags, "DPSESSION_KEEPALIVE,");
 450         if (dwFlags & DPSESSION_NODATAMESSAGES)
 451             strcat(flags, "DPSESSION_NODATAMESSAGES,");
 452         if (dwFlags & DPSESSION_SECURESERVER)
 453             strcat(flags, "DPSESSION_SECURESERVER,");
 454         if (dwFlags & DPSESSION_PRIVATE)
 455             strcat(flags, "DPSESSION_PRIVATE,");
 456         if (dwFlags & DPSESSION_PASSWORDREQUIRED)
 457             strcat(flags, "DPSESSION_PASSWORDREQUIRED,");
 458         if (dwFlags & DPSESSION_MULTICASTSERVER)
 459             strcat(flags, "DPSESSION_MULTICASTSERVER,");
 460         if (dwFlags & DPSESSION_CLIENTSERVER)
 461             strcat(flags, "DPSESSION_CLIENTSERVER,");
 462
 463         if (dwFlags & DPSESSION_DIRECTPLAYPROTOCOL)
 464             strcat(flags, "DPSESSION_DIRECTPLAYPROTOCOL,");
 465         if (dwFlags & DPSESSION_NOPRESERVEORDER)
 466             strcat(flags, "DPSESSION_NOPRESERVEORDER,");
 467         if (dwFlags & DPSESSION_OPTIMIZELATENCY)
 468             strcat(flags, "DPSESSION_OPTIMIZELATENCY,");
 469
 470     }
 471
 472     /* DPLCONNECTION */
 473
 474     if (flagType & FLAGS_DPLCONNECTION)
 475     {
 476         if (dwFlags & DPLCONNECTION_CREATESESSION)
 477             strcat(flags, "DPLCONNECTION_CREATESESSION,");
 478         if (dwFlags & DPLCONNECTION_JOINSESSION)
 479             strcat(flags, "DPLCONNECTION_JOINSESSION,");
 480     }
 481
 482     /* EnumSessionsCallback2 */
 483
 484     if (flagType & FLAGS_DPESC)
 485     {
 486         if (dwFlags & DPESC_TIMEDOUT)
 487             strcat(flags, "DPESC_TIMEDOUT,");
 488     }
 489
 490     /* GetCaps,
 491        GetPlayerCaps */
 492
 493     if (flagType & FLAGS_DPCAPS)
 494     {
 495         if (dwFlags & DPCAPS_ISHOST)
 496             strcat(flags, "DPCAPS_ISHOST,");
 497         if (dwFlags & DPCAPS_GROUPOPTIMIZED)
 498             strcat(flags, "DPCAPS_GROUPOPTIMIZED,");
 499         if (dwFlags & DPCAPS_KEEPALIVEOPTIMIZED)
 500             strcat(flags, "DPCAPS_KEEPALIVEOPTIMIZED,");
 501         if (dwFlags & DPCAPS_GUARANTEEDOPTIMIZED)
 502             strcat(flags, "DPCAPS_GUARANTEEDOPTIMIZED,");
 503         if (dwFlags & DPCAPS_GUARANTEEDSUPPORTED)
 504             strcat(flags, "DPCAPS_GUARANTEEDSUPPORTED,");
 505         if (dwFlags & DPCAPS_SIGNINGSUPPORTED)
 506             strcat(flags, "DPCAPS_SIGNINGSUPPORTED,");
 507         if (dwFlags & DPCAPS_ENCRYPTIONSUPPORTED)
 508             strcat(flags, "DPCAPS_ENCRYPTIONSUPPORTED,");
 509         if (dwFlags & DPCAPS_ASYNCCANCELSUPPORTED)
 510             strcat(flags, "DPCAPS_ASYNCCANCELSUPPORTED,");
 511         if (dwFlags & DPCAPS_ASYNCCANCELALLSUPPORTED)
 512             strcat(flags, "DPCAPS_ASYNCCANCELALLSUPPORTED,");
 513         if (dwFlags & DPCAPS_SENDTIMEOUTSUPPORTED)
 514             strcat(flags, "DPCAPS_SENDTIMEOUTSUPPORTED,");
 515         if (dwFlags & DPCAPS_SENDPRIORITYSUPPORTED)
 516             strcat(flags, "DPCAPS_SENDPRIORITYSUPPORTED,");
 517         if (dwFlags & DPCAPS_ASYNCSUPPORTED)
 518             strcat(flags, "DPCAPS_ASYNCSUPPORTED,");
 519
 520         if (dwFlags & DPPLAYERCAPS_LOCAL)
 521             strcat(flags, "DPPLAYERCAPS_LOCAL,");
 522     }
 523
 524     if ((strlen(flags) == 0) && (dwFlags != 0))
 525         strcpy(flags, "UNKNOWN");
 526     else
 527         flags[strlen(flags)-1] = '\0';
 528
 529     return flags;
 530 }
 531
 532 static void init_TCPIP_provider( LPDIRECTPLAY4 pDP,
 533                                  LPCSTR strIPAddressString,
 534                                  WORD port )
 535 {
 536
 537     DPCOMPOUNDADDRESSELEMENT addressElements[3];
 538     LPVOID pAddress = NULL;
 539     DWORD dwAddressSize = 0;
 540     LPDIRECTPLAYLOBBY3 pDPL;
 541     HRESULT hr;
 542
 543     CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL,
 544                       &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL );
 545
 546     /* Service provider */
 547     addressElements[0].guidDataType = DPAID_ServiceProvider;
 548     addressElements[0].dwDataSize   = sizeof(GUID);
 549     addressElements[0].lpData       = (LPVOID) &DPSPGUID_TCPIP;
 550
 551     /* IP address string */
 552     addressElements[1].guidDataType = DPAID_INet;
 553     addressElements[1].dwDataSize   = lstrlen(strIPAddressString) + 1;
 554     addressElements[1].lpData       = (LPVOID) strIPAddressString;
 555
 556     /* Optional Port number */
 557     if( port > 0 )
 558     {
 559         addressElements[2].guidDataType = DPAID_INetPort;
 560         addressElements[2].dwDataSize   = sizeof(WORD);
 561         addressElements[2].lpData       = &port;
 562     }
 563
 564
 565     hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2,
 566                                                  NULL, &dwAddressSize );
 567     checkHR( DPERR_BUFFERTOOSMALL, hr );
 568
 569     if( hr == DPERR_BUFFERTOOSMALL )
 570     {
 571         pAddress = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwAddressSize );
 572         hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2,
 573                                                      pAddress, &dwAddressSize );
 574         checkHR( DP_OK, hr );
 575     }
 576
 577     hr = IDirectPlayX_InitializeConnection( pDP, pAddress, 0 );
 578     todo_wine checkHR( DP_OK, hr );
 579
 580 }
 581
 582
 583 /* DirectPlayCreate */
 584
 585 static void test_DirectPlayCreate(void)
 586 {
 587
 588     LPDIRECTPLAY pDP;
 589     HRESULT hr;
 590
 591     /* TODO: Check how it behaves with pUnk!=NULL */
 592
 593     /* pDP==NULL */
 594     hr = DirectPlayCreate( NULL, NULL, NULL );
 595     checkHR( DPERR_INVALIDPARAMS, hr );
 596     hr = DirectPlayCreate( (LPGUID) &GUID_NULL, NULL, NULL );
 597     checkHR( DPERR_INVALIDPARAMS, hr );
 598     hr = DirectPlayCreate( (LPGUID) &DPSPGUID_TCPIP, NULL, NULL );
 599     checkHR( DPERR_INVALIDPARAMS, hr );
 600
 601     /* pUnk==NULL, pDP!=NULL */
 602     hr = DirectPlayCreate( NULL, &pDP, NULL );
 603     checkHR( DPERR_INVALIDPARAMS, hr );
 604     hr = DirectPlayCreate( (LPGUID) &GUID_NULL, &pDP, NULL );
 605     checkHR( DP_OK, hr );
 606     if ( hr == DP_OK )
 607         IDirectPlayX_Release( pDP );
 608     hr = DirectPlayCreate( (LPGUID) &DPSPGUID_TCPIP, &pDP, NULL );
 609     todo_wine checkHR( DP_OK, hr );
 610     if ( hr == DP_OK )
 611         IDirectPlayX_Release( pDP );
 612
 613 }
 614
 615 /* EnumConnections */
 616
 617 static BOOL FAR PASCAL EnumAddress_cb2( REFGUID guidDataType,
 618                                         DWORD dwDataSize,
 619                                         LPCVOID lpData,
 620                                         LPVOID lpContext )
 621 {
 622     lpCallbackData callbackData = (lpCallbackData) lpContext;
 623
 624     static REFGUID types[] = { &DPAID_TotalSize,
 625                                &DPAID_ServiceProvider,
 626                                &GUID_NULL };
 627     static DWORD sizes[] = { 4, 16, 0  };
 628     static REFGUID sps[] = { &DPSPGUID_SERIAL, &DPSPGUID_MODEM,
 629                              &DPSPGUID_IPX, &DPSPGUID_TCPIP };
 630
 631
 632     checkGuid( types[ callbackData->dwCounter2 ], guidDataType );
 633     check( sizes[ callbackData->dwCounter2 ], dwDataSize );
 634
 635     if ( IsEqualGUID( types[0], guidDataType ) )
 636     {
 637         todo_wine check( 80, *((LPDWORD) lpData) );
 638     }
 639     else if ( IsEqualGUID( types[1], guidDataType ) )
 640     {
 641         todo_wine checkGuid( sps[ callbackData->dwCounter1 ], (LPGUID) lpData );
 642     }
 643
 644     callbackData->dwCounter2++;
 645
 646     return TRUE;
 647 }
 648
 649 static BOOL CALLBACK EnumConnections_cb( LPCGUID lpguidSP,
 650                                          LPVOID lpConnection,
 651                                          DWORD dwConnectionSize,
 652                                          LPCDPNAME lpName,
 653                                          DWORD dwFlags,
 654                                          LPVOID lpContext )
 655 {
 656
 657     lpCallbackData callbackData = (lpCallbackData) lpContext;
 658     LPDIRECTPLAYLOBBY pDPL;
 659
 660
 661     if (!callbackData->dwFlags)
 662     {
 663         callbackData->dwFlags = DPCONNECTION_DIRECTPLAY;
 664     }
 665
 666     checkFlags( callbackData->dwFlags, dwFlags, FLAGS_DPCONNECTION );
 667
 668     /* Get info from lpConnection */
 669     CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL,
 670                       &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL );
 671
 672     callbackData->dwCounter2 = 0;
 673     IDirectPlayLobby_EnumAddress( pDPL, EnumAddress_cb2,
 674                                   (LPCVOID) lpConnection,
 675                                   dwConnectionSize,
 676                                   (LPVOID) callbackData );
 677     todo_wine check( 3, callbackData->dwCounter2 );
 678
 679     callbackData->dwCounter1++;
 680
 681     return TRUE;
 682 }
 683
 684 static void test_EnumConnections(void)
 685 {
 686
 687     LPDIRECTPLAY4 pDP;
 688     CallbackData callbackData;
 689     HRESULT hr;
 690
 691
 692     CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
 693                       &IID_IDirectPlay4A, (LPVOID*) &pDP );
 694
 695
 696     callbackData.dwCounter1 = 0;
 697     callbackData.dwFlags = 0;
 698     hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
 699                                        (LPVOID) &callbackData,
 700                                        callbackData.dwFlags );
 701     checkHR( DP_OK, hr );
 702     check( 4, callbackData.dwCounter1 );
 703
 704     callbackData.dwCounter1 = 0;
 705     callbackData.dwFlags = 0;
 706     hr = IDirectPlayX_EnumConnections( pDP, NULL, EnumConnections_cb,
 707                                        (LPVOID) &callbackData,
 708                                        callbackData.dwFlags );
 709     checkHR( DP_OK, hr );
 710     check( 4, callbackData.dwCounter1 );
 711
 712     callbackData.dwCounter1 = 0;
 713     callbackData.dwFlags = 0;
 714     hr = IDirectPlayX_EnumConnections( pDP, &appGuid, NULL,
 715                                        (LPVOID) &callbackData,
 716                                        callbackData.dwFlags );
 717     checkHR( DPERR_INVALIDPARAMS, hr );
 718     check( 0, callbackData.dwCounter1 );
 719
 720
 721     /* Flag tests */
 722     callbackData.dwCounter1 = 0;
 723     callbackData.dwFlags = DPCONNECTION_DIRECTPLAY;
 724     hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
 725                                        (LPVOID) &callbackData,
 726                                        callbackData.dwFlags );
 727     checkHR( DP_OK, hr );
 728     check( 4, callbackData.dwCounter1 );
 729
 730     callbackData.dwCounter1 = 0;
 731     callbackData.dwFlags = DPCONNECTION_DIRECTPLAYLOBBY;
 732     hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
 733                                        (LPVOID) &callbackData,
 734                                        callbackData.dwFlags );
 735     checkHR( DP_OK, hr );
 736     check( 0, callbackData.dwCounter1 );
 737
 738     callbackData.dwCounter1 = 0;
 739     callbackData.dwFlags = ( DPCONNECTION_DIRECTPLAY |
 740                              DPCONNECTION_DIRECTPLAYLOBBY );
 741     hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
 742                                        (LPVOID) &callbackData,
 743                                        callbackData.dwFlags );
 744     checkHR( DP_OK, hr );
 745     check( 4, callbackData.dwCounter1 );
 746
 747     callbackData.dwCounter1 = 0;
 748     callbackData.dwFlags = ~( DPCONNECTION_DIRECTPLAY |
 749                               DPCONNECTION_DIRECTPLAYLOBBY );
 750     hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
 751                                        (LPVOID) &callbackData,
 752                                        callbackData.dwFlags );
 753     checkHR( DPERR_INVALIDFLAGS, hr );
 754     check( 0, callbackData.dwCounter1 );
 755
 756
 757     IDirectPlayX_Release( pDP );
 758 }
 759
 760 /* InitializeConnection */
 761
 762 static BOOL CALLBACK EnumConnections_cb2( LPCGUID lpguidSP,
 763                                           LPVOID lpConnection,
 764                                           DWORD dwConnectionSize,
 765                                           LPCDPNAME lpName,
 766                                           DWORD dwFlags,
 767                                           LPVOID lpContext )
 768 {
 769     LPDIRECTPLAY4 pDP = (LPDIRECTPLAY4) lpContext;
 770     HRESULT hr;
 771
 772     /* Incorrect parameters */
 773     hr = IDirectPlayX_InitializeConnection( pDP, NULL, 1 );
 774     checkHR( DPERR_INVALIDPARAMS, hr );
 775     hr = IDirectPlayX_InitializeConnection( pDP, lpConnection, 1 );
 776     checkHR( DPERR_INVALIDFLAGS, hr );
 777
 778     /* Normal operation.
 779        We're only interested in ensuring that the TCP/IP provider works */
 780
 781     if( IsEqualGUID(lpguidSP, &DPSPGUID_TCPIP) )
 782     {
 783         hr = IDirectPlayX_InitializeConnection( pDP, lpConnection, 0 );
 784         todo_wine checkHR( DP_OK, hr );
 785         hr = IDirectPlayX_InitializeConnection( pDP, lpConnection, 0 );
 786         todo_wine checkHR( DPERR_ALREADYINITIALIZED, hr );
 787     }
 788
 789     return TRUE;
 790 }
 791
 792 static void test_InitializeConnection(void)
 793 {
 794
 795     LPDIRECTPLAY4 pDP;
 796
 797     CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
 798                       &IID_IDirectPlay4A, (LPVOID*) &pDP );
 799
 800     IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb2,
 801                                   (LPVOID) pDP, 0 );
 802
 803     IDirectPlayX_Release( pDP );
 804 }
 805
 806 /* GetCaps */
 807
 808 static void test_GetCaps(void)
 809 {
 810
 811     LPDIRECTPLAY4 pDP;
 812     DPCAPS dpcaps;
 813     DWORD dwFlags;
 814     HRESULT hr;
 815
 816
 817     CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
 818                       &IID_IDirectPlay4A, (LPVOID*) &pDP );
 819     ZeroMemory( &dpcaps, sizeof(DPCAPS) );
 820
 821     /* Service provider not ininitialized */
 822     hr = IDirectPlayX_GetCaps( pDP, &dpcaps, 0 );
 823     checkHR( DPERR_UNINITIALIZED, hr );
 824
 825     init_TCPIP_provider( pDP, "127.0.0.1", 0 );
 826
 827     /* dpcaps not ininitialized */
 828     hr = IDirectPlayX_GetCaps( pDP, &dpcaps, 0 );
 829     todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 830
 831     dpcaps.dwSize = sizeof(DPCAPS);
 832
 833     for (dwFlags=0;
 834          dwFlags<=DPGETCAPS_GUARANTEED;
 835          dwFlags+=DPGETCAPS_GUARANTEED)
 836     {
 837
 838         hr = IDirectPlayX_GetCaps( pDP, &dpcaps, dwFlags );
 839         todo_wine checkHR( DP_OK, hr );
 840
 841
 842         if ( hr == DP_OK )
 843         {
 844             check( sizeof(DPCAPS), dpcaps.dwSize );
 845             check( DPCAPS_ASYNCSUPPORTED |
 846                    DPCAPS_GUARANTEEDOPTIMIZED |
 847                    DPCAPS_GUARANTEEDSUPPORTED,
 848                    dpcaps.dwFlags );
 849             check( 0,     dpcaps.dwMaxQueueSize );
 850             check( 0,     dpcaps.dwHundredBaud );
 851             check( 500,   dpcaps.dwLatency );
 852             check( 65536, dpcaps.dwMaxLocalPlayers );
 853             check( 20,    dpcaps.dwHeaderLength );
 854             check( 5000,  dpcaps.dwTimeout );
 855
 856             switch (dwFlags)
 857             {
 858             case 0:
 859                 check( 65479,   dpcaps.dwMaxBufferSize );
 860                 check( 65536,   dpcaps.dwMaxPlayers );
 861                 break;
 862             case DPGETCAPS_GUARANTEED:
 863                 check( 1048547, dpcaps.dwMaxBufferSize );
 864                 check( 64,      dpcaps.dwMaxPlayers );
 865                 break;
 866             default: break;
 867             }
 868         }
 869     }
 870
 871     IDirectPlayX_Release( pDP );
 872 }
 873
 874 /* Open */
 875
 876 static BOOL FAR PASCAL EnumSessions_cb2( LPCDPSESSIONDESC2 lpThisSD,
 877                                          LPDWORD lpdwTimeOut,
 878                                          DWORD dwFlags,
 879                                          LPVOID lpContext )
 880 {
 881     LPDIRECTPLAY4 pDP = (LPDIRECTPLAY4) lpContext;
 882     DPSESSIONDESC2 dpsd;
 883     HRESULT hr;
 884
 885     if (dwFlags & DPESC_TIMEDOUT)
 886         return FALSE;
 887
 888
 889     ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
 890     dpsd.dwSize = sizeof(DPSESSIONDESC2);
 891     dpsd.guidApplication = appGuid;
 892     dpsd.guidInstance = lpThisSD->guidInstance;
 893
 894     if ( lpThisSD->dwFlags & DPSESSION_PASSWORDREQUIRED )
 895     {
 896         /* Incorrect password */
 897         dpsd.lpszPasswordA = (LPSTR) "sonic boom";
 898         hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
 899         checkHR( DPERR_INVALIDPASSWORD, hr );
 900
 901         /* Correct password */
 902         dpsd.lpszPasswordA = (LPSTR) "hadouken";
 903         hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
 904         checkHR( DP_OK, hr );
 905     }
 906     else
 907     {
 908         hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
 909         checkHR( DP_OK, hr );
 910     }
 911
 912     hr = IDirectPlayX_Close( pDP );
 913     checkHR( DP_OK, hr );
 914
 915     return TRUE;
 916 }
 917
 918 static void test_Open(void)
 919 {
 920
 921     LPDIRECTPLAY4 pDP, pDP_server;
 922     DPSESSIONDESC2 dpsd, dpsd_server;
 923     HRESULT hr;
 924
 925
 926     CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
 927                       &IID_IDirectPlay4A, (LPVOID*) &pDP_server );
 928     CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
 929                       &IID_IDirectPlay4A, (LPVOID*) &pDP );
 930     ZeroMemory( &dpsd_server, sizeof(DPSESSIONDESC2) );
 931     ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
 932
 933     /* Service provider not initialized */
 934     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
 935     todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 936
 937     init_TCPIP_provider( pDP_server, "127.0.0.1", 0 );
 938     init_TCPIP_provider( pDP, "127.0.0.1", 0 );
 939
 940     /* Uninitialized  dpsd */
 941     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
 942     todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 943
 944
 945     dpsd_server.dwSize = sizeof(DPSESSIONDESC2);
 946     dpsd_server.guidApplication = appGuid;
 947     dpsd_server.dwMaxPlayers = 10;
 948
 949
 950     /* Regular operation */
 951     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
 952     todo_wine checkHR( DP_OK, hr );
 953
 954     /* Opening twice */
 955     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
 956     todo_wine checkHR( DPERR_ALREADYINITIALIZED, hr );
 957
 958     /* Session flags */
 959     IDirectPlayX_Close( pDP_server );
 960
 961     dpsd_server.dwFlags = DPSESSION_CLIENTSERVER | DPSESSION_MIGRATEHOST;
 962     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
 963     todo_wine checkHR( DPERR_INVALIDFLAGS, hr );
 964
 965     dpsd_server.dwFlags = DPSESSION_MULTICASTSERVER | DPSESSION_MIGRATEHOST;
 966     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
 967     todo_wine checkHR( DPERR_INVALIDFLAGS, hr );
 968
 969     dpsd_server.dwFlags = DPSESSION_SECURESERVER | DPSESSION_MIGRATEHOST;
 970     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
 971     todo_wine checkHR( DPERR_INVALIDFLAGS, hr );
 972
 973
 974     /* Joining sessions */
 975     /* - Checking how strict dplay is with sizes */
 976     dpsd.dwSize = 0;
 977     hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
 978     todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 979
 980     dpsd.dwSize = sizeof(DPSESSIONDESC2)-1;
 981     hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
 982     todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 983
 984     dpsd.dwSize = sizeof(DPSESSIONDESC2)+1;
 985     hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
 986     todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 987
 988     dpsd.dwSize = sizeof(DPSESSIONDESC2);
 989     hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
 990     todo_wine checkHR( DPERR_NOSESSIONS, hr ); /* Only checks for size, not guids */
 991
 992
 993     dpsd.guidApplication = appGuid;
 994     dpsd.guidInstance = appGuid;
 995
 996
 997     hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
 998     todo_wine checkHR( DPERR_NOSESSIONS, hr );
 999     hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN | DPOPEN_CREATE );
1000     todo_wine checkHR( DPERR_NOSESSIONS, hr ); /* Second flag is ignored */
1001
1002     dpsd_server.dwFlags = 0;
1003
1004
1005     /* Join to normal session */
1006     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
1007     todo_wine checkHR( DP_OK, hr );
1008
1009     IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb2, pDP, 0 );
1010
1011
1012     /* Already initialized session */
1013     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
1014     todo_wine checkHR( DPERR_ALREADYINITIALIZED, hr );
1015
1016
1017     /* Checking which is the error checking order */
1018     dpsd_server.dwSize = 0;
1019
1020     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
1021     todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
1022
1023     dpsd_server.dwSize = sizeof(DPSESSIONDESC2);
1024
1025
1026     /* Join to protected session */
1027     IDirectPlayX_Close( pDP_server );
1028     dpsd_server.lpszPasswordA = (LPSTR) "hadouken";
1029     hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
1030     todo_wine checkHR( DP_OK, hr );
1031
1032     IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb2,
1033                                pDP, DPENUMSESSIONS_PASSWORDREQUIRED );
1034
1035
1036     IDirectPlayX_Release( pDP );
1037     IDirectPlayX_Release( pDP_server );
1038
1039 }
1040
1041
1042 START_TEST(dplayx)
1043 {
1044     CoInitialize( NULL );
1045
1046     test_DirectPlayCreate();
1047     test_EnumConnections();
1048     test_InitializeConnection();
1049
1050     test_GetCaps();
1051     test_Open();
1052
1053     CoUninitialize();
1054 }