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 #define COBJMACROS 21 #include "wine/test.h" 22 #include <stdio.h> 23 #define INITGUID 24 #include <dplay.h> 25 #include <dplobby.h> 26 #include <netfw.h> 27 28 static HRESULT (WINAPI *pDirectPlayEnumerateA)( LPDPENUMDPCALLBACKA, void* ); 29 static HRESULT (WINAPI *pDirectPlayEnumerateW)( LPDPENUMDPCALLBACKW, void* ); 30 static HRESULT (WINAPI *pDirectPlayCreate)( GUID *GUID, LPDIRECTPLAY *lplpDP, IUnknown *pUnk ); 31 32 #define check(expected, result) \ 33 ok( (expected) == (result), \ 34 "expected=%d got=%d\n", \ 35 (int)(expected), (int)(result) ); 36 #define checkLP(expected, result) \ 37 ok( (expected) == (result), \ 38 "expected=%p got=%p\n", \ 39 expected, result ); 40 #define checkHR(expected, result) \ 41 ok( (expected) == (result), \ 42 "expected=%s got=%s\n", \ 43 dpResult2str(expected), dpResult2str(result) ); 44 #define checkStr(expected, result) \ 45 ok( (result != NULL) && (!strcmp(expected, result)), \ 46 "expected=%s got=%s\n", \ 47 expected, result ); 48 #define checkFlags(expected, result, flags) \ 49 ok( (expected) == (result), \ 50 "expected=0x%08x(%s) got=0x%08x(%s)\n", \ 51 expected, dwFlags2str(expected, flags), \ 52 result, dwFlags2str(result, flags) ); 53 #define checkGuid(expected, result) \ 54 ok( IsEqualGUID(expected, result), \ 55 "expected=%s got=%s\n", \ 56 Guid2str(expected), Guid2str(result) ); 57 #define checkConv(expected, result, function) \ 58 ok( (expected) == (result), \ 59 "expected=0x%08x(%s) got=0x%08x(%s)\n", \ 60 expected, function(expected), \ 61 result, function(result) ); 62 63 64 DEFINE_GUID(appGuid, 0xbdcfe03e, 0xf0ec, 0x415b, 0x82, 0x11, 0x6f, 0x86, 0xd8, 0x19, 0x7f, 0xe1); 65 DEFINE_GUID(appGuid2, 0x93417d3f, 0x7d26, 0x46ba, 0xb5, 0x76, 0xfe, 0x4b, 0x20, 0xbb, 0xad, 0x70); 66 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0); 67 DEFINE_GUID(invalid_guid, 0x7b48b707, 0x0034, 0xc000, 0x02, 0x00, 0x00, 0x00, 0xec, 0xf6, 0x32, 0x00); 68 69 70 typedef struct tagCallbackData 71 { 72 IDirectPlay4 *pDP; 73 UINT dwCounter1, dwCounter2; 74 DWORD dwFlags; 75 char szTrace1[1024], szTrace2[1024]; 76 DPID *dpid; 77 UINT dpidSize; 78 } CallbackData, *lpCallbackData; 79 80 struct provider_data 81 { 82 int call_count; 83 GUID *guid_ptr[10]; 84 GUID guid_data[10]; 85 BOOL ret_value; 86 }; 87 88 static LPSTR get_temp_buffer(void) 89 { 90 static UINT index = 0; 91 static char buff[10][256]; 92 93 index = (index + 1) % 10; 94 *buff[index] = 0; 95 96 return buff[index]; 97 } 98 99 100 static LPCSTR Guid2str(const GUID *guid) 101 { 102 if (!guid) return "(null)"; 103 104 /* Service providers */ 105 if (IsEqualGUID(guid, &DPSPGUID_IPX)) 106 return "DPSPGUID_IPX"; 107 if (IsEqualGUID(guid, &DPSPGUID_TCPIP)) 108 return "DPSPGUID_TCPIP"; 109 if (IsEqualGUID(guid, &DPSPGUID_SERIAL)) 110 return "DPSPGUID_SERIAL"; 111 if (IsEqualGUID(guid, &DPSPGUID_MODEM)) 112 return "DPSPGUID_MODEM"; 113 /* DirectPlay Address IDs */ 114 if (IsEqualGUID(guid, &DPAID_TotalSize)) 115 return "DPAID_TotalSize"; 116 if (IsEqualGUID(guid, &DPAID_ServiceProvider)) 117 return "DPAID_ServiceProvider"; 118 if (IsEqualGUID(guid, &DPAID_LobbyProvider)) 119 return "DPAID_LobbyProvider"; 120 if (IsEqualGUID(guid, &DPAID_Phone)) 121 return "DPAID_Phone"; 122 if (IsEqualGUID(guid, &DPAID_PhoneW)) 123 return "DPAID_PhoneW"; 124 if (IsEqualGUID(guid, &DPAID_Modem)) 125 return "DPAID_Modem"; 126 if (IsEqualGUID(guid, &DPAID_ModemW)) 127 return "DPAID_ModemW"; 128 if (IsEqualGUID(guid, &DPAID_INet)) 129 return "DPAID_INet"; 130 if (IsEqualGUID(guid, &DPAID_INetW)) 131 return "DPAID_INetW"; 132 if (IsEqualGUID(guid, &DPAID_INetPort)) 133 return "DPAID_INetPort"; 134 if (IsEqualGUID(guid, &DPAID_ComPort)) 135 return "DPAID_ComPort"; 136 137 return wine_dbgstr_guid(guid); 138 } 139 140 141 static LPCSTR dpResult2str(HRESULT hr) 142 { 143 switch (hr) 144 { 145 case DP_OK: return "DP_OK"; 146 case DPERR_ALREADYINITIALIZED: return "DPERR_ALREADYINITIALIZED"; 147 case DPERR_ACCESSDENIED: return "DPERR_ACCESSDENIED"; 148 case DPERR_ACTIVEPLAYERS: return "DPERR_ACTIVEPLAYERS"; 149 case DPERR_BUFFERTOOSMALL: return "DPERR_BUFFERTOOSMALL"; 150 case DPERR_CANTADDPLAYER: return "DPERR_CANTADDPLAYER"; 151 case DPERR_CANTCREATEGROUP: return "DPERR_CANTCREATEGROUP"; 152 case DPERR_CANTCREATEPLAYER: return "DPERR_CANTCREATEPLAYER"; 153 case DPERR_CANTCREATESESSION: return "DPERR_CANTCREATESESSION"; 154 case DPERR_CAPSNOTAVAILABLEYET: return "DPERR_CAPSNOTAVAILABLEYET"; 155 case DPERR_EXCEPTION: return "DPERR_EXCEPTION"; 156 case DPERR_GENERIC: return "DPERR_GENERIC"; 157 case DPERR_INVALIDFLAGS: return "DPERR_INVALIDFLAGS"; 158 case DPERR_INVALIDOBJECT: return "DPERR_INVALIDOBJECT"; 159 case DPERR_INVALIDPARAMS: return "DPERR_INVALIDPARAMS"; 160 /* symbol with the same value: DPERR_INVALIDPARAM */ 161 case DPERR_INVALIDPLAYER: return "DPERR_INVALIDPLAYER"; 162 case DPERR_INVALIDGROUP: return "DPERR_INVALIDGROUP"; 163 case DPERR_NOCAPS: return "DPERR_NOCAPS"; 164 case DPERR_NOCONNECTION: return "DPERR_NOCONNECTION"; 165 case DPERR_NOMEMORY: return "DPERR_NOMEMORY"; 166 /* symbol with the same value: DPERR_OUTOFMEMORY */ 167 case DPERR_NOMESSAGES: return "DPERR_NOMESSAGES"; 168 case DPERR_NONAMESERVERFOUND: return "DPERR_NONAMESERVERFOUND"; 169 case DPERR_NOPLAYERS: return "DPERR_NOPLAYERS"; 170 case DPERR_NOSESSIONS: return "DPERR_NOSESSIONS"; 171 case DPERR_PENDING: return "DPERR_PENDING"; 172 case DPERR_SENDTOOBIG: return "DPERR_SENDTOOBIG"; 173 case DPERR_TIMEOUT: return "DPERR_TIMEOUT"; 174 case DPERR_UNAVAILABLE: return "DPERR_UNAVAILABLE"; 175 case DPERR_UNSUPPORTED: return "DPERR_UNSUPPORTED"; 176 case DPERR_BUSY: return "DPERR_BUSY"; 177 case DPERR_USERCANCEL: return "DPERR_USERCANCEL"; 178 case DPERR_NOINTERFACE: return "DPERR_NOINTERFACE"; 179 case DPERR_CANNOTCREATESERVER: return "DPERR_CANNOTCREATESERVER"; 180 case DPERR_PLAYERLOST: return "DPERR_PLAYERLOST"; 181 case DPERR_SESSIONLOST: return "DPERR_SESSIONLOST"; 182 case DPERR_UNINITIALIZED: return "DPERR_UNINITIALIZED"; 183 case DPERR_NONEWPLAYERS: return "DPERR_NONEWPLAYERS"; 184 case DPERR_INVALIDPASSWORD: return "DPERR_INVALIDPASSWORD"; 185 case DPERR_CONNECTING: return "DPERR_CONNECTING"; 186 case DPERR_CONNECTIONLOST: return "DPERR_CONNECTIONLOST"; 187 case DPERR_UNKNOWNMESSAGE: return "DPERR_UNKNOWNMESSAGE"; 188 case DPERR_CANCELFAILED: return "DPERR_CANCELFAILED"; 189 case DPERR_INVALIDPRIORITY: return "DPERR_INVALIDPRIORITY"; 190 case DPERR_NOTHANDLED: return "DPERR_NOTHANDLED"; 191 case DPERR_CANCELLED: return "DPERR_CANCELLED"; 192 case DPERR_ABORTED: return "DPERR_ABORTED"; 193 case DPERR_BUFFERTOOLARGE: return "DPERR_BUFFERTOOLARGE"; 194 case DPERR_CANTCREATEPROCESS: return "DPERR_CANTCREATEPROCESS"; 195 case DPERR_APPNOTSTARTED: return "DPERR_APPNOTSTARTED"; 196 case DPERR_INVALIDINTERFACE: return "DPERR_INVALIDINTERFACE"; 197 case DPERR_NOSERVICEPROVIDER: return "DPERR_NOSERVICEPROVIDER"; 198 case DPERR_UNKNOWNAPPLICATION: return "DPERR_UNKNOWNAPPLICATION"; 199 case DPERR_NOTLOBBIED: return "DPERR_NOTLOBBIED"; 200 case DPERR_SERVICEPROVIDERLOADED: return "DPERR_SERVICEPROVIDERLOADED"; 201 case DPERR_ALREADYREGISTERED: return "DPERR_ALREADYREGISTERED"; 202 case DPERR_NOTREGISTERED: return "DPERR_NOTREGISTERED"; 203 case DPERR_AUTHENTICATIONFAILED: return "DPERR_AUTHENTICATIONFAILED"; 204 case DPERR_CANTLOADSSPI: return "DPERR_CANTLOADSSPI"; 205 case DPERR_ENCRYPTIONFAILED: return "DPERR_ENCRYPTIONFAILED"; 206 case DPERR_SIGNFAILED: return "DPERR_SIGNFAILED"; 207 case DPERR_CANTLOADSECURITYPACKAGE: return "DPERR_CANTLOADSECURITYPACKAGE"; 208 case DPERR_ENCRYPTIONNOTSUPPORTED: return "DPERR_ENCRYPTIONNOTSUPPORTED"; 209 case DPERR_CANTLOADCAPI: return "DPERR_CANTLOADCAPI"; 210 case DPERR_NOTLOGGEDIN: return "DPERR_NOTLOGGEDIN"; 211 case DPERR_LOGONDENIED: return "DPERR_LOGONDENIED"; 212 case CLASS_E_NOAGGREGATION: return "CLASS_E_NOAGGREGATION"; 213 214 default: 215 { 216 LPSTR buffer = get_temp_buffer(); 217 sprintf( buffer, "%d", HRESULT_CODE(hr) ); 218 return buffer; 219 } 220 } 221 } 222 223 static LPCSTR dpMsgType2str(DWORD dwType) 224 { 225 switch(dwType) 226 { 227 case DPSYS_CREATEPLAYERORGROUP: return "DPSYS_CREATEPLAYERORGROUP"; 228 case DPSYS_DESTROYPLAYERORGROUP: return "DPSYS_DESTROYPLAYERORGROUP"; 229 case DPSYS_ADDPLAYERTOGROUP: return "DPSYS_ADDPLAYERTOGROUP"; 230 case DPSYS_DELETEPLAYERFROMGROUP: return "DPSYS_DELETEPLAYERFROMGROUP"; 231 case DPSYS_SESSIONLOST: return "DPSYS_SESSIONLOST"; 232 case DPSYS_HOST: return "DPSYS_HOST"; 233 case DPSYS_SETPLAYERORGROUPDATA: return "DPSYS_SETPLAYERORGROUPDATA"; 234 case DPSYS_SETPLAYERORGROUPNAME: return "DPSYS_SETPLAYERORGROUPNAME"; 235 case DPSYS_SETSESSIONDESC: return "DPSYS_SETSESSIONDESC"; 236 case DPSYS_ADDGROUPTOGROUP: return "DPSYS_ADDGROUPTOGROUP"; 237 case DPSYS_DELETEGROUPFROMGROUP: return "DPSYS_DELETEGROUPFROMGROUP"; 238 case DPSYS_SECUREMESSAGE: return "DPSYS_SECUREMESSAGE"; 239 case DPSYS_STARTSESSION: return "DPSYS_STARTSESSION"; 240 case DPSYS_CHAT: return "DPSYS_DPSYS_CHAT"; 241 case DPSYS_SETGROUPOWNER: return "DPSYS_SETGROUPOWNER"; 242 case DPSYS_SENDCOMPLETE: return "DPSYS_SENDCOMPLETE"; 243 244 default: return "UNKNOWN"; 245 } 246 } 247 248 static LPCSTR dwFlags2str(DWORD dwFlags, DWORD flagType) 249 { 250 251 #define FLAGS_DPCONNECTION (1<<0) 252 #define FLAGS_DPENUMPLAYERS (1<<1) 253 #define FLAGS_DPENUMGROUPS (1<<2) 254 #define FLAGS_DPPLAYER (1<<3) 255 #define FLAGS_DPGROUP (1<<4) 256 #define FLAGS_DPENUMSESSIONS (1<<5) 257 #define FLAGS_DPGETCAPS (1<<6) 258 #define FLAGS_DPGET (1<<7) 259 #define FLAGS_DPRECEIVE (1<<8) 260 #define FLAGS_DPSEND (1<<9) 261 #define FLAGS_DPSET (1<<10) 262 #define FLAGS_DPMESSAGEQUEUE (1<<11) 263 #define FLAGS_DPCONNECT (1<<12) 264 #define FLAGS_DPOPEN (1<<13) 265 #define FLAGS_DPSESSION (1<<14) 266 #define FLAGS_DPLCONNECTION (1<<15) 267 #define FLAGS_DPESC (1<<16) 268 #define FLAGS_DPCAPS (1<<17) 269 270 LPSTR flags = get_temp_buffer(); 271 272 /* EnumConnections */ 273 274 if (flagType & FLAGS_DPCONNECTION) 275 { 276 if (dwFlags & DPCONNECTION_DIRECTPLAY) 277 strcat(flags, "DPCONNECTION_DIRECTPLAY,"); 278 if (dwFlags & DPCONNECTION_DIRECTPLAYLOBBY) 279 strcat(flags, "DPCONNECTION_DIRECTPLAYLOBBY,"); 280 } 281 282 /* EnumPlayers, 283 EnumGroups */ 284 285 if (flagType & FLAGS_DPENUMPLAYERS) 286 { 287 if (dwFlags == DPENUMPLAYERS_ALL) 288 strcat(flags, "DPENUMPLAYERS_ALL,"); 289 if (dwFlags & DPENUMPLAYERS_LOCAL) 290 strcat(flags, "DPENUMPLAYERS_LOCAL,"); 291 if (dwFlags & DPENUMPLAYERS_REMOTE) 292 strcat(flags, "DPENUMPLAYERS_REMOTE,"); 293 if (dwFlags & DPENUMPLAYERS_GROUP) 294 strcat(flags, "DPENUMPLAYERS_GROUP,"); 295 if (dwFlags & DPENUMPLAYERS_SESSION) 296 strcat(flags, "DPENUMPLAYERS_SESSION,"); 297 if (dwFlags & DPENUMPLAYERS_SERVERPLAYER) 298 strcat(flags, "DPENUMPLAYERS_SERVERPLAYER,"); 299 if (dwFlags & DPENUMPLAYERS_SPECTATOR) 300 strcat(flags, "DPENUMPLAYERS_SPECTATOR,"); 301 if (dwFlags & DPENUMPLAYERS_OWNER) 302 strcat(flags, "DPENUMPLAYERS_OWNER,"); 303 } 304 if (flagType & FLAGS_DPENUMGROUPS) 305 { 306 if (dwFlags == DPENUMGROUPS_ALL) 307 strcat(flags, "DPENUMGROUPS_ALL,"); 308 if (dwFlags & DPENUMPLAYERS_LOCAL) 309 strcat(flags, "DPENUMGROUPS_LOCAL,"); 310 if (dwFlags & DPENUMPLAYERS_REMOTE) 311 strcat(flags, "DPENUMGROUPS_REMOTE,"); 312 if (dwFlags & DPENUMPLAYERS_GROUP) 313 strcat(flags, "DPENUMGROUPS_GROUP,"); 314 if (dwFlags & DPENUMPLAYERS_SESSION) 315 strcat(flags, "DPENUMGROUPS_SESSION,"); 316 if (dwFlags & DPENUMGROUPS_SHORTCUT) 317 strcat(flags, "DPENUMGROUPS_SHORTCUT,"); 318 if (dwFlags & DPENUMGROUPS_STAGINGAREA) 319 strcat(flags, "DPENUMGROUPS_STAGINGAREA,"); 320 if (dwFlags & DPENUMGROUPS_HIDDEN) 321 strcat(flags, "DPENUMGROUPS_HIDDEN,"); 322 } 323 324 /* CreatePlayer */ 325 326 if (flagType & FLAGS_DPPLAYER) 327 { 328 if (dwFlags & DPPLAYER_SERVERPLAYER) 329 strcat(flags, "DPPLAYER_SERVERPLAYER,"); 330 if (dwFlags & DPPLAYER_SPECTATOR) 331 strcat(flags, "DPPLAYER_SPECTATOR,"); 332 if (dwFlags & DPPLAYER_LOCAL) 333 strcat(flags, "DPPLAYER_LOCAL,"); 334 if (dwFlags & DPPLAYER_OWNER) 335 strcat(flags, "DPPLAYER_OWNER,"); 336 } 337 338 /* CreateGroup */ 339 340 if (flagType & FLAGS_DPGROUP) 341 { 342 if (dwFlags & DPGROUP_STAGINGAREA) 343 strcat(flags, "DPGROUP_STAGINGAREA,"); 344 if (dwFlags & DPGROUP_LOCAL) 345 strcat(flags, "DPGROUP_LOCAL,"); 346 if (dwFlags & DPGROUP_HIDDEN) 347 strcat(flags, "DPGROUP_HIDDEN,"); 348 } 349 350 /* EnumSessions */ 351 352 if (flagType & FLAGS_DPENUMSESSIONS) 353 { 354 if (dwFlags & DPENUMSESSIONS_AVAILABLE) 355 strcat(flags, "DPENUMSESSIONS_AVAILABLE,"); 356 if (dwFlags & DPENUMSESSIONS_ALL) 357 strcat(flags, "DPENUMSESSIONS_ALL,"); 358 if (dwFlags & DPENUMSESSIONS_ASYNC) 359 strcat(flags, "DPENUMSESSIONS_ASYNC,"); 360 if (dwFlags & DPENUMSESSIONS_STOPASYNC) 361 strcat(flags, "DPENUMSESSIONS_STOPASYNC,"); 362 if (dwFlags & DPENUMSESSIONS_PASSWORDREQUIRED) 363 strcat(flags, "DPENUMSESSIONS_PASSWORDREQUIRED,"); 364 if (dwFlags & DPENUMSESSIONS_RETURNSTATUS) 365 strcat(flags, "DPENUMSESSIONS_RETURNSTATUS,"); 366 } 367 368 /* GetCaps, 369 GetPlayerCaps */ 370 371 if (flagType & FLAGS_DPGETCAPS) 372 { 373 if (dwFlags & DPGETCAPS_GUARANTEED) 374 strcat(flags, "DPGETCAPS_GUARANTEED,"); 375 } 376 377 /* GetGroupData, 378 GetPlayerData */ 379 380 if (flagType & FLAGS_DPGET) 381 { 382 if (dwFlags == DPGET_REMOTE) 383 strcat(flags, "DPGET_REMOTE,"); 384 if (dwFlags & DPGET_LOCAL) 385 strcat(flags, "DPGET_LOCAL,"); 386 } 387 388 /* Receive */ 389 390 if (flagType & FLAGS_DPRECEIVE) 391 { 392 if (dwFlags & DPRECEIVE_ALL) 393 strcat(flags, "DPRECEIVE_ALL,"); 394 if (dwFlags & DPRECEIVE_TOPLAYER) 395 strcat(flags, "DPRECEIVE_TOPLAYER,"); 396 if (dwFlags & DPRECEIVE_FROMPLAYER) 397 strcat(flags, "DPRECEIVE_FROMPLAYER,"); 398 if (dwFlags & DPRECEIVE_PEEK) 399 strcat(flags, "DPRECEIVE_PEEK,"); 400 } 401 402 /* Send */ 403 404 if (flagType & FLAGS_DPSEND) 405 { 406 /*if (dwFlags == DPSEND_NONGUARANTEED) 407 strcat(flags, "DPSEND_NONGUARANTEED,");*/ 408 if (dwFlags == DPSEND_MAX_PRIORITY) /* = DPSEND_MAX_PRI */ 409 { 410 strcat(flags, "DPSEND_MAX_PRIORITY,"); 411 } 412 else 413 { 414 if (dwFlags & DPSEND_GUARANTEED) 415 strcat(flags, "DPSEND_GUARANTEED,"); 416 if (dwFlags & DPSEND_HIGHPRIORITY) 417 strcat(flags, "DPSEND_HIGHPRIORITY,"); 418 if (dwFlags & DPSEND_OPENSTREAM) 419 strcat(flags, "DPSEND_OPENSTREAM,"); 420 if (dwFlags & DPSEND_CLOSESTREAM) 421 strcat(flags, "DPSEND_CLOSESTREAM,"); 422 if (dwFlags & DPSEND_SIGNED) 423 strcat(flags, "DPSEND_SIGNED,"); 424 if (dwFlags & DPSEND_ENCRYPTED) 425 strcat(flags, "DPSEND_ENCRYPTED,"); 426 if (dwFlags & DPSEND_LOBBYSYSTEMMESSAGE) 427 strcat(flags, "DPSEND_LOBBYSYSTEMMESSAGE,"); 428 if (dwFlags & DPSEND_ASYNC) 429 strcat(flags, "DPSEND_ASYNC,"); 430 if (dwFlags & DPSEND_NOSENDCOMPLETEMSG) 431 strcat(flags, "DPSEND_NOSENDCOMPLETEMSG,"); 432 } 433 } 434 435 /* SetGroupData, 436 SetGroupName, 437 SetPlayerData, 438 SetPlayerName, 439 SetSessionDesc */ 440 441 if (flagType & FLAGS_DPSET) 442 { 443 if (dwFlags == DPSET_REMOTE) 444 strcat(flags, "DPSET_REMOTE,"); 445 if (dwFlags & DPSET_LOCAL) 446 strcat(flags, "DPSET_LOCAL,"); 447 if (dwFlags & DPSET_GUARANTEED) 448 strcat(flags, "DPSET_GUARANTEED,"); 449 } 450 451 /* GetMessageQueue */ 452 453 if (flagType & FLAGS_DPMESSAGEQUEUE) 454 { 455 if (dwFlags & DPMESSAGEQUEUE_SEND) 456 strcat(flags, "DPMESSAGEQUEUE_SEND,"); 457 if (dwFlags & DPMESSAGEQUEUE_RECEIVE) 458 strcat(flags, "DPMESSAGEQUEUE_RECEIVE,"); 459 } 460 461 /* Connect */ 462 463 if (flagType & FLAGS_DPCONNECT) 464 { 465 if (dwFlags & DPCONNECT_RETURNSTATUS) 466 strcat(flags, "DPCONNECT_RETURNSTATUS,"); 467 } 468 469 /* Open */ 470 471 if (flagType & FLAGS_DPOPEN) 472 { 473 if (dwFlags & DPOPEN_JOIN) 474 strcat(flags, "DPOPEN_JOIN,"); 475 if (dwFlags & DPOPEN_CREATE) 476 strcat(flags, "DPOPEN_CREATE,"); 477 if (dwFlags & DPOPEN_RETURNSTATUS) 478 strcat(flags, "DPOPEN_RETURNSTATUS,"); 479 } 480 481 /* DPSESSIONDESC2 */ 482 483 if (flagType & FLAGS_DPSESSION) 484 { 485 if (dwFlags & DPSESSION_NEWPLAYERSDISABLED) 486 strcat(flags, "DPSESSION_NEWPLAYERSDISABLED,"); 487 if (dwFlags & DPSESSION_MIGRATEHOST) 488 strcat(flags, "DPSESSION_MIGRATEHOST,"); 489 if (dwFlags & DPSESSION_NOMESSAGEID) 490 strcat(flags, "DPSESSION_NOMESSAGEID,"); 491 if (dwFlags & DPSESSION_JOINDISABLED) 492 strcat(flags, "DPSESSION_JOINDISABLED,"); 493 if (dwFlags & DPSESSION_KEEPALIVE) 494 strcat(flags, "DPSESSION_KEEPALIVE,"); 495 if (dwFlags & DPSESSION_NODATAMESSAGES) 496 strcat(flags, "DPSESSION_NODATAMESSAGES,"); 497 if (dwFlags & DPSESSION_SECURESERVER) 498 strcat(flags, "DPSESSION_SECURESERVER,"); 499 if (dwFlags & DPSESSION_PRIVATE) 500 strcat(flags, "DPSESSION_PRIVATE,"); 501 if (dwFlags & DPSESSION_PASSWORDREQUIRED) 502 strcat(flags, "DPSESSION_PASSWORDREQUIRED,"); 503 if (dwFlags & DPSESSION_MULTICASTSERVER) 504 strcat(flags, "DPSESSION_MULTICASTSERVER,"); 505 if (dwFlags & DPSESSION_CLIENTSERVER) 506 strcat(flags, "DPSESSION_CLIENTSERVER,"); 507 508 if (dwFlags & DPSESSION_DIRECTPLAYPROTOCOL) 509 strcat(flags, "DPSESSION_DIRECTPLAYPROTOCOL,"); 510 if (dwFlags & DPSESSION_NOPRESERVEORDER) 511 strcat(flags, "DPSESSION_NOPRESERVEORDER,"); 512 if (dwFlags & DPSESSION_OPTIMIZELATENCY) 513 strcat(flags, "DPSESSION_OPTIMIZELATENCY,"); 514 515 } 516 517 /* DPLCONNECTION */ 518 519 if (flagType & FLAGS_DPLCONNECTION) 520 { 521 if (dwFlags & DPLCONNECTION_CREATESESSION) 522 strcat(flags, "DPLCONNECTION_CREATESESSION,"); 523 if (dwFlags & DPLCONNECTION_JOINSESSION) 524 strcat(flags, "DPLCONNECTION_JOINSESSION,"); 525 } 526 527 /* EnumSessionsCallback2 */ 528 529 if (flagType & FLAGS_DPESC) 530 { 531 if (dwFlags & DPESC_TIMEDOUT) 532 strcat(flags, "DPESC_TIMEDOUT,"); 533 } 534 535 /* GetCaps, 536 GetPlayerCaps */ 537 538 if (flagType & FLAGS_DPCAPS) 539 { 540 if (dwFlags & DPCAPS_ISHOST) 541 strcat(flags, "DPCAPS_ISHOST,"); 542 if (dwFlags & DPCAPS_GROUPOPTIMIZED) 543 strcat(flags, "DPCAPS_GROUPOPTIMIZED,"); 544 if (dwFlags & DPCAPS_KEEPALIVEOPTIMIZED) 545 strcat(flags, "DPCAPS_KEEPALIVEOPTIMIZED,"); 546 if (dwFlags & DPCAPS_GUARANTEEDOPTIMIZED) 547 strcat(flags, "DPCAPS_GUARANTEEDOPTIMIZED,"); 548 if (dwFlags & DPCAPS_GUARANTEEDSUPPORTED) 549 strcat(flags, "DPCAPS_GUARANTEEDSUPPORTED,"); 550 if (dwFlags & DPCAPS_SIGNINGSUPPORTED) 551 strcat(flags, "DPCAPS_SIGNINGSUPPORTED,"); 552 if (dwFlags & DPCAPS_ENCRYPTIONSUPPORTED) 553 strcat(flags, "DPCAPS_ENCRYPTIONSUPPORTED,"); 554 if (dwFlags & DPCAPS_ASYNCCANCELSUPPORTED) 555 strcat(flags, "DPCAPS_ASYNCCANCELSUPPORTED,"); 556 if (dwFlags & DPCAPS_ASYNCCANCELALLSUPPORTED) 557 strcat(flags, "DPCAPS_ASYNCCANCELALLSUPPORTED,"); 558 if (dwFlags & DPCAPS_SENDTIMEOUTSUPPORTED) 559 strcat(flags, "DPCAPS_SENDTIMEOUTSUPPORTED,"); 560 if (dwFlags & DPCAPS_SENDPRIORITYSUPPORTED) 561 strcat(flags, "DPCAPS_SENDPRIORITYSUPPORTED,"); 562 if (dwFlags & DPCAPS_ASYNCSUPPORTED) 563 strcat(flags, "DPCAPS_ASYNCSUPPORTED,"); 564 565 if (dwFlags & DPPLAYERCAPS_LOCAL) 566 strcat(flags, "DPPLAYERCAPS_LOCAL,"); 567 } 568 569 if ((strlen(flags) == 0) && (dwFlags != 0)) 570 strcpy(flags, "UNKNOWN"); 571 else 572 flags[strlen(flags)-1] = '\0'; 573 574 return flags; 575 } 576 577 static char dpid2char(DPID* dpid, DWORD dpidSize, DPID idPlayer) 578 { 579 UINT i; 580 if ( idPlayer == DPID_SYSMSG ) 581 return 'S'; 582 for (i=0; i<dpidSize; i++) 583 { 584 if ( idPlayer == dpid[i] ) 585 return (char)(i+48); 586 } 587 return '?'; 588 } 589 590 static void check_messages( IDirectPlay4 *pDP, DPID *dpid, DWORD dpidSize, 591 lpCallbackData callbackData ) 592 { 593 /* Retrieves all messages from the queue of pDP, performing tests 594 * to check if we are receiving what we expect. 595 * 596 * Information about the messages is stores in callbackData: 597 * 598 * callbackData->dwCounter1: Number of messages received. 599 * callbackData->szTrace1: Traces for sender and receiver. 600 * We store the position a dpid holds in the dpid array. 601 * Example: 602 * 603 * trace string: "01,02,03,14" 604 * expanded: [ '01', '02', '03', '14' ] 605 * \ \ \ \ 606 * \ \ \ ) message 3: from 1 to 4 607 * \ \ ) message 2: from 0 to 3 608 * \ ) message 1: from 0 to 2 609 * ) message 0: from 0 to 1 610 * 611 * In general terms: 612 * sender of message i = character in place 3*i of the array 613 * receiver of message i = character in place 3*i+1 of the array 614 * 615 * A sender value of 'S' means DPID_SYSMSG, this is, a system message. 616 * 617 * callbackData->szTrace2: Traces for message sizes. 618 */ 619 620 DPID idFrom, idTo; 621 UINT i; 622 DWORD dwDataSize = 1024; 623 LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize ); 624 HRESULT hr; 625 char temp[5]; 626 627 callbackData->szTrace2[0] = '\0'; 628 629 i = 0; 630 while ( DP_OK == (hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, 631 lpData, &dwDataSize )) ) 632 { 633 634 callbackData->szTrace1[ 3*i ] = dpid2char( dpid, dpidSize, idFrom ); 635 callbackData->szTrace1[ 3*i+1 ] = dpid2char( dpid, dpidSize, idTo ); 636 callbackData->szTrace1[ 3*i+2 ] = ','; 637 638 sprintf( temp, "%d,", dwDataSize ); 639 strcat( callbackData->szTrace2, temp ); 640 641 dwDataSize = 1024; 642 ++i; 643 } 644 645 checkHR( DPERR_NOMESSAGES, hr ); 646 647 callbackData->szTrace1[ 3*i ] = '\0'; 648 callbackData->dwCounter1 = i; 649 650 651 HeapFree( GetProcessHeap(), 0, lpData ); 652 } 653 654 static void init_TCPIP_provider( IDirectPlay4 *pDP, LPCSTR strIPAddressString, WORD port ) 655 { 656 657 DPCOMPOUNDADDRESSELEMENT addressElements[3]; 658 LPVOID pAddress = NULL; 659 DWORD dwAddressSize = 0; 660 IDirectPlayLobby3 *pDPL; 661 HRESULT hr; 662 663 hr = CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL, 664 &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL ); 665 ok (SUCCEEDED (hr), "CCI of CLSID_DirectPlayLobby / IID_IDirectPlayLobby3A failed\n"); 666 if (FAILED (hr)) return; 667 668 /* Service provider */ 669 addressElements[0].guidDataType = DPAID_ServiceProvider; 670 addressElements[0].dwDataSize = sizeof(GUID); 671 addressElements[0].lpData = (LPVOID) &DPSPGUID_TCPIP; 672 673 /* IP address string */ 674 addressElements[1].guidDataType = DPAID_INet; 675 addressElements[1].dwDataSize = lstrlenA(strIPAddressString) + 1; 676 addressElements[1].lpData = (LPVOID) strIPAddressString; 677 678 /* Optional Port number */ 679 if( port > 0 ) 680 { 681 addressElements[2].guidDataType = DPAID_INetPort; 682 addressElements[2].dwDataSize = sizeof(WORD); 683 addressElements[2].lpData = &port; 684 } 685 686 687 hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2, 688 NULL, &dwAddressSize ); 689 checkHR( DPERR_BUFFERTOOSMALL, hr ); 690 691 if( hr == DPERR_BUFFERTOOSMALL ) 692 { 693 pAddress = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwAddressSize ); 694 hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2, 695 pAddress, &dwAddressSize ); 696 checkHR( DP_OK, hr ); 697 } 698 699 hr = IDirectPlayX_InitializeConnection( pDP, pAddress, 0 ); 700 checkHR( DP_OK, hr ); 701 702 HeapFree( GetProcessHeap(), 0, pAddress ); 703 IDirectPlayLobby_Release(pDPL); 704 } 705 706 static BOOL CALLBACK EnumSessions_cb_join( LPCDPSESSIONDESC2 lpThisSD, 707 LPDWORD lpdwTimeOut, 708 DWORD dwFlags, 709 LPVOID lpContext ) 710 { 711 IDirectPlay4 *pDP = lpContext; 712 DPSESSIONDESC2 dpsd; 713 HRESULT hr; 714 715 if (dwFlags & DPESC_TIMEDOUT) 716 { 717 return FALSE; 718 } 719 720 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 721 dpsd.dwSize = sizeof(DPSESSIONDESC2); 722 dpsd.guidApplication = appGuid; 723 dpsd.guidInstance = lpThisSD->guidInstance; 724 725 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN ); 726 checkHR( DP_OK, hr ); 727 728 return TRUE; 729 } 730 731 732 /* DirectPlayCreate */ 733 734 static void test_DirectPlayCreate(void) 735 { 736 737 IDirectPlay *pDP; 738 HRESULT hr; 739 740 /* TODO: Check how it behaves with pUnk!=NULL */ 741 742 /* pDP==NULL */ 743 hr = pDirectPlayCreate( NULL, NULL, NULL ); 744 checkHR( DPERR_INVALIDPARAMS, hr ); 745 hr = pDirectPlayCreate( (LPGUID) &GUID_NULL, NULL, NULL ); 746 checkHR( DPERR_INVALIDPARAMS, hr ); 747 hr = pDirectPlayCreate( (LPGUID) &DPSPGUID_TCPIP, NULL, NULL ); 748 checkHR( DPERR_INVALIDPARAMS, hr ); 749 750 /* pUnk==NULL, pDP!=NULL */ 751 hr = pDirectPlayCreate( NULL, &pDP, NULL ); 752 checkHR( DPERR_INVALIDPARAMS, hr ); 753 hr = pDirectPlayCreate( (LPGUID) &GUID_NULL, &pDP, NULL ); 754 checkHR( DP_OK, hr ); 755 if ( hr == DP_OK ) 756 IDirectPlayX_Release( pDP ); 757 hr = pDirectPlayCreate( (LPGUID) &DPSPGUID_TCPIP, &pDP, NULL ); 758 checkHR( DP_OK, hr ); 759 if ( hr == DP_OK ) 760 IDirectPlayX_Release( pDP ); 761 762 } 763 764 static BOOL CALLBACK callback_providersA(GUID* guid, char *name, DWORD major, DWORD minor, void *arg) 765 { 766 struct provider_data *prov = arg; 767 768 if (!prov) return TRUE; 769 770 if (prov->call_count < ARRAY_SIZE(prov->guid_data)) 771 { 772 prov->guid_ptr[prov->call_count] = guid; 773 prov->guid_data[prov->call_count] = *guid; 774 775 prov->call_count++; 776 } 777 778 if (prov->ret_value) /* Only trace when looping all providers */ 779 trace("Provider #%d '%s' (%d.%d)\n", prov->call_count, name, major, minor); 780 return prov->ret_value; 781 } 782 783 static BOOL CALLBACK callback_providersW(GUID* guid, WCHAR *name, DWORD major, DWORD minor, void *arg) 784 { 785 struct provider_data *prov = arg; 786 787 if (!prov) return TRUE; 788 789 if (prov->call_count < ARRAY_SIZE(prov->guid_data)) 790 { 791 prov->guid_ptr[prov->call_count] = guid; 792 prov->guid_data[prov->call_count] = *guid; 793 794 prov->call_count++; 795 } 796 797 return prov->ret_value; 798 } 799 800 static void test_EnumerateProviders(void) 801 { 802 HRESULT hr; 803 int i; 804 struct provider_data arg; 805 806 memset(&arg, 0, sizeof(arg)); 807 arg.ret_value = TRUE; 808 809 hr = pDirectPlayEnumerateA(callback_providersA, NULL); 810 ok(SUCCEEDED(hr), "DirectPlayEnumerateA failed\n"); 811 812 SetLastError(0xdeadbeef); 813 hr = pDirectPlayEnumerateA(NULL, &arg); 814 ok(FAILED(hr), "DirectPlayEnumerateA expected to fail\n"); 815 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got 0x%x\n", GetLastError()); 816 817 SetLastError(0xdeadbeef); 818 hr = pDirectPlayEnumerateA(NULL, NULL); 819 ok(FAILED(hr), "DirectPlayEnumerateA expected to fail\n"); 820 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got 0x%x\n", GetLastError()); 821 822 hr = pDirectPlayEnumerateA(callback_providersA, &arg); 823 ok(SUCCEEDED(hr), "DirectPlayEnumerateA failed\n"); 824 ok(arg.call_count > 0, "Expected at least one valid provider\n"); 825 trace("Found %d providers\n", arg.call_count); 826 827 /* The returned GUID values must have persisted after enumeration (bug 37185) */ 828 for(i = 0; i < arg.call_count; i++) 829 { 830 ok(IsEqualGUID(arg.guid_ptr[i], &arg.guid_data[i]), "#%d Expected equal GUID values\n", i); 831 } 832 833 memset(&arg, 0, sizeof(arg)); 834 arg.ret_value = FALSE; 835 hr = pDirectPlayEnumerateA(callback_providersA, &arg); 836 ok(SUCCEEDED(hr), "DirectPlayEnumerateA failed\n"); 837 ok(arg.call_count == 1, "Expected 1, got %d\n", arg.call_count); 838 839 hr = pDirectPlayEnumerateW(callback_providersW, NULL); 840 ok(SUCCEEDED(hr), "DirectPlayEnumerateW failed\n"); 841 842 SetLastError(0xdeadbeef); 843 hr = pDirectPlayEnumerateW(NULL, &arg); 844 ok(FAILED(hr), "DirectPlayEnumerateW expected to fail\n"); 845 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got 0x%x\n", GetLastError()); 846 847 SetLastError(0xdeadbeef); 848 hr = pDirectPlayEnumerateW(NULL, NULL); 849 ok(FAILED(hr), "DirectPlayEnumerateW expected to fail\n"); 850 ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got 0x%x\n", GetLastError()); 851 852 memset(&arg, 0, sizeof(arg)); 853 arg.ret_value = TRUE; 854 hr = pDirectPlayEnumerateW(callback_providersW, &arg); 855 ok(SUCCEEDED(hr), "DirectPlayEnumerateW failed\n"); 856 ok(arg.call_count > 0, "Expected at least one valid provider\n"); 857 858 /* The returned GUID values must have persisted after enumeration (bug 37185) */ 859 for(i = 0; i < arg.call_count; i++) 860 { 861 ok(IsEqualGUID(arg.guid_ptr[i], &arg.guid_data[i]), "#%d Expected equal GUID values\n", i); 862 } 863 864 memset(&arg, 0, sizeof(arg)); 865 arg.ret_value = FALSE; 866 hr = pDirectPlayEnumerateW(callback_providersW, &arg); 867 ok(SUCCEEDED(hr), "DirectPlayEnumerateW failed\n"); 868 ok(arg.call_count == 1, "Expected 1, got %d\n", arg.call_count); 869 } 870 871 /* EnumConnections */ 872 873 static BOOL CALLBACK EnumAddress_cb2( REFGUID guidDataType, 874 DWORD dwDataSize, 875 LPCVOID lpData, 876 LPVOID lpContext ) 877 { 878 lpCallbackData callbackData = lpContext; 879 880 static REFGUID types[] = { &DPAID_TotalSize, 881 &DPAID_ServiceProvider, 882 &GUID_NULL }; 883 static DWORD sizes[] = { 4, 16, 0 }; 884 static REFGUID sps[] = { &DPSPGUID_SERIAL, &DPSPGUID_MODEM, 885 &DPSPGUID_IPX, &DPSPGUID_TCPIP }; 886 887 888 checkGuid( types[ callbackData->dwCounter2 ], guidDataType ); 889 check( sizes[ callbackData->dwCounter2 ], dwDataSize ); 890 891 if ( IsEqualGUID( types[0], guidDataType ) ) 892 { 893 todo_wine check( 80, *((LPDWORD) lpData) ); 894 } 895 else if ( IsEqualGUID( types[1], guidDataType ) ) 896 { 897 BOOL found = FALSE; 898 int i; 899 for( i=0; i < ARRAY_SIZE(sps) && !found; i++ ) 900 found = IsEqualGUID( sps[i], lpData ); 901 ok( found, "Unknown Address type found %s\n", wine_dbgstr_guid(lpData) ); 902 } 903 904 callbackData->dwCounter2++; 905 906 return TRUE; 907 } 908 909 static BOOL CALLBACK EnumConnections_cb( LPCGUID lpguidSP, 910 LPVOID lpConnection, 911 DWORD dwConnectionSize, 912 LPCDPNAME lpName, 913 DWORD dwFlags, 914 LPVOID lpContext ) 915 { 916 917 lpCallbackData callbackData = lpContext; 918 IDirectPlayLobby *pDPL; 919 HRESULT hr; 920 921 922 if (!callbackData->dwFlags) 923 { 924 callbackData->dwFlags = DPCONNECTION_DIRECTPLAY; 925 } 926 927 checkFlags( callbackData->dwFlags, dwFlags, FLAGS_DPCONNECTION ); 928 929 /* Get info from lpConnection */ 930 hr = CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL, 931 &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL ); 932 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlayLobby / IID_IDirectPlayLobby3A failed\n"); 933 if (FAILED(hr)) 934 return FALSE; 935 936 callbackData->dwCounter2 = 0; 937 IDirectPlayLobby_EnumAddress( pDPL, EnumAddress_cb2, lpConnection, 938 dwConnectionSize, callbackData ); 939 todo_wine check( 3, callbackData->dwCounter2 ); 940 941 callbackData->dwCounter1++; 942 943 IDirectPlayLobby_Release(pDPL); 944 945 return TRUE; 946 } 947 948 static void test_EnumConnections(void) 949 { 950 951 IDirectPlay4 *pDP; 952 CallbackData callbackData; 953 HRESULT hr; 954 955 956 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 957 &IID_IDirectPlay4A, (LPVOID*) &pDP ); 958 959 ok (SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n"); 960 if (FAILED(hr)) return; 961 962 callbackData.dwCounter1 = 0; 963 callbackData.dwFlags = 0; 964 hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb, 965 &callbackData, callbackData.dwFlags ); 966 checkHR( DP_OK, hr ); 967 ok( callbackData.dwCounter1 == 4 || callbackData.dwCounter1 == 3, "got=%d\n", callbackData.dwCounter1 ); 968 969 callbackData.dwCounter1 = 0; 970 callbackData.dwFlags = 0; 971 hr = IDirectPlayX_EnumConnections( pDP, NULL, EnumConnections_cb, 972 &callbackData, callbackData.dwFlags ); 973 checkHR( DP_OK, hr ); 974 ok( callbackData.dwCounter1 == 4 || callbackData.dwCounter1 == 3, "got=%d\n", callbackData.dwCounter1 ); 975 976 callbackData.dwCounter1 = 0; 977 callbackData.dwFlags = 0; 978 hr = IDirectPlayX_EnumConnections( pDP, &appGuid, NULL, 979 &callbackData, callbackData.dwFlags ); 980 checkHR( DPERR_INVALIDPARAMS, hr ); 981 check( 0, callbackData.dwCounter1 ); 982 983 984 /* Flag tests */ 985 callbackData.dwCounter1 = 0; 986 callbackData.dwFlags = DPCONNECTION_DIRECTPLAY; 987 hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb, 988 &callbackData, callbackData.dwFlags ); 989 checkHR( DP_OK, hr ); 990 ok( callbackData.dwCounter1 == 4 || callbackData.dwCounter1 == 3, "got=%d\n", callbackData.dwCounter1 ); 991 992 callbackData.dwCounter1 = 0; 993 callbackData.dwFlags = DPCONNECTION_DIRECTPLAYLOBBY; 994 hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb, 995 &callbackData, callbackData.dwFlags ); 996 checkHR( DP_OK, hr ); 997 check( 0, callbackData.dwCounter1 ); 998 999 callbackData.dwCounter1 = 0; 1000 callbackData.dwFlags = ( DPCONNECTION_DIRECTPLAY | 1001 DPCONNECTION_DIRECTPLAYLOBBY ); 1002 hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb, 1003 &callbackData, callbackData.dwFlags ); 1004 checkHR( DP_OK, hr ); 1005 ok( callbackData.dwCounter1 == 4 || callbackData.dwCounter1 == 3, "got=%d\n", callbackData.dwCounter1 ); 1006 1007 callbackData.dwCounter1 = 0; 1008 callbackData.dwFlags = ~( DPCONNECTION_DIRECTPLAY | 1009 DPCONNECTION_DIRECTPLAYLOBBY ); 1010 hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb, 1011 &callbackData, callbackData.dwFlags ); 1012 checkHR( DPERR_INVALIDFLAGS, hr ); 1013 check( 0, callbackData.dwCounter1 ); 1014 1015 1016 IDirectPlayX_Release( pDP ); 1017 } 1018 1019 /* InitializeConnection */ 1020 1021 static BOOL CALLBACK EnumConnections_cb2( LPCGUID lpguidSP, 1022 LPVOID lpConnection, 1023 DWORD dwConnectionSize, 1024 LPCDPNAME lpName, 1025 DWORD dwFlags, 1026 LPVOID lpContext ) 1027 { 1028 IDirectPlay4 *pDP = lpContext; 1029 HRESULT hr; 1030 1031 /* Incorrect parameters */ 1032 hr = IDirectPlayX_InitializeConnection( pDP, NULL, 1 ); 1033 checkHR( DPERR_INVALIDPARAMS, hr ); 1034 hr = IDirectPlayX_InitializeConnection( pDP, lpConnection, 1 ); 1035 checkHR( DPERR_INVALIDFLAGS, hr ); 1036 1037 /* Normal operation. 1038 We're only interested in ensuring that the TCP/IP provider works */ 1039 1040 if( IsEqualGUID(lpguidSP, &DPSPGUID_TCPIP) ) 1041 { 1042 hr = IDirectPlayX_InitializeConnection( pDP, lpConnection, 0 ); 1043 checkHR( DP_OK, hr ); 1044 hr = IDirectPlayX_InitializeConnection( pDP, lpConnection, 0 ); 1045 checkHR( DPERR_ALREADYINITIALIZED, hr ); 1046 } 1047 1048 return TRUE; 1049 } 1050 1051 static void test_InitializeConnection(void) 1052 { 1053 1054 IDirectPlay4 *pDP; 1055 HRESULT hr; 1056 1057 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 1058 &IID_IDirectPlay4A, (LPVOID*) &pDP ); 1059 1060 ok (SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n"); 1061 if (FAILED(hr)) return; 1062 1063 IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb2, pDP, 0 ); 1064 1065 IDirectPlayX_Release( pDP ); 1066 } 1067 1068 /* GetCaps */ 1069 1070 static void test_GetCaps(void) 1071 { 1072 1073 IDirectPlay4 *pDP; 1074 DPCAPS dpcaps; 1075 DWORD dwFlags; 1076 HRESULT hr; 1077 1078 1079 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 1080 &IID_IDirectPlay4A, (LPVOID*) &pDP ); 1081 ok (SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n"); 1082 if (FAILED(hr)) return; 1083 1084 ZeroMemory( &dpcaps, sizeof(DPCAPS) ); 1085 1086 /* Service provider not ininitialized */ 1087 hr = IDirectPlayX_GetCaps( pDP, &dpcaps, 0 ); 1088 checkHR( DPERR_UNINITIALIZED, hr ); 1089 1090 init_TCPIP_provider( pDP, "127.0.0.1", 0 ); 1091 1092 /* dpcaps not ininitialized */ 1093 hr = IDirectPlayX_GetCaps( pDP, &dpcaps, 0 ); 1094 checkHR( DPERR_INVALIDPARAMS, hr ); 1095 1096 dpcaps.dwSize = sizeof(DPCAPS); 1097 1098 for (dwFlags=0; 1099 dwFlags<=DPGETCAPS_GUARANTEED; 1100 dwFlags+=DPGETCAPS_GUARANTEED) 1101 { 1102 1103 hr = IDirectPlayX_GetCaps( pDP, &dpcaps, dwFlags ); 1104 checkHR( DP_OK, hr ); 1105 check( sizeof(DPCAPS), dpcaps.dwSize ); 1106 check( DPCAPS_ASYNCSUPPORTED | 1107 DPCAPS_GUARANTEEDOPTIMIZED | 1108 DPCAPS_GUARANTEEDSUPPORTED, 1109 dpcaps.dwFlags ); 1110 check( 0, dpcaps.dwMaxQueueSize ); 1111 check( 0, dpcaps.dwHundredBaud ); 1112 check( 500, dpcaps.dwLatency ); 1113 check( 65536, dpcaps.dwMaxLocalPlayers ); 1114 check( 20, dpcaps.dwHeaderLength ); 1115 check( 5000, dpcaps.dwTimeout ); 1116 1117 switch (dwFlags) 1118 { 1119 case 0: 1120 check( 65479, dpcaps.dwMaxBufferSize ); 1121 check( 65536, dpcaps.dwMaxPlayers ); 1122 break; 1123 case DPGETCAPS_GUARANTEED: 1124 check( 1048547, dpcaps.dwMaxBufferSize ); 1125 check( 64, dpcaps.dwMaxPlayers ); 1126 break; 1127 default: break; 1128 } 1129 } 1130 1131 IDirectPlayX_Release( pDP ); 1132 } 1133 1134 static void test_EnumAddressTypes(void) 1135 { 1136 IDirectPlay4 *pDP; 1137 HRESULT hr; 1138 DPCOMPOUNDADDRESSELEMENT addressElements[2]; 1139 LPVOID pAddress = NULL; 1140 DWORD dwAddressSize = 0; 1141 IDirectPlayLobby3 *pDPL; 1142 WORD port = 6001; 1143 1144 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 1145 &IID_IDirectPlay4A, (LPVOID*) &pDP ); 1146 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 1147 if (FAILED(hr)) 1148 return; 1149 1150 hr = CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL, 1151 &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL ); 1152 ok (SUCCEEDED (hr), "CCI of CLSID_DirectPlayLobby / IID_IDirectPlayLobby3A failed\n"); 1153 if (FAILED (hr)) return; 1154 1155 addressElements[0].guidDataType = DPAID_ServiceProvider; 1156 addressElements[0].dwDataSize = sizeof(GUID); 1157 addressElements[0].lpData = (void*) &DPSPGUID_TCPIP; 1158 1159 addressElements[1].guidDataType = invalid_guid; 1160 addressElements[1].dwDataSize = sizeof(WORD); 1161 addressElements[1].lpData = &port; 1162 1163 hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2, NULL, &dwAddressSize ); 1164 checkHR( DPERR_BUFFERTOOSMALL, hr ); 1165 1166 if( hr == DPERR_BUFFERTOOSMALL ) 1167 { 1168 pAddress = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwAddressSize ); 1169 hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2, 1170 pAddress, &dwAddressSize ); 1171 checkHR( DP_OK, hr ); 1172 } 1173 1174 IDirectPlayX_Close(pDP); 1175 IDirectPlayX_Release(pDP); 1176 IDirectPlayLobby_Release(pDPL); 1177 1178 HeapFree( GetProcessHeap(), 0, pAddress ); 1179 } 1180 1181 /* Open */ 1182 1183 static BOOL CALLBACK EnumSessions_cb2( LPCDPSESSIONDESC2 lpThisSD, 1184 LPDWORD lpdwTimeOut, 1185 DWORD dwFlags, 1186 LPVOID lpContext ) 1187 { 1188 IDirectPlay4 *pDP = lpContext; 1189 DPSESSIONDESC2 dpsd; 1190 HRESULT hr; 1191 1192 if (dwFlags & DPESC_TIMEDOUT) 1193 return FALSE; 1194 1195 1196 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 1197 dpsd.dwSize = sizeof(DPSESSIONDESC2); 1198 dpsd.guidApplication = appGuid; 1199 dpsd.guidInstance = lpThisSD->guidInstance; 1200 1201 if ( lpThisSD->dwFlags & DPSESSION_PASSWORDREQUIRED ) 1202 { 1203 /* Incorrect password */ 1204 U2(dpsd).lpszPasswordA = (LPSTR) "sonic boom"; 1205 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN ); 1206 checkHR( DPERR_INVALIDPASSWORD, hr ); 1207 1208 /* Correct password */ 1209 U2(dpsd).lpszPasswordA = (LPSTR) "hadouken"; 1210 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN ); 1211 checkHR( DP_OK, hr ); 1212 } 1213 else 1214 { 1215 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN ); 1216 checkHR( DP_OK, hr ); 1217 } 1218 1219 hr = IDirectPlayX_Close( pDP ); 1220 checkHR( DP_OK, hr ); 1221 1222 return TRUE; 1223 } 1224 1225 static void test_Open(void) 1226 { 1227 1228 IDirectPlay4 *pDP, *pDP_server; 1229 DPSESSIONDESC2 dpsd, dpsd_server; 1230 HRESULT hr; 1231 1232 1233 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 1234 &IID_IDirectPlay4A, (LPVOID*) &pDP_server ); 1235 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 1236 if (FAILED(hr)) return; 1237 1238 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 1239 &IID_IDirectPlay4A, (LPVOID*) &pDP ); 1240 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 1241 if (FAILED(hr)) return; 1242 1243 ZeroMemory( &dpsd_server, sizeof(DPSESSIONDESC2) ); 1244 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 1245 1246 /* Service provider not initialized */ 1247 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE ); 1248 todo_wine checkHR( DPERR_INVALIDPARAMS, hr ); 1249 1250 init_TCPIP_provider( pDP_server, "127.0.0.1", 0 ); 1251 init_TCPIP_provider( pDP, "127.0.0.1", 0 ); 1252 1253 /* Uninitialized dpsd */ 1254 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE ); 1255 checkHR( DPERR_INVALIDPARAMS, hr ); 1256 1257 1258 dpsd_server.dwSize = sizeof(DPSESSIONDESC2); 1259 dpsd_server.guidApplication = appGuid; 1260 dpsd_server.dwMaxPlayers = 10; 1261 1262 1263 /* Regular operation */ 1264 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE ); 1265 todo_wine checkHR( DP_OK, hr ); 1266 1267 /* Opening twice */ 1268 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE ); 1269 todo_wine checkHR( DPERR_ALREADYINITIALIZED, hr ); 1270 1271 /* Session flags */ 1272 IDirectPlayX_Close( pDP_server ); 1273 1274 dpsd_server.dwFlags = DPSESSION_CLIENTSERVER | DPSESSION_MIGRATEHOST; 1275 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE ); 1276 todo_wine checkHR( DPERR_INVALIDFLAGS, hr ); 1277 1278 dpsd_server.dwFlags = DPSESSION_MULTICASTSERVER | DPSESSION_MIGRATEHOST; 1279 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE ); 1280 todo_wine checkHR( DPERR_INVALIDFLAGS, hr ); 1281 1282 dpsd_server.dwFlags = DPSESSION_SECURESERVER | DPSESSION_MIGRATEHOST; 1283 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE ); 1284 todo_wine checkHR( DPERR_INVALIDFLAGS, hr ); 1285 1286 1287 /* Joining sessions */ 1288 /* - Checking how strict dplay is with sizes */ 1289 dpsd.dwSize = 0; 1290 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN ); 1291 checkHR( DPERR_INVALIDPARAMS, hr ); 1292 1293 dpsd.dwSize = sizeof(DPSESSIONDESC2)-1; 1294 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN ); 1295 checkHR( DPERR_INVALIDPARAMS, hr ); 1296 1297 dpsd.dwSize = sizeof(DPSESSIONDESC2)+1; 1298 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN ); 1299 checkHR( DPERR_INVALIDPARAMS, hr ); 1300 1301 dpsd.dwSize = sizeof(DPSESSIONDESC2); 1302 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN ); 1303 todo_wine checkHR( DPERR_NOSESSIONS, hr ); /* Only checks for size, not guids */ 1304 1305 1306 dpsd.guidApplication = appGuid; 1307 dpsd.guidInstance = appGuid; 1308 1309 1310 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN ); 1311 todo_wine checkHR( DPERR_NOSESSIONS, hr ); 1312 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN | DPOPEN_CREATE ); 1313 todo_wine checkHR( DPERR_NOSESSIONS, hr ); /* Second flag is ignored */ 1314 1315 dpsd_server.dwFlags = 0; 1316 1317 1318 /* Join to normal session */ 1319 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE ); 1320 todo_wine checkHR( DP_OK, hr ); 1321 1322 IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb2, pDP, 0 ); 1323 1324 1325 /* Already initialized session */ 1326 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE ); 1327 todo_wine checkHR( DPERR_ALREADYINITIALIZED, hr ); 1328 1329 1330 /* Checking which is the error checking order */ 1331 dpsd_server.dwSize = 0; 1332 1333 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE ); 1334 checkHR( DPERR_INVALIDPARAMS, hr ); 1335 1336 dpsd_server.dwSize = sizeof(DPSESSIONDESC2); 1337 1338 1339 /* Join to protected session */ 1340 IDirectPlayX_Close( pDP_server ); 1341 U2(dpsd_server).lpszPasswordA = (LPSTR) "hadouken"; 1342 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE ); 1343 todo_wine checkHR( DP_OK, hr ); 1344 1345 IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb2, 1346 pDP, DPENUMSESSIONS_PASSWORDREQUIRED ); 1347 1348 1349 IDirectPlayX_Release( pDP ); 1350 IDirectPlayX_Release( pDP_server ); 1351 1352 } 1353 1354 /* EnumSessions */ 1355 1356 static BOOL CALLBACK EnumSessions_cb( LPCDPSESSIONDESC2 lpThisSD, 1357 LPDWORD lpdwTimeOut, 1358 DWORD dwFlags, 1359 LPVOID lpContext ) 1360 { 1361 lpCallbackData callbackData = lpContext; 1362 callbackData->dwCounter1++; 1363 1364 if ( dwFlags & DPESC_TIMEDOUT ) 1365 { 1366 check( TRUE, lpThisSD == NULL ); 1367 return FALSE; 1368 } 1369 check( FALSE, lpThisSD == NULL ); 1370 1371 1372 if ( U2(*lpThisSD).lpszPasswordA != NULL ) 1373 { 1374 check( TRUE, (lpThisSD->dwFlags & DPSESSION_PASSWORDREQUIRED) != 0 ); 1375 } 1376 1377 if ( lpThisSD->dwFlags & DPSESSION_NEWPLAYERSDISABLED ) 1378 { 1379 check( 0, lpThisSD->dwCurrentPlayers ); 1380 } 1381 1382 check( sizeof(*lpThisSD), lpThisSD->dwSize ); 1383 checkLP( NULL, U2(*lpThisSD).lpszPasswordA ); 1384 1385 return TRUE; 1386 } 1387 1388 static IDirectPlay4 *create_session(DPSESSIONDESC2 *lpdpsd) 1389 { 1390 1391 IDirectPlay4 *pDP; 1392 DPNAME name; 1393 DPID dpid; 1394 HRESULT hr; 1395 1396 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 1397 &IID_IDirectPlay4A, (LPVOID*) &pDP ); 1398 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 1399 if (FAILED(hr)) return NULL; 1400 1401 init_TCPIP_provider( pDP, "127.0.0.1", 0 ); 1402 1403 hr = IDirectPlayX_Open( pDP, lpdpsd, DPOPEN_CREATE ); 1404 todo_wine checkHR( DP_OK, hr ); 1405 1406 if ( ! (lpdpsd->dwFlags & DPSESSION_NEWPLAYERSDISABLED) ) 1407 { 1408 ZeroMemory( &name, sizeof(DPNAME) ); 1409 name.dwSize = sizeof(DPNAME); 1410 U1(name).lpszShortNameA = (LPSTR) "bofh"; 1411 1412 hr = IDirectPlayX_CreatePlayer( pDP, &dpid, &name, NULL, NULL, 1413 0, DPPLAYER_SERVERPLAYER ); 1414 todo_wine checkHR( DP_OK, hr ); 1415 } 1416 1417 return pDP; 1418 1419 } 1420 1421 static void test_EnumSessions(void) 1422 { 1423 1424 #define N_SESSIONS 6 1425 1426 IDirectPlay4 *pDP, *pDPserver[N_SESSIONS]; 1427 DPSESSIONDESC2 dpsd, dpsd_server[N_SESSIONS]; 1428 CallbackData callbackData; 1429 HRESULT hr; 1430 UINT i; 1431 1432 1433 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 1434 &IID_IDirectPlay4A, (LPVOID*) &pDP ); 1435 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 1436 if (FAILED(hr)) return; 1437 1438 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 1439 callbackData.dwCounter1 = -1; /* So that after a call to EnumSessions 1440 we get the exact number of sessions */ 1441 callbackData.dwFlags = 0; 1442 1443 1444 /* Service provider not initialized */ 1445 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1446 &callbackData, 0 ); 1447 checkHR( DPERR_UNINITIALIZED, hr ); 1448 1449 1450 init_TCPIP_provider( pDP, "127.0.0.1", 0 ); 1451 1452 1453 /* Session with no size */ 1454 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1455 &callbackData, 0 ); 1456 todo_wine checkHR( DPERR_INVALIDPARAMS, hr ); 1457 1458 if ( hr == DPERR_UNINITIALIZED ) 1459 { 1460 todo_wine win_skip( "EnumSessions not implemented\n" ); 1461 return; 1462 } 1463 1464 dpsd.dwSize = sizeof(DPSESSIONDESC2); 1465 1466 1467 /* No sessions */ 1468 callbackData.dwCounter1 = -1; 1469 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1470 &callbackData, 0 ); 1471 checkHR( DP_OK, hr ); 1472 check( 0, callbackData.dwCounter1 ); 1473 1474 1475 dpsd.guidApplication = appGuid; 1476 1477 /* Set up sessions */ 1478 for (i=0; i<N_SESSIONS; i++) 1479 { 1480 memcpy( &dpsd_server[i], &dpsd, sizeof(DPSESSIONDESC2) ); 1481 } 1482 1483 U1(dpsd_server[0]).lpszSessionNameA = (LPSTR) "normal"; 1484 dpsd_server[0].dwFlags = ( DPSESSION_CLIENTSERVER | 1485 DPSESSION_DIRECTPLAYPROTOCOL ); 1486 dpsd_server[0].dwMaxPlayers = 10; 1487 1488 U1(dpsd_server[1]).lpszSessionNameA = (LPSTR) "full"; 1489 dpsd_server[1].dwFlags = ( DPSESSION_CLIENTSERVER | 1490 DPSESSION_DIRECTPLAYPROTOCOL ); 1491 dpsd_server[1].dwMaxPlayers = 1; 1492 1493 U1(dpsd_server[2]).lpszSessionNameA = (LPSTR) "no new"; 1494 dpsd_server[2].dwFlags = ( DPSESSION_CLIENTSERVER | 1495 DPSESSION_DIRECTPLAYPROTOCOL | 1496 DPSESSION_NEWPLAYERSDISABLED ); 1497 dpsd_server[2].dwMaxPlayers = 10; 1498 1499 U1(dpsd_server[3]).lpszSessionNameA = (LPSTR) "no join"; 1500 dpsd_server[3].dwFlags = ( DPSESSION_CLIENTSERVER | 1501 DPSESSION_DIRECTPLAYPROTOCOL | 1502 DPSESSION_JOINDISABLED ); 1503 dpsd_server[3].dwMaxPlayers = 10; 1504 1505 U1(dpsd_server[4]).lpszSessionNameA = (LPSTR) "private"; 1506 dpsd_server[4].dwFlags = ( DPSESSION_CLIENTSERVER | 1507 DPSESSION_DIRECTPLAYPROTOCOL | 1508 DPSESSION_PRIVATE ); 1509 dpsd_server[4].dwMaxPlayers = 10; 1510 U2(dpsd_server[4]).lpszPasswordA = (LPSTR) "password"; 1511 1512 U1(dpsd_server[5]).lpszSessionNameA = (LPSTR) "protected"; 1513 dpsd_server[5].dwFlags = ( DPSESSION_CLIENTSERVER | 1514 DPSESSION_DIRECTPLAYPROTOCOL | 1515 DPSESSION_PASSWORDREQUIRED ); 1516 dpsd_server[5].dwMaxPlayers = 10; 1517 U2(dpsd_server[5]).lpszPasswordA = (LPSTR) "password"; 1518 1519 1520 for (i=0; i<N_SESSIONS; i++) 1521 { 1522 pDPserver[i] = create_session( &dpsd_server[i] ); 1523 if (!pDPserver[i]) return; 1524 } 1525 1526 1527 /* Invalid params */ 1528 callbackData.dwCounter1 = -1; 1529 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1530 &callbackData, -1 ); 1531 checkHR( DPERR_INVALIDPARAMS, hr ); 1532 1533 hr = IDirectPlayX_EnumSessions( pDP, NULL, 0, EnumSessions_cb, 1534 &callbackData, 0 ); 1535 checkHR( DPERR_INVALIDPARAMS, hr ); 1536 1537 check( -1, callbackData.dwCounter1 ); 1538 1539 1540 /* Flag tests */ 1541 callbackData.dwFlags = DPENUMSESSIONS_ALL; /* Doesn't list private, 1542 protected */ 1543 callbackData.dwCounter1 = -1; 1544 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1545 &callbackData, callbackData.dwFlags ); 1546 checkHR( DP_OK, hr ); 1547 check( N_SESSIONS-2, callbackData.dwCounter1 ); 1548 1549 /* Doesn't list private */ 1550 callbackData.dwFlags = ( DPENUMSESSIONS_ALL | 1551 DPENUMSESSIONS_PASSWORDREQUIRED ); 1552 callbackData.dwCounter1 = -1; 1553 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1554 &callbackData, callbackData.dwFlags ); 1555 checkHR( DP_OK, hr ); 1556 check( N_SESSIONS-1, callbackData.dwCounter1 ); 1557 1558 /* Doesn't list full, no new, no join, private, protected */ 1559 callbackData.dwFlags = DPENUMSESSIONS_AVAILABLE; 1560 callbackData.dwCounter1 = -1; 1561 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1562 &callbackData, callbackData.dwFlags ); 1563 checkHR( DP_OK, hr ); 1564 check( N_SESSIONS-5, callbackData.dwCounter1 ); 1565 1566 /* Like with DPENUMSESSIONS_AVAILABLE */ 1567 callbackData.dwFlags = 0; 1568 callbackData.dwCounter1 = -1; 1569 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1570 &callbackData, callbackData.dwFlags ); 1571 checkHR( DP_OK, hr ); 1572 check( N_SESSIONS-5, callbackData.dwCounter1 ); 1573 1574 /* Doesn't list full, no new, no join, private */ 1575 callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED; 1576 callbackData.dwCounter1 = -1; 1577 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1578 &callbackData, callbackData.dwFlags ); 1579 checkHR( DP_OK, hr ); 1580 check( N_SESSIONS-4, callbackData.dwCounter1 ); 1581 1582 1583 /* Async enumeration */ 1584 callbackData.dwFlags = DPENUMSESSIONS_ASYNC; 1585 callbackData.dwCounter1 = -1; 1586 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1587 &callbackData, callbackData.dwFlags ); 1588 checkHR( DP_OK, hr ); 1589 check( N_SESSIONS-4, callbackData.dwCounter1 ); /* Read cache of last 1590 sync enumeration */ 1591 1592 callbackData.dwFlags = DPENUMSESSIONS_STOPASYNC; 1593 callbackData.dwCounter1 = -1; 1594 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1595 &callbackData, callbackData.dwFlags ); 1596 checkHR( DP_OK, hr ); 1597 check( 0, callbackData.dwCounter1 ); /* Stop enumeration */ 1598 1599 callbackData.dwFlags = DPENUMSESSIONS_ASYNC; 1600 callbackData.dwCounter1 = -1; 1601 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1602 &callbackData, callbackData.dwFlags ); 1603 checkHR( DP_OK, hr ); 1604 check( 0, callbackData.dwCounter1 ); /* Start enumeration */ 1605 1606 Sleep(500); /* Give time to fill the cache */ 1607 1608 callbackData.dwFlags = DPENUMSESSIONS_ASYNC; 1609 callbackData.dwCounter1 = -1; 1610 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1611 &callbackData, callbackData.dwFlags ); 1612 checkHR( DP_OK, hr ); 1613 check( N_SESSIONS-5, callbackData.dwCounter1 ); /* Retrieve results */ 1614 1615 callbackData.dwFlags = DPENUMSESSIONS_STOPASYNC; 1616 callbackData.dwCounter1 = -1; 1617 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1618 &callbackData, callbackData.dwFlags ); 1619 checkHR( DP_OK, hr ); 1620 check( 0, callbackData.dwCounter1 ); /* Stop enumeration */ 1621 1622 1623 /* Specific tests for passworded sessions */ 1624 1625 for (i=0; i<N_SESSIONS; i++) 1626 { 1627 IDirectPlayX_Release( pDPserver[i] ); 1628 } 1629 1630 /* - Only session password set */ 1631 for (i=4;i<=5;i++) 1632 { 1633 U2(dpsd_server[i]).lpszPasswordA = (LPSTR) "password"; 1634 dpsd_server[i].dwFlags = 0; 1635 pDPserver[i] = create_session( &dpsd_server[i] ); 1636 } 1637 1638 callbackData.dwFlags = 0; 1639 callbackData.dwCounter1 = -1; 1640 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1641 &callbackData, callbackData.dwFlags ); 1642 checkHR( DP_OK, hr ); 1643 check( 0, callbackData.dwCounter1 ); 1644 1645 callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED; 1646 callbackData.dwCounter1 = -1; 1647 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1648 &callbackData, callbackData.dwFlags ); 1649 checkHR( DP_OK, hr ); 1650 check( 2, callbackData.dwCounter1 ); /* Both sessions automatically 1651 set DPSESSION_PASSWORDREQUIRED */ 1652 1653 /* - Only session flag set */ 1654 for (i=4; i<=5; i++) 1655 { 1656 IDirectPlayX_Release( pDPserver[i] ); 1657 U2(dpsd_server[i]).lpszPasswordA = NULL; 1658 } 1659 dpsd_server[4].dwFlags = DPSESSION_PRIVATE; 1660 dpsd_server[5].dwFlags = DPSESSION_PASSWORDREQUIRED; 1661 for (i=4; i<=5; i++) 1662 { 1663 pDPserver[i] = create_session( &dpsd_server[i] ); 1664 } 1665 1666 callbackData.dwFlags = 0; 1667 callbackData.dwCounter1 = -1; 1668 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1669 &callbackData, callbackData.dwFlags ); 1670 checkHR( DP_OK, hr ); 1671 check( 2, callbackData.dwCounter1 ); /* Without password, 1672 the flag is ignored */ 1673 1674 /* - Both session flag and password set */ 1675 for (i=4; i<=5; i++) 1676 { 1677 IDirectPlayX_Release( pDPserver[i] ); 1678 U2(dpsd_server[i]).lpszPasswordA = (LPSTR) "password"; 1679 } 1680 dpsd_server[4].dwFlags = DPSESSION_PRIVATE; 1681 dpsd_server[5].dwFlags = DPSESSION_PASSWORDREQUIRED; 1682 for (i=4; i<=5; i++) 1683 { 1684 pDPserver[i] = create_session( &dpsd_server[i] ); 1685 } 1686 1687 /* - Listing without password */ 1688 callbackData.dwCounter1 = -1; 1689 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1690 &callbackData, callbackData.dwFlags ); 1691 checkHR( DP_OK, hr ); 1692 check( 0, callbackData.dwCounter1 ); 1693 1694 callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED; 1695 callbackData.dwCounter1 = -1; 1696 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1697 &callbackData, callbackData.dwFlags ); 1698 checkHR( DP_OK, hr ); 1699 check( 1, callbackData.dwCounter1 ); 1700 1701 /* - Listing with incorrect password */ 1702 U2(dpsd).lpszPasswordA = (LPSTR) "bad_password"; 1703 callbackData.dwFlags = 0; 1704 callbackData.dwCounter1 = -1; 1705 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1706 &callbackData, callbackData.dwFlags ); 1707 checkHR( DP_OK, hr ); 1708 check( 0, callbackData.dwCounter1 ); 1709 1710 callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED; 1711 callbackData.dwCounter1 = -1; 1712 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1713 &callbackData, callbackData.dwFlags ); 1714 checkHR( DP_OK, hr ); 1715 check( 1, callbackData.dwCounter1 ); 1716 1717 /* - Listing with correct password */ 1718 U2(dpsd).lpszPasswordA = (LPSTR) "password"; 1719 callbackData.dwCounter1 = -1; 1720 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1721 &callbackData, callbackData.dwFlags ); 1722 checkHR( DP_OK, hr ); 1723 check( 2, callbackData.dwCounter1 ); 1724 1725 1726 U2(dpsd).lpszPasswordA = NULL; 1727 callbackData.dwFlags = DPENUMSESSIONS_ASYNC; 1728 callbackData.dwCounter1 = -1; 1729 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1730 &callbackData, callbackData.dwFlags ); 1731 checkHR( DP_OK, hr ); 1732 check( 2, callbackData.dwCounter1 ); /* Read cache of last sync enumeration, 1733 even private sessions */ 1734 1735 1736 /* GUID tests */ 1737 1738 /* - Creating two servers with different application GUIDs */ 1739 for (i=4; i<=5; i++) 1740 { 1741 IDirectPlayX_Release( pDPserver[i] ); 1742 dpsd_server[i].dwFlags = ( DPSESSION_CLIENTSERVER | 1743 DPSESSION_DIRECTPLAYPROTOCOL ); 1744 U2(dpsd_server[i]).lpszPasswordA = NULL; 1745 dpsd_server[i].dwMaxPlayers = 10; 1746 } 1747 U1(dpsd_server[4]).lpszSessionNameA = (LPSTR) "normal1"; 1748 dpsd_server[4].guidApplication = appGuid; 1749 U1(dpsd_server[5]).lpszSessionNameA = (LPSTR) "normal2"; 1750 dpsd_server[5].guidApplication = appGuid2; 1751 for (i=4; i<=5; i++) 1752 { 1753 pDPserver[i] = create_session( &dpsd_server[i] ); 1754 } 1755 1756 callbackData.dwFlags = 0; 1757 1758 dpsd.guidApplication = appGuid2; 1759 callbackData.dwCounter1 = -1; 1760 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1761 &callbackData, callbackData.dwFlags ); 1762 checkHR( DP_OK, hr ); 1763 check( 1, callbackData.dwCounter1 ); /* Only one of the sessions */ 1764 1765 dpsd.guidApplication = appGuid; 1766 callbackData.dwCounter1 = -1; 1767 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1768 &callbackData, callbackData.dwFlags ); 1769 checkHR( DP_OK, hr ); 1770 check( 1, callbackData.dwCounter1 ); /* The other session */ 1771 /* FIXME: 1772 For some reason, if we enum 1st with appGuid and 2nd with appGuid2, 1773 in the second enum we get the 2 sessions. Dplay fault? Elves? */ 1774 1775 dpsd.guidApplication = GUID_NULL; 1776 callbackData.dwCounter1 = -1; 1777 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb, 1778 &callbackData, callbackData.dwFlags ); 1779 checkHR( DP_OK, hr ); 1780 check( 2, callbackData.dwCounter1 ); /* Both sessions */ 1781 1782 for (i=4; i<=5; i++) 1783 { 1784 IDirectPlayX_Release( pDPserver[i] ); 1785 } 1786 IDirectPlayX_Release( pDP ); 1787 1788 } 1789 1790 /* SetSessionDesc 1791 GetSessionDesc */ 1792 1793 static void test_SessionDesc(void) 1794 { 1795 1796 IDirectPlay4 *pDP[2]; 1797 DPSESSIONDESC2 dpsd; 1798 LPDPSESSIONDESC2 lpData[2]; 1799 LPVOID lpDataMsg; 1800 DPID dpid[2]; 1801 DWORD dwDataSize; 1802 HRESULT hr; 1803 UINT i; 1804 CallbackData callbackData; 1805 1806 1807 for (i=0; i<2; i++) 1808 { 1809 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 1810 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 1811 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 1812 if (FAILED(hr)) return; 1813 } 1814 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 1815 1816 /* Service provider not initialized */ 1817 hr = IDirectPlayX_SetSessionDesc( pDP[0], NULL, 0 ); 1818 checkHR( DPERR_UNINITIALIZED, hr ); 1819 1820 hr = IDirectPlayX_GetSessionDesc( pDP[0], NULL, NULL ); 1821 checkHR( DPERR_UNINITIALIZED, hr ); 1822 1823 1824 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 ); 1825 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 ); 1826 1827 1828 /* No sessions open */ 1829 hr = IDirectPlayX_SetSessionDesc( pDP[0], NULL, 0 ); 1830 todo_wine checkHR( DPERR_NOSESSIONS, hr ); 1831 1832 if ( hr == DPERR_UNINITIALIZED ) 1833 { 1834 todo_wine win_skip("Get/SetSessionDesc not implemented\n"); 1835 return; 1836 } 1837 1838 hr = IDirectPlayX_GetSessionDesc( pDP[0], NULL, NULL ); 1839 checkHR( DPERR_NOSESSIONS, hr ); 1840 1841 1842 dpsd.dwSize = sizeof(DPSESSIONDESC2); 1843 dpsd.guidApplication = appGuid; 1844 dpsd.dwMaxPlayers = 10; 1845 1846 1847 /* Host */ 1848 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 1849 /* Peer */ 1850 IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join, 1851 pDP[1], 0 ); 1852 1853 for (i=0; i<2; i++) 1854 { 1855 /* Players, only to receive messages */ 1856 IDirectPlayX_CreatePlayer( pDP[i], &dpid[i], NULL, NULL, NULL, 0, 0 ); 1857 1858 lpData[i] = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 1024 ); 1859 } 1860 lpDataMsg = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 1024 ); 1861 1862 1863 /* Incorrect parameters */ 1864 hr = IDirectPlayX_SetSessionDesc( pDP[0], NULL, 0 ); 1865 checkHR( DPERR_INVALIDPARAMS, hr ); 1866 hr = IDirectPlayX_GetSessionDesc( pDP[0], NULL, NULL ); 1867 checkHR( DPERR_INVALIDPARAM, hr ); 1868 if(0) 1869 { 1870 /* Crashes under Win7 */ 1871 hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], NULL ); 1872 checkHR( DPERR_INVALIDPARAM, hr ); 1873 dwDataSize=-1; 1874 hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], &dwDataSize ); 1875 checkHR( DPERR_INVALIDPARAMS, hr ); 1876 check( -1, dwDataSize ); 1877 } 1878 1879 /* Get: Insufficient buffer size */ 1880 dwDataSize=0; 1881 hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], &dwDataSize ); 1882 checkHR( DPERR_BUFFERTOOSMALL, hr ); 1883 check( dpsd.dwSize, dwDataSize ); 1884 dwDataSize=4; 1885 hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], &dwDataSize ); 1886 checkHR( DPERR_BUFFERTOOSMALL, hr ); 1887 check( dpsd.dwSize, dwDataSize ); 1888 dwDataSize=1024; 1889 hr = IDirectPlayX_GetSessionDesc( pDP[0], NULL, &dwDataSize ); 1890 checkHR( DPERR_BUFFERTOOSMALL, hr ); 1891 check( dpsd.dwSize, dwDataSize ); 1892 1893 /* Get: Regular operation 1894 * i=0: Local session 1895 * i=1: Remote session */ 1896 for (i=0; i<2; i++) 1897 { 1898 hr = IDirectPlayX_GetSessionDesc( pDP[i], lpData[i], &dwDataSize ); 1899 checkHR( DP_OK, hr ); 1900 check( sizeof(DPSESSIONDESC2), dwDataSize ); 1901 check( sizeof(DPSESSIONDESC2), lpData[i]->dwSize ); 1902 checkGuid( &appGuid, &lpData[i]->guidApplication ); 1903 check( dpsd.dwMaxPlayers, lpData[i]->dwMaxPlayers ); 1904 } 1905 1906 checkGuid( &lpData[0]->guidInstance, &lpData[1]->guidInstance ); 1907 1908 /* Set: Regular operation */ 1909 U1(dpsd).lpszSessionNameA = (LPSTR) "Wahaa"; 1910 hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 ); 1911 checkHR( DP_OK, hr ); 1912 1913 dwDataSize = 1024; 1914 hr = IDirectPlayX_GetSessionDesc( pDP[1], lpData[1], &dwDataSize ); 1915 checkHR( DP_OK, hr ); 1916 checkStr( U1(dpsd).lpszSessionNameA, U1(*lpData[1]).lpszSessionNameA ); 1917 1918 1919 /* Set: Failing to modify a remote session */ 1920 hr = IDirectPlayX_SetSessionDesc( pDP[1], &dpsd, 0 ); 1921 checkHR( DPERR_ACCESSDENIED, hr ); 1922 1923 /* Trying to change immutable properties */ 1924 /* Flags */ 1925 hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 ); 1926 checkHR( DP_OK, hr ); 1927 dpsd.dwFlags = DPSESSION_SECURESERVER; 1928 hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 ); 1929 checkHR( DPERR_INVALIDPARAMS, hr ); 1930 dpsd.dwFlags = 0; 1931 hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 ); 1932 checkHR( DP_OK, hr ); 1933 /* Size */ 1934 dpsd.dwSize = 2048; 1935 hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 ); 1936 checkHR( DPERR_INVALIDPARAMS, hr ); 1937 dpsd.dwSize = sizeof(DPSESSIONDESC2); 1938 hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 ); 1939 checkHR( DP_OK, hr ); 1940 1941 /* Changing the GUIDs and size is ignored */ 1942 dpsd.guidApplication = appGuid2; 1943 hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 ); 1944 checkHR( DP_OK, hr ); 1945 dpsd.guidInstance = appGuid2; 1946 hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 ); 1947 checkHR( DP_OK, hr ); 1948 1949 hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], &dwDataSize ); 1950 checkHR( DP_OK, hr ); 1951 checkGuid( &appGuid, &lpData[0]->guidApplication ); 1952 checkGuid( &lpData[1]->guidInstance, &lpData[0]->guidInstance ); 1953 check( sizeof(DPSESSIONDESC2), lpData[0]->dwSize ); 1954 1955 1956 /* Checking system messages */ 1957 check_messages( pDP[0], dpid, 2, &callbackData ); 1958 checkStr( "S0,S0,S0,S0,S0,S0,S0,", callbackData.szTrace1 ); 1959 checkStr( "48,90,90,90,90,90,90,", callbackData.szTrace2 ); 1960 check_messages( pDP[1], dpid, 2, &callbackData ); 1961 checkStr( "S1,S1,S1,S1,S1,S1,", callbackData.szTrace1 ); 1962 checkStr( "90,90,90,90,90,90,", callbackData.szTrace2 ); 1963 1964 HeapFree( GetProcessHeap(), 0, lpDataMsg ); 1965 for (i=0; i<2; i++) 1966 { 1967 HeapFree( GetProcessHeap(), 0, lpData[i] ); 1968 IDirectPlayX_Release( pDP[i] ); 1969 } 1970 1971 } 1972 1973 /* CreatePlayer */ 1974 1975 static void test_CreatePlayer(void) 1976 { 1977 1978 IDirectPlay4 *pDP[2]; 1979 DPSESSIONDESC2 dpsd; 1980 DPNAME name; 1981 DPID dpid; 1982 HRESULT hr; 1983 1984 1985 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 1986 &IID_IDirectPlay4A, (LPVOID*) &pDP[0] ); 1987 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 1988 if (FAILED(hr)) return; 1989 1990 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 1991 &IID_IDirectPlay4A, (LPVOID*) &pDP[1] ); 1992 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 1993 if (FAILED(hr)) return; 1994 1995 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 1996 ZeroMemory( &name, sizeof(DPNAME) ); 1997 1998 1999 /* Connection not initialized */ 2000 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 0, 0 ); 2001 checkHR( DPERR_UNINITIALIZED, hr ); 2002 2003 2004 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 ); 2005 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 ); 2006 2007 2008 /* Session not open */ 2009 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 0, 0 ); 2010 todo_wine checkHR( DPERR_INVALIDPARAMS, hr ); 2011 2012 if ( hr == DPERR_UNINITIALIZED ) 2013 { 2014 todo_wine win_skip( "CreatePlayer not implemented\n" ); 2015 return; 2016 } 2017 2018 dpsd.dwSize = sizeof(DPSESSIONDESC2); 2019 dpsd.guidApplication = appGuid; 2020 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 2021 2022 2023 /* Player name */ 2024 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 0, 0 ); 2025 checkHR( DP_OK, hr ); 2026 2027 2028 name.dwSize = -1; 2029 2030 2031 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, &name, NULL, NULL, 0, 0 ); 2032 checkHR( DP_OK, hr ); 2033 2034 2035 name.dwSize = sizeof(DPNAME); 2036 U1(name).lpszShortNameA = (LPSTR) "test"; 2037 U2(name).lpszLongNameA = NULL; 2038 2039 2040 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, &name, NULL, NULL, 2041 0, 0 ); 2042 checkHR( DP_OK, hr ); 2043 2044 2045 /* Null dpid */ 2046 hr = IDirectPlayX_CreatePlayer( pDP[0], NULL, NULL, NULL, NULL, 2047 0, 0 ); 2048 checkHR( DPERR_INVALIDPARAMS, hr ); 2049 2050 2051 /* There can only be one server player */ 2052 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 2053 0, DPPLAYER_SERVERPLAYER ); 2054 checkHR( DP_OK, hr ); 2055 check( DPID_SERVERPLAYER, dpid ); 2056 2057 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 2058 0, DPPLAYER_SERVERPLAYER ); 2059 checkHR( DPERR_CANTCREATEPLAYER, hr ); 2060 2061 IDirectPlayX_DestroyPlayer( pDP[0], dpid ); 2062 2063 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 2064 0, DPPLAYER_SERVERPLAYER ); 2065 checkHR( DP_OK, hr ); 2066 check( DPID_SERVERPLAYER, dpid ); 2067 IDirectPlayX_DestroyPlayer( pDP[0], dpid ); 2068 2069 2070 /* Flags */ 2071 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 2072 0, 0 ); 2073 checkHR( DP_OK, hr ); 2074 2075 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 2076 0, DPPLAYER_SERVERPLAYER ); 2077 checkHR( DP_OK, hr ); 2078 check( DPID_SERVERPLAYER, dpid ); 2079 IDirectPlayX_DestroyPlayer( pDP[0], dpid ); 2080 2081 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 2082 0, DPPLAYER_SPECTATOR ); 2083 checkHR( DP_OK, hr ); 2084 2085 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 2086 0, ( DPPLAYER_SERVERPLAYER | 2087 DPPLAYER_SPECTATOR ) ); 2088 checkHR( DP_OK, hr ); 2089 check( DPID_SERVERPLAYER, dpid ); 2090 IDirectPlayX_DestroyPlayer( pDP[0], dpid ); 2091 2092 2093 /* Session with DPSESSION_NEWPLAYERSDISABLED */ 2094 IDirectPlayX_Close( pDP[0] ); 2095 dpsd.dwFlags = DPSESSION_NEWPLAYERSDISABLED; 2096 hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 2097 checkHR( DP_OK, hr ); 2098 2099 2100 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 2101 0, 0 ); 2102 checkHR( DPERR_CANTCREATEPLAYER, hr ); 2103 2104 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 2105 0, DPPLAYER_SERVERPLAYER ); 2106 checkHR( DPERR_CANTCREATEPLAYER, hr ); 2107 2108 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 2109 0, DPPLAYER_SPECTATOR ); 2110 checkHR( DPERR_CANTCREATEPLAYER, hr ); 2111 2112 2113 /* Creating players in a Client/Server session */ 2114 IDirectPlayX_Close( pDP[0] ); 2115 dpsd.dwFlags = DPSESSION_CLIENTSERVER; 2116 hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 2117 checkHR( DP_OK, hr ); 2118 hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join, 2119 pDP[1], 0 ); 2120 checkHR( DP_OK, hr ); 2121 2122 2123 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 2124 0, 0 ); 2125 checkHR( DPERR_ACCESSDENIED, hr ); 2126 2127 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 2128 0, DPPLAYER_SERVERPLAYER ); 2129 checkHR( DP_OK, hr ); 2130 check( DPID_SERVERPLAYER, dpid ); 2131 2132 hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid, NULL, NULL, NULL, 2133 0, DPPLAYER_SERVERPLAYER ); 2134 checkHR( DPERR_INVALIDFLAGS, hr ); 2135 2136 hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid, NULL, NULL, NULL, 2137 0, 0 ); 2138 checkHR( DP_OK, hr ); 2139 2140 2141 IDirectPlayX_Release( pDP[0] ); 2142 IDirectPlayX_Release( pDP[1] ); 2143 2144 } 2145 2146 /* GetPlayerCaps */ 2147 2148 static void test_GetPlayerCaps(void) 2149 { 2150 2151 IDirectPlay4 *pDP[2]; 2152 DPSESSIONDESC2 dpsd; 2153 DPID dpid[2]; 2154 HRESULT hr; 2155 UINT i; 2156 2157 DPCAPS playerCaps; 2158 DWORD dwFlags; 2159 2160 2161 for (i=0; i<2; i++) 2162 { 2163 hr= CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 2164 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 2165 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 2166 if (FAILED(hr)) return; 2167 } 2168 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 2169 dpsd.dwSize = sizeof(DPSESSIONDESC2); 2170 dpsd.guidApplication = appGuid; 2171 dpsd.dwMaxPlayers = 10; 2172 2173 ZeroMemory( &playerCaps, sizeof(DPCAPS) ); 2174 2175 2176 /* Uninitialized service provider */ 2177 playerCaps.dwSize = 0; 2178 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 ); 2179 checkHR( DPERR_UNINITIALIZED, hr ); 2180 2181 playerCaps.dwSize = sizeof(DPCAPS); 2182 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 ); 2183 checkHR( DPERR_UNINITIALIZED, hr ); 2184 2185 2186 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 ); 2187 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 ); 2188 2189 2190 /* No session */ 2191 playerCaps.dwSize = 0; 2192 2193 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 ); 2194 todo_wine checkHR( DPERR_INVALIDPARAMS, hr ); 2195 2196 if ( hr == DPERR_UNINITIALIZED ) 2197 { 2198 todo_wine win_skip( "GetPlayerCaps not implemented\n" ); 2199 return; 2200 } 2201 2202 playerCaps.dwSize = sizeof(DPCAPS); 2203 2204 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 ); 2205 checkHR( DPERR_INVALIDPLAYER, hr ); 2206 2207 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 2, &playerCaps, 0 ); 2208 checkHR( DPERR_INVALIDPLAYER, hr ); 2209 2210 2211 hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 2212 checkHR( DP_OK, hr ); 2213 hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join, 2214 pDP[1], 0 ); 2215 checkHR( DP_OK, hr ); 2216 2217 for (i=0; i<2; i++) 2218 { 2219 hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i], 2220 NULL, NULL, NULL, 0, 0 ); 2221 checkHR( DP_OK, hr ); 2222 } 2223 2224 2225 /* Uninitialized playerCaps */ 2226 playerCaps.dwSize = 0; 2227 2228 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 ); 2229 checkHR( DPERR_INVALIDPARAMS, hr ); 2230 2231 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 2, &playerCaps, 0 ); 2232 checkHR( DPERR_INVALIDPARAMS, hr ); 2233 2234 hr = IDirectPlayX_GetPlayerCaps( pDP[0], dpid[0], &playerCaps, 0 ); 2235 checkHR( DPERR_INVALIDPARAMS, hr ); 2236 2237 /* Invalid player */ 2238 playerCaps.dwSize = sizeof(DPCAPS); 2239 2240 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 ); 2241 checkHR( DPERR_INVALIDPLAYER, hr ); 2242 2243 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 2, &playerCaps, 0 ); 2244 checkHR( DPERR_INVALIDPLAYER, hr ); 2245 2246 hr = IDirectPlayX_GetPlayerCaps( pDP[0], dpid[0], &playerCaps, 0 ); 2247 checkHR( DP_OK, hr ); 2248 2249 hr = IDirectPlayX_GetPlayerCaps( pDP[0], dpid[0], NULL, 0 ); 2250 checkHR( DPERR_INVALIDPARAMS, hr ); 2251 2252 /* Regular parameters */ 2253 for (i=0; i<2; i++) 2254 { 2255 for (dwFlags=0; 2256 dwFlags<=DPGETCAPS_GUARANTEED; 2257 dwFlags+=DPGETCAPS_GUARANTEED) 2258 { 2259 2260 hr = IDirectPlayX_GetPlayerCaps( pDP[0], dpid[i], 2261 &playerCaps, dwFlags ); 2262 checkHR( DP_OK, hr ); 2263 2264 2265 check( sizeof(DPCAPS), playerCaps.dwSize ); 2266 check( 40, playerCaps.dwSize ); 2267 check( 0, playerCaps.dwMaxQueueSize ); 2268 check( 0, playerCaps.dwHundredBaud ); 2269 check( 0, playerCaps.dwLatency ); 2270 check( 65536, playerCaps.dwMaxLocalPlayers ); 2271 check( 20, playerCaps.dwHeaderLength ); 2272 2273 if ( i == 0 ) 2274 { 2275 checkFlags( DPCAPS_ISHOST | 2276 DPCAPS_GUARANTEEDOPTIMIZED | 2277 DPCAPS_GUARANTEEDSUPPORTED | 2278 DPCAPS_ASYNCSUPPORTED | 2279 DPPLAYERCAPS_LOCAL, 2280 playerCaps.dwFlags, FLAGS_DPCAPS ); 2281 } 2282 else 2283 checkFlags( DPCAPS_ISHOST | 2284 DPCAPS_GUARANTEEDOPTIMIZED | 2285 DPCAPS_GUARANTEEDSUPPORTED | 2286 DPCAPS_ASYNCSUPPORTED, 2287 playerCaps.dwFlags, FLAGS_DPCAPS ); 2288 2289 if ( dwFlags == DPGETCAPS_GUARANTEED ) 2290 { 2291 check( 1048547, playerCaps.dwMaxBufferSize ); 2292 check( 64, playerCaps.dwMaxPlayers ); 2293 } 2294 else 2295 { 2296 check( 65479, playerCaps.dwMaxBufferSize ); 2297 check( 65536, playerCaps.dwMaxPlayers ); 2298 } 2299 2300 } 2301 } 2302 2303 2304 IDirectPlayX_Release( pDP[0] ); 2305 IDirectPlayX_Release( pDP[1] ); 2306 2307 } 2308 2309 /* SetPlayerData 2310 GetPlayerData */ 2311 2312 static void test_PlayerData(void) 2313 { 2314 IDirectPlay4 *pDP; 2315 DPSESSIONDESC2 dpsd; 2316 DPID dpid; 2317 HRESULT hr; 2318 2319 /* lpDataFake has to be bigger than the rest, limits lpDataGet size */ 2320 LPCSTR lpDataFake = "big_fake_data_chunk"; 2321 DWORD dwDataSizeFake = strlen(lpDataFake)+1; 2322 2323 LPCSTR lpData = "remote_data"; 2324 DWORD dwDataSize = strlen(lpData)+1; 2325 2326 LPCSTR lpDataLocal = "local_data"; 2327 DWORD dwDataSizeLocal = strlen(lpDataLocal)+1; 2328 2329 LPSTR lpDataGet = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 2330 dwDataSizeFake ); 2331 DWORD dwDataSizeGet = dwDataSizeFake; 2332 2333 2334 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 2335 &IID_IDirectPlay4A, (LPVOID*) &pDP ); 2336 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 2337 if (FAILED(hr)) return; 2338 2339 /* No service provider */ 2340 hr = IDirectPlayX_SetPlayerData( pDP, 0, (LPVOID) lpData, 2341 dwDataSize, 0 ); 2342 checkHR( DPERR_UNINITIALIZED, hr ); 2343 2344 hr = IDirectPlayX_GetPlayerData( pDP, 0, lpDataGet, &dwDataSizeGet, 0 ); 2345 checkHR( DPERR_UNINITIALIZED, hr ); 2346 2347 2348 init_TCPIP_provider( pDP, "127.0.0.1", 0 ); 2349 2350 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 2351 dpsd.dwSize = sizeof(DPSESSIONDESC2); 2352 dpsd.guidApplication = appGuid; 2353 IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE ); 2354 2355 2356 /* Invalid player */ 2357 hr = IDirectPlayX_SetPlayerData( pDP, 0, (LPVOID) lpData, 2358 dwDataSize, 0 ); 2359 todo_wine checkHR( DPERR_INVALIDPLAYER, hr ); 2360 2361 hr = IDirectPlayX_GetPlayerData( pDP, 0, lpDataGet, &dwDataSizeGet, 0 ); 2362 todo_wine checkHR( DPERR_INVALIDPLAYER, hr ); 2363 2364 if ( hr == DPERR_UNINITIALIZED ) 2365 { 2366 todo_wine win_skip( "Get/SetPlayerData not implemented\n" ); 2367 return; 2368 } 2369 2370 /* Create the player */ 2371 /* By default, the data is remote */ 2372 hr = IDirectPlayX_CreatePlayer( pDP, &dpid, NULL, NULL, (LPVOID) lpData, 2373 dwDataSize, 0 ); 2374 checkHR( DP_OK, hr ); 2375 2376 /* Invalid parameters */ 2377 hr = IDirectPlayX_SetPlayerData( pDP, dpid, NULL, dwDataSize, 0 ); 2378 checkHR( DPERR_INVALIDPARAMS, hr ); 2379 hr = IDirectPlayX_SetPlayerData( pDP, dpid, lpDataGet, -1, 0 ); 2380 checkHR( DPERR_INVALIDPARAMS, hr ); 2381 2382 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, NULL, 0 ); 2383 checkHR( DPERR_INVALIDPARAMS, hr ); 2384 2385 2386 /* 2387 * Remote data (default) 2388 */ 2389 2390 2391 /* Buffer redimension */ 2392 dwDataSizeGet = dwDataSizeFake; 2393 strcpy(lpDataGet, lpDataFake); 2394 hr = IDirectPlayX_GetPlayerData( pDP, dpid, NULL, 2395 &dwDataSizeGet, 0 ); 2396 check( DPERR_BUFFERTOOSMALL, hr ); 2397 check( dwDataSize, dwDataSizeGet ); 2398 checkStr( lpDataFake, lpDataGet ); 2399 2400 dwDataSizeGet = 2; 2401 strcpy(lpDataGet, lpDataFake); 2402 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 ); 2403 check( DPERR_BUFFERTOOSMALL, hr ); 2404 check( dwDataSize, dwDataSizeGet ); 2405 2406 strcpy(lpDataGet, lpDataFake); 2407 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 ); 2408 checkHR( DP_OK, hr ); 2409 check( dwDataSize, dwDataSizeGet ); 2410 checkStr( lpData, lpDataGet ); 2411 2412 /* Normal operation */ 2413 dwDataSizeGet = dwDataSizeFake; 2414 strcpy(lpDataGet, lpDataFake); 2415 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 ); 2416 checkHR( DP_OK, hr ); 2417 check( dwDataSize, dwDataSizeGet ); 2418 checkStr( lpData, lpDataGet ); 2419 2420 /* Flag tests */ 2421 dwDataSizeGet = dwDataSizeFake; 2422 strcpy(lpDataGet, lpDataFake); 2423 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 ); 2424 checkHR( DP_OK, hr ); 2425 check( dwDataSize, dwDataSizeGet ); /* Remote: works as expected */ 2426 checkStr( lpData, lpDataGet ); 2427 2428 dwDataSizeGet = dwDataSizeFake; 2429 strcpy(lpDataGet, lpDataFake); 2430 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 2431 DPGET_REMOTE ); 2432 checkHR( DP_OK, hr ); 2433 check( dwDataSize, dwDataSizeGet ); /* Same behaviour as in previous test */ 2434 checkStr( lpData, lpDataGet ); 2435 2436 dwDataSizeGet = dwDataSizeFake; 2437 strcpy(lpDataGet, lpDataFake); 2438 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 2439 DPGET_LOCAL ); 2440 checkHR( DP_OK, hr ); 2441 check( 0, dwDataSizeGet ); /* Sets size to 0 (as local data doesn't exist) */ 2442 checkStr( lpDataFake, lpDataGet ); 2443 2444 dwDataSizeGet = dwDataSizeFake; 2445 strcpy(lpDataGet, lpDataFake); 2446 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 2447 DPGET_LOCAL | DPGET_REMOTE ); 2448 checkHR( DP_OK, hr ); 2449 check( 0, dwDataSizeGet ); /* Same behaviour as in previous test */ 2450 checkStr( lpDataFake, lpDataGet ); 2451 2452 /* Getting local data (which doesn't exist), buffer size is ignored */ 2453 dwDataSizeGet = 0; 2454 strcpy(lpDataGet, lpDataFake); 2455 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 2456 DPGET_LOCAL ); 2457 checkHR( DP_OK, hr ); 2458 check( 0, dwDataSizeGet ); /* Sets size to 0 */ 2459 checkStr( lpDataFake, lpDataGet ); 2460 2461 dwDataSizeGet = dwDataSizeFake; 2462 strcpy(lpDataGet, lpDataFake); 2463 hr = IDirectPlayX_GetPlayerData( pDP, dpid, NULL, &dwDataSizeGet, 2464 DPGET_LOCAL ); 2465 checkHR( DP_OK, hr ); 2466 check( 0, dwDataSizeGet ); /* Sets size to 0 */ 2467 checkStr( lpDataFake, lpDataGet ); 2468 2469 2470 /* 2471 * Local data 2472 */ 2473 2474 2475 /* Invalid flags */ 2476 hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataLocal, 2477 dwDataSizeLocal, 2478 DPSET_LOCAL | DPSET_GUARANTEED ); 2479 checkHR( DPERR_INVALIDPARAMS, hr ); 2480 2481 /* Correct parameters */ 2482 hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataLocal, 2483 dwDataSizeLocal, DPSET_LOCAL ); 2484 checkHR( DP_OK, hr ); 2485 2486 /* Flag tests (again) */ 2487 dwDataSizeGet = dwDataSizeFake; 2488 strcpy(lpDataGet, lpDataFake); 2489 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 ); 2490 checkHR( DP_OK, hr ); 2491 check( dwDataSize, dwDataSizeGet ); /* Remote: works as expected */ 2492 checkStr( lpData, lpDataGet ); 2493 2494 dwDataSizeGet = dwDataSizeFake; 2495 strcpy(lpDataGet, lpDataFake); 2496 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 2497 DPGET_REMOTE ); 2498 checkHR( DP_OK, hr ); 2499 check( dwDataSize, dwDataSizeGet ); /* Like in previous test */ 2500 checkStr( lpData, lpDataGet ); 2501 2502 dwDataSizeGet = dwDataSizeFake; 2503 strcpy(lpDataGet, lpDataFake); 2504 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 2505 DPGET_LOCAL ); 2506 checkHR( DP_OK, hr ); 2507 check( dwDataSizeLocal, dwDataSizeGet ); /* Local: works as expected */ 2508 checkStr( lpDataLocal, lpDataGet ); 2509 2510 dwDataSizeGet = dwDataSizeFake; 2511 strcpy(lpDataGet, lpDataFake); 2512 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 2513 DPGET_LOCAL | DPGET_REMOTE ); 2514 checkHR( DP_OK, hr ); 2515 check( dwDataSizeLocal, dwDataSizeGet ); /* Like in previous test */ 2516 checkStr( lpDataLocal, lpDataGet ); 2517 2518 /* Small buffer works as expected again */ 2519 dwDataSizeGet = 0; 2520 strcpy(lpDataGet, lpDataFake); 2521 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 2522 DPGET_LOCAL ); 2523 checkHR( DPERR_BUFFERTOOSMALL, hr ); 2524 check( dwDataSizeLocal, dwDataSizeGet ); 2525 checkStr( lpDataFake, lpDataGet ); 2526 2527 dwDataSizeGet = dwDataSizeFake; 2528 strcpy(lpDataGet, lpDataFake); 2529 hr = IDirectPlayX_GetPlayerData( pDP, dpid, NULL, 2530 &dwDataSizeGet, DPGET_LOCAL ); 2531 check( DPERR_BUFFERTOOSMALL, hr ); 2532 check( dwDataSizeLocal, dwDataSizeGet ); 2533 checkStr( lpDataFake, lpDataGet ); 2534 2535 2536 /* 2537 * Changing remote data 2538 */ 2539 2540 2541 /* Remote data := local data */ 2542 hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataLocal, 2543 dwDataSizeLocal, 2544 DPSET_GUARANTEED | DPSET_REMOTE ); 2545 checkHR( DP_OK, hr ); 2546 hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataLocal, 2547 dwDataSizeLocal, 0 ); 2548 checkHR( DP_OK, hr ); 2549 2550 dwDataSizeGet = dwDataSizeFake; 2551 strcpy(lpDataGet, lpDataFake); 2552 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 ); 2553 checkHR( DP_OK, hr ); 2554 check( dwDataSizeLocal, dwDataSizeGet ); 2555 checkStr( lpDataLocal, lpDataGet ); 2556 2557 /* Remote data := fake data */ 2558 hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataFake, 2559 dwDataSizeFake, DPSET_REMOTE ); 2560 checkHR( DP_OK, hr ); 2561 2562 dwDataSizeGet = dwDataSizeFake + 1; 2563 strcpy(lpDataGet, lpData); 2564 hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 ); 2565 checkHR( DP_OK, hr ); 2566 check( dwDataSizeFake, dwDataSizeGet ); 2567 checkStr( lpDataFake, lpDataGet ); 2568 2569 2570 HeapFree( GetProcessHeap(), 0, lpDataGet ); 2571 IDirectPlayX_Release( pDP ); 2572 } 2573 2574 /* GetPlayerName 2575 SetPlayerName */ 2576 2577 static void test_PlayerName(void) 2578 { 2579 2580 IDirectPlay4 *pDP[2]; 2581 DPSESSIONDESC2 dpsd; 2582 DPID dpid[2]; 2583 HRESULT hr; 2584 UINT i; 2585 2586 DPNAME playerName; 2587 DWORD dwDataSize = 1024; 2588 LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize ); 2589 CallbackData callbackData; 2590 2591 2592 for (i=0; i<2; i++) 2593 { 2594 hr= CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 2595 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 2596 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 2597 if (FAILED(hr)) return; 2598 } 2599 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 2600 ZeroMemory( &playerName, sizeof(DPNAME) ); 2601 2602 2603 /* Service provider not initialized */ 2604 hr = IDirectPlayX_SetPlayerName( pDP[0], 0, &playerName, 0 ); 2605 checkHR( DPERR_UNINITIALIZED, hr ); 2606 2607 dwDataSize = 1024; 2608 hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize ); 2609 checkHR( DPERR_UNINITIALIZED, hr ); 2610 check( 1024, dwDataSize ); 2611 2612 2613 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 ); 2614 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 ); 2615 2616 2617 /* Session not initialized */ 2618 hr = IDirectPlayX_SetPlayerName( pDP[0], 0, &playerName, 0 ); 2619 todo_wine checkHR( DPERR_INVALIDPLAYER, hr ); 2620 2621 if ( hr == DPERR_UNINITIALIZED ) 2622 { 2623 todo_wine win_skip( "Get/SetPlayerName not implemented\n" ); 2624 return; 2625 } 2626 2627 dwDataSize = 1024; 2628 hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize ); 2629 checkHR( DPERR_INVALIDPLAYER, hr ); 2630 check( 1024, dwDataSize ); 2631 2632 2633 dpsd.dwSize = sizeof(DPSESSIONDESC2); 2634 dpsd.guidApplication = appGuid; 2635 dpsd.dwMaxPlayers = 10; 2636 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 2637 IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join, 2638 pDP[1], 0 ); 2639 2640 IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 ); 2641 IDirectPlayX_CreatePlayer( pDP[1], &dpid[1], NULL, NULL, NULL, 0, 0 ); 2642 2643 2644 /* Name not initialized */ 2645 playerName.dwSize = -1; 2646 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, 0 ); 2647 checkHR( DP_OK, hr ); 2648 2649 dwDataSize = 1024; 2650 hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize ); 2651 checkHR( DPERR_INVALIDPLAYER, hr ); 2652 check( 1024, dwDataSize ); 2653 2654 2655 playerName.dwSize = sizeof(DPNAME); 2656 U1(playerName).lpszShortNameA = (LPSTR) "player_name"; 2657 U2(playerName).lpszLongNameA = (LPSTR) "player_long_name"; 2658 2659 2660 /* Invalid parameters */ 2661 hr = IDirectPlayX_SetPlayerName( pDP[0], -1, &playerName, 0 ); 2662 checkHR( DPERR_INVALIDPLAYER, hr ); 2663 hr = IDirectPlayX_SetPlayerName( pDP[0], 0, &playerName, 0 ); 2664 checkHR( DPERR_INVALIDPLAYER, hr ); 2665 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, -1 ); 2666 checkHR( DPERR_INVALIDPARAMS, hr ); 2667 2668 dwDataSize = 1024; 2669 hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize ); 2670 checkHR( DPERR_INVALIDPLAYER, hr ); 2671 check( 1024, dwDataSize ); 2672 2673 if(0) 2674 { 2675 /* Crashes under Win7 */ 2676 dwDataSize = -1; 2677 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize ); 2678 checkHR( DPERR_INVALIDPARAMS, hr ); 2679 check( -1, dwDataSize ); 2680 } 2681 2682 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, NULL ); 2683 checkHR( DPERR_INVALIDPARAMS, hr ); 2684 2685 /* Trying to modify remote player */ 2686 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[1], &playerName, 0 ); 2687 checkHR( DPERR_ACCESSDENIED, hr ); 2688 2689 2690 /* Regular operation */ 2691 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, 0 ); 2692 checkHR( DP_OK, hr ); 2693 dwDataSize = 1024; 2694 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize ); 2695 checkHR( DP_OK, hr ); 2696 check( 45, dwDataSize ); 2697 checkStr( U1(playerName).lpszShortNameA, U1(*(LPDPNAME)lpData).lpszShortNameA ); 2698 checkStr( U2(playerName).lpszLongNameA, U2(*(LPDPNAME)lpData).lpszLongNameA ); 2699 check( 0, ((LPDPNAME)lpData)->dwFlags ); 2700 2701 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], NULL, 0 ); 2702 checkHR( DP_OK, hr ); 2703 dwDataSize = 1024; 2704 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize ); 2705 checkHR( DP_OK, hr ); 2706 check( 16, dwDataSize ); 2707 checkLP( NULL, U1(*(LPDPNAME)lpData).lpszShortNameA ); 2708 checkLP( NULL, U2(*(LPDPNAME)lpData).lpszLongNameA ); 2709 check( 0, ((LPDPNAME)lpData)->dwFlags ); 2710 2711 2712 /* Small buffer in get operation */ 2713 dwDataSize = 1024; 2714 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], NULL, &dwDataSize ); 2715 checkHR( DPERR_BUFFERTOOSMALL, hr ); 2716 check( 16, dwDataSize ); 2717 2718 dwDataSize = 0; 2719 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize ); 2720 checkHR( DPERR_BUFFERTOOSMALL, hr ); 2721 check( 16, dwDataSize ); 2722 2723 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize ); 2724 checkHR( DP_OK, hr ); 2725 check( 16, dwDataSize ); 2726 checkLP( NULL, U1(*(LPDPNAME)lpData).lpszShortNameA ); 2727 checkLP( NULL, U2(*(LPDPNAME)lpData).lpszLongNameA ); 2728 check( 0, ((LPDPNAME)lpData)->dwFlags ); 2729 2730 2731 /* Flags */ 2732 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, 2733 DPSET_GUARANTEED ); 2734 checkHR( DP_OK, hr ); 2735 dwDataSize = 1024; 2736 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize ); 2737 checkHR( DP_OK, hr ); 2738 check( 45, dwDataSize ); 2739 checkStr( U1(playerName).lpszShortNameA, U1(*(LPDPNAME)lpData).lpszShortNameA ); 2740 checkStr( U2(playerName).lpszLongNameA, U2(*(LPDPNAME)lpData).lpszLongNameA ); 2741 check( 0, ((LPDPNAME)lpData)->dwFlags ); 2742 2743 /* - Local (no propagation) */ 2744 U1(playerName).lpszShortNameA = (LPSTR) "no_propagation"; 2745 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, 2746 DPSET_LOCAL ); 2747 checkHR( DP_OK, hr ); 2748 2749 dwDataSize = 1024; 2750 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], 2751 lpData, &dwDataSize ); /* Local fetch */ 2752 checkHR( DP_OK, hr ); 2753 check( 48, dwDataSize ); 2754 checkStr( "no_propagation", U1(*(LPDPNAME)lpData).lpszShortNameA ); 2755 2756 dwDataSize = 1024; 2757 hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0], 2758 lpData, &dwDataSize ); /* Remote fetch */ 2759 checkHR( DP_OK, hr ); 2760 check( 45, dwDataSize ); 2761 checkStr( "player_name", U1(*(LPDPNAME)lpData).lpszShortNameA ); 2762 2763 /* -- 2 */ 2764 2765 U1(playerName).lpszShortNameA = (LPSTR) "no_propagation_2"; 2766 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, 2767 DPSET_LOCAL | DPSET_REMOTE ); 2768 checkHR( DP_OK, hr ); 2769 2770 dwDataSize = 1024; 2771 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], 2772 lpData, &dwDataSize ); /* Local fetch */ 2773 checkHR( DP_OK, hr ); 2774 check( 50, dwDataSize ); 2775 checkStr( "no_propagation_2", U1(*(LPDPNAME)lpData).lpszShortNameA ); 2776 2777 dwDataSize = 1024; 2778 hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0], 2779 lpData, &dwDataSize ); /* Remote fetch */ 2780 checkHR( DP_OK, hr ); 2781 check( 45, dwDataSize ); 2782 checkStr( "player_name", U1(*(LPDPNAME)lpData).lpszShortNameA ); 2783 2784 /* - Remote (propagation, default) */ 2785 U1(playerName).lpszShortNameA = (LPSTR) "propagation"; 2786 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, 2787 DPSET_REMOTE ); 2788 checkHR( DP_OK, hr ); 2789 2790 dwDataSize = 1024; 2791 hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0], 2792 lpData, &dwDataSize ); /* Remote fetch */ 2793 checkHR( DP_OK, hr ); 2794 check( 45, dwDataSize ); 2795 checkStr( "propagation", U1(*(LPDPNAME)lpData).lpszShortNameA ); 2796 2797 /* -- 2 */ 2798 U1(playerName).lpszShortNameA = (LPSTR) "propagation_2"; 2799 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, 2800 0 ); 2801 checkHR( DP_OK, hr ); 2802 2803 dwDataSize = 1024; 2804 hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0], 2805 lpData, &dwDataSize ); /* Remote fetch */ 2806 checkHR( DP_OK, hr ); 2807 check( 47, dwDataSize ); 2808 checkStr( "propagation_2", U1(*(LPDPNAME)lpData).lpszShortNameA ); 2809 2810 2811 /* Checking system messages */ 2812 check_messages( pDP[0], dpid, 2, &callbackData ); 2813 checkStr( "S0,S0,S0,S0,S0,S0,S0,", callbackData.szTrace1 ); 2814 checkStr( "48,28,57,28,57,57,59,", callbackData.szTrace2 ); 2815 check_messages( pDP[1], dpid, 2, &callbackData ); 2816 checkStr( "S1,S1,S1,S1,S1,S1,", callbackData.szTrace1 ); 2817 checkStr( "28,57,28,57,57,59,", callbackData.szTrace2 ); 2818 2819 2820 HeapFree( GetProcessHeap(), 0, lpData ); 2821 IDirectPlayX_Release( pDP[0] ); 2822 IDirectPlayX_Release( pDP[1] ); 2823 2824 } 2825 2826 /* GetPlayerAccount */ 2827 2828 static BOOL CALLBACK EnumSessions_cb_join_secure( LPCDPSESSIONDESC2 lpThisSD, 2829 LPDWORD lpdwTimeOut, 2830 DWORD dwFlags, 2831 LPVOID lpContext ) 2832 { 2833 IDirectPlay4 *pDP = lpContext; 2834 DPSESSIONDESC2 dpsd; 2835 DPCREDENTIALS dpCredentials; 2836 HRESULT hr; 2837 2838 if (dwFlags & DPESC_TIMEDOUT) 2839 { 2840 return FALSE; 2841 } 2842 2843 checkFlags( DPSESSION_SECURESERVER, lpThisSD->dwFlags, FLAGS_DPSESSION ); 2844 2845 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 2846 dpsd.dwSize = sizeof(DPSESSIONDESC2); 2847 dpsd.guidApplication = appGuid; 2848 dpsd.guidInstance = lpThisSD->guidInstance; 2849 2850 ZeroMemory( &dpCredentials, sizeof(DPCREDENTIALS) ); 2851 dpCredentials.dwSize = sizeof(DPCREDENTIALS); 2852 U1(dpCredentials).lpszUsernameA = (LPSTR) "user"; 2853 U2(dpCredentials).lpszPasswordA = (LPSTR) "pass"; 2854 hr = IDirectPlayX_SecureOpen( pDP, &dpsd, DPOPEN_JOIN, 2855 NULL, &dpCredentials ); 2856 checkHR( DPERR_LOGONDENIED, hr ); /* TODO: Make this work */ 2857 2858 return TRUE; 2859 } 2860 2861 static void test_GetPlayerAccount(void) 2862 { 2863 2864 IDirectPlay4 *pDP[2]; 2865 DPSESSIONDESC2 dpsd; 2866 DPID dpid[2]; 2867 HRESULT hr; 2868 UINT i; 2869 2870 DWORD dwDataSize = 1024; 2871 LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize ); 2872 2873 2874 for (i=0; i<2; i++) 2875 { 2876 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 2877 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 2878 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 2879 if (FAILED(hr)) return; 2880 } 2881 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 2882 dpsd.dwSize = sizeof(DPSESSIONDESC2); 2883 dpsd.guidApplication = appGuid; 2884 dpsd.dwMaxPlayers = 10; 2885 2886 /* Uninitialized service provider */ 2887 hr = IDirectPlayX_GetPlayerAccount( pDP[0], 0, 0, lpData, &dwDataSize ); 2888 todo_wine checkHR( DPERR_UNINITIALIZED, hr ); 2889 2890 if ( hr == DP_OK ) 2891 { 2892 todo_wine win_skip( "GetPlayerAccount not implemented\n" ); 2893 return; 2894 } 2895 2896 2897 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 ); 2898 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 ); 2899 2900 2901 /* No session */ 2902 hr = IDirectPlayX_GetPlayerAccount( pDP[0], 0, 0, lpData, &dwDataSize ); 2903 checkHR( DPERR_NOSESSIONS, hr ); 2904 2905 2906 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 2907 IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join, 2908 pDP[1], 0 ); 2909 2910 for (i=0; i<2; i++) 2911 { 2912 hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i], NULL, NULL, NULL, 2913 0, 0 ); 2914 checkHR( DP_OK, hr ); 2915 } 2916 2917 2918 /* Session is not secure */ 2919 dwDataSize = 1024; 2920 hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0, 2921 lpData, &dwDataSize ); 2922 checkHR( DPERR_UNSUPPORTED, hr ); 2923 check( 1024, dwDataSize ); 2924 2925 2926 /* Open a secure session */ 2927 for (i=0; i<2; i++) 2928 { 2929 hr = IDirectPlayX_Close( pDP[i] ); 2930 checkHR( DP_OK, hr ); 2931 } 2932 2933 dpsd.dwFlags = DPSESSION_SECURESERVER; 2934 hr = IDirectPlayX_SecureOpen( pDP[0], &dpsd, DPOPEN_CREATE, NULL, NULL ); 2935 checkHR( DP_OK, hr ); 2936 2937 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], 2938 NULL, NULL, NULL, 0, 0 ); 2939 checkHR( DP_OK, hr ); 2940 2941 hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, 2942 EnumSessions_cb_join_secure, pDP[1], 0 ); 2943 checkHR( DP_OK, hr ); 2944 2945 hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid[1], 2946 NULL, NULL, NULL, 0, 0 ); 2947 checkHR( DPERR_INVALIDPARAMS, hr ); 2948 2949 /* TODO: Player creation so that this works */ 2950 2951 /* Invalid player */ 2952 dwDataSize = 1024; 2953 hr = IDirectPlayX_GetPlayerAccount( pDP[0], 0, 0, 2954 lpData, &dwDataSize ); 2955 checkHR( DPERR_INVALIDPLAYER, hr ); 2956 check( 1024, dwDataSize ); 2957 2958 /* Invalid flags */ 2959 dwDataSize = 1024; 2960 hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], -1, 2961 lpData, &dwDataSize ); 2962 checkHR( DPERR_INVALIDFLAGS, hr ); 2963 check( 1024, dwDataSize ); 2964 2965 dwDataSize = 1024; 2966 hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 1, 2967 lpData, &dwDataSize ); 2968 checkHR( DPERR_INVALIDFLAGS, hr ); 2969 check( 1024, dwDataSize ); 2970 2971 /* Small buffer */ 2972 dwDataSize = 1024; 2973 hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0, 2974 NULL, &dwDataSize ); 2975 checkHR( DPERR_INVALIDPLAYER, hr ); 2976 check( 0, dwDataSize ); 2977 2978 dwDataSize = 0; 2979 hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0, 2980 lpData, &dwDataSize ); 2981 checkHR( DPERR_INVALIDPLAYER, hr ); 2982 check( 0, dwDataSize ); 2983 2984 hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0, 2985 lpData, &dwDataSize ); 2986 checkHR( DPERR_INVALIDPLAYER, hr ); 2987 check( 0, dwDataSize ); 2988 2989 /* Normal operation */ 2990 dwDataSize = 1024; 2991 hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0, 2992 lpData, &dwDataSize ); 2993 checkHR( DPERR_INVALIDPLAYER, hr ); 2994 check( 1024, dwDataSize ); 2995 2996 2997 HeapFree( GetProcessHeap(), 0, lpData ); 2998 IDirectPlayX_Release( pDP[0] ); 2999 IDirectPlayX_Release( pDP[1] ); 3000 3001 } 3002 3003 /* GetPlayerAddress */ 3004 3005 static BOOL CALLBACK EnumAddress_cb( REFGUID guidDataType, 3006 DWORD dwDataSize, 3007 LPCVOID lpData, 3008 LPVOID lpContext ) 3009 { 3010 lpCallbackData callbackData = lpContext; 3011 static REFGUID types[] = { &DPAID_TotalSize, 3012 &DPAID_ServiceProvider, 3013 &DPAID_INet, 3014 &DPAID_INetW }; 3015 static DWORD sizes[] = { 4, 16, 12, 24, 4, 16, 10, 20 }; 3016 3017 3018 checkGuid( types[callbackData->dwCounter1%4], guidDataType ); 3019 check( sizes[callbackData->dwCounter1], dwDataSize ); 3020 3021 switch(callbackData->dwCounter1) 3022 { 3023 case 0: 3024 check( 136, *(LPDWORD) lpData ); 3025 break; 3026 case 4: 3027 check( 130, *(LPDWORD) lpData ); 3028 break; 3029 case 1: 3030 case 5: 3031 checkGuid( &DPSPGUID_TCPIP, lpData ); 3032 break; 3033 case 6: 3034 checkStr( "127.0.0.1", (LPSTR) lpData ); 3035 break; 3036 default: break; 3037 } 3038 3039 3040 callbackData->dwCounter1++; 3041 3042 return TRUE; 3043 } 3044 3045 static void test_GetPlayerAddress(void) 3046 { 3047 3048 IDirectPlay4 *pDP[2]; 3049 IDirectPlayLobby3 *pDPL; 3050 DPSESSIONDESC2 dpsd; 3051 DPID dpid[2]; 3052 CallbackData callbackData; 3053 HRESULT hr; 3054 UINT i; 3055 3056 DWORD dwDataSize = 1024; 3057 LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize ); 3058 3059 3060 for (i=0; i<2; i++) 3061 { 3062 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 3063 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 3064 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 3065 if (FAILED(hr)) return; 3066 } 3067 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 3068 hr = CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL, 3069 &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL ); 3070 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlayLobby / IID_IDirectPlayLobby3A failed\n" ); 3071 if (FAILED(hr)) return; 3072 3073 /* Uninitialized service provider */ 3074 hr = IDirectPlayX_GetPlayerAddress( pDP[0], 0, lpData, &dwDataSize ); 3075 todo_wine checkHR( DPERR_UNINITIALIZED, hr ); 3076 3077 if ( hr == DP_OK ) 3078 { 3079 todo_wine win_skip( "GetPlayerAddress not implemented\n" ); 3080 goto cleanup; 3081 } 3082 3083 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 ); 3084 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 ); 3085 3086 3087 /* No session */ 3088 dwDataSize = 1024; 3089 hr = IDirectPlayX_GetPlayerAddress( pDP[0], 0, lpData, &dwDataSize ); 3090 checkHR( DPERR_UNSUPPORTED, hr ); 3091 check( 1024, dwDataSize ); 3092 3093 dwDataSize = 1024; 3094 hr = IDirectPlayX_GetPlayerAddress( pDP[0], 1, lpData, &dwDataSize ); 3095 checkHR( DPERR_INVALIDPLAYER, hr ); 3096 check( 1024, dwDataSize ); 3097 3098 3099 dpsd.dwSize = sizeof(DPSESSIONDESC2); 3100 dpsd.guidApplication = appGuid; 3101 dpsd.dwMaxPlayers = 10; 3102 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 3103 IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join, 3104 pDP[1], 0 ); 3105 3106 for (i=0; i<2; i++) 3107 { 3108 hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i], NULL, NULL, NULL, 3109 0, 0 ); 3110 checkHR( DP_OK, hr ); 3111 } 3112 3113 /* Invalid player */ 3114 dwDataSize = 1024; 3115 hr = IDirectPlayX_GetPlayerAddress( pDP[0], 0, 3116 lpData, &dwDataSize ); 3117 checkHR( DPERR_UNSUPPORTED, hr ); 3118 check( 1024, dwDataSize ); 3119 3120 dwDataSize = 1024; 3121 hr = IDirectPlayX_GetPlayerAddress( pDP[0], 1, 3122 lpData, &dwDataSize ); 3123 checkHR( DPERR_INVALIDPLAYER, hr ); 3124 check( 1024, dwDataSize ); 3125 3126 /* Small buffer */ 3127 dwDataSize = 1024; 3128 hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0], 3129 NULL, &dwDataSize ); 3130 checkHR( DPERR_BUFFERTOOSMALL, hr ); 3131 check( 136, dwDataSize ); 3132 3133 dwDataSize = 0; 3134 hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0], 3135 lpData, &dwDataSize ); 3136 checkHR( DPERR_BUFFERTOOSMALL, hr ); 3137 check( 136, dwDataSize ); 3138 3139 hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0], 3140 lpData, &dwDataSize ); 3141 checkHR( DP_OK, hr ); 3142 check( 136, dwDataSize ); 3143 3144 3145 /* Regular parameters */ 3146 callbackData.dwCounter1 = 0; 3147 3148 /* - Local */ 3149 dwDataSize = 1024; 3150 hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0], 3151 lpData, &dwDataSize ); 3152 checkHR( DP_OK, hr ); 3153 check( 136, dwDataSize ); 3154 3155 hr = IDirectPlayLobby_EnumAddress( pDPL, EnumAddress_cb, lpData, dwDataSize, 3156 &callbackData ); 3157 checkHR( DP_OK, hr ); 3158 3159 check( 4, callbackData.dwCounter1 ); 3160 3161 /* - Remote */ 3162 dwDataSize = 1024; 3163 hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[1], 3164 lpData, &dwDataSize ); 3165 checkHR( DP_OK, hr ); 3166 check( 130, dwDataSize ); 3167 3168 hr = IDirectPlayLobby_EnumAddress( pDPL, EnumAddress_cb, lpData, dwDataSize, 3169 &callbackData ); 3170 checkHR( DP_OK, hr ); 3171 3172 check( 8, callbackData.dwCounter1 ); 3173 3174 3175 HeapFree( GetProcessHeap(), 0, lpData ); 3176 3177 cleanup: 3178 IDirectPlayX_Release( pDP[0] ); 3179 IDirectPlayX_Release( pDP[1] ); 3180 IDirectPlayLobby_Release(pDPL); 3181 } 3182 3183 /* GetPlayerFlags */ 3184 3185 static void test_GetPlayerFlags(void) 3186 { 3187 3188 IDirectPlay4 *pDP[2]; 3189 DPSESSIONDESC2 dpsd; 3190 DPID dpid[4]; 3191 HRESULT hr; 3192 UINT i; 3193 3194 DWORD dwFlags = 0; 3195 3196 3197 for (i=0; i<2; i++) 3198 { 3199 hr= CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 3200 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 3201 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 3202 if (FAILED(hr)) return; 3203 } 3204 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 3205 dpsd.dwSize = sizeof(DPSESSIONDESC2); 3206 dpsd.guidApplication = appGuid; 3207 dpsd.dwMaxPlayers = 10; 3208 3209 /* Uninitialized service provider */ 3210 hr = IDirectPlayX_GetPlayerFlags( pDP[0], 0, &dwFlags ); 3211 todo_wine checkHR( DPERR_UNINITIALIZED, hr ); 3212 3213 if ( hr == DP_OK ) 3214 { 3215 todo_wine win_skip( "GetPlayerFlags not implemented\n" ); 3216 return; 3217 } 3218 3219 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 ); 3220 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 ); 3221 3222 3223 /* No session */ 3224 hr = IDirectPlayX_GetPlayerFlags( pDP[0], 0, &dwFlags ); 3225 checkHR( DPERR_INVALIDPLAYER, hr ); 3226 3227 hr = IDirectPlayX_GetPlayerFlags( pDP[0], 1, &dwFlags ); 3228 checkHR( DPERR_INVALIDPLAYER, hr ); 3229 3230 3231 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 3232 IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join, 3233 pDP[1], 0 ); 3234 3235 for (i=0; i<2; i++) 3236 { 3237 hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i], 3238 NULL, NULL, NULL, 0, 0 ); 3239 checkHR( DP_OK, hr ); 3240 } 3241 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[2], 3242 NULL, NULL, NULL, 3243 0, DPPLAYER_SPECTATOR ); 3244 checkHR( DP_OK, hr ); 3245 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[3], 3246 NULL, NULL, NULL, 3247 0, DPPLAYER_SERVERPLAYER ); 3248 checkHR( DP_OK, hr ); 3249 3250 3251 /* Invalid player */ 3252 hr = IDirectPlayX_GetPlayerFlags( pDP[0], 0, &dwFlags ); 3253 checkHR( DPERR_INVALIDPLAYER, hr ); 3254 3255 hr = IDirectPlayX_GetPlayerFlags( pDP[0], 2, &dwFlags ); 3256 checkHR( DPERR_INVALIDPLAYER, hr ); 3257 3258 /* Invalid parameters */ 3259 hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[0], NULL ); 3260 checkHR( DPERR_INVALIDPARAMS, hr ); 3261 3262 3263 /* Regular parameters */ 3264 hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[0], &dwFlags ); 3265 checkHR( DP_OK, hr ); 3266 checkFlags( dwFlags, DPPLAYER_LOCAL, FLAGS_DPPLAYER ); 3267 3268 hr = IDirectPlayX_GetPlayerFlags( pDP[1], dpid[1], &dwFlags ); 3269 checkHR( DP_OK, hr ); 3270 checkFlags( dwFlags, DPPLAYER_LOCAL, FLAGS_DPPLAYER ); 3271 3272 hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[1], &dwFlags ); 3273 checkHR( DP_OK, hr ); 3274 checkFlags( dwFlags, 0, FLAGS_DPPLAYER ); 3275 3276 hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[2], &dwFlags ); 3277 checkHR( DP_OK, hr ); 3278 checkFlags( dwFlags, DPPLAYER_SPECTATOR | DPPLAYER_LOCAL, FLAGS_DPPLAYER ); 3279 3280 hr = IDirectPlayX_GetPlayerFlags( pDP[1], dpid[3], &dwFlags ); 3281 checkHR( DP_OK, hr ); 3282 checkFlags( dwFlags, DPPLAYER_SERVERPLAYER, FLAGS_DPPLAYER ); 3283 3284 3285 IDirectPlayX_Release( pDP[0] ); 3286 IDirectPlayX_Release( pDP[1] ); 3287 3288 } 3289 3290 /* CreateGroup 3291 CreateGroupInGroup */ 3292 3293 static void test_CreateGroup(void) 3294 { 3295 3296 IDirectPlay4 *pDP; 3297 DPSESSIONDESC2 dpsd; 3298 DPID idFrom, idTo, dpid, idGroup, idGroupParent; 3299 DPNAME groupName; 3300 HRESULT hr; 3301 UINT i; 3302 3303 LPCSTR lpData = "data"; 3304 DWORD dwDataSize = strlen(lpData)+1; 3305 LPDPMSG_CREATEPLAYERORGROUP lpDataGet = HeapAlloc( GetProcessHeap(), 3306 HEAP_ZERO_MEMORY, 3307 1024 ); 3308 DWORD dwDataSizeGet = 1024; 3309 CallbackData callbackData; 3310 3311 3312 hr= CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 3313 &IID_IDirectPlay4A, (LPVOID*) &pDP ); 3314 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 3315 if (FAILED(hr)) return; 3316 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 3317 dpsd.dwSize = sizeof(DPSESSIONDESC2); 3318 dpsd.guidApplication = appGuid; 3319 dpsd.dwMaxPlayers = 10; 3320 ZeroMemory( &groupName, sizeof(DPNAME) ); 3321 3322 3323 /* No service provider */ 3324 hr = IDirectPlayX_CreateGroup( pDP, &idGroup, NULL, NULL, 0, 0 ); 3325 checkHR( DPERR_UNINITIALIZED, hr ); 3326 3327 hr = IDirectPlayX_CreateGroupInGroup( pDP, 0, &idGroup, NULL, NULL, 0, 0 ); 3328 checkHR( DPERR_UNINITIALIZED, hr ); 3329 3330 3331 3332 init_TCPIP_provider( pDP, "127.0.0.1", 0 ); 3333 3334 3335 /* No session */ 3336 hr = IDirectPlayX_CreateGroup( pDP, &idGroup, 3337 NULL, NULL, 0, 0 ); 3338 todo_wine checkHR( DPERR_INVALIDPARAMS, hr ); 3339 3340 if ( hr == DPERR_UNINITIALIZED ) 3341 { 3342 todo_wine win_skip( "CreateGroup not implemented\n" ); 3343 return; 3344 } 3345 3346 hr = IDirectPlayX_CreateGroupInGroup( pDP, 0, &idGroup, 3347 NULL, NULL, 0, 0 ); 3348 checkHR( DPERR_INVALIDGROUP, hr ); 3349 3350 hr = IDirectPlayX_CreateGroupInGroup( pDP, 2, &idGroup, 3351 NULL, NULL, 0, 0 ); 3352 checkHR( DPERR_INVALIDGROUP, hr ); 3353 3354 3355 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE ); 3356 checkHR( DP_OK, hr ); 3357 IDirectPlayX_CreatePlayer( pDP, &dpid, 3358 NULL, NULL, NULL, 0, 0 ); 3359 3360 3361 3362 /* With name */ 3363 hr = IDirectPlayX_CreateGroup( pDP, &idGroup, 3364 NULL, NULL, 0, 0 ); 3365 checkHR( DP_OK, hr ); 3366 3367 hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup, 3368 NULL, NULL, 0, 0 ); 3369 checkHR( DP_OK, hr ); 3370 3371 hr = IDirectPlayX_CreateGroup( pDP, &idGroup, 3372 &groupName, NULL, 0, 0 ); 3373 checkHR( DP_OK, hr ); 3374 3375 hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup, 3376 &groupName, NULL, 0, 0 ); 3377 checkHR( DP_OK, hr ); 3378 3379 3380 groupName.dwSize = sizeof(DPNAME); 3381 U1(groupName).lpszShortNameA = (LPSTR) lpData; 3382 3383 3384 hr = IDirectPlayX_CreateGroup( pDP, &idGroup, 3385 &groupName, NULL, 0, 0 ); 3386 checkHR( DP_OK, hr ); 3387 3388 hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup, 3389 &groupName, NULL, 0, 0 ); 3390 checkHR( DP_OK, hr ); 3391 3392 3393 /* Message checking */ 3394 for (i=0; i<6; i++) 3395 { 3396 dwDataSizeGet = 1024; 3397 hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpDataGet, 3398 &dwDataSizeGet ); 3399 checkHR( DP_OK, hr ); 3400 if ( NULL == U1(lpDataGet->dpnName).lpszShortNameA ) 3401 { 3402 check( 48, dwDataSizeGet ); 3403 } 3404 else 3405 { 3406 check( 48 + dwDataSize, dwDataSizeGet ); 3407 checkStr( lpData, U1(lpDataGet->dpnName).lpszShortNameA ); 3408 } 3409 check( DPID_SYSMSG, idFrom ); 3410 checkConv( DPSYS_CREATEPLAYERORGROUP, lpDataGet->dwType, dpMsgType2str ); 3411 check( DPPLAYERTYPE_GROUP, lpDataGet->dwPlayerType ); 3412 checkFlags( DPGROUP_LOCAL, lpDataGet->dwFlags, FLAGS_DPGROUP ); 3413 } 3414 check_messages( pDP, &dpid, 1, &callbackData ); 3415 checkStr( "", callbackData.szTrace1 ); 3416 3417 3418 /* With data */ 3419 hr = IDirectPlayX_CreateGroup( pDP, &idGroup, 3420 NULL, (LPVOID) lpData, -1, 0 ); 3421 checkHR( DPERR_INVALIDPARAMS, hr ); 3422 3423 hr = IDirectPlayX_CreateGroup( pDP, &idGroup, 3424 NULL, (LPVOID) lpData, 0, 0 ); 3425 checkHR( DP_OK, hr ); 3426 3427 hr = IDirectPlayX_CreateGroup( pDP, &idGroup, 3428 NULL, NULL, dwDataSize, 0 ); 3429 checkHR( DPERR_INVALIDPARAMS, hr ); 3430 3431 hr = IDirectPlayX_CreateGroup( pDP, &idGroup, 3432 NULL, (LPVOID) lpData, dwDataSize, 0 ); 3433 checkHR( DP_OK, hr ); 3434 3435 3436 hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup, 3437 NULL, (LPVOID) lpData, -1, 0 ); 3438 checkHR( DPERR_INVALIDPARAMS, hr ); 3439 3440 hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup, 3441 NULL, (LPVOID) lpData, 0, 0 ); 3442 checkHR( DP_OK, hr ); 3443 3444 hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup, 3445 NULL, NULL, dwDataSize, 0 ); 3446 checkHR( DPERR_INVALIDPARAMS, hr ); 3447 3448 hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup, 3449 NULL, (LPVOID)lpData, dwDataSize, 0 ); 3450 checkHR( DP_OK, hr ); 3451 3452 3453 hr = IDirectPlayX_CreateGroup( pDP, &idGroupParent, 3454 NULL, NULL, 0, 0 ); 3455 checkHR( DP_OK, hr ); 3456 3457 3458 /* Message checking */ 3459 for (i=0; i<5; i++) 3460 { 3461 dwDataSizeGet = 1024; 3462 hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpDataGet, 3463 &dwDataSizeGet ); 3464 checkHR( DP_OK, hr ); 3465 check( 48 + lpDataGet->dwDataSize, dwDataSizeGet ); 3466 check( DPID_SYSMSG, idFrom ); 3467 checkConv( DPSYS_CREATEPLAYERORGROUP, lpDataGet->dwType, dpMsgType2str ); 3468 check( DPPLAYERTYPE_GROUP, lpDataGet->dwPlayerType ); 3469 checkFlags( DPGROUP_LOCAL, lpDataGet->dwFlags, FLAGS_DPGROUP ); 3470 } 3471 check_messages( pDP, &dpid, 1, &callbackData ); 3472 checkStr( "", callbackData.szTrace1 ); 3473 3474 3475 /* Flags and idGroupParent */ 3476 hr = IDirectPlayX_CreateGroup( pDP, &idGroup, 3477 NULL, NULL, 0, 0 ); 3478 checkHR( DP_OK, hr ); 3479 3480 hr = IDirectPlayX_CreateGroup( pDP, &idGroup, 3481 NULL, NULL, 0, DPGROUP_HIDDEN ); 3482 checkHR( DP_OK, hr ); 3483 3484 hr = IDirectPlayX_CreateGroup( pDP, &idGroup, 3485 NULL, NULL, 0, DPGROUP_STAGINGAREA ); 3486 checkHR( DP_OK, hr ); 3487 3488 hr = IDirectPlayX_CreateGroup( pDP, &idGroup, 3489 NULL, NULL, 0, 3490 DPGROUP_HIDDEN | DPGROUP_STAGINGAREA ); 3491 checkHR( DP_OK, hr ); 3492 3493 3494 hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroupParent, &idGroup, 3495 NULL, NULL, 0, 0 ); 3496 checkHR( DP_OK, hr ); 3497 3498 hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroupParent, &idGroup, 3499 NULL, NULL, 0, DPGROUP_HIDDEN ); 3500 checkHR( DP_OK, hr ); 3501 3502 hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroupParent, &idGroup, 3503 NULL, NULL, 0, DPGROUP_STAGINGAREA ); 3504 checkHR( DP_OK, hr ); 3505 3506 hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroupParent, &idGroup, 3507 NULL, NULL, 0, 3508 DPGROUP_HIDDEN | 3509 DPGROUP_STAGINGAREA ); 3510 checkHR( DP_OK, hr ); 3511 3512 3513 /* Message checking */ 3514 for (i=0; i<8; i++) 3515 { 3516 dwDataSizeGet = 1024; 3517 hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpDataGet, 3518 &dwDataSizeGet ); 3519 checkHR( DP_OK, hr ); 3520 check( 48, dwDataSizeGet ); 3521 check( DPID_SYSMSG, idFrom ); 3522 checkConv( DPSYS_CREATEPLAYERORGROUP, lpDataGet->dwType, dpMsgType2str ); 3523 check( DPPLAYERTYPE_GROUP, lpDataGet->dwPlayerType ); 3524 3525 if ( lpDataGet->dpIdParent != 0 ) 3526 { 3527 check( idGroupParent, lpDataGet->dpIdParent ); 3528 } 3529 3530 switch (i%4) 3531 { 3532 case 0: 3533 checkFlags( DPGROUP_LOCAL, 3534 lpDataGet->dwFlags, FLAGS_DPGROUP ); 3535 break; 3536 case 1: 3537 checkFlags( DPGROUP_LOCAL | DPGROUP_HIDDEN, 3538 lpDataGet->dwFlags, FLAGS_DPGROUP ); 3539 break; 3540 case 2: 3541 checkFlags( DPGROUP_STAGINGAREA | DPGROUP_LOCAL, 3542 lpDataGet->dwFlags, FLAGS_DPGROUP ); 3543 break; 3544 case 3: 3545 checkFlags( DPGROUP_STAGINGAREA | DPGROUP_LOCAL | DPGROUP_HIDDEN, 3546 lpDataGet->dwFlags, FLAGS_DPGROUP ); 3547 break; 3548 default: break; 3549 } 3550 } 3551 check_messages( pDP, &dpid, 1, &callbackData ); 3552 checkStr( "", callbackData.szTrace1 ); 3553 3554 3555 /* If a group is created in C/S mode, no messages are sent */ 3556 3557 /* - Peer 2 peer */ 3558 IDirectPlayX_Close( pDP ); 3559 3560 dpsd.dwFlags = 0; 3561 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE ); 3562 checkHR( DP_OK, hr ); 3563 hr = IDirectPlayX_CreatePlayer( pDP, &dpid, NULL, NULL, NULL, 0, 0 ); 3564 checkHR( DP_OK, hr ); 3565 3566 hr = IDirectPlayX_CreateGroup( pDP, &idGroup, NULL, NULL, 0, 0 ); 3567 checkHR( DP_OK, hr ); 3568 3569 /* Messages are received */ 3570 check_messages( pDP, &dpid, 1, &callbackData ); 3571 checkStr( "S0,", callbackData.szTrace1 ); 3572 3573 3574 /* - Client/Server */ 3575 IDirectPlayX_Close( pDP ); 3576 3577 dpsd.dwFlags = DPSESSION_CLIENTSERVER; 3578 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE ); 3579 checkHR( DP_OK, hr ); 3580 hr = IDirectPlayX_CreatePlayer( pDP, &dpid, 3581 NULL, NULL, NULL, 0, 3582 DPPLAYER_SERVERPLAYER ); 3583 checkHR( DP_OK, hr ); 3584 3585 hr = IDirectPlayX_CreateGroup( pDP, &idGroup, 3586 NULL, NULL, 0, 0 ); 3587 checkHR( DP_OK, hr ); 3588 3589 /* No messages */ 3590 check_messages( pDP, &dpid, 1, &callbackData ); 3591 checkStr( "S0,", callbackData.szTrace1 ); /* Or at least there 3592 shouldn't be messages... */ 3593 3594 3595 HeapFree( GetProcessHeap(), 0, lpDataGet ); 3596 IDirectPlayX_Release( pDP ); 3597 3598 } 3599 3600 /* GroupOwner */ 3601 3602 static void test_GroupOwner(void) 3603 { 3604 3605 IDirectPlay4 *pDP[2]; 3606 DPSESSIONDESC2 dpsd; 3607 DPID dpid[2], idGroup, idOwner; 3608 HRESULT hr; 3609 UINT i; 3610 3611 3612 for (i=0; i<2; i++) 3613 { 3614 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 3615 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 3616 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 3617 if (FAILED(hr)) return; 3618 } 3619 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 3620 dpsd.dwSize = sizeof(DPSESSIONDESC2); 3621 dpsd.guidApplication = appGuid; 3622 dpsd.dwMaxPlayers = 10; 3623 idGroup = 0; 3624 idOwner = 0; 3625 3626 /* Service provider not initialized */ 3627 hr = IDirectPlayX_GetGroupOwner( pDP[0], idGroup, &idOwner ); 3628 todo_wine checkHR( DPERR_UNINITIALIZED, hr ); 3629 check( 0, idOwner ); 3630 3631 if ( hr == DP_OK ) 3632 { 3633 todo_wine win_skip( "GetGroupOwner not implemented\n" ); 3634 return; 3635 } 3636 3637 3638 for (i=0; i<2; i++) 3639 init_TCPIP_provider( pDP[i], "127.0.0.1", 0 ); 3640 3641 hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 3642 checkHR( DP_OK, hr ); 3643 hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join, 3644 pDP[1], 0 ); 3645 checkHR( DP_OK, hr ); 3646 3647 for (i=0; i<2; i++) 3648 { 3649 hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i], 3650 NULL, NULL, NULL, 0, 0 ); 3651 checkHR( DP_OK, hr ); 3652 } 3653 3654 /* Invalid group */ 3655 hr = IDirectPlayX_GetGroupOwner( pDP[0], idGroup, &idOwner ); 3656 checkHR( DPERR_INVALIDGROUP, hr ); 3657 3658 hr = IDirectPlayX_CreateGroup( pDP[0], &idGroup, NULL, NULL, 0, 0 ); 3659 checkHR( DP_OK, hr ); 3660 3661 /* Fails, because we need a lobby session */ 3662 hr = IDirectPlayX_GetGroupOwner( pDP[0], idGroup, &idOwner ); 3663 checkHR( DPERR_UNSUPPORTED, hr ); 3664 3665 3666 /* TODO: 3667 * - Make this work 3668 * - Check migration of the ownership of a group 3669 * when the owner leaves 3670 */ 3671 3672 3673 IDirectPlayX_Release( pDP[0] ); 3674 IDirectPlayX_Release( pDP[1] ); 3675 3676 } 3677 3678 /* EnumPlayers */ 3679 3680 static BOOL CALLBACK EnumPlayers_cb( DPID dpId, 3681 DWORD dwPlayerType, 3682 LPCDPNAME lpName, 3683 DWORD dwFlags, 3684 LPVOID lpContext ) 3685 { 3686 lpCallbackData callbackData = lpContext; 3687 char playerIndex = dpid2char( callbackData->dpid, 3688 callbackData->dpidSize, 3689 dpId ); 3690 3691 3692 /* Trace to study player ids */ 3693 callbackData->szTrace1[ callbackData->dwCounter1 ] = playerIndex; 3694 callbackData->dwCounter1++; 3695 callbackData->szTrace1[ callbackData->dwCounter1 ] = '\0'; 3696 3697 /* Trace to study flags received */ 3698 strcat( callbackData->szTrace2, 3699 ( dwFlags2str(dwFlags, FLAGS_DPENUMPLAYERS) + 3700 strlen("DPENUMPLAYERS_") ) ); 3701 strcat( callbackData->szTrace2, ":" ); 3702 3703 3704 if ( playerIndex < '5' ) 3705 { 3706 check( DPPLAYERTYPE_PLAYER, dwPlayerType ); 3707 } 3708 else 3709 { 3710 check( DPPLAYERTYPE_GROUP, dwPlayerType ); 3711 } 3712 3713 return TRUE; 3714 3715 } 3716 3717 static BOOL CALLBACK EnumSessions_cb_EnumPlayers( LPCDPSESSIONDESC2 lpThisSD, 3718 LPDWORD lpdwTimeOut, 3719 DWORD dwFlags, 3720 LPVOID lpContext ) 3721 { 3722 lpCallbackData callbackData = lpContext; 3723 HRESULT hr; 3724 3725 if (dwFlags & DPESC_TIMEDOUT) 3726 { 3727 return FALSE; 3728 } 3729 3730 /* guid = NULL */ 3731 callbackData->dwCounter1 = 0; 3732 hr = IDirectPlayX_EnumPlayers( callbackData->pDP, NULL, EnumPlayers_cb, 3733 &callbackData, 0 ); 3734 checkHR( DPERR_NOSESSIONS, hr ); 3735 check( 0, callbackData->dwCounter1 ); 3736 3737 /* guid = appGuid */ 3738 callbackData->dwCounter1 = 0; 3739 hr = IDirectPlayX_EnumPlayers( callbackData->pDP, (LPGUID) &appGuid, 3740 EnumPlayers_cb, &callbackData, 0 ); 3741 checkHR( DPERR_NOSESSIONS, hr ); 3742 check( 0, callbackData->dwCounter1 ); 3743 3744 callbackData->dwCounter1 = 0; 3745 hr = IDirectPlayX_EnumPlayers( callbackData->pDP, (LPGUID) &appGuid, 3746 EnumPlayers_cb, &callbackData, 3747 DPENUMPLAYERS_SESSION ); 3748 checkHR( DPERR_NOSESSIONS, hr ); 3749 check( 0, callbackData->dwCounter1 ); 3750 3751 /* guid = guidInstance */ 3752 callbackData->dwCounter1 = 0; 3753 hr = IDirectPlayX_EnumPlayers( callbackData->pDP, 3754 (LPGUID) &lpThisSD->guidInstance, 3755 EnumPlayers_cb, &callbackData, 0 ); 3756 checkHR( DPERR_NOSESSIONS, hr ); 3757 check( 0, callbackData->dwCounter1 ); 3758 3759 callbackData->dwCounter1 = 0; 3760 hr = IDirectPlayX_EnumPlayers( callbackData->pDP, 3761 (LPGUID) &lpThisSD->guidInstance, 3762 EnumPlayers_cb, &callbackData, 3763 DPENUMPLAYERS_SESSION ); 3764 checkHR( DPERR_GENERIC, hr ); /* Why? */ 3765 check( 0, callbackData->dwCounter1 ); 3766 3767 return TRUE; 3768 3769 } 3770 3771 static void test_EnumPlayers(void) 3772 { 3773 IDirectPlay4 *pDP[3]; 3774 DPSESSIONDESC2 dpsd[3]; 3775 DPID dpid[5+2]; /* 5 players, 2 groups */ 3776 CallbackData callbackData; 3777 HRESULT hr; 3778 UINT i; 3779 3780 3781 for (i=0; i<3; i++) 3782 { 3783 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 3784 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 3785 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 3786 if (FAILED(hr)) return; 3787 3788 ZeroMemory( &dpsd[i], sizeof(DPSESSIONDESC2) ); 3789 dpsd[i].dwSize = sizeof(DPSESSIONDESC2); 3790 } 3791 3792 dpsd[0].guidApplication = appGuid; 3793 dpsd[1].guidApplication = appGuid2; 3794 dpsd[2].guidApplication = GUID_NULL; 3795 3796 callbackData.dpid = dpid; 3797 callbackData.dpidSize = 5+2; 3798 3799 3800 /* Uninitialized service provider */ 3801 callbackData.dwCounter1 = 0; 3802 hr = IDirectPlayX_EnumPlayers( pDP[0], (LPGUID) &appGuid, NULL, 3803 &callbackData, 0 ); 3804 checkHR( DPERR_UNINITIALIZED, hr ); 3805 check( 0, callbackData.dwCounter1 ); 3806 3807 3808 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 ); 3809 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 ); 3810 init_TCPIP_provider( pDP[2], "127.0.0.1", 0 ); 3811 3812 3813 /* No session */ 3814 callbackData.dwCounter1 = 0; 3815 hr = IDirectPlayX_EnumPlayers( pDP[0], NULL, EnumPlayers_cb, 3816 &callbackData, 0 ); 3817 todo_wine checkHR( DPERR_NOSESSIONS, hr ); 3818 check( 0, callbackData.dwCounter1 ); 3819 3820 if ( hr == DPERR_UNINITIALIZED ) 3821 { 3822 todo_wine win_skip( "EnumPlayers not implemented\n" ); 3823 return; 3824 } 3825 3826 callbackData.dwCounter1 = 0; 3827 hr = IDirectPlayX_EnumPlayers( pDP[0], (LPGUID) &appGuid, EnumPlayers_cb, 3828 &callbackData, 0 ); 3829 checkHR( DPERR_NOSESSIONS, hr ); 3830 check( 0, callbackData.dwCounter1 ); 3831 3832 callbackData.dwCounter1 = 0; 3833 hr = IDirectPlayX_EnumPlayers( pDP[0], (LPGUID) &appGuid, EnumPlayers_cb, 3834 &callbackData, DPENUMPLAYERS_SESSION ); 3835 checkHR( DPERR_NOSESSIONS, hr ); 3836 check( 0, callbackData.dwCounter1 ); 3837 3838 3839 hr = IDirectPlayX_Open( pDP[0], &dpsd[0], DPOPEN_CREATE ); 3840 checkHR( DP_OK, hr ); 3841 hr = IDirectPlayX_Open( pDP[1], &dpsd[1], DPOPEN_CREATE ); 3842 checkHR( DP_OK, hr ); 3843 3844 3845 /* No players */ 3846 callbackData.dwCounter1 = 0; 3847 hr = IDirectPlayX_EnumPlayers( pDP[0], NULL, EnumPlayers_cb, 3848 &callbackData, 0 ); 3849 checkHR( DP_OK, hr ); 3850 check( 0, callbackData.dwCounter1 ); 3851 3852 3853 /* Create players */ 3854 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], 3855 NULL, NULL, NULL, 0, 3856 DPPLAYER_SERVERPLAYER ); 3857 checkHR( DP_OK, hr ); 3858 hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid[1], 3859 NULL, NULL, NULL, 0, 3860 0 ); 3861 checkHR( DP_OK, hr ); 3862 3863 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[2], 3864 NULL, NULL, NULL, 0, 3865 0 ); 3866 checkHR( DP_OK, hr ); 3867 hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[5], 3868 NULL, NULL, 0, 0 ); 3869 checkHR( DP_OK, hr ); 3870 3871 3872 /* Invalid parameters */ 3873 callbackData.dwCounter1 = 0; 3874 hr = IDirectPlayX_EnumPlayers( pDP[0], (LPGUID) &appGuid, NULL, 3875 &callbackData, 0 ); 3876 checkHR( DPERR_INVALIDPARAMS, hr ); 3877 check( 0, callbackData.dwCounter1 ); 3878 3879 callbackData.dwCounter1 = 0; 3880 hr = IDirectPlayX_EnumPlayers( pDP[0], NULL, EnumPlayers_cb, 3881 &callbackData, DPENUMPLAYERS_SESSION ); 3882 checkHR( DPERR_INVALIDPARAMS, hr ); 3883 check( 0, callbackData.dwCounter1 ); 3884 3885 3886 /* Regular operation */ 3887 callbackData.dwCounter1 = 0; 3888 callbackData.szTrace2[0] = 0; 3889 hr = IDirectPlayX_EnumPlayers( pDP[0], NULL, EnumPlayers_cb, 3890 &callbackData, 0 ); 3891 checkHR( DP_OK, hr ); 3892 check( 2, callbackData.dwCounter1 ); 3893 checkStr( "20", callbackData.szTrace1 ); 3894 checkStr( "ALL:SERVERPLAYER:", callbackData.szTrace2 ); 3895 3896 callbackData.dwCounter1 = 0; 3897 callbackData.szTrace2[0] = 0; 3898 hr = IDirectPlayX_EnumPlayers( pDP[1], NULL, EnumPlayers_cb, 3899 &callbackData, 0 ); 3900 checkHR( DP_OK, hr ); 3901 check( 1, callbackData.dwCounter1 ); 3902 checkStr( "1", callbackData.szTrace1 ); 3903 checkStr( "ALL:", callbackData.szTrace2 ); 3904 3905 callbackData.dwCounter1 = 0; 3906 callbackData.szTrace2[0] = 0; 3907 hr = IDirectPlayX_EnumPlayers( pDP[0], (LPGUID) &appGuid, EnumPlayers_cb, 3908 &callbackData, 0 ); 3909 checkHR( DP_OK, hr ); 3910 check( 2, callbackData.dwCounter1 ); /* Guid is ignored */ 3911 checkStr( "20", callbackData.szTrace1 ); 3912 checkStr( "ALL:SERVERPLAYER:", callbackData.szTrace2 ); 3913 3914 3915 /* Enumerating from a remote session */ 3916 /* - Session not open */ 3917 callbackData.pDP = pDP[2]; 3918 hr = IDirectPlayX_EnumSessions( pDP[2], &dpsd[2], 0, 3919 EnumSessions_cb_EnumPlayers, 3920 &callbackData, 0 ); 3921 checkHR( DP_OK, hr ); 3922 3923 3924 /* - Open session */ 3925 callbackData.pDP = pDP[2]; 3926 hr = IDirectPlayX_EnumSessions( pDP[2], &dpsd[0], 0, EnumSessions_cb_join, 3927 pDP[2], 0 ); 3928 checkHR( DP_OK, hr ); 3929 hr = IDirectPlayX_CreatePlayer( pDP[2], &dpid[3], 3930 NULL, NULL, NULL, 0, 3931 DPPLAYER_SPECTATOR ); 3932 checkHR( DP_OK, hr ); 3933 hr = IDirectPlayX_CreatePlayer( pDP[2], &dpid[4], 3934 NULL, NULL, NULL, 0, 3935 0 ); 3936 checkHR( DP_OK, hr ); 3937 hr = IDirectPlayX_CreateGroup( pDP[2], &dpid[6], 3938 NULL, NULL, 0, 0 ); 3939 checkHR( DP_OK, hr ); 3940 3941 callbackData.dwCounter1 = 0; 3942 callbackData.szTrace2[0] = 0; 3943 hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb, 3944 &callbackData, 0 ); 3945 checkHR( DP_OK, hr ); 3946 check( 4, callbackData.dwCounter1 ); 3947 checkStr( "4302", callbackData.szTrace1 ); 3948 checkStr( "ALL:SPECTATOR:SERVERPLAYER:ALL:", callbackData.szTrace2 ); 3949 3950 3951 /* Flag tests */ 3952 3953 callbackData.dwCounter1 = 0; 3954 callbackData.szTrace2[0] = 0; 3955 hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb, 3956 &callbackData, DPENUMPLAYERS_ALL ); 3957 checkHR( DP_OK, hr ); 3958 check( 4, callbackData.dwCounter1 ); 3959 checkStr( "4302", callbackData.szTrace1 ); 3960 checkStr( "ALL:SPECTATOR:SERVERPLAYER:ALL:", callbackData.szTrace2 ); 3961 3962 callbackData.dwCounter1 = 0; 3963 callbackData.szTrace2[0] = 0; 3964 hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb, 3965 &callbackData, DPENUMPLAYERS_GROUP ); 3966 checkHR( DP_OK, hr ); 3967 check( 6, callbackData.dwCounter1 ); 3968 checkStr( "430256", callbackData.szTrace1 ); 3969 checkStr( "GROUP:" 3970 "GROUP,DPENUMPLAYERS_SPECTATOR:" 3971 "GROUP,DPENUMPLAYERS_SERVERPLAYER:" 3972 "GROUP:ALL:ALL:", callbackData.szTrace2 ); 3973 3974 callbackData.dwCounter1 = 0; 3975 callbackData.szTrace2[0] = 0; 3976 hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb, 3977 &callbackData, DPENUMPLAYERS_LOCAL ); 3978 checkHR( DP_OK, hr ); 3979 check( 2, callbackData.dwCounter1 ); 3980 checkStr( "43", callbackData.szTrace1 ); 3981 checkStr( "LOCAL:" 3982 "LOCAL,DPENUMPLAYERS_SPECTATOR:", callbackData.szTrace2 ); 3983 3984 callbackData.dwCounter1 = 0; 3985 callbackData.szTrace2[0] = 0; 3986 hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb, 3987 &callbackData, DPENUMPLAYERS_SERVERPLAYER ); 3988 checkHR( DP_OK, hr ); 3989 check( 1, callbackData.dwCounter1 ); 3990 checkStr( "0", callbackData.szTrace1 ); 3991 checkStr( "SERVERPLAYER:", callbackData.szTrace2 ); 3992 3993 callbackData.dwCounter1 = 0; 3994 callbackData.szTrace2[0] = 0; 3995 hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb, 3996 &callbackData, DPENUMPLAYERS_SPECTATOR ); 3997 checkHR( DP_OK, hr ); 3998 check( 1, callbackData.dwCounter1 ); 3999 checkStr( "3", callbackData.szTrace1 ); 4000 checkStr( "SPECTATOR:", callbackData.szTrace2 ); 4001 4002 4003 IDirectPlayX_Release( pDP[0] ); 4004 IDirectPlayX_Release( pDP[1] ); 4005 IDirectPlayX_Release( pDP[2] ); 4006 4007 } 4008 4009 /* EnumGroups */ 4010 4011 static BOOL CALLBACK EnumGroups_cb( DPID dpId, 4012 DWORD dwPlayerType, 4013 LPCDPNAME lpName, 4014 DWORD dwFlags, 4015 LPVOID lpContext ) 4016 { 4017 lpCallbackData callbackData = lpContext; 4018 char playerIndex = dpid2char( callbackData->dpid, 4019 callbackData->dpidSize, 4020 dpId ); 4021 4022 4023 /* Trace to study player ids */ 4024 callbackData->szTrace1[ callbackData->dwCounter1 ] = playerIndex; 4025 callbackData->dwCounter1++; 4026 callbackData->szTrace1[ callbackData->dwCounter1 ] = '\0'; 4027 4028 /* Trace to study flags received */ 4029 strcat( callbackData->szTrace2, 4030 ( dwFlags2str(dwFlags, FLAGS_DPENUMGROUPS) + 4031 strlen("DPENUMGROUPS_") ) ); 4032 strcat( callbackData->szTrace2, ":" ); 4033 4034 4035 check( DPPLAYERTYPE_GROUP, dwPlayerType ); 4036 4037 return TRUE; 4038 } 4039 4040 static BOOL CALLBACK EnumSessions_cb_EnumGroups( LPCDPSESSIONDESC2 lpThisSD, 4041 LPDWORD lpdwTimeOut, 4042 DWORD dwFlags, 4043 LPVOID lpContext ) 4044 { 4045 lpCallbackData callbackData = lpContext; 4046 HRESULT hr; 4047 4048 if (dwFlags & DPESC_TIMEDOUT) 4049 { 4050 return FALSE; 4051 } 4052 4053 /* guid = NULL */ 4054 callbackData->dwCounter1 = 0; 4055 hr = IDirectPlayX_EnumGroups( callbackData->pDP, NULL, 4056 EnumGroups_cb, &callbackData, 0 ); 4057 checkHR( DPERR_NOSESSIONS, hr ); 4058 check( 0, callbackData->dwCounter1 ); 4059 4060 /* guid = appGuid */ 4061 callbackData->dwCounter1 = 0; 4062 hr = IDirectPlayX_EnumGroups( callbackData->pDP, (LPGUID) &appGuid, 4063 EnumGroups_cb, &callbackData, 0 ); 4064 checkHR( DPERR_NOSESSIONS, hr ); 4065 check( 0, callbackData->dwCounter1 ); 4066 4067 callbackData->dwCounter1 = 0; 4068 hr = IDirectPlayX_EnumGroups( callbackData->pDP, (LPGUID) &appGuid, 4069 EnumGroups_cb, &callbackData, 4070 DPENUMGROUPS_SESSION ); 4071 checkHR( DPERR_NOSESSIONS, hr ); 4072 check( 0, callbackData->dwCounter1 ); 4073 4074 /* guid = guidInstance */ 4075 callbackData->dwCounter1 = 0; 4076 hr = IDirectPlayX_EnumGroups( callbackData->pDP, 4077 (LPGUID) &lpThisSD->guidInstance, 4078 EnumGroups_cb, &callbackData, 0 ); 4079 checkHR( DPERR_NOSESSIONS, hr ); 4080 check( 0, callbackData->dwCounter1 ); 4081 4082 callbackData->dwCounter1 = 0; 4083 hr = IDirectPlayX_EnumGroups( callbackData->pDP, 4084 (LPGUID) &lpThisSD->guidInstance, 4085 EnumGroups_cb, &callbackData, 4086 DPENUMGROUPS_SESSION ); 4087 checkHR( DPERR_GENERIC, hr ); /* Why? */ 4088 check( 0, callbackData->dwCounter1 ); 4089 4090 return TRUE; 4091 4092 } 4093 4094 static void test_EnumGroups(void) 4095 { 4096 IDirectPlay4 *pDP[3]; 4097 DPSESSIONDESC2 dpsd[3]; 4098 DPID dpid[5]; 4099 CallbackData callbackData; 4100 HRESULT hr; 4101 UINT i; 4102 4103 4104 for (i=0; i<3; i++) 4105 { 4106 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 4107 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 4108 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 4109 if (FAILED(hr)) return; 4110 4111 ZeroMemory( &dpsd[i], sizeof(DPSESSIONDESC2) ); 4112 dpsd[i].dwSize = sizeof(DPSESSIONDESC2); 4113 } 4114 4115 dpsd[0].guidApplication = appGuid; 4116 dpsd[1].guidApplication = appGuid2; 4117 dpsd[2].guidApplication = GUID_NULL; 4118 4119 callbackData.dpid = dpid; 4120 callbackData.dpidSize = 5; 4121 4122 4123 /* Uninitialized service provider */ 4124 callbackData.dwCounter1 = 0; 4125 hr = IDirectPlayX_EnumGroups( pDP[0], NULL, EnumGroups_cb, 4126 &callbackData, 0 ); 4127 checkHR( DPERR_UNINITIALIZED, hr ); 4128 check( 0, callbackData.dwCounter1 ); 4129 4130 4131 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 ); 4132 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 ); 4133 init_TCPIP_provider( pDP[2], "127.0.0.1", 0 ); 4134 4135 4136 /* No session */ 4137 callbackData.dwCounter1 = 0; 4138 hr = IDirectPlayX_EnumGroups( pDP[0], NULL, EnumGroups_cb, 4139 &callbackData, 0 ); 4140 todo_wine checkHR( DPERR_NOSESSIONS, hr ); 4141 check( 0, callbackData.dwCounter1 ); 4142 4143 if ( hr == DPERR_UNINITIALIZED ) 4144 { 4145 todo_wine win_skip( "EnumGroups not implemented\n" ); 4146 return; 4147 } 4148 4149 callbackData.dwCounter1 = 0; 4150 hr = IDirectPlayX_EnumGroups( pDP[0], (LPGUID) &appGuid, EnumGroups_cb, 4151 &callbackData, 0 ); 4152 checkHR( DPERR_NOSESSIONS, hr ); 4153 check( 0, callbackData.dwCounter1 ); 4154 4155 callbackData.dwCounter1 = 0; 4156 hr = IDirectPlayX_EnumGroups( pDP[0], (LPGUID) &appGuid, EnumGroups_cb, 4157 &callbackData, DPENUMGROUPS_SESSION ); 4158 checkHR( DPERR_NOSESSIONS, hr ); 4159 check( 0, callbackData.dwCounter1 ); 4160 4161 4162 hr = IDirectPlayX_Open( pDP[0], &dpsd[0], DPOPEN_CREATE ); 4163 checkHR( DP_OK, hr ); 4164 hr = IDirectPlayX_Open( pDP[1], &dpsd[1], DPOPEN_CREATE ); 4165 checkHR( DP_OK, hr ); 4166 4167 4168 /* No groups */ 4169 callbackData.dwCounter1 = 0; 4170 hr = IDirectPlayX_EnumGroups( pDP[0], NULL, EnumGroups_cb, 4171 &callbackData, 0 ); 4172 checkHR( DP_OK, hr ); 4173 check( 0, callbackData.dwCounter1 ); 4174 4175 4176 /* Create groups */ 4177 hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[0], 4178 NULL, NULL, 0, 0 ); 4179 checkHR( DP_OK, hr ); 4180 hr = IDirectPlayX_CreateGroupInGroup( pDP[0], dpid[0], &dpid[3], 4181 NULL, NULL, 0, 0 ); 4182 checkHR( DP_OK, hr ); /* Not a superior level group, 4183 won't appear in the enumerations */ 4184 hr = IDirectPlayX_CreateGroup( pDP[1], &dpid[1], 4185 NULL, NULL, 0, 0 ); 4186 checkHR( DP_OK, hr ); 4187 hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[2], 4188 NULL, NULL, 0, DPGROUP_HIDDEN ); 4189 checkHR( DP_OK, hr ); 4190 4191 4192 /* Invalid parameters */ 4193 callbackData.dwCounter1 = 0; 4194 hr = IDirectPlayX_EnumGroups( pDP[0], (LPGUID) &appGuid, NULL, 4195 &callbackData, 0 ); 4196 checkHR( DPERR_INVALIDPARAMS, hr ); 4197 check( 0, callbackData.dwCounter1 ); 4198 4199 callbackData.dwCounter1 = 0; 4200 hr = IDirectPlayX_EnumGroups( pDP[0], NULL, EnumGroups_cb, 4201 &callbackData, DPENUMGROUPS_SESSION ); 4202 checkHR( DPERR_INVALIDPARAMS, hr ); 4203 check( 0, callbackData.dwCounter1 ); 4204 4205 4206 /* Regular operation */ 4207 callbackData.dwCounter1 = 0; 4208 callbackData.szTrace2[0] = 0; 4209 hr = IDirectPlayX_EnumGroups( pDP[0], NULL, EnumGroups_cb, 4210 &callbackData, 0 ); 4211 checkHR( DP_OK, hr ); 4212 check( 2, callbackData.dwCounter1 ); 4213 checkStr( "02", callbackData.szTrace1 ); 4214 checkStr( "ALL:HIDDEN:", callbackData.szTrace2 ); 4215 4216 callbackData.dwCounter1 = 0; 4217 callbackData.szTrace2[0] = 0; 4218 hr = IDirectPlayX_EnumGroups( pDP[1], NULL, EnumGroups_cb, 4219 &callbackData, 0 ); 4220 checkHR( DP_OK, hr ); 4221 check( 1, callbackData.dwCounter1 ); 4222 checkStr( "1", callbackData.szTrace1 ); 4223 checkStr( "ALL:", callbackData.szTrace2 ); 4224 4225 callbackData.dwCounter1 = 0; 4226 callbackData.szTrace2[0] = 0; 4227 hr = IDirectPlayX_EnumGroups( pDP[0], (LPGUID) &appGuid, EnumGroups_cb, 4228 &callbackData, 0 ); 4229 checkHR( DP_OK, hr ); 4230 check( 2, callbackData.dwCounter1 ); /* Guid is ignored */ 4231 checkStr( "02", callbackData.szTrace1 ); 4232 checkStr( "ALL:HIDDEN:", callbackData.szTrace2 ); 4233 4234 4235 /* Enumerating from a remote session */ 4236 /* - Session not open */ 4237 callbackData.pDP = pDP[2]; 4238 hr = IDirectPlayX_EnumSessions( pDP[2], &dpsd[2], 0, 4239 EnumSessions_cb_EnumGroups, 4240 &callbackData, 0 ); 4241 checkHR( DP_OK, hr ); 4242 4243 /* - Open session */ 4244 callbackData.pDP = pDP[2]; 4245 hr = IDirectPlayX_EnumSessions( pDP[2], &dpsd[0], 0, EnumSessions_cb_join, 4246 pDP[2], 0 ); 4247 checkHR( DP_OK, hr ); 4248 4249 hr = IDirectPlayX_CreateGroup( pDP[2], &dpid[3], 4250 NULL, NULL, 0, 0 ); 4251 checkHR( DP_OK, hr ); 4252 hr = IDirectPlayX_CreateGroup( pDP[2], &dpid[4], 4253 NULL, NULL, 0, DPGROUP_STAGINGAREA ); 4254 checkHR( DP_OK, hr ); 4255 4256 4257 callbackData.dwCounter1 = 0; 4258 callbackData.szTrace2[0] = 0; 4259 hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb, 4260 &callbackData, 0 ); 4261 checkHR( DP_OK, hr ); 4262 check( 4, callbackData.dwCounter1 ); 4263 checkStr( "0234", callbackData.szTrace1 ); 4264 checkStr( "ALL:HIDDEN:ALL:STAGINGAREA:", callbackData.szTrace2 ); 4265 4266 /* Flag tests */ 4267 callbackData.dwCounter1 = 0; 4268 callbackData.szTrace2[0] = 0; 4269 hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb, 4270 &callbackData, DPENUMGROUPS_ALL ); 4271 checkHR( DP_OK, hr ); 4272 check( 4, callbackData.dwCounter1 ); 4273 checkStr( "0234", callbackData.szTrace1 ); 4274 checkStr( "ALL:HIDDEN:ALL:STAGINGAREA:", callbackData.szTrace2 ); 4275 4276 callbackData.dwCounter1 = 0; 4277 callbackData.szTrace2[0] = 0; 4278 hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb, 4279 &callbackData, DPENUMGROUPS_HIDDEN ); 4280 checkHR( DP_OK, hr ); 4281 check( 1, callbackData.dwCounter1 ); 4282 checkStr( "2", callbackData.szTrace1 ); 4283 checkStr( "HIDDEN:", callbackData.szTrace2 ); 4284 4285 callbackData.dwCounter1 = 0; 4286 callbackData.szTrace2[0] = 0; 4287 hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb, 4288 &callbackData, DPENUMGROUPS_LOCAL ); 4289 checkHR( DP_OK, hr ); 4290 check( 2, callbackData.dwCounter1 ); 4291 checkStr( "34", callbackData.szTrace1 ); 4292 checkStr( "LOCAL:" 4293 "LOCAL,DPENUMGROUPS_STAGINGAREA:", callbackData.szTrace2 ); 4294 4295 callbackData.dwCounter1 = 0; 4296 callbackData.szTrace2[0] = 0; 4297 hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb, 4298 &callbackData, DPENUMGROUPS_REMOTE ); 4299 checkHR( DP_OK, hr ); 4300 check( 2, callbackData.dwCounter1 ); 4301 checkStr( "02", callbackData.szTrace1 ); 4302 checkStr( "REMOTE:" 4303 "REMOTE,DPENUMGROUPS_HIDDEN:", callbackData.szTrace2 ); 4304 4305 callbackData.dwCounter1 = 0; 4306 callbackData.szTrace2[0] = 0; 4307 hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb, 4308 &callbackData, DPENUMGROUPS_STAGINGAREA ); 4309 checkHR( DP_OK, hr ); 4310 check( 1, callbackData.dwCounter1 ); 4311 checkStr( "4", callbackData.szTrace1 ); 4312 checkStr( "STAGINGAREA:", callbackData.szTrace2 ); 4313 4314 4315 IDirectPlayX_Release( pDP[0] ); 4316 IDirectPlayX_Release( pDP[1] ); 4317 IDirectPlayX_Release( pDP[2] ); 4318 4319 } 4320 4321 static void test_EnumGroupsInGroup(void) 4322 { 4323 IDirectPlay4 *pDP[2]; 4324 DPSESSIONDESC2 dpsd[2]; 4325 DPID dpid[6]; 4326 CallbackData callbackData; 4327 HRESULT hr; 4328 UINT i; 4329 4330 4331 for (i=0; i<2; i++) 4332 { 4333 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 4334 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 4335 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 4336 if (FAILED(hr)) return; 4337 4338 ZeroMemory( &dpsd[i], sizeof(DPSESSIONDESC2) ); 4339 dpsd[i].dwSize = sizeof(DPSESSIONDESC2); 4340 } 4341 4342 dpsd[0].guidApplication = appGuid; 4343 dpsd[1].guidApplication = GUID_NULL; 4344 4345 callbackData.dpid = dpid; 4346 callbackData.dpidSize = 6; 4347 4348 4349 /* Uninitialized service provider */ 4350 callbackData.dwCounter1 = 0; 4351 hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], 0, NULL, EnumGroups_cb, 4352 &callbackData, 0 ); 4353 checkHR( DPERR_UNINITIALIZED, hr ); 4354 check( 0, callbackData.dwCounter1 ); 4355 4356 4357 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 ); 4358 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 ); 4359 4360 hr = IDirectPlayX_Open( pDP[0], &dpsd[0], DPOPEN_CREATE ); 4361 todo_wine checkHR( DP_OK, hr ); 4362 4363 if ( hr == DPERR_UNINITIALIZED ) 4364 { 4365 todo_wine win_skip( "EnumGroupsInGroup not implemented\n" ); 4366 return; 4367 } 4368 4369 /* Create groups */ 4370 /* 4371 * 0 4372 * / 2 4373 * 1 | 3 4374 * | 4 4375 * \ 5 (shortcut) 4376 */ 4377 hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[0], 4378 NULL, NULL, 0, 0 ); 4379 checkHR( DP_OK, hr ); 4380 hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[1], 4381 NULL, NULL, 0, 0 ); 4382 checkHR( DP_OK, hr ); 4383 hr = IDirectPlayX_CreateGroupInGroup( pDP[0], dpid[1], &dpid[2], 4384 NULL, NULL, 0, 0 ); 4385 checkHR( DP_OK, hr ); 4386 hr = IDirectPlayX_CreateGroupInGroup( pDP[0], dpid[1], &dpid[3], 4387 NULL, NULL, 0, 4388 DPGROUP_HIDDEN ); 4389 checkHR( DP_OK, hr ); 4390 hr = IDirectPlayX_CreateGroupInGroup( pDP[0], dpid[1], &dpid[4], 4391 NULL, NULL, 0, 4392 DPGROUP_STAGINGAREA ); 4393 checkHR( DP_OK, hr ); 4394 hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[5], 4395 NULL, NULL, 0, 0 ); 4396 checkHR( DP_OK, hr ); 4397 4398 hr = IDirectPlayX_AddGroupToGroup( pDP[0], dpid[1], dpid[5] ); 4399 checkHR( DP_OK, hr ); 4400 4401 4402 /* Invalid parameters */ 4403 callbackData.dwCounter1 = 0; 4404 hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], 0, NULL, EnumGroups_cb, 4405 &callbackData, 0 ); 4406 checkHR( DPERR_INVALIDGROUP, hr ); 4407 check( 0, callbackData.dwCounter1 ); 4408 4409 callbackData.dwCounter1 = 0; 4410 hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], 10, NULL, EnumGroups_cb, 4411 &callbackData, 0 ); 4412 checkHR( DPERR_INVALIDGROUP, hr ); 4413 check( 0, callbackData.dwCounter1 ); 4414 4415 callbackData.dwCounter1 = 0; 4416 hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], (LPGUID) &appGuid, 4417 NULL, &callbackData, 0 ); 4418 checkHR( DPERR_INVALIDPARAMS, hr ); 4419 check( 0, callbackData.dwCounter1 ); 4420 4421 callbackData.dwCounter1 = 0; 4422 hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb, 4423 &callbackData, DPENUMGROUPS_SESSION ); 4424 checkHR( DPERR_INVALIDPARAMS, hr ); 4425 check( 0, callbackData.dwCounter1 ); 4426 4427 4428 /* Regular operation */ 4429 callbackData.dwCounter1 = 0; 4430 hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[0], NULL, EnumGroups_cb, 4431 &callbackData, 0 ); 4432 checkHR( DP_OK, hr ); 4433 check( 0, callbackData.dwCounter1 ); 4434 4435 callbackData.dwCounter1 = 0; 4436 callbackData.szTrace2[0] = 0; 4437 hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb, 4438 &callbackData, 0 ); 4439 checkHR( DP_OK, hr ); 4440 check( 4, callbackData.dwCounter1 ); 4441 checkStr( "5432", callbackData.szTrace1 ); 4442 checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData.szTrace2 ); 4443 4444 callbackData.dwCounter1 = 0; 4445 callbackData.szTrace2[0] = 0; 4446 hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], (LPGUID) &appGuid, 4447 EnumGroups_cb, &callbackData, 0 ); 4448 checkHR( DP_OK, hr ); 4449 check( 4, callbackData.dwCounter1 ); /* Guid is ignored */ 4450 checkStr( "5432", callbackData.szTrace1 ); 4451 checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData.szTrace2 ); 4452 4453 4454 /* Enumerating from a remote session */ 4455 /* - Session not open */ 4456 callbackData.pDP = pDP[1]; 4457 hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd[1], 0, 4458 EnumSessions_cb_EnumGroups, 4459 &callbackData, 0 ); 4460 checkHR( DP_OK, hr ); 4461 4462 /* - Open session */ 4463 hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd[0], 0, EnumSessions_cb_join, 4464 pDP[1], 0 ); 4465 checkHR( DP_OK, hr ); 4466 4467 4468 callbackData.dwCounter1 = 0; 4469 callbackData.szTrace2[0] = 0; 4470 hr = IDirectPlayX_EnumGroupsInGroup( pDP[1], dpid[1], NULL, EnumGroups_cb, 4471 &callbackData, 0 ); 4472 checkHR( DP_OK, hr ); 4473 check( 4, callbackData.dwCounter1 ); 4474 checkStr( "5432", callbackData.szTrace1 ); 4475 checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData.szTrace2 ); 4476 4477 /* Flag tests */ 4478 callbackData.dwCounter1 = 0; 4479 callbackData.szTrace2[0] = 0; 4480 hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb, 4481 &callbackData, DPENUMGROUPS_ALL ); 4482 checkHR( DP_OK, hr ); 4483 check( 4, callbackData.dwCounter1 ); 4484 checkStr( "5432", callbackData.szTrace1 ); 4485 checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData.szTrace2 ); 4486 4487 callbackData.dwCounter1 = 0; 4488 callbackData.szTrace2[0] = 0; 4489 hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb, 4490 &callbackData, DPENUMGROUPS_HIDDEN ); 4491 checkHR( DP_OK, hr ); 4492 check( 1, callbackData.dwCounter1 ); 4493 checkStr( "3", callbackData.szTrace1 ); 4494 checkStr( "HIDDEN:", callbackData.szTrace2 ); 4495 4496 callbackData.dwCounter1 = 0; 4497 callbackData.szTrace2[0] = 0; 4498 hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb, 4499 &callbackData, DPENUMGROUPS_LOCAL ); 4500 checkHR( DP_OK, hr ); 4501 check( 4, callbackData.dwCounter1 ); 4502 checkStr( "5432", callbackData.szTrace1 ); 4503 checkStr( "LOCAL,DPENUMGROUPS_SHORTCUT:" 4504 "LOCAL,DPENUMGROUPS_STAGINGAREA:" 4505 "LOCAL,DPENUMGROUPS_HIDDEN:LOCAL:", callbackData.szTrace2 ); 4506 4507 callbackData.dwCounter1 = 0; 4508 hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb, 4509 &callbackData, DPENUMGROUPS_REMOTE ); 4510 checkHR( DP_OK, hr ); 4511 check( 0, callbackData.dwCounter1 ); 4512 4513 callbackData.dwCounter1 = 0; 4514 hr = IDirectPlayX_EnumGroupsInGroup( pDP[1], dpid[1], NULL, EnumGroups_cb, 4515 &callbackData, DPENUMGROUPS_LOCAL ); 4516 checkHR( DP_OK, hr ); 4517 check( 0, callbackData.dwCounter1 ); 4518 4519 callbackData.dwCounter1 = 0; 4520 callbackData.szTrace2[0] = 0; 4521 hr = IDirectPlayX_EnumGroupsInGroup( pDP[1], dpid[1], NULL, EnumGroups_cb, 4522 &callbackData, DPENUMGROUPS_REMOTE ); 4523 checkHR( DP_OK, hr ); 4524 check( 4, callbackData.dwCounter1 ); 4525 checkStr( "5432", callbackData.szTrace1 ); 4526 checkStr( "REMOTE,DPENUMGROUPS_SHORTCUT:" 4527 "REMOTE,DPENUMGROUPS_STAGINGAREA:" 4528 "REMOTE,DPENUMGROUPS_HIDDEN:REMOTE:", callbackData.szTrace2 ); 4529 4530 callbackData.dwCounter1 = 0; 4531 callbackData.szTrace2[0] = 0; 4532 hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb, 4533 &callbackData, DPENUMGROUPS_SHORTCUT ); 4534 checkHR( DP_OK, hr ); 4535 check( 1, callbackData.dwCounter1 ); 4536 checkStr( "5", callbackData.szTrace1 ); 4537 checkStr( "SHORTCUT:", callbackData.szTrace2 ); 4538 4539 callbackData.dwCounter1 = 0; 4540 callbackData.szTrace2[0] = 0; 4541 hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb, 4542 &callbackData, 4543 DPENUMGROUPS_STAGINGAREA ); 4544 checkHR( DP_OK, hr ); 4545 check( 1, callbackData.dwCounter1 ); 4546 checkStr( "4", callbackData.szTrace1 ); 4547 checkStr( "STAGINGAREA:", callbackData.szTrace2 ); 4548 4549 4550 IDirectPlayX_Release( pDP[0] ); 4551 IDirectPlayX_Release( pDP[1] ); 4552 4553 } 4554 4555 static void test_groups_p2p(void) 4556 { 4557 4558 IDirectPlay4 *pDP[2]; 4559 DPSESSIONDESC2 dpsd; 4560 DPID idPlayer[6], idGroup[3]; 4561 HRESULT hr; 4562 UINT i; 4563 4564 DWORD dwDataSize = 1024; 4565 LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 1024 ); 4566 CallbackData callbackData; 4567 4568 4569 for (i=0; i<2; i++) 4570 { 4571 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 4572 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 4573 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 4574 if (FAILED(hr)) return; 4575 } 4576 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 4577 dpsd.dwSize = sizeof(DPSESSIONDESC2); 4578 dpsd.guidApplication = appGuid; 4579 dpsd.dwMaxPlayers = 10; 4580 4581 4582 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 ); 4583 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 ); 4584 4585 hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 4586 todo_wine checkHR( DP_OK, hr ); 4587 hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join, 4588 pDP[1], 0 ); 4589 todo_wine checkHR( DP_OK, hr ); 4590 4591 if ( hr == DPERR_UNINITIALIZED ) 4592 { 4593 todo_wine win_skip( "dplay not implemented enough for this test yet\n" ); 4594 return; 4595 } 4596 4597 4598 /* Create players */ 4599 hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[0], 4600 NULL, NULL, NULL, 0, 0 ); 4601 checkHR( DP_OK, hr ); 4602 hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[1], 4603 NULL, NULL, NULL, 0, 0 ); 4604 checkHR( DP_OK, hr ); 4605 hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[2], 4606 NULL, NULL, NULL, 0, 0 ); 4607 checkHR( DP_OK, hr ); 4608 hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[3], 4609 NULL, NULL, NULL, 0, 0 ); 4610 checkHR( DP_OK, hr ); 4611 hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[4], 4612 NULL, NULL, NULL, 0, 0 ); 4613 checkHR( DP_OK, hr ); 4614 hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[5], 4615 NULL, NULL, NULL, 0, 0 ); 4616 checkHR( DP_OK, hr ); 4617 4618 hr = IDirectPlayX_CreateGroup( pDP[0], &idGroup[0], 4619 NULL, NULL, 0, 0 ); 4620 checkHR( DP_OK, hr ); 4621 hr = IDirectPlayX_CreateGroup( pDP[1], &idGroup[2], 4622 NULL, NULL, 0, 0 ); 4623 checkHR( DP_OK, hr ); 4624 hr = IDirectPlayX_CreateGroupInGroup( pDP[1], idGroup[2], &idGroup[1], 4625 NULL, NULL, 0, 0 ); 4626 checkHR( DP_OK, hr ); 4627 4628 4629 /* Purge queues */ 4630 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4631 checkStr( "S0," "S1,S0," 4632 "S2,S1,S0," "S2,S1,S0," 4633 "S2,S1,S0," "S2,S1,S0," 4634 "S2,S1,S0," "S2,S1,S0,", callbackData.szTrace1 ); 4635 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4636 checkStr( "S3," "S4,S3," 4637 "S5,S4,S3," "S5,S4,S3," 4638 "S5,S4,S3,", callbackData.szTrace1 ); 4639 4640 4641 /* 4642 * Player 0 | | 4643 * Player 1 | Group 0 | pDP 0 4644 * Player 2 | | 4645 * Player 3 | Group 1 ) | 4646 * Player 4 | | Group 2 | pDP 1 4647 * Player 5 | | 4648 */ 4649 4650 /* Build groups */ 4651 hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[0] ); 4652 checkHR( DP_OK, hr ); 4653 hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[1] ); 4654 checkHR( DP_OK, hr ); 4655 hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[2] ); 4656 checkHR( DP_OK, hr ); 4657 hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[1], idPlayer[3] ); 4658 checkHR( DP_OK, hr ); 4659 hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[1], idPlayer[4] ); 4660 checkHR( DP_OK, hr ); 4661 hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[2], idPlayer[4] ); 4662 checkHR( DP_OK, hr ); 4663 hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[2], idPlayer[5] ); 4664 checkHR( DP_OK, hr ); 4665 4666 hr = IDirectPlayX_AddGroupToGroup( pDP[1], idGroup[2], idGroup[1] ); 4667 checkHR( DP_OK, hr ); 4668 4669 /* Purge queues */ 4670 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4671 checkStr( "S2,S1,S0," "S2,S1,S0," "S2,S1,S0," 4672 "S2,S1,S0," "S2,S1,S0," "S2,S1,S0," 4673 "S2,S1,S0,", callbackData.szTrace1 ); 4674 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4675 checkStr( "S5,S4,S3," "S5,S4,S3," "S5,S4,S3," 4676 "S5,S4,S3," "S5,S4,S3," "S5,S4,S3," 4677 "S5,S4,S3,", callbackData.szTrace1 ); 4678 4679 4680 /* Sending broadcast messages, and checking who receives them */ 4681 4682 dwDataSize = 4; 4683 /* 0 -> * */ 4684 hr = IDirectPlayX_Send( pDP[0], idPlayer[0], DPID_ALLPLAYERS, 0, 4685 lpData, dwDataSize ); 4686 checkHR( DP_OK, hr ); 4687 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4688 checkStr( "02,01,", callbackData.szTrace1 ); 4689 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4690 checkStr( "05,04,03,", callbackData.szTrace1 ); 4691 4692 /* 0 -> g0 */ 4693 hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[0], 0, 4694 lpData, dwDataSize ); 4695 checkHR( DP_OK, hr ); 4696 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4697 checkStr( "02,01,", callbackData.szTrace1 ); 4698 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4699 checkStr( "", callbackData.szTrace1 ); 4700 /* 0 -> g1 */ 4701 hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[1], 0, 4702 lpData, dwDataSize ); 4703 checkHR( DP_OK, hr ); 4704 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4705 checkStr( "", callbackData.szTrace1 ); 4706 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4707 checkStr( "04,03,", callbackData.szTrace1 ); 4708 /* 0 -> g2 */ 4709 hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[2], 0, 4710 lpData, dwDataSize ); 4711 checkHR( DP_OK, hr ); 4712 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4713 checkStr( "", callbackData.szTrace1 ); 4714 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4715 checkStr( "05,04,", callbackData.szTrace1 ); 4716 4717 /* 3 -> * */ 4718 hr = IDirectPlayX_Send( pDP[1], idPlayer[3], DPID_ALLPLAYERS, 0, 4719 lpData, dwDataSize ); 4720 checkHR( DP_OK, hr ); 4721 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4722 checkStr( "32,31,30,", callbackData.szTrace1 ); 4723 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4724 checkStr( "35,34,", callbackData.szTrace1 ); 4725 /* 3 -> g0 */ 4726 hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[0], 0, 4727 lpData, dwDataSize ); 4728 checkHR( DP_OK, hr ); 4729 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4730 checkStr( "32,31,30,", callbackData.szTrace1 ); 4731 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4732 checkStr( "", callbackData.szTrace1 ); 4733 /* 3 -> g1 */ 4734 hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[1], 0, 4735 lpData, dwDataSize ); 4736 checkHR( DP_OK, hr ); 4737 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4738 checkStr( "", callbackData.szTrace1 ); 4739 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4740 checkStr( "34,", callbackData.szTrace1 ); 4741 /* 3 -> g2 */ 4742 hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[2], 0, 4743 lpData, dwDataSize ); 4744 checkHR( DP_OK, hr ); 4745 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4746 checkStr( "", callbackData.szTrace1 ); 4747 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4748 checkStr( "35,34,", callbackData.szTrace1 ); 4749 4750 /* 5 -> * */ 4751 hr = IDirectPlayX_Send( pDP[1], idPlayer[5], DPID_ALLPLAYERS, 0, 4752 lpData, dwDataSize ); 4753 checkHR( DP_OK, hr ); 4754 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4755 checkStr( "52,51,50,", callbackData.szTrace1 ); 4756 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4757 checkStr( "54,53,", callbackData.szTrace1 ); 4758 /* 5 -> g0 */ 4759 hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[0], 0, 4760 lpData, dwDataSize ); 4761 checkHR( DP_OK, hr ); 4762 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4763 checkStr( "52,51,50,", callbackData.szTrace1 ); 4764 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4765 checkStr( "", callbackData.szTrace1 ); 4766 /* 5 -> g1 */ 4767 hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[1], 0, 4768 lpData, dwDataSize ); 4769 checkHR( DP_OK, hr ); 4770 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4771 checkStr( "", callbackData.szTrace1 ); 4772 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4773 checkStr( "54,53,", callbackData.szTrace1 ); 4774 /* 5 -> g2 */ 4775 hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[2], 0, 4776 lpData, dwDataSize ); 4777 checkHR( DP_OK, hr ); 4778 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4779 checkStr( "", callbackData.szTrace1 ); 4780 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4781 checkStr( "54,", callbackData.szTrace1 ); 4782 4783 4784 HeapFree( GetProcessHeap(), 0, lpData ); 4785 IDirectPlayX_Release( pDP[0] ); 4786 IDirectPlayX_Release( pDP[1] ); 4787 4788 } 4789 4790 static void test_groups_cs(void) 4791 { 4792 4793 IDirectPlay4 *pDP[2]; 4794 DPSESSIONDESC2 dpsd; 4795 DPID idPlayer[6], idGroup[3]; 4796 CallbackData callbackData; 4797 HRESULT hr; 4798 UINT i; 4799 4800 DWORD dwDataSize = 1024; 4801 LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 1024 ); 4802 4803 4804 for (i=0; i<2; i++) 4805 { 4806 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 4807 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 4808 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 4809 if (FAILED(hr)) return; 4810 } 4811 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 4812 dpsd.dwSize = sizeof(DPSESSIONDESC2); 4813 dpsd.guidApplication = appGuid; 4814 dpsd.dwMaxPlayers = 10; 4815 4816 4817 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 ); 4818 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 ); 4819 4820 dpsd.dwFlags = DPSESSION_CLIENTSERVER; 4821 hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 4822 todo_wine checkHR( DP_OK, hr ); 4823 dpsd.dwFlags = 0; 4824 hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join, 4825 pDP[1], 0 ); 4826 todo_wine checkHR( DP_OK, hr ); 4827 4828 if ( hr == DPERR_UNINITIALIZED ) 4829 { 4830 todo_wine win_skip( "dplay not implemented enough for this test yet\n" ); 4831 return; 4832 } 4833 4834 4835 /* Create players */ 4836 hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[0], 4837 NULL, NULL, NULL, 0, 0 ); 4838 checkHR( DPERR_ACCESSDENIED, hr ); 4839 hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[0], 4840 NULL, NULL, NULL, 0, 4841 DPPLAYER_SERVERPLAYER ); 4842 checkHR( DP_OK, hr ); 4843 hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[1], 4844 NULL, NULL, NULL, 0, 0 ); 4845 checkHR( DPERR_ACCESSDENIED, hr ); 4846 hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[1], 4847 NULL, NULL, NULL, 0, 0 ); 4848 checkHR( DP_OK, hr ); 4849 hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[2], 4850 NULL, NULL, NULL, 0, 0 ); 4851 checkHR( DP_OK, hr ); 4852 hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[3], 4853 NULL, NULL, NULL, 0, 0 ); 4854 checkHR( DP_OK, hr ); 4855 hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[4], 4856 NULL, NULL, NULL, 0, 0 ); 4857 checkHR( DP_OK, hr ); 4858 hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[5], 4859 NULL, NULL, NULL, 0, 0 ); 4860 checkHR( DP_OK, hr ); 4861 4862 hr = IDirectPlayX_CreateGroup( pDP[0], &idGroup[0], 4863 NULL, NULL, 0, 0 ); 4864 checkHR( DP_OK, hr ); 4865 hr = IDirectPlayX_CreateGroup( pDP[1], &idGroup[2], 4866 NULL, NULL, 0, 0 ); 4867 checkHR( DP_OK, hr ); 4868 hr = IDirectPlayX_CreateGroupInGroup( pDP[1], idGroup[2], &idGroup[1], 4869 NULL, NULL, 0, 0 ); 4870 checkHR( DP_OK, hr ); 4871 4872 4873 /* Purge queues */ 4874 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4875 checkStr( "S0,S0,S0,S0,S0,S0,", callbackData.szTrace1 ); 4876 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4877 checkStr( "S1," "S2,S1," "S3,S2,S1," "S4,S3,S2,S1," 4878 "S5,S4,S3,S2,S1," "S5,S4,S3,S2,S1,", callbackData.szTrace1 ); 4879 4880 /* 4881 * Player 0 | | pDP 0 4882 * Player 1 | Group 0 | 4883 * Player 2 | | 4884 * Player 3 | Group 1 ) | 4885 * Player 4 | | Group 2 | pDP 1 4886 * Player 5 | | 4887 */ 4888 4889 /* Build groups */ 4890 hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[0] ); 4891 checkHR( DP_OK, hr ); 4892 hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[1] ); 4893 checkHR( DP_OK, hr ); 4894 hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[2] ); 4895 checkHR( DP_OK, hr ); 4896 hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[1], idPlayer[3] ); 4897 checkHR( DP_OK, hr ); 4898 hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[1], idPlayer[4] ); 4899 checkHR( DP_OK, hr ); 4900 hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[2], idPlayer[4] ); 4901 checkHR( DP_OK, hr ); 4902 hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[2], idPlayer[5] ); 4903 checkHR( DP_OK, hr ); 4904 4905 hr = IDirectPlayX_AddGroupToGroup( pDP[1], idGroup[2], idGroup[1] ); 4906 checkHR( DP_OK, hr ); 4907 4908 /* Purge queues */ 4909 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4910 checkStr( "S0,S0,S0,S0,", callbackData.szTrace1 ); 4911 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4912 checkStr( "S5," "S4,S3,S2,S1," "S5,S4,S3,S2,S1," 4913 "S5,S4,S3,S2,S1," "S5,S4,S3,S2,S1,", callbackData.szTrace1 ); 4914 4915 4916 /* Sending broadcast messages, and checking who receives them */ 4917 dwDataSize = 4; 4918 /* 0 -> * */ 4919 hr = IDirectPlayX_Send( pDP[0], idPlayer[0], DPID_ALLPLAYERS, 0, 4920 lpData, dwDataSize ); 4921 checkHR( DP_OK, hr ); 4922 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4923 checkStr( "", callbackData.szTrace1 ); 4924 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4925 checkStr( "05,04,03,02,01,", callbackData.szTrace1 ); 4926 4927 /* 0 -> g0 */ 4928 hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[0], 0, 4929 lpData, dwDataSize ); 4930 checkHR( DP_OK, hr ); 4931 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4932 checkStr( "", callbackData.szTrace1 ); 4933 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4934 checkStr( "02,01,", callbackData.szTrace1 ); 4935 /* 0 -> g1 */ 4936 hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[1], 0, 4937 lpData, dwDataSize ); 4938 checkHR( DPERR_INVALIDPARAMS, hr ); 4939 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4940 checkStr( "", callbackData.szTrace1 ); 4941 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4942 checkStr( "", callbackData.szTrace1 ); 4943 /* 0 -> g2 */ 4944 hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[2], 0, 4945 lpData, dwDataSize ); 4946 checkHR( DPERR_INVALIDPARAMS, hr ); 4947 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4948 checkStr( "", callbackData.szTrace1 ); 4949 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4950 checkStr( "", callbackData.szTrace1 ); 4951 4952 /* 3 -> * */ 4953 hr = IDirectPlayX_Send( pDP[1], idPlayer[3], DPID_ALLPLAYERS, 0, 4954 lpData, dwDataSize ); 4955 checkHR( DP_OK, hr ); 4956 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4957 checkStr( "30,", callbackData.szTrace1 ); 4958 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4959 checkStr( "35,34,32,31,", callbackData.szTrace1 ); 4960 /* 3 -> g0 */ 4961 hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[0], 0, 4962 lpData, dwDataSize ); 4963 checkHR( DPERR_INVALIDPARAMS, hr ); 4964 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4965 checkStr( "", callbackData.szTrace1 ); 4966 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4967 checkStr( "", callbackData.szTrace1 ); 4968 /* 3 -> g1 */ 4969 hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[1], 0, 4970 lpData, dwDataSize ); 4971 checkHR( DP_OK, hr ); 4972 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4973 checkStr( "", callbackData.szTrace1 ); 4974 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4975 checkStr( "34,", callbackData.szTrace1 ); 4976 /* 3 -> g2 */ 4977 hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[2], 0, 4978 lpData, dwDataSize ); 4979 checkHR( DP_OK, hr ); 4980 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4981 checkStr( "", callbackData.szTrace1 ); 4982 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4983 checkStr( "35,34,", callbackData.szTrace1 ); 4984 4985 /* 5 -> * */ 4986 hr = IDirectPlayX_Send( pDP[1], idPlayer[5], DPID_ALLPLAYERS, 0, 4987 lpData, dwDataSize ); 4988 checkHR( DP_OK, hr ); 4989 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4990 checkStr( "50,", callbackData.szTrace1 ); 4991 check_messages( pDP[1], idPlayer, 6, &callbackData ); 4992 checkStr( "54,53,52,51,", callbackData.szTrace1 ); 4993 /* 5 -> g0 */ 4994 hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[0], 0, 4995 lpData, dwDataSize ); 4996 checkHR( DPERR_INVALIDPARAMS, hr ); 4997 check_messages( pDP[0], idPlayer, 6, &callbackData ); 4998 checkStr( "", callbackData.szTrace1 ); 4999 check_messages( pDP[1], idPlayer, 6, &callbackData ); 5000 checkStr( "", callbackData.szTrace1 ); 5001 /* 5 -> g1 */ 5002 hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[1], 0, 5003 lpData, dwDataSize ); 5004 checkHR( DP_OK, hr ); 5005 check_messages( pDP[0], idPlayer, 6, &callbackData ); 5006 checkStr( "", callbackData.szTrace1 ); 5007 check_messages( pDP[1], idPlayer, 6, &callbackData ); 5008 checkStr( "54,53,", callbackData.szTrace1 ); 5009 /* 5 -> g2 */ 5010 hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[2], 0, 5011 lpData, dwDataSize ); 5012 checkHR( DP_OK, hr ); 5013 check_messages( pDP[0], idPlayer, 6, &callbackData ); 5014 checkStr( "", callbackData.szTrace1 ); 5015 check_messages( pDP[1], idPlayer, 6, &callbackData ); 5016 checkStr( "54,", callbackData.szTrace1 ); 5017 5018 5019 HeapFree( GetProcessHeap(), 0, lpData ); 5020 IDirectPlayX_Release( pDP[0] ); 5021 IDirectPlayX_Release( pDP[1] ); 5022 5023 } 5024 5025 /* Send */ 5026 5027 static void test_Send(void) 5028 { 5029 5030 IDirectPlay4 *pDP[2]; 5031 DPSESSIONDESC2 dpsd; 5032 DPID dpid[4], idFrom, idTo; 5033 CallbackData callbackData; 5034 HRESULT hr; 5035 LPCSTR message = "message"; 5036 DWORD messageSize = strlen(message) + 1; 5037 DWORD dwDataSize = 1024; 5038 LPDPMSG_GENERIC lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize ); 5039 LPDPMSG_SECUREMESSAGE lpDataSecure; 5040 UINT i; 5041 5042 5043 for (i=0; i<2; i++) 5044 { 5045 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 5046 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 5047 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 5048 if (FAILED(hr)) return; 5049 } 5050 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 5051 5052 5053 /* Uninitialized service provider */ 5054 hr = IDirectPlayX_Send( pDP[0], 0, 0, 0, 5055 (LPVOID) message, messageSize ); 5056 checkHR( DPERR_UNINITIALIZED, hr ); 5057 5058 5059 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 ); 5060 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 ); 5061 5062 dpsd.dwSize = sizeof(DPSESSIONDESC2); 5063 dpsd.guidApplication = appGuid; 5064 dpsd.dwMaxPlayers = 10; 5065 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 5066 IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join, 5067 pDP[1], 0 ); 5068 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 5069 5070 5071 /* Incorrect players */ 5072 hr = IDirectPlayX_Send( pDP[0], 0, 1, 2, 5073 (LPVOID) message, messageSize ); 5074 todo_wine checkHR( DPERR_INVALIDPLAYER, hr ); 5075 5076 if ( hr == DPERR_UNINITIALIZED ) 5077 { 5078 todo_wine win_skip( "Send not implemented\n" ); 5079 return; 5080 } 5081 5082 5083 IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 ); 5084 IDirectPlayX_CreatePlayer( pDP[0], &dpid[1], NULL, NULL, NULL, 0, 0 ); 5085 IDirectPlayX_CreatePlayer( pDP[0], &dpid[2], NULL, NULL, NULL, 0, 0 ); 5086 IDirectPlayX_CreatePlayer( pDP[1], &dpid[3], NULL, NULL, NULL, 0, 0 ); 5087 5088 /* Purge player creation messages */ 5089 check_messages( pDP[0], dpid, 4, &callbackData ); 5090 checkStr( "S0," "S1,S0," "S2,S1,S0,", callbackData.szTrace1 ); 5091 check_messages( pDP[1], dpid, 4, &callbackData ); 5092 checkStr( "", callbackData.szTrace1 ); 5093 5094 5095 /* Message to self: no error, but no message is sent */ 5096 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[0], 0, 5097 (LPVOID) message, messageSize ); 5098 checkHR( DP_OK, hr ); 5099 5100 /* Send a message from a remote player */ 5101 hr = IDirectPlayX_Send( pDP[1], dpid[0], dpid[1], 0, 5102 (LPVOID) message, messageSize ); 5103 checkHR( DPERR_ACCESSDENIED, hr ); 5104 hr = IDirectPlayX_Send( pDP[1], dpid[0], dpid[3], 0, 5105 (LPVOID) message, messageSize ); 5106 checkHR( DPERR_ACCESSDENIED, hr ); 5107 5108 /* Null message */ 5109 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 0, 5110 NULL, messageSize ); 5111 checkHR( DPERR_INVALIDPARAMS, hr ); 5112 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 0, 5113 (LPVOID) message, 0 ); 5114 checkHR( DPERR_INVALIDPARAMS, hr ); 5115 5116 5117 /* Checking no message was sent */ 5118 check_messages( pDP[0], dpid, 4, &callbackData ); 5119 checkStr( "", callbackData.szTrace1 ); 5120 check_messages( pDP[1], dpid, 4, &callbackData ); 5121 checkStr( "", callbackData.szTrace1 ); 5122 5123 5124 /* Regular parameters */ 5125 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5126 0, 5127 (LPVOID) message, messageSize ); 5128 checkHR( DP_OK, hr ); 5129 5130 hr = IDirectPlayX_Receive( pDP[0], &dpid[0], &dpid[1], 5131 DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER, 5132 lpData, &dwDataSize ); 5133 checkHR( DP_OK, hr ); 5134 checkStr( message, (LPSTR) lpData ); 5135 check( strlen(message)+1, dwDataSize ); 5136 5137 check_messages( pDP[0], dpid, 4, &callbackData ); 5138 checkStr( "", callbackData.szTrace1 ); 5139 check_messages( pDP[1], dpid, 4, &callbackData ); 5140 checkStr( "", callbackData.szTrace1 ); 5141 5142 5143 /* Message to a remote player */ 5144 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[3], 0, 5145 (LPVOID) message, messageSize ); 5146 checkHR( DP_OK, hr ); 5147 5148 hr = IDirectPlayX_Receive( pDP[0], &dpid[0], &dpid[3], 5149 DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER, 5150 lpData, &dwDataSize ); 5151 checkHR( DPERR_NOMESSAGES, hr ); 5152 hr = IDirectPlayX_Receive( pDP[1], &dpid[0], &dpid[3], 5153 DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER, 5154 lpData, &dwDataSize ); 5155 checkHR( DP_OK, hr ); 5156 checkStr( message, (LPSTR) lpData ); 5157 check( strlen(message)+1, dwDataSize ); 5158 5159 check_messages( pDP[0], dpid, 4, &callbackData ); 5160 checkStr( "", callbackData.szTrace1 ); 5161 check_messages( pDP[1], dpid, 4, &callbackData ); 5162 checkStr( "", callbackData.szTrace1 ); 5163 5164 5165 /* Broadcast */ 5166 5167 hr = IDirectPlayX_Send( pDP[0], dpid[0], DPID_ALLPLAYERS, 0, 5168 (LPVOID) message, messageSize ); 5169 checkHR( DP_OK, hr ); 5170 5171 for (i=1; i<3; i++) 5172 { 5173 hr = IDirectPlayX_Receive( pDP[0], &dpid[0], &dpid[i], 5174 DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER, 5175 lpData, &dwDataSize ); 5176 checkHR( DP_OK, hr ); 5177 checkStr( message, (LPSTR) lpData ); 5178 } 5179 hr = IDirectPlayX_Receive( pDP[1], &dpid[0], &dpid[3], 5180 DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER, 5181 lpData, &dwDataSize ); 5182 checkHR( DP_OK, hr ); 5183 checkStr( message, (LPSTR) lpData ); 5184 5185 check_messages( pDP[0], dpid, 4, &callbackData ); 5186 checkStr( "", callbackData.szTrace1 ); 5187 check_messages( pDP[1], dpid, 4, &callbackData ); 5188 checkStr( "", callbackData.szTrace1 ); 5189 5190 5191 hr = IDirectPlayX_Send( pDP[0], DPID_ALLPLAYERS, dpid[1], 5192 0, 5193 (LPVOID) message, messageSize ); 5194 checkHR( DPERR_INVALIDPLAYER, hr ); 5195 hr = IDirectPlayX_Send( pDP[0], DPID_ALLPLAYERS, DPID_ALLPLAYERS, 5196 0, 5197 (LPVOID) message, messageSize ); 5198 checkHR( DPERR_INVALIDPLAYER, hr ); 5199 5200 5201 /* Flags */ 5202 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5203 DPSEND_GUARANTEED, 5204 (LPVOID) message, messageSize ); 5205 checkHR( DP_OK, hr ); 5206 5207 hr = IDirectPlayX_Receive( pDP[0], &dpid[0], &dpid[1], 5208 DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER, 5209 lpData, &dwDataSize ); 5210 checkHR( DP_OK, hr ); 5211 checkStr( message, (LPSTR)lpData ); 5212 5213 /* - Inorrect flags */ 5214 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5215 DPSEND_ENCRYPTED, 5216 (LPVOID) message, messageSize ); 5217 checkHR( DPERR_INVALIDPARAMS, hr ); 5218 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5219 DPSEND_SIGNED, 5220 (LPVOID) message, messageSize ); 5221 checkHR( DPERR_INVALIDPARAMS, hr ); 5222 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5223 DPSEND_ENCRYPTED | DPSEND_SIGNED, 5224 (LPVOID) message, messageSize ); 5225 checkHR( DPERR_INVALIDPARAMS, hr ); 5226 5227 /* - Correct flags, but session is not secure */ 5228 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5229 DPSEND_ENCRYPTED | DPSEND_GUARANTEED, 5230 (LPVOID) message, messageSize ); 5231 checkHR( DPERR_INVALIDPARAMS, hr ); 5232 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5233 DPSEND_SIGNED | DPSEND_GUARANTEED, 5234 (LPVOID) message, messageSize ); 5235 checkHR( DPERR_INVALIDPARAMS, hr ); 5236 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5237 ( DPSEND_ENCRYPTED | 5238 DPSEND_SIGNED | 5239 DPSEND_GUARANTEED ), 5240 (LPVOID) message, messageSize ); 5241 checkHR( DPERR_INVALIDPARAMS, hr ); 5242 5243 /* - Correct flags, secure session incorrectly opened (without flags) */ 5244 hr = IDirectPlayX_Close( pDP[0] ); 5245 checkHR( DP_OK, hr ); 5246 5247 dpsd.dwFlags = 0; 5248 hr = IDirectPlayX_SecureOpen( pDP[0], &dpsd, DPOPEN_CREATE, NULL, NULL ); 5249 checkHR( DP_OK, hr ); 5250 for (i=0; i<2; i++) 5251 IDirectPlayX_CreatePlayer( pDP[0], &dpid[i], NULL, NULL, NULL, 0, 0 ); 5252 5253 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5254 DPSEND_ENCRYPTED | DPSEND_GUARANTEED, 5255 (LPVOID) message, messageSize ); 5256 checkHR( DPERR_INVALIDPARAMS, hr ); 5257 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5258 DPSEND_SIGNED | DPSEND_GUARANTEED, 5259 (LPVOID) message, messageSize ); 5260 checkHR( DPERR_INVALIDPARAMS, hr ); 5261 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5262 ( DPSEND_ENCRYPTED | 5263 DPSEND_SIGNED | 5264 DPSEND_GUARANTEED ), 5265 (LPVOID) message, messageSize ); 5266 checkHR( DPERR_INVALIDPARAMS, hr ); 5267 5268 /* - Correct flags, secure session */ 5269 hr = IDirectPlayX_Close( pDP[0] ); 5270 checkHR( DP_OK, hr ); 5271 5272 dpsd.dwFlags = DPSESSION_SECURESERVER; 5273 hr = IDirectPlayX_SecureOpen( pDP[0], &dpsd, DPOPEN_CREATE, NULL, NULL ); 5274 checkHR( DP_OK, hr ); 5275 IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 ); 5276 IDirectPlayX_CreatePlayer( pDP[0], &dpid[1], NULL, NULL, NULL, 0, 0 ); 5277 5278 /* Purge */ 5279 check_messages( pDP[0], dpid, 6, &callbackData ); 5280 checkStr( "S0,", callbackData.szTrace1 ); 5281 5282 5283 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5284 DPSEND_ENCRYPTED | DPSEND_GUARANTEED, 5285 (LPVOID) message, messageSize ); 5286 checkHR( DP_OK, hr ); 5287 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5288 DPSEND_SIGNED | DPSEND_GUARANTEED, 5289 (LPVOID) message, messageSize ); 5290 checkHR( DP_OK, hr ); 5291 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5292 ( DPSEND_ENCRYPTED | 5293 DPSEND_SIGNED | 5294 DPSEND_GUARANTEED ), 5295 (LPVOID) message, messageSize ); 5296 checkHR( DP_OK, hr ); 5297 5298 5299 for (i=0; i<3; i++) 5300 { 5301 dwDataSize = 1024; 5302 hr = IDirectPlayX_Receive( pDP[0], &idFrom, &idTo, 0, lpData, 5303 &dwDataSize ); 5304 5305 lpDataSecure = (LPDPMSG_SECUREMESSAGE) lpData; 5306 5307 checkHR( DP_OK, hr ); 5308 checkConv( DPSYS_SECUREMESSAGE, lpData->dwType, dpMsgType2str ); 5309 check( DPID_SYSMSG, idFrom ); 5310 check( dpid[1], idTo ); 5311 check( dpid[0], lpDataSecure->dpIdFrom ); 5312 checkStr( message, (LPSTR) lpDataSecure->lpData ); 5313 check( strlen(message)+1, lpDataSecure->dwDataSize ); 5314 5315 switch(i) 5316 { 5317 case 0: 5318 checkFlags( DPSEND_ENCRYPTED, 5319 lpDataSecure->dwFlags, 5320 FLAGS_DPSEND ); 5321 break; 5322 case 1: 5323 checkFlags( DPSEND_SIGNED, 5324 lpDataSecure->dwFlags, 5325 FLAGS_DPSEND ); 5326 break; 5327 case 2: 5328 checkFlags( DPSEND_SIGNED | DPSEND_ENCRYPTED, 5329 lpDataSecure->dwFlags, 5330 FLAGS_DPSEND ); 5331 break; 5332 default: break; 5333 } 5334 } 5335 check_messages( pDP[0], dpid, 4, &callbackData ); 5336 checkStr( "", callbackData.szTrace1 ); 5337 5338 5339 /* - Even in a secure session, incorrect flags still not working */ 5340 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5341 DPSEND_ENCRYPTED, 5342 (LPVOID) message, messageSize ); 5343 checkHR( DPERR_INVALIDPARAMS, hr ); 5344 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5345 DPSEND_SIGNED, 5346 (LPVOID) message, messageSize ); 5347 checkHR( DPERR_INVALIDPARAMS, hr ); 5348 hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 5349 DPSEND_ENCRYPTED | DPSEND_SIGNED, 5350 (LPVOID) message, messageSize ); 5351 checkHR( DPERR_INVALIDPARAMS, hr ); 5352 5353 5354 HeapFree( GetProcessHeap(), 0, lpData ); 5355 IDirectPlayX_Release( pDP[0] ); 5356 IDirectPlayX_Release( pDP[1] ); 5357 5358 } 5359 5360 /* Receive */ 5361 5362 static void test_Receive(void) 5363 { 5364 5365 IDirectPlay4 *pDP; 5366 DPSESSIONDESC2 dpsd; 5367 DPID dpid[4], idFrom, idTo; 5368 HRESULT hr; 5369 LPCSTR message = "message"; 5370 DWORD messageSize = strlen(message) + 1; 5371 DWORD dwDataSize = 1024; 5372 LPDPMSG_GENERIC lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 5373 dwDataSize ); 5374 LPDPMSG_CREATEPLAYERORGROUP lpDataCreate; 5375 LPDPMSG_DESTROYPLAYERORGROUP lpDataDestroy; 5376 5377 DWORD dwCount; 5378 UINT i; 5379 5380 5381 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 5382 &IID_IDirectPlay4A, (LPVOID*) &pDP ); 5383 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 5384 if (FAILED(hr)) return; 5385 5386 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 5387 dpsd.dwSize = sizeof(DPSESSIONDESC2); 5388 dpsd.guidApplication = appGuid; 5389 5390 init_TCPIP_provider( pDP, "127.0.0.1", 0 ); 5391 5392 IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE ); 5393 5394 5395 /* Invalid parameters */ 5396 hr = IDirectPlayX_Receive( pDP, NULL, &idTo, 0, 5397 lpData, &dwDataSize ); 5398 todo_wine checkHR( DPERR_INVALIDPARAMS, hr ); 5399 5400 if ( hr == DPERR_UNINITIALIZED ) 5401 { 5402 todo_wine win_skip( "Receive not implemented\n" ); 5403 return; 5404 } 5405 5406 hr = IDirectPlayX_Receive( pDP, &idFrom, NULL, 0, 5407 lpData, &dwDataSize ); 5408 checkHR( DPERR_INVALIDPARAMS, hr ); 5409 hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, 5410 lpData, NULL ); 5411 checkHR( DPERR_INVALIDPARAMS, hr ); 5412 dwDataSize = -1; 5413 hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, 5414 lpData, &dwDataSize ); 5415 checkHR( DPERR_INVALIDPARAMS, hr ); 5416 5417 /* No messages yet */ 5418 hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, 5419 NULL, &dwDataSize ); 5420 checkHR( DPERR_NOMESSAGES, hr ); 5421 dwDataSize = 0; 5422 hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, 5423 lpData, &dwDataSize ); 5424 checkHR( DPERR_NOMESSAGES, hr ); 5425 5426 5427 IDirectPlayX_CreatePlayer( pDP, &dpid[0], NULL, 0, NULL, 0, 0 ); 5428 IDirectPlayX_CreatePlayer( pDP, &dpid[1], NULL, 0, NULL, 0, 5429 DPPLAYER_SPECTATOR ); 5430 IDirectPlayX_CreatePlayer( pDP, &dpid[2], NULL, 0, NULL, 0, 0 ); 5431 IDirectPlayX_CreatePlayer( pDP, &dpid[3], NULL, 0, NULL, 0, 0 ); 5432 5433 5434 /* 0, 1, 2, 3 */ 5435 /* 3, 2, 1, 0 */ 5436 for (i=0; i<4; i++) 5437 { 5438 IDirectPlayX_GetMessageCount( pDP, dpid[i], &dwCount ); 5439 check( 3-i, dwCount ); 5440 } 5441 5442 5443 IDirectPlayX_DestroyPlayer( pDP, dpid[3] ); 5444 IDirectPlayX_DestroyPlayer( pDP, dpid[1] ); 5445 5446 5447 /* 0, 1, 2, 3 */ 5448 /* 5, 5, 3, 3 */ 5449 IDirectPlayX_GetMessageCount( pDP, dpid[0], &dwCount ); 5450 check( 5, dwCount ); 5451 IDirectPlayX_GetMessageCount( pDP, dpid[1], &dwCount ); 5452 check( 5, dwCount ); 5453 IDirectPlayX_GetMessageCount( pDP, dpid[2], &dwCount ); 5454 check( 3, dwCount ); 5455 IDirectPlayX_GetMessageCount( pDP, dpid[3], &dwCount ); 5456 check( 3, dwCount ); 5457 5458 5459 /* Buffer too small */ 5460 hr = IDirectPlayX_Receive( pDP, &idFrom, &idFrom, 0, 5461 NULL, &dwDataSize ); 5462 checkHR( DPERR_BUFFERTOOSMALL, hr ); 5463 check( 48, dwDataSize ); 5464 dwDataSize = 0; 5465 hr = IDirectPlayX_Receive( pDP, &idTo, &idFrom, 0, 5466 lpData, &dwDataSize ); 5467 checkHR( DPERR_BUFFERTOOSMALL, hr ); 5468 check( 48, dwDataSize ); 5469 5470 5471 /* Checking the order or reception */ 5472 for (i=0; i<11; i++) 5473 { 5474 dwDataSize = 1024; 5475 hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, 5476 lpData, &dwDataSize ); 5477 5478 checkHR( DP_OK, hr ); 5479 check( DPID_SYSMSG, idFrom ); 5480 5481 if (i<6) /* Player creation */ 5482 { 5483 checkConv( DPSYS_CREATEPLAYERORGROUP, lpData->dwType, dpMsgType2str ); 5484 check( 48, dwDataSize ); 5485 lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData; 5486 check( DPPLAYERTYPE_PLAYER, lpDataCreate->dwPlayerType ); 5487 checkLP( NULL, lpDataCreate->lpData ); 5488 check( 0, lpDataCreate->dwDataSize ); 5489 checkLP( NULL, U1(lpDataCreate->dpnName).lpszShortNameA ); 5490 check( 0, lpDataCreate->dpIdParent ); 5491 } 5492 else /* Player destruction */ 5493 { 5494 checkConv( DPSYS_DESTROYPLAYERORGROUP, lpData->dwType, 5495 dpMsgType2str ); 5496 check( 52, dwDataSize ); 5497 lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData; 5498 check( DPPLAYERTYPE_PLAYER, lpDataDestroy->dwPlayerType ); 5499 checkLP( NULL, lpDataDestroy->lpLocalData ); 5500 check( 0, lpDataDestroy->dwLocalDataSize ); 5501 checkLP( NULL, lpDataDestroy->lpRemoteData ); 5502 check( 0, lpDataDestroy->dwRemoteDataSize ); 5503 checkLP( NULL, U1(lpDataDestroy->dpnName).lpszShortNameA ); 5504 check( 0, lpDataDestroy->dpIdParent ); 5505 } 5506 5507 switch(i) 5508 { 5509 /* 1 -> 0 */ 5510 case 0: 5511 lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData; 5512 check( dpid[0], idTo ); 5513 check( dpid[1], lpDataCreate->dpId ); 5514 check( 1, lpDataCreate->dwCurrentPlayers ); 5515 checkFlags( DPPLAYER_LOCAL|DPPLAYER_SPECTATOR, lpDataCreate->dwFlags, 5516 FLAGS_DPPLAYER|FLAGS_DPGROUP ); 5517 break; 5518 5519 /* 2 -> 1,0 */ 5520 case 1: 5521 check( dpid[1], idTo ); 5522 lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData; 5523 check( dpid[2], lpDataCreate->dpId ); 5524 check( 2, lpDataCreate->dwCurrentPlayers ); 5525 checkFlags( DPPLAYER_LOCAL, lpDataCreate->dwFlags, 5526 FLAGS_DPPLAYER | FLAGS_DPGROUP ); 5527 break; 5528 case 2: 5529 check( dpid[0], idTo ); 5530 lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData; 5531 check( dpid[2], lpDataCreate->dpId ); 5532 check( 2, lpDataCreate->dwCurrentPlayers ); 5533 checkFlags( DPPLAYER_LOCAL, lpDataCreate->dwFlags, 5534 FLAGS_DPPLAYER | FLAGS_DPGROUP ); 5535 break; 5536 5537 /* 3 -> 2,1,0 */ 5538 case 3: 5539 check( dpid[2], idTo ); 5540 lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData; 5541 check( dpid[3], lpDataCreate->dpId ); 5542 check( 3, lpDataCreate->dwCurrentPlayers ); 5543 checkFlags( DPPLAYER_LOCAL, lpDataCreate->dwFlags, 5544 FLAGS_DPPLAYER | FLAGS_DPGROUP ); 5545 break; 5546 case 4: 5547 check( dpid[1], idTo ); 5548 lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData; 5549 check( dpid[3], lpDataCreate->dpId ); 5550 check( 3, lpDataCreate->dwCurrentPlayers ); 5551 checkFlags( DPPLAYER_LOCAL, lpDataCreate->dwFlags, 5552 FLAGS_DPPLAYER | FLAGS_DPGROUP ); 5553 break; 5554 case 5: 5555 check( dpid[0], idTo ); 5556 lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData; 5557 check( dpid[3], lpDataCreate->dpId ); 5558 check( 3, lpDataCreate->dwCurrentPlayers ); 5559 checkFlags( DPPLAYER_LOCAL, lpDataCreate->dwFlags, 5560 FLAGS_DPPLAYER | FLAGS_DPGROUP ); 5561 break; 5562 5563 /* 3 -> 2,1,0 */ 5564 case 6: 5565 check( dpid[2], idTo ); 5566 lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData; 5567 check( dpid[3], lpDataDestroy->dpId ); 5568 checkFlags( DPPLAYER_LOCAL, lpDataDestroy->dwFlags, 5569 FLAGS_DPPLAYER | FLAGS_DPGROUP ); 5570 break; 5571 case 7: 5572 check( dpid[1], idTo ); 5573 lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData; 5574 check( dpid[3], lpDataDestroy->dpId ); 5575 checkFlags( DPPLAYER_LOCAL, lpDataDestroy->dwFlags, 5576 FLAGS_DPPLAYER | FLAGS_DPGROUP ); 5577 break; 5578 case 8: 5579 check( dpid[0], idTo ); 5580 lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData; 5581 check( dpid[3], lpDataDestroy->dpId ); 5582 checkFlags( DPPLAYER_LOCAL, lpDataDestroy->dwFlags, 5583 FLAGS_DPPLAYER | FLAGS_DPGROUP ); 5584 break; 5585 5586 /* 1 -> 2,0 */ 5587 case 9: 5588 check( dpid[2], idTo ); 5589 lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData; 5590 check( dpid[1], lpDataDestroy->dpId ); 5591 checkFlags( DPPLAYER_LOCAL | 5592 DPPLAYER_SPECTATOR, lpDataDestroy->dwFlags, 5593 FLAGS_DPPLAYER | FLAGS_DPGROUP ); 5594 break; 5595 case 10: 5596 check( dpid[0], idTo ); 5597 lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData; 5598 check( dpid[1], lpDataDestroy->dpId ); 5599 checkFlags( DPPLAYER_LOCAL | 5600 DPPLAYER_SPECTATOR, lpDataDestroy->dwFlags, 5601 FLAGS_DPPLAYER | FLAGS_DPGROUP ); 5602 break; 5603 5604 default: 5605 trace( "%s\n", dpMsgType2str(lpData->dwType) ); 5606 break; 5607 } 5608 } 5609 5610 hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpData, &dwDataSize ); 5611 checkHR( DPERR_NOMESSAGES, hr ); 5612 5613 5614 /* New data message */ 5615 hr = IDirectPlayX_Send( pDP, dpid[0], dpid[2], 0, 5616 (LPVOID) message, messageSize ); 5617 checkHR( DP_OK, hr ); 5618 5619 5620 /* Ensuring DPRECEIVE_PEEK doesn't remove the messages from the queue */ 5621 for (i=0; i<10; i++) 5622 { 5623 hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, DPRECEIVE_PEEK, 5624 lpData, &dwDataSize ); 5625 checkHR( DP_OK, hr ); 5626 checkStr( message, (LPSTR) lpData ); 5627 } 5628 5629 /* Removing the message from the queue */ 5630 hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpData, &dwDataSize ); 5631 checkHR( DP_OK, hr ); 5632 check( idFrom, dpid[0] ); 5633 check( idTo, dpid[2] ); 5634 checkStr( message, (LPSTR) lpData ); 5635 5636 hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpData, &dwDataSize ); 5637 checkHR( DPERR_NOMESSAGES, hr ); 5638 5639 5640 HeapFree( GetProcessHeap(), 0, lpData ); 5641 IDirectPlayX_Release( pDP ); 5642 5643 } 5644 5645 /* GetMessageCount */ 5646 5647 static void test_GetMessageCount(void) 5648 { 5649 5650 IDirectPlay4 *pDP[2]; 5651 DPSESSIONDESC2 dpsd; 5652 DPID dpid[4]; 5653 HRESULT hr; 5654 UINT i; 5655 DWORD dwCount; 5656 5657 DWORD dwDataSize = 1024; 5658 LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize ); 5659 CallbackData callbackData; 5660 5661 5662 for (i=0; i<2; i++) 5663 { 5664 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 5665 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 5666 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 5667 if (FAILED(hr)) return; 5668 } 5669 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 5670 5671 dwCount = -1; 5672 hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount ); 5673 todo_wine checkHR( DPERR_UNINITIALIZED, hr ); 5674 check( -1, dwCount ); 5675 5676 if ( hr == DP_OK ) 5677 { 5678 todo_wine win_skip( "GetMessageCount not implemented\n" ); 5679 return; 5680 } 5681 5682 5683 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 ); 5684 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 ); 5685 5686 5687 dwCount = -1; 5688 hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount ); 5689 checkHR( DP_OK, hr ); 5690 check( 0, dwCount ); 5691 5692 5693 dpsd.dwSize = sizeof(DPSESSIONDESC2); 5694 dpsd.guidApplication = appGuid; 5695 dpsd.dwMaxPlayers = 10; 5696 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 5697 IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join, 5698 pDP[1], 0 ); 5699 5700 IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 ); 5701 IDirectPlayX_CreatePlayer( pDP[0], &dpid[1], NULL, NULL, NULL, 0, 0 ); 5702 IDirectPlayX_CreatePlayer( pDP[1], &dpid[3], NULL, NULL, NULL, 0, 0 ); 5703 IDirectPlayX_CreatePlayer( pDP[0], &dpid[2], NULL, NULL, NULL, 0, 0 ); 5704 5705 5706 /* Incorrect parameters */ 5707 dwCount = -1; 5708 hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[0], NULL ); 5709 checkHR( DPERR_INVALIDPARAMS, hr ); 5710 check( -1, dwCount ); 5711 5712 dwCount = -1; 5713 hr = IDirectPlayX_GetMessageCount( pDP[0], 0, NULL ); 5714 checkHR( DPERR_INVALIDPARAMS, hr ); 5715 check( -1, dwCount ); 5716 5717 dwCount = -1; 5718 hr = IDirectPlayX_GetMessageCount( pDP[0], -1, &dwCount ); 5719 checkHR( DPERR_INVALIDPLAYER, hr ); 5720 check( -1, dwCount ); 5721 5722 5723 /* Correct parameters */ 5724 /* Player creation messages */ 5725 dwCount = -1; 5726 hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount ); 5727 checkHR( DP_OK, hr ); 5728 check( 5, dwCount ); 5729 5730 dwCount = -1; 5731 hr = IDirectPlayX_GetMessageCount( pDP[1], 0, &dwCount ); 5732 checkHR( DP_OK, hr ); 5733 check( 1, dwCount ); 5734 5735 dwCount = -1; 5736 hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[0], &dwCount ); 5737 checkHR( DP_OK, hr ); 5738 check( 3, dwCount ); 5739 5740 dwCount = -1; 5741 hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[1], &dwCount ); 5742 checkHR( DP_OK, hr ); 5743 check( 2, dwCount ); 5744 5745 dwCount = -1; 5746 hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[3], &dwCount ); 5747 checkHR( DP_OK, hr ); 5748 /* Remote player: doesn't throw error but result is 0 and not 1 */ 5749 check( 0, dwCount ); 5750 5751 dwCount = -1; 5752 hr = IDirectPlayX_GetMessageCount( pDP[1], dpid[3], &dwCount ); 5753 checkHR( DP_OK, hr ); 5754 check( 1, dwCount ); 5755 5756 dwCount = -1; 5757 hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[1], &dwCount ); 5758 checkHR( DP_OK, hr ); 5759 check( 2, dwCount ); 5760 5761 5762 /* Purge queues */ 5763 check_messages( pDP[0], dpid, 6, &callbackData ); 5764 checkStr( "S0,S1,S0,S1,S0,", callbackData.szTrace1 ); 5765 check_messages( pDP[1], dpid, 6, &callbackData ); 5766 checkStr( "S3,", callbackData.szTrace1 ); 5767 5768 5769 /* Ensure queues is purged */ 5770 dwCount = -1; 5771 hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount ); 5772 checkHR( DP_OK, hr ); 5773 check( 0, dwCount ); 5774 5775 dwCount = -1; 5776 hr = IDirectPlayX_GetMessageCount( pDP[1], 0, &dwCount ); 5777 checkHR( DP_OK, hr ); 5778 check( 0, dwCount ); 5779 5780 5781 /* Send data messages */ 5782 for (i=0; i<5; i++) 5783 IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 0, lpData, dwDataSize ); 5784 for (i=0; i<6; i++) 5785 IDirectPlayX_Send( pDP[0], dpid[1], dpid[2], 0, lpData, dwDataSize ); 5786 for (i=0; i<7; i++) 5787 IDirectPlayX_Send( pDP[0], dpid[2], dpid[3], 0, lpData, dwDataSize ); 5788 5789 5790 /* Check all messages are in the queues */ 5791 dwCount = -1; 5792 hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount ); 5793 checkHR( DP_OK, hr ); 5794 check( 11, dwCount ); 5795 5796 dwCount = -1; 5797 hr = IDirectPlayX_GetMessageCount( pDP[1], 0, &dwCount ); 5798 checkHR( DP_OK, hr ); 5799 check( 7, dwCount ); 5800 5801 dwCount = -1; 5802 hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[0], &dwCount ); 5803 checkHR( DP_OK, hr ); 5804 check( 0, dwCount ); 5805 5806 dwCount = -1; 5807 hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[1], &dwCount ); 5808 checkHR( DP_OK, hr ); 5809 check( 5, dwCount ); 5810 5811 dwCount = -1; 5812 hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[2], &dwCount ); 5813 checkHR( DP_OK, hr ); 5814 check( 6, dwCount ); 5815 5816 dwCount = -1; 5817 hr = IDirectPlayX_GetMessageCount( pDP[1], dpid[3], &dwCount ); 5818 checkHR( DP_OK, hr ); 5819 check( 7, dwCount ); 5820 5821 5822 /* Purge queues again */ 5823 check_messages( pDP[0], dpid, 6, &callbackData ); 5824 checkStr( "01,01,01,01,01," 5825 "12,12,12,12,12,12,", callbackData.szTrace1 ); 5826 check_messages( pDP[1], dpid, 6, &callbackData ); 5827 checkStr( "23,23,23,23,23,23,23,", callbackData.szTrace1 ); 5828 5829 5830 /* Check queues are purged */ 5831 dwCount = -1; 5832 hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount ); 5833 checkHR( DP_OK, hr ); 5834 check( 0, dwCount ); 5835 5836 dwCount = -1; 5837 hr = IDirectPlayX_GetMessageCount( pDP[1], 0, &dwCount ); 5838 checkHR( DP_OK, hr ); 5839 check( 0, dwCount ); 5840 5841 dwCount = -1; 5842 hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[0], &dwCount ); 5843 checkHR( DP_OK, hr ); 5844 check( 0, dwCount ); 5845 5846 dwCount = -1; 5847 hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[1], &dwCount ); 5848 checkHR( DP_OK, hr ); 5849 check( 0, dwCount ); 5850 5851 dwCount = -1; 5852 hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[2], &dwCount ); 5853 checkHR( DP_OK, hr ); 5854 check( 0, dwCount ); 5855 5856 dwCount = -1; 5857 hr = IDirectPlayX_GetMessageCount( pDP[1], dpid[3], &dwCount ); 5858 checkHR( DP_OK, hr ); 5859 check( 0, dwCount ); 5860 5861 5862 HeapFree( GetProcessHeap(), 0, lpData ); 5863 IDirectPlayX_Release( pDP[0] ); 5864 IDirectPlayX_Release( pDP[1] ); 5865 5866 } 5867 5868 /* GetMessageQueue */ 5869 5870 static void test_GetMessageQueue(void) 5871 { 5872 5873 IDirectPlay4 *pDP[2]; 5874 DPSESSIONDESC2 dpsd; 5875 DPID dpid[4]; 5876 CallbackData callbackData; 5877 HRESULT hr; 5878 UINT i; 5879 DWORD dwNumMsgs, dwNumBytes; 5880 5881 DWORD dwDataSize = 1024; 5882 LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize ); 5883 5884 5885 for (i=0; i<2; i++) 5886 { 5887 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 5888 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 5889 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 5890 if (FAILED(hr)) return; 5891 } 5892 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 5893 5894 5895 dwNumMsgs = dwNumBytes = -1; 5896 hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, 0, 0, 5897 &dwNumMsgs, &dwNumBytes ); 5898 todo_wine checkHR( DPERR_UNINITIALIZED, hr ); 5899 check( -1, dwNumMsgs ); 5900 check( -1, dwNumBytes ); 5901 5902 if ( hr == DP_OK ) 5903 { 5904 todo_wine win_skip( "GetMessageQueue not implemented\n" ); 5905 return; 5906 } 5907 5908 5909 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 ); 5910 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 ); 5911 5912 5913 dwNumMsgs = dwNumBytes = -1; 5914 hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, 0, 0, 5915 &dwNumMsgs, &dwNumBytes ); 5916 checkHR( DP_OK, hr ); 5917 check( 0, dwNumMsgs ); 5918 check( 0, dwNumBytes ); 5919 5920 5921 dpsd.dwSize = sizeof(DPSESSIONDESC2); 5922 dpsd.guidApplication = appGuid; 5923 dpsd.dwMaxPlayers = 10; 5924 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 5925 IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join, 5926 pDP[1], 0 ); 5927 5928 IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 ); 5929 IDirectPlayX_CreatePlayer( pDP[0], &dpid[1], NULL, NULL, NULL, 0, 0 ); 5930 IDirectPlayX_CreatePlayer( pDP[1], &dpid[3], NULL, NULL, NULL, 0, 0 ); 5931 IDirectPlayX_CreatePlayer( pDP[0], &dpid[2], NULL, NULL, NULL, 0, 0 ); 5932 5933 5934 5935 /* Incorrect parameters */ 5936 dwNumMsgs = dwNumBytes = -1; 5937 hr = IDirectPlayX_GetMessageQueue( pDP[0], -1, dpid[1], 5938 0, 5939 &dwNumMsgs, &dwNumBytes ); 5940 checkHR( DPERR_INVALIDPLAYER, hr ); 5941 check( -1, dwNumMsgs ); 5942 check( -1, dwNumBytes ); 5943 5944 dwNumMsgs = dwNumBytes = -1; 5945 hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], -1, 5946 0, 5947 &dwNumMsgs, &dwNumBytes ); 5948 checkHR( DPERR_INVALIDPLAYER, hr ); 5949 check( -1, dwNumMsgs ); 5950 check( -1, dwNumBytes ); 5951 5952 dwNumMsgs = dwNumBytes = -1; 5953 hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[0], 5954 -1, 5955 &dwNumMsgs, &dwNumBytes ); 5956 checkHR( DPERR_INVALIDFLAGS, hr ); 5957 check( -1, dwNumMsgs ); 5958 check( -1, dwNumBytes ); 5959 5960 dwNumMsgs = dwNumBytes = -1; 5961 hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1], 5962 ( DPMESSAGEQUEUE_SEND | 5963 DPMESSAGEQUEUE_RECEIVE ), 5964 &dwNumMsgs, &dwNumBytes ); 5965 checkHR( DPERR_INVALIDFLAGS, hr ); 5966 check( -1, dwNumMsgs ); 5967 check( -1, dwNumBytes ); 5968 5969 /* - Remote players */ 5970 if(0) 5971 { 5972 /* Crash under Win7 */ 5973 dwNumMsgs = dwNumBytes = -1; 5974 hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, dpid[3], 5975 DPMESSAGEQUEUE_RECEIVE, 5976 &dwNumMsgs, &dwNumBytes ); 5977 checkHR( DPERR_INVALIDPLAYER, hr ); /* Player 3 is remote */ 5978 check( -1, dwNumMsgs ); 5979 check( -1, dwNumBytes ); 5980 } 5981 5982 dwNumMsgs = dwNumBytes = -1; 5983 hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[3], 0, 5984 DPMESSAGEQUEUE_SEND, 5985 &dwNumMsgs, &dwNumBytes ); 5986 checkHR( DPERR_INVALIDPLAYER, hr ); /* Player 3 is remote */ 5987 check( -1, dwNumMsgs ); 5988 check( -1, dwNumBytes ); 5989 5990 /* - Remote players, this time in the right place */ 5991 dwNumMsgs = dwNumBytes = -1; 5992 hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, dpid[3], 5993 DPMESSAGEQUEUE_SEND, 5994 &dwNumMsgs, &dwNumBytes ); 5995 checkHR( DP_OK, hr ); 5996 check( 0, dwNumMsgs ); 5997 check( 0, dwNumBytes ); 5998 5999 dwNumMsgs = dwNumBytes = -1; 6000 hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[3], 0, 6001 DPMESSAGEQUEUE_RECEIVE, 6002 &dwNumMsgs, &dwNumBytes ); 6003 checkHR( DP_OK, hr ); 6004 check( 0, dwNumMsgs ); 6005 check( 0, dwNumBytes ); 6006 6007 6008 /* Correct parameters */ 6009 dwNumMsgs = dwNumBytes = -1; 6010 hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, dpid[1], 6011 DPMESSAGEQUEUE_RECEIVE, 6012 &dwNumMsgs, &dwNumBytes ); 6013 checkHR( DP_OK, hr ); 6014 check( 2, dwNumMsgs ); 6015 check( 96, dwNumBytes ); 6016 6017 dwNumMsgs = dwNumBytes = -1; 6018 hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], 0, 6019 DPMESSAGEQUEUE_RECEIVE, 6020 &dwNumMsgs, &dwNumBytes ); 6021 checkHR( DP_OK, hr ); 6022 check( 0, dwNumMsgs ); 6023 check( 0, dwNumBytes ); 6024 6025 dwNumMsgs = dwNumBytes = -1; 6026 hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, 0, 6027 DPMESSAGEQUEUE_RECEIVE, 6028 &dwNumMsgs, &dwNumBytes ); 6029 checkHR( DP_OK, hr ); 6030 check( 5, dwNumMsgs ); 6031 check( 240, dwNumBytes ); 6032 6033 dwNumMsgs = dwNumBytes = -1; 6034 hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1], 6035 DPMESSAGEQUEUE_RECEIVE, 6036 NULL, &dwNumBytes ); 6037 checkHR( DP_OK, hr ); 6038 check( -1, dwNumMsgs ); 6039 check( 0, dwNumBytes ); 6040 6041 dwNumMsgs = dwNumBytes = -1; 6042 hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1], 6043 DPMESSAGEQUEUE_RECEIVE, 6044 &dwNumMsgs, NULL ); 6045 checkHR( DP_OK, hr ); 6046 check( 0, dwNumMsgs ); 6047 check( -1, dwNumBytes ); 6048 6049 dwNumMsgs = dwNumBytes = -1; 6050 hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1], 6051 DPMESSAGEQUEUE_RECEIVE, 6052 NULL, NULL ); 6053 checkHR( DP_OK, hr ); 6054 check( -1, dwNumMsgs ); 6055 check( -1, dwNumBytes ); 6056 6057 dwNumMsgs = dwNumBytes = -1; 6058 hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1], 6059 DPMESSAGEQUEUE_RECEIVE, 6060 &dwNumMsgs, &dwNumBytes ); 6061 checkHR( DP_OK, hr ); 6062 check( 0, dwNumMsgs ); 6063 check( 0, dwNumBytes ); 6064 6065 6066 /* Purge messages */ 6067 check_messages( pDP[0], dpid, 6, &callbackData ); 6068 checkStr( "S0,S1,S0,S1,S0,", callbackData.szTrace1 ); 6069 check_messages( pDP[1], dpid, 6, &callbackData ); 6070 checkStr( "S3,", callbackData.szTrace1 ); 6071 6072 /* Check queues are empty */ 6073 dwNumMsgs = dwNumBytes = -1; 6074 hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, 0, 6075 DPMESSAGEQUEUE_RECEIVE, 6076 &dwNumMsgs, &dwNumBytes ); 6077 checkHR( DP_OK, hr ); 6078 check( 0, dwNumMsgs ); 6079 check( 0, dwNumBytes ); 6080 6081 6082 /* Sending 4 data messages from 0 to 1 */ 6083 /* 3 from 0 to 3 */ 6084 /* 2 from 1 to 3 */ 6085 for (i=0; i<4; i++) 6086 IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 0, lpData, dwDataSize ); 6087 for (i=0; i<3; i++) 6088 IDirectPlayX_Send( pDP[0], dpid[0], dpid[3], 0, lpData, dwDataSize ); 6089 for (i=0; i<2; i++) 6090 IDirectPlayX_Send( pDP[0], dpid[1], dpid[3], 0, lpData, dwDataSize ); 6091 6092 6093 dwNumMsgs = dwNumBytes = -1; 6094 hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1], 6095 DPMESSAGEQUEUE_RECEIVE, 6096 &dwNumMsgs, &dwNumBytes ); 6097 checkHR( DP_OK, hr ); 6098 check( 4, dwNumMsgs ); 6099 check( 4*dwDataSize, dwNumBytes ); 6100 6101 dwNumMsgs = dwNumBytes = -1; 6102 hr = IDirectPlayX_GetMessageQueue( pDP[1], dpid[0], dpid[3], 6103 DPMESSAGEQUEUE_RECEIVE, 6104 &dwNumMsgs, &dwNumBytes ); 6105 checkHR( DP_OK, hr ); 6106 check( 3, dwNumMsgs ); 6107 check( 3*dwDataSize, dwNumBytes ); 6108 6109 dwNumMsgs = dwNumBytes = -1; 6110 hr = IDirectPlayX_GetMessageQueue( pDP[1], dpid[1], dpid[3], 6111 DPMESSAGEQUEUE_RECEIVE, 6112 &dwNumMsgs, &dwNumBytes ); 6113 checkHR( DP_OK, hr ); 6114 check( 2, dwNumMsgs ); 6115 check( 2*dwDataSize, dwNumBytes ); 6116 6117 dwNumMsgs = dwNumBytes = -1; 6118 hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], 0, 6119 DPMESSAGEQUEUE_RECEIVE, 6120 &dwNumMsgs, &dwNumBytes ); 6121 checkHR( DP_OK, hr ); 6122 check( 4, dwNumMsgs ); 6123 check( 4*dwDataSize, dwNumBytes ); 6124 6125 dwNumMsgs = dwNumBytes = -1; 6126 hr = IDirectPlayX_GetMessageQueue( pDP[1], dpid[0], 0, 6127 DPMESSAGEQUEUE_RECEIVE, 6128 &dwNumMsgs, &dwNumBytes ); 6129 checkHR( DP_OK, hr ); 6130 check( 3, dwNumMsgs ); 6131 check( 3*dwDataSize, dwNumBytes ); 6132 6133 dwNumMsgs = dwNumBytes = -1; 6134 hr = IDirectPlayX_GetMessageQueue( pDP[1], 0, dpid[3], 6135 DPMESSAGEQUEUE_RECEIVE, 6136 &dwNumMsgs, &dwNumBytes ); 6137 checkHR( DP_OK, hr ); 6138 check( 5, dwNumMsgs ); 6139 check( 5*dwDataSize, dwNumBytes ); 6140 6141 dwNumMsgs = dwNumBytes = -1; 6142 hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, 0, 6143 DPMESSAGEQUEUE_RECEIVE, 6144 &dwNumMsgs, &dwNumBytes ); 6145 checkHR( DP_OK, hr ); 6146 check( 4, dwNumMsgs ); 6147 check( 4*dwDataSize, dwNumBytes ); 6148 6149 dwNumMsgs = dwNumBytes = -1; 6150 hr = IDirectPlayX_GetMessageQueue( pDP[1], 0, 0, 6151 DPMESSAGEQUEUE_RECEIVE, 6152 &dwNumMsgs, &dwNumBytes ); 6153 checkHR( DP_OK, hr ); 6154 check( 5, dwNumMsgs ); 6155 check( 5*dwDataSize, dwNumBytes ); 6156 6157 6158 dwNumMsgs = dwNumBytes = -1; 6159 hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1], 6160 DPMESSAGEQUEUE_SEND, 6161 &dwNumMsgs, &dwNumBytes ); 6162 checkHR( DP_OK, hr ); 6163 check( 0, dwNumMsgs ); 6164 check( 0, dwNumBytes ); 6165 6166 dwNumMsgs = dwNumBytes = -1; 6167 hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1], 6168 0, 6169 &dwNumMsgs, &dwNumBytes ); 6170 checkHR( DP_OK, hr ); 6171 check( 0, dwNumMsgs ); 6172 check( 0, dwNumBytes ); 6173 6174 6175 HeapFree( GetProcessHeap(), 0, lpData ); 6176 IDirectPlayX_Release( pDP[0] ); 6177 IDirectPlayX_Release( pDP[1] ); 6178 6179 } 6180 6181 /* Remote data replication */ 6182 6183 static void test_remote_data_replication(void) 6184 { 6185 6186 IDirectPlay4 *pDP[2]; 6187 DPSESSIONDESC2 dpsd; 6188 DPID dpid[2], idFrom, idTo; 6189 CallbackData callbackData; 6190 HRESULT hr; 6191 UINT i, j; 6192 DWORD dwFlags, dwDataSize = 1024; 6193 DWORD dwCount; 6194 6195 LPDPMSG_SETPLAYERORGROUPDATA lpData = HeapAlloc( GetProcessHeap(), 6196 HEAP_ZERO_MEMORY, 6197 dwDataSize ); 6198 6199 LPCSTR lpDataLocal[] = { "local_0", "local_1" }; 6200 LPCSTR lpDataRemote[] = { "remote_0", "remote_1" }; 6201 LPCSTR lpDataFake = "ugly_fake_data"; 6202 LPSTR lpDataGet = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 32 ); 6203 DWORD dwDataSizeLocal = strlen(lpDataLocal[0])+1, 6204 dwDataSizeRemote = strlen(lpDataRemote[0])+1, 6205 dwDataSizeFake = strlen(lpDataFake)+1, 6206 dwDataSizeGet; 6207 6208 6209 for (i=0; i<2; i++) 6210 { 6211 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 6212 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 6213 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 6214 if (FAILED(hr)) return; 6215 init_TCPIP_provider( pDP[i], "127.0.0.1", 0 ); 6216 } 6217 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 6218 dpsd.dwSize = sizeof(DPSESSIONDESC2); 6219 dpsd.guidApplication = appGuid; 6220 6221 /* Host */ 6222 hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 6223 todo_wine checkHR( DP_OK, hr ); 6224 6225 if ( hr == DPERR_UNINITIALIZED ) 6226 { 6227 todo_wine win_skip( "dplay not implemented enough for this test yet\n" ); 6228 return; 6229 } 6230 6231 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], 6232 NULL, NULL, NULL, 0, 0 ); 6233 checkHR( DP_OK, hr ); 6234 6235 /* Peer */ 6236 hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join, 6237 pDP[1], 0 ); 6238 checkHR( DP_OK, hr ); 6239 6240 hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid[1], 6241 NULL, NULL, NULL, 0, 0 ); 6242 checkHR( DP_OK, hr ); 6243 6244 /* Check players */ 6245 for (i=0; i<2; i++) 6246 { 6247 /* Local (0,0) (1,1) */ 6248 IDirectPlayX_GetPlayerFlags( pDP[i], dpid[i], &dwFlags ); 6249 checkFlags( DPPLAYER_LOCAL, dwFlags, FLAGS_DPPLAYER ); 6250 /* Remote (0,1) (1,0) */ 6251 IDirectPlayX_GetPlayerFlags( pDP[i], dpid[!i], &dwFlags ); 6252 checkFlags( 0, dwFlags, FLAGS_DPPLAYER ); 6253 } 6254 6255 /* Set data for a local player */ 6256 for (i=0; i<2; i++) 6257 { 6258 hr = IDirectPlayX_SetPlayerData( pDP[i], dpid[i], 6259 (LPVOID) lpDataLocal[i], 6260 dwDataSizeLocal, 6261 DPSET_LOCAL ); 6262 checkHR( DP_OK, hr ); 6263 hr = IDirectPlayX_SetPlayerData( pDP[i], dpid[i], 6264 (LPVOID) lpDataRemote[i], 6265 dwDataSizeRemote, 6266 DPSET_REMOTE ); 6267 checkHR( DP_OK, hr ); 6268 } 6269 6270 /* Retrieve data locally (0->0, 1->1) */ 6271 for (i=0; i<2; i++) 6272 { 6273 dwDataSizeGet = dwDataSizeFake; 6274 strcpy( lpDataGet, lpDataFake ); 6275 hr = IDirectPlayX_GetPlayerData( pDP[i], dpid[i], 6276 lpDataGet, &dwDataSizeGet, 6277 DPGET_LOCAL ); 6278 checkHR( DP_OK, hr ); 6279 check( dwDataSizeLocal, dwDataSizeGet ); 6280 checkStr( lpDataLocal[i], lpDataGet ); 6281 6282 dwDataSizeGet = dwDataSizeFake; 6283 strcpy( lpDataGet, lpDataFake ); 6284 hr = IDirectPlayX_GetPlayerData( pDP[i], dpid[i], 6285 lpDataGet, &dwDataSizeGet, 6286 DPGET_REMOTE ); 6287 checkHR( DP_OK, hr ); 6288 check( dwDataSizeRemote, dwDataSizeGet ); 6289 checkStr( lpDataRemote[i], lpDataGet ); 6290 } 6291 6292 6293 /* Set data for a remote player */ 6294 /* This should fail with DPERR_ACCESSDENIED, 6295 but for some reason it doesn't */ 6296 for (i=0; i<2; i++) 6297 { 6298 IDirectPlayX_SetPlayerData( pDP[i], dpid[!i], 6299 (LPVOID) lpDataLocal[!i], 6300 dwDataSizeLocal, 6301 DPSET_LOCAL ); 6302 checkHR( DP_OK, hr ); 6303 IDirectPlayX_SetPlayerData( pDP[i], dpid[!i], 6304 (LPVOID) lpDataRemote[!i], 6305 dwDataSizeRemote, 6306 DPSET_REMOTE ); 6307 checkHR( DP_OK, hr ); 6308 } 6309 6310 /* Retrieve crossed data (0->1, 1->0) */ 6311 for (i=0; i<2; i++) 6312 { 6313 dwDataSizeGet = dwDataSizeFake; 6314 strcpy( lpDataGet, lpDataFake ); 6315 hr = IDirectPlayX_GetPlayerData( pDP[i], dpid[!i], 6316 lpDataGet, &dwDataSizeGet, 6317 DPGET_LOCAL ); 6318 checkHR( DP_OK, hr ); 6319 check( dwDataSizeLocal, dwDataSizeGet ); 6320 checkStr( lpDataLocal[!i], lpDataGet ); 6321 6322 dwDataSizeGet = dwDataSizeFake; 6323 strcpy( lpDataGet, lpDataFake ); 6324 hr = IDirectPlayX_GetPlayerData( pDP[i], dpid[!i], 6325 lpDataGet, &dwDataSizeGet, 6326 DPGET_REMOTE ); 6327 checkHR( DP_OK, hr ); 6328 check( dwDataSizeRemote, dwDataSizeGet ); 6329 checkStr( lpDataRemote[!i], lpDataGet ); 6330 } 6331 6332 6333 /* Purge "new player" messages from queue */ 6334 hr = IDirectPlayX_Receive( pDP[0], &idFrom, &idTo, 0, lpData, &dwDataSize ); 6335 checkHR( DP_OK, hr ); 6336 checkConv( DPSYS_CREATEPLAYERORGROUP, lpData->dwType, dpMsgType2str ); 6337 6338 /* Check number of messages in queue */ 6339 for (i=0; i<2; i++) 6340 { 6341 IDirectPlayX_GetMessageCount( pDP[i], dpid[i], &dwCount ); 6342 check( 2, dwCount ); 6343 IDirectPlayX_GetMessageCount( pDP[i], dpid[!i], &dwCount ); 6344 check( 0, dwCount ); 6345 } 6346 6347 /* Checking system messages */ 6348 for (i=0; i<2; i++) 6349 { 6350 for (j=0; j<2; j++) 6351 { 6352 hr = IDirectPlayX_Receive( pDP[i], &idFrom, &idTo, 0, lpData, 6353 &dwDataSize ); 6354 checkHR( DP_OK, hr ); 6355 check( 29, dwDataSize ); 6356 check( DPID_SYSMSG, idFrom ); 6357 check( dpid[i], idTo ); 6358 checkConv( DPSYS_SETPLAYERORGROUPDATA, lpData->dwType, 6359 dpMsgType2str ); 6360 check( DPPLAYERTYPE_PLAYER, lpData->dwPlayerType ); 6361 check( dpid[j], lpData->dpId ); 6362 checkStr( lpDataRemote[j], (LPSTR) lpData->lpData ); 6363 check( dwDataSizeRemote, lpData->dwDataSize ); 6364 dwDataSize = 1024; 6365 } 6366 hr = IDirectPlayX_Receive( pDP[i], &idFrom, &idTo, 0, 6367 lpData, &dwDataSize ); 6368 checkHR( DPERR_NOMESSAGES, hr ); 6369 } 6370 6371 6372 /* Changing remote data */ 6373 hr = IDirectPlayX_SetPlayerData( pDP[0], dpid[0], 6374 (LPVOID) lpDataRemote[0], dwDataSizeRemote, 6375 DPSET_REMOTE ); 6376 checkHR( DP_OK, hr ); 6377 6378 /* Checking system messages (j=0) */ 6379 for (i=0; i<2; i++) 6380 { 6381 hr = IDirectPlayX_Receive( pDP[i], &idFrom, &idTo, 0, 6382 lpData, &dwDataSize ); 6383 checkHR( DP_OK, hr ); 6384 check( 29, dwDataSize ); 6385 check( DPID_SYSMSG, idFrom ); 6386 check( dpid[i], idTo ); 6387 checkConv( DPSYS_SETPLAYERORGROUPDATA, lpData->dwType, dpMsgType2str ); 6388 check( DPPLAYERTYPE_PLAYER, lpData->dwPlayerType ); 6389 check( dpid[0], lpData->dpId ); 6390 checkStr( lpDataRemote[0], (LPSTR) lpData->lpData ); 6391 check( dwDataSizeRemote, lpData->dwDataSize ); 6392 dwDataSize = 1024; 6393 } 6394 6395 /* Queue is empty */ 6396 check_messages( pDP[0], dpid, 2, &callbackData ); 6397 checkStr( "", callbackData.szTrace1 ); 6398 check_messages( pDP[1], dpid, 2, &callbackData ); 6399 checkStr( "", callbackData.szTrace1 ); 6400 6401 6402 HeapFree( GetProcessHeap(), 0, lpDataGet ); 6403 HeapFree( GetProcessHeap(), 0, lpData ); 6404 IDirectPlayX_Release( pDP[0] ); 6405 IDirectPlayX_Release( pDP[1] ); 6406 6407 } 6408 6409 /* Host migration */ 6410 6411 static void test_host_migration(void) 6412 { 6413 6414 IDirectPlay4 *pDP[2]; 6415 DPSESSIONDESC2 dpsd; 6416 DPID dpid[2], idFrom, idTo; 6417 HRESULT hr; 6418 UINT i; 6419 DWORD dwCount; 6420 6421 DWORD dwDataSize = 1024; 6422 LPDPMSG_DESTROYPLAYERORGROUP lpData = HeapAlloc( GetProcessHeap(), 6423 HEAP_ZERO_MEMORY, 6424 dwDataSize ); 6425 6426 6427 for (i=0; i<2; i++) 6428 { 6429 hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL, 6430 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] ); 6431 ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" ); 6432 if (FAILED(hr)) return; 6433 init_TCPIP_provider( pDP[i], "127.0.0.1", 0 ); 6434 } 6435 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) ); 6436 dpsd.dwSize = sizeof(DPSESSIONDESC2); 6437 dpsd.guidApplication = appGuid; 6438 dpsd.dwMaxPlayers = 10; 6439 dpsd.dwFlags = DPSESSION_MIGRATEHOST; 6440 6441 /* Host */ 6442 hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE ); 6443 todo_wine checkHR( DP_OK, hr ); 6444 6445 if ( hr != DP_OK ) 6446 { 6447 todo_wine win_skip( "dplay not implemented enough for this test yet\n" ); 6448 return; 6449 } 6450 6451 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 ); 6452 checkHR( DP_OK, hr ); 6453 6454 /* Peer */ 6455 hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join, 6456 pDP[1], 0 ); 6457 checkHR( DP_OK, hr ); 6458 6459 hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid[1], NULL, NULL, NULL, 0, 0 ); 6460 checkHR( DP_OK, hr ); 6461 6462 6463 /* Host: One message in queue */ 6464 IDirectPlayX_GetMessageCount( pDP[0], dpid[0], &dwCount ); 6465 check( 1, dwCount ); 6466 dwDataSize = 1024; 6467 hr = IDirectPlayX_Receive( pDP[0], &idFrom, &idTo, DPRECEIVE_PEEK, 6468 lpData, &dwDataSize ); 6469 checkHR( DP_OK, hr ); 6470 checkConv( DPSYS_CREATEPLAYERORGROUP, lpData->dwType, dpMsgType2str ); 6471 6472 /* Peer: No messages */ 6473 IDirectPlayX_GetMessageCount( pDP[1], dpid[1], &dwCount ); 6474 check( 0, dwCount ); 6475 hr = IDirectPlayX_Receive( pDP[1], &idFrom, &idTo, DPRECEIVE_PEEK, 6476 lpData, &dwDataSize ); 6477 checkHR( DPERR_NOMESSAGES, hr ); 6478 6479 6480 /* Closing host */ 6481 IDirectPlayX_Close( pDP[0] ); 6482 6483 6484 /* Host: Queue is cleaned */ 6485 IDirectPlayX_GetMessageCount( pDP[0], dpid[0], &dwCount ); 6486 check( 0, dwCount ); 6487 hr = IDirectPlayX_Receive( pDP[0], &idFrom, &idTo, DPRECEIVE_PEEK, 6488 lpData, &dwDataSize ); 6489 checkHR( DPERR_NOMESSAGES, hr ); 6490 6491 /* Peer: gets message of player destruction */ 6492 IDirectPlayX_GetMessageCount( pDP[1], dpid[1], &dwCount ); 6493 check( 2, dwCount ); 6494 dwDataSize = 1024; 6495 hr = IDirectPlayX_Receive( pDP[1], &idFrom, &idTo, DPRECEIVE_PEEK, 6496 lpData, &dwDataSize ); 6497 checkHR( DP_OK, hr ); 6498 checkConv( DPSYS_DESTROYPLAYERORGROUP, lpData->dwType, dpMsgType2str ); 6499 6500 6501 /* Message analysis */ 6502 for (i=0; i<2; i++) 6503 { 6504 hr = IDirectPlayX_Receive( pDP[1], &idFrom, &idTo, 0, 6505 lpData, &dwDataSize ); 6506 checkHR( DP_OK, hr ); 6507 check( DPID_SYSMSG, idFrom ); 6508 check( dpid[1], idTo ); /* Peer player id */ 6509 switch(i) 6510 { 6511 case 0: 6512 checkConv( DPSYS_DESTROYPLAYERORGROUP, lpData->dwType, 6513 dpMsgType2str ); 6514 check( DPPLAYERTYPE_PLAYER, lpData->dwPlayerType ); 6515 check( dpid[0], lpData->dpId ); /* Host player id */ 6516 checkLP( NULL, lpData->lpLocalData ); 6517 check( 0, lpData->dwLocalDataSize ); 6518 checkLP( NULL, lpData->lpRemoteData ); 6519 check( 0, lpData->dwRemoteDataSize ); 6520 checkLP( NULL, U1(lpData->dpnName).lpszShortNameA ); 6521 check( 0, lpData->dpIdParent ); 6522 checkFlags( 0, lpData->dwFlags, 6523 FLAGS_DPPLAYER | FLAGS_DPGROUP ); 6524 break; 6525 case 1: 6526 checkConv( DPSYS_HOST, lpData->dwType, dpMsgType2str ); 6527 break; 6528 default: 6529 break; 6530 } 6531 dwDataSize = 1024; 6532 } 6533 hr = IDirectPlayX_Receive( pDP[1], &idFrom, &idTo, 0, lpData, &dwDataSize ); 6534 checkHR( DPERR_NOMESSAGES, hr ); 6535 6536 6537 HeapFree( GetProcessHeap(), 0, lpData ); 6538 IDirectPlayX_Release( pDP[0] ); 6539 IDirectPlayX_Release( pDP[1] ); 6540 6541 } 6542 6543 static void test_COM(void) 6544 { 6545 IDirectPlay *dp; 6546 IDirectPlay2A *dp2A; 6547 IDirectPlay2 *dp2; 6548 IDirectPlay3A *dp3A; 6549 IDirectPlay3 *dp3; 6550 IDirectPlay4A *dp4A; 6551 #ifdef __REACTOS__ 6552 IDirectPlay4 *dp4 = (IDirectPlay4*)(ULONG_PTR)0xdeadbeefdeadbeefull; 6553 #else 6554 IDirectPlay4 *dp4 = (IDirectPlay4*)0xdeadbeef; 6555 #endif 6556 IUnknown *unk; 6557 ULONG refcount; 6558 HRESULT hr; 6559 6560 /* COM aggregation */ 6561 #ifdef __REACTOS__ 6562 hr = CoCreateInstance(&CLSID_DirectPlay, (IUnknown*)(ULONG_PTR)0xdeadbeefdeadbeefull, CLSCTX_INPROC_SERVER, 6563 &IID_IUnknown, (void**)&dp4); 6564 #else 6565 hr = CoCreateInstance(&CLSID_DirectPlay, (IUnknown*)0xdeadbeef, CLSCTX_INPROC_SERVER, 6566 &IID_IUnknown, (void**)&dp4); 6567 #endif 6568 ok(hr == CLASS_E_NOAGGREGATION || broken(hr == E_INVALIDARG), 6569 "DirectPlay create failed: %08x, expected CLASS_E_NOAGGREGATION\n", hr); 6570 #ifdef __REACTOS__ 6571 ok(!dp4 || dp4 == (IDirectPlay4*)(ULONG_PTR)0xdeadbeefdeadbeefull, "dp4 = %p\n", dp4); 6572 #else 6573 ok(!dp4 || dp4 == (IDirectPlay4*)0xdeadbeef, "dp4 = %p\n", dp4); 6574 #endif 6575 6576 /* Invalid RIID */ 6577 hr = CoCreateInstance(&CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlayLobby, 6578 (void**)&dp4); 6579 ok(hr == E_NOINTERFACE, "DirectPlay create failed: %08x, expected E_NOINTERFACE\n", hr); 6580 6581 /* Different refcount for all DirectPlay Interfaces */ 6582 hr = CoCreateInstance(&CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay4, 6583 (void**)&dp4); 6584 ok(hr == S_OK, "DirectPlay create failed: %08x, expected S_OK\n", hr); 6585 refcount = IDirectPlayX_AddRef(dp4); 6586 ok(refcount == 2, "refcount == %u, expected 2\n", refcount); 6587 6588 hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay2A, (void**)&dp2A); 6589 ok(hr == S_OK, "QueryInterface for IID_IDirectPlay2A failed: %08x\n", hr); 6590 refcount = IDirectPlay2_AddRef(dp2A); 6591 ok(refcount == 2, "refcount == %u, expected 2\n", refcount); 6592 IDirectPlay2_Release(dp2A); 6593 6594 hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay2, (void**)&dp2); 6595 ok(hr == S_OK, "QueryInterface for IID_IDirectPlay2 failed: %08x\n", hr); 6596 refcount = IDirectPlay2_AddRef(dp2); 6597 ok(refcount == 2, "refcount == %u, expected 2\n", refcount); 6598 IDirectPlay2_Release(dp2); 6599 6600 hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay3A, (void**)&dp3A); 6601 ok(hr == S_OK, "QueryInterface for IID_IDirectPlay3A failed: %08x\n", hr); 6602 refcount = IDirectPlay3_AddRef(dp3A); 6603 ok(refcount == 2, "refcount == %u, expected 2\n", refcount); 6604 IDirectPlay3_Release(dp3A); 6605 6606 hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay3, (void**)&dp3); 6607 ok(hr == S_OK, "QueryInterface for IID_IDirectPlay3 failed: %08x\n", hr); 6608 refcount = IDirectPlay3_AddRef(dp3); 6609 ok(refcount == 2, "refcount == %u, expected 2\n", refcount); 6610 IDirectPlay3_Release(dp3); 6611 6612 hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay4A, (void**)&dp4A); 6613 ok(hr == S_OK, "QueryInterface for IID_IDirectPlay4A failed: %08x\n", hr); 6614 refcount = IDirectPlayX_AddRef(dp4A); 6615 ok(refcount == 2, "refcount == %u, expected 2\n", refcount); 6616 IDirectPlayX_Release(dp4A); 6617 6618 /* IDirectPlay and IUnknown share a refcount */ 6619 hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay, (void**)&dp); 6620 ok(hr == S_OK, "QueryInterface for IID_IDirectPlay failed: %08x\n", hr); 6621 refcount = IDirectPlayX_AddRef(dp); 6622 ok(refcount == 2, "refcount == %u, expected 2\n", refcount); 6623 IDirectPlay_Release(dp); 6624 6625 hr = IDirectPlayX_QueryInterface(dp4, &IID_IUnknown, (void**)&unk); 6626 ok(hr == S_OK, "QueryInterface for IID_IUnknown failed: %08x\n", hr); 6627 refcount = IUnknown_AddRef(unk); 6628 ok(refcount == 3, "refcount == %u, expected 3\n", refcount); 6629 refcount = IUnknown_Release(unk); 6630 ok(refcount == 2, "refcount == %u, expected 2\n", refcount); 6631 6632 IUnknown_Release(unk); 6633 IDirectPlay_Release(dp); 6634 IDirectPlayX_Release(dp4A); 6635 IDirectPlay3_Release(dp3); 6636 IDirectPlay3_Release(dp3A); 6637 IDirectPlay2_Release(dp2); 6638 IDirectPlay2_Release(dp2A); 6639 IDirectPlayX_Release(dp4); 6640 refcount = IDirectPlayX_Release(dp4); 6641 ok(refcount == 0, "refcount == %u, expected 0\n", refcount); 6642 } 6643 6644 static void test_COM_dplobby(void) 6645 { 6646 #ifdef __REACTOS__ 6647 IDirectPlayLobby *dpl = (IDirectPlayLobby*)(ULONG_PTR)0xdeadbeefdeadbeefull; 6648 #else 6649 IDirectPlayLobby *dpl = (IDirectPlayLobby*)0xdeadbeef; 6650 #endif 6651 IDirectPlayLobbyA *dplA; 6652 IDirectPlayLobby2A *dpl2A; 6653 IDirectPlayLobby2 *dpl2; 6654 IDirectPlayLobby3A *dpl3A; 6655 IDirectPlayLobby3 *dpl3; 6656 IUnknown *unk; 6657 ULONG refcount; 6658 HRESULT hr; 6659 6660 /* COM aggregation */ 6661 #ifdef __REACTOS__ 6662 hr = CoCreateInstance(&CLSID_DirectPlayLobby, (IUnknown*)(ULONG_PTR)0xdeadbeefdeadbeefull, CLSCTX_INPROC_SERVER, 6663 &IID_IUnknown, (void**)&dpl); 6664 #else 6665 hr = CoCreateInstance(&CLSID_DirectPlayLobby, (IUnknown*)0xdeadbeef, CLSCTX_INPROC_SERVER, 6666 &IID_IUnknown, (void**)&dpl); 6667 #endif 6668 ok(hr == CLASS_E_NOAGGREGATION || broken(hr == E_INVALIDARG), 6669 "DirectPlayLobby create failed: %08x, expected CLASS_E_NOAGGREGATION\n", hr); 6670 #ifdef __REACTOS__ 6671 ok(!dpl || dpl == (IDirectPlayLobby*)(ULONG_PTR)0xdeadbeefdeadbeefull, "dpl = %p\n", dpl); 6672 #else 6673 ok(!dpl || dpl == (IDirectPlayLobby*)0xdeadbeef, "dpl = %p\n", dpl); 6674 #endif 6675 6676 /* Invalid RIID */ 6677 hr = CoCreateInstance(&CLSID_DirectPlayLobby, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay, 6678 (void**)&dpl); 6679 ok(hr == E_NOINTERFACE, "DirectPlayLobby create failed: %08x, expected E_NOINTERFACE\n", hr); 6680 6681 /* Different refcount for all DirectPlayLobby Interfaces */ 6682 hr = CoCreateInstance(&CLSID_DirectPlayLobby, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlayLobby, 6683 (void**)&dpl); 6684 ok(hr == S_OK, "DirectPlayLobby create failed: %08x, expected S_OK\n", hr); 6685 refcount = IDirectPlayLobby_AddRef(dpl); 6686 ok(refcount == 2, "refcount == %u, expected 2\n", refcount); 6687 6688 hr = IDirectPlayLobby_QueryInterface(dpl, &IID_IDirectPlayLobbyA, (void**)&dplA); 6689 ok(hr == S_OK, "QueryInterface for IID_IDirectPlayLobbyA failed: %08x\n", hr); 6690 refcount = IDirectPlayLobby_AddRef(dplA); 6691 ok(refcount == 2, "refcount == %u, expected 2\n", refcount); 6692 IDirectPlayLobby_Release(dplA); 6693 6694 hr = IDirectPlayLobby_QueryInterface(dpl, &IID_IDirectPlayLobby2, (void**)&dpl2); 6695 ok(hr == S_OK, "QueryInterface for IID_IDirectPlayLobby2 failed: %08x\n", hr); 6696 refcount = IDirectPlayLobby_AddRef(dpl2); 6697 ok(refcount == 2, "refcount == %u, expected 2\n", refcount); 6698 IDirectPlayLobby_Release(dpl2); 6699 6700 hr = IDirectPlayLobby_QueryInterface(dpl, &IID_IDirectPlayLobby2A, (void**)&dpl2A); 6701 ok(hr == S_OK, "QueryInterface for IID_IDirectPlayLobby2A failed: %08x\n", hr); 6702 refcount = IDirectPlayLobby_AddRef(dpl2A); 6703 ok(refcount == 2, "refcount == %u, expected 2\n", refcount); 6704 IDirectPlayLobby_Release(dpl2A); 6705 6706 hr = IDirectPlayLobby_QueryInterface(dpl, &IID_IDirectPlayLobby3, (void**)&dpl3); 6707 ok(hr == S_OK, "QueryInterface for IID_IDirectPlayLobby3 failed: %08x\n", hr); 6708 refcount = IDirectPlayLobby_AddRef(dpl3); 6709 ok(refcount == 2, "refcount == %u, expected 2\n", refcount); 6710 IDirectPlayLobby_Release(dpl3); 6711 6712 hr = IDirectPlayLobby_QueryInterface(dpl, &IID_IDirectPlayLobby3A, (void**)&dpl3A); 6713 ok(hr == S_OK, "QueryInterface for IID_IDirectPlayLobby3A failed: %08x\n", hr); 6714 refcount = IDirectPlayLobby_AddRef(dpl3A); 6715 ok(refcount == 2, "refcount == %u, expected 2\n", refcount); 6716 IDirectPlayLobby_Release(dpl3A); 6717 6718 /* IDirectPlayLobby and IUnknown share a refcount */ 6719 hr = IDirectPlayX_QueryInterface(dpl, &IID_IUnknown, (void**)&unk); 6720 ok(hr == S_OK, "QueryInterface for IID_IUnknown failed: %08x\n", hr); 6721 refcount = IUnknown_AddRef(unk); 6722 ok(refcount == 4, "refcount == %u, expected 4\n", refcount); 6723 IDirectPlayLobby_Release(unk); 6724 6725 IUnknown_Release(unk); 6726 IDirectPlayLobby_Release(dpl3); 6727 IDirectPlayLobby_Release(dpl3A); 6728 IDirectPlayLobby_Release(dpl2); 6729 IDirectPlayLobby_Release(dpl2A); 6730 IDirectPlayLobby_Release(dplA); 6731 IDirectPlayLobby_Release(dpl); 6732 refcount = IDirectPlayLobby_Release(dpl); 6733 ok(refcount == 0, "refcount == %u, expected 0\n", refcount); 6734 } 6735 6736 enum firewall_op 6737 { 6738 APP_ADD, 6739 APP_REMOVE 6740 }; 6741 6742 static BOOL is_process_elevated(void) 6743 { 6744 HANDLE token; 6745 if (OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &token )) 6746 { 6747 TOKEN_ELEVATION_TYPE type; 6748 DWORD size; 6749 BOOL ret; 6750 6751 ret = GetTokenInformation( token, TokenElevationType, &type, sizeof(type), &size ); 6752 CloseHandle( token ); 6753 return (ret && type == TokenElevationTypeFull); 6754 } 6755 return FALSE; 6756 } 6757 6758 static BOOL is_firewall_enabled(void) 6759 { 6760 HRESULT hr, init; 6761 INetFwMgr *mgr = NULL; 6762 INetFwPolicy *policy = NULL; 6763 INetFwProfile *profile = NULL; 6764 VARIANT_BOOL enabled = VARIANT_FALSE; 6765 6766 init = CoInitializeEx( 0, COINIT_APARTMENTTHREADED ); 6767 6768 hr = CoCreateInstance( &CLSID_NetFwMgr, NULL, CLSCTX_INPROC_SERVER, &IID_INetFwMgr, 6769 (void **)&mgr ); 6770 ok( hr == S_OK, "got %08x\n", hr ); 6771 if (hr != S_OK) goto done; 6772 6773 hr = INetFwMgr_get_LocalPolicy( mgr, &policy ); 6774 ok( hr == S_OK, "got %08x\n", hr ); 6775 if (hr != S_OK) goto done; 6776 6777 hr = INetFwPolicy_get_CurrentProfile( policy, &profile ); 6778 if (hr != S_OK) goto done; 6779 6780 hr = INetFwProfile_get_FirewallEnabled( profile, &enabled ); 6781 ok( hr == S_OK, "got %08x\n", hr ); 6782 6783 done: 6784 if (policy) INetFwPolicy_Release( policy ); 6785 if (profile) INetFwProfile_Release( profile ); 6786 if (mgr) INetFwMgr_Release( mgr ); 6787 if (SUCCEEDED( init )) CoUninitialize(); 6788 return (enabled == VARIANT_TRUE); 6789 } 6790 6791 static HRESULT set_firewall( enum firewall_op op ) 6792 { 6793 static const WCHAR dplaysvrW[] = 6794 {'d','p','l','a','y','s','v','r','.','e','x','e',0}; 6795 static const WCHAR separator[] = {'\\',0}; 6796 static const WCHAR clientW[] = 6797 {'d','p','l','a','y','_','c','l','i','e','n','t',0}; 6798 static const WCHAR serverW[] = 6799 {'d','p','l','a','y','_','s','e','r','v','e','r',0}; 6800 HRESULT hr, init; 6801 INetFwMgr *mgr = NULL; 6802 INetFwPolicy *policy = NULL; 6803 INetFwProfile *profile = NULL; 6804 INetFwAuthorizedApplication *app = NULL; 6805 INetFwAuthorizedApplications *apps = NULL; 6806 BSTR name, image = SysAllocStringLen( NULL, MAX_PATH ); 6807 WCHAR path[MAX_PATH]; 6808 6809 if (!GetModuleFileNameW( NULL, image, MAX_PATH )) 6810 { 6811 SysFreeString( image ); 6812 return E_FAIL; 6813 } 6814 6815 if(!GetSystemDirectoryW(path, MAX_PATH)) 6816 { 6817 SysFreeString( image ); 6818 return E_FAIL; 6819 } 6820 lstrcatW(path, separator); 6821 lstrcatW(path, dplaysvrW); 6822 6823 init = CoInitializeEx( 0, COINIT_APARTMENTTHREADED ); 6824 6825 hr = CoCreateInstance( &CLSID_NetFwMgr, NULL, CLSCTX_INPROC_SERVER, &IID_INetFwMgr, 6826 (void **)&mgr ); 6827 ok( hr == S_OK, "got %08x\n", hr ); 6828 if (hr != S_OK) goto done; 6829 6830 hr = INetFwMgr_get_LocalPolicy( mgr, &policy ); 6831 ok( hr == S_OK, "got %08x\n", hr ); 6832 if (hr != S_OK) goto done; 6833 6834 hr = INetFwPolicy_get_CurrentProfile( policy, &profile ); 6835 if (hr != S_OK) goto done; 6836 6837 hr = INetFwProfile_get_AuthorizedApplications( profile, &apps ); 6838 ok( hr == S_OK, "got %08x\n", hr ); 6839 if (hr != S_OK) goto done; 6840 6841 hr = CoCreateInstance( &CLSID_NetFwAuthorizedApplication, NULL, CLSCTX_INPROC_SERVER, 6842 &IID_INetFwAuthorizedApplication, (void **)&app ); 6843 ok( hr == S_OK, "got %08x\n", hr ); 6844 if (hr != S_OK) goto done; 6845 6846 hr = INetFwAuthorizedApplication_put_ProcessImageFileName( app, image ); 6847 if (hr != S_OK) goto done; 6848 6849 name = SysAllocString( clientW ); 6850 hr = INetFwAuthorizedApplication_put_Name( app, name ); 6851 SysFreeString( name ); 6852 ok( hr == S_OK, "got %08x\n", hr ); 6853 if (hr != S_OK) goto done; 6854 6855 if (op == APP_ADD) 6856 hr = INetFwAuthorizedApplications_Add( apps, app ); 6857 else if (op == APP_REMOVE) 6858 hr = INetFwAuthorizedApplications_Remove( apps, image ); 6859 else 6860 hr = E_INVALIDARG; 6861 if (hr != S_OK) goto done; 6862 6863 INetFwAuthorizedApplication_Release( app ); 6864 hr = CoCreateInstance( &CLSID_NetFwAuthorizedApplication, NULL, CLSCTX_INPROC_SERVER, 6865 &IID_INetFwAuthorizedApplication, (void **)&app ); 6866 ok( hr == S_OK, "got %08x\n", hr ); 6867 if (hr != S_OK) goto done; 6868 6869 SysFreeString( image ); 6870 image = SysAllocString( path ); 6871 hr = INetFwAuthorizedApplication_put_ProcessImageFileName( app, image ); 6872 if (hr != S_OK) goto done; 6873 6874 name = SysAllocString( serverW ); 6875 hr = INetFwAuthorizedApplication_put_Name( app, name ); 6876 SysFreeString( name ); 6877 ok( hr == S_OK, "got %08x\n", hr ); 6878 if (hr != S_OK) goto done; 6879 6880 if (op == APP_ADD) 6881 hr = INetFwAuthorizedApplications_Add( apps, app ); 6882 else if (op == APP_REMOVE) 6883 hr = INetFwAuthorizedApplications_Remove( apps, image ); 6884 else 6885 hr = E_INVALIDARG; 6886 6887 done: 6888 if (app) INetFwAuthorizedApplication_Release( app ); 6889 if (apps) INetFwAuthorizedApplications_Release( apps ); 6890 if (policy) INetFwPolicy_Release( policy ); 6891 if (profile) INetFwProfile_Release( profile ); 6892 if (mgr) INetFwMgr_Release( mgr ); 6893 if (SUCCEEDED( init )) CoUninitialize(); 6894 SysFreeString( image ); 6895 return hr; 6896 } 6897 6898 /* taken from programs/winetest/main.c */ 6899 static BOOL is_stub_dll(const char *filename) 6900 { 6901 DWORD size, ver; 6902 BOOL isstub = FALSE; 6903 char *p, *data; 6904 6905 size = GetFileVersionInfoSizeA(filename, &ver); 6906 if (!size) return FALSE; 6907 6908 data = HeapAlloc(GetProcessHeap(), 0, size); 6909 if (!data) return FALSE; 6910 6911 if (GetFileVersionInfoA(filename, ver, size, data)) 6912 { 6913 char buf[256]; 6914 6915 sprintf(buf, "\\StringFileInfo\\%04x%04x\\OriginalFilename", MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), 1200); 6916 if (VerQueryValueA(data, buf, (void**)&p, &size)) 6917 isstub = !lstrcmpiA("wcodstub.dll", p); 6918 } 6919 HeapFree(GetProcessHeap(), 0, data); 6920 6921 return isstub; 6922 } 6923 6924 START_TEST(dplayx) 6925 { 6926 BOOL firewall_enabled; 6927 HRESULT hr; 6928 char path[MAX_PATH]; 6929 HMODULE module; 6930 6931 if(!GetSystemDirectoryA(path, MAX_PATH)) 6932 { 6933 skip("Failed to get systems directory\n"); 6934 return; 6935 } 6936 strcat(path, "\\dplayx.dll"); 6937 6938 if (!winetest_interactive && is_stub_dll(path)) 6939 { 6940 win_skip("dpnet is a stub dll, skipping tests\n"); 6941 return; 6942 } 6943 6944 if ((firewall_enabled = is_firewall_enabled()) && !is_process_elevated()) 6945 { 6946 skip("no privileges, skipping tests to avoid firewall dialog\n"); 6947 return; 6948 } 6949 6950 if (firewall_enabled) 6951 { 6952 hr = set_firewall(APP_ADD); 6953 if (hr != S_OK) 6954 { 6955 skip("can't authorize app in firewall %08x\n", hr); 6956 return; 6957 } 6958 } 6959 6960 CoInitialize( NULL ); 6961 6962 module = LoadLibraryA("dplayx.dll"); 6963 6964 pDirectPlayEnumerateA = (void *)GetProcAddress(module, "DirectPlayEnumerateA"); 6965 pDirectPlayEnumerateW = (void *)GetProcAddress(module, "DirectPlayEnumerateW"); 6966 pDirectPlayCreate = (void *)GetProcAddress(module, "DirectPlayCreate"); 6967 6968 test_COM(); 6969 test_COM_dplobby(); 6970 test_EnumerateProviders(); 6971 test_DirectPlayCreate(); 6972 test_EnumConnections(); 6973 test_InitializeConnection(); 6974 test_GetCaps(); 6975 test_EnumAddressTypes(); 6976 6977 if (!winetest_interactive) 6978 { 6979 skip("Run in interactive mode to run all dplayx tests.\n"); 6980 goto done; 6981 } 6982 6983 trace("Running in interactive mode, tests will take a while\n"); 6984 6985 /* test_Open() takes almost a minute, */ 6986 test_Open(); 6987 /* test_EnumSession takes three minutes */ 6988 test_EnumSessions(); 6989 test_SessionDesc(); 6990 6991 /* test_CreatePlayer() takes over a minute */ 6992 test_CreatePlayer(); 6993 test_GetPlayerCaps(); 6994 test_PlayerData(); 6995 test_PlayerName(); 6996 6997 /* test_GetPlayerAccount() takes over 30s */ 6998 test_GetPlayerAccount(); 6999 test_GetPlayerAddress(); 7000 test_GetPlayerFlags(); 7001 7002 test_CreateGroup(); 7003 test_GroupOwner(); 7004 7005 test_EnumPlayers(); 7006 test_EnumGroups(); 7007 test_EnumGroupsInGroup(); 7008 7009 test_groups_p2p(); 7010 test_groups_cs(); 7011 7012 test_Send(); 7013 test_Receive(); 7014 test_GetMessageCount(); 7015 test_GetMessageQueue(); 7016 7017 test_remote_data_replication(); 7018 test_host_migration(); 7019 7020 done: 7021 FreeLibrary(module); 7022 CoUninitialize(); 7023 if (firewall_enabled) set_firewall(APP_REMOVE); 7024 } 7025