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) );
54 DEFINE_GUID(appGuid
, 0xbdcfe03e, 0xf0ec, 0x415b, 0x82, 0x11, 0x6f, 0x86, 0xd8, 0x19, 0x7f, 0xe1);
55 DEFINE_GUID(appGuid2
, 0x93417d3f, 0x7d26, 0x46ba, 0xb5, 0x76, 0xfe, 0x4b, 0x20, 0xbb, 0xad, 0x70);
56 DEFINE_GUID(GUID_NULL
,0,0,0,0,0,0,0,0,0,0,0);
59 typedef struct tagCallbackData
62 UINT dwCounter1
, dwCounter2
;
64 char szTrace1
[1024], szTrace2
[1024];
67 } CallbackData
, *lpCallbackData
;
70 static LPSTR
get_temp_buffer(void)
72 static UINT index
= 0;
73 static char buff
[10][256];
75 index
= (index
+ 1) % 10;
82 static LPCSTR
Guid2str(const GUID
*guid
)
84 LPSTR buffer
= get_temp_buffer();
86 if (!guid
) return "(null)";
88 /* Service providers */
89 if (IsEqualGUID(guid
, &DPSPGUID_IPX
))
90 return "DPSPGUID_IPX";
91 if (IsEqualGUID(guid
, &DPSPGUID_TCPIP
))
92 return "DPSPGUID_TCPIP";
93 if (IsEqualGUID(guid
, &DPSPGUID_SERIAL
))
94 return "DPSPGUID_SERIAL";
95 if (IsEqualGUID(guid
, &DPSPGUID_MODEM
))
96 return "DPSPGUID_MODEM";
97 /* DirectPlay Address ID's */
98 if (IsEqualGUID(guid
, &DPAID_TotalSize
))
99 return "DPAID_TotalSize";
100 if (IsEqualGUID(guid
, &DPAID_ServiceProvider
))
101 return "DPAID_ServiceProvider";
102 if (IsEqualGUID(guid
, &DPAID_LobbyProvider
))
103 return "DPAID_LobbyProvider";
104 if (IsEqualGUID(guid
, &DPAID_Phone
))
105 return "DPAID_Phone";
106 if (IsEqualGUID(guid
, &DPAID_PhoneW
))
107 return "DPAID_PhoneW";
108 if (IsEqualGUID(guid
, &DPAID_Modem
))
109 return "DPAID_Modem";
110 if (IsEqualGUID(guid
, &DPAID_ModemW
))
111 return "DPAID_ModemW";
112 if (IsEqualGUID(guid
, &DPAID_INet
))
114 if (IsEqualGUID(guid
, &DPAID_INetW
))
115 return "DPAID_INetW";
116 if (IsEqualGUID(guid
, &DPAID_INetPort
))
117 return "DPAID_INetPort";
118 if (IsEqualGUID(guid
, &DPAID_ComPort
))
119 return "DPAID_ComPort";
121 sprintf( buffer
, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
122 guid
->Data1
, guid
->Data2
, guid
->Data3
,
123 guid
->Data4
[0], guid
->Data4
[1], guid
->Data4
[2], guid
->Data4
[3],
124 guid
->Data4
[4], guid
->Data4
[5], guid
->Data4
[6], guid
->Data4
[7] );
130 static LPCSTR
dpResult2str(HRESULT hr
)
134 case DP_OK
: return "DP_OK";
135 case DPERR_ALREADYINITIALIZED
: return "DPERR_ALREADYINITIALIZED";
136 case DPERR_ACCESSDENIED
: return "DPERR_ACCESSDENIED";
137 case DPERR_ACTIVEPLAYERS
: return "DPERR_ACTIVEPLAYERS";
138 case DPERR_BUFFERTOOSMALL
: return "DPERR_BUFFERTOOSMALL";
139 case DPERR_CANTADDPLAYER
: return "DPERR_CANTADDPLAYER";
140 case DPERR_CANTCREATEGROUP
: return "DPERR_CANTCREATEGROUP";
141 case DPERR_CANTCREATEPLAYER
: return "DPERR_CANTCREATEPLAYER";
142 case DPERR_CANTCREATESESSION
: return "DPERR_CANTCREATESESSION";
143 case DPERR_CAPSNOTAVAILABLEYET
: return "DPERR_CAPSNOTAVAILABLEYET";
144 case DPERR_EXCEPTION
: return "DPERR_EXCEPTION";
145 case DPERR_GENERIC
: return "DPERR_GENERIC";
146 case DPERR_INVALIDFLAGS
: return "DPERR_INVALIDFLAGS";
147 case DPERR_INVALIDOBJECT
: return "DPERR_INVALIDOBJECT";
148 case DPERR_INVALIDPARAMS
: return "DPERR_INVALIDPARAMS";
149 /* symbol with the same value: DPERR_INVALIDPARAM */
150 case DPERR_INVALIDPLAYER
: return "DPERR_INVALIDPLAYER";
151 case DPERR_INVALIDGROUP
: return "DPERR_INVALIDGROUP";
152 case DPERR_NOCAPS
: return "DPERR_NOCAPS";
153 case DPERR_NOCONNECTION
: return "DPERR_NOCONNECTION";
154 case DPERR_NOMEMORY
: return "DPERR_NOMEMORY";
155 /* symbol with the same value: DPERR_OUTOFMEMORY */
156 case DPERR_NOMESSAGES
: return "DPERR_NOMESSAGES";
157 case DPERR_NONAMESERVERFOUND
: return "DPERR_NONAMESERVERFOUND";
158 case DPERR_NOPLAYERS
: return "DPERR_NOPLAYERS";
159 case DPERR_NOSESSIONS
: return "DPERR_NOSESSIONS";
160 case DPERR_PENDING
: return "DPERR_PENDING";
161 case DPERR_SENDTOOBIG
: return "DPERR_SENDTOOBIG";
162 case DPERR_TIMEOUT
: return "DPERR_TIMEOUT";
163 case DPERR_UNAVAILABLE
: return "DPERR_UNAVAILABLE";
164 case DPERR_UNSUPPORTED
: return "DPERR_UNSUPPORTED";
165 case DPERR_BUSY
: return "DPERR_BUSY";
166 case DPERR_USERCANCEL
: return "DPERR_USERCANCEL";
167 case DPERR_NOINTERFACE
: return "DPERR_NOINTERFACE";
168 case DPERR_CANNOTCREATESERVER
: return "DPERR_CANNOTCREATESERVER";
169 case DPERR_PLAYERLOST
: return "DPERR_PLAYERLOST";
170 case DPERR_SESSIONLOST
: return "DPERR_SESSIONLOST";
171 case DPERR_UNINITIALIZED
: return "DPERR_UNINITIALIZED";
172 case DPERR_NONEWPLAYERS
: return "DPERR_NONEWPLAYERS";
173 case DPERR_INVALIDPASSWORD
: return "DPERR_INVALIDPASSWORD";
174 case DPERR_CONNECTING
: return "DPERR_CONNECTING";
175 case DPERR_CONNECTIONLOST
: return "DPERR_CONNECTIONLOST";
176 case DPERR_UNKNOWNMESSAGE
: return "DPERR_UNKNOWNMESSAGE";
177 case DPERR_CANCELFAILED
: return "DPERR_CANCELFAILED";
178 case DPERR_INVALIDPRIORITY
: return "DPERR_INVALIDPRIORITY";
179 case DPERR_NOTHANDLED
: return "DPERR_NOTHANDLED";
180 case DPERR_CANCELLED
: return "DPERR_CANCELLED";
181 case DPERR_ABORTED
: return "DPERR_ABORTED";
182 case DPERR_BUFFERTOOLARGE
: return "DPERR_BUFFERTOOLARGE";
183 case DPERR_CANTCREATEPROCESS
: return "DPERR_CANTCREATEPROCESS";
184 case DPERR_APPNOTSTARTED
: return "DPERR_APPNOTSTARTED";
185 case DPERR_INVALIDINTERFACE
: return "DPERR_INVALIDINTERFACE";
186 case DPERR_NOSERVICEPROVIDER
: return "DPERR_NOSERVICEPROVIDER";
187 case DPERR_UNKNOWNAPPLICATION
: return "DPERR_UNKNOWNAPPLICATION";
188 case DPERR_NOTLOBBIED
: return "DPERR_NOTLOBBIED";
189 case DPERR_SERVICEPROVIDERLOADED
: return "DPERR_SERVICEPROVIDERLOADED";
190 case DPERR_ALREADYREGISTERED
: return "DPERR_ALREADYREGISTERED";
191 case DPERR_NOTREGISTERED
: return "DPERR_NOTREGISTERED";
192 case DPERR_AUTHENTICATIONFAILED
: return "DPERR_AUTHENTICATIONFAILED";
193 case DPERR_CANTLOADSSPI
: return "DPERR_CANTLOADSSPI";
194 case DPERR_ENCRYPTIONFAILED
: return "DPERR_ENCRYPTIONFAILED";
195 case DPERR_SIGNFAILED
: return "DPERR_SIGNFAILED";
196 case DPERR_CANTLOADSECURITYPACKAGE
: return "DPERR_CANTLOADSECURITYPACKAGE";
197 case DPERR_ENCRYPTIONNOTSUPPORTED
: return "DPERR_ENCRYPTIONNOTSUPPORTED";
198 case DPERR_CANTLOADCAPI
: return "DPERR_CANTLOADCAPI";
199 case DPERR_NOTLOGGEDIN
: return "DPERR_NOTLOGGEDIN";
200 case DPERR_LOGONDENIED
: return "DPERR_LOGONDENIED";
201 case CLASS_E_NOAGGREGATION
: return "CLASS_E_NOAGGREGATION";
205 LPSTR buffer
= get_temp_buffer();
206 sprintf( buffer
, "%d", HRESULT_CODE(hr
) );
212 static LPCSTR
dwFlags2str(DWORD dwFlags
, DWORD flagType
)
215 #define FLAGS_DPCONNECTION (1<<0)
216 #define FLAGS_DPENUMPLAYERS (1<<1)
217 #define FLAGS_DPENUMGROUPS (1<<2)
218 #define FLAGS_DPPLAYER (1<<3)
219 #define FLAGS_DPGROUP (1<<4)
220 #define FLAGS_DPENUMSESSIONS (1<<5)
221 #define FLAGS_DPGETCAPS (1<<6)
222 #define FLAGS_DPGET (1<<7)
223 #define FLAGS_DPRECEIVE (1<<8)
224 #define FLAGS_DPSEND (1<<9)
225 #define FLAGS_DPSET (1<<10)
226 #define FLAGS_DPMESSAGEQUEUE (1<<11)
227 #define FLAGS_DPCONNECT (1<<12)
228 #define FLAGS_DPOPEN (1<<13)
229 #define FLAGS_DPSESSION (1<<14)
230 #define FLAGS_DPLCONNECTION (1<<15)
231 #define FLAGS_DPESC (1<<16)
232 #define FLAGS_DPCAPS (1<<17)
234 LPSTR flags
= get_temp_buffer();
236 /* EnumConnections */
238 if (flagType
& FLAGS_DPCONNECTION
)
240 if (dwFlags
& DPCONNECTION_DIRECTPLAY
)
241 strcat(flags
, "DPCONNECTION_DIRECTPLAY,");
242 if (dwFlags
& DPCONNECTION_DIRECTPLAYLOBBY
)
243 strcat(flags
, "DPCONNECTION_DIRECTPLAYLOBBY,");
249 if (flagType
& FLAGS_DPENUMPLAYERS
)
251 if (dwFlags
== DPENUMPLAYERS_ALL
)
252 strcat(flags
, "DPENUMPLAYERS_ALL,");
253 if (dwFlags
& DPENUMPLAYERS_LOCAL
)
254 strcat(flags
, "DPENUMPLAYERS_LOCAL,");
255 if (dwFlags
& DPENUMPLAYERS_REMOTE
)
256 strcat(flags
, "DPENUMPLAYERS_REMOTE,");
257 if (dwFlags
& DPENUMPLAYERS_GROUP
)
258 strcat(flags
, "DPENUMPLAYERS_GROUP,");
259 if (dwFlags
& DPENUMPLAYERS_SESSION
)
260 strcat(flags
, "DPENUMPLAYERS_SESSION,");
261 if (dwFlags
& DPENUMPLAYERS_SERVERPLAYER
)
262 strcat(flags
, "DPENUMPLAYERS_SERVERPLAYER,");
263 if (dwFlags
& DPENUMPLAYERS_SPECTATOR
)
264 strcat(flags
, "DPENUMPLAYERS_SPECTATOR,");
265 if (dwFlags
& DPENUMPLAYERS_OWNER
)
266 strcat(flags
, "DPENUMPLAYERS_OWNER,");
268 if (flagType
& FLAGS_DPENUMGROUPS
)
270 if (dwFlags
== DPENUMGROUPS_ALL
)
271 strcat(flags
, "DPENUMGROUPS_ALL,");
272 if (dwFlags
& DPENUMPLAYERS_LOCAL
)
273 strcat(flags
, "DPENUMGROUPS_LOCAL,");
274 if (dwFlags
& DPENUMPLAYERS_REMOTE
)
275 strcat(flags
, "DPENUMGROUPS_REMOTE,");
276 if (dwFlags
& DPENUMPLAYERS_GROUP
)
277 strcat(flags
, "DPENUMGROUPS_GROUP,");
278 if (dwFlags
& DPENUMPLAYERS_SESSION
)
279 strcat(flags
, "DPENUMGROUPS_SESSION,");
280 if (dwFlags
& DPENUMGROUPS_SHORTCUT
)
281 strcat(flags
, "DPENUMGROUPS_SHORTCUT,");
282 if (dwFlags
& DPENUMGROUPS_STAGINGAREA
)
283 strcat(flags
, "DPENUMGROUPS_STAGINGAREA,");
284 if (dwFlags
& DPENUMGROUPS_HIDDEN
)
285 strcat(flags
, "DPENUMGROUPS_HIDDEN,");
290 if (flagType
& FLAGS_DPPLAYER
)
292 if (dwFlags
& DPPLAYER_SERVERPLAYER
)
293 strcat(flags
, "DPPLAYER_SERVERPLAYER,");
294 if (dwFlags
& DPPLAYER_SPECTATOR
)
295 strcat(flags
, "DPPLAYER_SPECTATOR,");
296 if (dwFlags
& DPPLAYER_LOCAL
)
297 strcat(flags
, "DPPLAYER_LOCAL,");
298 if (dwFlags
& DPPLAYER_OWNER
)
299 strcat(flags
, "DPPLAYER_OWNER,");
304 if (flagType
& FLAGS_DPGROUP
)
306 if (dwFlags
& DPGROUP_STAGINGAREA
)
307 strcat(flags
, "DPGROUP_STAGINGAREA,");
308 if (dwFlags
& DPGROUP_LOCAL
)
309 strcat(flags
, "DPGROUP_LOCAL,");
310 if (dwFlags
& DPGROUP_HIDDEN
)
311 strcat(flags
, "DPGROUP_HIDDEN,");
316 if (flagType
& FLAGS_DPENUMSESSIONS
)
318 if (dwFlags
& DPENUMSESSIONS_AVAILABLE
)
319 strcat(flags
, "DPENUMSESSIONS_AVAILABLE,");
320 if (dwFlags
& DPENUMSESSIONS_ALL
)
321 strcat(flags
, "DPENUMSESSIONS_ALL,");
322 if (dwFlags
& DPENUMSESSIONS_ASYNC
)
323 strcat(flags
, "DPENUMSESSIONS_ASYNC,");
324 if (dwFlags
& DPENUMSESSIONS_STOPASYNC
)
325 strcat(flags
, "DPENUMSESSIONS_STOPASYNC,");
326 if (dwFlags
& DPENUMSESSIONS_PASSWORDREQUIRED
)
327 strcat(flags
, "DPENUMSESSIONS_PASSWORDREQUIRED,");
328 if (dwFlags
& DPENUMSESSIONS_RETURNSTATUS
)
329 strcat(flags
, "DPENUMSESSIONS_RETURNSTATUS,");
335 if (flagType
& FLAGS_DPGETCAPS
)
337 if (dwFlags
& DPGETCAPS_GUARANTEED
)
338 strcat(flags
, "DPGETCAPS_GUARANTEED,");
344 if (flagType
& FLAGS_DPGET
)
346 if (dwFlags
== DPGET_REMOTE
)
347 strcat(flags
, "DPGET_REMOTE,");
348 if (dwFlags
& DPGET_LOCAL
)
349 strcat(flags
, "DPGET_LOCAL,");
354 if (flagType
& FLAGS_DPRECEIVE
)
356 if (dwFlags
& DPRECEIVE_ALL
)
357 strcat(flags
, "DPRECEIVE_ALL,");
358 if (dwFlags
& DPRECEIVE_TOPLAYER
)
359 strcat(flags
, "DPRECEIVE_TOPLAYER,");
360 if (dwFlags
& DPRECEIVE_FROMPLAYER
)
361 strcat(flags
, "DPRECEIVE_FROMPLAYER,");
362 if (dwFlags
& DPRECEIVE_PEEK
)
363 strcat(flags
, "DPRECEIVE_PEEK,");
368 if (flagType
& FLAGS_DPSEND
)
370 /*if (dwFlags == DPSEND_NONGUARANTEED)
371 strcat(flags, "DPSEND_NONGUARANTEED,");*/
372 if (dwFlags
== DPSEND_MAX_PRIORITY
) /* = DPSEND_MAX_PRI */
374 strcat(flags
, "DPSEND_MAX_PRIORITY,");
378 if (dwFlags
& DPSEND_GUARANTEED
)
379 strcat(flags
, "DPSEND_GUARANTEED,");
380 if (dwFlags
& DPSEND_HIGHPRIORITY
)
381 strcat(flags
, "DPSEND_HIGHPRIORITY,");
382 if (dwFlags
& DPSEND_OPENSTREAM
)
383 strcat(flags
, "DPSEND_OPENSTREAM,");
384 if (dwFlags
& DPSEND_CLOSESTREAM
)
385 strcat(flags
, "DPSEND_CLOSESTREAM,");
386 if (dwFlags
& DPSEND_SIGNED
)
387 strcat(flags
, "DPSEND_SIGNED,");
388 if (dwFlags
& DPSEND_ENCRYPTED
)
389 strcat(flags
, "DPSEND_ENCRYPTED,");
390 if (dwFlags
& DPSEND_LOBBYSYSTEMMESSAGE
)
391 strcat(flags
, "DPSEND_LOBBYSYSTEMMESSAGE,");
392 if (dwFlags
& DPSEND_ASYNC
)
393 strcat(flags
, "DPSEND_ASYNC,");
394 if (dwFlags
& DPSEND_NOSENDCOMPLETEMSG
)
395 strcat(flags
, "DPSEND_NOSENDCOMPLETEMSG,");
405 if (flagType
& FLAGS_DPSET
)
407 if (dwFlags
== DPSET_REMOTE
)
408 strcat(flags
, "DPSET_REMOTE,");
409 if (dwFlags
& DPSET_LOCAL
)
410 strcat(flags
, "DPSET_LOCAL,");
411 if (dwFlags
& DPSET_GUARANTEED
)
412 strcat(flags
, "DPSET_GUARANTEED,");
415 /* GetMessageQueue */
417 if (flagType
& FLAGS_DPMESSAGEQUEUE
)
419 if (dwFlags
& DPMESSAGEQUEUE_SEND
)
420 strcat(flags
, "DPMESSAGEQUEUE_SEND,");
421 if (dwFlags
& DPMESSAGEQUEUE_RECEIVE
)
422 strcat(flags
, "DPMESSAGEQUEUE_RECEIVE,");
427 if (flagType
& FLAGS_DPCONNECT
)
429 if (dwFlags
& DPCONNECT_RETURNSTATUS
)
430 strcat(flags
, "DPCONNECT_RETURNSTATUS,");
435 if (flagType
& FLAGS_DPOPEN
)
437 if (dwFlags
& DPOPEN_JOIN
)
438 strcat(flags
, "DPOPEN_JOIN,");
439 if (dwFlags
& DPOPEN_CREATE
)
440 strcat(flags
, "DPOPEN_CREATE,");
441 if (dwFlags
& DPOPEN_RETURNSTATUS
)
442 strcat(flags
, "DPOPEN_RETURNSTATUS,");
447 if (flagType
& FLAGS_DPSESSION
)
449 if (dwFlags
& DPSESSION_NEWPLAYERSDISABLED
)
450 strcat(flags
, "DPSESSION_NEWPLAYERSDISABLED,");
451 if (dwFlags
& DPSESSION_MIGRATEHOST
)
452 strcat(flags
, "DPSESSION_MIGRATEHOST,");
453 if (dwFlags
& DPSESSION_NOMESSAGEID
)
454 strcat(flags
, "DPSESSION_NOMESSAGEID,");
455 if (dwFlags
& DPSESSION_JOINDISABLED
)
456 strcat(flags
, "DPSESSION_JOINDISABLED,");
457 if (dwFlags
& DPSESSION_KEEPALIVE
)
458 strcat(flags
, "DPSESSION_KEEPALIVE,");
459 if (dwFlags
& DPSESSION_NODATAMESSAGES
)
460 strcat(flags
, "DPSESSION_NODATAMESSAGES,");
461 if (dwFlags
& DPSESSION_SECURESERVER
)
462 strcat(flags
, "DPSESSION_SECURESERVER,");
463 if (dwFlags
& DPSESSION_PRIVATE
)
464 strcat(flags
, "DPSESSION_PRIVATE,");
465 if (dwFlags
& DPSESSION_PASSWORDREQUIRED
)
466 strcat(flags
, "DPSESSION_PASSWORDREQUIRED,");
467 if (dwFlags
& DPSESSION_MULTICASTSERVER
)
468 strcat(flags
, "DPSESSION_MULTICASTSERVER,");
469 if (dwFlags
& DPSESSION_CLIENTSERVER
)
470 strcat(flags
, "DPSESSION_CLIENTSERVER,");
472 if (dwFlags
& DPSESSION_DIRECTPLAYPROTOCOL
)
473 strcat(flags
, "DPSESSION_DIRECTPLAYPROTOCOL,");
474 if (dwFlags
& DPSESSION_NOPRESERVEORDER
)
475 strcat(flags
, "DPSESSION_NOPRESERVEORDER,");
476 if (dwFlags
& DPSESSION_OPTIMIZELATENCY
)
477 strcat(flags
, "DPSESSION_OPTIMIZELATENCY,");
483 if (flagType
& FLAGS_DPLCONNECTION
)
485 if (dwFlags
& DPLCONNECTION_CREATESESSION
)
486 strcat(flags
, "DPLCONNECTION_CREATESESSION,");
487 if (dwFlags
& DPLCONNECTION_JOINSESSION
)
488 strcat(flags
, "DPLCONNECTION_JOINSESSION,");
491 /* EnumSessionsCallback2 */
493 if (flagType
& FLAGS_DPESC
)
495 if (dwFlags
& DPESC_TIMEDOUT
)
496 strcat(flags
, "DPESC_TIMEDOUT,");
502 if (flagType
& FLAGS_DPCAPS
)
504 if (dwFlags
& DPCAPS_ISHOST
)
505 strcat(flags
, "DPCAPS_ISHOST,");
506 if (dwFlags
& DPCAPS_GROUPOPTIMIZED
)
507 strcat(flags
, "DPCAPS_GROUPOPTIMIZED,");
508 if (dwFlags
& DPCAPS_KEEPALIVEOPTIMIZED
)
509 strcat(flags
, "DPCAPS_KEEPALIVEOPTIMIZED,");
510 if (dwFlags
& DPCAPS_GUARANTEEDOPTIMIZED
)
511 strcat(flags
, "DPCAPS_GUARANTEEDOPTIMIZED,");
512 if (dwFlags
& DPCAPS_GUARANTEEDSUPPORTED
)
513 strcat(flags
, "DPCAPS_GUARANTEEDSUPPORTED,");
514 if (dwFlags
& DPCAPS_SIGNINGSUPPORTED
)
515 strcat(flags
, "DPCAPS_SIGNINGSUPPORTED,");
516 if (dwFlags
& DPCAPS_ENCRYPTIONSUPPORTED
)
517 strcat(flags
, "DPCAPS_ENCRYPTIONSUPPORTED,");
518 if (dwFlags
& DPCAPS_ASYNCCANCELSUPPORTED
)
519 strcat(flags
, "DPCAPS_ASYNCCANCELSUPPORTED,");
520 if (dwFlags
& DPCAPS_ASYNCCANCELALLSUPPORTED
)
521 strcat(flags
, "DPCAPS_ASYNCCANCELALLSUPPORTED,");
522 if (dwFlags
& DPCAPS_SENDTIMEOUTSUPPORTED
)
523 strcat(flags
, "DPCAPS_SENDTIMEOUTSUPPORTED,");
524 if (dwFlags
& DPCAPS_SENDPRIORITYSUPPORTED
)
525 strcat(flags
, "DPCAPS_SENDPRIORITYSUPPORTED,");
526 if (dwFlags
& DPCAPS_ASYNCSUPPORTED
)
527 strcat(flags
, "DPCAPS_ASYNCSUPPORTED,");
529 if (dwFlags
& DPPLAYERCAPS_LOCAL
)
530 strcat(flags
, "DPPLAYERCAPS_LOCAL,");
533 if ((strlen(flags
) == 0) && (dwFlags
!= 0))
534 strcpy(flags
, "UNKNOWN");
536 flags
[strlen(flags
)-1] = '\0';
541 static char dpid2char(DPID
* dpid
, DWORD dpidSize
, DPID idPlayer
)
544 if ( idPlayer
== DPID_SYSMSG
)
546 for (i
=0; i
<dpidSize
; i
++)
548 if ( idPlayer
== dpid
[i
] )
554 static void check_messages( LPDIRECTPLAY4 pDP
,
557 lpCallbackData callbackData
)
559 /* Retrieves all messages from the queue of pDP, performing tests
560 * to check if we are receiving what we expect.
562 * Information about the messages is stores in callbackData:
564 * callbackData->dwCounter1: Number of messages received.
565 * callbackData->szTrace1: Traces for sender and receiver.
566 * We store the position a dpid holds in the dpid array.
569 * trace string: "01,02,03,14"
570 * expanded: [ '01', '02', '03', '14' ]
572 * \ \ \ ) message 3: from 1 to 4
573 * \ \ ) message 2: from 0 to 3
574 * \ ) message 1: from 0 to 2
575 * ) message 0: from 0 to 1
578 * sender of message i = character in place 3*i of the array
579 * receiver of message i = character in place 3*i+1 of the array
581 * A sender value of 'S' means DPID_SYSMSG, this is, a system message.
583 * callbackData->szTrace2: Traces for message sizes.
588 DWORD dwDataSize
= 1024;
589 LPVOID lpData
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, dwDataSize
);
593 callbackData
->szTrace2
[0] = '\0';
596 while ( DP_OK
== (hr
= IDirectPlayX_Receive( pDP
, &idFrom
, &idTo
, 0,
597 lpData
, &dwDataSize
)) )
600 callbackData
->szTrace1
[ 3*i
] = dpid2char( dpid
, dpidSize
, idFrom
);
601 callbackData
->szTrace1
[ 3*i
+1 ] = dpid2char( dpid
, dpidSize
, idTo
);
602 callbackData
->szTrace1
[ 3*i
+2 ] = ',';
604 sprintf( temp
, "%d,", dwDataSize
);
605 strcat( callbackData
->szTrace2
, temp
);
611 checkHR( DPERR_NOMESSAGES
, hr
);
613 callbackData
->szTrace1
[ 3*i
] = '\0';
614 callbackData
->dwCounter1
= i
;
617 HeapFree( GetProcessHeap(), 0, lpData
);
620 static void init_TCPIP_provider( LPDIRECTPLAY4 pDP
,
621 LPCSTR strIPAddressString
,
625 DPCOMPOUNDADDRESSELEMENT addressElements
[3];
626 LPVOID pAddress
= NULL
;
627 DWORD dwAddressSize
= 0;
628 LPDIRECTPLAYLOBBY3 pDPL
;
631 CoCreateInstance( &CLSID_DirectPlayLobby
, NULL
, CLSCTX_ALL
,
632 &IID_IDirectPlayLobby3A
, (LPVOID
*) &pDPL
);
634 /* Service provider */
635 addressElements
[0].guidDataType
= DPAID_ServiceProvider
;
636 addressElements
[0].dwDataSize
= sizeof(GUID
);
637 addressElements
[0].lpData
= (LPVOID
) &DPSPGUID_TCPIP
;
639 /* IP address string */
640 addressElements
[1].guidDataType
= DPAID_INet
;
641 addressElements
[1].dwDataSize
= lstrlen(strIPAddressString
) + 1;
642 addressElements
[1].lpData
= (LPVOID
) strIPAddressString
;
644 /* Optional Port number */
647 addressElements
[2].guidDataType
= DPAID_INetPort
;
648 addressElements
[2].dwDataSize
= sizeof(WORD
);
649 addressElements
[2].lpData
= &port
;
653 hr
= IDirectPlayLobby_CreateCompoundAddress( pDPL
, addressElements
, 2,
654 NULL
, &dwAddressSize
);
655 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
657 if( hr
== DPERR_BUFFERTOOSMALL
)
659 pAddress
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, dwAddressSize
);
660 hr
= IDirectPlayLobby_CreateCompoundAddress( pDPL
, addressElements
, 2,
661 pAddress
, &dwAddressSize
);
662 checkHR( DP_OK
, hr
);
665 hr
= IDirectPlayX_InitializeConnection( pDP
, pAddress
, 0 );
666 todo_wine
checkHR( DP_OK
, hr
);
670 static BOOL FAR PASCAL
EnumSessions_cb_join( LPCDPSESSIONDESC2 lpThisSD
,
675 LPDIRECTPLAY4 pDP
= (LPDIRECTPLAY4
) lpContext
;
679 if (dwFlags
& DPESC_TIMEDOUT
)
684 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
685 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
686 dpsd
.guidApplication
= appGuid
;
687 dpsd
.guidInstance
= lpThisSD
->guidInstance
;
689 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
690 checkHR( DP_OK
, hr
);
696 /* DirectPlayCreate */
698 static void test_DirectPlayCreate(void)
704 /* TODO: Check how it behaves with pUnk!=NULL */
707 hr
= DirectPlayCreate( NULL
, NULL
, NULL
);
708 checkHR( DPERR_INVALIDPARAMS
, hr
);
709 hr
= DirectPlayCreate( (LPGUID
) &GUID_NULL
, NULL
, NULL
);
710 checkHR( DPERR_INVALIDPARAMS
, hr
);
711 hr
= DirectPlayCreate( (LPGUID
) &DPSPGUID_TCPIP
, NULL
, NULL
);
712 checkHR( DPERR_INVALIDPARAMS
, hr
);
714 /* pUnk==NULL, pDP!=NULL */
715 hr
= DirectPlayCreate( NULL
, &pDP
, NULL
);
716 checkHR( DPERR_INVALIDPARAMS
, hr
);
717 hr
= DirectPlayCreate( (LPGUID
) &GUID_NULL
, &pDP
, NULL
);
718 checkHR( DP_OK
, hr
);
720 IDirectPlayX_Release( pDP
);
721 hr
= DirectPlayCreate( (LPGUID
) &DPSPGUID_TCPIP
, &pDP
, NULL
);
722 todo_wine
checkHR( DP_OK
, hr
);
724 IDirectPlayX_Release( pDP
);
728 /* EnumConnections */
730 static BOOL FAR PASCAL
EnumAddress_cb2( REFGUID guidDataType
,
735 lpCallbackData callbackData
= (lpCallbackData
) lpContext
;
737 static REFGUID types
[] = { &DPAID_TotalSize
,
738 &DPAID_ServiceProvider
,
740 static DWORD sizes
[] = { 4, 16, 0 };
741 static REFGUID sps
[] = { &DPSPGUID_SERIAL
, &DPSPGUID_MODEM
,
742 &DPSPGUID_IPX
, &DPSPGUID_TCPIP
};
745 checkGuid( types
[ callbackData
->dwCounter2
], guidDataType
);
746 check( sizes
[ callbackData
->dwCounter2
], dwDataSize
);
748 if ( IsEqualGUID( types
[0], guidDataType
) )
750 todo_wine
check( 80, *((LPDWORD
) lpData
) );
752 else if ( IsEqualGUID( types
[1], guidDataType
) )
754 todo_wine
checkGuid( sps
[ callbackData
->dwCounter1
], (LPGUID
) lpData
);
757 callbackData
->dwCounter2
++;
762 static BOOL CALLBACK
EnumConnections_cb( LPCGUID lpguidSP
,
764 DWORD dwConnectionSize
,
770 lpCallbackData callbackData
= (lpCallbackData
) lpContext
;
771 LPDIRECTPLAYLOBBY pDPL
;
774 if (!callbackData
->dwFlags
)
776 callbackData
->dwFlags
= DPCONNECTION_DIRECTPLAY
;
779 checkFlags( callbackData
->dwFlags
, dwFlags
, FLAGS_DPCONNECTION
);
781 /* Get info from lpConnection */
782 CoCreateInstance( &CLSID_DirectPlayLobby
, NULL
, CLSCTX_ALL
,
783 &IID_IDirectPlayLobby3A
, (LPVOID
*) &pDPL
);
785 callbackData
->dwCounter2
= 0;
786 IDirectPlayLobby_EnumAddress( pDPL
, EnumAddress_cb2
,
787 (LPCVOID
) lpConnection
,
789 (LPVOID
) callbackData
);
790 todo_wine
check( 3, callbackData
->dwCounter2
);
792 callbackData
->dwCounter1
++;
797 static void test_EnumConnections(void)
801 CallbackData callbackData
;
805 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
806 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
809 callbackData
.dwCounter1
= 0;
810 callbackData
.dwFlags
= 0;
811 hr
= IDirectPlayX_EnumConnections( pDP
, &appGuid
, EnumConnections_cb
,
812 (LPVOID
) &callbackData
,
813 callbackData
.dwFlags
);
814 checkHR( DP_OK
, hr
);
815 check( 4, callbackData
.dwCounter1
);
817 callbackData
.dwCounter1
= 0;
818 callbackData
.dwFlags
= 0;
819 hr
= IDirectPlayX_EnumConnections( pDP
, NULL
, EnumConnections_cb
,
820 (LPVOID
) &callbackData
,
821 callbackData
.dwFlags
);
822 checkHR( DP_OK
, hr
);
823 check( 4, callbackData
.dwCounter1
);
825 callbackData
.dwCounter1
= 0;
826 callbackData
.dwFlags
= 0;
827 hr
= IDirectPlayX_EnumConnections( pDP
, &appGuid
, NULL
,
828 (LPVOID
) &callbackData
,
829 callbackData
.dwFlags
);
830 checkHR( DPERR_INVALIDPARAMS
, hr
);
831 check( 0, callbackData
.dwCounter1
);
835 callbackData
.dwCounter1
= 0;
836 callbackData
.dwFlags
= DPCONNECTION_DIRECTPLAY
;
837 hr
= IDirectPlayX_EnumConnections( pDP
, &appGuid
, EnumConnections_cb
,
838 (LPVOID
) &callbackData
,
839 callbackData
.dwFlags
);
840 checkHR( DP_OK
, hr
);
841 check( 4, callbackData
.dwCounter1
);
843 callbackData
.dwCounter1
= 0;
844 callbackData
.dwFlags
= DPCONNECTION_DIRECTPLAYLOBBY
;
845 hr
= IDirectPlayX_EnumConnections( pDP
, &appGuid
, EnumConnections_cb
,
846 (LPVOID
) &callbackData
,
847 callbackData
.dwFlags
);
848 checkHR( DP_OK
, hr
);
849 check( 0, callbackData
.dwCounter1
);
851 callbackData
.dwCounter1
= 0;
852 callbackData
.dwFlags
= ( DPCONNECTION_DIRECTPLAY
|
853 DPCONNECTION_DIRECTPLAYLOBBY
);
854 hr
= IDirectPlayX_EnumConnections( pDP
, &appGuid
, EnumConnections_cb
,
855 (LPVOID
) &callbackData
,
856 callbackData
.dwFlags
);
857 checkHR( DP_OK
, hr
);
858 check( 4, callbackData
.dwCounter1
);
860 callbackData
.dwCounter1
= 0;
861 callbackData
.dwFlags
= ~( DPCONNECTION_DIRECTPLAY
|
862 DPCONNECTION_DIRECTPLAYLOBBY
);
863 hr
= IDirectPlayX_EnumConnections( pDP
, &appGuid
, EnumConnections_cb
,
864 (LPVOID
) &callbackData
,
865 callbackData
.dwFlags
);
866 checkHR( DPERR_INVALIDFLAGS
, hr
);
867 check( 0, callbackData
.dwCounter1
);
870 IDirectPlayX_Release( pDP
);
873 /* InitializeConnection */
875 static BOOL CALLBACK
EnumConnections_cb2( LPCGUID lpguidSP
,
877 DWORD dwConnectionSize
,
882 LPDIRECTPLAY4 pDP
= (LPDIRECTPLAY4
) lpContext
;
885 /* Incorrect parameters */
886 hr
= IDirectPlayX_InitializeConnection( pDP
, NULL
, 1 );
887 checkHR( DPERR_INVALIDPARAMS
, hr
);
888 hr
= IDirectPlayX_InitializeConnection( pDP
, lpConnection
, 1 );
889 checkHR( DPERR_INVALIDFLAGS
, hr
);
892 We're only interested in ensuring that the TCP/IP provider works */
894 if( IsEqualGUID(lpguidSP
, &DPSPGUID_TCPIP
) )
896 hr
= IDirectPlayX_InitializeConnection( pDP
, lpConnection
, 0 );
897 todo_wine
checkHR( DP_OK
, hr
);
898 hr
= IDirectPlayX_InitializeConnection( pDP
, lpConnection
, 0 );
899 todo_wine
checkHR( DPERR_ALREADYINITIALIZED
, hr
);
905 static void test_InitializeConnection(void)
910 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
911 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
913 IDirectPlayX_EnumConnections( pDP
, &appGuid
, EnumConnections_cb2
,
916 IDirectPlayX_Release( pDP
);
921 static void test_GetCaps(void)
930 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
931 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
932 ZeroMemory( &dpcaps
, sizeof(DPCAPS
) );
934 /* Service provider not ininitialized */
935 hr
= IDirectPlayX_GetCaps( pDP
, &dpcaps
, 0 );
936 checkHR( DPERR_UNINITIALIZED
, hr
);
938 init_TCPIP_provider( pDP
, "127.0.0.1", 0 );
940 /* dpcaps not ininitialized */
941 hr
= IDirectPlayX_GetCaps( pDP
, &dpcaps
, 0 );
942 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
944 dpcaps
.dwSize
= sizeof(DPCAPS
);
947 dwFlags
<=DPGETCAPS_GUARANTEED
;
948 dwFlags
+=DPGETCAPS_GUARANTEED
)
951 hr
= IDirectPlayX_GetCaps( pDP
, &dpcaps
, dwFlags
);
952 todo_wine
checkHR( DP_OK
, hr
);
957 check( sizeof(DPCAPS
), dpcaps
.dwSize
);
958 check( DPCAPS_ASYNCSUPPORTED
|
959 DPCAPS_GUARANTEEDOPTIMIZED
|
960 DPCAPS_GUARANTEEDSUPPORTED
,
962 check( 0, dpcaps
.dwMaxQueueSize
);
963 check( 0, dpcaps
.dwHundredBaud
);
964 check( 500, dpcaps
.dwLatency
);
965 check( 65536, dpcaps
.dwMaxLocalPlayers
);
966 check( 20, dpcaps
.dwHeaderLength
);
967 check( 5000, dpcaps
.dwTimeout
);
972 check( 65479, dpcaps
.dwMaxBufferSize
);
973 check( 65536, dpcaps
.dwMaxPlayers
);
975 case DPGETCAPS_GUARANTEED
:
976 check( 1048547, dpcaps
.dwMaxBufferSize
);
977 check( 64, dpcaps
.dwMaxPlayers
);
984 IDirectPlayX_Release( pDP
);
989 static BOOL FAR PASCAL
EnumSessions_cb2( LPCDPSESSIONDESC2 lpThisSD
,
994 LPDIRECTPLAY4 pDP
= (LPDIRECTPLAY4
) lpContext
;
998 if (dwFlags
& DPESC_TIMEDOUT
)
1002 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
1003 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
1004 dpsd
.guidApplication
= appGuid
;
1005 dpsd
.guidInstance
= lpThisSD
->guidInstance
;
1007 if ( lpThisSD
->dwFlags
& DPSESSION_PASSWORDREQUIRED
)
1009 /* Incorrect password */
1010 dpsd
.lpszPasswordA
= (LPSTR
) "sonic boom";
1011 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1012 checkHR( DPERR_INVALIDPASSWORD
, hr
);
1014 /* Correct password */
1015 dpsd
.lpszPasswordA
= (LPSTR
) "hadouken";
1016 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1017 checkHR( DP_OK
, hr
);
1021 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1022 checkHR( DP_OK
, hr
);
1025 hr
= IDirectPlayX_Close( pDP
);
1026 checkHR( DP_OK
, hr
);
1031 static void test_Open(void)
1034 LPDIRECTPLAY4 pDP
, pDP_server
;
1035 DPSESSIONDESC2 dpsd
, dpsd_server
;
1039 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1040 &IID_IDirectPlay4A
, (LPVOID
*) &pDP_server
);
1041 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1042 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
1043 ZeroMemory( &dpsd_server
, sizeof(DPSESSIONDESC2
) );
1044 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
1046 /* Service provider not initialized */
1047 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1048 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1050 init_TCPIP_provider( pDP_server
, "127.0.0.1", 0 );
1051 init_TCPIP_provider( pDP
, "127.0.0.1", 0 );
1053 /* Uninitialized dpsd */
1054 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1055 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1058 dpsd_server
.dwSize
= sizeof(DPSESSIONDESC2
);
1059 dpsd_server
.guidApplication
= appGuid
;
1060 dpsd_server
.dwMaxPlayers
= 10;
1063 /* Regular operation */
1064 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1065 todo_wine
checkHR( DP_OK
, hr
);
1068 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1069 todo_wine
checkHR( DPERR_ALREADYINITIALIZED
, hr
);
1072 IDirectPlayX_Close( pDP_server
);
1074 dpsd_server
.dwFlags
= DPSESSION_CLIENTSERVER
| DPSESSION_MIGRATEHOST
;
1075 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1076 todo_wine
checkHR( DPERR_INVALIDFLAGS
, hr
);
1078 dpsd_server
.dwFlags
= DPSESSION_MULTICASTSERVER
| DPSESSION_MIGRATEHOST
;
1079 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1080 todo_wine
checkHR( DPERR_INVALIDFLAGS
, hr
);
1082 dpsd_server
.dwFlags
= DPSESSION_SECURESERVER
| DPSESSION_MIGRATEHOST
;
1083 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1084 todo_wine
checkHR( DPERR_INVALIDFLAGS
, hr
);
1087 /* Joining sessions */
1088 /* - Checking how strict dplay is with sizes */
1090 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1091 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1093 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
)-1;
1094 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1095 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1097 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
)+1;
1098 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1099 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1101 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
1102 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1103 todo_wine
checkHR( DPERR_NOSESSIONS
, hr
); /* Only checks for size, not guids */
1106 dpsd
.guidApplication
= appGuid
;
1107 dpsd
.guidInstance
= appGuid
;
1110 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
);
1111 todo_wine
checkHR( DPERR_NOSESSIONS
, hr
);
1112 hr
= IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_JOIN
| DPOPEN_CREATE
);
1113 todo_wine
checkHR( DPERR_NOSESSIONS
, hr
); /* Second flag is ignored */
1115 dpsd_server
.dwFlags
= 0;
1118 /* Join to normal session */
1119 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1120 todo_wine
checkHR( DP_OK
, hr
);
1122 IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb2
, pDP
, 0 );
1125 /* Already initialized session */
1126 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1127 todo_wine
checkHR( DPERR_ALREADYINITIALIZED
, hr
);
1130 /* Checking which is the error checking order */
1131 dpsd_server
.dwSize
= 0;
1133 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1134 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1136 dpsd_server
.dwSize
= sizeof(DPSESSIONDESC2
);
1139 /* Join to protected session */
1140 IDirectPlayX_Close( pDP_server
);
1141 dpsd_server
.lpszPasswordA
= (LPSTR
) "hadouken";
1142 hr
= IDirectPlayX_Open( pDP_server
, &dpsd_server
, DPOPEN_CREATE
);
1143 todo_wine
checkHR( DP_OK
, hr
);
1145 IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb2
,
1146 pDP
, DPENUMSESSIONS_PASSWORDREQUIRED
);
1149 IDirectPlayX_Release( pDP
);
1150 IDirectPlayX_Release( pDP_server
);
1156 static BOOL FAR PASCAL
EnumSessions_cb( LPCDPSESSIONDESC2 lpThisSD
,
1157 LPDWORD lpdwTimeOut
,
1161 lpCallbackData callbackData
= (lpCallbackData
) lpContext
;
1162 callbackData
->dwCounter1
++;
1164 if ( dwFlags
& DPESC_TIMEDOUT
)
1166 check( TRUE
, lpThisSD
== NULL
);
1169 check( FALSE
, lpThisSD
== NULL
);
1172 if ( lpThisSD
->lpszPasswordA
!= NULL
)
1174 check( TRUE
, (lpThisSD
->dwFlags
& DPSESSION_PASSWORDREQUIRED
) != 0 );
1177 if ( lpThisSD
->dwFlags
& DPSESSION_NEWPLAYERSDISABLED
)
1179 check( 0, lpThisSD
->dwCurrentPlayers
);
1182 check( sizeof(*lpThisSD
), lpThisSD
->dwSize
);
1183 checkLP( NULL
, lpThisSD
->lpszPasswordA
);
1188 static LPDIRECTPLAY4
create_session(DPSESSIONDESC2
*lpdpsd
)
1198 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1199 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
1201 init_TCPIP_provider( pDP
, "127.0.0.1", 0 );
1203 hr
= IDirectPlayX_Open( pDP
, lpdpsd
, DPOPEN_CREATE
);
1204 todo_wine
checkHR( DP_OK
, hr
);
1206 if ( ! (lpdpsd
->dwFlags
& DPSESSION_NEWPLAYERSDISABLED
) )
1208 ZeroMemory( &name
, sizeof(DPNAME
) );
1209 name
.dwSize
= sizeof(DPNAME
);
1210 name
.lpszShortNameA
= (LPSTR
) "bofh";
1212 hr
= IDirectPlayX_CreatePlayer( pDP
, &dpid
, &name
, NULL
, NULL
,
1213 0, DPPLAYER_SERVERPLAYER
);
1214 todo_wine
checkHR( DP_OK
, hr
);
1221 static void test_EnumSessions(void)
1224 #define N_SESSIONS 6
1226 LPDIRECTPLAY4 pDP
, pDPserver
[N_SESSIONS
];
1227 DPSESSIONDESC2 dpsd
, dpsd_server
[N_SESSIONS
];
1228 CallbackData callbackData
;
1233 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1234 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
1235 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
1236 callbackData
.dwCounter1
= -1; /* So that after a call to EnumSessions
1237 we get the exact number of sessions */
1238 callbackData
.dwFlags
= 0;
1241 /* Service provider not initialized */
1242 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1243 (LPVOID
) &callbackData
, 0 );
1244 checkHR( DPERR_UNINITIALIZED
, hr
);
1247 init_TCPIP_provider( pDP
, "127.0.0.1", 0 );
1250 /* Session with no size */
1251 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1252 (LPVOID
) &callbackData
, 0 );
1253 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1255 if ( hr
== DPERR_UNINITIALIZED
)
1257 skip( "EnumSessions not implemented\n" );
1261 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
1265 callbackData
.dwCounter1
= -1;
1266 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1267 (LPVOID
) &callbackData
, 0 );
1268 checkHR( DP_OK
, hr
);
1269 check( 0, callbackData
.dwCounter1
);
1272 dpsd
.guidApplication
= appGuid
;
1274 /* Set up sessions */
1275 for (i
=0; i
<N_SESSIONS
; i
++)
1277 memcpy( &dpsd_server
[i
], &dpsd
, sizeof(DPSESSIONDESC2
) );
1280 dpsd_server
[0].lpszSessionNameA
= (LPSTR
) "normal";
1281 dpsd_server
[0].dwFlags
= ( DPSESSION_CLIENTSERVER
|
1282 DPSESSION_DIRECTPLAYPROTOCOL
);
1283 dpsd_server
[0].dwMaxPlayers
= 10;
1285 dpsd_server
[1].lpszSessionNameA
= (LPSTR
) "full";
1286 dpsd_server
[1].dwFlags
= ( DPSESSION_CLIENTSERVER
|
1287 DPSESSION_DIRECTPLAYPROTOCOL
);
1288 dpsd_server
[1].dwMaxPlayers
= 1;
1290 dpsd_server
[2].lpszSessionNameA
= (LPSTR
) "no new";
1291 dpsd_server
[2].dwFlags
= ( DPSESSION_CLIENTSERVER
|
1292 DPSESSION_DIRECTPLAYPROTOCOL
|
1293 DPSESSION_NEWPLAYERSDISABLED
);
1294 dpsd_server
[2].dwMaxPlayers
= 10;
1296 dpsd_server
[3].lpszSessionNameA
= (LPSTR
) "no join";
1297 dpsd_server
[3].dwFlags
= ( DPSESSION_CLIENTSERVER
|
1298 DPSESSION_DIRECTPLAYPROTOCOL
|
1299 DPSESSION_JOINDISABLED
);
1300 dpsd_server
[3].dwMaxPlayers
= 10;
1302 dpsd_server
[4].lpszSessionNameA
= (LPSTR
) "private";
1303 dpsd_server
[4].dwFlags
= ( DPSESSION_CLIENTSERVER
|
1304 DPSESSION_DIRECTPLAYPROTOCOL
|
1305 DPSESSION_PRIVATE
);
1306 dpsd_server
[4].dwMaxPlayers
= 10;
1307 dpsd_server
[4].lpszPasswordA
= (LPSTR
) "password";
1309 dpsd_server
[5].lpszSessionNameA
= (LPSTR
) "protected";
1310 dpsd_server
[5].dwFlags
= ( DPSESSION_CLIENTSERVER
|
1311 DPSESSION_DIRECTPLAYPROTOCOL
|
1312 DPSESSION_PASSWORDREQUIRED
);
1313 dpsd_server
[5].dwMaxPlayers
= 10;
1314 dpsd_server
[5].lpszPasswordA
= (LPSTR
) "password";
1317 for (i
=0; i
<N_SESSIONS
; i
++)
1319 pDPserver
[i
] = create_session( &dpsd_server
[i
] );
1323 /* Invalid params */
1324 callbackData
.dwCounter1
= -1;
1325 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1326 (LPVOID
) &callbackData
, -1 );
1327 checkHR( DPERR_INVALIDPARAMS
, hr
);
1329 hr
= IDirectPlayX_EnumSessions( pDP
, NULL
, 0, EnumSessions_cb
,
1330 (LPVOID
) &callbackData
, 0 );
1331 checkHR( DPERR_INVALIDPARAMS
, hr
);
1333 check( -1, callbackData
.dwCounter1
);
1337 callbackData
.dwFlags
= DPENUMSESSIONS_ALL
; /* Doesn't list private,
1339 callbackData
.dwCounter1
= -1;
1340 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1341 (LPVOID
) &callbackData
,
1342 callbackData
.dwFlags
);
1343 check( N_SESSIONS
-2, callbackData
.dwCounter1
);
1345 /* Doesn't list private */
1346 callbackData
.dwFlags
= ( DPENUMSESSIONS_ALL
|
1347 DPENUMSESSIONS_PASSWORDREQUIRED
);
1348 callbackData
.dwCounter1
= -1;
1349 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1350 (LPVOID
) &callbackData
,
1351 callbackData
.dwFlags
);
1352 check( N_SESSIONS
-1, callbackData
.dwCounter1
);
1354 /* Doesn't list full, no new, no join, private, protected */
1355 callbackData
.dwFlags
= DPENUMSESSIONS_AVAILABLE
;
1356 callbackData
.dwCounter1
= -1;
1357 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1358 (LPVOID
) &callbackData
,
1359 callbackData
.dwFlags
);
1360 check( N_SESSIONS
-5, callbackData
.dwCounter1
);
1362 /* Like with DPENUMSESSIONS_AVAILABLE */
1363 callbackData
.dwFlags
= 0;
1364 callbackData
.dwCounter1
= -1;
1365 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1366 (LPVOID
) &callbackData
,
1367 callbackData
.dwFlags
);
1368 check( N_SESSIONS
-5, callbackData
.dwCounter1
);
1370 /* Doesn't list full, no new, no join, private */
1371 callbackData
.dwFlags
= DPENUMSESSIONS_PASSWORDREQUIRED
;
1372 callbackData
.dwCounter1
= -1;
1373 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1374 (LPVOID
) &callbackData
,
1375 callbackData
.dwFlags
);
1376 check( N_SESSIONS
-4, callbackData
.dwCounter1
);
1379 /* Async enumeration */
1380 callbackData
.dwFlags
= DPENUMSESSIONS_ASYNC
;
1381 callbackData
.dwCounter1
= -1;
1382 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1383 (LPVOID
) &callbackData
,
1384 callbackData
.dwFlags
);
1385 check( N_SESSIONS
-4, callbackData
.dwCounter1
); /* Read cache of last
1388 callbackData
.dwFlags
= DPENUMSESSIONS_STOPASYNC
;
1389 callbackData
.dwCounter1
= -1;
1390 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1391 (LPVOID
) &callbackData
,
1392 callbackData
.dwFlags
);
1393 check( 0, callbackData
.dwCounter1
); /* Stop enumeration */
1395 callbackData
.dwFlags
= DPENUMSESSIONS_ASYNC
;
1396 callbackData
.dwCounter1
= -1;
1397 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1398 (LPVOID
) &callbackData
,
1399 callbackData
.dwFlags
);
1400 check( 0, callbackData
.dwCounter1
); /* Start enumeration */
1402 Sleep(500); /* Give time to fill the cache */
1404 callbackData
.dwFlags
= DPENUMSESSIONS_ASYNC
;
1405 callbackData
.dwCounter1
= -1;
1406 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1407 (LPVOID
) &callbackData
,
1408 callbackData
.dwFlags
);
1409 check( N_SESSIONS
-5, callbackData
.dwCounter1
); /* Retrieve results */
1411 callbackData
.dwFlags
= DPENUMSESSIONS_STOPASYNC
;
1412 callbackData
.dwCounter1
= -1;
1413 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1414 (LPVOID
) &callbackData
,
1415 callbackData
.dwFlags
);
1416 check( 0, callbackData
.dwCounter1
); /* Stop enumeration */
1419 /* Specific tests for passworded sessions */
1421 for (i
=0; i
<N_SESSIONS
; i
++)
1423 IDirectPlayX_Release( pDPserver
[i
] );
1426 /* - Only session password set */
1429 dpsd_server
[i
].lpszPasswordA
= (LPSTR
) "password";
1430 dpsd_server
[i
].dwFlags
= 0;
1431 pDPserver
[i
] = create_session( &dpsd_server
[i
] );
1434 callbackData
.dwFlags
= 0;
1435 callbackData
.dwCounter1
= -1;
1436 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1437 (LPVOID
) &callbackData
,
1438 callbackData
.dwFlags
);
1439 check( 0, callbackData
.dwCounter1
);
1441 callbackData
.dwFlags
= DPENUMSESSIONS_PASSWORDREQUIRED
;
1442 callbackData
.dwCounter1
= -1;
1443 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1444 (LPVOID
) &callbackData
,
1445 callbackData
.dwFlags
);
1446 check( 2, callbackData
.dwCounter1
); /* Both sessions automatically
1447 set DPSESSION_PASSWORDREQUIRED */
1449 /* - Only session flag set */
1450 for (i
=4; i
<=5; i
++)
1452 IDirectPlayX_Release( pDPserver
[i
] );
1453 dpsd_server
[i
].lpszPasswordA
= NULL
;
1455 dpsd_server
[4].dwFlags
= DPSESSION_PRIVATE
;
1456 dpsd_server
[5].dwFlags
= DPSESSION_PASSWORDREQUIRED
;
1457 for (i
=4; i
<=5; i
++)
1459 pDPserver
[i
] = create_session( &dpsd_server
[i
] );
1462 callbackData
.dwFlags
= 0;
1463 callbackData
.dwCounter1
= -1;
1464 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1465 (LPVOID
) &callbackData
,
1466 callbackData
.dwFlags
);
1467 check( 2, callbackData
.dwCounter1
); /* Without password,
1468 the flag is ignored */
1470 /* - Both session flag and password set */
1471 for (i
=4; i
<=5; i
++)
1473 IDirectPlayX_Release( pDPserver
[i
] );
1474 dpsd_server
[i
].lpszPasswordA
= (LPSTR
) "password";
1476 dpsd_server
[4].dwFlags
= DPSESSION_PRIVATE
;
1477 dpsd_server
[5].dwFlags
= DPSESSION_PASSWORDREQUIRED
;
1478 for (i
=4; i
<=5; i
++)
1480 pDPserver
[i
] = create_session( &dpsd_server
[i
] );
1483 /* - Listing without password */
1484 callbackData
.dwCounter1
= -1;
1485 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1486 (LPVOID
) &callbackData
,
1487 callbackData
.dwFlags
);
1488 check( 0, callbackData
.dwCounter1
);
1490 callbackData
.dwFlags
= DPENUMSESSIONS_PASSWORDREQUIRED
;
1491 callbackData
.dwCounter1
= -1;
1492 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1493 (LPVOID
) &callbackData
,
1494 callbackData
.dwFlags
);
1495 check( 1, callbackData
.dwCounter1
);
1497 /* - Listing with incorrect password */
1498 dpsd
.lpszPasswordA
= (LPSTR
) "bad_password";
1499 callbackData
.dwFlags
= 0;
1500 callbackData
.dwCounter1
= -1;
1501 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1502 (LPVOID
) &callbackData
,
1503 callbackData
.dwFlags
);
1504 check( 0, callbackData
.dwCounter1
);
1506 callbackData
.dwFlags
= DPENUMSESSIONS_PASSWORDREQUIRED
;
1507 callbackData
.dwCounter1
= -1;
1508 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1509 (LPVOID
) &callbackData
,
1510 callbackData
.dwFlags
);
1511 check( 1, callbackData
.dwCounter1
);
1513 /* - Listing with correct password */
1514 dpsd
.lpszPasswordA
= (LPSTR
) "password";
1515 callbackData
.dwCounter1
= -1;
1516 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1517 (LPVOID
) &callbackData
,
1518 callbackData
.dwFlags
);
1519 check( 2, callbackData
.dwCounter1
);
1522 dpsd
.lpszPasswordA
= NULL
;
1523 callbackData
.dwFlags
= DPENUMSESSIONS_ASYNC
;
1524 callbackData
.dwCounter1
= -1;
1525 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1526 (LPVOID
) &callbackData
,
1527 callbackData
.dwFlags
);
1528 check( 2, callbackData
.dwCounter1
); /* Read cache of last sync enumeration,
1529 even private sessions */
1534 /* - Creating two servers with different application GUIDs */
1535 for (i
=4; i
<=5; i
++)
1537 IDirectPlayX_Release( pDPserver
[i
] );
1538 dpsd_server
[i
].dwFlags
= ( DPSESSION_CLIENTSERVER
|
1539 DPSESSION_DIRECTPLAYPROTOCOL
);
1540 dpsd_server
[i
].lpszPasswordA
= NULL
;
1541 dpsd_server
[i
].dwMaxPlayers
= 10;
1543 dpsd_server
[4].lpszSessionNameA
= (LPSTR
) "normal1";
1544 dpsd_server
[4].guidApplication
= appGuid
;
1545 dpsd_server
[5].lpszSessionNameA
= (LPSTR
) "normal2";
1546 dpsd_server
[5].guidApplication
= appGuid2
;
1547 for (i
=4; i
<=5; i
++)
1549 pDPserver
[i
] = create_session( &dpsd_server
[i
] );
1552 callbackData
.dwFlags
= 0;
1554 dpsd
.guidApplication
= appGuid2
;
1555 callbackData
.dwCounter1
= -1;
1556 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1557 (LPVOID
) &callbackData
,
1558 callbackData
.dwFlags
);
1559 check( 1, callbackData
.dwCounter1
); /* Only one of the sessions */
1561 dpsd
.guidApplication
= appGuid
;
1562 callbackData
.dwCounter1
= -1;
1563 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1564 (LPVOID
) &callbackData
,
1565 callbackData
.dwFlags
);
1566 check( 1, callbackData
.dwCounter1
); /* The other session */
1568 For some reason, if we enum 1st with appGuid and 2nd with appGuid2,
1569 in the second enum we get the 2 sessions. Dplay fault? Elves? */
1571 dpsd
.guidApplication
= GUID_NULL
;
1572 callbackData
.dwCounter1
= -1;
1573 hr
= IDirectPlayX_EnumSessions( pDP
, &dpsd
, 0, EnumSessions_cb
,
1574 (LPVOID
) &callbackData
,
1575 callbackData
.dwFlags
);
1576 check( 2, callbackData
.dwCounter1
); /* Both sessions */
1578 for (i
=4; i
<=5; i
++)
1580 IDirectPlayX_Release( pDPserver
[i
] );
1582 IDirectPlayX_Release( pDP
);
1589 static void test_SessionDesc(void)
1592 LPDIRECTPLAY4 pDP
[2];
1593 DPSESSIONDESC2 dpsd
;
1594 LPDPSESSIONDESC2 lpData
[2];
1600 CallbackData callbackData
;
1605 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1606 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
1608 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
1610 /* Service provider not initialized */
1611 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], NULL
, 0 );
1612 checkHR( DPERR_UNINITIALIZED
, hr
);
1614 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], NULL
, NULL
);
1615 checkHR( DPERR_UNINITIALIZED
, hr
);
1618 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
1619 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
1622 /* No sessions open */
1623 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], NULL
, 0 );
1624 todo_wine
checkHR( DPERR_NOSESSIONS
, hr
);
1626 if ( hr
== DPERR_UNINITIALIZED
)
1628 skip("Get/SetSessionDesc not implemented\n");
1632 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], NULL
, NULL
);
1633 checkHR( DPERR_NOSESSIONS
, hr
);
1636 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
1637 dpsd
.guidApplication
= appGuid
;
1638 dpsd
.dwMaxPlayers
= 10;
1642 IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
1644 IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
1645 (LPVOID
)pDP
[1], 0 );
1649 /* Players, only to receive messages */
1650 IDirectPlayX_CreatePlayer( pDP
[i
], &dpid
[i
], NULL
, NULL
, NULL
, 0, 0 );
1652 lpData
[i
] = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, 1024 );
1654 lpDataMsg
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, 1024 );
1657 /* Incorrect parameters */
1658 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], NULL
, 0 );
1659 checkHR( DPERR_INVALIDPARAMS
, hr
);
1660 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], NULL
, NULL
);
1661 checkHR( DPERR_INVALIDPARAM
, hr
);
1662 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], lpData
[0], NULL
);
1663 checkHR( DPERR_INVALIDPARAM
, hr
);
1665 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], lpData
[0], &dwDataSize
);
1666 checkHR( DPERR_INVALIDPARAMS
, hr
);
1667 check( -1, dwDataSize
);
1669 /* Get: Insufficient buffer size */
1671 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], lpData
[0], &dwDataSize
);
1672 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
1673 check( dpsd
.dwSize
, dwDataSize
);
1675 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], lpData
[0], &dwDataSize
);
1676 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
1677 check( dpsd
.dwSize
, dwDataSize
);
1679 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], NULL
, &dwDataSize
);
1680 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
1681 check( dpsd
.dwSize
, dwDataSize
);
1683 /* Get: Regular operation
1684 * i=0: Local session
1685 * i=1: Remote session */
1688 hr
= IDirectPlayX_GetSessionDesc( pDP
[i
], lpData
[i
], &dwDataSize
);
1689 checkHR( DP_OK
, hr
);
1690 check( sizeof(DPSESSIONDESC2
), dwDataSize
);
1691 check( sizeof(DPSESSIONDESC2
), lpData
[i
]->dwSize
);
1692 checkGuid( &appGuid
, &lpData
[i
]->guidApplication
);
1693 check( dpsd
.dwMaxPlayers
, lpData
[i
]->dwMaxPlayers
);
1696 checkGuid( &lpData
[0]->guidInstance
, &lpData
[1]->guidInstance
);
1698 /* Set: Regular operation */
1699 dpsd
.lpszSessionNameA
= (LPSTR
) "Wahaa";
1700 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1701 checkHR( DP_OK
, hr
);
1704 hr
= IDirectPlayX_GetSessionDesc( pDP
[1], lpData
[1], &dwDataSize
);
1705 checkHR( DP_OK
, hr
);
1706 checkStr( dpsd
.lpszSessionNameA
, lpData
[1]->lpszSessionNameA
);
1709 /* Set: Failing to modify a remote session */
1710 hr
= IDirectPlayX_SetSessionDesc( pDP
[1], &dpsd
, 0 );
1711 checkHR( DPERR_ACCESSDENIED
, hr
);
1713 /* Trying to change inmutable properties */
1715 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1716 checkHR( DP_OK
, hr
);
1717 dpsd
.dwFlags
= DPSESSION_SECURESERVER
;
1718 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1719 checkHR( DPERR_INVALIDPARAMS
, hr
);
1721 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1722 checkHR( DP_OK
, hr
);
1725 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1726 checkHR( DPERR_INVALIDPARAMS
, hr
);
1727 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
1728 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1729 checkHR( DP_OK
, hr
);
1731 /* Changing the GUIDs and size is ignored */
1732 dpsd
.guidApplication
= appGuid2
;
1733 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1734 checkHR( DP_OK
, hr
);
1735 dpsd
.guidInstance
= appGuid2
;
1736 hr
= IDirectPlayX_SetSessionDesc( pDP
[0], &dpsd
, 0 );
1737 checkHR( DP_OK
, hr
);
1739 hr
= IDirectPlayX_GetSessionDesc( pDP
[0], lpData
[0], &dwDataSize
);
1740 checkHR( DP_OK
, hr
);
1741 checkGuid( &appGuid
, &lpData
[0]->guidApplication
);
1742 checkGuid( &lpData
[1]->guidInstance
, &lpData
[0]->guidInstance
);
1743 check( sizeof(DPSESSIONDESC2
), lpData
[0]->dwSize
);
1746 /* Checking system messages */
1747 check_messages( pDP
[0], dpid
, 2, &callbackData
);
1748 checkStr( "S0,S0,S0,S0,S0,S0,S0,", callbackData
.szTrace1
);
1749 checkStr( "48,90,90,90,90,90,90,", callbackData
.szTrace2
);
1750 check_messages( pDP
[1], dpid
, 2, &callbackData
);
1751 checkStr( "S1,S1,S1,S1,S1,S1,", callbackData
.szTrace1
);
1752 checkStr( "90,90,90,90,90,90,", callbackData
.szTrace2
);
1756 HeapFree( GetProcessHeap(), 0, lpData
[i
] );
1757 IDirectPlayX_Release( pDP
[i
] );
1764 static void test_CreatePlayer(void)
1767 LPDIRECTPLAY4 pDP
[2];
1768 DPSESSIONDESC2 dpsd
;
1774 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1775 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[0] );
1776 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1777 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[1] );
1778 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
1779 ZeroMemory( &name
, sizeof(DPNAME
) );
1782 /* Connection not initialized */
1783 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
, 0, 0 );
1784 checkHR( DPERR_UNINITIALIZED
, hr
);
1787 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
1788 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
1791 /* Session not open */
1792 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
, 0, 0 );
1793 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1795 if ( hr
== DPERR_UNINITIALIZED
)
1797 skip( "CreatePlayer not implemented\n" );
1801 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
1802 dpsd
.guidApplication
= appGuid
;
1803 IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
1807 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
, 0, 0 );
1808 checkHR( DP_OK
, hr
);
1814 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, &name
, NULL
, NULL
, 0, 0 );
1815 checkHR( DP_OK
, hr
);
1818 name
.dwSize
= sizeof(DPNAME
);
1819 name
.lpszShortNameA
= (LPSTR
) "test";
1820 name
.lpszLongNameA
= NULL
;
1823 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, &name
, NULL
, NULL
,
1825 checkHR( DP_OK
, hr
);
1829 hr
= IDirectPlayX_CreatePlayer( pDP
[0], NULL
, NULL
, NULL
, NULL
,
1831 checkHR( DPERR_INVALIDPARAMS
, hr
);
1834 /* There can only be one server player */
1835 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1836 0, DPPLAYER_SERVERPLAYER
);
1837 checkHR( DP_OK
, hr
);
1838 check( DPID_SERVERPLAYER
, dpid
);
1840 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1841 0, DPPLAYER_SERVERPLAYER
);
1842 checkHR( DPERR_CANTCREATEPLAYER
, hr
);
1844 IDirectPlayX_DestroyPlayer( pDP
[0], dpid
);
1846 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1847 0, DPPLAYER_SERVERPLAYER
);
1848 checkHR( DP_OK
, hr
);
1849 check( DPID_SERVERPLAYER
, dpid
);
1850 IDirectPlayX_DestroyPlayer( pDP
[0], dpid
);
1854 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1856 checkHR( DP_OK
, hr
);
1858 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1859 0, DPPLAYER_SERVERPLAYER
);
1860 checkHR( DP_OK
, hr
);
1861 check( DPID_SERVERPLAYER
, dpid
);
1862 IDirectPlayX_DestroyPlayer( pDP
[0], dpid
);
1864 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1865 0, DPPLAYER_SPECTATOR
);
1866 checkHR( DP_OK
, hr
);
1868 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1869 0, ( DPPLAYER_SERVERPLAYER
|
1870 DPPLAYER_SPECTATOR
) );
1871 checkHR( DP_OK
, hr
);
1872 check( DPID_SERVERPLAYER
, dpid
);
1873 IDirectPlayX_DestroyPlayer( pDP
[0], dpid
);
1876 /* Session with DPSESSION_NEWPLAYERSDISABLED */
1877 IDirectPlayX_Close( pDP
[0] );
1878 dpsd
.dwFlags
= DPSESSION_NEWPLAYERSDISABLED
;
1879 hr
= IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
1880 checkHR( DP_OK
, hr
);
1883 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1885 checkHR( DPERR_CANTCREATEPLAYER
, hr
);
1887 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1888 0, DPPLAYER_SERVERPLAYER
);
1889 checkHR( DPERR_CANTCREATEPLAYER
, hr
);
1891 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1892 0, DPPLAYER_SPECTATOR
);
1893 checkHR( DPERR_CANTCREATEPLAYER
, hr
);
1896 /* Creating players in a Client/Server session */
1897 IDirectPlayX_Close( pDP
[0] );
1898 dpsd
.dwFlags
= DPSESSION_CLIENTSERVER
;
1899 hr
= IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
1900 checkHR( DP_OK
, hr
);
1901 hr
= IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
1902 (LPVOID
) pDP
[1], 0 );
1903 checkHR( DP_OK
, hr
);
1906 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1908 checkHR( DPERR_ACCESSDENIED
, hr
);
1910 hr
= IDirectPlayX_CreatePlayer( pDP
[0], &dpid
, NULL
, NULL
, NULL
,
1911 0, DPPLAYER_SERVERPLAYER
);
1912 checkHR( DP_OK
, hr
);
1913 check( DPID_SERVERPLAYER
, dpid
);
1915 hr
= IDirectPlayX_CreatePlayer( pDP
[1], &dpid
, NULL
, NULL
, NULL
,
1916 0, DPPLAYER_SERVERPLAYER
);
1917 checkHR( DPERR_INVALIDFLAGS
, hr
);
1919 hr
= IDirectPlayX_CreatePlayer( pDP
[1], &dpid
, NULL
, NULL
, NULL
,
1921 checkHR( DP_OK
, hr
);
1924 IDirectPlayX_Release( pDP
[0] );
1925 IDirectPlayX_Release( pDP
[1] );
1931 static void test_GetPlayerCaps(void)
1934 LPDIRECTPLAY4 pDP
[2];
1935 DPSESSIONDESC2 dpsd
;
1946 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
1947 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
[i
] );
1949 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
1950 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
1951 dpsd
.guidApplication
= appGuid
;
1952 dpsd
.dwMaxPlayers
= 10;
1954 ZeroMemory( &playerCaps
, sizeof(DPCAPS
) );
1957 /* Uninitialized service provider */
1958 playerCaps
.dwSize
= 0;
1959 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 0, &playerCaps
, 0 );
1960 checkHR( DPERR_UNINITIALIZED
, hr
);
1962 playerCaps
.dwSize
= sizeof(DPCAPS
);
1963 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 0, &playerCaps
, 0 );
1964 checkHR( DPERR_UNINITIALIZED
, hr
);
1967 init_TCPIP_provider( pDP
[0], "127.0.0.1", 0 );
1968 init_TCPIP_provider( pDP
[1], "127.0.0.1", 0 );
1972 playerCaps
.dwSize
= 0;
1974 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 0, &playerCaps
, 0 );
1975 todo_wine
checkHR( DPERR_INVALIDPARAMS
, hr
);
1977 if ( hr
== DPERR_UNINITIALIZED
)
1979 skip( "GetPlayerCaps not implemented\n" );
1983 playerCaps
.dwSize
= sizeof(DPCAPS
);
1985 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 0, &playerCaps
, 0 );
1986 checkHR( DPERR_INVALIDPLAYER
, hr
);
1988 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 2, &playerCaps
, 0 );
1989 checkHR( DPERR_INVALIDPLAYER
, hr
);
1992 hr
= IDirectPlayX_Open( pDP
[0], &dpsd
, DPOPEN_CREATE
);
1993 checkHR( DP_OK
, hr
);
1994 hr
= IDirectPlayX_EnumSessions( pDP
[1], &dpsd
, 0, EnumSessions_cb_join
,
1995 (LPVOID
) pDP
[1], 0 );
1996 checkHR( DP_OK
, hr
);
2000 hr
= IDirectPlayX_CreatePlayer( pDP
[i
], &dpid
[i
],
2001 NULL
, NULL
, NULL
, 0, 0 );
2002 checkHR( DP_OK
, hr
);
2006 /* Uninitialized playerCaps */
2007 playerCaps
.dwSize
= 0;
2009 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 0, &playerCaps
, 0 );
2010 checkHR( DPERR_INVALIDPARAMS
, hr
);
2012 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 2, &playerCaps
, 0 );
2013 checkHR( DPERR_INVALIDPARAMS
, hr
);
2015 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], dpid
[0], &playerCaps
, 0 );
2016 checkHR( DPERR_INVALIDPARAMS
, hr
);
2019 /* Invalid player */
2020 playerCaps
.dwSize
= sizeof(DPCAPS
);
2022 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 0, &playerCaps
, 0 );
2023 checkHR( DPERR_INVALIDPLAYER
, hr
);
2025 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], 2, &playerCaps
, 0 );
2026 checkHR( DPERR_INVALIDPLAYER
, hr
);
2028 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], dpid
[0], &playerCaps
, 0 );
2029 checkHR( DP_OK
, hr
);
2032 /* Regular parameters */
2036 dwFlags
<=DPGETCAPS_GUARANTEED
;
2037 dwFlags
+=DPGETCAPS_GUARANTEED
)
2040 hr
= IDirectPlayX_GetPlayerCaps( pDP
[0], dpid
[i
],
2041 &playerCaps
, dwFlags
);
2042 checkHR( DP_OK
, hr
);
2045 check( sizeof(DPCAPS
), playerCaps
.dwSize
);
2046 check( 40, playerCaps
.dwSize
);
2047 check( 0, playerCaps
.dwMaxQueueSize
);
2048 check( 0, playerCaps
.dwHundredBaud
);
2049 check( 0, playerCaps
.dwLatency
);
2050 check( 65536, playerCaps
.dwMaxLocalPlayers
);
2051 check( 20, playerCaps
.dwHeaderLength
);
2055 checkFlags( DPCAPS_ISHOST
|
2056 DPCAPS_GUARANTEEDOPTIMIZED
|
2057 DPCAPS_GUARANTEEDSUPPORTED
|
2058 DPCAPS_ASYNCSUPPORTED
|
2060 playerCaps
.dwFlags
, FLAGS_DPCAPS
);
2063 checkFlags( DPCAPS_ISHOST
|
2064 DPCAPS_GUARANTEEDOPTIMIZED
|
2065 DPCAPS_GUARANTEEDSUPPORTED
|
2066 DPCAPS_ASYNCSUPPORTED
,
2067 playerCaps
.dwFlags
, FLAGS_DPCAPS
);
2069 if ( dwFlags
== DPGETCAPS_GUARANTEED
)
2071 check( 1048547, playerCaps
.dwMaxBufferSize
);
2072 check( 64, playerCaps
.dwMaxPlayers
);
2076 check( 65479, playerCaps
.dwMaxBufferSize
);
2077 check( 65536, playerCaps
.dwMaxPlayers
);
2084 IDirectPlayX_Release( pDP
[0] );
2085 IDirectPlayX_Release( pDP
[1] );
2092 static void test_PlayerData(void)
2095 DPSESSIONDESC2 dpsd
;
2099 /* lpDataFake has to be bigger than the rest, limits lpDataGet size */
2100 LPCSTR lpDataFake
= "big_fake_data_chunk";
2101 DWORD dwDataSizeFake
= strlen(lpDataFake
)+1;
2103 LPCSTR lpData
= "remote_data";
2104 DWORD dwDataSize
= strlen(lpData
)+1;
2106 LPCSTR lpDataLocal
= "local_data";
2107 DWORD dwDataSizeLocal
= strlen(lpDataLocal
)+1;
2109 LPSTR lpDataGet
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
2111 DWORD dwDataSizeGet
= dwDataSizeFake
;
2114 CoCreateInstance( &CLSID_DirectPlay
, NULL
, CLSCTX_ALL
,
2115 &IID_IDirectPlay4A
, (LPVOID
*) &pDP
);
2117 /* No service provider */
2118 hr
= IDirectPlayX_SetPlayerData( pDP
, 0, (LPVOID
) lpData
,
2120 checkHR( DPERR_UNINITIALIZED
, hr
);
2122 hr
= IDirectPlayX_GetPlayerData( pDP
, 0, (LPVOID
) lpDataGet
,
2123 &dwDataSizeGet
, 0 );
2124 checkHR( DPERR_UNINITIALIZED
, hr
);
2127 init_TCPIP_provider( pDP
, "127.0.0.1", 0 );
2129 ZeroMemory( &dpsd
, sizeof(DPSESSIONDESC2
) );
2130 dpsd
.dwSize
= sizeof(DPSESSIONDESC2
);
2131 dpsd
.guidApplication
= appGuid
;
2132 IDirectPlayX_Open( pDP
, &dpsd
, DPOPEN_CREATE
);
2135 /* Invalid player */
2136 hr
= IDirectPlayX_SetPlayerData( pDP
, 0, (LPVOID
) lpData
,
2138 todo_wine
checkHR( DPERR_INVALIDPLAYER
, hr
);
2140 hr
= IDirectPlayX_GetPlayerData( pDP
, 0, (LPVOID
) lpDataGet
,
2141 &dwDataSizeGet
, 0 );
2142 todo_wine
checkHR( DPERR_INVALIDPLAYER
, hr
);
2144 if ( hr
== DPERR_UNINITIALIZED
)
2146 skip( "Get/SetPlayerData not implemented\n" );
2150 /* Create the player */
2151 /* By default, the data is remote */
2152 hr
= IDirectPlayX_CreatePlayer( pDP
, &dpid
, NULL
, NULL
, (LPVOID
) lpData
,
2154 checkHR( DP_OK
, hr
);
2156 /* Invalid parameters */
2157 hr
= IDirectPlayX_SetPlayerData( pDP
, dpid
, NULL
,
2159 checkHR( DPERR_INVALIDPARAMS
, hr
);
2160 hr
= IDirectPlayX_SetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2162 checkHR( DPERR_INVALIDPARAMS
, hr
);
2164 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2166 checkHR( DPERR_INVALIDPARAMS
, hr
);
2170 * Remote data (default)
2174 /* Buffer redimension */
2175 dwDataSizeGet
= dwDataSizeFake
;
2176 strcpy(lpDataGet
, lpDataFake
);
2177 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, NULL
,
2178 &dwDataSizeGet
, 0 );
2179 check( DPERR_BUFFERTOOSMALL
, hr
);
2180 check( dwDataSize
, dwDataSizeGet
);
2181 checkStr( lpDataFake
, lpDataGet
);
2184 strcpy(lpDataGet
, lpDataFake
);
2185 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2186 &dwDataSizeGet
, 0 );
2187 check( DPERR_BUFFERTOOSMALL
, hr
);
2188 check( dwDataSize
, dwDataSizeGet
);
2190 strcpy(lpDataGet
, lpDataFake
);
2191 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2192 &dwDataSizeGet
, 0 );
2193 checkHR( DP_OK
, hr
);
2194 check( dwDataSize
, dwDataSizeGet
);
2195 checkStr( lpData
, lpDataGet
);
2197 /* Normal operation */
2198 dwDataSizeGet
= dwDataSizeFake
;
2199 strcpy(lpDataGet
, lpDataFake
);
2200 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2201 &dwDataSizeGet
, 0 );
2202 checkHR( DP_OK
, hr
);
2203 check( dwDataSize
, dwDataSizeGet
);
2204 checkStr( lpData
, lpDataGet
);
2207 dwDataSizeGet
= dwDataSizeFake
;
2208 strcpy(lpDataGet
, lpDataFake
);
2209 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2210 &dwDataSizeGet
, 0 );
2211 checkHR( DP_OK
, hr
);
2212 check( dwDataSize
, dwDataSizeGet
); /* Remote: works as expected */
2213 checkStr( lpData
, lpDataGet
);
2215 dwDataSizeGet
= dwDataSizeFake
;
2216 strcpy(lpDataGet
, lpDataFake
);
2217 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2218 &dwDataSizeGet
, DPGET_REMOTE
);
2219 checkHR( DP_OK
, hr
);
2220 check( dwDataSize
, dwDataSizeGet
); /* Same behaviour as in previous test */
2221 checkStr( lpData
, lpDataGet
);
2223 dwDataSizeGet
= dwDataSizeFake
;
2224 strcpy(lpDataGet
, lpDataFake
);
2225 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2226 &dwDataSizeGet
, DPGET_LOCAL
);
2227 checkHR( DP_OK
, hr
);
2228 check( 0, dwDataSizeGet
); /* Sets size to 0 (as local data doesn't exist) */
2229 checkStr( lpDataFake
, lpDataGet
);
2231 dwDataSizeGet
= dwDataSizeFake
;
2232 strcpy(lpDataGet
, lpDataFake
);
2233 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2235 DPGET_LOCAL
| DPGET_REMOTE
);
2236 checkHR( DP_OK
, hr
);
2237 check( 0, dwDataSizeGet
); /* Same behaviour as in previous test */
2238 checkStr( lpDataFake
, lpDataGet
);
2240 /* Getting local data (which doesn't exist), buffer size is ignored */
2242 strcpy(lpDataGet
, lpDataFake
);
2243 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2244 &dwDataSizeGet
, DPGET_LOCAL
);
2245 checkHR( DP_OK
, hr
);
2246 check( 0, dwDataSizeGet
); /* Sets size to 0 */
2247 checkStr( lpDataFake
, lpDataGet
);
2249 dwDataSizeGet
= dwDataSizeFake
;
2250 strcpy(lpDataGet
, lpDataFake
);
2251 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, NULL
,
2252 &dwDataSizeGet
, DPGET_LOCAL
);
2253 checkHR( DP_OK
, hr
);
2254 check( 0, dwDataSizeGet
); /* Sets size to 0 */
2255 checkStr( lpDataFake
, lpDataGet
);
2264 hr
= IDirectPlayX_SetPlayerData( pDP
, dpid
, (LPVOID
) lpDataLocal
,
2266 DPSET_LOCAL
| DPSET_GUARANTEED
);
2267 checkHR( DPERR_INVALIDPARAMS
, hr
);
2269 /* Correct parameters */
2270 hr
= IDirectPlayX_SetPlayerData( pDP
, dpid
, (LPVOID
) lpDataLocal
,
2271 dwDataSizeLocal
, DPSET_LOCAL
);
2272 checkHR( DP_OK
, hr
);
2274 /* Flag tests (again) */
2275 dwDataSizeGet
= dwDataSizeFake
;
2276 strcpy(lpDataGet
, lpDataFake
);
2277 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2278 &dwDataSizeGet
, 0 );
2279 checkHR( DP_OK
, hr
);
2280 check( dwDataSize
, dwDataSizeGet
); /* Remote: works as expected */
2281 checkStr( lpData
, lpDataGet
);
2283 dwDataSizeGet
= dwDataSizeFake
;
2284 strcpy(lpDataGet
, lpDataFake
);
2285 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2286 &dwDataSizeGet
, DPGET_REMOTE
);
2287 checkHR( DP_OK
, hr
);
2288 check( dwDataSize
, dwDataSizeGet
); /* Like in previous test */
2289 checkStr( lpData
, lpDataGet
);
2291 dwDataSizeGet
= dwDataSizeFake
;
2292 strcpy(lpDataGet
, lpDataFake
);
2293 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2294 &dwDataSizeGet
, DPGET_LOCAL
);
2295 checkHR( DP_OK
, hr
);
2296 check( dwDataSizeLocal
, dwDataSizeGet
); /* Local: works as expected */
2297 checkStr( lpDataLocal
, lpDataGet
);
2299 dwDataSizeGet
= dwDataSizeFake
;
2300 strcpy(lpDataGet
, lpDataFake
);
2301 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2303 DPGET_LOCAL
| DPGET_REMOTE
);
2304 checkHR( DP_OK
, hr
);
2305 check( dwDataSizeLocal
, dwDataSizeGet
); /* Like in previous test */
2306 checkStr( lpDataLocal
, lpDataGet
);
2308 /* Small buffer works as expected again */
2310 strcpy(lpDataGet
, lpDataFake
);
2311 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2312 &dwDataSizeGet
, DPGET_LOCAL
);
2313 checkHR( DPERR_BUFFERTOOSMALL
, hr
);
2314 check( dwDataSizeLocal
, dwDataSizeGet
);
2315 checkStr( lpDataFake
, lpDataGet
);
2317 dwDataSizeGet
= dwDataSizeFake
;
2318 strcpy(lpDataGet
, lpDataFake
);
2319 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, NULL
,
2320 &dwDataSizeGet
, DPGET_LOCAL
);
2321 check( DPERR_BUFFERTOOSMALL
, hr
);
2322 check( dwDataSizeLocal
, dwDataSizeGet
);
2323 checkStr( lpDataFake
, lpDataGet
);
2327 * Changing remote data
2331 /* Remote data := local data */
2332 hr
= IDirectPlayX_SetPlayerData( pDP
, dpid
, (LPVOID
) lpDataLocal
,
2334 DPSET_GUARANTEED
| DPSET_REMOTE
);
2335 checkHR( DP_OK
, hr
);
2336 hr
= IDirectPlayX_SetPlayerData( pDP
, dpid
, (LPVOID
) lpDataLocal
,
2337 dwDataSizeLocal
, 0 );
2338 checkHR( DP_OK
, hr
);
2340 dwDataSizeGet
= dwDataSizeFake
;
2341 strcpy(lpDataGet
, lpDataFake
);
2342 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2343 &dwDataSizeGet
, 0 );
2344 checkHR( DP_OK
, hr
);
2345 check( dwDataSizeLocal
, dwDataSizeGet
);
2346 checkStr( lpDataLocal
, lpDataGet
);
2348 /* Remote data := fake data */
2349 hr
= IDirectPlayX_SetPlayerData( pDP
, dpid
, (LPVOID
) lpDataFake
,
2350 dwDataSizeFake
, DPSET_REMOTE
);
2351 checkHR( DP_OK
, hr
);
2353 dwDataSizeGet
= dwDataSizeFake
+ 1;
2354 strcpy(lpDataGet
, lpData
);
2355 hr
= IDirectPlayX_GetPlayerData( pDP
, dpid
, (LPVOID
) lpDataGet
,
2356 &dwDataSizeGet
, 0 );
2357 checkHR( DP_OK
, hr
);
2358 check( dwDataSizeFake
, dwDataSizeGet
);
2359 checkStr( lpDataFake
, lpDataGet
);
2362 HeapFree( GetProcessHeap(), 0, lpDataGet
);
2363 IDirectPlayX_Release( pDP
);
2369 CoInitialize( NULL
);
2371 test_DirectPlayCreate();
2372 test_EnumConnections();
2373 test_InitializeConnection();
2377 test_EnumSessions();
2380 test_CreatePlayer();
2381 test_GetPlayerCaps();