1 /* DirectPlay Conformance Tests
3 * Copyright 2007 - Alessandro Pignotti
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.
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.
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
20 #include "wine/test.h"
27 #define check(expected, result) \
28 ok( (expected) == (result), \
29 "expected=%d got=%d\n", \
31 #define checkLP(expected, result) \
32 ok( (expected) == (result), \
33 "expected=%p got=%p\n", \
35 #define checkHR(expected, result) \
36 ok( (expected) == (result), \
37 "expected=%s got=%s\n", \
38 dpResult2str(expected), dpResult2str(result) );
39 #define checkStr(expected, result) \
40 ok( (result != NULL) && (!strcmp(expected, result)), \
41 "expected=%s got=%s\n", \
43 #define checkFlags(expected, result, flags) \
44 ok( (expected) == (result), \
45 "expected=0x%08x(%s) got=0x%08x(%s)\n", \
46 expected, dwFlags2str(expected, flags), \
47 result, dwFlags2str(result, flags) );
48 #define checkGuid(expected, result) \
49 ok( IsEqualGUID(expected, result), \
50 "expected=%s got=%s\n", \
51 Guid2str(expected), Guid2str(result) );
52 #define checkConv(expected, result, function) \
53 ok( (expected) == (result), \
54 "expected=0x%08x(%s) got=0x%08x(%s)\n", \
55 expected, function(expected), \
56 result, function(result) );
59 DEFINE_GUID(appGuid
, 0xbdcfe03e, 0xf0ec, 0x415b, 0x82, 0x11, 0x6f, 0x86, 0xd8, 0x19, 0x7f, 0xe1);
60 DEFINE_GUID(appGuid2
, 0x93417d3f, 0x7d26, 0x46ba, 0xb5, 0x76, 0xfe, 0x4b, 0x20, 0xbb, 0xad, 0x70);
61 DEFINE_GUID(GUID_NULL
,0,0,0,0,0,0,0,0,0,0,0);
64 typedef struct tagCallbackData
67 UINT dwCounter1
, dwCounter2
;
69 char szTrace1
[1024], szTrace2
[1024];
72 } CallbackData
, *lpCallbackData
;
75 static LPSTR
get_temp_buffer(void)
77 static UINT index
= 0;
78 static char buff
[10][256];
80 index
= (index
+ 1) % 10;
87 static LPCSTR
Guid2str(const GUID
*guid
)
89 LPSTR buffer
= get_temp_buffer();
91 if (!guid
) return "(null)";
93 /* Service providers */
94 if (IsEqualGUID(guid
, &DPSPGUID_IPX
))
95 return "DPSPGUID_IPX";
96 if (IsEqualGUID(guid
, &DPSPGUID_TCPIP
))
97 return "DPSPGUID_TCPIP";
98 if (IsEqualGUID(guid
, &DPSPGUID_SERIAL
))
99 return "DPSPGUID_SERIAL";
100 if (IsEqualGUID(guid
, &DPSPGUID_MODEM
))
101 return "DPSPGUID_MODEM";
102 /* DirectPlay Address ID's */
103 if (IsEqualGUID(guid
, &DPAID_TotalSize
))
104 return "DPAID_TotalSize";
105 if (IsEqualGUID(guid
, &DPAID_ServiceProvider
))
106 return "DPAID_ServiceProvider";
107 if (IsEqualGUID(guid
, &DPAID_LobbyProvider
))
108 return "DPAID_LobbyProvider";
109 if (IsEqualGUID(guid
, &DPAID_Phone
))
110 return "DPAID_Phone";
111 if (IsEqualGUID(guid
, &DPAID_PhoneW
))
112 return "DPAID_PhoneW";
113 if (IsEqualGUID(guid
, &DPAID_Modem
))
114 return "DPAID_Modem";
115 if (IsEqualGUID(guid
, &DPAID_ModemW
))
116 return "DPAID_ModemW";
117 if (IsEqualGUID(guid
, &DPAID_INet
))
119 if (IsEqualGUID(guid
, &DPAID_INetW
))
120 return "DPAID_INetW";
121 if (IsEqualGUID(guid
, &DPAID_INetPort
))
122 return "DPAID_INetPort";
123 if (IsEqualGUID(guid
, &DPAID_ComPort
))
124 return "DPAID_ComPort";
126 sprintf( buffer
, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
127 guid
->Data1
, guid
->Data2
, guid
->Data3
,
128 guid
->Data4
[0], guid
->Data4
[1], guid
->Data4
[2], guid
->Data4
[3],
129 guid
->Data4
[4], guid
->Data4
[5], guid
->Data4
[6], guid
->Data4
[7] );
135 static LPCSTR
dpResult2str(HRESULT hr
)
139 case DP_OK
: return "DP_OK";
140 case DPERR_ALREADYINITIALIZED
: return "DPERR_ALREADYINITIALIZED";
141 case DPERR_ACCESSDENIED
: return "DPERR_ACCESSDENIED";
142 case DPERR_ACTIVEPLAYERS
: return "DPERR_ACTIVEPLAYERS";
143 case DPERR_BUFFERTOOSMALL
: return "DPERR_BUFFERTOOSMALL";
144 case DPERR_CANTADDPLAYER
: return "DPERR_CANTADDPLAYER";
145 case DPERR_CANTCREATEGROUP
: return "DPERR_CANTCREATEGROUP";
146 case DPERR_CANTCREATEPLAYER
: return "DPERR_CANTCREATEPLAYER";
147 case DPERR_CANTCREATESESSION
: return "DPERR_CANTCREATESESSION";
148 case DPERR_CAPSNOTAVAILABLEYET
: return "DPERR_CAPSNOTAVAILABLEYET";
149 case DPERR_EXCEPTION
: return "DPERR_EXCEPTION";
150 case DPERR_GENERIC
: return "DPERR_GENERIC";
151 case DPERR_INVALIDFLAGS
: return "DPERR_INVALIDFLAGS";
152 case DPERR_INVALIDOBJECT
: return "DPERR_INVALIDOBJECT";
153 case DPERR_INVALIDPARAMS
: return "DPERR_INVALIDPARAMS";
154 /* symbol with the same value: DPERR_INVALIDPARAM */
155 case DPERR_INVALIDPLAYER
: return "DPERR_INVALIDPLAYER";
156 case DPERR_INVALIDGROUP
: return "DPERR_INVALIDGROUP";
157 case DPERR_NOCAPS
: return "DPERR_NOCAPS";
158 case DPERR_NOCONNECTION
: return "DPERR_NOCONNECTION";
159 case DPERR_NOMEMORY
: return "DPERR_NOMEMORY";
160 /* symbol with the same value: DPERR_OUTOFMEMORY */
161 case DPERR_NOMESSAGES
: return "DPERR_NOMESSAGES";
162 case DPERR_NONAMESERVERFOUND
: return "DPERR_NONAMESERVERFOUND";
163 case DPERR_NOPLAYERS
: return "DPERR_NOPLAYERS";
164 case DPERR_NOSESSIONS
: return "DPERR_NOSESSIONS";
165 case DPERR_PENDING
: return "DPERR_PENDING";
166 case DPERR_SENDTOOBIG
: return "DPERR_SENDTOOBIG";
167 case DPERR_TIMEOUT
: return "DPERR_TIMEOUT";
168 case DPERR_UNAVAILABLE
: return "DPERR_UNAVAILABLE";
169 case DPERR_UNSUPPORTED
: return "DPERR_UNSUPPORTED";
170 case DPERR_BUSY
: return "DPERR_BUSY";
171 case DPERR_USERCANCEL
: return "DPERR_USERCANCEL";
172 case DPERR_NOINTERFACE
: return "DPERR_NOINTERFACE";
173 case DPERR_CANNOTCREATESERVER
: return "DPERR_CANNOTCREATESERVER";
174 case DPERR_PLAYERLOST
: return "DPERR_PLAYERLOST";
175 case DPERR_SESSIONLOST
: return "DPERR_SESSIONLOST";
176 case DPERR_UNINITIALIZED
: return "DPERR_UNINITIALIZED";
177 case DPERR_NONEWPLAYERS
: return "DPERR_NONEWPLAYERS";
178 case DPERR_INVALIDPASSWORD
: return "DPERR_INVALIDPASSWORD";
179 case DPERR_CONNECTING
: return "DPERR_CONNECTING";
180 case DPERR_CONNECTIONLOST
: return "DPERR_CONNECTIONLOST";
181 case DPERR_UNKNOWNMESSAGE
: return "DPERR_UNKNOWNMESSAGE";
182 case DPERR_CANCELFAILED
: return "DPERR_CANCELFAILED";
183 case DPERR_INVALIDPRIORITY
: return "DPERR_INVALIDPRIORITY";
184 case DPERR_NOTHANDLED
: return "DPERR_NOTHANDLED";
185 case DPERR_CANCELLED
: return "DPERR_CANCELLED";
186 case DPERR_ABORTED
: return "DPERR_ABORTED";
187 case DPERR_BUFFERTOOLARGE
: return "DPERR_BUFFERTOOLARGE";
188 case DPERR_CANTCREATEPROCESS
: return "DPERR_CANTCREATEPROCESS";
189 case DPERR_APPNOTSTARTED
: return "DPERR_APPNOTSTARTED";
190 case DPERR_INVALIDINTERFACE
: return "DPERR_INVALIDINTERFACE";
191 case DPERR_NOSERVICEPROVIDER
: return "DPERR_NOSERVICEPROVIDER";
192 case DPERR_UNKNOWNAPPLICATION
: return "DPERR_UNKNOWNAPPLICATION";
193 case DPERR_NOTLOBBIED
: return "DPERR_NOTLOBBIED";
194 case DPERR_SERVICEPROVIDERLOADED
: return "DPERR_SERVICEPROVIDERLOADED";
195 case DPERR_ALREADYREGISTERED
: return "DPERR_ALREADYREGISTERED";
196 case DPERR_NOTREGISTERED
: return "DPERR_NOTREGISTERED";
197 case DPERR_AUTHENTICATIONFAILED
: return "DPERR_AUTHENTICATIONFAILED";
198 case DPERR_CANTLOADSSPI
: return "DPERR_CANTLOADSSPI";
199 case DPERR_ENCRYPTIONFAILED
: return "DPERR_ENCRYPTIONFAILED";
200 case DPERR_SIGNFAILED
: return "DPERR_SIGNFAILED";
201 case DPERR_CANTLOADSECURITYPACKAGE
: return "DPERR_CANTLOADSECURITYPACKAGE";
202 case DPERR_ENCRYPTIONNOTSUPPORTED
: return "DPERR_ENCRYPTIONNOTSUPPORTED";
203 case DPERR_CANTLOADCAPI
: return "DPERR_CANTLOADCAPI";
204 case DPERR_NOTLOGGEDIN
: return "DPERR_NOTLOGGEDIN";
205 case DPERR_LOGONDENIED
: return "DPERR_LOGONDENIED";
206 case CLASS_E_NOAGGREGATION
: return "CLASS_E_NOAGGREGATION";
210 LPSTR buffer
= get_temp_buffer();
211 sprintf( buffer
, "%d", HRESULT_CODE(hr
) );
217 static LPCSTR
dpMsgType2str(DWORD dwType
)
221 case DPSYS_CREATEPLAYERORGROUP
: return "DPSYS_CREATEPLAYERORGROUP";
222 case DPSYS_DESTROYPLAYERORGROUP
: return "DPSYS_DESTROYPLAYERORGROUP";
223 case DPSYS_ADDPLAYERTOGROUP
: return "DPSYS_ADDPLAYERTOGROUP";
224 case DPSYS_DELETEPLAYERFROMGROUP
: return "DPSYS_DELETEPLAYERFROMGROUP";
225 case DPSYS_SESSIONLOST
: return "DPSYS_SESSIONLOST";
226 case DPSYS_HOST
: return "DPSYS_HOST";
227 case DPSYS_SETPLAYERORGROUPDATA
: return "DPSYS_SETPLAYERORGROUPDATA";
228 case DPSYS_SETPLAYERORGROUPNAME
: return "DPSYS_SETPLAYERORGROUPNAME";
229 case DPSYS_SETSESSIONDESC
: return "DPSYS_SETSESSIONDESC";
230 case DPSYS_ADDGROUPTOGROUP
: return "DPSYS_ADDGROUPTOGROUP";
231 case DPSYS_DELETEGROUPFROMGROUP
: return "DPSYS_DELETEGROUPFROMGROUP";
232 case DPSYS_SECUREMESSAGE
: return "DPSYS_SECUREMESSAGE";
233 case DPSYS_STARTSESSION
: return "DPSYS_STARTSESSION";
234 case DPSYS_CHAT
: return "DPSYS_DPSYS_CHAT";
235 case DPSYS_SETGROUPOWNER
: return "DPSYS_SETGROUPOWNER";
236 case DPSYS_SENDCOMPLETE
: return "DPSYS_SENDCOMPLETE";
238 default: return "UNKNOWN";
242 static LPCSTR
dwFlags2str(DWORD dwFlags
, DWORD flagType
)
245 #define FLAGS_DPCONNECTION (1<<0)
246 #define FLAGS_DPENUMPLAYERS (1<<1)
247 #define FLAGS_DPENUMGROUPS (1<<2)
248 #define FLAGS_DPPLAYER (1<<3)
249 #define FLAGS_DPGROUP (1<<4)
250 #define FLAGS_DPENUMSESSIONS (1<<5)
251 #define FLAGS_DPGETCAPS (1<<6)
252 #define FLAGS_DPGET (1<<7)
253 #define FLAGS_DPRECEIVE (1<<8)
254 #define FLAGS_DPSEND (1<<9)
255 #define FLAGS_DPSET (1<<10)
256 #define FLAGS_DPMESSAGEQUEUE (1<<11)
257 #define FLAGS_DPCONNECT (1<<12)
258 #define FLAGS_DPOPEN (1<<13)
259 #define FLAGS_DPSESSION (1<<14)
260 #define FLAGS_DPLCONNECTION (1<<15)
261 #define FLAGS_DPESC (1<<16)
262 #define FLAGS_DPCAPS (1<<17)
264 LPSTR flags
= get_temp_buffer();
266 /* EnumConnections */
268 if (flagType
& FLAGS_DPCONNECTION
)
270 if (dwFlags
& DPCONNECTION_DIRECTPLAY
)
271 strcat(flags
, "DPCONNECTION_DIRECTPLAY,");
272 if (dwFlags
& DPCONNECTION_DIRECTPLAYLOBBY
)
273 strcat(flags
, "DPCONNECTION_DIRECTPLAYLOBBY,");
279 if (flagType
& FLAGS_DPENUMPLAYERS
)
281 if (dwFlags
== DPENUMPLAYERS_ALL
)
282 strcat(flags
, "DPENUMPLAYERS_ALL,");
283 if (dwFlags
& DPENUMPLAYERS_LOCAL
)
284 strcat(flags
, "DPENUMPLAYERS_LOCAL,");
285 if (dwFlags
& DPENUMPLAYERS_REMOTE
)
286 strcat(flags
, "DPENUMPLAYERS_REMOTE,");
287 if (dwFlags
& DPENUMPLAYERS_GROUP
)
288 strcat(flags
, "DPENUMPLAYERS_GROUP,");
289 if (dwFlags
& DPENUMPLAYERS_SESSION
)
290 strcat(flags
, "DPENUMPLAYERS_SESSION,");
291 if (dwFlags
& DPENUMPLAYERS_SERVERPLAYER
)
292 strcat(flags
, "DPENUMPLAYERS_SERVERPLAYER,");
293 if (dwFlags
& DPENUMPLAYERS_SPECTATOR
)
294 strcat(flags
, "DPENUMPLAYERS_SPECTATOR,");
295 if (dwFlags
& DPENUMPLAYERS_OWNER
)
296 strcat(flags
, "DPENUMPLAYERS_OWNER,");
298 if (flagType
& FLAGS_DPENUMGROUPS
)
300 if (dwFlags
== DPENUMGROUPS_ALL
)
301 strcat(flags
, "DPENUMGROUPS_ALL,");
302 if (dwFlags
& DPENUMPLAYERS_LOCAL
)
303 strcat(flags
, "DPENUMGROUPS_LOCAL,");
304 if (dwFlags
& DPENUMPLAYERS_REMOTE
)
305 strcat(flags
, "DPENUMGROUPS_REMOTE,");
306 if (dwFlags
& DPENUMPLAYERS_GROUP
)
307 strcat(flags
, "DPENUMGROUPS_GROUP,");
308 if (dwFlags
& DPENUMPLAYERS_SESSION
)
309 strcat(flags
, "DPENUMGROUPS_SESSION,");
310 if (dwFlags
& DPENUMGROUPS_SHORTCUT
)
311 strcat(flags
, "DPENUMGROUPS_SHORTCUT,");
312 if (dwFlags
& DPENUMGROUPS_STAGINGAREA
)
313 strcat(flags
, "DPENUMGROUPS_STAGINGAREA,");
314 if (dwFlags
& DPENUMGROUPS_HIDDEN
)
315 strcat(flags
, "DPENUMGROUPS_HIDDEN,");
320 if (flagType
& FLAGS_DPPLAYER
)
322 if (dwFlags
& DPPLAYER_SERVERPLAYER
)
323 strcat(flags
, "DPPLAYER_SERVERPLAYER,");
324 if (dwFlags
& DPPLAYER_SPECTATOR
)
325 strcat(flags
, "DPPLAYER_SPECTATOR,");
326 if (dwFlags
& DPPLAYER_LOCAL
)
327 strcat(flags
, "DPPLAYER_LOCAL,");
328 if (dwFlags
& DPPLAYER_OWNER
)
329 strcat(flags
, "DPPLAYER_OWNER,");
334 if (flagType
& FLAGS_DPGROUP
)
336 if (dwFlags
& DPGROUP_STAGINGAREA
)
337 strcat(flags
, "DPGROUP_STAGINGAREA,");
338 if (dwFlags
& DPGROUP_LOCAL
)
339 strcat(flags
, "DPGROUP_LOCAL,");
340 if (dwFlags
& DPGROUP_HIDDEN
)
341 strcat(flags
, "DPGROUP_HIDDEN,");
346 if (flagType
& FLAGS_DPENUMSESSIONS
)
348 if (dwFlags
& DPENUMSESSIONS_AVAILABLE
)
349 strcat(flags
, "DPENUMSESSIONS_AVAILABLE,");
350 if (dwFlags
& DPENUMSESSIONS_ALL
)
351 strcat(flags
, "DPENUMSESSIONS_ALL,");
352 if (dwFlags
& DPENUMSESSIONS_ASYNC
)
353 strcat(flags
, "DPENUMSESSIONS_ASYNC,");
354 if (dwFlags
& DPENUMSESSIONS_STOPASYNC
)
355 strcat(flags
, "DPENUMSESSIONS_STOPASYNC,");
356 if (dwFlags
& DPENUMSESSIONS_PASSWORDREQUIRED
)
357 strcat(flags
, "DPENUMSESSIONS_PASSWORDREQUIRED,");
358 if (dwFlags
& DPENUMSESSIONS_RETURNSTATUS
)
359 strcat(flags
, "DPENUMSESSIONS_RETURNSTATUS,");
365 if (flagType
& FLAGS_DPGETCAPS
)
367 if (dwFlags
& DPGETCAPS_GUARANTEED
)
368 strcat(flags
, "DPGETCAPS_GUARANTEED,");
374 if (flagType
& FLAGS_DPGET
)
376 if (dwFlags
== DPGET_REMOTE
)
377 strcat(flags
, "DPGET_REMOTE,");
378 if (dwFlags
& DPGET_LOCAL
)
379 strcat(flags
, "DPGET_LOCAL,");
384 if (flagType
& FLAGS_DPRECEIVE
)
386 if (dwFlags
& DPRECEIVE_ALL
)
387 strcat(flags
, "DPRECEIVE_ALL,");
388 if (dwFlags
& DPRECEIVE_TOPLAYER
)
389 strcat(flags
, "DPRECEIVE_TOPLAYER,");
390 if (dwFlags
& DPRECEIVE_FROMPLAYER
)
391 strcat(flags
, "DPRECEIVE_FROMPLAYER,");
392 if (dwFlags
& DPRECEIVE_PEEK
)
393 strcat(flags
, "DPRECEIVE_PEEK,");
398 if (flagType
& FLAGS_DPSEND
)
400 /*if (dwFlags == DPSEND_NONGUARANTEED)
401 strcat(flags, "DPSEND_NONGUARANTEED,");*/
402 if (dwFlags
== DPSEND_MAX_PRIORITY
) /* = DPSEND_MAX_PRI */
404 strcat(flags
, "DPSEND_MAX_PRIORITY,");
408 if (dwFlags
& DPSEND_GUARANTEED
)
409 strcat(flags
, "DPSEND_GUARANTEED,");
410 if (dwFlags
& DPSEND_HIGHPRIORITY
)
411 strcat(flags
, "DPSEND_HIGHPRIORITY,");
412 if (dwFlags
& DPSEND_OPENSTREAM
)
413 strcat(flags
, "DPSEND_OPENSTREAM,");
414 if (dwFlags
& DPSEND_CLOSESTREAM
)
415 strcat(flags
, "DPSEND_CLOSESTREAM,");
416 if (dwFlags
& DPSEND_SIGNED
)
417 strcat(flags
, "DPSEND_SIGNED,");
418 if (dwFlags
& DPSEND_ENCRYPTED
)
419 strcat(flags
, "DPSEND_ENCRYPTED,");
420 if (dwFlags
& DPSEND_LOBBYSYSTEMMESSAGE
)
421 strcat(flags
, "DPSEND_LOBBYSYSTEMMESSAGE,");
422 if (dwFlags
& DPSEND_ASYNC
)
423 strcat(flags
, "DPSEND_ASYNC,");
424 if (dwFlags
& DPSEND_NOSENDCOMPLETEMSG
)
425 strcat(flags
, "DPSEND_NOSENDCOMPLETEMSG,");
435 if (flagType
& FLAGS_DPSET
)
437 if (dwFlags
== DPSET_REMOTE
)
438 strcat(flags
, "DPSET_REMOTE,");
439 if (dwFlags
& DPSET_LOCAL
)
440 strcat(flags
, "DPSET_LOCAL,");
441 if (dwFlags
& DPSET_GUARANTEED
)
442 strcat(flags
, "DPSET_GUARANTEED,");
445 /* GetMessageQueue */
447 if (flagType
& FLAGS_DPMESSAGEQUEUE
)
449 if (dwFlags
& DPMESSAGEQUEUE_SEND
)
450 strcat(flags
, "DPMESSAGEQUEUE_SEND,");
451 if (dwFlags
& DPMESSAGEQUEUE_RECEIVE
)
452 strcat(flags
, "DPMESSAGEQUEUE_RECEIVE,");
457 if (flagType
& FLAGS_DPCONNECT
)
459 if (dwFlags
& DPCONNECT_RETURNSTATUS
)
460 strcat(flags
, "DPCONNECT_RETURNSTATUS,");
465 if (flagType
& FLAGS_DPOPEN
)
467 if (dwFlags
& DPOPEN_JOIN
)
468 strcat(flags
, "DPOPEN_JOIN,");
469 if (dwFlags
& DPOPEN_CREATE
)
470 strcat(flags
, "DPOPEN_CREATE,");
471 if (dwFlags
& DPOPEN_RETURNSTATUS
)
472 strcat(flags
, "DPOPEN_RETURNSTATUS,");
477 if (flagType
& FLAGS_DPSESSION
)
479 if (dwFlags
& DPSESSION_NEWPLAYERSDISABLED
)
480 strcat(flags
, "DPSESSION_NEWPLAYERSDISABLED,");
481 if (dwFlags
& DPSESSION_MIGRATEHOST
)
482 strcat(flags
, "DPSESSION_MIGRATEHOST,");
483 if (dwFlags
& DPSESSION_NOMESSAGEID
)
484 strcat(flags
, "DPSESSION_NOMESSAGEID,");
485 if (dwFlags
& DPSESSION_JOINDISABLED
)
486 strcat(flags
, "DPSESSION_JOINDISABLED,");
487 if (dwFlags
& DPSESSION_KEEPALIVE
)
488 strcat(flags
, "DPSESSION_KEEPALIVE,");
489 if (dwFlags
& DPSESSION_NODATAMESSAGES
)
490 strcat(flags
, "DPSESSION_NODATAMESSAGES,");
491 if (dwFlags
& DPSESSION_SECURESERVER
)
492 strcat(flags
, "DPSESSION_SECURESERVER,");
493 if (dwFlags
& DPSESSION_PRIVATE
)
494 strcat(flags
, "DPSESSION_PRIVATE,");
495 if (dwFlags
& DPSESSION_PASSWORDREQUIRED
)
496 strcat(flags
, "DPSESSION_PASSWORDREQUIRED,");
497 if (dwFlags
& DPSESSION_MULTICASTSERVER
)
498 strcat(flags
, "DPSESSION_MULTICASTSERVER,");
499 if (dwFlags
& DPSESSION_CLIENTSERVER
)
500 strcat(flags
, "DPSESSION_CLIENTSERVER,");
502 if (dwFlags
& DPSESSION_DIRECTPLAYPROTOCOL
)
503 strcat(flags
, "DPSESSION_DIRECTPLAYPROTOCOL,");
504 if (dwFlags
& DPSESSION_NOPRESERVEORDER
)
505 strcat(flags
, "DPSESSION_NOPRESERVEORDER,");
506 if (dwFlags
& DPSESSION_OPTIMIZELATENCY
)
507 strcat(flags
, "DPSESSION_OPTIMIZELATENCY,");
513 if (flagType
& FLAGS_DPLCONNECTION
)
515 if (dwFlags
& DPLCONNECTION_CREATESESSION
)
516 strcat(flags
, "DPLCONNECTION_CREATESESSION,");
517 if (dwFlags
& DPLCONNECTION_JOINSESSION
)
518 strcat(flags
, "DPLCONNECTION_JOINSESSION,");
521 /* EnumSessionsCallback2 */
523 if (flagType
& FLAGS_DPESC
)
525 if (dwFlags
& DPESC_TIMEDOUT
)
526 strcat(flags
, "DPESC_TIMEDOUT,");
532 if (flagType
& FLAGS_DPCAPS
)
534 if (dwFlags
& DPCAPS_ISHOST
)
535 strcat(flags
, "DPCAPS_ISHOST,");
536 if (dwFlags
& DPCAPS_GROUPOPTIMIZED
)
537 strcat(flags
, "DPCAPS_GROUPOPTIMIZED,");
538 if (dwFlags
& DPCAPS_KEEPALIVEOPTIMIZED
)
539 strcat(flags
, "DPCAPS_KEEPALIVEOPTIMIZED,");
540 if (dwFlags
& DPCAPS_GUARANTEEDOPTIMIZED
)
541 strcat(flags
, "DPCAPS_GUARANTEEDOPTIMIZED,");
542 if (dwFlags
& DPCAPS_GUARANTEEDSUPPORTED
)
543 strcat(flags
, "DPCAPS_GUARANTEEDSUPPORTED,");
544 if (dwFlags
& DPCAPS_SIGNINGSUPPORTED
)
545 strcat(flags
, "DPCAPS_SIGNINGSUPPORTED,");
546 if (dwFlags
& DPCAPS_ENCRYPTIONSUPPORTED
)
547 strcat(flags
, "DPCAPS_ENCRYPTIONSUPPORTED,");
548 if (dwFlags
& DPCAPS_ASYNCCANCELSUPPORTED
)
549 strcat(flags
, "DPCAPS_ASYNCCANCELSUPPORTED,");
550 if (dwFlags
& DPCAPS_ASYNCCANCELALLSUPPORTED
)
551 strcat(flags
, "DPCAPS_ASYNCCANCELALLSUPPORTED,");
552 if (dwFlags
& DPCAPS_SENDTIMEOUTSUPPORTED
)
553 strcat(flags
, "DPCAPS_SENDTIMEOUTSUPPORTED,");
554 if (dwFlags
& DPCAPS_SENDPRIORITYSUPPORTED
)
555 strcat(flags
, "DPCAPS_SENDPRIORITYSUPPORTED,");
556 if (dwFlags
& DPCAPS_ASYNCSUPPORTED
)
557 strcat(flags
, "DPCAPS_ASYNCSUPPORTED,");
559 if (dwFlags
& DPPLAYERCAPS_LOCAL
)
560 strcat(flags
, "DPPLAYERCAPS_LOCAL,");
563 if ((strlen(flags
) == 0) && (dwFlags
!= 0))
564 strcpy(flags
, "UNKNOWN");
566 flags
[strlen(flags
)-1] = '\0';
571 static char dpid2char(DPID
* dpid
, DWORD dpidSize
, DPID idPlayer
)
574 if ( idPlayer
== DPID_SYSMSG
)
576 for (i
=0; i
<dpidSize
; i
++)
578 if ( idPlayer
== dpid
[i
] )
584 static void check_messages( LPDIRECTPLAY4 pDP
,
587 lpCallbackData callbackData
)
589 /* Retrieves all messages from the queue of pDP, performing tests
590 * to check if we are receiving what we expect.
592 * Information about the messages is stores in callbackData:
594 * callbackData->dwCounter1: Number of messages received.
595 * callbackData->szTrace1: Traces for sender and receiver.
596 * We store the position a dpid holds in the dpid array.
599 * trace string: "01,02,03,14"
600 * expanded: [ '01', '02', '03', '14' ]
602 * \ \ \ ) message 3: from 1 to 4
603 * \ \ ) message 2: from 0 to 3
604 * \ ) message 1: from 0 to 2
605 * ) message 0: from 0 to 1
608 * sender of message i = character in place 3*i of the array
609 * receiver of message i = character in place 3*i+1 of the array
611 * A sender value of 'S' means DPID_SYSMSG, this is, a system message.
613 * callbackData->szTrace2: Traces for message sizes.
618 DWORD dwDataSize
= 1024;
619 LPVOID lpData
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, dwDataSize
);
623 callbackData
->szTrace2
[0] = '\0';
626 while ( DP_OK
== (hr
= IDirectPlayX_Receive( pDP
, &idFrom
, &idTo
, 0,
627 lpData
, &dwDataSize
)) )
630 callbackData
->szTrace1
[ 3*i
] = dpid2char( dpid
, dpidSize
, idFrom
);
631 callbackData
->szTrace1
[ 3*i
+1 ] = dpid2char( dpid
, dpidSize
, idTo
);
632 callbackData
->szTrace1
[ 3*i
+2 ] = ',';
634 sprintf( temp
, "%d,", dwDataSize
);
635 strcat( callbackData
->szTrace2
, temp
);
641 checkHR( DPERR_NOMESSAGES
, hr
);
643 callbackData
->szTrace1
[ 3*i
] = '\0';
644 callbackData
->dwCounter1
= i
;
647 HeapFree( GetProcessHeap(), 0, lpData
);
650 static void init_TCPIP_provider( LPDIRECTPLAY4 pDP
,
651 LPCSTR strIPAddressString
,
655 DPCOMPOUNDADDRESSELEMENT addressElements
[3];
656 LPVOID pAddress
= NULL
;
657 DWORD dwAddressSize
= 0;
658 LPDIRECTPLAYLOBBY3 pDPL
;
661 CoCreateInstance( &CLSID_DirectPlayLobby
, NULL
, CLSCTX_ALL
,
662 &IID_IDirectPlayLobby3A
, (LPVOID
*) &pDPL
);
664 /* Service provider */
665 addressElements
[0].guidDataType
= DPAID_ServiceProvider
;
666 addressElements
[0].dwDataSize
= sizeof(GUID
);
667 addressElements
[0].lpData
= (LPVOID
) &DPSPGUID_TCPIP
;
669 /* IP address string */
670 addressElements
[1].guidDataType
= DPAID_INet
;
671 addressElements
[1].dwDataSize
= lstrlen(strIPAddressString
) + 1;
672 addressElements
[1].lpData
= (LPVOID
) strIPAddressString
;
674 /* Optional Port number */
677 addressElements
[2].guidDataType
= DPAID_INetPort
;
678 addressElements
[2].dwDataSize
= sizeof(WORD
);
679 addressElements
[2].lpData
= &port
;
683 hr
= IDirectPlayLobby_CreateCompoundAddress( pDPL
, addressElements
, 2,
684 NULL
, &dwAddressSize
);
685 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
687 if( hr
== DPERR_BUFFERTOOSMALL
)
689 pAddress
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, dwAddressSize
);
690 hr
= IDirectPlayLobby_CreateCompoundAddress( pDPL
, addressElements
, 2,
691 pAddress
, &dwAddressSize
);
692 checkHR( DP_OK
, hr
);
695 hr
= IDirectPlayX_InitializeConnection( pDP
, pAddress
, 0 );
696 todo_wine
checkHR( DP_OK
, hr
);
700 static BOOL CALLBACK
EnumSessions_cb_join( LPCDPSESSIONDESC2 lpThisSD
,
705 LPDIRECTPLAY4 pDP
= (LPDIRECTPLAY4
) lpContext
;
709 if (dwFlags
& DPESC_TIMEDOUT
)
714 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
715 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
716 dpsd
.guidApplication
= appGuid
;
717 dpsd
.guidInstance
= lpThisSD
->guidInstance
;
719 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
720 checkHR( DP_OK
, hr
);
726 /* DirectPlayCreate */
728 static void test_DirectPlayCreate(void)
734 /* TODO: Check how it behaves with pUnk!=NULL */
737 hr
= DirectPlayCreate( NULL
, NULL
, NULL
);
738 checkHR( DPERR_INVALIDPARAMS
, hr
);
739 hr
= DirectPlayCreate( (LPGUID
) &GUID_NULL
, NULL
, NULL
);
740 checkHR( DPERR_INVALIDPARAMS
, hr
);
741 hr
= DirectPlayCreate( (LPGUID
) &DPSPGUID_TCPIP
, NULL
, NULL
);
742 checkHR( DPERR_INVALIDPARAMS
, hr
);
744 /* pUnk==NULL, pDP!=NULL */
745 hr
= DirectPlayCreate( NULL
, &pDP
, NULL
);
746 checkHR( DPERR_INVALIDPARAMS
, hr
);
747 hr
= DirectPlayCreate( (LPGUID
) &GUID_NULL
, &pDP
, NULL
);
748 checkHR( DP_OK
, hr
);
750 IDirectPlayX_Release( pDP
);
751 hr
= DirectPlayCreate( (LPGUID
) &DPSPGUID_TCPIP
, &pDP
, NULL
);
752 todo_wine
checkHR( DP_OK
, hr
);
754 IDirectPlayX_Release( pDP
);
758 /* EnumConnections */
760 static BOOL CALLBACK
EnumAddress_cb2( REFGUID guidDataType
,
765 lpCallbackData callbackData
= (lpCallbackData
) lpContext
;
767 static REFGUID types
[] = { &DPAID_TotalSize
,
768 &DPAID_ServiceProvider
,
770 static DWORD sizes
[] = { 4, 16, 0 };
771 static REFGUID sps
[] = { &DPSPGUID_SERIAL
, &DPSPGUID_MODEM
,
772 &DPSPGUID_IPX
, &DPSPGUID_TCPIP
};
775 checkGuid( types
[ callbackData
->dwCounter2
], guidDataType
);
776 check( sizes
[ callbackData
->dwCounter2
], dwDataSize
);
778 if ( IsEqualGUID( types
[0], guidDataType
) )
780 todo_wine
check( 80, *((LPDWORD
) lpData
) );
782 else if ( IsEqualGUID( types
[1], guidDataType
) )
784 todo_wine
checkGuid( sps
[ callbackData
->dwCounter1
], (LPGUID
) lpData
);
787 callbackData
->dwCounter2
++;
792 static BOOL CALLBACK
EnumConnections_cb( LPCGUID lpguidSP
,
794 DWORD dwConnectionSize
,
800 lpCallbackData callbackData
= (lpCallbackData
) lpContext
;
801 LPDIRECTPLAYLOBBY pDPL
;
804 if (!callbackData
->dwFlags
)
806 callbackData
->dwFlags
= DPCONNECTION_DIRECTPLAY
;
809 checkFlags( callbackData
->dwFlags
, dwFlags
, FLAGS_DPCONNECTION
);
811 /* Get info from lpConnection */
812 CoCreateInstance( &CLSID_DirectPlayLobby
, NULL
, CLSCTX_ALL
,
813 &IID_IDirectPlayLobby3A
, (LPVOID
*) &pDPL
);
815 callbackData
->dwCounter2
= 0;
816 IDirectPlayLobby_EnumAddress( pDPL
, EnumAddress_cb2
,
817 (LPCVOID
) lpConnection
,
819 (LPVOID
) callbackData
);
820 todo_wine
check( 3, callbackData
->dwCounter2
);
822 callbackData
->dwCounter1
++;
827 static void test_EnumConnections(void)
831 CallbackData callbackData
;
835 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
836 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
839 callbackData
.dwCounter1
= 0;
840 callbackData
.dwFlags
= 0;
841 hr
= IDirectPlayX_EnumConnections( pDP
, &appGuid
, EnumConnections_cb
,
842 (LPVOID
) &callbackData
,
843 callbackData
.dwFlags
);
844 checkHR( DP_OK
, hr
);
845 check( 4, callbackData
.dwCounter1
);
847 callbackData
.dwCounter1
= 0;
848 callbackData
.dwFlags
= 0;
849 hr
= IDirectPlayX_EnumConnections( pDP
, NULL
, EnumConnections_cb
,
850 (LPVOID
) &callbackData
,
851 callbackData
.dwFlags
);
852 checkHR( DP_OK
, hr
);
853 check( 4, callbackData
.dwCounter1
);
855 callbackData
.dwCounter1
= 0;
856 callbackData
.dwFlags
= 0;
857 hr
= IDirectPlayX_EnumConnections( pDP
, &appGuid
, NULL
,
858 (LPVOID
) &callbackData
,
859 callbackData
.dwFlags
);
860 checkHR( DPERR_INVALIDPARAMS
, hr
);
861 check( 0, callbackData
.dwCounter1
);
865 callbackData
.dwCounter1
= 0;
866 callbackData
.dwFlags
= DPCONNECTION_DIRECTPLAY
;
867 hr
= IDirectPlayX_EnumConnections( pDP
, &appGuid
, EnumConnections_cb
,
868 (LPVOID
) &callbackData
,
869 callbackData
.dwFlags
);
870 checkHR( DP_OK
, hr
);
871 check( 4, callbackData
.dwCounter1
);
873 callbackData
.dwCounter1
= 0;
874 callbackData
.dwFlags
= DPCONNECTION_DIRECTPLAYLOBBY
;
875 hr
= IDirectPlayX_EnumConnections( pDP
, &appGuid
, EnumConnections_cb
,
876 (LPVOID
) &callbackData
,
877 callbackData
.dwFlags
);
878 checkHR( DP_OK
, hr
);
879 check( 0, callbackData
.dwCounter1
);
881 callbackData
.dwCounter1
= 0;
882 callbackData
.dwFlags
= ( DPCONNECTION_DIRECTPLAY
|
883 DPCONNECTION_DIRECTPLAYLOBBY
);
884 hr
= IDirectPlayX_EnumConnections( pDP
, &appGuid
, EnumConnections_cb
,
885 (LPVOID
) &callbackData
,
886 callbackData
.dwFlags
);
887 checkHR( DP_OK
, hr
);
888 check( 4, callbackData
.dwCounter1
);
890 callbackData
.dwCounter1
= 0;
891 callbackData
.dwFlags
= ~( DPCONNECTION_DIRECTPLAY
|
892 DPCONNECTION_DIRECTPLAYLOBBY
);
893 hr
= IDirectPlayX_EnumConnections( pDP
, &appGuid
, EnumConnections_cb
,
894 (LPVOID
) &callbackData
,
895 callbackData
.dwFlags
);
896 checkHR( DPERR_INVALIDFLAGS
, hr
);
897 check( 0, callbackData
.dwCounter1
);
900 IDirectPlayX_Release( pDP
);
903 /* InitializeConnection */
905 static BOOL CALLBACK
EnumConnections_cb2( LPCGUID lpguidSP
,
907 DWORD dwConnectionSize
,
912 LPDIRECTPLAY4 pDP
= (LPDIRECTPLAY4
) lpContext
;
915 /* Incorrect parameters */
916 hr
= IDirectPlayX_InitializeConnection( pDP
, NULL
, 1 );
917 checkHR( DPERR_INVALIDPARAMS
, hr
);
918 hr
= IDirectPlayX_InitializeConnection( pDP
, lpConnection
, 1 );
919 checkHR( DPERR_INVALIDFLAGS
, hr
);
922 We're only interested in ensuring that the TCP/IP provider works */
924 if( IsEqualGUID(lpguidSP
, &DPSPGUID_TCPIP
) )
926 hr
= IDirectPlayX_InitializeConnection( pDP
, lpConnection
, 0 );
927 todo_wine
checkHR( DP_OK
, hr
);
928 hr
= IDirectPlayX_InitializeConnection( pDP
, lpConnection
, 0 );
929 todo_wine
checkHR( DPERR_ALREADYINITIALIZED
, hr
);
935 static void test_InitializeConnection(void)
940 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
941 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
943 IDirectPlayX_EnumConnections( pDP
, &appGuid
, EnumConnections_cb2
,
946 IDirectPlayX_Release( pDP
);
951 static void test_GetCaps(void)
960 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
961 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
962 ZeroMemory( &dpcaps
, sizeof(DPCAPS
) );
964 /* Service provider not ininitialized */
965 hr
= IDirectPlayX_GetCaps( pDP
, &dpcaps
, 0 );
966 checkHR( DPERR_UNINITIALIZED
, hr
);
968 init_TCPIP_provider( pDP
, "127.0.0.1", 0 );
970 /* dpcaps not ininitialized */
971 hr
= IDirectPlayX_GetCaps( pDP
, &dpcaps
, 0 );
972 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
974 dpcaps
.dwSize
= sizeof(DPCAPS
);
977 dwFlags
<=DPGETCAPS_GUARANTEED
;
978 dwFlags
+=DPGETCAPS_GUARANTEED
)
981 hr
= IDirectPlayX_GetCaps( pDP
, &dpcaps
, dwFlags
);
982 todo_wine
checkHR( DP_OK
, hr
);
987 check( sizeof(DPCAPS
), dpcaps
.dwSize
);
988 check( DPCAPS_ASYNCSUPPORTED
|
989 DPCAPS_GUARANTEEDOPTIMIZED
|
990 DPCAPS_GUARANTEEDSUPPORTED
,
992 check( 0, dpcaps
.dwMaxQueueSize
);
993 check( 0, dpcaps
.dwHundredBaud
);
994 check( 500, dpcaps
.dwLatency
);
995 check( 65536, dpcaps
.dwMaxLocalPlayers
);
996 check( 20, dpcaps
.dwHeaderLength
);
997 check( 5000, dpcaps
.dwTimeout
);
1002 check( 65479, dpcaps
.dwMaxBufferSize
);
1003 check( 65536, dpcaps
.dwMaxPlayers
);
1005 case DPGETCAPS_GUARANTEED
:
1006 check( 1048547, dpcaps
.dwMaxBufferSize
);
1007 check( 64, dpcaps
.dwMaxPlayers
);
1014 IDirectPlayX_Release( pDP
);
1019 static BOOL CALLBACK
EnumSessions_cb2( LPCDPSESSIONDESC2 lpThisSD
,
1020 LPDWORD lpdwTimeOut
,
1024 LPDIRECTPLAY4 pDP
= (LPDIRECTPLAY4
) lpContext
;
1025 DPSESSIONDESC2 dpsd
;
1028 if (dwFlags
& DPESC_TIMEDOUT
)
1032 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
1033 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
1034 dpsd
.guidApplication
= appGuid
;
1035 dpsd
.guidInstance
= lpThisSD
->guidInstance
;
1037 if ( lpThisSD
->dwFlags
& DPSESSION_PASSWORDREQUIRED
)
1039 /* Incorrect password */
1040 U2(dpsd
).lpszPasswordA
= (LPSTR
) "sonic boom";
1041 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1042 checkHR( DPERR_INVALIDPASSWORD
, hr
);
1044 /* Correct password */
1045 U2(dpsd
).lpszPasswordA
= (LPSTR
) "hadouken";
1046 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1047 checkHR( DP_OK
, hr
);
1051 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1052 checkHR( DP_OK
, hr
);
1055 hr
= IDirectPlayX_Close( pDP
);
1056 checkHR( DP_OK
, hr
);
1061 static void test_Open(void)
1064 LPDIRECTPLAY4 pDP
, pDP_server
;
1065 DPSESSIONDESC2 dpsd
, dpsd_server
;
1069 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1070 &IID_IDirectPlay4A
, (LPVOID
*) &pDP_server
);
1071 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1072 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
1073 ZeroMemory( &dpsd_server
, sizeof(DPSESSIONDESC2
) );
1074 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
1076 /* Service provider not initialized */
1077 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1078 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1080 init_TCPIP_provider( pDP_server
, "127.0.0.1", 0 );
1081 init_TCPIP_provider( pDP
, "127.0.0.1", 0 );
1083 /* Uninitialized dpsd */
1084 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1085 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1088 dpsd_server
.dwSize
= sizeof(DPSESSIONDESC2
);
1089 dpsd_server
.guidApplication
= appGuid
;
1090 dpsd_server
.dwMaxPlayers
= 10;
1093 /* Regular operation */
1094 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1095 todo_wine
checkHR( DP_OK
, hr
);
1098 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1099 todo_wine
checkHR( DPERR_ALREADYINITIALIZED
, hr
);
1102 IDirectPlayX_Close( pDP_server
);
1104 dpsd_server
.dwFlags
= DPSESSION_CLIENTSERVER
| DPSESSION_MIGRATEHOST
;
1105 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1106 todo_wine
checkHR( DPERR_INVALIDFLAGS
, hr
);
1108 dpsd_server
.dwFlags
= DPSESSION_MULTICASTSERVER
| DPSESSION_MIGRATEHOST
;
1109 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1110 todo_wine
checkHR( DPERR_INVALIDFLAGS
, hr
);
1112 dpsd_server
.dwFlags
= DPSESSION_SECURESERVER
| DPSESSION_MIGRATEHOST
;
1113 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1114 todo_wine
checkHR( DPERR_INVALIDFLAGS
, hr
);
1117 /* Joining sessions */
1118 /* - Checking how strict dplay is with sizes */
1120 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1121 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1123 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
)-1;
1124 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1125 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1127 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
)+1;
1128 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1129 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1131 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
1132 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1133 todo_wine
checkHR( DPERR_NOSESSIONS
, hr
); /* Only checks for size, not guids */
1136 dpsd
.guidApplication
= appGuid
;
1137 dpsd
.guidInstance
= appGuid
;
1140 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1141 todo_wine
checkHR( DPERR_NOSESSIONS
, hr
);
1142 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
| DPOPEN_CREATE
);
1143 todo_wine
checkHR( DPERR_NOSESSIONS
, hr
); /* Second flag is ignored */
1145 dpsd_server
.dwFlags
= 0;
1148 /* Join to normal session */
1149 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1150 todo_wine
checkHR( DP_OK
, hr
);
1152 IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb2
, pDP
, 0 );
1155 /* Already initialized session */
1156 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1157 todo_wine
checkHR( DPERR_ALREADYINITIALIZED
, hr
);
1160 /* Checking which is the error checking order */
1161 dpsd_server
.dwSize
= 0;
1163 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1164 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1166 dpsd_server
.dwSize
= sizeof(DPSESSIONDESC2
);
1169 /* Join to protected session */
1170 IDirectPlayX_Close( pDP_server
);
1171 U2(dpsd_server
).lpszPasswordA
= (LPSTR
) "hadouken";
1172 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1173 todo_wine
checkHR( DP_OK
, hr
);
1175 IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb2
,
1176 pDP
, DPENUMSESSIONS_PASSWORDREQUIRED
);
1179 IDirectPlayX_Release( pDP
);
1180 IDirectPlayX_Release( pDP_server
);
1186 static BOOL CALLBACK
EnumSessions_cb( LPCDPSESSIONDESC2 lpThisSD
,
1187 LPDWORD lpdwTimeOut
,
1191 lpCallbackData callbackData
= (lpCallbackData
) lpContext
;
1192 callbackData
->dwCounter1
++;
1194 if ( dwFlags
& DPESC_TIMEDOUT
)
1196 check( TRUE
, lpThisSD
== NULL
);
1199 check( FALSE
, lpThisSD
== NULL
);
1202 if ( U2(*lpThisSD
).lpszPasswordA
!= NULL
)
1204 check( TRUE
, (lpThisSD
->dwFlags
& DPSESSION_PASSWORDREQUIRED
) != 0 );
1207 if ( lpThisSD
->dwFlags
& DPSESSION_NEWPLAYERSDISABLED
)
1209 check( 0, lpThisSD
->dwCurrentPlayers
);
1212 check( sizeof(*lpThisSD
), lpThisSD
->dwSize
);
1213 checkLP( NULL
, U2(*lpThisSD
).lpszPasswordA
);
1218 static LPDIRECTPLAY4
create_session(DPSESSIONDESC2
*lpdpsd
)
1228 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1229 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
1231 init_TCPIP_provider( pDP
, "127.0.0.1", 0 );
1233 hr
= IDirectPlayX_Open( pDP
, lpdpsd
, DPOPEN_CREATE
);
1234 todo_wine
checkHR( DP_OK
, hr
);
1236 if ( ! (lpdpsd
->dwFlags
& DPSESSION_NEWPLAYERSDISABLED
) )
1238 ZeroMemory( &name
, sizeof(DPNAME
) );
1239 name
.dwSize
= sizeof(DPNAME
);
1240 U1(name
).lpszShortNameA
= (LPSTR
) "bofh";
1242 hr
= IDirectPlayX_CreatePlayer( pDP
, &dpid
, &name
, NULL
, NULL
,
1243 0, DPPLAYER_SERVERPLAYER
);
1244 todo_wine
checkHR( DP_OK
, hr
);
1251 static void test_EnumSessions(void)
1254 #define N_SESSIONS 6
1256 LPDIRECTPLAY4 pDP
, pDPserver
[N_SESSIONS
];
1257 DPSESSIONDESC2 dpsd
, dpsd_server
[N_SESSIONS
];
1258 CallbackData callbackData
;
1263 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1264 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
1265 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
1266 callbackData
.dwCounter1
= -1; /* So that after a call to EnumSessions
1267 we get the exact number of sessions */
1268 callbackData
.dwFlags
= 0;
1271 /* Service provider not initialized */
1272 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1273 (LPVOID
) &callbackData
, 0 );
1274 checkHR( DPERR_UNINITIALIZED
, hr
);
1277 init_TCPIP_provider( pDP
, "127.0.0.1", 0 );
1280 /* Session with no size */
1281 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1282 (LPVOID
) &callbackData
, 0 );
1283 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1285 if ( hr
== DPERR_UNINITIALIZED
)
1287 skip( "EnumSessions not implemented\n" );
1291 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
1295 callbackData
.dwCounter1
= -1;
1296 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1297 (LPVOID
) &callbackData
, 0 );
1298 checkHR( DP_OK
, hr
);
1299 check( 0, callbackData
.dwCounter1
);
1302 dpsd
.guidApplication
= appGuid
;
1304 /* Set up sessions */
1305 for (i
=0; i
<N_SESSIONS
; i
++)
1307 memcpy( &dpsd_server
[i
], &dpsd
, sizeof(DPSESSIONDESC2
) );
1310 U1(dpsd_server
[0]).lpszSessionNameA
= (LPSTR
) "normal";
1311 dpsd_server
[0].dwFlags
= ( DPSESSION_CLIENTSERVER
|
1312 DPSESSION_DIRECTPLAYPROTOCOL
);
1313 dpsd_server
[0].dwMaxPlayers
= 10;
1315 U1(dpsd_server
[1]).lpszSessionNameA
= (LPSTR
) "full";
1316 dpsd_server
[1].dwFlags
= ( DPSESSION_CLIENTSERVER
|
1317 DPSESSION_DIRECTPLAYPROTOCOL
);
1318 dpsd_server
[1].dwMaxPlayers
= 1;
1320 U1(dpsd_server
[2]).lpszSessionNameA
= (LPSTR
) "no new";
1321 dpsd_server
[2].dwFlags
= ( DPSESSION_CLIENTSERVER
|
1322 DPSESSION_DIRECTPLAYPROTOCOL
|
1323 DPSESSION_NEWPLAYERSDISABLED
);
1324 dpsd_server
[2].dwMaxPlayers
= 10;
1326 U1(dpsd_server
[3]).lpszSessionNameA
= (LPSTR
) "no join";
1327 dpsd_server
[3].dwFlags
= ( DPSESSION_CLIENTSERVER
|
1328 DPSESSION_DIRECTPLAYPROTOCOL
|
1329 DPSESSION_JOINDISABLED
);
1330 dpsd_server
[3].dwMaxPlayers
= 10;
1332 U1(dpsd_server
[4]).lpszSessionNameA
= (LPSTR
) "private";
1333 dpsd_server
[4].dwFlags
= ( DPSESSION_CLIENTSERVER
|
1334 DPSESSION_DIRECTPLAYPROTOCOL
|
1335 DPSESSION_PRIVATE
);
1336 dpsd_server
[4].dwMaxPlayers
= 10;
1337 U2(dpsd_server
[4]).lpszPasswordA
= (LPSTR
) "password";
1339 U1(dpsd_server
[5]).lpszSessionNameA
= (LPSTR
) "protected";
1340 dpsd_server
[5].dwFlags
= ( DPSESSION_CLIENTSERVER
|
1341 DPSESSION_DIRECTPLAYPROTOCOL
|
1342 DPSESSION_PASSWORDREQUIRED
);
1343 dpsd_server
[5].dwMaxPlayers
= 10;
1344 U2(dpsd_server
[5]).lpszPasswordA
= (LPSTR
) "password";
1347 for (i
=0; i
<N_SESSIONS
; i
++)
1349 pDPserver
[i
] = create_session( &dpsd_server
[i
] );
1353 /* Invalid params */
1354 callbackData
.dwCounter1
= -1;
1355 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1356 (LPVOID
) &callbackData
, -1 );
1357 checkHR( DPERR_INVALIDPARAMS
, hr
);
1359 hr
= IDirectPlayX_EnumSessions( pDP
, NULL
, 0, EnumSessions_cb
,
1360 (LPVOID
) &callbackData
, 0 );
1361 checkHR( DPERR_INVALIDPARAMS
, hr
);
1363 check( -1, callbackData
.dwCounter1
);
1367 callbackData
.dwFlags
= DPENUMSESSIONS_ALL
; /* Doesn't list private,
1369 callbackData
.dwCounter1
= -1;
1370 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1371 (LPVOID
) &callbackData
,
1372 callbackData
.dwFlags
);
1373 check( N_SESSIONS
-2, callbackData
.dwCounter1
);
1375 /* Doesn't list private */
1376 callbackData
.dwFlags
= ( DPENUMSESSIONS_ALL
|
1377 DPENUMSESSIONS_PASSWORDREQUIRED
);
1378 callbackData
.dwCounter1
= -1;
1379 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1380 (LPVOID
) &callbackData
,
1381 callbackData
.dwFlags
);
1382 check( N_SESSIONS
-1, callbackData
.dwCounter1
);
1384 /* Doesn't list full, no new, no join, private, protected */
1385 callbackData
.dwFlags
= DPENUMSESSIONS_AVAILABLE
;
1386 callbackData
.dwCounter1
= -1;
1387 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1388 (LPVOID
) &callbackData
,
1389 callbackData
.dwFlags
);
1390 check( N_SESSIONS
-5, callbackData
.dwCounter1
);
1392 /* Like with DPENUMSESSIONS_AVAILABLE */
1393 callbackData
.dwFlags
= 0;
1394 callbackData
.dwCounter1
= -1;
1395 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1396 (LPVOID
) &callbackData
,
1397 callbackData
.dwFlags
);
1398 check( N_SESSIONS
-5, callbackData
.dwCounter1
);
1400 /* Doesn't list full, no new, no join, private */
1401 callbackData
.dwFlags
= DPENUMSESSIONS_PASSWORDREQUIRED
;
1402 callbackData
.dwCounter1
= -1;
1403 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1404 (LPVOID
) &callbackData
,
1405 callbackData
.dwFlags
);
1406 check( N_SESSIONS
-4, callbackData
.dwCounter1
);
1409 /* Async enumeration */
1410 callbackData
.dwFlags
= DPENUMSESSIONS_ASYNC
;
1411 callbackData
.dwCounter1
= -1;
1412 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1413 (LPVOID
) &callbackData
,
1414 callbackData
.dwFlags
);
1415 check( N_SESSIONS
-4, callbackData
.dwCounter1
); /* Read cache of last
1418 callbackData
.dwFlags
= DPENUMSESSIONS_STOPASYNC
;
1419 callbackData
.dwCounter1
= -1;
1420 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1421 (LPVOID
) &callbackData
,
1422 callbackData
.dwFlags
);
1423 check( 0, callbackData
.dwCounter1
); /* Stop enumeration */
1425 callbackData
.dwFlags
= DPENUMSESSIONS_ASYNC
;
1426 callbackData
.dwCounter1
= -1;
1427 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1428 (LPVOID
) &callbackData
,
1429 callbackData
.dwFlags
);
1430 check( 0, callbackData
.dwCounter1
); /* Start enumeration */
1432 Sleep(500); /* Give time to fill the cache */
1434 callbackData
.dwFlags
= DPENUMSESSIONS_ASYNC
;
1435 callbackData
.dwCounter1
= -1;
1436 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1437 (LPVOID
) &callbackData
,
1438 callbackData
.dwFlags
);
1439 check( N_SESSIONS
-5, callbackData
.dwCounter1
); /* Retrieve results */
1441 callbackData
.dwFlags
= DPENUMSESSIONS_STOPASYNC
;
1442 callbackData
.dwCounter1
= -1;
1443 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1444 (LPVOID
) &callbackData
,
1445 callbackData
.dwFlags
);
1446 check( 0, callbackData
.dwCounter1
); /* Stop enumeration */
1449 /* Specific tests for passworded sessions */
1451 for (i
=0; i
<N_SESSIONS
; i
++)
1453 IDirectPlayX_Release( pDPserver
[i
] );
1456 /* - Only session password set */
1459 U2(dpsd_server
[i
]).lpszPasswordA
= (LPSTR
) "password";
1460 dpsd_server
[i
].dwFlags
= 0;
1461 pDPserver
[i
] = create_session( &dpsd_server
[i
] );
1464 callbackData
.dwFlags
= 0;
1465 callbackData
.dwCounter1
= -1;
1466 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1467 (LPVOID
) &callbackData
,
1468 callbackData
.dwFlags
);
1469 check( 0, callbackData
.dwCounter1
);
1471 callbackData
.dwFlags
= DPENUMSESSIONS_PASSWORDREQUIRED
;
1472 callbackData
.dwCounter1
= -1;
1473 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1474 (LPVOID
) &callbackData
,
1475 callbackData
.dwFlags
);
1476 check( 2, callbackData
.dwCounter1
); /* Both sessions automatically
1477 set DPSESSION_PASSWORDREQUIRED */
1479 /* - Only session flag set */
1480 for (i
=4; i
<=5; i
++)
1482 IDirectPlayX_Release( pDPserver
[i
] );
1483 U2(dpsd_server
[i
]).lpszPasswordA
= NULL
;
1485 dpsd_server
[4].dwFlags
= DPSESSION_PRIVATE
;
1486 dpsd_server
[5].dwFlags
= DPSESSION_PASSWORDREQUIRED
;
1487 for (i
=4; i
<=5; i
++)
1489 pDPserver
[i
] = create_session( &dpsd_server
[i
] );
1492 callbackData
.dwFlags
= 0;
1493 callbackData
.dwCounter1
= -1;
1494 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1495 (LPVOID
) &callbackData
,
1496 callbackData
.dwFlags
);
1497 check( 2, callbackData
.dwCounter1
); /* Without password,
1498 the flag is ignored */
1500 /* - Both session flag and password set */
1501 for (i
=4; i
<=5; i
++)
1503 IDirectPlayX_Release( pDPserver
[i
] );
1504 U2(dpsd_server
[i
]).lpszPasswordA
= (LPSTR
) "password";
1506 dpsd_server
[4].dwFlags
= DPSESSION_PRIVATE
;
1507 dpsd_server
[5].dwFlags
= DPSESSION_PASSWORDREQUIRED
;
1508 for (i
=4; i
<=5; i
++)
1510 pDPserver
[i
] = create_session( &dpsd_server
[i
] );
1513 /* - Listing without password */
1514 callbackData
.dwCounter1
= -1;
1515 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1516 (LPVOID
) &callbackData
,
1517 callbackData
.dwFlags
);
1518 check( 0, callbackData
.dwCounter1
);
1520 callbackData
.dwFlags
= DPENUMSESSIONS_PASSWORDREQUIRED
;
1521 callbackData
.dwCounter1
= -1;
1522 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1523 (LPVOID
) &callbackData
,
1524 callbackData
.dwFlags
);
1525 check( 1, callbackData
.dwCounter1
);
1527 /* - Listing with incorrect password */
1528 U2(dpsd
).lpszPasswordA
= (LPSTR
) "bad_password";
1529 callbackData
.dwFlags
= 0;
1530 callbackData
.dwCounter1
= -1;
1531 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1532 (LPVOID
) &callbackData
,
1533 callbackData
.dwFlags
);
1534 check( 0, callbackData
.dwCounter1
);
1536 callbackData
.dwFlags
= DPENUMSESSIONS_PASSWORDREQUIRED
;
1537 callbackData
.dwCounter1
= -1;
1538 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1539 (LPVOID
) &callbackData
,
1540 callbackData
.dwFlags
);
1541 check( 1, callbackData
.dwCounter1
);
1543 /* - Listing with correct password */
1544 U2(dpsd
).lpszPasswordA
= (LPSTR
) "password";
1545 callbackData
.dwCounter1
= -1;
1546 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1547 (LPVOID
) &callbackData
,
1548 callbackData
.dwFlags
);
1549 check( 2, callbackData
.dwCounter1
);
1552 U2(dpsd
).lpszPasswordA
= NULL
;
1553 callbackData
.dwFlags
= DPENUMSESSIONS_ASYNC
;
1554 callbackData
.dwCounter1
= -1;
1555 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1556 (LPVOID
) &callbackData
,
1557 callbackData
.dwFlags
);
1558 check( 2, callbackData
.dwCounter1
); /* Read cache of last sync enumeration,
1559 even private sessions */
1564 /* - Creating two servers with different application GUIDs */
1565 for (i
=4; i
<=5; i
++)
1567 IDirectPlayX_Release( pDPserver
[i
] );
1568 dpsd_server
[i
].dwFlags
= ( DPSESSION_CLIENTSERVER
|
1569 DPSESSION_DIRECTPLAYPROTOCOL
);
1570 U2(dpsd_server
[i
]).lpszPasswordA
= NULL
;
1571 dpsd_server
[i
].dwMaxPlayers
= 10;
1573 U1(dpsd_server
[4]).lpszSessionNameA
= (LPSTR
) "normal1";
1574 dpsd_server
[4].guidApplication
= appGuid
;
1575 U1(dpsd_server
[5]).lpszSessionNameA
= (LPSTR
) "normal2";
1576 dpsd_server
[5].guidApplication
= appGuid2
;
1577 for (i
=4; i
<=5; i
++)
1579 pDPserver
[i
] = create_session( &dpsd_server
[i
] );
1582 callbackData
.dwFlags
= 0;
1584 dpsd
.guidApplication
= appGuid2
;
1585 callbackData
.dwCounter1
= -1;
1586 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1587 (LPVOID
) &callbackData
,
1588 callbackData
.dwFlags
);
1589 check( 1, callbackData
.dwCounter1
); /* Only one of the sessions */
1591 dpsd
.guidApplication
= appGuid
;
1592 callbackData
.dwCounter1
= -1;
1593 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1594 (LPVOID
) &callbackData
,
1595 callbackData
.dwFlags
);
1596 check( 1, callbackData
.dwCounter1
); /* The other session */
1598 For some reason, if we enum 1st with appGuid and 2nd with appGuid2,
1599 in the second enum we get the 2 sessions. Dplay fault? Elves? */
1601 dpsd
.guidApplication
= GUID_NULL
;
1602 callbackData
.dwCounter1
= -1;
1603 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1604 (LPVOID
) &callbackData
,
1605 callbackData
.dwFlags
);
1606 check( 2, callbackData
.dwCounter1
); /* Both sessions */
1608 for (i
=4; i
<=5; i
++)
1610 IDirectPlayX_Release( pDPserver
[i
] );
1612 IDirectPlayX_Release( pDP
);
1619 static void test_SessionDesc(void)
1622 LPDIRECTPLAY4 pDP
[2];
1623 DPSESSIONDESC2 dpsd
;
1624 LPDPSESSIONDESC2 lpData
[2];
1630 CallbackData callbackData
;
1635 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1636 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
1638 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
1640 /* Service provider not initialized */
1641 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], NULL
, 0 );
1642 checkHR( DPERR_UNINITIALIZED
, hr
);
1644 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], NULL
, NULL
);
1645 checkHR( DPERR_UNINITIALIZED
, hr
);
1648 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
1649 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
1652 /* No sessions open */
1653 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], NULL
, 0 );
1654 todo_wine
checkHR( DPERR_NOSESSIONS
, hr
);
1656 if ( hr
== DPERR_UNINITIALIZED
)
1658 skip("Get/SetSessionDesc not implemented\n");
1662 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], NULL
, NULL
);
1663 checkHR( DPERR_NOSESSIONS
, hr
);
1666 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
1667 dpsd
.guidApplication
= appGuid
;
1668 dpsd
.dwMaxPlayers
= 10;
1672 IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
1674 IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
1675 (LPVOID
)pDP
[1], 0 );
1679 /* Players, only to receive messages */
1680 IDirectPlayX_CreatePlayer( pDP
[i
], &dpid
[i
], NULL
, NULL
, NULL
, 0, 0 );
1682 lpData
[i
] = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, 1024 );
1684 lpDataMsg
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, 1024 );
1687 /* Incorrect parameters */
1688 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], NULL
, 0 );
1689 checkHR( DPERR_INVALIDPARAMS
, hr
);
1690 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], NULL
, NULL
);
1691 checkHR( DPERR_INVALIDPARAM
, hr
);
1692 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], lpData
[0], NULL
);
1693 checkHR( DPERR_INVALIDPARAM
, hr
);
1695 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], lpData
[0], &dwDataSize
);
1696 checkHR( DPERR_INVALIDPARAMS
, hr
);
1697 check( -1, dwDataSize
);
1699 /* Get: Insufficient buffer size */
1701 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], lpData
[0], &dwDataSize
);
1702 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
1703 check( dpsd
.dwSize
, dwDataSize
);
1705 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], lpData
[0], &dwDataSize
);
1706 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
1707 check( dpsd
.dwSize
, dwDataSize
);
1709 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], NULL
, &dwDataSize
);
1710 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
1711 check( dpsd
.dwSize
, dwDataSize
);
1713 /* Get: Regular operation
1714 * i=0: Local session
1715 * i=1: Remote session */
1718 hr
= IDirectPlayX_GetSessionDesc( pDP
[i
], lpData
[i
], &dwDataSize
);
1719 checkHR( DP_OK
, hr
);
1720 check( sizeof(DPSESSIONDESC2
), dwDataSize
);
1721 check( sizeof(DPSESSIONDESC2
), lpData
[i
]->dwSize
);
1722 checkGuid( &appGuid
, &lpData
[i
]->guidApplication
);
1723 check( dpsd
.dwMaxPlayers
, lpData
[i
]->dwMaxPlayers
);
1726 checkGuid( &lpData
[0]->guidInstance
, &lpData
[1]->guidInstance
);
1728 /* Set: Regular operation */
1729 U1(dpsd
).lpszSessionNameA
= (LPSTR
) "Wahaa";
1730 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1731 checkHR( DP_OK
, hr
);
1734 hr
= IDirectPlayX_GetSessionDesc( pDP
[1], lpData
[1], &dwDataSize
);
1735 checkHR( DP_OK
, hr
);
1736 checkStr( U1(dpsd
).lpszSessionNameA
, U1(*lpData
[1]).lpszSessionNameA
);
1739 /* Set: Failing to modify a remote session */
1740 hr
= IDirectPlayX_SetSessionDesc( pDP
[1], &dpsd
, 0 );
1741 checkHR( DPERR_ACCESSDENIED
, hr
);
1743 /* Trying to change inmutable properties */
1745 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1746 checkHR( DP_OK
, hr
);
1747 dpsd
.dwFlags
= DPSESSION_SECURESERVER
;
1748 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1749 checkHR( DPERR_INVALIDPARAMS
, hr
);
1751 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1752 checkHR( DP_OK
, hr
);
1755 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1756 checkHR( DPERR_INVALIDPARAMS
, hr
);
1757 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
1758 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1759 checkHR( DP_OK
, hr
);
1761 /* Changing the GUIDs and size is ignored */
1762 dpsd
.guidApplication
= appGuid2
;
1763 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1764 checkHR( DP_OK
, hr
);
1765 dpsd
.guidInstance
= appGuid2
;
1766 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1767 checkHR( DP_OK
, hr
);
1769 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], lpData
[0], &dwDataSize
);
1770 checkHR( DP_OK
, hr
);
1771 checkGuid( &appGuid
, &lpData
[0]->guidApplication
);
1772 checkGuid( &lpData
[1]->guidInstance
, &lpData
[0]->guidInstance
);
1773 check( sizeof(DPSESSIONDESC2
), lpData
[0]->dwSize
);
1776 /* Checking system messages */
1777 check_messages( pDP
[0], dpid
, 2, &callbackData
);
1778 checkStr( "S0,S0,S0,S0,S0,S0,S0,", callbackData
.szTrace1
);
1779 checkStr( "48,90,90,90,90,90,90,", callbackData
.szTrace2
);
1780 check_messages( pDP
[1], dpid
, 2, &callbackData
);
1781 checkStr( "S1,S1,S1,S1,S1,S1,", callbackData
.szTrace1
);
1782 checkStr( "90,90,90,90,90,90,", callbackData
.szTrace2
);
1786 HeapFree( GetProcessHeap(), 0, lpData
[i
] );
1787 IDirectPlayX_Release( pDP
[i
] );
1794 static void test_CreatePlayer(void)
1797 LPDIRECTPLAY4 pDP
[2];
1798 DPSESSIONDESC2 dpsd
;
1804 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1805 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[0] );
1806 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1807 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[1] );
1808 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
1809 ZeroMemory( &name
, sizeof(DPNAME
) );
1812 /* Connection not initialized */
1813 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
, 0, 0 );
1814 checkHR( DPERR_UNINITIALIZED
, hr
);
1817 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
1818 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
1821 /* Session not open */
1822 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
, 0, 0 );
1823 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1825 if ( hr
== DPERR_UNINITIALIZED
)
1827 skip( "CreatePlayer not implemented\n" );
1831 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
1832 dpsd
.guidApplication
= appGuid
;
1833 IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
1837 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
, 0, 0 );
1838 checkHR( DP_OK
, hr
);
1844 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, &name
, NULL
, NULL
, 0, 0 );
1845 checkHR( DP_OK
, hr
);
1848 name
.dwSize
= sizeof(DPNAME
);
1849 U1(name
).lpszShortNameA
= (LPSTR
) "test";
1850 U2(name
).lpszLongNameA
= NULL
;
1853 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, &name
, NULL
, NULL
,
1855 checkHR( DP_OK
, hr
);
1859 hr
= IDirectPlayX_CreatePlayer( pDP
[0], NULL
, NULL
, NULL
, NULL
,
1861 checkHR( DPERR_INVALIDPARAMS
, hr
);
1864 /* There can only be one server player */
1865 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1866 0, DPPLAYER_SERVERPLAYER
);
1867 checkHR( DP_OK
, hr
);
1868 check( DPID_SERVERPLAYER
, dpid
);
1870 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1871 0, DPPLAYER_SERVERPLAYER
);
1872 checkHR( DPERR_CANTCREATEPLAYER
, hr
);
1874 IDirectPlayX_DestroyPlayer( pDP
[0], dpid
);
1876 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1877 0, DPPLAYER_SERVERPLAYER
);
1878 checkHR( DP_OK
, hr
);
1879 check( DPID_SERVERPLAYER
, dpid
);
1880 IDirectPlayX_DestroyPlayer( pDP
[0], dpid
);
1884 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1886 checkHR( DP_OK
, hr
);
1888 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1889 0, DPPLAYER_SERVERPLAYER
);
1890 checkHR( DP_OK
, hr
);
1891 check( DPID_SERVERPLAYER
, dpid
);
1892 IDirectPlayX_DestroyPlayer( pDP
[0], dpid
);
1894 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1895 0, DPPLAYER_SPECTATOR
);
1896 checkHR( DP_OK
, hr
);
1898 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1899 0, ( DPPLAYER_SERVERPLAYER
|
1900 DPPLAYER_SPECTATOR
) );
1901 checkHR( DP_OK
, hr
);
1902 check( DPID_SERVERPLAYER
, dpid
);
1903 IDirectPlayX_DestroyPlayer( pDP
[0], dpid
);
1906 /* Session with DPSESSION_NEWPLAYERSDISABLED */
1907 IDirectPlayX_Close( pDP
[0] );
1908 dpsd
.dwFlags
= DPSESSION_NEWPLAYERSDISABLED
;
1909 hr
= IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
1910 checkHR( DP_OK
, hr
);
1913 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1915 checkHR( DPERR_CANTCREATEPLAYER
, hr
);
1917 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1918 0, DPPLAYER_SERVERPLAYER
);
1919 checkHR( DPERR_CANTCREATEPLAYER
, hr
);
1921 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1922 0, DPPLAYER_SPECTATOR
);
1923 checkHR( DPERR_CANTCREATEPLAYER
, hr
);
1926 /* Creating players in a Client/Server session */
1927 IDirectPlayX_Close( pDP
[0] );
1928 dpsd
.dwFlags
= DPSESSION_CLIENTSERVER
;
1929 hr
= IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
1930 checkHR( DP_OK
, hr
);
1931 hr
= IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
1932 (LPVOID
) pDP
[1], 0 );
1933 checkHR( DP_OK
, hr
);
1936 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1938 checkHR( DPERR_ACCESSDENIED
, hr
);
1940 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1941 0, DPPLAYER_SERVERPLAYER
);
1942 checkHR( DP_OK
, hr
);
1943 check( DPID_SERVERPLAYER
, dpid
);
1945 hr
= IDirectPlayX_CreatePlayer( pDP
[1], &dpid
, NULL
, NULL
, NULL
,
1946 0, DPPLAYER_SERVERPLAYER
);
1947 checkHR( DPERR_INVALIDFLAGS
, hr
);
1949 hr
= IDirectPlayX_CreatePlayer( pDP
[1], &dpid
, NULL
, NULL
, NULL
,
1951 checkHR( DP_OK
, hr
);
1954 IDirectPlayX_Release( pDP
[0] );
1955 IDirectPlayX_Release( pDP
[1] );
1961 static void test_GetPlayerCaps(void)
1964 LPDIRECTPLAY4 pDP
[2];
1965 DPSESSIONDESC2 dpsd
;
1976 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1977 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
1979 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
1980 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
1981 dpsd
.guidApplication
= appGuid
;
1982 dpsd
.dwMaxPlayers
= 10;
1984 ZeroMemory( &playerCaps
, sizeof(DPCAPS
) );
1987 /* Uninitialized service provider */
1988 playerCaps
.dwSize
= 0;
1989 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 0, &playerCaps
, 0 );
1990 checkHR( DPERR_UNINITIALIZED
, hr
);
1992 playerCaps
.dwSize
= sizeof(DPCAPS
);
1993 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 0, &playerCaps
, 0 );
1994 checkHR( DPERR_UNINITIALIZED
, hr
);
1997 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
1998 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
2002 playerCaps
.dwSize
= 0;
2004 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 0, &playerCaps
, 0 );
2005 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
2007 if ( hr
== DPERR_UNINITIALIZED
)
2009 skip( "GetPlayerCaps not implemented\n" );
2013 playerCaps
.dwSize
= sizeof(DPCAPS
);
2015 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 0, &playerCaps
, 0 );
2016 checkHR( DPERR_INVALIDPLAYER
, hr
);
2018 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 2, &playerCaps
, 0 );
2019 checkHR( DPERR_INVALIDPLAYER
, hr
);
2022 hr
= IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
2023 checkHR( DP_OK
, hr
);
2024 hr
= IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
2025 (LPVOID
) pDP
[1], 0 );
2026 checkHR( DP_OK
, hr
);
2030 hr
= IDirectPlayX_CreatePlayer( pDP
[i
], &dpid
[i
],
2031 NULL
, NULL
, NULL
, 0, 0 );
2032 checkHR( DP_OK
, hr
);
2036 /* Uninitialized playerCaps */
2037 playerCaps
.dwSize
= 0;
2039 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 0, &playerCaps
, 0 );
2040 checkHR( DPERR_INVALIDPARAMS
, hr
);
2042 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 2, &playerCaps
, 0 );
2043 checkHR( DPERR_INVALIDPARAMS
, hr
);
2045 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], dpid
[0], &playerCaps
, 0 );
2046 checkHR( DPERR_INVALIDPARAMS
, hr
);
2049 /* Invalid player */
2050 playerCaps
.dwSize
= sizeof(DPCAPS
);
2052 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 0, &playerCaps
, 0 );
2053 checkHR( DPERR_INVALIDPLAYER
, hr
);
2055 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 2, &playerCaps
, 0 );
2056 checkHR( DPERR_INVALIDPLAYER
, hr
);
2058 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], dpid
[0], &playerCaps
, 0 );
2059 checkHR( DP_OK
, hr
);
2062 /* Regular parameters */
2066 dwFlags
<=DPGETCAPS_GUARANTEED
;
2067 dwFlags
+=DPGETCAPS_GUARANTEED
)
2070 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], dpid
[i
],
2071 &playerCaps
, dwFlags
);
2072 checkHR( DP_OK
, hr
);
2075 check( sizeof(DPCAPS
), playerCaps
.dwSize
);
2076 check( 40, playerCaps
.dwSize
);
2077 check( 0, playerCaps
.dwMaxQueueSize
);
2078 check( 0, playerCaps
.dwHundredBaud
);
2079 check( 0, playerCaps
.dwLatency
);
2080 check( 65536, playerCaps
.dwMaxLocalPlayers
);
2081 check( 20, playerCaps
.dwHeaderLength
);
2085 checkFlags( DPCAPS_ISHOST
|
2086 DPCAPS_GUARANTEEDOPTIMIZED
|
2087 DPCAPS_GUARANTEEDSUPPORTED
|
2088 DPCAPS_ASYNCSUPPORTED
|
2090 playerCaps
.dwFlags
, FLAGS_DPCAPS
);
2093 checkFlags( DPCAPS_ISHOST
|
2094 DPCAPS_GUARANTEEDOPTIMIZED
|
2095 DPCAPS_GUARANTEEDSUPPORTED
|
2096 DPCAPS_ASYNCSUPPORTED
,
2097 playerCaps
.dwFlags
, FLAGS_DPCAPS
);
2099 if ( dwFlags
== DPGETCAPS_GUARANTEED
)
2101 check( 1048547, playerCaps
.dwMaxBufferSize
);
2102 check( 64, playerCaps
.dwMaxPlayers
);
2106 check( 65479, playerCaps
.dwMaxBufferSize
);
2107 check( 65536, playerCaps
.dwMaxPlayers
);
2114 IDirectPlayX_Release( pDP
[0] );
2115 IDirectPlayX_Release( pDP
[1] );
2122 static void test_PlayerData(void)
2125 DPSESSIONDESC2 dpsd
;
2129 /* lpDataFake has to be bigger than the rest, limits lpDataGet size */
2130 LPCSTR lpDataFake
= "big_fake_data_chunk";
2131 DWORD dwDataSizeFake
= strlen(lpDataFake
)+1;
2133 LPCSTR lpData
= "remote_data";
2134 DWORD dwDataSize
= strlen(lpData
)+1;
2136 LPCSTR lpDataLocal
= "local_data";
2137 DWORD dwDataSizeLocal
= strlen(lpDataLocal
)+1;
2139 LPSTR lpDataGet
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
2141 DWORD dwDataSizeGet
= dwDataSizeFake
;
2144 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
2145 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
2147 /* No service provider */
2148 hr
= IDirectPlayX_SetPlayerData( pDP
, 0, (LPVOID
) lpData
,
2150 checkHR( DPERR_UNINITIALIZED
, hr
);
2152 hr
= IDirectPlayX_GetPlayerData( pDP
, 0, (LPVOID
) lpDataGet
,
2153 &dwDataSizeGet
, 0 );
2154 checkHR( DPERR_UNINITIALIZED
, hr
);
2157 init_TCPIP_provider( pDP
, "127.0.0.1", 0 );
2159 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
2160 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
2161 dpsd
.guidApplication
= appGuid
;
2162 IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_CREATE
);
2165 /* Invalid player */
2166 hr
= IDirectPlayX_SetPlayerData( pDP
, 0, (LPVOID
) lpData
,
2168 todo_wine
checkHR( DPERR_INVALIDPLAYER
, hr
);
2170 hr
= IDirectPlayX_GetPlayerData( pDP
, 0, (LPVOID
) lpDataGet
,
2171 &dwDataSizeGet
, 0 );
2172 todo_wine
checkHR( DPERR_INVALIDPLAYER
, hr
);
2174 if ( hr
== DPERR_UNINITIALIZED
)
2176 skip( "Get/SetPlayerData not implemented\n" );
2180 /* Create the player */
2181 /* By default, the data is remote */
2182 hr
= IDirectPlayX_CreatePlayer( pDP
, &dpid
, NULL
, NULL
, (LPVOID
) lpData
,
2184 checkHR( DP_OK
, hr
);
2186 /* Invalid parameters */
2187 hr
= IDirectPlayX_SetPlayerData( pDP
, dpid
, NULL
,
2189 checkHR( DPERR_INVALIDPARAMS
, hr
);
2190 hr
= IDirectPlayX_SetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2192 checkHR( DPERR_INVALIDPARAMS
, hr
);
2194 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2196 checkHR( DPERR_INVALIDPARAMS
, hr
);
2200 * Remote data (default)
2204 /* Buffer redimension */
2205 dwDataSizeGet
= dwDataSizeFake
;
2206 strcpy(lpDataGet
, lpDataFake
);
2207 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, NULL
,
2208 &dwDataSizeGet
, 0 );
2209 check( DPERR_BUFFERTOOSMALL
, hr
);
2210 check( dwDataSize
, dwDataSizeGet
);
2211 checkStr( lpDataFake
, lpDataGet
);
2214 strcpy(lpDataGet
, lpDataFake
);
2215 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2216 &dwDataSizeGet
, 0 );
2217 check( DPERR_BUFFERTOOSMALL
, hr
);
2218 check( dwDataSize
, dwDataSizeGet
);
2220 strcpy(lpDataGet
, lpDataFake
);
2221 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2222 &dwDataSizeGet
, 0 );
2223 checkHR( DP_OK
, hr
);
2224 check( dwDataSize
, dwDataSizeGet
);
2225 checkStr( lpData
, lpDataGet
);
2227 /* Normal operation */
2228 dwDataSizeGet
= dwDataSizeFake
;
2229 strcpy(lpDataGet
, lpDataFake
);
2230 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2231 &dwDataSizeGet
, 0 );
2232 checkHR( DP_OK
, hr
);
2233 check( dwDataSize
, dwDataSizeGet
);
2234 checkStr( lpData
, lpDataGet
);
2237 dwDataSizeGet
= dwDataSizeFake
;
2238 strcpy(lpDataGet
, lpDataFake
);
2239 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2240 &dwDataSizeGet
, 0 );
2241 checkHR( DP_OK
, hr
);
2242 check( dwDataSize
, dwDataSizeGet
); /* Remote: works as expected */
2243 checkStr( lpData
, lpDataGet
);
2245 dwDataSizeGet
= dwDataSizeFake
;
2246 strcpy(lpDataGet
, lpDataFake
);
2247 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2248 &dwDataSizeGet
, DPGET_REMOTE
);
2249 checkHR( DP_OK
, hr
);
2250 check( dwDataSize
, dwDataSizeGet
); /* Same behaviour as in previous test */
2251 checkStr( lpData
, lpDataGet
);
2253 dwDataSizeGet
= dwDataSizeFake
;
2254 strcpy(lpDataGet
, lpDataFake
);
2255 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2256 &dwDataSizeGet
, DPGET_LOCAL
);
2257 checkHR( DP_OK
, hr
);
2258 check( 0, dwDataSizeGet
); /* Sets size to 0 (as local data doesn't exist) */
2259 checkStr( lpDataFake
, lpDataGet
);
2261 dwDataSizeGet
= dwDataSizeFake
;
2262 strcpy(lpDataGet
, lpDataFake
);
2263 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2265 DPGET_LOCAL
| DPGET_REMOTE
);
2266 checkHR( DP_OK
, hr
);
2267 check( 0, dwDataSizeGet
); /* Same behaviour as in previous test */
2268 checkStr( lpDataFake
, lpDataGet
);
2270 /* Getting local data (which doesn't exist), buffer size is ignored */
2272 strcpy(lpDataGet
, lpDataFake
);
2273 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2274 &dwDataSizeGet
, DPGET_LOCAL
);
2275 checkHR( DP_OK
, hr
);
2276 check( 0, dwDataSizeGet
); /* Sets size to 0 */
2277 checkStr( lpDataFake
, lpDataGet
);
2279 dwDataSizeGet
= dwDataSizeFake
;
2280 strcpy(lpDataGet
, lpDataFake
);
2281 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, NULL
,
2282 &dwDataSizeGet
, DPGET_LOCAL
);
2283 checkHR( DP_OK
, hr
);
2284 check( 0, dwDataSizeGet
); /* Sets size to 0 */
2285 checkStr( lpDataFake
, lpDataGet
);
2294 hr
= IDirectPlayX_SetPlayerData( pDP
, dpid
, (LPVOID
) lpDataLocal
,
2296 DPSET_LOCAL
| DPSET_GUARANTEED
);
2297 checkHR( DPERR_INVALIDPARAMS
, hr
);
2299 /* Correct parameters */
2300 hr
= IDirectPlayX_SetPlayerData( pDP
, dpid
, (LPVOID
) lpDataLocal
,
2301 dwDataSizeLocal
, DPSET_LOCAL
);
2302 checkHR( DP_OK
, hr
);
2304 /* Flag tests (again) */
2305 dwDataSizeGet
= dwDataSizeFake
;
2306 strcpy(lpDataGet
, lpDataFake
);
2307 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2308 &dwDataSizeGet
, 0 );
2309 checkHR( DP_OK
, hr
);
2310 check( dwDataSize
, dwDataSizeGet
); /* Remote: works as expected */
2311 checkStr( lpData
, lpDataGet
);
2313 dwDataSizeGet
= dwDataSizeFake
;
2314 strcpy(lpDataGet
, lpDataFake
);
2315 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2316 &dwDataSizeGet
, DPGET_REMOTE
);
2317 checkHR( DP_OK
, hr
);
2318 check( dwDataSize
, dwDataSizeGet
); /* Like in previous test */
2319 checkStr( lpData
, lpDataGet
);
2321 dwDataSizeGet
= dwDataSizeFake
;
2322 strcpy(lpDataGet
, lpDataFake
);
2323 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2324 &dwDataSizeGet
, DPGET_LOCAL
);
2325 checkHR( DP_OK
, hr
);
2326 check( dwDataSizeLocal
, dwDataSizeGet
); /* Local: works as expected */
2327 checkStr( lpDataLocal
, lpDataGet
);
2329 dwDataSizeGet
= dwDataSizeFake
;
2330 strcpy(lpDataGet
, lpDataFake
);
2331 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2333 DPGET_LOCAL
| DPGET_REMOTE
);
2334 checkHR( DP_OK
, hr
);
2335 check( dwDataSizeLocal
, dwDataSizeGet
); /* Like in previous test */
2336 checkStr( lpDataLocal
, lpDataGet
);
2338 /* Small buffer works as expected again */
2340 strcpy(lpDataGet
, lpDataFake
);
2341 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2342 &dwDataSizeGet
, DPGET_LOCAL
);
2343 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
2344 check( dwDataSizeLocal
, dwDataSizeGet
);
2345 checkStr( lpDataFake
, lpDataGet
);
2347 dwDataSizeGet
= dwDataSizeFake
;
2348 strcpy(lpDataGet
, lpDataFake
);
2349 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, NULL
,
2350 &dwDataSizeGet
, DPGET_LOCAL
);
2351 check( DPERR_BUFFERTOOSMALL
, hr
);
2352 check( dwDataSizeLocal
, dwDataSizeGet
);
2353 checkStr( lpDataFake
, lpDataGet
);
2357 * Changing remote data
2361 /* Remote data := local data */
2362 hr
= IDirectPlayX_SetPlayerData( pDP
, dpid
, (LPVOID
) lpDataLocal
,
2364 DPSET_GUARANTEED
| DPSET_REMOTE
);
2365 checkHR( DP_OK
, hr
);
2366 hr
= IDirectPlayX_SetPlayerData( pDP
, dpid
, (LPVOID
) lpDataLocal
,
2367 dwDataSizeLocal
, 0 );
2368 checkHR( DP_OK
, hr
);
2370 dwDataSizeGet
= dwDataSizeFake
;
2371 strcpy(lpDataGet
, lpDataFake
);
2372 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2373 &dwDataSizeGet
, 0 );
2374 checkHR( DP_OK
, hr
);
2375 check( dwDataSizeLocal
, dwDataSizeGet
);
2376 checkStr( lpDataLocal
, lpDataGet
);
2378 /* Remote data := fake data */
2379 hr
= IDirectPlayX_SetPlayerData( pDP
, dpid
, (LPVOID
) lpDataFake
,
2380 dwDataSizeFake
, DPSET_REMOTE
);
2381 checkHR( DP_OK
, hr
);
2383 dwDataSizeGet
= dwDataSizeFake
+ 1;
2384 strcpy(lpDataGet
, lpData
);
2385 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2386 &dwDataSizeGet
, 0 );
2387 checkHR( DP_OK
, hr
);
2388 check( dwDataSizeFake
, dwDataSizeGet
);
2389 checkStr( lpDataFake
, lpDataGet
);
2392 HeapFree( GetProcessHeap(), 0, lpDataGet
);
2393 IDirectPlayX_Release( pDP
);
2399 static void test_PlayerName(void)
2402 LPDIRECTPLAY4 pDP
[2];
2403 DPSESSIONDESC2 dpsd
;
2409 DWORD dwDataSize
= 1024;
2410 LPVOID lpData
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, dwDataSize
);
2411 CallbackData callbackData
;
2416 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
2417 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
2419 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
2420 ZeroMemory( &playerName
, sizeof(DPNAME
) );
2423 /* Service provider not initialized */
2424 hr
= IDirectPlayX_SetPlayerName( pDP
[0], 0, &playerName
, 0 );
2425 checkHR( DPERR_UNINITIALIZED
, hr
);
2428 hr
= IDirectPlayX_GetPlayerName( pDP
[0], 0, lpData
, &dwDataSize
);
2429 checkHR( DPERR_UNINITIALIZED
, hr
);
2430 check( 1024, dwDataSize
);
2433 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
2434 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
2437 /* Session not initialized */
2438 hr
= IDirectPlayX_SetPlayerName( pDP
[0], 0, &playerName
, 0 );
2439 todo_wine
checkHR( DPERR_INVALIDPLAYER
, hr
);
2441 if ( hr
== DPERR_UNINITIALIZED
)
2443 skip( "Get/SetPlayerName not implemented\n" );
2448 hr
= IDirectPlayX_GetPlayerName( pDP
[0], 0, lpData
, &dwDataSize
);
2449 checkHR( DPERR_INVALIDPLAYER
, hr
);
2450 check( 1024, dwDataSize
);
2453 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
2454 dpsd
.guidApplication
= appGuid
;
2455 dpsd
.dwMaxPlayers
= 10;
2456 IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
2457 IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
2458 (LPVOID
) pDP
[1], 0 );
2460 IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[0], NULL
, NULL
, NULL
, 0, 0 );
2461 IDirectPlayX_CreatePlayer( pDP
[1], &dpid
[1], NULL
, NULL
, NULL
, 0, 0 );
2464 /* Name not initialized */
2465 playerName
.dwSize
= -1;
2466 hr
= IDirectPlayX_SetPlayerName( pDP
[0], dpid
[0], &playerName
, 0 );
2467 checkHR( DP_OK
, hr
);
2470 hr
= IDirectPlayX_GetPlayerName( pDP
[0], 0, lpData
, &dwDataSize
);
2471 checkHR( DPERR_INVALIDPLAYER
, hr
);
2472 check( 1024, dwDataSize
);
2475 playerName
.dwSize
= sizeof(DPNAME
);
2476 U1(playerName
).lpszShortNameA
= (LPSTR
) "player_name";
2477 U2(playerName
).lpszLongNameA
= (LPSTR
) "player_long_name";
2480 /* Invalid parameters */
2481 hr
= IDirectPlayX_SetPlayerName( pDP
[0], -1, &playerName
, 0 );
2482 checkHR( DPERR_INVALIDPLAYER
, hr
);
2483 hr
= IDirectPlayX_SetPlayerName( pDP
[0], 0, &playerName
, 0 );
2484 checkHR( DPERR_INVALIDPLAYER
, hr
);
2485 hr
= IDirectPlayX_SetPlayerName( pDP
[0], dpid
[0], &playerName
, -1 );
2486 checkHR( DPERR_INVALIDPARAMS
, hr
);
2489 hr
= IDirectPlayX_GetPlayerName( pDP
[0], 0, lpData
, &dwDataSize
);
2490 checkHR( DPERR_INVALIDPLAYER
, hr
);
2491 check( 1024, dwDataSize
);
2494 hr
= IDirectPlayX_GetPlayerName( pDP
[0], dpid
[0], lpData
, &dwDataSize
);
2495 checkHR( DPERR_INVALIDPARAMS
, hr
);
2496 check( -1, dwDataSize
);
2498 hr
= IDirectPlayX_GetPlayerName( pDP
[0], dpid
[0], lpData
, NULL
);
2499 checkHR( DPERR_INVALIDPARAMS
, hr
);
2501 /* Trying to modify remote player */
2502 hr
= IDirectPlayX_SetPlayerName( pDP
[0], dpid
[1], &playerName
, 0 );
2503 checkHR( DPERR_ACCESSDENIED
, hr
);
2506 /* Regular operation */
2507 hr
= IDirectPlayX_SetPlayerName( pDP
[0], dpid
[0], &playerName
, 0 );
2510 hr
= IDirectPlayX_GetPlayerName( pDP
[0], dpid
[0], lpData
, &dwDataSize
);
2511 checkHR( DP_OK
, hr
);
2512 check( 45, dwDataSize
);
2513 checkStr( U1(playerName
).lpszShortNameA
, U1(*(LPDPNAME
)lpData
).lpszShortNameA
);
2514 checkStr( U2(playerName
).lpszLongNameA
, U2(*(LPDPNAME
)lpData
).lpszLongNameA
);
2515 check( 0, ((LPDPNAME
)lpData
)->dwFlags
);
2517 hr
= IDirectPlayX_SetPlayerName( pDP
[0], dpid
[0], NULL
, 0 );
2520 hr
= IDirectPlayX_GetPlayerName( pDP
[0], dpid
[0], lpData
, &dwDataSize
);
2521 checkHR( DP_OK
, hr
);
2522 check( 16, dwDataSize
);
2523 checkLP( NULL
, U1(*(LPDPNAME
)lpData
).lpszShortNameA
);
2524 checkLP( NULL
, U2(*(LPDPNAME
)lpData
).lpszLongNameA
);
2525 check( 0, ((LPDPNAME
)lpData
)->dwFlags
);
2528 /* Small buffer in get operation */
2530 hr
= IDirectPlayX_GetPlayerName( pDP
[0], dpid
[0], NULL
, &dwDataSize
);
2531 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
2532 check( 16, dwDataSize
);
2535 hr
= IDirectPlayX_GetPlayerName( pDP
[0], dpid
[0], lpData
, &dwDataSize
);
2536 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
2537 check( 16, dwDataSize
);
2539 hr
= IDirectPlayX_GetPlayerName( pDP
[0], dpid
[0], lpData
, &dwDataSize
);
2540 checkHR( DP_OK
, hr
);
2541 check( 16, dwDataSize
);
2542 checkLP( NULL
, U1(*(LPDPNAME
)lpData
).lpszShortNameA
);
2543 checkLP( NULL
, U2(*(LPDPNAME
)lpData
).lpszLongNameA
);
2544 check( 0, ((LPDPNAME
)lpData
)->dwFlags
);
2548 hr
= IDirectPlayX_SetPlayerName( pDP
[0], dpid
[0], &playerName
,
2550 checkHR( DP_OK
, hr
);
2552 /* - Local (no propagation) */
2553 U1(playerName
).lpszShortNameA
= (LPSTR
) "no_propagation";
2554 hr
= IDirectPlayX_SetPlayerName( pDP
[0], dpid
[0], &playerName
,
2556 checkHR( DP_OK
, hr
);
2559 hr
= IDirectPlayX_GetPlayerName( pDP
[0], dpid
[0],
2560 lpData
, &dwDataSize
); /* Local fetch */
2561 checkHR( DP_OK
, hr
);
2562 check( 48, dwDataSize
);
2563 checkStr( "no_propagation", U1(*(LPDPNAME
)lpData
).lpszShortNameA
);
2566 hr
= IDirectPlayX_GetPlayerName( pDP
[1], dpid
[0],
2567 lpData
, &dwDataSize
); /* Remote fetch */
2568 checkHR( DP_OK
, hr
);
2569 check( 45, dwDataSize
);
2570 checkStr( "player_name", U1(*(LPDPNAME
)lpData
).lpszShortNameA
);
2574 U1(playerName
).lpszShortNameA
= (LPSTR
) "no_propagation_2";
2575 hr
= IDirectPlayX_SetPlayerName( pDP
[0], dpid
[0], &playerName
,
2576 DPSET_LOCAL
| DPSET_REMOTE
);
2577 checkHR( DP_OK
, hr
);
2580 hr
= IDirectPlayX_GetPlayerName( pDP
[0], dpid
[0],
2581 lpData
, &dwDataSize
); /* Local fetch */
2582 checkHR( DP_OK
, hr
);
2583 check( 50, dwDataSize
);
2584 checkStr( "no_propagation_2", U1(*(LPDPNAME
)lpData
).lpszShortNameA
);
2587 hr
= IDirectPlayX_GetPlayerName( pDP
[1], dpid
[0],
2588 lpData
, &dwDataSize
); /* Remote fetch */
2589 checkHR( DP_OK
, hr
);
2590 check( 45, dwDataSize
);
2591 checkStr( "player_name", U1(*(LPDPNAME
)lpData
).lpszShortNameA
);
2593 /* - Remote (propagation, default) */
2594 U1(playerName
).lpszShortNameA
= (LPSTR
) "propagation";
2595 hr
= IDirectPlayX_SetPlayerName( pDP
[0], dpid
[0], &playerName
,
2597 checkHR( DP_OK
, hr
);
2600 hr
= IDirectPlayX_GetPlayerName( pDP
[1], dpid
[0],
2601 lpData
, &dwDataSize
); /* Remote fetch */
2602 checkHR( DP_OK
, hr
);
2603 check( 45, dwDataSize
);
2604 checkStr( "propagation", U1(*(LPDPNAME
)lpData
).lpszShortNameA
);
2607 U1(playerName
).lpszShortNameA
= (LPSTR
) "propagation_2";
2608 hr
= IDirectPlayX_SetPlayerName( pDP
[0], dpid
[0], &playerName
,
2610 checkHR( DP_OK
, hr
);
2613 hr
= IDirectPlayX_GetPlayerName( pDP
[1], dpid
[0],
2614 lpData
, &dwDataSize
); /* Remote fetch */
2615 checkHR( DP_OK
, hr
);
2616 check( 47, dwDataSize
);
2617 checkStr( "propagation_2", U1(*(LPDPNAME
)lpData
).lpszShortNameA
);
2620 /* Checking system messages */
2621 check_messages( pDP
[0], dpid
, 2, &callbackData
);
2622 checkStr( "S0,S0,S0,S0,S0,S0,S0,", callbackData
.szTrace1
);
2623 checkStr( "48,28,57,28,57,57,59,", callbackData
.szTrace2
);
2624 check_messages( pDP
[1], dpid
, 2, &callbackData
);
2625 checkStr( "S1,S1,S1,S1,S1,S1,", callbackData
.szTrace1
);
2626 checkStr( "28,57,28,57,57,59,", callbackData
.szTrace2
);
2629 HeapFree( GetProcessHeap(), 0, lpData
);
2630 IDirectPlayX_Release( pDP
[0] );
2631 IDirectPlayX_Release( pDP
[1] );
2635 /* GetPlayerAccount */
2637 static BOOL CALLBACK
EnumSessions_cb_join_secure( LPCDPSESSIONDESC2 lpThisSD
,
2638 LPDWORD lpdwTimeOut
,
2642 LPDIRECTPLAY4 pDP
= (LPDIRECTPLAY4
) lpContext
;
2643 DPSESSIONDESC2 dpsd
;
2644 DPCREDENTIALS dpCredentials
;
2647 if (dwFlags
& DPESC_TIMEDOUT
)
2652 checkFlags( DPSESSION_SECURESERVER
, lpThisSD
->dwFlags
, FLAGS_DPSESSION
);
2654 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
2655 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
2656 dpsd
.guidApplication
= appGuid
;
2657 dpsd
.guidInstance
= lpThisSD
->guidInstance
;
2659 ZeroMemory( &dpCredentials
, sizeof(DPCREDENTIALS
) );
2660 dpCredentials
.dwSize
= sizeof(DPCREDENTIALS
);
2661 U1(dpCredentials
).lpszUsernameA
= (LPSTR
) "user";
2662 U2(dpCredentials
).lpszPasswordA
= (LPSTR
) "pass";
2663 hr
= IDirectPlayX_SecureOpen( pDP
, &dpsd
, DPOPEN_JOIN
,
2664 NULL
, &dpCredentials
);
2665 checkHR( DPERR_LOGONDENIED
, hr
); /* TODO: Make this work */
2670 static void test_GetPlayerAccount(void)
2673 LPDIRECTPLAY4 pDP
[2];
2674 DPSESSIONDESC2 dpsd
;
2679 DWORD dwDataSize
= 1024;
2680 LPVOID lpData
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, dwDataSize
);
2685 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
2686 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
2688 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
2689 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
2690 dpsd
.guidApplication
= appGuid
;
2691 dpsd
.dwMaxPlayers
= 10;
2693 /* Uninitialized service provider */
2694 hr
= IDirectPlayX_GetPlayerAccount( pDP
[0], 0, 0, lpData
, &dwDataSize
);
2695 todo_wine
checkHR( DPERR_UNINITIALIZED
, hr
);
2699 skip( "GetPlayerAccount not implemented\n" );
2704 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
2705 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
2709 hr
= IDirectPlayX_GetPlayerAccount( pDP
[0], 0, 0, lpData
, &dwDataSize
);
2710 checkHR( DPERR_NOSESSIONS
, hr
);
2713 IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
2714 IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
2715 (LPVOID
) pDP
[1], 0 );
2719 hr
= IDirectPlayX_CreatePlayer( pDP
[i
], &dpid
[i
], NULL
, NULL
, NULL
,
2721 checkHR( DP_OK
, hr
);
2725 /* Session is not secure */
2727 hr
= IDirectPlayX_GetPlayerAccount( pDP
[0], dpid
[0], 0,
2728 lpData
, &dwDataSize
);
2729 checkHR( DPERR_UNSUPPORTED
, hr
);
2730 check( 1024, dwDataSize
);
2733 /* Open a secure session */
2736 hr
= IDirectPlayX_Close( pDP
[i
] );
2737 checkHR( DP_OK
, hr
);
2740 dpsd
.dwFlags
= DPSESSION_SECURESERVER
;
2741 hr
= IDirectPlayX_SecureOpen( pDP
[0], &dpsd
, DPOPEN_CREATE
, NULL
, NULL
);
2742 checkHR( DP_OK
, hr
);
2744 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[0],
2745 NULL
, NULL
, NULL
, 0, 0 );
2746 checkHR( DP_OK
, hr
);
2748 hr
= IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0,
2749 EnumSessions_cb_join_secure
,
2750 (LPVOID
) pDP
[1], 0 );
2751 checkHR( DP_OK
, hr
);
2753 hr
= IDirectPlayX_CreatePlayer( pDP
[1], &dpid
[1],
2754 NULL
, NULL
, NULL
, 0, 0 );
2755 checkHR( DPERR_INVALIDPARAMS
, hr
);
2757 /* TODO: Player creation so that this works */
2759 /* Invalid player */
2761 hr
= IDirectPlayX_GetPlayerAccount( pDP
[0], 0, 0,
2762 lpData
, &dwDataSize
);
2763 checkHR( DPERR_INVALIDPLAYER
, hr
);
2764 check( 1024, dwDataSize
);
2768 hr
= IDirectPlayX_GetPlayerAccount( pDP
[0], dpid
[0], -1,
2769 lpData
, &dwDataSize
);
2770 checkHR( DPERR_INVALIDFLAGS
, hr
);
2771 check( 1024, dwDataSize
);
2774 hr
= IDirectPlayX_GetPlayerAccount( pDP
[0], dpid
[0], 1,
2775 lpData
, &dwDataSize
);
2776 checkHR( DPERR_INVALIDFLAGS
, hr
);
2777 check( 1024, dwDataSize
);
2781 hr
= IDirectPlayX_GetPlayerAccount( pDP
[0], dpid
[0], 0,
2782 NULL
, &dwDataSize
);
2783 checkHR( DPERR_INVALIDPLAYER
, hr
);
2784 check( 0, dwDataSize
);
2787 hr
= IDirectPlayX_GetPlayerAccount( pDP
[0], dpid
[0], 0,
2788 lpData
, &dwDataSize
);
2789 checkHR( DPERR_INVALIDPLAYER
, hr
);
2790 check( 0, dwDataSize
);
2792 hr
= IDirectPlayX_GetPlayerAccount( pDP
[0], dpid
[0], 0,
2793 lpData
, &dwDataSize
);
2794 checkHR( DPERR_INVALIDPLAYER
, hr
);
2795 check( 0, dwDataSize
);
2797 /* Normal operation */
2799 hr
= IDirectPlayX_GetPlayerAccount( pDP
[0], dpid
[0], 0,
2800 lpData
, &dwDataSize
);
2801 checkHR( DPERR_INVALIDPLAYER
, hr
);
2802 check( 1024, dwDataSize
);
2805 HeapFree( GetProcessHeap(), 0, lpData
);
2806 IDirectPlayX_Release( pDP
[0] );
2807 IDirectPlayX_Release( pDP
[1] );
2811 /* GetPlayerAddress */
2813 static BOOL CALLBACK
EnumAddress_cb( REFGUID guidDataType
,
2818 lpCallbackData callbackData
= (lpCallbackData
) lpContext
;
2819 static REFGUID types
[] = { &DPAID_TotalSize
,
2820 &DPAID_ServiceProvider
,
2823 static DWORD sizes
[] = { 4, 16, 12, 24, 4, 16, 10, 20 };
2826 checkGuid( types
[callbackData
->dwCounter1
%4], guidDataType
);
2827 check( sizes
[callbackData
->dwCounter1
], dwDataSize
);
2829 switch(callbackData
->dwCounter1
)
2832 check( 136, *(LPDWORD
) lpData
);
2835 check( 130, *(LPDWORD
) lpData
);
2839 checkGuid( &DPSPGUID_TCPIP
, (LPGUID
) lpData
);
2842 checkStr( "127.0.0.1", (LPSTR
) lpData
);
2848 callbackData
->dwCounter1
++;
2853 static void test_GetPlayerAddress(void)
2856 LPDIRECTPLAY4 pDP
[2];
2857 LPDIRECTPLAYLOBBY3 pDPL
;
2858 DPSESSIONDESC2 dpsd
;
2860 CallbackData callbackData
;
2864 DWORD dwDataSize
= 1024;
2865 LPVOID lpData
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, dwDataSize
);
2870 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
2871 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
2873 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
2874 CoCreateInstance( &CLSID_DirectPlayLobby
, NULL
, CLSCTX_ALL
,
2875 &IID_IDirectPlayLobby3A
, (LPVOID
*) &pDPL
);
2878 /* Uninitialized service provider */
2879 hr
= IDirectPlayX_GetPlayerAddress( pDP
[0], 0, lpData
, &dwDataSize
);
2880 todo_wine
checkHR( DPERR_UNINITIALIZED
, hr
);
2884 skip( "GetPlayerAddress not implemented\n" );
2888 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
2889 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
2894 hr
= IDirectPlayX_GetPlayerAddress( pDP
[0], 0, lpData
, &dwDataSize
);
2895 checkHR( DPERR_UNSUPPORTED
, hr
);
2896 check( 1024, dwDataSize
);
2899 hr
= IDirectPlayX_GetPlayerAddress( pDP
[0], 1, lpData
, &dwDataSize
);
2900 checkHR( DPERR_INVALIDPLAYER
, hr
);
2901 check( 1024, dwDataSize
);
2904 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
2905 dpsd
.guidApplication
= appGuid
;
2906 dpsd
.dwMaxPlayers
= 10;
2907 IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
2908 IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
2909 (LPVOID
) pDP
[1], 0 );
2913 hr
= IDirectPlayX_CreatePlayer( pDP
[i
], &dpid
[i
], NULL
, NULL
, NULL
,
2915 checkHR( DP_OK
, hr
);
2918 /* Invalid player */
2920 hr
= IDirectPlayX_GetPlayerAddress( pDP
[0], 0,
2921 lpData
, &dwDataSize
);
2922 checkHR( DPERR_UNSUPPORTED
, hr
);
2923 check( 1024, dwDataSize
);
2926 hr
= IDirectPlayX_GetPlayerAddress( pDP
[0], 1,
2927 lpData
, &dwDataSize
);
2928 checkHR( DPERR_INVALIDPLAYER
, hr
);
2929 check( 1024, dwDataSize
);
2933 hr
= IDirectPlayX_GetPlayerAddress( pDP
[0], dpid
[0],
2934 NULL
, &dwDataSize
);
2935 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
2936 check( 136, dwDataSize
);
2939 hr
= IDirectPlayX_GetPlayerAddress( pDP
[0], dpid
[0],
2940 lpData
, &dwDataSize
);
2941 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
2942 check( 136, dwDataSize
);
2944 hr
= IDirectPlayX_GetPlayerAddress( pDP
[0], dpid
[0],
2945 lpData
, &dwDataSize
);
2946 checkHR( DP_OK
, hr
);
2947 check( 136, dwDataSize
);
2950 /* Regular parameters */
2951 callbackData
.dwCounter1
= 0;
2955 hr
= IDirectPlayX_GetPlayerAddress( pDP
[0], dpid
[0],
2956 lpData
, &dwDataSize
);
2957 checkHR( DP_OK
, hr
);
2958 check( 136, dwDataSize
);
2960 hr
= IDirectPlayLobby_EnumAddress( pDPL
, EnumAddress_cb
,
2961 (LPCVOID
) lpData
, dwDataSize
,
2962 (LPVOID
) &callbackData
);
2963 checkHR( DP_OK
, hr
);
2965 check( 4, callbackData
.dwCounter1
);
2969 hr
= IDirectPlayX_GetPlayerAddress( pDP
[0], dpid
[1],
2970 lpData
, &dwDataSize
);
2971 checkHR( DP_OK
, hr
);
2972 check( 130, dwDataSize
);
2974 hr
= IDirectPlayLobby_EnumAddress( pDPL
, EnumAddress_cb
,
2975 (LPCVOID
) lpData
, dwDataSize
,
2976 (LPVOID
) &callbackData
);
2977 checkHR( DP_OK
, hr
);
2979 check( 8, callbackData
.dwCounter1
);
2982 HeapFree( GetProcessHeap(), 0, lpData
);
2983 IDirectPlayX_Release( pDP
[0] );
2984 IDirectPlayX_Release( pDP
[1] );
2988 /* GetPlayerFlags */
2990 static void test_GetPlayerFlags(void)
2993 LPDIRECTPLAY4 pDP
[2];
2994 DPSESSIONDESC2 dpsd
;
3004 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
3005 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
3007 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
3008 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
3009 dpsd
.guidApplication
= appGuid
;
3010 dpsd
.dwMaxPlayers
= 10;
3012 /* Uninitialized service provider */
3013 hr
= IDirectPlayX_GetPlayerFlags( pDP
[0], 0, &dwFlags
);
3014 todo_wine
checkHR( DPERR_UNINITIALIZED
, hr
);
3018 skip( "GetPlayerFlags not implemented\n" );
3022 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
3023 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
3027 hr
= IDirectPlayX_GetPlayerFlags( pDP
[0], 0, &dwFlags
);
3028 checkHR( DPERR_INVALIDPLAYER
, hr
);
3030 hr
= IDirectPlayX_GetPlayerFlags( pDP
[0], 1, &dwFlags
);
3031 checkHR( DPERR_INVALIDPLAYER
, hr
);
3034 IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
3035 IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
3036 (LPVOID
) pDP
[1], 0 );
3040 hr
= IDirectPlayX_CreatePlayer( pDP
[i
], &dpid
[i
],
3041 NULL
, NULL
, NULL
, 0, 0 );
3042 checkHR( DP_OK
, hr
);
3044 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[2],
3046 0, DPPLAYER_SPECTATOR
);
3047 checkHR( DP_OK
, hr
);
3048 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[3],
3050 0, DPPLAYER_SERVERPLAYER
);
3051 checkHR( DP_OK
, hr
);
3054 /* Invalid player */
3055 hr
= IDirectPlayX_GetPlayerFlags( pDP
[0], 0, &dwFlags
);
3056 checkHR( DPERR_INVALIDPLAYER
, hr
);
3058 hr
= IDirectPlayX_GetPlayerFlags( pDP
[0], 2, &dwFlags
);
3059 checkHR( DPERR_INVALIDPLAYER
, hr
);
3061 /* Invalid parameters */
3062 hr
= IDirectPlayX_GetPlayerFlags( pDP
[0], dpid
[0], NULL
);
3063 checkHR( DPERR_INVALIDPARAMS
, hr
);
3066 /* Regular parameters */
3067 hr
= IDirectPlayX_GetPlayerFlags( pDP
[0], dpid
[0], &dwFlags
);
3068 checkHR( DP_OK
, hr
);
3069 checkFlags( dwFlags
, DPPLAYER_LOCAL
, FLAGS_DPPLAYER
);
3071 hr
= IDirectPlayX_GetPlayerFlags( pDP
[1], dpid
[1], &dwFlags
);
3072 checkHR( DP_OK
, hr
);
3073 checkFlags( dwFlags
, DPPLAYER_LOCAL
, FLAGS_DPPLAYER
);
3075 hr
= IDirectPlayX_GetPlayerFlags( pDP
[0], dpid
[1], &dwFlags
);
3076 checkHR( DP_OK
, hr
);
3077 checkFlags( dwFlags
, 0, FLAGS_DPPLAYER
);
3079 hr
= IDirectPlayX_GetPlayerFlags( pDP
[0], dpid
[2], &dwFlags
);
3080 checkHR( DP_OK
, hr
);
3081 checkFlags( dwFlags
, DPPLAYER_SPECTATOR
| DPPLAYER_LOCAL
, FLAGS_DPPLAYER
);
3083 hr
= IDirectPlayX_GetPlayerFlags( pDP
[1], dpid
[3], &dwFlags
);
3084 checkHR( DP_OK
, hr
);
3085 checkFlags( dwFlags
, DPPLAYER_SERVERPLAYER
, FLAGS_DPPLAYER
);
3088 IDirectPlayX_Release( pDP
[0] );
3089 IDirectPlayX_Release( pDP
[1] );
3094 CreateGroupInGroup */
3096 static void test_CreateGroup(void)
3100 DPSESSIONDESC2 dpsd
;
3101 DPID idFrom
, idTo
, dpid
, idGroup
, idGroupParent
;
3106 LPCSTR lpData
= "data";
3107 DWORD dwDataSize
= strlen(lpData
)+1;
3108 LPDPMSG_CREATEPLAYERORGROUP lpDataGet
= HeapAlloc( GetProcessHeap(),
3111 DWORD dwDataSizeGet
= 1024;
3112 CallbackData callbackData
;
3115 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
3116 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
3117 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
3118 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
3119 dpsd
.guidApplication
= appGuid
;
3120 dpsd
.dwMaxPlayers
= 10;
3121 ZeroMemory( &groupName
, sizeof(DPNAME
) );
3124 /* No service provider */
3125 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroup
, NULL
, NULL
, 0, 0 );
3126 checkHR( DPERR_UNINITIALIZED
, hr
);
3128 hr
= IDirectPlayX_CreateGroupInGroup( pDP
, 0, &idGroup
, NULL
, NULL
, 0, 0 );
3129 checkHR( DPERR_UNINITIALIZED
, hr
);
3133 init_TCPIP_provider( pDP
, "127.0.0.1", 0 );
3137 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroup
,
3139 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
3141 if ( hr
== DPERR_UNINITIALIZED
)
3143 skip( "CreateGroup not implemented\n" );
3147 hr
= IDirectPlayX_CreateGroupInGroup( pDP
, 0, &idGroup
,
3149 checkHR( DPERR_INVALIDGROUP
, hr
);
3151 hr
= IDirectPlayX_CreateGroupInGroup( pDP
, 2, &idGroup
,
3153 checkHR( DPERR_INVALIDGROUP
, hr
);
3156 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_CREATE
);
3157 checkHR( DP_OK
, hr
);
3158 IDirectPlayX_CreatePlayer( pDP
, &dpid
,
3159 NULL
, NULL
, NULL
, 0, 0 );
3164 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroup
,
3166 checkHR( DP_OK
, hr
);
3168 hr
= IDirectPlayX_CreateGroupInGroup( pDP
, idGroup
, &idGroup
,
3170 checkHR( DP_OK
, hr
);
3172 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroup
,
3173 &groupName
, NULL
, 0, 0 );
3174 checkHR( DP_OK
, hr
);
3176 hr
= IDirectPlayX_CreateGroupInGroup( pDP
, idGroup
, &idGroup
,
3177 &groupName
, NULL
, 0, 0 );
3178 checkHR( DP_OK
, hr
);
3181 groupName
.dwSize
= sizeof(DPNAME
);
3182 groupName
.lpszShortNameA
= (LPSTR
) lpData
;
3185 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroup
,
3186 &groupName
, NULL
, 0, 0 );
3187 checkHR( DP_OK
, hr
);
3189 hr
= IDirectPlayX_CreateGroupInGroup( pDP
, idGroup
, &idGroup
,
3190 &groupName
, NULL
, 0, 0 );
3191 checkHR( DP_OK
, hr
);
3194 /* Message checking */
3197 dwDataSizeGet
= 1024;
3198 hr
= IDirectPlayX_Receive( pDP
, &idFrom
, &idTo
, 0,
3199 (LPVOID
) lpDataGet
, &dwDataSizeGet
);
3200 checkHR( DP_OK
, hr
);
3201 if ( NULL
== lpDataGet
->dpnName
.lpszShortNameA
)
3203 check( 48, dwDataSizeGet
);
3207 check( 48 + dwDataSize
, dwDataSizeGet
);
3208 checkStr( lpData
, lpDataGet
->dpnName
.lpszShortNameA
);
3210 check( DPID_SYSMSG
, idFrom
);
3211 checkConv( DPSYS_CREATEPLAYERORGROUP
, lpDataGet
->dwType
, dpMsgType2str
);
3212 check( DPPLAYERTYPE_GROUP
, lpDataGet
->dwPlayerType
);
3213 checkFlags( DPGROUP_LOCAL
, lpDataGet
->dwFlags
, FLAGS_DPGROUP
);
3215 check_messages( pDP
, &dpid
, 1, &callbackData
);
3216 checkStr( "", callbackData
.szTrace1
);
3220 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroup
,
3221 NULL
, (LPVOID
) lpData
, -1, 0 );
3222 checkHR( DPERR_INVALIDPARAMS
, hr
);
3224 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroup
,
3225 NULL
, (LPVOID
) lpData
, 0, 0 );
3226 checkHR( DP_OK
, hr
);
3228 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroup
,
3229 NULL
, NULL
, dwDataSize
, 0 );
3230 checkHR( DPERR_INVALIDPARAMS
, hr
);
3232 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroup
,
3233 NULL
, (LPVOID
) lpData
, dwDataSize
, 0 );
3234 checkHR( DP_OK
, hr
);
3237 hr
= IDirectPlayX_CreateGroupInGroup( pDP
, idGroup
, &idGroup
,
3238 NULL
, (LPVOID
) lpData
, -1, 0 );
3239 checkHR( DPERR_INVALIDPARAMS
, hr
);
3241 hr
= IDirectPlayX_CreateGroupInGroup( pDP
, idGroup
, &idGroup
,
3242 NULL
, (LPVOID
) lpData
, 0, 0 );
3243 checkHR( DP_OK
, hr
);
3245 hr
= IDirectPlayX_CreateGroupInGroup( pDP
, idGroup
, &idGroup
,
3246 NULL
, NULL
, dwDataSize
, 0 );
3247 checkHR( DPERR_INVALIDPARAMS
, hr
);
3249 hr
= IDirectPlayX_CreateGroupInGroup( pDP
, idGroup
, &idGroup
,
3250 NULL
, (LPVOID
)lpData
, dwDataSize
, 0 );
3251 checkHR( DP_OK
, hr
);
3254 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroupParent
,
3256 checkHR( DP_OK
, hr
);
3259 /* Message checking */
3262 dwDataSizeGet
= 1024;
3263 hr
= IDirectPlayX_Receive( pDP
, &idFrom
, &idTo
, 0,
3264 (LPVOID
) lpDataGet
, &dwDataSizeGet
);
3265 checkHR( DP_OK
, hr
);
3266 check( 48 + lpDataGet
->dwDataSize
, dwDataSizeGet
);
3267 check( DPID_SYSMSG
, idFrom
);
3268 checkConv( DPSYS_CREATEPLAYERORGROUP
, lpDataGet
->dwType
, dpMsgType2str
);
3269 check( DPPLAYERTYPE_GROUP
, lpDataGet
->dwPlayerType
);
3270 checkFlags( DPGROUP_LOCAL
, lpDataGet
->dwFlags
, FLAGS_DPGROUP
);
3272 check_messages( pDP
, &dpid
, 1, &callbackData
);
3273 checkStr( "", callbackData
.szTrace1
);
3276 /* Flags and idGroupParent */
3277 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroup
,
3279 checkHR( DP_OK
, hr
);
3281 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroup
,
3282 NULL
, NULL
, 0, DPGROUP_HIDDEN
);
3283 checkHR( DP_OK
, hr
);
3285 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroup
,
3286 NULL
, NULL
, 0, DPGROUP_STAGINGAREA
);
3287 checkHR( DP_OK
, hr
);
3289 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroup
,
3291 DPGROUP_HIDDEN
| DPGROUP_STAGINGAREA
);
3292 checkHR( DP_OK
, hr
);
3295 hr
= IDirectPlayX_CreateGroupInGroup( pDP
, idGroupParent
, &idGroup
,
3297 checkHR( DP_OK
, hr
);
3299 hr
= IDirectPlayX_CreateGroupInGroup( pDP
, idGroupParent
, &idGroup
,
3300 NULL
, NULL
, 0, DPGROUP_HIDDEN
);
3301 checkHR( DP_OK
, hr
);
3303 hr
= IDirectPlayX_CreateGroupInGroup( pDP
, idGroupParent
, &idGroup
,
3304 NULL
, NULL
, 0, DPGROUP_STAGINGAREA
);
3305 checkHR( DP_OK
, hr
);
3307 hr
= IDirectPlayX_CreateGroupInGroup( pDP
, idGroupParent
, &idGroup
,
3310 DPGROUP_STAGINGAREA
);
3311 checkHR( DP_OK
, hr
);
3314 /* Message checking */
3317 dwDataSizeGet
= 1024;
3318 hr
= IDirectPlayX_Receive( pDP
, &idFrom
, &idTo
, 0,
3319 (LPVOID
) lpDataGet
, &dwDataSizeGet
);
3320 checkHR( DP_OK
, hr
);
3321 check( 48, dwDataSizeGet
);
3322 check( DPID_SYSMSG
, idFrom
);
3323 checkConv( DPSYS_CREATEPLAYERORGROUP
, lpDataGet
->dwType
, dpMsgType2str
);
3324 check( DPPLAYERTYPE_GROUP
, lpDataGet
->dwPlayerType
);
3326 if ( lpDataGet
->dpIdParent
!= 0 )
3328 check( idGroupParent
, lpDataGet
->dpIdParent
);
3334 checkFlags( DPGROUP_LOCAL
,
3335 lpDataGet
->dwFlags
, FLAGS_DPGROUP
);
3338 checkFlags( DPGROUP_LOCAL
| DPGROUP_HIDDEN
,
3339 lpDataGet
->dwFlags
, FLAGS_DPGROUP
);
3342 checkFlags( DPGROUP_STAGINGAREA
| DPGROUP_LOCAL
,
3343 lpDataGet
->dwFlags
, FLAGS_DPGROUP
);
3346 checkFlags( DPGROUP_STAGINGAREA
| DPGROUP_LOCAL
| DPGROUP_HIDDEN
,
3347 lpDataGet
->dwFlags
, FLAGS_DPGROUP
);
3352 check_messages( pDP
, &dpid
, 1, &callbackData
);
3353 checkStr( "", callbackData
.szTrace1
);
3356 /* If a group is created in C/S mode, no messages are sent */
3359 IDirectPlayX_Close( pDP
);
3362 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_CREATE
);
3363 checkHR( DP_OK
, hr
);
3364 hr
= IDirectPlayX_CreatePlayer( pDP
, &dpid
, NULL
, NULL
, NULL
, 0, 0 );
3365 checkHR( DP_OK
, hr
);
3367 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroup
, NULL
, NULL
, 0, 0 );
3368 checkHR( DP_OK
, hr
);
3370 /* Messages are received */
3371 check_messages( pDP
, &dpid
, 1, &callbackData
);
3372 checkStr( "S0,", callbackData
.szTrace1
);
3375 /* - Client/Server */
3376 IDirectPlayX_Close( pDP
);
3378 dpsd
.dwFlags
= DPSESSION_CLIENTSERVER
;
3379 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_CREATE
);
3380 checkHR( DP_OK
, hr
);
3381 hr
= IDirectPlayX_CreatePlayer( pDP
, &dpid
,
3382 NULL
, NULL
, NULL
, 0,
3383 DPPLAYER_SERVERPLAYER
);
3384 checkHR( DP_OK
, hr
);
3386 hr
= IDirectPlayX_CreateGroup( pDP
, &idGroup
,
3388 checkHR( DP_OK
, hr
);
3391 check_messages( pDP
, &dpid
, 1, &callbackData
);
3392 checkStr( "S0,", callbackData
.szTrace1
); /* Or at least there
3393 shouldn't be messages... */
3396 HeapFree( GetProcessHeap(), 0, lpDataGet
);
3397 IDirectPlayX_Release( pDP
);
3403 static void test_GroupOwner(void)
3406 LPDIRECTPLAY4 pDP
[2];
3407 DPSESSIONDESC2 dpsd
;
3408 DPID dpid
[2], idGroup
, idOwner
;
3415 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
3416 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
3418 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
3419 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
3420 dpsd
.guidApplication
= appGuid
;
3421 dpsd
.dwMaxPlayers
= 10;
3425 /* Service provider not initialized */
3426 hr
= IDirectPlayX_GetGroupOwner( pDP
[0], idGroup
, &idOwner
);
3427 todo_wine
checkHR( DPERR_UNINITIALIZED
, hr
);
3428 check( 0, idOwner
);
3432 skip( "GetGroupOwner not implemented\n" );
3438 init_TCPIP_provider( pDP
[i
], "127.0.0.1", 0 );
3440 hr
= IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
3441 checkHR( DP_OK
, hr
);
3442 hr
= IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
3443 (LPVOID
) pDP
[1], 0 );
3444 checkHR( DP_OK
, hr
);
3448 hr
= IDirectPlayX_CreatePlayer( pDP
[i
], &dpid
[i
],
3449 NULL
, NULL
, NULL
, 0, 0 );
3450 checkHR( DP_OK
, hr
);
3454 hr
= IDirectPlayX_GetGroupOwner( pDP
[0], idGroup
, &idOwner
);
3455 checkHR( DPERR_INVALIDGROUP
, hr
);
3457 hr
= IDirectPlayX_CreateGroup( pDP
[0], &idGroup
, NULL
, NULL
, 0, 0 );
3458 checkHR( DP_OK
, hr
);
3460 /* Fails, because we need a lobby session */
3461 hr
= IDirectPlayX_GetGroupOwner( pDP
[0], idGroup
, &idOwner
);
3462 checkHR( DPERR_UNSUPPORTED
, hr
);
3467 * - Check migration of the ownership of a group
3468 * when the owner leaves
3472 IDirectPlayX_Release( pDP
[0] );
3473 IDirectPlayX_Release( pDP
[1] );
3479 static BOOL CALLBACK
EnumPlayers_cb( DPID dpId
,
3485 lpCallbackData callbackData
= (lpCallbackData
) lpContext
;
3486 char playerIndex
= dpid2char( callbackData
->dpid
,
3487 callbackData
->dpidSize
,
3491 /* Trace to study player ids */
3492 callbackData
->szTrace1
[ callbackData
->dwCounter1
] = playerIndex
;
3493 callbackData
->dwCounter1
++;
3494 callbackData
->szTrace1
[ callbackData
->dwCounter1
] = '\0';
3496 /* Trace to study flags received */
3497 strcat( callbackData
->szTrace2
,
3498 ( dwFlags2str(dwFlags
, FLAGS_DPENUMPLAYERS
) +
3499 strlen("DPENUMPLAYERS_") ) );
3500 strcat( callbackData
->szTrace2
, ":" );
3503 if ( playerIndex
< '5' )
3505 check( DPPLAYERTYPE_PLAYER
, dwPlayerType
);
3509 check( DPPLAYERTYPE_GROUP
, dwPlayerType
);
3516 static BOOL CALLBACK
EnumSessions_cb_EnumPlayers( LPCDPSESSIONDESC2 lpThisSD
,
3517 LPDWORD lpdwTimeOut
,
3521 lpCallbackData callbackData
= (lpCallbackData
) lpContext
;
3524 if (dwFlags
& DPESC_TIMEDOUT
)
3530 callbackData
->dwCounter1
= 0;
3531 hr
= IDirectPlayX_EnumPlayers( callbackData
->pDP
, NULL
,
3533 (LPVOID
) &callbackData
, 0 );
3534 checkHR( DPERR_NOSESSIONS
, hr
);
3535 check( 0, callbackData
->dwCounter1
);
3537 /* guid = appGuid */
3538 callbackData
->dwCounter1
= 0;
3539 hr
= IDirectPlayX_EnumPlayers( callbackData
->pDP
, (LPGUID
) &appGuid
,
3541 (LPVOID
) &callbackData
, 0 );
3542 checkHR( DPERR_NOSESSIONS
, hr
);
3543 check( 0, callbackData
->dwCounter1
);
3545 callbackData
->dwCounter1
= 0;
3546 hr
= IDirectPlayX_EnumPlayers( callbackData
->pDP
, (LPGUID
) &appGuid
,
3548 (LPVOID
) &callbackData
,
3549 DPENUMPLAYERS_SESSION
);
3550 checkHR( DPERR_NOSESSIONS
, hr
);
3551 check( 0, callbackData
->dwCounter1
);
3553 /* guid = guidInstance */
3554 callbackData
->dwCounter1
= 0;
3555 hr
= IDirectPlayX_EnumPlayers( callbackData
->pDP
,
3556 (LPGUID
) &lpThisSD
->guidInstance
,
3558 (LPVOID
) &callbackData
, 0 );
3559 checkHR( DPERR_NOSESSIONS
, hr
);
3560 check( 0, callbackData
->dwCounter1
);
3562 callbackData
->dwCounter1
= 0;
3563 hr
= IDirectPlayX_EnumPlayers( callbackData
->pDP
,
3564 (LPGUID
) &lpThisSD
->guidInstance
,
3566 (LPVOID
) &callbackData
,
3567 DPENUMPLAYERS_SESSION
);
3568 checkHR( DPERR_GENERIC
, hr
); /* Why? */
3569 check( 0, callbackData
->dwCounter1
);
3575 static void test_EnumPlayers(void)
3577 LPDIRECTPLAY4 pDP
[3];
3578 DPSESSIONDESC2 dpsd
[3];
3579 DPID dpid
[5+2]; /* 5 players, 2 groups */
3580 CallbackData callbackData
;
3587 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
3588 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
3590 ZeroMemory( &dpsd
[i
], sizeof(DPSESSIONDESC2
) );
3591 dpsd
[i
].dwSize
= sizeof(DPSESSIONDESC2
);
3594 dpsd
[0].guidApplication
= appGuid
;
3595 dpsd
[1].guidApplication
= appGuid2
;
3596 dpsd
[2].guidApplication
= GUID_NULL
;
3598 callbackData
.dpid
= dpid
;
3599 callbackData
.dpidSize
= 5+2;
3602 /* Uninitialized service provider */
3603 callbackData
.dwCounter1
= 0;
3604 hr
= IDirectPlayX_EnumPlayers( pDP
[0], (LPGUID
) &appGuid
, NULL
,
3605 (LPVOID
) &callbackData
, 0 );
3606 checkHR( DPERR_UNINITIALIZED
, hr
);
3607 check( 0, callbackData
.dwCounter1
);
3610 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
3611 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
3612 init_TCPIP_provider( pDP
[2], "127.0.0.1", 0 );
3616 callbackData
.dwCounter1
= 0;
3617 hr
= IDirectPlayX_EnumPlayers( pDP
[0], NULL
, EnumPlayers_cb
,
3618 (LPVOID
) &callbackData
, 0 );
3619 todo_wine
checkHR( DPERR_NOSESSIONS
, hr
);
3620 check( 0, callbackData
.dwCounter1
);
3622 if ( hr
== DPERR_UNINITIALIZED
)
3624 skip( "EnumPlayers not implemented\n" );
3628 callbackData
.dwCounter1
= 0;
3629 hr
= IDirectPlayX_EnumPlayers( pDP
[0], (LPGUID
) &appGuid
, EnumPlayers_cb
,
3630 (LPVOID
) &callbackData
, 0 );
3631 checkHR( DPERR_NOSESSIONS
, hr
);
3632 check( 0, callbackData
.dwCounter1
);
3634 callbackData
.dwCounter1
= 0;
3635 hr
= IDirectPlayX_EnumPlayers( pDP
[0], (LPGUID
) &appGuid
, EnumPlayers_cb
,
3636 (LPVOID
) &callbackData
,
3637 DPENUMPLAYERS_SESSION
);
3638 checkHR( DPERR_NOSESSIONS
, hr
);
3639 check( 0, callbackData
.dwCounter1
);
3642 hr
= IDirectPlayX_Open( pDP
[0], &dpsd
[0], DPOPEN_CREATE
);
3643 checkHR( DP_OK
, hr
);
3644 hr
= IDirectPlayX_Open( pDP
[1], &dpsd
[1], DPOPEN_CREATE
);
3645 checkHR( DP_OK
, hr
);
3649 callbackData
.dwCounter1
= 0;
3650 hr
= IDirectPlayX_EnumPlayers( pDP
[0], NULL
, EnumPlayers_cb
,
3651 (LPVOID
) &callbackData
, 0 );
3652 checkHR( DP_OK
, hr
);
3653 check( 0, callbackData
.dwCounter1
);
3656 /* Create players */
3657 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[0],
3658 NULL
, NULL
, NULL
, 0,
3659 DPPLAYER_SERVERPLAYER
);
3660 checkHR( DP_OK
, hr
);
3661 hr
= IDirectPlayX_CreatePlayer( pDP
[1], &dpid
[1],
3662 NULL
, NULL
, NULL
, 0,
3664 checkHR( DP_OK
, hr
);
3666 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[2],
3667 NULL
, NULL
, NULL
, 0,
3669 checkHR( DP_OK
, hr
);
3670 hr
= IDirectPlayX_CreateGroup( pDP
[0], &dpid
[5],
3672 checkHR( DP_OK
, hr
);
3675 /* Invalid parameters */
3676 callbackData
.dwCounter1
= 0;
3677 hr
= IDirectPlayX_EnumPlayers( pDP
[0], (LPGUID
) &appGuid
, NULL
,
3678 (LPVOID
) &callbackData
, 0 );
3679 checkHR( DPERR_INVALIDPARAMS
, hr
);
3680 check( 0, callbackData
.dwCounter1
);
3682 callbackData
.dwCounter1
= 0;
3683 hr
= IDirectPlayX_EnumPlayers( pDP
[0], NULL
, EnumPlayers_cb
,
3684 (LPVOID
) &callbackData
,
3685 DPENUMPLAYERS_SESSION
);
3686 checkHR( DPERR_INVALIDPARAMS
, hr
);
3687 check( 0, callbackData
.dwCounter1
);
3690 /* Regular operation */
3691 callbackData
.dwCounter1
= 0;
3692 callbackData
.szTrace2
[0] = 0;
3693 hr
= IDirectPlayX_EnumPlayers( pDP
[0], NULL
, EnumPlayers_cb
,
3694 (LPVOID
) &callbackData
, 0 );
3695 checkHR( DP_OK
, hr
);
3696 check( 2, callbackData
.dwCounter1
);
3697 checkStr( "20", callbackData
.szTrace1
);
3698 checkStr( "ALL:SERVERPLAYER:", callbackData
.szTrace2
);
3700 callbackData
.dwCounter1
= 0;
3701 callbackData
.szTrace2
[0] = 0;
3702 hr
= IDirectPlayX_EnumPlayers( pDP
[1], NULL
, EnumPlayers_cb
,
3703 (LPVOID
) &callbackData
, 0 );
3704 checkHR( DP_OK
, hr
);
3705 check( 1, callbackData
.dwCounter1
);
3706 checkStr( "1", callbackData
.szTrace1
);
3707 checkStr( "ALL:", callbackData
.szTrace2
);
3709 callbackData
.dwCounter1
= 0;
3710 callbackData
.szTrace2
[0] = 0;
3711 hr
= IDirectPlayX_EnumPlayers( pDP
[0], (LPGUID
) &appGuid
, EnumPlayers_cb
,
3712 (LPVOID
) &callbackData
, 0 );
3713 checkHR( DP_OK
, hr
);
3714 check( 2, callbackData
.dwCounter1
); /* Guid is ignored */
3715 checkStr( "20", callbackData
.szTrace1
);
3716 checkStr( "ALL:SERVERPLAYER:", callbackData
.szTrace2
);
3719 /* Enumerating from a remote session */
3720 /* - Session not open */
3721 callbackData
.pDP
= pDP
[2];
3722 hr
= IDirectPlayX_EnumSessions( pDP
[2], &dpsd
[2], 0,
3723 EnumSessions_cb_EnumPlayers
,
3724 (LPVOID
) &callbackData
, 0 );
3725 checkHR( DP_OK
, hr
);
3728 /* - Open session */
3729 callbackData
.pDP
= pDP
[2];
3730 hr
= IDirectPlayX_EnumSessions( pDP
[2], &dpsd
[0], 0, EnumSessions_cb_join
,
3731 (LPVOID
) pDP
[2], 0 );
3732 checkHR( DP_OK
, hr
);
3733 hr
= IDirectPlayX_CreatePlayer( pDP
[2], &dpid
[3],
3734 NULL
, NULL
, NULL
, 0,
3735 DPPLAYER_SPECTATOR
);
3736 checkHR( DP_OK
, hr
);
3737 hr
= IDirectPlayX_CreatePlayer( pDP
[2], &dpid
[4],
3738 NULL
, NULL
, NULL
, 0,
3740 checkHR( DP_OK
, hr
);
3741 hr
= IDirectPlayX_CreateGroup( pDP
[2], &dpid
[6],
3743 checkHR( DP_OK
, hr
);
3745 callbackData
.dwCounter1
= 0;
3746 callbackData
.szTrace2
[0] = 0;
3747 hr
= IDirectPlayX_EnumPlayers( pDP
[2], NULL
, EnumPlayers_cb
,
3748 (LPVOID
) &callbackData
, 0 );
3749 checkHR( DP_OK
, hr
);
3750 check( 4, callbackData
.dwCounter1
);
3751 checkStr( "4302", callbackData
.szTrace1
);
3752 checkStr( "ALL:SPECTATOR:SERVERPLAYER:ALL:", callbackData
.szTrace2
);
3757 callbackData
.dwCounter1
= 0;
3758 callbackData
.szTrace2
[0] = 0;
3759 hr
= IDirectPlayX_EnumPlayers( pDP
[2], NULL
, EnumPlayers_cb
,
3760 (LPVOID
) &callbackData
,
3761 DPENUMPLAYERS_ALL
);
3762 checkHR( DP_OK
, hr
);
3763 check( 4, callbackData
.dwCounter1
);
3764 checkStr( "4302", callbackData
.szTrace1
);
3765 checkStr( "ALL:SPECTATOR:SERVERPLAYER:ALL:", callbackData
.szTrace2
);
3767 callbackData
.dwCounter1
= 0;
3768 callbackData
.szTrace2
[0] = 0;
3769 hr
= IDirectPlayX_EnumPlayers( pDP
[2], NULL
, EnumPlayers_cb
,
3770 (LPVOID
) &callbackData
,
3771 DPENUMPLAYERS_GROUP
);
3772 checkHR( DP_OK
, hr
);
3773 check( 6, callbackData
.dwCounter1
);
3774 checkStr( "430256", callbackData
.szTrace1
);
3776 "GROUP,DPENUMPLAYERS_SPECTATOR:"
3777 "GROUP,DPENUMPLAYERS_SERVERPLAYER:"
3778 "GROUP:ALL:ALL:", callbackData
.szTrace2
);
3780 callbackData
.dwCounter1
= 0;
3781 callbackData
.szTrace2
[0] = 0;
3782 hr
= IDirectPlayX_EnumPlayers( pDP
[2], NULL
, EnumPlayers_cb
,
3783 (LPVOID
) &callbackData
,
3784 DPENUMPLAYERS_LOCAL
);
3785 checkHR( DP_OK
, hr
);
3786 check( 2, callbackData
.dwCounter1
);
3787 checkStr( "43", callbackData
.szTrace1
);
3789 "LOCAL,DPENUMPLAYERS_SPECTATOR:", callbackData
.szTrace2
);
3791 callbackData
.dwCounter1
= 0;
3792 callbackData
.szTrace2
[0] = 0;
3793 hr
= IDirectPlayX_EnumPlayers( pDP
[2], NULL
, EnumPlayers_cb
,
3794 (LPVOID
) &callbackData
,
3795 DPENUMPLAYERS_SERVERPLAYER
);
3796 checkHR( DP_OK
, hr
);
3797 check( 1, callbackData
.dwCounter1
);
3798 checkStr( "0", callbackData
.szTrace1
);
3799 checkStr( "SERVERPLAYER:", callbackData
.szTrace2
);
3801 callbackData
.dwCounter1
= 0;
3802 callbackData
.szTrace2
[0] = 0;
3803 hr
= IDirectPlayX_EnumPlayers( pDP
[2], NULL
, EnumPlayers_cb
,
3804 (LPVOID
) &callbackData
,
3805 DPENUMPLAYERS_SPECTATOR
);
3806 checkHR( DP_OK
, hr
);
3807 check( 1, callbackData
.dwCounter1
);
3808 checkStr( "3", callbackData
.szTrace1
);
3809 checkStr( "SPECTATOR:", callbackData
.szTrace2
);
3812 IDirectPlayX_Release( pDP
[0] );
3813 IDirectPlayX_Release( pDP
[1] );
3814 IDirectPlayX_Release( pDP
[2] );
3820 static BOOL CALLBACK
EnumGroups_cb( DPID dpId
,
3826 lpCallbackData callbackData
= (lpCallbackData
) lpContext
;
3827 char playerIndex
= dpid2char( callbackData
->dpid
,
3828 callbackData
->dpidSize
,
3832 /* Trace to study player ids */
3833 callbackData
->szTrace1
[ callbackData
->dwCounter1
] = playerIndex
;
3834 callbackData
->dwCounter1
++;
3835 callbackData
->szTrace1
[ callbackData
->dwCounter1
] = '\0';
3837 /* Trace to study flags received */
3838 strcat( callbackData
->szTrace2
,
3839 ( dwFlags2str(dwFlags
, FLAGS_DPENUMGROUPS
) +
3840 strlen("DPENUMGROUPS_") ) );
3841 strcat( callbackData
->szTrace2
, ":" );
3844 check( DPPLAYERTYPE_GROUP
, dwPlayerType
);
3849 static BOOL CALLBACK
EnumSessions_cb_EnumGroups( LPCDPSESSIONDESC2 lpThisSD
,
3850 LPDWORD lpdwTimeOut
,
3854 lpCallbackData callbackData
= (lpCallbackData
) lpContext
;
3857 if (dwFlags
& DPESC_TIMEDOUT
)
3863 callbackData
->dwCounter1
= 0;
3864 hr
= IDirectPlayX_EnumGroups( callbackData
->pDP
, NULL
,
3866 (LPVOID
) &callbackData
, 0 );
3867 checkHR( DPERR_NOSESSIONS
, hr
);
3868 check( 0, callbackData
->dwCounter1
);
3870 /* guid = appGuid */
3871 callbackData
->dwCounter1
= 0;
3872 hr
= IDirectPlayX_EnumGroups( callbackData
->pDP
, (LPGUID
) &appGuid
,
3874 (LPVOID
) &callbackData
, 0 );
3875 checkHR( DPERR_NOSESSIONS
, hr
);
3876 check( 0, callbackData
->dwCounter1
);
3878 callbackData
->dwCounter1
= 0;
3879 hr
= IDirectPlayX_EnumGroups( callbackData
->pDP
, (LPGUID
) &appGuid
,
3881 (LPVOID
) &callbackData
,
3882 DPENUMGROUPS_SESSION
);
3883 checkHR( DPERR_NOSESSIONS
, hr
);
3884 check( 0, callbackData
->dwCounter1
);
3886 /* guid = guidInstance */
3887 callbackData
->dwCounter1
= 0;
3888 hr
= IDirectPlayX_EnumGroups( callbackData
->pDP
,
3889 (LPGUID
) &lpThisSD
->guidInstance
,
3891 (LPVOID
) &callbackData
, 0 );
3892 checkHR( DPERR_NOSESSIONS
, hr
);
3893 check( 0, callbackData
->dwCounter1
);
3895 callbackData
->dwCounter1
= 0;
3896 hr
= IDirectPlayX_EnumGroups( callbackData
->pDP
,
3897 (LPGUID
) &lpThisSD
->guidInstance
,
3899 (LPVOID
) &callbackData
,
3900 DPENUMGROUPS_SESSION
);
3901 checkHR( DPERR_GENERIC
, hr
); /* Why? */
3902 check( 0, callbackData
->dwCounter1
);
3908 static void test_EnumGroups(void)
3910 LPDIRECTPLAY4 pDP
[3];
3911 DPSESSIONDESC2 dpsd
[3];
3913 CallbackData callbackData
;
3920 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
3921 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
3923 ZeroMemory( &dpsd
[i
], sizeof(DPSESSIONDESC2
) );
3924 dpsd
[i
].dwSize
= sizeof(DPSESSIONDESC2
);
3927 dpsd
[0].guidApplication
= appGuid
;
3928 dpsd
[1].guidApplication
= appGuid2
;
3929 dpsd
[2].guidApplication
= GUID_NULL
;
3931 callbackData
.dpid
= dpid
;
3932 callbackData
.dpidSize
= 5;
3935 /* Uninitialized service provider */
3936 callbackData
.dwCounter1
= 0;
3937 hr
= IDirectPlayX_EnumGroups( pDP
[0], NULL
, EnumGroups_cb
,
3938 (LPVOID
) &callbackData
, 0 );
3939 checkHR( DPERR_UNINITIALIZED
, hr
);
3940 check( 0, callbackData
.dwCounter1
);
3943 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
3944 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
3945 init_TCPIP_provider( pDP
[2], "127.0.0.1", 0 );
3949 callbackData
.dwCounter1
= 0;
3950 hr
= IDirectPlayX_EnumGroups( pDP
[0], NULL
, EnumGroups_cb
,
3951 (LPVOID
) &callbackData
, 0 );
3952 todo_wine
checkHR( DPERR_NOSESSIONS
, hr
);
3953 check( 0, callbackData
.dwCounter1
);
3955 if ( hr
== DPERR_UNINITIALIZED
)
3957 skip( "EnumGroups not implemented\n" );
3961 callbackData
.dwCounter1
= 0;
3962 hr
= IDirectPlayX_EnumGroups( pDP
[0], (LPGUID
) &appGuid
, EnumGroups_cb
,
3963 (LPVOID
) &callbackData
, 0 );
3964 checkHR( DPERR_NOSESSIONS
, hr
);
3965 check( 0, callbackData
.dwCounter1
);
3967 callbackData
.dwCounter1
= 0;
3968 hr
= IDirectPlayX_EnumGroups( pDP
[0], (LPGUID
) &appGuid
, EnumGroups_cb
,
3969 (LPVOID
) &callbackData
,
3970 DPENUMGROUPS_SESSION
);
3971 checkHR( DPERR_NOSESSIONS
, hr
);
3972 check( 0, callbackData
.dwCounter1
);
3975 hr
= IDirectPlayX_Open( pDP
[0], &dpsd
[0], DPOPEN_CREATE
);
3976 checkHR( DP_OK
, hr
);
3977 hr
= IDirectPlayX_Open( pDP
[1], &dpsd
[1], DPOPEN_CREATE
);
3978 checkHR( DP_OK
, hr
);
3982 callbackData
.dwCounter1
= 0;
3983 hr
= IDirectPlayX_EnumGroups( pDP
[0], NULL
, EnumGroups_cb
,
3984 (LPVOID
) &callbackData
, 0 );
3985 checkHR( DP_OK
, hr
);
3986 check( 0, callbackData
.dwCounter1
);
3990 hr
= IDirectPlayX_CreateGroup( pDP
[0], &dpid
[0],
3992 checkHR( DP_OK
, hr
);
3993 hr
= IDirectPlayX_CreateGroupInGroup( pDP
[0], dpid
[0], &dpid
[3],
3995 checkHR( DP_OK
, hr
); /* Not a superior level group,
3996 won't appear in the enumerations */
3997 hr
= IDirectPlayX_CreateGroup( pDP
[1], &dpid
[1],
3999 checkHR( DP_OK
, hr
);
4000 hr
= IDirectPlayX_CreateGroup( pDP
[0], &dpid
[2],
4001 NULL
, NULL
, 0, DPGROUP_HIDDEN
);
4002 checkHR( DP_OK
, hr
);
4005 /* Invalid parameters */
4006 callbackData
.dwCounter1
= 0;
4007 hr
= IDirectPlayX_EnumGroups( pDP
[0], (LPGUID
) &appGuid
, NULL
,
4008 (LPVOID
) &callbackData
, 0 );
4009 checkHR( DPERR_INVALIDPARAMS
, hr
);
4010 check( 0, callbackData
.dwCounter1
);
4012 callbackData
.dwCounter1
= 0;
4013 hr
= IDirectPlayX_EnumGroups( pDP
[0], NULL
, EnumGroups_cb
,
4014 (LPVOID
) &callbackData
,
4015 DPENUMGROUPS_SESSION
);
4016 checkHR( DPERR_INVALIDPARAMS
, hr
);
4017 check( 0, callbackData
.dwCounter1
);
4020 /* Regular operation */
4021 callbackData
.dwCounter1
= 0;
4022 callbackData
.szTrace2
[0] = 0;
4023 hr
= IDirectPlayX_EnumGroups( pDP
[0], NULL
, EnumGroups_cb
,
4024 (LPVOID
) &callbackData
, 0 );
4025 checkHR( DP_OK
, hr
);
4026 check( 2, callbackData
.dwCounter1
);
4027 checkStr( "02", callbackData
.szTrace1
);
4028 checkStr( "ALL:HIDDEN:", callbackData
.szTrace2
);
4030 callbackData
.dwCounter1
= 0;
4031 callbackData
.szTrace2
[0] = 0;
4032 hr
= IDirectPlayX_EnumGroups( pDP
[1], NULL
, EnumGroups_cb
,
4033 (LPVOID
) &callbackData
, 0 );
4034 checkHR( DP_OK
, hr
);
4035 check( 1, callbackData
.dwCounter1
);
4036 checkStr( "1", callbackData
.szTrace1
);
4037 checkStr( "ALL:", callbackData
.szTrace2
);
4039 callbackData
.dwCounter1
= 0;
4040 callbackData
.szTrace2
[0] = 0;
4041 hr
= IDirectPlayX_EnumGroups( pDP
[0], (LPGUID
) &appGuid
, EnumGroups_cb
,
4042 (LPVOID
) &callbackData
, 0 );
4043 checkHR( DP_OK
, hr
);
4044 check( 2, callbackData
.dwCounter1
); /* Guid is ignored */
4045 checkStr( "02", callbackData
.szTrace1
);
4046 checkStr( "ALL:HIDDEN:", callbackData
.szTrace2
);
4049 /* Enumerating from a remote session */
4050 /* - Session not open */
4051 callbackData
.pDP
= pDP
[2];
4052 hr
= IDirectPlayX_EnumSessions( pDP
[2], &dpsd
[2], 0,
4053 EnumSessions_cb_EnumGroups
,
4054 (LPVOID
) &callbackData
, 0 );
4055 checkHR( DP_OK
, hr
);
4057 /* - Open session */
4058 callbackData
.pDP
= pDP
[2];
4059 hr
= IDirectPlayX_EnumSessions( pDP
[2], &dpsd
[0], 0, EnumSessions_cb_join
,
4060 (LPVOID
) pDP
[2], 0 );
4061 checkHR( DP_OK
, hr
);
4063 hr
= IDirectPlayX_CreateGroup( pDP
[2], &dpid
[3],
4065 checkHR( DP_OK
, hr
);
4066 hr
= IDirectPlayX_CreateGroup( pDP
[2], &dpid
[4],
4067 NULL
, NULL
, 0, DPGROUP_STAGINGAREA
);
4068 checkHR( DP_OK
, hr
);
4071 callbackData
.dwCounter1
= 0;
4072 callbackData
.szTrace2
[0] = 0;
4073 hr
= IDirectPlayX_EnumGroups( pDP
[2], NULL
, EnumGroups_cb
,
4074 (LPVOID
) &callbackData
, 0 );
4075 checkHR( DP_OK
, hr
);
4076 check( 4, callbackData
.dwCounter1
);
4077 checkStr( "0234", callbackData
.szTrace1
);
4078 checkStr( "ALL:HIDDEN:ALL:STAGINGAREA:", callbackData
.szTrace2
);
4081 callbackData
.dwCounter1
= 0;
4082 callbackData
.szTrace2
[0] = 0;
4083 hr
= IDirectPlayX_EnumGroups( pDP
[2], NULL
, EnumGroups_cb
,
4084 (LPVOID
) &callbackData
,
4086 checkHR( DP_OK
, hr
);
4087 check( 4, callbackData
.dwCounter1
);
4088 checkStr( "0234", callbackData
.szTrace1
);
4089 checkStr( "ALL:HIDDEN:ALL:STAGINGAREA:", callbackData
.szTrace2
);
4091 callbackData
.dwCounter1
= 0;
4092 callbackData
.szTrace2
[0] = 0;
4093 hr
= IDirectPlayX_EnumGroups( pDP
[2], NULL
, EnumGroups_cb
,
4094 (LPVOID
) &callbackData
,
4095 DPENUMGROUPS_HIDDEN
);
4096 checkHR( DP_OK
, hr
);
4097 check( 1, callbackData
.dwCounter1
);
4098 checkStr( "2", callbackData
.szTrace1
);
4099 checkStr( "HIDDEN:", callbackData
.szTrace2
);
4101 callbackData
.dwCounter1
= 0;
4102 callbackData
.szTrace2
[0] = 0;
4103 hr
= IDirectPlayX_EnumGroups( pDP
[2], NULL
, EnumGroups_cb
,
4104 (LPVOID
) &callbackData
,
4105 DPENUMGROUPS_LOCAL
);
4106 checkHR( DP_OK
, hr
);
4107 check( 2, callbackData
.dwCounter1
);
4108 checkStr( "34", callbackData
.szTrace1
);
4110 "LOCAL,DPENUMGROUPS_STAGINGAREA:", callbackData
.szTrace2
);
4112 callbackData
.dwCounter1
= 0;
4113 callbackData
.szTrace2
[0] = 0;
4114 hr
= IDirectPlayX_EnumGroups( pDP
[2], NULL
, EnumGroups_cb
,
4115 (LPVOID
) &callbackData
,
4116 DPENUMGROUPS_REMOTE
);
4117 checkHR( DP_OK
, hr
);
4118 check( 2, callbackData
.dwCounter1
);
4119 checkStr( "02", callbackData
.szTrace1
);
4121 "REMOTE,DPENUMGROUPS_HIDDEN:", callbackData
.szTrace2
);
4123 callbackData
.dwCounter1
= 0;
4124 callbackData
.szTrace2
[0] = 0;
4125 hr
= IDirectPlayX_EnumGroups( pDP
[2], NULL
, EnumGroups_cb
,
4126 (LPVOID
) &callbackData
,
4127 DPENUMGROUPS_STAGINGAREA
);
4128 checkHR( DP_OK
, hr
);
4129 check( 1, callbackData
.dwCounter1
);
4130 checkStr( "4", callbackData
.szTrace1
);
4131 checkStr( "STAGINGAREA:", callbackData
.szTrace2
);
4134 IDirectPlayX_Release( pDP
[0] );
4135 IDirectPlayX_Release( pDP
[1] );
4136 IDirectPlayX_Release( pDP
[2] );
4140 static void test_EnumGroupsInGroup(void)
4142 LPDIRECTPLAY4 pDP
[2];
4143 DPSESSIONDESC2 dpsd
[2];
4145 CallbackData callbackData
;
4152 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
4153 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
4155 ZeroMemory( &dpsd
[i
], sizeof(DPSESSIONDESC2
) );
4156 dpsd
[i
].dwSize
= sizeof(DPSESSIONDESC2
);
4159 dpsd
[0].guidApplication
= appGuid
;
4160 dpsd
[1].guidApplication
= GUID_NULL
;
4162 callbackData
.dpid
= dpid
;
4163 callbackData
.dpidSize
= 6;
4166 /* Uninitialized service provider */
4167 callbackData
.dwCounter1
= 0;
4168 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[0], 0, NULL
, EnumGroups_cb
,
4169 (LPVOID
) &callbackData
, 0 );
4170 checkHR( DPERR_UNINITIALIZED
, hr
);
4171 check( 0, callbackData
.dwCounter1
);
4174 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
4175 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
4177 hr
= IDirectPlayX_Open( pDP
[0], &dpsd
[0], DPOPEN_CREATE
);
4178 todo_wine
checkHR( DP_OK
, hr
);
4180 if ( hr
== DPERR_UNINITIALIZED
)
4182 skip( "EnumGroupsInGroup not implemented\n" );
4194 hr
= IDirectPlayX_CreateGroup( pDP
[0], &dpid
[0],
4196 checkHR( DP_OK
, hr
);
4197 hr
= IDirectPlayX_CreateGroup( pDP
[0], &dpid
[1],
4199 checkHR( DP_OK
, hr
);
4200 hr
= IDirectPlayX_CreateGroupInGroup( pDP
[0], dpid
[1], &dpid
[2],
4202 checkHR( DP_OK
, hr
);
4203 hr
= IDirectPlayX_CreateGroupInGroup( pDP
[0], dpid
[1], &dpid
[3],
4206 checkHR( DP_OK
, hr
);
4207 hr
= IDirectPlayX_CreateGroupInGroup( pDP
[0], dpid
[1], &dpid
[4],
4209 DPGROUP_STAGINGAREA
);
4210 checkHR( DP_OK
, hr
);
4211 hr
= IDirectPlayX_CreateGroup( pDP
[0], &dpid
[5],
4213 checkHR( DP_OK
, hr
);
4215 hr
= IDirectPlayX_AddGroupToGroup( pDP
[0], dpid
[1], dpid
[5] );
4216 checkHR( DP_OK
, hr
);
4219 /* Invalid parameters */
4220 callbackData
.dwCounter1
= 0;
4221 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[0], 0, NULL
, EnumGroups_cb
,
4222 (LPVOID
) &callbackData
, 0 );
4223 checkHR( DPERR_INVALIDGROUP
, hr
);
4224 check( 0, callbackData
.dwCounter1
);
4226 callbackData
.dwCounter1
= 0;
4227 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[0], 10, NULL
, EnumGroups_cb
,
4228 (LPVOID
) &callbackData
, 0 );
4229 checkHR( DPERR_INVALIDGROUP
, hr
);
4230 check( 0, callbackData
.dwCounter1
);
4232 callbackData
.dwCounter1
= 0;
4233 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[0], dpid
[1], (LPGUID
) &appGuid
,
4234 NULL
, (LPVOID
) &callbackData
, 0 );
4235 checkHR( DPERR_INVALIDPARAMS
, hr
);
4236 check( 0, callbackData
.dwCounter1
);
4238 callbackData
.dwCounter1
= 0;
4239 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[0], dpid
[1], NULL
, EnumGroups_cb
,
4240 (LPVOID
) &callbackData
,
4241 DPENUMGROUPS_SESSION
);
4242 checkHR( DPERR_INVALIDPARAMS
, hr
);
4243 check( 0, callbackData
.dwCounter1
);
4246 /* Regular operation */
4247 callbackData
.dwCounter1
= 0;
4248 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[0], dpid
[0], NULL
, EnumGroups_cb
,
4249 (LPVOID
) &callbackData
, 0 );
4250 checkHR( DP_OK
, hr
);
4251 check( 0, callbackData
.dwCounter1
);
4253 callbackData
.dwCounter1
= 0;
4254 callbackData
.szTrace2
[0] = 0;
4255 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[0], dpid
[1], NULL
, EnumGroups_cb
,
4256 (LPVOID
) &callbackData
, 0 );
4257 checkHR( DP_OK
, hr
);
4258 check( 4, callbackData
.dwCounter1
);
4259 checkStr( "5432", callbackData
.szTrace1
);
4260 checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData
.szTrace2
);
4262 callbackData
.dwCounter1
= 0;
4263 callbackData
.szTrace2
[0] = 0;
4264 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[0], dpid
[1], (LPGUID
) &appGuid
,
4266 (LPVOID
) &callbackData
, 0 );
4267 checkHR( DP_OK
, hr
);
4268 check( 4, callbackData
.dwCounter1
); /* Guid is ignored */
4269 checkStr( "5432", callbackData
.szTrace1
);
4270 checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData
.szTrace2
);
4273 /* Enumerating from a remote session */
4274 /* - Session not open */
4275 callbackData
.pDP
= pDP
[1];
4276 hr
= IDirectPlayX_EnumSessions( pDP
[1], &dpsd
[1], 0,
4277 EnumSessions_cb_EnumGroups
,
4278 (LPVOID
) &callbackData
, 0 );
4279 checkHR( DP_OK
, hr
);
4281 /* - Open session */
4282 callbackData
.pDP
= pDP
[1];
4283 hr
= IDirectPlayX_EnumSessions( pDP
[1], &dpsd
[0], 0, EnumSessions_cb_join
,
4284 (LPVOID
) pDP
[2], 0 );
4285 checkHR( DP_OK
, hr
);
4288 callbackData
.dwCounter1
= 0;
4289 callbackData
.szTrace2
[0] = 0;
4290 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[1], dpid
[1], NULL
, EnumGroups_cb
,
4291 (LPVOID
) &callbackData
, 0 );
4292 checkHR( DP_OK
, hr
);
4293 check( 4, callbackData
.dwCounter1
);
4294 checkStr( "5432", callbackData
.szTrace1
);
4295 checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData
.szTrace2
);
4298 callbackData
.dwCounter1
= 0;
4299 callbackData
.szTrace2
[0] = 0;
4300 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[0], dpid
[1], NULL
, EnumGroups_cb
,
4301 (LPVOID
) &callbackData
,
4303 checkHR( DP_OK
, hr
);
4304 check( 4, callbackData
.dwCounter1
);
4305 checkStr( "5432", callbackData
.szTrace1
);
4306 checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData
.szTrace2
);
4308 callbackData
.dwCounter1
= 0;
4309 callbackData
.szTrace2
[0] = 0;
4310 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[0], dpid
[1], NULL
, EnumGroups_cb
,
4311 (LPVOID
) &callbackData
,
4312 DPENUMGROUPS_HIDDEN
);
4313 checkHR( DP_OK
, hr
);
4314 check( 1, callbackData
.dwCounter1
);
4315 checkStr( "3", callbackData
.szTrace1
);
4316 checkStr( "HIDDEN:", callbackData
.szTrace2
);
4318 callbackData
.dwCounter1
= 0;
4319 callbackData
.szTrace2
[0] = 0;
4320 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[0], dpid
[1], NULL
, EnumGroups_cb
,
4321 (LPVOID
) &callbackData
,
4322 DPENUMGROUPS_LOCAL
);
4323 checkHR( DP_OK
, hr
);
4324 check( 4, callbackData
.dwCounter1
);
4325 checkStr( "5432", callbackData
.szTrace1
);
4326 checkStr( "LOCAL,DPENUMGROUPS_SHORTCUT:"
4327 "LOCAL,DPENUMGROUPS_STAGINGAREA:"
4328 "LOCAL,DPENUMGROUPS_HIDDEN:LOCAL:", callbackData
.szTrace2
);
4330 callbackData
.dwCounter1
= 0;
4331 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[0], dpid
[1], NULL
, EnumGroups_cb
,
4332 (LPVOID
) &callbackData
,
4333 DPENUMGROUPS_REMOTE
);
4334 checkHR( DP_OK
, hr
);
4335 check( 0, callbackData
.dwCounter1
);
4337 callbackData
.dwCounter1
= 0;
4338 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[1], dpid
[1], NULL
, EnumGroups_cb
,
4339 (LPVOID
) &callbackData
,
4340 DPENUMGROUPS_LOCAL
);
4341 checkHR( DP_OK
, hr
);
4342 check( 0, callbackData
.dwCounter1
);
4344 callbackData
.dwCounter1
= 0;
4345 callbackData
.szTrace2
[0] = 0;
4346 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[1], dpid
[1], NULL
, EnumGroups_cb
,
4347 (LPVOID
) &callbackData
,
4348 DPENUMGROUPS_REMOTE
);
4349 checkHR( DP_OK
, hr
);
4350 check( 4, callbackData
.dwCounter1
);
4351 checkStr( "5432", callbackData
.szTrace1
);
4352 checkStr( "REMOTE,DPENUMGROUPS_SHORTCUT:"
4353 "REMOTE,DPENUMGROUPS_STAGINGAREA:"
4354 "REMOTE,DPENUMGROUPS_HIDDEN:REMOTE:", callbackData
.szTrace2
);
4356 callbackData
.dwCounter1
= 0;
4357 callbackData
.szTrace2
[0] = 0;
4358 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[0], dpid
[1], NULL
, EnumGroups_cb
,
4359 (LPVOID
) &callbackData
,
4360 DPENUMGROUPS_SHORTCUT
);
4361 checkHR( DP_OK
, hr
);
4362 check( 1, callbackData
.dwCounter1
);
4363 checkStr( "5", callbackData
.szTrace1
);
4364 checkStr( "SHORTCUT:", callbackData
.szTrace2
);
4366 callbackData
.dwCounter1
= 0;
4367 callbackData
.szTrace2
[0] = 0;
4368 hr
= IDirectPlayX_EnumGroupsInGroup( pDP
[0], dpid
[1], NULL
, EnumGroups_cb
,
4369 (LPVOID
) &callbackData
,
4370 DPENUMGROUPS_STAGINGAREA
);
4371 checkHR( DP_OK
, hr
);
4372 check( 1, callbackData
.dwCounter1
);
4373 checkStr( "4", callbackData
.szTrace1
);
4374 checkStr( "STAGINGAREA:", callbackData
.szTrace2
);
4377 IDirectPlayX_Release( pDP
[0] );
4378 IDirectPlayX_Release( pDP
[1] );
4382 static void test_groups_p2p(void)
4385 LPDIRECTPLAY4 pDP
[2];
4386 DPSESSIONDESC2 dpsd
;
4387 DPID idPlayer
[6], idGroup
[3];
4391 DWORD dwDataSize
= 1024;
4392 LPVOID lpData
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, 1024 );
4393 CallbackData callbackData
;
4398 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
4399 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
4401 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
4402 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
4403 dpsd
.guidApplication
= appGuid
;
4404 dpsd
.dwMaxPlayers
= 10;
4407 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
4408 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
4410 hr
= IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
4411 todo_wine
checkHR( DP_OK
, hr
);
4412 hr
= IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
4413 (LPVOID
) pDP
[1], 0 );
4414 todo_wine
checkHR( DP_OK
, hr
);
4416 if ( hr
== DPERR_UNINITIALIZED
)
4418 skip( "dplay not implemented enough for this test yet\n" );
4423 /* Create players */
4424 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &idPlayer
[0],
4425 NULL
, NULL
, NULL
, 0, 0 );
4426 checkHR( DP_OK
, hr
);
4427 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &idPlayer
[1],
4428 NULL
, NULL
, NULL
, 0, 0 );
4429 checkHR( DP_OK
, hr
);
4430 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &idPlayer
[2],
4431 NULL
, NULL
, NULL
, 0, 0 );
4432 checkHR( DP_OK
, hr
);
4433 hr
= IDirectPlayX_CreatePlayer( pDP
[1], &idPlayer
[3],
4434 NULL
, NULL
, NULL
, 0, 0 );
4435 checkHR( DP_OK
, hr
);
4436 hr
= IDirectPlayX_CreatePlayer( pDP
[1], &idPlayer
[4],
4437 NULL
, NULL
, NULL
, 0, 0 );
4438 checkHR( DP_OK
, hr
);
4439 hr
= IDirectPlayX_CreatePlayer( pDP
[1], &idPlayer
[5],
4440 NULL
, NULL
, NULL
, 0, 0 );
4441 checkHR( DP_OK
, hr
);
4443 hr
= IDirectPlayX_CreateGroup( pDP
[0], &idGroup
[0],
4445 checkHR( DP_OK
, hr
);
4446 hr
= IDirectPlayX_CreateGroup( pDP
[1], &idGroup
[2],
4448 checkHR( DP_OK
, hr
);
4449 hr
= IDirectPlayX_CreateGroupInGroup( pDP
[1], idGroup
[2], &idGroup
[1],
4451 checkHR( DP_OK
, hr
);
4455 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4456 checkStr( "S0," "S1,S0,"
4457 "S2,S1,S0," "S2,S1,S0,"
4458 "S2,S1,S0," "S2,S1,S0,"
4459 "S2,S1,S0," "S2,S1,S0,", callbackData
.szTrace1
);
4460 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4461 checkStr( "S3," "S4,S3,"
4462 "S5,S4,S3," "S5,S4,S3,"
4463 "S5,S4,S3,", callbackData
.szTrace1
);
4468 * Player 1 | Group 0 | pDP 0
4470 * Player 3 | Group 1 ) |
4471 * Player 4 | | Group 2 | pDP 1
4476 hr
= IDirectPlayX_AddPlayerToGroup( pDP
[0], idGroup
[0], idPlayer
[0] );
4477 checkHR( DP_OK
, hr
);
4478 hr
= IDirectPlayX_AddPlayerToGroup( pDP
[0], idGroup
[0], idPlayer
[1] );
4479 checkHR( DP_OK
, hr
);
4480 hr
= IDirectPlayX_AddPlayerToGroup( pDP
[0], idGroup
[0], idPlayer
[2] );
4481 checkHR( DP_OK
, hr
);
4482 hr
= IDirectPlayX_AddPlayerToGroup( pDP
[1], idGroup
[1], idPlayer
[3] );
4483 checkHR( DP_OK
, hr
);
4484 hr
= IDirectPlayX_AddPlayerToGroup( pDP
[1], idGroup
[1], idPlayer
[4] );
4485 checkHR( DP_OK
, hr
);
4486 hr
= IDirectPlayX_AddPlayerToGroup( pDP
[1], idGroup
[2], idPlayer
[4] );
4487 checkHR( DP_OK
, hr
);
4488 hr
= IDirectPlayX_AddPlayerToGroup( pDP
[1], idGroup
[2], idPlayer
[5] );
4489 checkHR( DP_OK
, hr
);
4491 hr
= IDirectPlayX_AddGroupToGroup( pDP
[1], idGroup
[2], idGroup
[1] );
4492 checkHR( DP_OK
, hr
);
4495 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4496 checkStr( "S2,S1,S0," "S2,S1,S0," "S2,S1,S0,"
4497 "S2,S1,S0," "S2,S1,S0," "S2,S1,S0,"
4498 "S2,S1,S0,", callbackData
.szTrace1
);
4499 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4500 checkStr( "S5,S4,S3," "S5,S4,S3," "S5,S4,S3,"
4501 "S5,S4,S3," "S5,S4,S3," "S5,S4,S3,"
4502 "S5,S4,S3,", callbackData
.szTrace1
);
4505 /* Sending broadcast messages, and checking who receives them */
4509 hr
= IDirectPlayX_Send( pDP
[0], idPlayer
[0], DPID_ALLPLAYERS
, 0,
4510 lpData
, dwDataSize
);
4511 checkHR( DP_OK
, hr
);
4512 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4513 checkStr( "02,01,", callbackData
.szTrace1
);
4514 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4515 checkStr( "05,04,03,", callbackData
.szTrace1
);
4518 hr
= IDirectPlayX_Send( pDP
[0], idPlayer
[0], idGroup
[0], 0,
4519 lpData
, dwDataSize
);
4520 checkHR( DP_OK
, hr
);
4521 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4522 checkStr( "02,01,", callbackData
.szTrace1
);
4523 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4524 checkStr( "", callbackData
.szTrace1
);
4526 hr
= IDirectPlayX_Send( pDP
[0], idPlayer
[0], idGroup
[1], 0,
4527 lpData
, dwDataSize
);
4528 checkHR( DP_OK
, hr
);
4529 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4530 checkStr( "", callbackData
.szTrace1
);
4531 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4532 checkStr( "04,03,", callbackData
.szTrace1
);
4534 hr
= IDirectPlayX_Send( pDP
[0], idPlayer
[0], idGroup
[2], 0,
4535 lpData
, dwDataSize
);
4536 checkHR( DP_OK
, hr
);
4537 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4538 checkStr( "", callbackData
.szTrace1
);
4539 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4540 checkStr( "05,04,", callbackData
.szTrace1
);
4543 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[3], DPID_ALLPLAYERS
, 0,
4544 lpData
, dwDataSize
);
4545 checkHR( DP_OK
, hr
);
4546 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4547 checkStr( "32,31,30,", callbackData
.szTrace1
);
4548 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4549 checkStr( "35,34,", callbackData
.szTrace1
);
4551 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[3], idGroup
[0], 0,
4552 lpData
, dwDataSize
);
4553 checkHR( DP_OK
, hr
);
4554 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4555 checkStr( "32,31,30,", callbackData
.szTrace1
);
4556 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4557 checkStr( "", callbackData
.szTrace1
);
4559 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[3], idGroup
[1], 0,
4560 lpData
, dwDataSize
);
4561 checkHR( DP_OK
, hr
);
4562 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4563 checkStr( "", callbackData
.szTrace1
);
4564 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4565 checkStr( "34,", callbackData
.szTrace1
);
4567 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[3], idGroup
[2], 0,
4568 lpData
, dwDataSize
);
4569 checkHR( DP_OK
, hr
);
4570 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4571 checkStr( "", callbackData
.szTrace1
);
4572 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4573 checkStr( "35,34,", callbackData
.szTrace1
);
4576 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[5], DPID_ALLPLAYERS
, 0,
4577 lpData
, dwDataSize
);
4578 checkHR( DP_OK
, hr
);
4579 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4580 checkStr( "52,51,50,", callbackData
.szTrace1
);
4581 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4582 checkStr( "54,53,", callbackData
.szTrace1
);
4584 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[5], idGroup
[0], 0,
4585 lpData
, dwDataSize
);
4586 checkHR( DP_OK
, hr
);
4587 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4588 checkStr( "52,51,50,", callbackData
.szTrace1
);
4589 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4590 checkStr( "", callbackData
.szTrace1
);
4592 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[5], idGroup
[1], 0,
4593 lpData
, dwDataSize
);
4594 checkHR( DP_OK
, hr
);
4595 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4596 checkStr( "", callbackData
.szTrace1
);
4597 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4598 checkStr( "54,53,", callbackData
.szTrace1
);
4600 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[5], idGroup
[2], 0,
4601 lpData
, dwDataSize
);
4602 checkHR( DP_OK
, hr
);
4603 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4604 checkStr( "", callbackData
.szTrace1
);
4605 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4606 checkStr( "54,", callbackData
.szTrace1
);
4609 HeapFree( GetProcessHeap(), 0, lpData
);
4610 IDirectPlayX_Release( pDP
[0] );
4611 IDirectPlayX_Release( pDP
[1] );
4615 static void test_groups_cs(void)
4618 LPDIRECTPLAY4 pDP
[2];
4619 DPSESSIONDESC2 dpsd
;
4620 DPID idPlayer
[6], idGroup
[3];
4621 CallbackData callbackData
;
4625 DWORD dwDataSize
= 1024;
4626 LPVOID lpData
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, 1024 );
4631 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
4632 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
4634 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
4635 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
4636 dpsd
.guidApplication
= appGuid
;
4637 dpsd
.dwMaxPlayers
= 10;
4640 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
4641 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
4643 dpsd
.dwFlags
= DPSESSION_CLIENTSERVER
;
4644 hr
= IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
4645 todo_wine
checkHR( DP_OK
, hr
);
4647 hr
= IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
4648 (LPVOID
) pDP
[1], 0 );
4649 todo_wine
checkHR( DP_OK
, hr
);
4651 if ( hr
== DPERR_UNINITIALIZED
)
4653 skip( "dplay not implemented enough for this test yet\n" );
4658 /* Create players */
4659 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &idPlayer
[0],
4660 NULL
, NULL
, NULL
, 0, 0 );
4661 checkHR( DPERR_ACCESSDENIED
, hr
);
4662 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &idPlayer
[0],
4663 NULL
, NULL
, NULL
, 0,
4664 DPPLAYER_SERVERPLAYER
);
4665 checkHR( DP_OK
, hr
);
4666 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &idPlayer
[1],
4667 NULL
, NULL
, NULL
, 0, 0 );
4668 checkHR( DPERR_ACCESSDENIED
, hr
);
4669 hr
= IDirectPlayX_CreatePlayer( pDP
[1], &idPlayer
[1],
4670 NULL
, NULL
, NULL
, 0, 0 );
4671 checkHR( DP_OK
, hr
);
4672 hr
= IDirectPlayX_CreatePlayer( pDP
[1], &idPlayer
[2],
4673 NULL
, NULL
, NULL
, 0, 0 );
4674 checkHR( DP_OK
, hr
);
4675 hr
= IDirectPlayX_CreatePlayer( pDP
[1], &idPlayer
[3],
4676 NULL
, NULL
, NULL
, 0, 0 );
4677 checkHR( DP_OK
, hr
);
4678 hr
= IDirectPlayX_CreatePlayer( pDP
[1], &idPlayer
[4],
4679 NULL
, NULL
, NULL
, 0, 0 );
4680 checkHR( DP_OK
, hr
);
4681 hr
= IDirectPlayX_CreatePlayer( pDP
[1], &idPlayer
[5],
4682 NULL
, NULL
, NULL
, 0, 0 );
4683 checkHR( DP_OK
, hr
);
4685 hr
= IDirectPlayX_CreateGroup( pDP
[0], &idGroup
[0],
4687 checkHR( DP_OK
, hr
);
4688 hr
= IDirectPlayX_CreateGroup( pDP
[1], &idGroup
[2],
4690 checkHR( DP_OK
, hr
);
4691 hr
= IDirectPlayX_CreateGroupInGroup( pDP
[1], idGroup
[2], &idGroup
[1],
4693 checkHR( DP_OK
, hr
);
4697 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4698 checkStr( "S0,S0,S0,S0,S0,S0,", callbackData
.szTrace1
);
4699 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4700 checkStr( "S1," "S2,S1," "S3,S2,S1," "S4,S3,S2,S1,"
4701 "S5,S4,S3,S2,S1," "S5,S4,S3,S2,S1,", callbackData
.szTrace1
);
4704 * Player 0 | | pDP 0
4705 * Player 1 | Group 0 |
4707 * Player 3 | Group 1 ) |
4708 * Player 4 | | Group 2 | pDP 1
4713 hr
= IDirectPlayX_AddPlayerToGroup( pDP
[0], idGroup
[0], idPlayer
[0] );
4714 checkHR( DP_OK
, hr
);
4715 hr
= IDirectPlayX_AddPlayerToGroup( pDP
[0], idGroup
[0], idPlayer
[1] );
4716 checkHR( DP_OK
, hr
);
4717 hr
= IDirectPlayX_AddPlayerToGroup( pDP
[0], idGroup
[0], idPlayer
[2] );
4718 checkHR( DP_OK
, hr
);
4719 hr
= IDirectPlayX_AddPlayerToGroup( pDP
[1], idGroup
[1], idPlayer
[3] );
4720 checkHR( DP_OK
, hr
);
4721 hr
= IDirectPlayX_AddPlayerToGroup( pDP
[1], idGroup
[1], idPlayer
[4] );
4722 checkHR( DP_OK
, hr
);
4723 hr
= IDirectPlayX_AddPlayerToGroup( pDP
[1], idGroup
[2], idPlayer
[4] );
4724 checkHR( DP_OK
, hr
);
4725 hr
= IDirectPlayX_AddPlayerToGroup( pDP
[1], idGroup
[2], idPlayer
[5] );
4726 checkHR( DP_OK
, hr
);
4728 hr
= IDirectPlayX_AddGroupToGroup( pDP
[1], idGroup
[2], idGroup
[1] );
4729 checkHR( DP_OK
, hr
);
4732 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4733 checkStr( "S0,S0,S0,S0,", callbackData
.szTrace1
);
4734 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4735 checkStr( "S5," "S4,S3,S2,S1," "S5,S4,S3,S2,S1,"
4736 "S5,S4,S3,S2,S1," "S5,S4,S3,S2,S1,", callbackData
.szTrace1
);
4739 /* Sending broadcast messages, and checking who receives them */
4742 hr
= IDirectPlayX_Send( pDP
[0], idPlayer
[0], DPID_ALLPLAYERS
, 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( "05,04,03,02,01,", callbackData
.szTrace1
);
4751 hr
= IDirectPlayX_Send( pDP
[0], idPlayer
[0], idGroup
[0], 0,
4752 lpData
, dwDataSize
);
4753 checkHR( DP_OK
, hr
);
4754 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4755 checkStr( "", callbackData
.szTrace1
);
4756 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4757 checkStr( "02,01,", callbackData
.szTrace1
);
4759 hr
= IDirectPlayX_Send( pDP
[0], idPlayer
[0], idGroup
[1], 0,
4760 lpData
, dwDataSize
);
4761 checkHR( DPERR_INVALIDPARAMS
, hr
);
4762 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4763 checkStr( "", callbackData
.szTrace1
);
4764 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4765 checkStr( "", callbackData
.szTrace1
);
4767 hr
= IDirectPlayX_Send( pDP
[0], idPlayer
[0], idGroup
[2], 0,
4768 lpData
, dwDataSize
);
4769 checkHR( DPERR_INVALIDPARAMS
, hr
);
4770 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4771 checkStr( "", callbackData
.szTrace1
);
4772 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4773 checkStr( "", callbackData
.szTrace1
);
4776 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[3], DPID_ALLPLAYERS
, 0,
4777 lpData
, dwDataSize
);
4778 checkHR( DP_OK
, hr
);
4779 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4780 checkStr( "30,", callbackData
.szTrace1
);
4781 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4782 checkStr( "35,34,32,31,", callbackData
.szTrace1
);
4784 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[3], idGroup
[0], 0,
4785 lpData
, dwDataSize
);
4786 checkHR( DPERR_INVALIDPARAMS
, hr
);
4787 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4788 checkStr( "", callbackData
.szTrace1
);
4789 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4790 checkStr( "", callbackData
.szTrace1
);
4792 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[3], idGroup
[1], 0,
4793 lpData
, dwDataSize
);
4794 checkHR( DP_OK
, hr
);
4795 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4796 checkStr( "", callbackData
.szTrace1
);
4797 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4798 checkStr( "34,", callbackData
.szTrace1
);
4800 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[3], idGroup
[2], 0,
4801 lpData
, dwDataSize
);
4802 checkHR( DP_OK
, hr
);
4803 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4804 checkStr( "", callbackData
.szTrace1
);
4805 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4806 checkStr( "35,34,", callbackData
.szTrace1
);
4809 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[5], DPID_ALLPLAYERS
, 0,
4810 lpData
, dwDataSize
);
4811 checkHR( DP_OK
, hr
);
4812 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4813 checkStr( "50,", callbackData
.szTrace1
);
4814 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4815 checkStr( "54,53,52,51,", callbackData
.szTrace1
);
4817 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[5], idGroup
[0], 0,
4818 lpData
, dwDataSize
);
4819 checkHR( DPERR_INVALIDPARAMS
, hr
);
4820 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4821 checkStr( "", callbackData
.szTrace1
);
4822 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4823 checkStr( "", callbackData
.szTrace1
);
4825 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[5], idGroup
[1], 0,
4826 lpData
, dwDataSize
);
4827 checkHR( DP_OK
, hr
);
4828 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4829 checkStr( "", callbackData
.szTrace1
);
4830 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4831 checkStr( "54,53,", callbackData
.szTrace1
);
4833 hr
= IDirectPlayX_Send( pDP
[1], idPlayer
[5], idGroup
[2], 0,
4834 lpData
, dwDataSize
);
4835 checkHR( DP_OK
, hr
);
4836 check_messages( pDP
[0], idPlayer
, 6, &callbackData
);
4837 checkStr( "", callbackData
.szTrace1
);
4838 check_messages( pDP
[1], idPlayer
, 6, &callbackData
);
4839 checkStr( "54,", callbackData
.szTrace1
);
4842 HeapFree( GetProcessHeap(), 0, lpData
);
4843 IDirectPlayX_Release( pDP
[0] );
4844 IDirectPlayX_Release( pDP
[1] );
4850 static void test_Send(void)
4853 LPDIRECTPLAY4 pDP
[2];
4854 DPSESSIONDESC2 dpsd
;
4855 DPID dpid
[4], idFrom
, idTo
;
4856 CallbackData callbackData
;
4858 LPCSTR message
= "message";
4859 DWORD messageSize
= strlen(message
) + 1;
4860 DWORD dwDataSize
= 1024;
4861 LPDPMSG_GENERIC lpData
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, dwDataSize
);
4862 LPDPMSG_SECUREMESSAGE lpDataSecure
;
4868 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
4869 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
4871 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
4874 /* Uninitialized service provider */
4875 hr
= IDirectPlayX_Send( pDP
[0], 0, 0, 0,
4876 (LPVOID
) message
, messageSize
);
4877 checkHR( DPERR_UNINITIALIZED
, hr
);
4880 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
4881 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
4883 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
4884 dpsd
.guidApplication
= appGuid
;
4885 dpsd
.dwMaxPlayers
= 10;
4886 IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
4887 IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
4888 (LPVOID
) pDP
[1], 0 );
4889 IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
4892 /* Incorrect players */
4893 hr
= IDirectPlayX_Send( pDP
[0], 0, 1, 2,
4894 (LPVOID
) message
, messageSize
);
4895 todo_wine
checkHR( DPERR_INVALIDPLAYER
, hr
);
4897 if ( hr
== DPERR_UNINITIALIZED
)
4899 skip( "Send not implemented\n" );
4904 IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[0], NULL
, NULL
, NULL
, 0, 0 );
4905 IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[1], NULL
, NULL
, NULL
, 0, 0 );
4906 IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[2], NULL
, NULL
, NULL
, 0, 0 );
4907 IDirectPlayX_CreatePlayer( pDP
[1], &dpid
[3], NULL
, NULL
, NULL
, 0, 0 );
4909 /* Purge player creation messages */
4910 check_messages( pDP
[0], dpid
, 4, &callbackData
);
4911 checkStr( "S0," "S1,S0," "S2,S1,S0,", callbackData
.szTrace1
);
4912 check_messages( pDP
[1], dpid
, 4, &callbackData
);
4913 checkStr( "", callbackData
.szTrace1
);
4916 /* Message to self: no error, but no message is sent */
4917 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[0], 0,
4918 (LPVOID
) message
, messageSize
);
4919 checkHR( DP_OK
, hr
);
4921 /* Send a message from a remote player */
4922 hr
= IDirectPlayX_Send( pDP
[1], dpid
[0], dpid
[1], 0,
4923 (LPVOID
) message
, messageSize
);
4924 checkHR( DPERR_ACCESSDENIED
, hr
);
4925 hr
= IDirectPlayX_Send( pDP
[1], dpid
[0], dpid
[3], 0,
4926 (LPVOID
) message
, messageSize
);
4927 checkHR( DPERR_ACCESSDENIED
, hr
);
4930 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1], 0,
4931 NULL
, messageSize
);
4932 checkHR( DPERR_INVALIDPARAMS
, hr
);
4933 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1], 0,
4934 (LPVOID
) message
, 0 );
4935 checkHR( DPERR_INVALIDPARAMS
, hr
);
4938 /* Checking no message was sent */
4939 check_messages( pDP
[0], dpid
, 4, &callbackData
);
4940 checkStr( "", callbackData
.szTrace1
);
4941 check_messages( pDP
[1], dpid
, 4, &callbackData
);
4942 checkStr( "", callbackData
.szTrace1
);
4945 /* Regular parameters */
4946 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
4948 (LPVOID
) message
, messageSize
);
4949 checkHR( DP_OK
, hr
);
4951 hr
= IDirectPlayX_Receive( pDP
[0], &dpid
[0], &dpid
[1],
4952 DPRECEIVE_FROMPLAYER
| DPRECEIVE_TOPLAYER
,
4953 (LPVOID
) lpData
, &dwDataSize
);
4954 checkHR( DP_OK
, hr
);
4955 checkStr( message
, (LPSTR
) lpData
);
4956 check( strlen(message
)+1, dwDataSize
);
4958 check_messages( pDP
[0], dpid
, 4, &callbackData
);
4959 checkStr( "", callbackData
.szTrace1
);
4960 check_messages( pDP
[1], dpid
, 4, &callbackData
);
4961 checkStr( "", callbackData
.szTrace1
);
4964 /* Message to a remote player */
4965 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[3], 0,
4966 (LPVOID
) message
, messageSize
);
4967 checkHR( DP_OK
, hr
);
4969 hr
= IDirectPlayX_Receive( pDP
[0], &dpid
[0], &dpid
[3],
4970 DPRECEIVE_FROMPLAYER
| DPRECEIVE_TOPLAYER
,
4971 (LPVOID
) lpData
, &dwDataSize
);
4972 checkHR( DPERR_NOMESSAGES
, hr
);
4973 hr
= IDirectPlayX_Receive( pDP
[1], &dpid
[0], &dpid
[3],
4974 DPRECEIVE_FROMPLAYER
| DPRECEIVE_TOPLAYER
,
4975 (LPVOID
) lpData
, &dwDataSize
);
4976 checkHR( DP_OK
, hr
);
4977 checkStr( message
, (LPSTR
) lpData
);
4978 check( strlen(message
)+1, dwDataSize
);
4980 check_messages( pDP
[0], dpid
, 4, &callbackData
);
4981 checkStr( "", callbackData
.szTrace1
);
4982 check_messages( pDP
[1], dpid
, 4, &callbackData
);
4983 checkStr( "", callbackData
.szTrace1
);
4988 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], DPID_ALLPLAYERS
, 0,
4989 (LPVOID
) message
, messageSize
);
4990 checkHR( DP_OK
, hr
);
4994 hr
= IDirectPlayX_Receive( pDP
[0], &dpid
[0], &dpid
[i
],
4995 DPRECEIVE_FROMPLAYER
| DPRECEIVE_TOPLAYER
,
4996 (LPVOID
) lpData
, &dwDataSize
);
4997 checkHR( DP_OK
, hr
);
4998 checkStr( message
, (LPSTR
) lpData
);
5000 hr
= IDirectPlayX_Receive( pDP
[1], &dpid
[0], &dpid
[3],
5001 DPRECEIVE_FROMPLAYER
| DPRECEIVE_TOPLAYER
,
5002 (LPVOID
) lpData
, &dwDataSize
);
5003 checkHR( DP_OK
, hr
);
5004 checkStr( message
, (LPSTR
) lpData
);
5006 check_messages( pDP
[0], dpid
, 4, &callbackData
);
5007 checkStr( "", callbackData
.szTrace1
);
5008 check_messages( pDP
[1], dpid
, 4, &callbackData
);
5009 checkStr( "", callbackData
.szTrace1
);
5012 hr
= IDirectPlayX_Send( pDP
[0], DPID_ALLPLAYERS
, dpid
[1],
5014 (LPVOID
) message
, messageSize
);
5015 checkHR( DPERR_INVALIDPLAYER
, hr
);
5016 hr
= IDirectPlayX_Send( pDP
[0], DPID_ALLPLAYERS
, DPID_ALLPLAYERS
,
5018 (LPVOID
) message
, messageSize
);
5019 checkHR( DPERR_INVALIDPLAYER
, hr
);
5023 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5025 (LPVOID
) message
, messageSize
);
5026 checkHR( DP_OK
, hr
);
5028 hr
= IDirectPlayX_Receive( pDP
[0], &dpid
[0], &dpid
[1],
5029 DPRECEIVE_FROMPLAYER
| DPRECEIVE_TOPLAYER
,
5030 lpData
, &dwDataSize
);
5031 checkHR( DP_OK
, hr
);
5032 checkStr( message
, (LPSTR
)lpData
);
5034 /* - Inorrect flags */
5035 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5037 (LPVOID
) message
, messageSize
);
5038 checkHR( DPERR_INVALIDPARAMS
, hr
);
5039 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5041 (LPVOID
) message
, messageSize
);
5042 checkHR( DPERR_INVALIDPARAMS
, hr
);
5043 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5044 DPSEND_ENCRYPTED
| DPSEND_SIGNED
,
5045 (LPVOID
) message
, messageSize
);
5046 checkHR( DPERR_INVALIDPARAMS
, hr
);
5048 /* - Correct flags, but session is not secure */
5049 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5050 DPSEND_ENCRYPTED
| DPSEND_GUARANTEED
,
5051 (LPVOID
) message
, messageSize
);
5052 checkHR( DPERR_INVALIDPARAMS
, hr
);
5053 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5054 DPSEND_SIGNED
| DPSEND_GUARANTEED
,
5055 (LPVOID
) message
, messageSize
);
5056 checkHR( DPERR_INVALIDPARAMS
, hr
);
5057 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5058 ( DPSEND_ENCRYPTED
|
5060 DPSEND_GUARANTEED
),
5061 (LPVOID
) message
, messageSize
);
5062 checkHR( DPERR_INVALIDPARAMS
, hr
);
5064 /* - Corerct flags, secure session incorrectly opened (without flags) */
5065 hr
= IDirectPlayX_Close( pDP
[0] );
5066 checkHR( DP_OK
, hr
);
5069 hr
= IDirectPlayX_SecureOpen( pDP
[0], &dpsd
, DPOPEN_CREATE
, NULL
, NULL
);
5070 checkHR( DP_OK
, hr
);
5072 IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[i
], NULL
, NULL
, NULL
, 0, 0 );
5074 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5075 DPSEND_ENCRYPTED
| DPSEND_GUARANTEED
,
5076 (LPVOID
) message
, messageSize
);
5077 checkHR( DPERR_INVALIDPARAMS
, hr
);
5078 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5079 DPSEND_SIGNED
| DPSEND_GUARANTEED
,
5080 (LPVOID
) message
, messageSize
);
5081 checkHR( DPERR_INVALIDPARAMS
, hr
);
5082 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5083 ( DPSEND_ENCRYPTED
|
5085 DPSEND_GUARANTEED
),
5086 (LPVOID
) message
, messageSize
);
5087 checkHR( DPERR_INVALIDPARAMS
, hr
);
5089 /* - Correct flags, secure session */
5090 hr
= IDirectPlayX_Close( pDP
[0] );
5091 checkHR( DP_OK
, hr
);
5093 dpsd
.dwFlags
= DPSESSION_SECURESERVER
;
5094 hr
= IDirectPlayX_SecureOpen( pDP
[0], &dpsd
, DPOPEN_CREATE
, NULL
, NULL
);
5095 checkHR( DP_OK
, hr
);
5096 IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[0], NULL
, NULL
, NULL
, 0, 0 );
5097 IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[1], NULL
, NULL
, NULL
, 0, 0 );
5100 check_messages( pDP
[0], dpid
, 6, &callbackData
);
5101 checkStr( "S0,", callbackData
.szTrace1
);
5104 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5105 DPSEND_ENCRYPTED
| DPSEND_GUARANTEED
,
5106 (LPVOID
) message
, messageSize
);
5107 checkHR( DP_OK
, hr
);
5108 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5109 DPSEND_SIGNED
| DPSEND_GUARANTEED
,
5110 (LPVOID
) message
, messageSize
);
5111 checkHR( DP_OK
, hr
);
5112 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5113 ( DPSEND_ENCRYPTED
|
5115 DPSEND_GUARANTEED
),
5116 (LPVOID
) message
, messageSize
);
5117 checkHR( DP_OK
, hr
);
5123 hr
= IDirectPlayX_Receive( pDP
[0], &idFrom
, &idTo
, 0,
5124 (LPVOID
) lpData
, &dwDataSize
);
5126 lpDataSecure
= (LPDPMSG_SECUREMESSAGE
) lpData
;
5128 checkHR( DP_OK
, hr
);
5129 checkConv( DPSYS_SECUREMESSAGE
, lpData
->dwType
, dpMsgType2str
);
5130 check( DPID_SYSMSG
, idFrom
);
5131 check( dpid
[1], idTo
);
5132 check( dpid
[0], lpDataSecure
->dpIdFrom
);
5133 checkStr( message
, (LPSTR
) lpDataSecure
->lpData
);
5134 check( strlen(message
)+1, lpDataSecure
->dwDataSize
);
5139 checkFlags( DPSEND_ENCRYPTED
,
5140 lpDataSecure
->dwFlags
,
5144 checkFlags( DPSEND_SIGNED
,
5145 lpDataSecure
->dwFlags
,
5149 checkFlags( DPSEND_SIGNED
| DPSEND_ENCRYPTED
,
5150 lpDataSecure
->dwFlags
,
5156 check_messages( pDP
[0], dpid
, 4, &callbackData
);
5157 checkStr( "", callbackData
.szTrace1
);
5160 /* - Even in a secure session, incorrect flags still not working */
5161 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5163 (LPVOID
) message
, messageSize
);
5164 checkHR( DPERR_INVALIDPARAMS
, hr
);
5165 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5167 (LPVOID
) message
, messageSize
);
5168 checkHR( DPERR_INVALIDPARAMS
, hr
);
5169 hr
= IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1],
5170 DPSEND_ENCRYPTED
| DPSEND_SIGNED
,
5171 (LPVOID
) message
, messageSize
);
5172 checkHR( DPERR_INVALIDPARAMS
, hr
);
5175 HeapFree( GetProcessHeap(), 0, lpData
);
5176 IDirectPlayX_Release( pDP
[0] );
5177 IDirectPlayX_Release( pDP
[1] );
5183 static void test_Receive(void)
5187 DPSESSIONDESC2 dpsd
;
5188 DPID dpid
[4], idFrom
, idTo
;
5190 LPCSTR message
= "message";
5191 DWORD messageSize
= strlen(message
) + 1;
5192 DWORD dwDataSize
= 1024;
5193 LPDPMSG_GENERIC lpData
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
5195 LPDPMSG_CREATEPLAYERORGROUP lpDataCreate
;
5196 LPDPMSG_DESTROYPLAYERORGROUP lpDataDestroy
;
5202 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
5203 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
5205 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
5206 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
5207 dpsd
.guidApplication
= appGuid
;
5209 init_TCPIP_provider( pDP
, "127.0.0.1", 0 );
5211 IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_CREATE
);
5214 /* Invalid parameters */
5215 hr
= IDirectPlayX_Receive( pDP
, NULL
, &idTo
, 0,
5216 lpData
, &dwDataSize
);
5217 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
5219 if ( hr
== DPERR_UNINITIALIZED
)
5221 skip( "Receive not implemented\n" );
5225 hr
= IDirectPlayX_Receive( pDP
, &idFrom
, NULL
, 0,
5226 lpData
, &dwDataSize
);
5227 checkHR( DPERR_INVALIDPARAMS
, hr
);
5228 hr
= IDirectPlayX_Receive( pDP
, &idFrom
, &idTo
, 0,
5230 checkHR( DPERR_INVALIDPARAMS
, hr
);
5232 hr
= IDirectPlayX_Receive( pDP
, &idFrom
, &idTo
, 0,
5233 lpData
, &dwDataSize
);
5234 checkHR( DPERR_INVALIDPARAMS
, hr
);
5236 /* No messages yet */
5237 hr
= IDirectPlayX_Receive( pDP
, &idFrom
, &idTo
, 0,
5238 NULL
, &dwDataSize
);
5239 checkHR( DPERR_NOMESSAGES
, hr
);
5241 hr
= IDirectPlayX_Receive( pDP
, &idFrom
, &idTo
, 0,
5242 lpData
, &dwDataSize
);
5243 checkHR( DPERR_NOMESSAGES
, hr
);
5246 IDirectPlayX_CreatePlayer( pDP
, &dpid
[0], NULL
, 0, NULL
, 0, 0 );
5247 IDirectPlayX_CreatePlayer( pDP
, &dpid
[1], NULL
, 0, NULL
, 0,
5248 DPPLAYER_SPECTATOR
);
5249 IDirectPlayX_CreatePlayer( pDP
, &dpid
[2], NULL
, 0, NULL
, 0, 0 );
5250 IDirectPlayX_CreatePlayer( pDP
, &dpid
[3], NULL
, 0, NULL
, 0, 0 );
5257 IDirectPlayX_GetMessageCount( pDP
, dpid
[i
], &dwCount
);
5258 check( 3-i
, dwCount
);
5262 IDirectPlayX_DestroyPlayer( pDP
, dpid
[3] );
5263 IDirectPlayX_DestroyPlayer( pDP
, dpid
[1] );
5268 IDirectPlayX_GetMessageCount( pDP
, dpid
[0], &dwCount
);
5269 check( 5, dwCount
);
5270 IDirectPlayX_GetMessageCount( pDP
, dpid
[1], &dwCount
);
5271 check( 5, dwCount
);
5272 IDirectPlayX_GetMessageCount( pDP
, dpid
[2], &dwCount
);
5273 check( 3, dwCount
);
5274 IDirectPlayX_GetMessageCount( pDP
, dpid
[3], &dwCount
);
5275 check( 3, dwCount
);
5278 /* Buffer too small */
5279 hr
= IDirectPlayX_Receive( pDP
, &idFrom
, &idFrom
, 0,
5280 NULL
, &dwDataSize
);
5281 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
5282 check( 48, dwDataSize
);
5284 hr
= IDirectPlayX_Receive( pDP
, &idTo
, &idFrom
, 0,
5285 lpData
, &dwDataSize
);
5286 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
5287 check( 48, dwDataSize
);
5290 /* Checking the order or reception */
5291 for (i
=0; i
<11; i
++)
5294 hr
= IDirectPlayX_Receive( pDP
, &idFrom
, &idTo
, 0,
5295 lpData
, &dwDataSize
);
5297 checkHR( DP_OK
, hr
);
5298 check( DPID_SYSMSG
, idFrom
);
5300 if (i
<6) /* Player creation */
5302 checkConv( DPSYS_CREATEPLAYERORGROUP
, lpData
->dwType
, dpMsgType2str
);
5303 check( 48, dwDataSize
);
5304 lpDataCreate
= (LPDPMSG_CREATEPLAYERORGROUP
) lpData
;
5305 check( DPPLAYERTYPE_PLAYER
, lpDataCreate
->dwPlayerType
);
5306 checkLP( NULL
, lpDataCreate
->lpData
);
5307 check( 0, lpDataCreate
->dwDataSize
);
5308 checkLP( NULL
, lpDataCreate
->dpnName
.lpszShortNameA
);
5309 check( 0, lpDataCreate
->dpIdParent
);
5311 else /* Player destruction */
5313 checkConv( DPSYS_DESTROYPLAYERORGROUP
, lpData
->dwType
,
5315 check( 52, dwDataSize
);
5316 lpDataDestroy
= (LPDPMSG_DESTROYPLAYERORGROUP
) lpData
;
5317 check( DPPLAYERTYPE_PLAYER
, lpDataDestroy
->dwPlayerType
);
5318 checkLP( NULL
, lpDataDestroy
->lpLocalData
);
5319 check( 0, lpDataDestroy
->dwLocalDataSize
);
5320 checkLP( NULL
, lpDataDestroy
->lpRemoteData
);
5321 check( 0, lpDataDestroy
->dwRemoteDataSize
);
5322 checkLP( NULL
, lpDataDestroy
->dpnName
.lpszShortNameA
);
5323 check( 0, lpDataDestroy
->dpIdParent
);
5330 lpDataCreate
= (LPDPMSG_CREATEPLAYERORGROUP
) lpData
;
5331 check( dpid
[0], idTo
);
5332 check( dpid
[1], lpDataCreate
->dpId
);
5333 check( 1, lpDataCreate
->dwCurrentPlayers
);
5334 checkFlags( DPPLAYER_LOCAL
|DPPLAYER_SPECTATOR
, lpDataCreate
->dwFlags
,
5335 FLAGS_DPPLAYER
|FLAGS_DPGROUP
);
5340 check( dpid
[1], idTo
);
5341 lpDataCreate
= (LPDPMSG_CREATEPLAYERORGROUP
) lpData
;
5342 check( dpid
[2], lpDataCreate
->dpId
);
5343 check( 2, lpDataCreate
->dwCurrentPlayers
);
5344 checkFlags( DPPLAYER_LOCAL
, lpDataCreate
->dwFlags
,
5345 FLAGS_DPPLAYER
| FLAGS_DPGROUP
);
5348 check( dpid
[0], idTo
);
5349 lpDataCreate
= (LPDPMSG_CREATEPLAYERORGROUP
) lpData
;
5350 check( dpid
[2], lpDataCreate
->dpId
);
5351 check( 2, lpDataCreate
->dwCurrentPlayers
);
5352 checkFlags( DPPLAYER_LOCAL
, lpDataCreate
->dwFlags
,
5353 FLAGS_DPPLAYER
| FLAGS_DPGROUP
);
5358 check( dpid
[2], idTo
);
5359 lpDataCreate
= (LPDPMSG_CREATEPLAYERORGROUP
) lpData
;
5360 check( dpid
[3], lpDataCreate
->dpId
);
5361 check( 3, lpDataCreate
->dwCurrentPlayers
);
5362 checkFlags( DPPLAYER_LOCAL
, lpDataCreate
->dwFlags
,
5363 FLAGS_DPPLAYER
| FLAGS_DPGROUP
);
5366 check( dpid
[1], idTo
);
5367 lpDataCreate
= (LPDPMSG_CREATEPLAYERORGROUP
) lpData
;
5368 check( dpid
[3], lpDataCreate
->dpId
);
5369 check( 3, lpDataCreate
->dwCurrentPlayers
);
5370 checkFlags( DPPLAYER_LOCAL
, lpDataCreate
->dwFlags
,
5371 FLAGS_DPPLAYER
| FLAGS_DPGROUP
);
5374 check( dpid
[0], idTo
);
5375 lpDataCreate
= (LPDPMSG_CREATEPLAYERORGROUP
) lpData
;
5376 check( dpid
[3], lpDataCreate
->dpId
);
5377 check( 3, lpDataCreate
->dwCurrentPlayers
);
5378 checkFlags( DPPLAYER_LOCAL
, lpDataCreate
->dwFlags
,
5379 FLAGS_DPPLAYER
| FLAGS_DPGROUP
);
5384 check( dpid
[2], idTo
);
5385 lpDataDestroy
= (LPDPMSG_DESTROYPLAYERORGROUP
) lpData
;
5386 check( dpid
[3], lpDataDestroy
->dpId
);
5387 checkFlags( DPPLAYER_LOCAL
, lpDataDestroy
->dwFlags
,
5388 FLAGS_DPPLAYER
| FLAGS_DPGROUP
);
5391 check( dpid
[1], idTo
);
5392 lpDataDestroy
= (LPDPMSG_DESTROYPLAYERORGROUP
) lpData
;
5393 check( dpid
[3], lpDataDestroy
->dpId
);
5394 checkFlags( DPPLAYER_LOCAL
, lpDataDestroy
->dwFlags
,
5395 FLAGS_DPPLAYER
| FLAGS_DPGROUP
);
5398 check( dpid
[0], idTo
);
5399 lpDataDestroy
= (LPDPMSG_DESTROYPLAYERORGROUP
) lpData
;
5400 check( dpid
[3], lpDataDestroy
->dpId
);
5401 checkFlags( DPPLAYER_LOCAL
, lpDataDestroy
->dwFlags
,
5402 FLAGS_DPPLAYER
| FLAGS_DPGROUP
);
5407 check( dpid
[2], idTo
);
5408 lpDataDestroy
= (LPDPMSG_DESTROYPLAYERORGROUP
) lpData
;
5409 check( dpid
[1], lpDataDestroy
->dpId
);
5410 checkFlags( DPPLAYER_LOCAL
|
5411 DPPLAYER_SPECTATOR
, lpDataDestroy
->dwFlags
,
5412 FLAGS_DPPLAYER
| FLAGS_DPGROUP
);
5415 check( dpid
[0], idTo
);
5416 lpDataDestroy
= (LPDPMSG_DESTROYPLAYERORGROUP
) lpData
;
5417 check( dpid
[1], lpDataDestroy
->dpId
);
5418 checkFlags( DPPLAYER_LOCAL
|
5419 DPPLAYER_SPECTATOR
, lpDataDestroy
->dwFlags
,
5420 FLAGS_DPPLAYER
| FLAGS_DPGROUP
);
5424 trace( "%s\n", dpMsgType2str(lpData
->dwType
) );
5429 hr
= IDirectPlayX_Receive( pDP
, &idFrom
, &idTo
, 0, lpData
, &dwDataSize
);
5430 checkHR( DPERR_NOMESSAGES
, hr
);
5433 /* New data message */
5434 hr
= IDirectPlayX_Send( pDP
, dpid
[0], dpid
[2], 0,
5435 (LPVOID
) message
, messageSize
);
5436 checkHR( DP_OK
, hr
);
5439 /* Ensuring DPRECEIVE_PEEK doesn't remove the messages from the queue */
5440 for (i
=0; i
<10; i
++)
5442 hr
= IDirectPlayX_Receive( pDP
, &idFrom
, &idTo
, DPRECEIVE_PEEK
,
5443 lpData
, &dwDataSize
);
5444 checkStr( message
, (LPSTR
) lpData
);
5447 /* Removing the message from the queue */
5448 hr
= IDirectPlayX_Receive( pDP
, &idFrom
, &idTo
, 0, lpData
, &dwDataSize
);
5449 checkHR( DP_OK
, hr
);
5450 check( idFrom
, dpid
[0] );
5451 check( idTo
, dpid
[2] );
5452 checkStr( message
, (LPSTR
) lpData
);
5454 hr
= IDirectPlayX_Receive( pDP
, &idFrom
, &idTo
, 0, lpData
, &dwDataSize
);
5455 checkHR( DPERR_NOMESSAGES
, hr
);
5458 HeapFree( GetProcessHeap(), 0, lpData
);
5459 IDirectPlayX_Release( pDP
);
5463 /* GetMessageCount */
5465 static void test_GetMessageCount(void)
5468 LPDIRECTPLAY4 pDP
[2];
5469 DPSESSIONDESC2 dpsd
;
5475 DWORD dwDataSize
= 1024;
5476 LPVOID lpData
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, dwDataSize
);
5477 CallbackData callbackData
;
5482 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
5483 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
5485 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
5488 hr
= IDirectPlayX_GetMessageCount( pDP
[0], 0, &dwCount
);
5489 todo_wine
checkHR( DPERR_UNINITIALIZED
, hr
);
5490 check( -1, dwCount
);
5494 skip( "GetMessageCount not implemented\n" );
5499 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
5500 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
5504 hr
= IDirectPlayX_GetMessageCount( pDP
[0], 0, &dwCount
);
5505 checkHR( DP_OK
, hr
);
5506 check( 0, dwCount
);
5509 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
5510 dpsd
.guidApplication
= appGuid
;
5511 dpsd
.dwMaxPlayers
= 10;
5512 IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
5513 IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
5514 (LPVOID
) pDP
[1], 0 );
5516 IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[0], NULL
, NULL
, NULL
, 0, 0 );
5517 IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[1], NULL
, NULL
, NULL
, 0, 0 );
5518 IDirectPlayX_CreatePlayer( pDP
[1], &dpid
[3], NULL
, NULL
, NULL
, 0, 0 );
5519 IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[2], NULL
, NULL
, NULL
, 0, 0 );
5522 /* Incorrect parameters */
5524 hr
= IDirectPlayX_GetMessageCount( pDP
[0], dpid
[0], NULL
);
5525 checkHR( DPERR_INVALIDPARAMS
, hr
);
5526 check( -1, dwCount
);
5529 hr
= IDirectPlayX_GetMessageCount( pDP
[0], 0, NULL
);
5530 checkHR( DPERR_INVALIDPARAMS
, hr
);
5531 check( -1, dwCount
);
5534 hr
= IDirectPlayX_GetMessageCount( pDP
[0], -1, &dwCount
);
5535 checkHR( DPERR_INVALIDPLAYER
, hr
);
5536 check( -1, dwCount
);
5539 /* Correct parameters */
5540 /* Player creation messages */
5542 hr
= IDirectPlayX_GetMessageCount( pDP
[0], 0, &dwCount
);
5543 checkHR( DP_OK
, hr
);
5544 check( 5, dwCount
);
5547 hr
= IDirectPlayX_GetMessageCount( pDP
[1], 0, &dwCount
);
5548 checkHR( DP_OK
, hr
);
5549 check( 1, dwCount
);
5552 hr
= IDirectPlayX_GetMessageCount( pDP
[0], dpid
[0], &dwCount
);
5553 checkHR( DP_OK
, hr
);
5554 check( 3, dwCount
);
5557 hr
= IDirectPlayX_GetMessageCount( pDP
[0], dpid
[1], &dwCount
);
5558 checkHR( DP_OK
, hr
);
5559 check( 2, dwCount
);
5562 hr
= IDirectPlayX_GetMessageCount( pDP
[0], dpid
[3], &dwCount
);
5563 checkHR( DP_OK
, hr
);
5564 /* Remote player: doesn't throw error but result is 0 and not 1 */
5565 check( 0, dwCount
);
5568 hr
= IDirectPlayX_GetMessageCount( pDP
[1], dpid
[3], &dwCount
);
5569 checkHR( DP_OK
, hr
);
5570 check( 1, dwCount
);
5573 hr
= IDirectPlayX_GetMessageCount( pDP
[0], dpid
[1], &dwCount
);
5574 checkHR( DP_OK
, hr
);
5575 check( 2, dwCount
);
5579 check_messages( pDP
[0], dpid
, 6, &callbackData
);
5580 checkStr( "S0,S1,S0,S1,S0,", callbackData
.szTrace1
);
5581 check_messages( pDP
[1], dpid
, 6, &callbackData
);
5582 checkStr( "S3,", callbackData
.szTrace1
);
5585 /* Ensure queues is purged */
5587 hr
= IDirectPlayX_GetMessageCount( pDP
[0], 0, &dwCount
);
5588 checkHR( DP_OK
, hr
);
5589 check( 0, dwCount
);
5592 hr
= IDirectPlayX_GetMessageCount( pDP
[1], 0, &dwCount
);
5593 checkHR( DP_OK
, hr
);
5594 check( 0, dwCount
);
5597 /* Send data messages */
5599 IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1], 0, lpData
, dwDataSize
);
5601 IDirectPlayX_Send( pDP
[0], dpid
[1], dpid
[2], 0, lpData
, dwDataSize
);
5603 IDirectPlayX_Send( pDP
[0], dpid
[2], dpid
[3], 0, lpData
, dwDataSize
);
5606 /* Check all messages are in the queues */
5608 hr
= IDirectPlayX_GetMessageCount( pDP
[0], 0, &dwCount
);
5609 checkHR( DP_OK
, hr
);
5610 check( 11, dwCount
);
5613 hr
= IDirectPlayX_GetMessageCount( pDP
[1], 0, &dwCount
);
5614 checkHR( DP_OK
, hr
);
5615 check( 7, dwCount
);
5618 hr
= IDirectPlayX_GetMessageCount( pDP
[0], dpid
[0], &dwCount
);
5619 checkHR( DP_OK
, hr
);
5620 check( 0, dwCount
);
5623 hr
= IDirectPlayX_GetMessageCount( pDP
[0], dpid
[1], &dwCount
);
5624 checkHR( DP_OK
, hr
);
5625 check( 5, dwCount
);
5628 hr
= IDirectPlayX_GetMessageCount( pDP
[0], dpid
[2], &dwCount
);
5629 checkHR( DP_OK
, hr
);
5630 check( 6, dwCount
);
5633 hr
= IDirectPlayX_GetMessageCount( pDP
[1], dpid
[3], &dwCount
);
5634 checkHR( DP_OK
, hr
);
5635 check( 7, dwCount
);
5638 /* Purge queues again */
5639 check_messages( pDP
[0], dpid
, 6, &callbackData
);
5640 checkStr( "01,01,01,01,01,"
5641 "12,12,12,12,12,12,", callbackData
.szTrace1
);
5642 check_messages( pDP
[1], dpid
, 6, &callbackData
);
5643 checkStr( "23,23,23,23,23,23,23,", callbackData
.szTrace1
);
5646 /* Check queues are purged */
5648 hr
= IDirectPlayX_GetMessageCount( pDP
[0], 0, &dwCount
);
5649 checkHR( DP_OK
, hr
);
5650 check( 0, dwCount
);
5653 hr
= IDirectPlayX_GetMessageCount( pDP
[1], 0, &dwCount
);
5654 checkHR( DP_OK
, hr
);
5655 check( 0, dwCount
);
5658 hr
= IDirectPlayX_GetMessageCount( pDP
[0], dpid
[0], &dwCount
);
5659 checkHR( DP_OK
, hr
);
5660 check( 0, dwCount
);
5663 hr
= IDirectPlayX_GetMessageCount( pDP
[0], dpid
[1], &dwCount
);
5664 checkHR( DP_OK
, hr
);
5665 check( 0, dwCount
);
5668 hr
= IDirectPlayX_GetMessageCount( pDP
[0], dpid
[2], &dwCount
);
5669 checkHR( DP_OK
, hr
);
5670 check( 0, dwCount
);
5673 hr
= IDirectPlayX_GetMessageCount( pDP
[1], dpid
[3], &dwCount
);
5674 checkHR( DP_OK
, hr
);
5675 check( 0, dwCount
);
5678 HeapFree( GetProcessHeap(), 0, lpData
);
5679 IDirectPlayX_Release( pDP
[0] );
5680 IDirectPlayX_Release( pDP
[1] );
5684 /* GetMessageQueue */
5686 static void test_GetMessageQueue(void)
5689 LPDIRECTPLAY4 pDP
[2];
5690 DPSESSIONDESC2 dpsd
;
5692 CallbackData callbackData
;
5695 DWORD dwNumMsgs
, dwNumBytes
;
5697 DWORD dwDataSize
= 1024;
5698 LPVOID lpData
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, dwDataSize
);
5703 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
5704 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
5706 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
5709 dwNumMsgs
= dwNumBytes
= -1;
5710 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], 0, 0, 0,
5711 &dwNumMsgs
, &dwNumBytes
);
5712 todo_wine
checkHR( DPERR_UNINITIALIZED
, hr
);
5713 check( -1, dwNumMsgs
);
5714 check( -1, dwNumBytes
);
5718 skip( "GetMessageQueue not implemented\n" );
5723 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
5724 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
5727 dwNumMsgs
= dwNumBytes
= -1;
5728 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], 0, 0, 0,
5729 &dwNumMsgs
, &dwNumBytes
);
5730 checkHR( DP_OK
, hr
);
5731 check( 0, dwNumMsgs
);
5732 check( 0, dwNumBytes
);
5735 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
5736 dpsd
.guidApplication
= appGuid
;
5737 dpsd
.dwMaxPlayers
= 10;
5738 IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
5739 IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
5740 (LPVOID
) pDP
[1], 0 );
5742 IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[0], NULL
, NULL
, NULL
, 0, 0 );
5743 IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[1], NULL
, NULL
, NULL
, 0, 0 );
5744 IDirectPlayX_CreatePlayer( pDP
[1], &dpid
[3], NULL
, NULL
, NULL
, 0, 0 );
5745 IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[2], NULL
, NULL
, NULL
, 0, 0 );
5749 /* Incorrect parameters */
5750 dwNumMsgs
= dwNumBytes
= -1;
5751 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], -1, dpid
[1],
5753 &dwNumMsgs
, &dwNumBytes
);
5754 checkHR( DPERR_INVALIDPLAYER
, hr
);
5755 check( -1, dwNumMsgs
);
5756 check( -1, dwNumBytes
);
5758 dwNumMsgs
= dwNumBytes
= -1;
5759 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], dpid
[0], -1,
5761 &dwNumMsgs
, &dwNumBytes
);
5762 checkHR( DPERR_INVALIDPLAYER
, hr
);
5763 check( -1, dwNumMsgs
);
5764 check( -1, dwNumBytes
);
5766 dwNumMsgs
= dwNumBytes
= -1;
5767 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], dpid
[0], dpid
[0],
5769 &dwNumMsgs
, &dwNumBytes
);
5770 checkHR( DPERR_INVALIDFLAGS
, hr
);
5771 check( -1, dwNumMsgs
);
5772 check( -1, dwNumBytes
);
5774 dwNumMsgs
= dwNumBytes
= -1;
5775 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], dpid
[0], dpid
[1],
5776 ( DPMESSAGEQUEUE_SEND
|
5777 DPMESSAGEQUEUE_RECEIVE
),
5778 &dwNumMsgs
, &dwNumBytes
);
5779 checkHR( DPERR_INVALIDFLAGS
, hr
);
5780 check( -1, dwNumMsgs
);
5781 check( -1, dwNumBytes
);
5783 /* - Remote players */
5784 dwNumMsgs
= dwNumBytes
= -1;
5785 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], 0, dpid
[3],
5786 DPMESSAGEQUEUE_RECEIVE
,
5787 &dwNumMsgs
, &dwNumBytes
);
5788 checkHR( DPERR_INVALIDPLAYER
, hr
); /* Player 3 is remote */
5789 check( -1, dwNumMsgs
);
5790 check( -1, dwNumBytes
);
5792 dwNumMsgs
= dwNumBytes
= -1;
5793 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], dpid
[3], 0,
5794 DPMESSAGEQUEUE_SEND
,
5795 &dwNumMsgs
, &dwNumBytes
);
5796 checkHR( DPERR_INVALIDPLAYER
, hr
); /* Player 3 is remote */
5797 check( -1, dwNumMsgs
);
5798 check( -1, dwNumBytes
);
5800 /* - Remote players, this time in the right place */
5801 dwNumMsgs
= dwNumBytes
= -1;
5802 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], 0, dpid
[3],
5803 DPMESSAGEQUEUE_SEND
,
5804 &dwNumMsgs
, &dwNumBytes
);
5805 checkHR( DP_OK
, hr
);
5806 check( 0, dwNumMsgs
);
5807 check( 0, dwNumBytes
);
5809 dwNumMsgs
= dwNumBytes
= -1;
5810 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], dpid
[3], 0,
5811 DPMESSAGEQUEUE_RECEIVE
,
5812 &dwNumMsgs
, &dwNumBytes
);
5813 checkHR( DP_OK
, hr
);
5814 check( 0, dwNumMsgs
);
5815 check( 0, dwNumBytes
);
5818 /* Correct parameters */
5819 dwNumMsgs
= dwNumBytes
= -1;
5820 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], 0, dpid
[1],
5821 DPMESSAGEQUEUE_RECEIVE
,
5822 &dwNumMsgs
, &dwNumBytes
);
5823 checkHR( DP_OK
, hr
);
5824 check( 2, dwNumMsgs
);
5825 check( 96, dwNumBytes
);
5827 dwNumMsgs
= dwNumBytes
= -1;
5828 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], dpid
[0], 0,
5829 DPMESSAGEQUEUE_RECEIVE
,
5830 &dwNumMsgs
, &dwNumBytes
);
5831 checkHR( DP_OK
, hr
);
5832 check( 0, dwNumMsgs
);
5833 check( 0, dwNumBytes
);
5835 dwNumMsgs
= dwNumBytes
= -1;
5836 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], 0, 0,
5837 DPMESSAGEQUEUE_RECEIVE
,
5838 &dwNumMsgs
, &dwNumBytes
);
5839 checkHR( DP_OK
, hr
);
5840 check( 5, dwNumMsgs
);
5841 check( 240, dwNumBytes
);
5843 dwNumMsgs
= dwNumBytes
= -1;
5844 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], dpid
[0], dpid
[1],
5845 DPMESSAGEQUEUE_RECEIVE
,
5846 NULL
, &dwNumBytes
);
5847 checkHR( DP_OK
, hr
);
5848 check( -1, dwNumMsgs
);
5849 check( 0, dwNumBytes
);
5851 dwNumMsgs
= dwNumBytes
= -1;
5852 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], dpid
[0], dpid
[1],
5853 DPMESSAGEQUEUE_RECEIVE
,
5855 checkHR( DP_OK
, hr
);
5856 check( 0, dwNumMsgs
);
5857 check( -1, dwNumBytes
);
5859 dwNumMsgs
= dwNumBytes
= -1;
5860 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], dpid
[0], dpid
[1],
5861 DPMESSAGEQUEUE_RECEIVE
,
5863 checkHR( DP_OK
, hr
);
5864 check( -1, dwNumMsgs
);
5865 check( -1, dwNumBytes
);
5867 dwNumMsgs
= dwNumBytes
= -1;
5868 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], dpid
[0], dpid
[1],
5869 DPMESSAGEQUEUE_RECEIVE
,
5870 &dwNumMsgs
, &dwNumBytes
);
5871 checkHR( DP_OK
, hr
);
5872 check( 0, dwNumMsgs
);
5873 check( 0, dwNumBytes
);
5876 /* Purge messages */
5877 check_messages( pDP
[0], dpid
, 6, &callbackData
);
5878 checkStr( "S0,S1,S0,S1,S0,", callbackData
.szTrace1
);
5879 check_messages( pDP
[1], dpid
, 6, &callbackData
);
5880 checkStr( "S3,", callbackData
.szTrace1
);
5882 /* Check queues are empty */
5883 dwNumMsgs
= dwNumBytes
= -1;
5884 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], 0, 0,
5885 DPMESSAGEQUEUE_RECEIVE
,
5886 &dwNumMsgs
, &dwNumBytes
);
5887 checkHR( DP_OK
, hr
);
5888 check( 0, dwNumMsgs
);
5889 check( 0, dwNumBytes
);
5892 /* Sending 4 data messages from 0 to 1 */
5896 IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[1], 0, lpData
, dwDataSize
);
5898 IDirectPlayX_Send( pDP
[0], dpid
[0], dpid
[3], 0, lpData
, dwDataSize
);
5900 IDirectPlayX_Send( pDP
[0], dpid
[1], dpid
[3], 0, lpData
, dwDataSize
);
5903 dwNumMsgs
= dwNumBytes
= -1;
5904 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], dpid
[0], dpid
[1],
5905 DPMESSAGEQUEUE_RECEIVE
,
5906 &dwNumMsgs
, &dwNumBytes
);
5907 checkHR( DP_OK
, hr
);
5908 check( 4, dwNumMsgs
);
5909 check( 4*dwDataSize
, dwNumBytes
);
5911 dwNumMsgs
= dwNumBytes
= -1;
5912 hr
= IDirectPlayX_GetMessageQueue( pDP
[1], dpid
[0], dpid
[3],
5913 DPMESSAGEQUEUE_RECEIVE
,
5914 &dwNumMsgs
, &dwNumBytes
);
5915 checkHR( DP_OK
, hr
);
5916 check( 3, dwNumMsgs
);
5917 check( 3*dwDataSize
, dwNumBytes
);
5919 dwNumMsgs
= dwNumBytes
= -1;
5920 hr
= IDirectPlayX_GetMessageQueue( pDP
[1], dpid
[1], dpid
[3],
5921 DPMESSAGEQUEUE_RECEIVE
,
5922 &dwNumMsgs
, &dwNumBytes
);
5923 checkHR( DP_OK
, hr
);
5924 check( 2, dwNumMsgs
);
5925 check( 2*dwDataSize
, dwNumBytes
);
5927 dwNumMsgs
= dwNumBytes
= -1;
5928 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], dpid
[0], 0,
5929 DPMESSAGEQUEUE_RECEIVE
,
5930 &dwNumMsgs
, &dwNumBytes
);
5931 checkHR( DP_OK
, hr
);
5932 check( 4, dwNumMsgs
);
5933 check( 4*dwDataSize
, dwNumBytes
);
5935 dwNumMsgs
= dwNumBytes
= -1;
5936 hr
= IDirectPlayX_GetMessageQueue( pDP
[1], dpid
[0], 0,
5937 DPMESSAGEQUEUE_RECEIVE
,
5938 &dwNumMsgs
, &dwNumBytes
);
5939 checkHR( DP_OK
, hr
);
5940 check( 3, dwNumMsgs
);
5941 check( 3*dwDataSize
, dwNumBytes
);
5943 dwNumMsgs
= dwNumBytes
= -1;
5944 hr
= IDirectPlayX_GetMessageQueue( pDP
[1], 0, dpid
[3],
5945 DPMESSAGEQUEUE_RECEIVE
,
5946 &dwNumMsgs
, &dwNumBytes
);
5947 checkHR( DP_OK
, hr
);
5948 check( 5, dwNumMsgs
);
5949 check( 5*dwDataSize
, dwNumBytes
);
5951 dwNumMsgs
= dwNumBytes
= -1;
5952 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], 0, 0,
5953 DPMESSAGEQUEUE_RECEIVE
,
5954 &dwNumMsgs
, &dwNumBytes
);
5955 checkHR( DP_OK
, hr
);
5956 check( 4, dwNumMsgs
);
5957 check( 4*dwDataSize
, dwNumBytes
);
5959 dwNumMsgs
= dwNumBytes
= -1;
5960 hr
= IDirectPlayX_GetMessageQueue( pDP
[1], 0, 0,
5961 DPMESSAGEQUEUE_RECEIVE
,
5962 &dwNumMsgs
, &dwNumBytes
);
5963 checkHR( DP_OK
, hr
);
5964 check( 5, dwNumMsgs
);
5965 check( 5*dwDataSize
, dwNumBytes
);
5968 dwNumMsgs
= dwNumBytes
= -1;
5969 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], dpid
[0], dpid
[1],
5970 DPMESSAGEQUEUE_SEND
,
5971 &dwNumMsgs
, &dwNumBytes
);
5972 checkHR( DP_OK
, hr
);
5973 check( 0, dwNumMsgs
);
5974 check( 0, dwNumBytes
);
5976 dwNumMsgs
= dwNumBytes
= -1;
5977 hr
= IDirectPlayX_GetMessageQueue( pDP
[0], dpid
[0], dpid
[1],
5979 &dwNumMsgs
, &dwNumBytes
);
5980 checkHR( DP_OK
, hr
);
5981 check( 0, dwNumMsgs
);
5982 check( 0, dwNumBytes
);
5985 HeapFree( GetProcessHeap(), 0, lpData
);
5986 IDirectPlayX_Release( pDP
[0] );
5987 IDirectPlayX_Release( pDP
[1] );
5991 /* Remote data replication */
5993 static void test_remote_data_replication(void)
5996 LPDIRECTPLAY4 pDP
[2];
5997 DPSESSIONDESC2 dpsd
;
5998 DPID dpid
[2], idFrom
, idTo
;
5999 CallbackData callbackData
;
6002 DWORD dwFlags
, dwDataSize
= 1024;
6005 LPDPMSG_SETPLAYERORGROUPDATA lpData
= HeapAlloc( GetProcessHeap(),
6009 LPCSTR lpDataLocal
[] = { "local_0", "local_1" };
6010 LPCSTR lpDataRemote
[] = { "remote_0", "remote_1" };
6011 LPCSTR lpDataFake
= "ugly_fake_data";
6012 LPSTR lpDataGet
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, 32 );
6013 DWORD dwDataSizeLocal
= strlen(lpDataLocal
[0])+1,
6014 dwDataSizeRemote
= strlen(lpDataRemote
[0])+1,
6015 dwDataSizeFake
= strlen(lpDataFake
)+1,
6021 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
6022 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
6023 init_TCPIP_provider( pDP
[i
], "127.0.0.1", 0 );
6025 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
6026 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
6027 dpsd
.guidApplication
= appGuid
;
6030 hr
= IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
6031 todo_wine
checkHR( DP_OK
, hr
);
6033 if ( hr
== DPERR_UNINITIALIZED
)
6035 skip( "dplay not implemented enough for this test yet\n" );
6039 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
[0],
6040 NULL
, NULL
, NULL
, 0, 0 );
6041 checkHR( DP_OK
, hr
);
6044 hr
= IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
6045 (LPVOID
) pDP
[1], 0 );
6046 checkHR( DP_OK
, hr
);
6048 hr
= IDirectPlayX_CreatePlayer( pDP
[1], &dpid
[1],
6049 NULL
, NULL
, NULL
, 0, 0 );
6050 checkHR( DP_OK
, hr
);
6055 /* Local (0,0) (1,1) */
6056 IDirectPlayX_GetPlayerFlags( pDP
[i
], dpid
[i
], &dwFlags
);
6057 checkFlags( DPPLAYER_LOCAL
, dwFlags
, FLAGS_DPPLAYER
);
6058 /* Remote (0,1) (1,0) */
6059 IDirectPlayX_GetPlayerFlags( pDP
[i
], dpid
[!i
], &dwFlags
);
6060 checkFlags( 0, dwFlags
, FLAGS_DPPLAYER
);
6063 /* Set data for a local player */
6066 hr
= IDirectPlayX_SetPlayerData( pDP
[i
], dpid
[i
],
6067 (LPVOID
) lpDataLocal
[i
],
6070 checkHR( DP_OK
, hr
);
6071 hr
= IDirectPlayX_SetPlayerData( pDP
[i
], dpid
[i
],
6072 (LPVOID
) lpDataRemote
[i
],
6075 checkHR( DP_OK
, hr
);
6078 /* Retrieve data locally (0->0, 1->1) */
6081 dwDataSizeGet
= dwDataSizeFake
;
6082 strcpy( lpDataGet
, lpDataFake
);
6083 hr
= IDirectPlayX_GetPlayerData( pDP
[i
], dpid
[i
],
6084 lpDataGet
, &dwDataSizeGet
,
6086 checkHR( DP_OK
, hr
);
6087 check( dwDataSizeLocal
, dwDataSizeGet
);
6088 checkStr( lpDataLocal
[i
], lpDataGet
);
6090 dwDataSizeGet
= dwDataSizeFake
;
6091 strcpy( lpDataGet
, lpDataFake
);
6092 hr
= IDirectPlayX_GetPlayerData( pDP
[i
], dpid
[i
],
6093 lpDataGet
, &dwDataSizeGet
,
6095 checkHR( DP_OK
, hr
);
6096 check( dwDataSizeRemote
, dwDataSizeGet
);
6097 checkStr( lpDataRemote
[i
], lpDataGet
);
6101 /* Set data for a remote player */
6102 /* This should fail with DPERR_ACCESSDENIED,
6103 but for some reason it doesn't */
6106 IDirectPlayX_SetPlayerData( pDP
[i
], dpid
[!i
],
6107 (LPVOID
) lpDataLocal
[!i
],
6110 checkHR( DP_OK
, hr
);
6111 IDirectPlayX_SetPlayerData( pDP
[i
], dpid
[!i
],
6112 (LPVOID
) lpDataRemote
[!i
],
6115 checkHR( DP_OK
, hr
);
6118 /* Retrieve crossed data (0->1, 1->0) */
6121 dwDataSizeGet
= dwDataSizeFake
;
6122 strcpy( lpDataGet
, lpDataFake
);
6123 hr
= IDirectPlayX_GetPlayerData( pDP
[i
], dpid
[!i
],
6124 lpDataGet
, &dwDataSizeGet
,
6126 checkHR( DP_OK
, hr
);
6127 check( dwDataSizeLocal
, dwDataSizeGet
);
6128 checkStr( lpDataLocal
[!i
], lpDataGet
);
6130 dwDataSizeGet
= dwDataSizeFake
;
6131 strcpy( lpDataGet
, lpDataFake
);
6132 hr
= IDirectPlayX_GetPlayerData( pDP
[i
], dpid
[!i
],
6133 lpDataGet
, &dwDataSizeGet
,
6135 checkHR( DP_OK
, hr
);
6136 check( dwDataSizeRemote
, dwDataSizeGet
);
6137 checkStr( lpDataRemote
[!i
], lpDataGet
);
6141 /* Purge "new player" messages from queue */
6142 hr
= IDirectPlayX_Receive( pDP
[0], &idFrom
, &idTo
, 0,
6143 (LPVOID
) lpData
, &dwDataSize
);
6144 checkHR( DP_OK
, hr
);
6145 checkConv( DPSYS_CREATEPLAYERORGROUP
, lpData
->dwType
, dpMsgType2str
);
6147 /* Check number of messages in queue */
6150 IDirectPlayX_GetMessageCount( pDP
[i
], dpid
[i
], &dwCount
);
6151 check( 2, dwCount
);
6152 IDirectPlayX_GetMessageCount( pDP
[i
], dpid
[!i
], &dwCount
);
6153 check( 0, dwCount
);
6156 /* Checking system messages */
6161 hr
= IDirectPlayX_Receive( pDP
[i
], &idFrom
, &idTo
, 0,
6162 (LPVOID
) lpData
, &dwDataSize
);
6163 checkHR( DP_OK
, hr
);
6164 check( 29, dwDataSize
);
6165 check( DPID_SYSMSG
, idFrom
);
6166 check( dpid
[i
], idTo
);
6167 checkConv( DPSYS_SETPLAYERORGROUPDATA
, lpData
->dwType
,
6169 check( DPPLAYERTYPE_PLAYER
, lpData
->dwPlayerType
);
6170 check( dpid
[j
], lpData
->dpId
);
6171 checkStr( lpDataRemote
[j
], (LPSTR
) lpData
->lpData
);
6172 check( dwDataSizeRemote
, lpData
->dwDataSize
);
6175 hr
= IDirectPlayX_Receive( pDP
[i
], &idFrom
, &idTo
, 0,
6176 lpData
, &dwDataSize
);
6177 checkHR( DPERR_NOMESSAGES
, hr
);
6181 /* Changing remote data */
6182 hr
= IDirectPlayX_SetPlayerData( pDP
[0], dpid
[0],
6183 (LPVOID
) lpDataRemote
[0], dwDataSizeRemote
,
6185 checkHR( DP_OK
, hr
);
6187 /* Checking system messages (j=0) */
6190 hr
= IDirectPlayX_Receive( pDP
[i
], &idFrom
, &idTo
, 0,
6191 lpData
, &dwDataSize
);
6192 checkHR( DP_OK
, hr
);
6193 check( 29, dwDataSize
);
6194 check( DPID_SYSMSG
, idFrom
);
6195 check( dpid
[i
], idTo
);
6196 checkConv( DPSYS_SETPLAYERORGROUPDATA
, lpData
->dwType
, dpMsgType2str
);
6197 check( DPPLAYERTYPE_PLAYER
, lpData
->dwPlayerType
);
6198 check( dpid
[0], lpData
->dpId
);
6199 checkStr( lpDataRemote
[0], (LPSTR
) lpData
->lpData
);
6200 check( dwDataSizeRemote
, lpData
->dwDataSize
);
6204 /* Queue is empty */
6205 check_messages( pDP
[0], dpid
, 2, &callbackData
);
6206 checkStr( "", callbackData
.szTrace1
);
6207 check_messages( pDP
[1], dpid
, 2, &callbackData
);
6208 checkStr( "", callbackData
.szTrace1
);
6211 HeapFree( GetProcessHeap(), 0, lpData
);
6212 IDirectPlayX_Release( pDP
[0] );
6213 IDirectPlayX_Release( pDP
[1] );
6220 CoInitialize( NULL
);
6222 test_DirectPlayCreate();
6223 test_EnumConnections();
6224 test_InitializeConnection();
6228 test_EnumSessions();
6231 test_CreatePlayer();
6232 test_GetPlayerCaps();
6235 test_GetPlayerAccount();
6236 test_GetPlayerAddress();
6237 test_GetPlayerFlags();
6244 test_EnumGroupsInGroup();
6251 test_GetMessageCount();
6252 test_GetMessageQueue();
6254 test_remote_data_replication();