?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dplayx: Tests for GetPlayerFlags.
[wine/gsoc_dplay.git] / dlls / dplayx / tests / dplayx.c
blobc1eb0376ae072ba3036647820dc3544f01a0a673
1 /* DirectPlay Conformance Tests
2 *
3 * Copyright 2007 - Alessandro Pignotti
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #include "wine/test.h"
21 #include <stdio.h>
22 #define INITGUID
23 #include <dplay.h>
24 #include <dplobby.h>
25
26
27 #define check(expected, result) \
28 ok( (expected) == (result), \
29 "expected=%d got=%d\n", \
30 expected, result );
31 #define checkLP(expected, result) \
32 ok( (expected) == (result), \
33 "expected=%p got=%p\n", \
34 expected, result );
35 #define checkHR(expected, result) \
36 ok( (expected) == (result), \
37 "expected=%s got=%s\n", \
38 dpResult2str(expected), dpResult2str(result) );
39 #define checkStr(expected, result) \
40 ok( (result != NULL) && (!strcmp(expected, result)), \
41 "expected=%s got=%s\n", \
42 expected, result );
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
53
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);
57
58
59 typedef struct tagCallbackData
60 {
61 LPDIRECTPLAY4 pDP;
62 UINT dwCounter1, dwCounter2;
63 DWORD dwFlags;
64 char szTrace1[1024], szTrace2[1024];
65 DPID *dpid;
66 UINT dpidSize;
67 } CallbackData, *lpCallbackData;
68
69
70 static LPSTR get_temp_buffer(void)
71 {
72 static UINT index = 0;
73 static char buff[10][256];
74
75 index = (index + 1) % 10;
76 *buff[index] = 0;
77
78 return buff[index];
79 }
80
81
82 static LPCSTR Guid2str(const GUID *guid)
83 {
84 LPSTR buffer = get_temp_buffer();
85
86 if (!guid) return "(null)";
87
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))
113 return "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";
120
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] );
125 return buffer;
126
127 }
128
129
130 static LPCSTR dpResult2str(HRESULT hr)
131 {
132 switch (hr)
133 {
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";
202
203 default:
204 {
205 LPSTR buffer = get_temp_buffer();
206 sprintf( buffer, "%d", HRESULT_CODE(hr) );
207 return buffer;
208 }
209 }
210 }
211
212 static LPCSTR dwFlags2str(DWORD dwFlags, DWORD flagType)
213 {
214
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)
233
234 LPSTR flags = get_temp_buffer();
235
236 /* EnumConnections */
237
238 if (flagType & FLAGS_DPCONNECTION)
239 {
240 if (dwFlags & DPCONNECTION_DIRECTPLAY)
241 strcat(flags, "DPCONNECTION_DIRECTPLAY,");
242 if (dwFlags & DPCONNECTION_DIRECTPLAYLOBBY)
243 strcat(flags, "DPCONNECTION_DIRECTPLAYLOBBY,");
244 }
245
246 /* EnumPlayers,
247 EnumGroups */
248
249 if (flagType & FLAGS_DPENUMPLAYERS)
250 {
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,");
267 }
268 if (flagType & FLAGS_DPENUMGROUPS)
269 {
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,");
286 }
287
288 /* CreatePlayer */
289
290 if (flagType & FLAGS_DPPLAYER)
291 {
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,");
300 }
301
302 /* CreateGroup */
303
304 if (flagType & FLAGS_DPGROUP)
305 {
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,");
312 }
313
314 /* EnumSessions */
315
316 if (flagType & FLAGS_DPENUMSESSIONS)
317 {
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,");
330 }
331
332 /* GetCaps,
333 GetPlayerCaps */
334
335 if (flagType & FLAGS_DPGETCAPS)
336 {
337 if (dwFlags & DPGETCAPS_GUARANTEED)
338 strcat(flags, "DPGETCAPS_GUARANTEED,");
339 }
340
341 /* GetGroupData,
342 GetPlayerData */
343
344 if (flagType & FLAGS_DPGET)
345 {
346 if (dwFlags == DPGET_REMOTE)
347 strcat(flags, "DPGET_REMOTE,");
348 if (dwFlags & DPGET_LOCAL)
349 strcat(flags, "DPGET_LOCAL,");
350 }
351
352 /* Receive */
353
354 if (flagType & FLAGS_DPRECEIVE)
355 {
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,");
364 }
365
366 /* Send */
367
368 if (flagType & FLAGS_DPSEND)
369 {
370 /*if (dwFlags == DPSEND_NONGUARANTEED)
371 strcat(flags, "DPSEND_NONGUARANTEED,");*/
372 if (dwFlags == DPSEND_MAX_PRIORITY) /* = DPSEND_MAX_PRI */
373 {
374 strcat(flags, "DPSEND_MAX_PRIORITY,");
375 }
376 else
377 {
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,");
396 }
397 }
398
399 /* SetGroupData,
400 SetGroupName,
401 SetPlayerData,
402 SetPlayerName,
403 SetSessionDesc */
404
405 if (flagType & FLAGS_DPSET)
406 {
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,");
413 }
414
415 /* GetMessageQueue */
416
417 if (flagType & FLAGS_DPMESSAGEQUEUE)
418 {
419 if (dwFlags & DPMESSAGEQUEUE_SEND)
420 strcat(flags, "DPMESSAGEQUEUE_SEND,");
421 if (dwFlags & DPMESSAGEQUEUE_RECEIVE)
422 strcat(flags, "DPMESSAGEQUEUE_RECEIVE,");
423 }
424
425 /* Connect */
426
427 if (flagType & FLAGS_DPCONNECT)
428 {
429 if (dwFlags & DPCONNECT_RETURNSTATUS)
430 strcat(flags, "DPCONNECT_RETURNSTATUS,");
431 }
432
433 /* Open */
434
435 if (flagType & FLAGS_DPOPEN)
436 {
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,");
443 }
444
445 /* DPSESSIONDESC2 */
446
447 if (flagType & FLAGS_DPSESSION)
448 {
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,");
471
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,");
478
479 }
480
481 /* DPLCONNECTION */
482
483 if (flagType & FLAGS_DPLCONNECTION)
484 {
485 if (dwFlags & DPLCONNECTION_CREATESESSION)
486 strcat(flags, "DPLCONNECTION_CREATESESSION,");
487 if (dwFlags & DPLCONNECTION_JOINSESSION)
488 strcat(flags, "DPLCONNECTION_JOINSESSION,");
489 }
490
491 /* EnumSessionsCallback2 */
492
493 if (flagType & FLAGS_DPESC)
494 {
495 if (dwFlags & DPESC_TIMEDOUT)
496 strcat(flags, "DPESC_TIMEDOUT,");
497 }
498
499 /* GetCaps,
500 GetPlayerCaps */
501
502 if (flagType & FLAGS_DPCAPS)
503 {
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,");
528
529 if (dwFlags & DPPLAYERCAPS_LOCAL)
530 strcat(flags, "DPPLAYERCAPS_LOCAL,");
531 }
532
533 if ((strlen(flags) == 0) && (dwFlags != 0))
534 strcpy(flags, "UNKNOWN");
535 else
536 flags[strlen(flags)-1] = '\0';
537
538 return flags;
539 }
540
541 static char dpid2char(DPID* dpid, DWORD dpidSize, DPID idPlayer)
542 {
543 UINT i;
544 if ( idPlayer == DPID_SYSMSG )
545 return 'S';
546 for (i=0; i<dpidSize; i++)
547 {
548 if ( idPlayer == dpid[i] )
549 return (char)(i+48);
550 }
551 return '?';
552 }
553
554 static void check_messages( LPDIRECTPLAY4 pDP,
555 DPID *dpid,
556 DWORD dpidSize,
557 lpCallbackData callbackData )
558 {
559 /* Retrieves all messages from the queue of pDP, performing tests
560 * to check if we are receiving what we expect.
561 *
562 * Information about the messages is stores in callbackData:
563 *
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.
567 * Example:
568 *
569 * trace string: "01,02,03,14"
570 * expanded: [ '01', '02', '03', '14' ]
571 * \ \ \ \
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
576 *
577 * In general terms:
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
580 *
581 * A sender value of 'S' means DPID_SYSMSG, this is, a system message.
582 *
583 * callbackData->szTrace2: Traces for message sizes.
584 */
585
586 DPID idFrom, idTo;
587 UINT i;
588 DWORD dwDataSize = 1024;
589 LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
590 HRESULT hr;
591 char temp[5];
592
593 callbackData->szTrace2[0] = '\0';
594
595 i = 0;
596 while ( DP_OK == (hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0,
597 lpData, &dwDataSize )) )
598 {
599
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 ] = ',';
603
604 sprintf( temp, "%d,", dwDataSize );
605 strcat( callbackData->szTrace2, temp );
606
607 dwDataSize = 1024;
608 ++i;
609 }
610
611 checkHR( DPERR_NOMESSAGES, hr );
612
613 callbackData->szTrace1[ 3*i ] = '\0';
614 callbackData->dwCounter1 = i;
615
616
617 HeapFree( GetProcessHeap(), 0, lpData );
618 }
619
620 static void init_TCPIP_provider( LPDIRECTPLAY4 pDP,
621 LPCSTR strIPAddressString,
622 WORD port )
623 {
624
625 DPCOMPOUNDADDRESSELEMENT addressElements[3];
626 LPVOID pAddress = NULL;
627 DWORD dwAddressSize = 0;
628 LPDIRECTPLAYLOBBY3 pDPL;
629 HRESULT hr;
630
631 CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL,
632 &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL );
633
634 /* Service provider */
635 addressElements[0].guidDataType = DPAID_ServiceProvider;
636 addressElements[0].dwDataSize = sizeof(GUID);
637 addressElements[0].lpData = (LPVOID) &DPSPGUID_TCPIP;
638
639 /* IP address string */
640 addressElements[1].guidDataType = DPAID_INet;
641 addressElements[1].dwDataSize = lstrlen(strIPAddressString) + 1;
642 addressElements[1].lpData = (LPVOID) strIPAddressString;
643
644 /* Optional Port number */
645 if( port > 0 )
646 {
647 addressElements[2].guidDataType = DPAID_INetPort;
648 addressElements[2].dwDataSize = sizeof(WORD);
649 addressElements[2].lpData = &port;
650 }
651
652
653 hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2,
654 NULL, &dwAddressSize );
655 checkHR( DPERR_BUFFERTOOSMALL, hr );
656
657 if( hr == DPERR_BUFFERTOOSMALL )
658 {
659 pAddress = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwAddressSize );
660 hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2,
661 pAddress, &dwAddressSize );
662 checkHR( DP_OK, hr );
663 }
664
665 hr = IDirectPlayX_InitializeConnection( pDP, pAddress, 0 );
666 todo_wine checkHR( DP_OK, hr );
667
668 }
669
670 static BOOL FAR PASCAL EnumSessions_cb_join( LPCDPSESSIONDESC2 lpThisSD,
671 LPDWORD lpdwTimeOut,
672 DWORD dwFlags,
673 LPVOID lpContext )
674 {
675 LPDIRECTPLAY4 pDP = (LPDIRECTPLAY4) lpContext;
676 DPSESSIONDESC2 dpsd;
677 HRESULT hr;
678
679 if (dwFlags & DPESC_TIMEDOUT)
680 {
681 return FALSE;
682 }
683
684 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
685 dpsd.dwSize = sizeof(DPSESSIONDESC2);
686 dpsd.guidApplication = appGuid;
687 dpsd.guidInstance = lpThisSD->guidInstance;
688
689 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
690 checkHR( DP_OK, hr );
691
692 return TRUE;
693 }
694
695
696 /* DirectPlayCreate */
697
698 static void test_DirectPlayCreate(void)
699 {
700
701 LPDIRECTPLAY pDP;
702 HRESULT hr;
703
704 /* TODO: Check how it behaves with pUnk!=NULL */
705
706 /* pDP==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 );
713
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 );
719 if ( hr == DP_OK )
720 IDirectPlayX_Release( pDP );
721 hr = DirectPlayCreate( (LPGUID) &DPSPGUID_TCPIP, &pDP, NULL );
722 todo_wine checkHR( DP_OK, hr );
723 if ( hr == DP_OK )
724 IDirectPlayX_Release( pDP );
725
726 }
727
728 /* EnumConnections */
729
730 static BOOL FAR PASCAL EnumAddress_cb2( REFGUID guidDataType,
731 DWORD dwDataSize,
732 LPCVOID lpData,
733 LPVOID lpContext )
734 {
735 lpCallbackData callbackData = (lpCallbackData) lpContext;
736
737 static REFGUID types[] = { &DPAID_TotalSize,
738 &DPAID_ServiceProvider,
739 &GUID_NULL };
740 static DWORD sizes[] = { 4, 16, 0 };
741 static REFGUID sps[] = { &DPSPGUID_SERIAL, &DPSPGUID_MODEM,
742 &DPSPGUID_IPX, &DPSPGUID_TCPIP };
743
744
745 checkGuid( types[ callbackData->dwCounter2 ], guidDataType );
746 check( sizes[ callbackData->dwCounter2 ], dwDataSize );
747
748 if ( IsEqualGUID( types[0], guidDataType ) )
749 {
750 todo_wine check( 80, *((LPDWORD) lpData) );
751 }
752 else if ( IsEqualGUID( types[1], guidDataType ) )
753 {
754 todo_wine checkGuid( sps[ callbackData->dwCounter1 ], (LPGUID) lpData );
755 }
756
757 callbackData->dwCounter2++;
758
759 return TRUE;
760 }
761
762 static BOOL CALLBACK EnumConnections_cb( LPCGUID lpguidSP,
763 LPVOID lpConnection,
764 DWORD dwConnectionSize,
765 LPCDPNAME lpName,
766 DWORD dwFlags,
767 LPVOID lpContext )
768 {
769
770 lpCallbackData callbackData = (lpCallbackData) lpContext;
771 LPDIRECTPLAYLOBBY pDPL;
772
773
774 if (!callbackData->dwFlags)
775 {
776 callbackData->dwFlags = DPCONNECTION_DIRECTPLAY;
777 }
778
779 checkFlags( callbackData->dwFlags, dwFlags, FLAGS_DPCONNECTION );
780
781 /* Get info from lpConnection */
782 CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL,
783 &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL );
784
785 callbackData->dwCounter2 = 0;
786 IDirectPlayLobby_EnumAddress( pDPL, EnumAddress_cb2,
787 (LPCVOID) lpConnection,
788 dwConnectionSize,
789 (LPVOID) callbackData );
790 todo_wine check( 3, callbackData->dwCounter2 );
791
792 callbackData->dwCounter1++;
793
794 return TRUE;
795 }
796
797 static void test_EnumConnections(void)
798 {
799
800 LPDIRECTPLAY4 pDP;
801 CallbackData callbackData;
802 HRESULT hr;
803
804
805 CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
806 &IID_IDirectPlay4A, (LPVOID*) &pDP );
807
808
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 );
816
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 );
824
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 );
832
833
834 /* Flag tests */
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 );
842
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 );
850
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 );
859
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 );
868
869
870 IDirectPlayX_Release( pDP );
871 }
872
873 /* InitializeConnection */
874
875 static BOOL CALLBACK EnumConnections_cb2( LPCGUID lpguidSP,
876 LPVOID lpConnection,
877 DWORD dwConnectionSize,
878 LPCDPNAME lpName,
879 DWORD dwFlags,
880 LPVOID lpContext )
881 {
882 LPDIRECTPLAY4 pDP = (LPDIRECTPLAY4) lpContext;
883 HRESULT hr;
884
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 );
890
891 /* Normal operation.
892 We're only interested in ensuring that the TCP/IP provider works */
893
894 if( IsEqualGUID(lpguidSP, &DPSPGUID_TCPIP) )
895 {
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 );
900 }
901
902 return TRUE;
903 }
904
905 static void test_InitializeConnection(void)
906 {
907
908 LPDIRECTPLAY4 pDP;
909
910 CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
911 &IID_IDirectPlay4A, (LPVOID*) &pDP );
912
913 IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb2,
914 (LPVOID) pDP, 0 );
915
916 IDirectPlayX_Release( pDP );
917 }
918
919 /* GetCaps */
920
921 static void test_GetCaps(void)
922 {
923
924 LPDIRECTPLAY4 pDP;
925 DPCAPS dpcaps;
926 DWORD dwFlags;
927 HRESULT hr;
928
929
930 CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
931 &IID_IDirectPlay4A, (LPVOID*) &pDP );
932 ZeroMemory( &dpcaps, sizeof(DPCAPS) );
933
934 /* Service provider not ininitialized */
935 hr = IDirectPlayX_GetCaps( pDP, &dpcaps, 0 );
936 checkHR( DPERR_UNINITIALIZED, hr );
937
938 init_TCPIP_provider( pDP, "127.0.0.1", 0 );
939
940 /* dpcaps not ininitialized */
941 hr = IDirectPlayX_GetCaps( pDP, &dpcaps, 0 );
942 todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
943
944 dpcaps.dwSize = sizeof(DPCAPS);
945
946 for (dwFlags=0;
947 dwFlags<=DPGETCAPS_GUARANTEED;
948 dwFlags+=DPGETCAPS_GUARANTEED)
949 {
950
951 hr = IDirectPlayX_GetCaps( pDP, &dpcaps, dwFlags );
952 todo_wine checkHR( DP_OK, hr );
953
954
955 if ( hr == DP_OK )
956 {
957 check( sizeof(DPCAPS), dpcaps.dwSize );
958 check( DPCAPS_ASYNCSUPPORTED |
959 DPCAPS_GUARANTEEDOPTIMIZED |
960 DPCAPS_GUARANTEEDSUPPORTED,
961 dpcaps.dwFlags );
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 );
968
969 switch (dwFlags)
970 {
971 case 0:
972 check( 65479, dpcaps.dwMaxBufferSize );
973 check( 65536, dpcaps.dwMaxPlayers );
974 break;
975 case DPGETCAPS_GUARANTEED:
976 check( 1048547, dpcaps.dwMaxBufferSize );
977 check( 64, dpcaps.dwMaxPlayers );
978 break;
979 default: break;
980 }
981 }
982 }
983
984 IDirectPlayX_Release( pDP );
985 }
986
987 /* Open */
988
989 static BOOL FAR PASCAL EnumSessions_cb2( LPCDPSESSIONDESC2 lpThisSD,
990 LPDWORD lpdwTimeOut,
991 DWORD dwFlags,
992 LPVOID lpContext )
993 {
994 LPDIRECTPLAY4 pDP = (LPDIRECTPLAY4) lpContext;
995 DPSESSIONDESC2 dpsd;
996 HRESULT hr;
997
998 if (dwFlags & DPESC_TIMEDOUT)
999 return FALSE;
1000
1001
1002 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
1003 dpsd.dwSize = sizeof(DPSESSIONDESC2);
1004 dpsd.guidApplication = appGuid;
1005 dpsd.guidInstance = lpThisSD->guidInstance;
1006
1007 if ( lpThisSD->dwFlags & DPSESSION_PASSWORDREQUIRED )
1008 {
1009 /* Incorrect password */
1010 dpsd.lpszPasswordA = (LPSTR) "sonic boom";
1011 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
1012 checkHR( DPERR_INVALIDPASSWORD, hr );
1013
1014 /* Correct password */
1015 dpsd.lpszPasswordA = (LPSTR) "hadouken";
1016 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
1017 checkHR( DP_OK, hr );
1018 }
1019 else
1020 {
1021 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
1022 checkHR( DP_OK, hr );
1023 }
1024
1025 hr = IDirectPlayX_Close( pDP );
1026 checkHR( DP_OK, hr );
1027
1028 return TRUE;
1029 }
1030
1031 static void test_Open(void)
1032 {
1033
1034 LPDIRECTPLAY4 pDP, pDP_server;
1035 DPSESSIONDESC2 dpsd, dpsd_server;
1036 HRESULT hr;
1037
1038
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) );
1045
1046 /* Service provider not initialized */
1047 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
1048 todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
1049
1050 init_TCPIP_provider( pDP_server, "127.0.0.1", 0 );
1051 init_TCPIP_provider( pDP, "127.0.0.1", 0 );
1052
1053 /* Uninitialized dpsd */
1054 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
1055 todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
1056
1057
1058 dpsd_server.dwSize = sizeof(DPSESSIONDESC2);
1059 dpsd_server.guidApplication = appGuid;
1060 dpsd_server.dwMaxPlayers = 10;
1061
1062
1063 /* Regular operation */
1064 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
1065 todo_wine checkHR( DP_OK, hr );
1066
1067 /* Opening twice */
1068 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
1069 todo_wine checkHR( DPERR_ALREADYINITIALIZED, hr );
1070
1071 /* Session flags */
1072 IDirectPlayX_Close( pDP_server );
1073
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 );
1077
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 );
1081
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 );
1085
1086
1087 /* Joining sessions */
1088 /* - Checking how strict dplay is with sizes */
1089 dpsd.dwSize = 0;
1090 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
1091 todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
1092
1093 dpsd.dwSize = sizeof(DPSESSIONDESC2)-1;
1094 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
1095 todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
1096
1097 dpsd.dwSize = sizeof(DPSESSIONDESC2)+1;
1098 hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
1099 todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
1100
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 */
1104
1105
1106 dpsd.guidApplication = appGuid;
1107 dpsd.guidInstance = appGuid;
1108
1109
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 */
1114
1115 dpsd_server.dwFlags = 0;
1116
1117
1118 /* Join to normal session */
1119 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
1120 todo_wine checkHR( DP_OK, hr );
1121
1122 IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb2, pDP, 0 );
1123
1124
1125 /* Already initialized session */
1126 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
1127 todo_wine checkHR( DPERR_ALREADYINITIALIZED, hr );
1128
1129
1130 /* Checking which is the error checking order */
1131 dpsd_server.dwSize = 0;
1132
1133 hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
1134 todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
1135
1136 dpsd_server.dwSize = sizeof(DPSESSIONDESC2);
1137
1138
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 );
1144
1145 IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb2,
1146 pDP, DPENUMSESSIONS_PASSWORDREQUIRED );
1147
1148
1149 IDirectPlayX_Release( pDP );
1150 IDirectPlayX_Release( pDP_server );
1151
1152 }
1153
1154 /* EnumSessions */
1155
1156 static BOOL FAR PASCAL EnumSessions_cb( LPCDPSESSIONDESC2 lpThisSD,
1157 LPDWORD lpdwTimeOut,
1158 DWORD dwFlags,
1159 LPVOID lpContext )
1160 {
1161 lpCallbackData callbackData = (lpCallbackData) lpContext;
1162 callbackData->dwCounter1++;
1163
1164 if ( dwFlags & DPESC_TIMEDOUT )
1165 {
1166 check( TRUE, lpThisSD == NULL );
1167 return FALSE;
1168 }
1169 check( FALSE, lpThisSD == NULL );
1170
1171
1172 if ( lpThisSD->lpszPasswordA != NULL )
1173 {
1174 check( TRUE, (lpThisSD->dwFlags & DPSESSION_PASSWORDREQUIRED) != 0 );
1175 }
1176
1177 if ( lpThisSD->dwFlags & DPSESSION_NEWPLAYERSDISABLED )
1178 {
1179 check( 0, lpThisSD->dwCurrentPlayers );
1180 }
1181
1182 check( sizeof(*lpThisSD), lpThisSD->dwSize );
1183 checkLP( NULL, lpThisSD->lpszPasswordA );
1184
1185 return TRUE;
1186 }
1187
1188 static LPDIRECTPLAY4 create_session(DPSESSIONDESC2 *lpdpsd)
1189 {
1190
1191 LPDIRECTPLAY4 pDP;
1192 DPNAME name;
1193 DPID dpid;
1194 HRESULT hr;
1195
1196 CoInitialize(NULL);
1197
1198 CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
1199 &IID_IDirectPlay4A, (LPVOID*) &pDP );
1200
1201 init_TCPIP_provider( pDP, "127.0.0.1", 0 );
1202
1203 hr = IDirectPlayX_Open( pDP, lpdpsd, DPOPEN_CREATE );
1204 todo_wine checkHR( DP_OK, hr );
1205
1206 if ( ! (lpdpsd->dwFlags & DPSESSION_NEWPLAYERSDISABLED) )
1207 {
1208 ZeroMemory( &name, sizeof(DPNAME) );
1209 name.dwSize = sizeof(DPNAME);
1210 name.lpszShortNameA = (LPSTR) "bofh";
1211
1212 hr = IDirectPlayX_CreatePlayer( pDP, &dpid, &name, NULL, NULL,
1213 0, DPPLAYER_SERVERPLAYER );
1214 todo_wine checkHR( DP_OK, hr );
1215 }
1216
1217 return pDP;
1218
1219 }
1220
1221 static void test_EnumSessions(void)
1222 {
1223
1224 #define N_SESSIONS 6
1225
1226 LPDIRECTPLAY4 pDP, pDPserver[N_SESSIONS];
1227 DPSESSIONDESC2 dpsd, dpsd_server[N_SESSIONS];
1228 CallbackData callbackData;
1229 HRESULT hr;
1230 UINT i;
1231
1232
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;
1239
1240
1241 /* Service provider not initialized */
1242 hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
1243 (LPVOID) &callbackData, 0 );
1244 checkHR( DPERR_UNINITIALIZED, hr );
1245
1246
1247 init_TCPIP_provider( pDP, "127.0.0.1", 0 );
1248
1249
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 );
1254
1255 if ( hr == DPERR_UNINITIALIZED )
1256 {
1257 skip( "EnumSessions not implemented\n" );
1258 return;
1259 }
1260
1261 dpsd.dwSize = sizeof(DPSESSIONDESC2);
1262
1263
1264 /* No sessions */
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 );
1270
1271
1272 dpsd.guidApplication = appGuid;
1273
1274 /* Set up sessions */
1275 for (i=0; i<N_SESSIONS; i++)
1276 {
1277 memcpy( &dpsd_server[i], &dpsd, sizeof(DPSESSIONDESC2) );
1278 }
1279
1280 dpsd_server[0].lpszSessionNameA = (LPSTR) "normal";
1281 dpsd_server[0].dwFlags = ( DPSESSION_CLIENTSERVER |
1282 DPSESSION_DIRECTPLAYPROTOCOL );
1283 dpsd_server[0].dwMaxPlayers = 10;
1284
1285 dpsd_server[1].lpszSessionNameA = (LPSTR) "full";
1286 dpsd_server[1].dwFlags = ( DPSESSION_CLIENTSERVER |
1287 DPSESSION_DIRECTPLAYPROTOCOL );
1288 dpsd_server[1].dwMaxPlayers = 1;
1289
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;
1295
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;
1301
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";
1308
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";
1315
1316
1317 for (i=0; i<N_SESSIONS; i++)
1318 {
1319 pDPserver[i] = create_session( &dpsd_server[i] );
1320 }
1321
1322
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 );
1328
1329 hr = IDirectPlayX_EnumSessions( pDP, NULL, 0, EnumSessions_cb,
1330 (LPVOID) &callbackData, 0 );
1331 checkHR( DPERR_INVALIDPARAMS, hr );
1332
1333 check( -1, callbackData.dwCounter1 );
1334
1335
1336 /* Flag tests */
1337 callbackData.dwFlags = DPENUMSESSIONS_ALL; /* Doesn't list private,
1338 protected */
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 );
1344
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 );
1353
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 );
1361
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 );
1369
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 );
1377
1378
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
1386 sync enumeration */
1387
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 */
1394
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 */
1401
1402 Sleep(500); /* Give time to fill the cache */
1403
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 */
1410
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 */
1417
1418
1419 /* Specific tests for passworded sessions */
1420
1421 for (i=0; i<N_SESSIONS; i++)
1422 {
1423 IDirectPlayX_Release( pDPserver[i] );
1424 }
1425
1426 /* - Only session password set */
1427 for (i=4;i<=5;i++)
1428 {
1429 dpsd_server[i].lpszPasswordA = (LPSTR) "password";
1430 dpsd_server[i].dwFlags = 0;
1431 pDPserver[i] = create_session( &dpsd_server[i] );
1432 }
1433
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 );
1440
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 */
1448
1449 /* - Only session flag set */
1450 for (i=4; i<=5; i++)
1451 {
1452 IDirectPlayX_Release( pDPserver[i] );
1453 dpsd_server[i].lpszPasswordA = NULL;
1454 }
1455 dpsd_server[4].dwFlags = DPSESSION_PRIVATE;
1456 dpsd_server[5].dwFlags = DPSESSION_PASSWORDREQUIRED;
1457 for (i=4; i<=5; i++)
1458 {
1459 pDPserver[i] = create_session( &dpsd_server[i] );
1460 }
1461
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 */
1469
1470 /* - Both session flag and password set */
1471 for (i=4; i<=5; i++)
1472 {
1473 IDirectPlayX_Release( pDPserver[i] );
1474 dpsd_server[i].lpszPasswordA = (LPSTR) "password";
1475 }
1476 dpsd_server[4].dwFlags = DPSESSION_PRIVATE;
1477 dpsd_server[5].dwFlags = DPSESSION_PASSWORDREQUIRED;
1478 for (i=4; i<=5; i++)
1479 {
1480 pDPserver[i] = create_session( &dpsd_server[i] );
1481 }
1482
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 );
1489
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 );
1496
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 );
1505
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 );
1512
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 );
1520
1521
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 */
1530
1531
1532 /* GUID tests */
1533
1534 /* - Creating two servers with different application GUIDs */
1535 for (i=4; i<=5; i++)
1536 {
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;
1542 }
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++)
1548 {
1549 pDPserver[i] = create_session( &dpsd_server[i] );
1550 }
1551
1552 callbackData.dwFlags = 0;
1553
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 */
1560
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 */
1567 /* FIXME:
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? */
1570
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 */
1577
1578 for (i=4; i<=5; i++)
1579 {
1580 IDirectPlayX_Release( pDPserver[i] );
1581 }
1582 IDirectPlayX_Release( pDP );
1583
1584 }
1585
1586 /* SetSessionDesc
1587 GetSessionDesc */
1588
1589 static void test_SessionDesc(void)
1590 {
1591
1592 LPDIRECTPLAY4 pDP[2];
1593 DPSESSIONDESC2 dpsd;
1594 LPDPSESSIONDESC2 lpData[2];
1595 LPVOID lpDataMsg;
1596 DPID dpid[2];
1597 DWORD dwDataSize;
1598 HRESULT hr;
1599 UINT i;
1600 CallbackData callbackData;
1601
1602
1603 for (i=0; i<2; i++)
1604 {
1605 CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
1606 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
1607 }
1608 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
1609
1610 /* Service provider not initialized */
1611 hr = IDirectPlayX_SetSessionDesc( pDP[0], NULL, 0 );
1612 checkHR( DPERR_UNINITIALIZED, hr );
1613
1614 hr = IDirectPlayX_GetSessionDesc( pDP[0], NULL, NULL );
1615 checkHR( DPERR_UNINITIALIZED, hr );
1616
1617
1618 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
1619 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
1620
1621
1622 /* No sessions open */
1623 hr = IDirectPlayX_SetSessionDesc( pDP[0], NULL, 0 );
1624 todo_wine checkHR( DPERR_NOSESSIONS, hr );
1625
1626 if ( hr == DPERR_UNINITIALIZED )
1627 {
1628 skip("Get/SetSessionDesc not implemented\n");
1629 return;
1630 }
1631
1632 hr = IDirectPlayX_GetSessionDesc( pDP[0], NULL, NULL );
1633 checkHR( DPERR_NOSESSIONS, hr );
1634
1635
1636 dpsd.dwSize = sizeof(DPSESSIONDESC2);
1637 dpsd.guidApplication = appGuid;
1638 dpsd.dwMaxPlayers = 10;
1639
1640
1641 /* Host */
1642 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
1643 /* Peer */
1644 IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
1645 (LPVOID)pDP[1], 0 );
1646
1647 for (i=0; i<2; i++)
1648 {
1649 /* Players, only to receive messages */
1650 IDirectPlayX_CreatePlayer( pDP[i], &dpid[i], NULL, NULL, NULL, 0, 0 );
1651
1652 lpData[i] = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 1024 );
1653 }
1654 lpDataMsg = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 1024 );
1655
1656
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 );
1664 dwDataSize=-1;
1665 hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], &dwDataSize );
1666 checkHR( DPERR_INVALIDPARAMS, hr );
1667 check( -1, dwDataSize );
1668
1669 /* Get: Insufficient buffer size */
1670 dwDataSize=0;
1671 hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], &dwDataSize );
1672 checkHR( DPERR_BUFFERTOOSMALL, hr );
1673 check( dpsd.dwSize, dwDataSize );
1674 dwDataSize=4;
1675 hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], &dwDataSize );
1676 checkHR( DPERR_BUFFERTOOSMALL, hr );
1677 check( dpsd.dwSize, dwDataSize );
1678 dwDataSize=1024;
1679 hr = IDirectPlayX_GetSessionDesc( pDP[0], NULL, &dwDataSize );
1680 checkHR( DPERR_BUFFERTOOSMALL, hr );
1681 check( dpsd.dwSize, dwDataSize );
1682
1683 /* Get: Regular operation
1684 * i=0: Local session
1685 * i=1: Remote session */
1686 for (i=0; i<2; i++)
1687 {
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 );
1694 }
1695
1696 checkGuid( &lpData[0]->guidInstance, &lpData[1]->guidInstance );
1697
1698 /* Set: Regular operation */
1699 dpsd.lpszSessionNameA = (LPSTR) "Wahaa";
1700 hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
1701 checkHR( DP_OK, hr );
1702
1703 dwDataSize = 1024;
1704 hr = IDirectPlayX_GetSessionDesc( pDP[1], lpData[1], &dwDataSize );
1705 checkHR( DP_OK, hr );
1706 checkStr( dpsd.lpszSessionNameA, lpData[1]->lpszSessionNameA );
1707
1708
1709 /* Set: Failing to modify a remote session */
1710 hr = IDirectPlayX_SetSessionDesc( pDP[1], &dpsd, 0 );
1711 checkHR( DPERR_ACCESSDENIED, hr );
1712
1713 /* Trying to change inmutable properties */
1714 /* Flags */
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 );
1720 dpsd.dwFlags = 0;
1721 hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
1722 checkHR( DP_OK, hr );
1723 /* Size */
1724 dpsd.dwSize = 2048;
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 );
1730
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 );
1738
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 );
1744
1745
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 );
1753
1754 for (i=0; i<2; i++)
1755 {
1756 HeapFree( GetProcessHeap(), 0, lpData[i] );
1757 IDirectPlayX_Release( pDP[i] );
1758 }
1759
1760 }
1761
1762 /* CreatePlayer */
1763
1764 static void test_CreatePlayer(void)
1765 {
1766
1767 LPDIRECTPLAY4 pDP[2];
1768 DPSESSIONDESC2 dpsd;
1769 DPNAME name;
1770 DPID dpid;
1771 HRESULT hr;
1772
1773
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) );
1780
1781
1782 /* Connection not initialized */
1783 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 0, 0 );
1784 checkHR( DPERR_UNINITIALIZED, hr );
1785
1786
1787 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
1788 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
1789
1790
1791 /* Session not open */
1792 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 0, 0 );
1793 todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
1794
1795 if ( hr == DPERR_UNINITIALIZED )
1796 {
1797 skip( "CreatePlayer not implemented\n" );
1798 return;
1799 }
1800
1801 dpsd.dwSize = sizeof(DPSESSIONDESC2);
1802 dpsd.guidApplication = appGuid;
1803 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
1804
1805
1806 /* Player name */
1807 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 0, 0 );
1808 checkHR( DP_OK, hr );
1809
1810
1811 name.dwSize = -1;
1812
1813
1814 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, &name, NULL, NULL, 0, 0 );
1815 checkHR( DP_OK, hr );
1816
1817
1818 name.dwSize = sizeof(DPNAME);
1819 name.lpszShortNameA = (LPSTR) "test";
1820 name.lpszLongNameA = NULL;
1821
1822
1823 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, &name, NULL, NULL,
1824 0, 0 );
1825 checkHR( DP_OK, hr );
1826
1827
1828 /* Null dpid */
1829 hr = IDirectPlayX_CreatePlayer( pDP[0], NULL, NULL, NULL, NULL,
1830 0, 0 );
1831 checkHR( DPERR_INVALIDPARAMS, hr );
1832
1833
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 );
1839
1840 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
1841 0, DPPLAYER_SERVERPLAYER );
1842 checkHR( DPERR_CANTCREATEPLAYER, hr );
1843
1844 IDirectPlayX_DestroyPlayer( pDP[0], dpid );
1845
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 );
1851
1852
1853 /* Flags */
1854 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
1855 0, 0 );
1856 checkHR( DP_OK, hr );
1857
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 );
1863
1864 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
1865 0, DPPLAYER_SPECTATOR );
1866 checkHR( DP_OK, hr );
1867
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 );
1874
1875
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 );
1881
1882
1883 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
1884 0, 0 );
1885 checkHR( DPERR_CANTCREATEPLAYER, hr );
1886
1887 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
1888 0, DPPLAYER_SERVERPLAYER );
1889 checkHR( DPERR_CANTCREATEPLAYER, hr );
1890
1891 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
1892 0, DPPLAYER_SPECTATOR );
1893 checkHR( DPERR_CANTCREATEPLAYER, hr );
1894
1895
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 );
1904
1905
1906 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
1907 0, 0 );
1908 checkHR( DPERR_ACCESSDENIED, hr );
1909
1910 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
1911 0, DPPLAYER_SERVERPLAYER );
1912 checkHR( DP_OK, hr );
1913 check( DPID_SERVERPLAYER, dpid );
1914
1915 hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid, NULL, NULL, NULL,
1916 0, DPPLAYER_SERVERPLAYER );
1917 checkHR( DPERR_INVALIDFLAGS, hr );
1918
1919 hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid, NULL, NULL, NULL,
1920 0, 0 );
1921 checkHR( DP_OK, hr );
1922
1923
1924 IDirectPlayX_Release( pDP[0] );
1925 IDirectPlayX_Release( pDP[1] );
1926
1927 }
1928
1929 /* GetPlayerCaps */
1930
1931 static void test_GetPlayerCaps(void)
1932 {
1933
1934 LPDIRECTPLAY4 pDP[2];
1935 DPSESSIONDESC2 dpsd;
1936 DPID dpid[2];
1937 HRESULT hr;
1938 UINT i;
1939
1940 DPCAPS playerCaps;
1941 DWORD dwFlags;
1942
1943
1944 for (i=0; i<2; i++)
1945 {
1946 CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
1947 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
1948 }
1949 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
1950 dpsd.dwSize = sizeof(DPSESSIONDESC2);
1951 dpsd.guidApplication = appGuid;
1952 dpsd.dwMaxPlayers = 10;
1953
1954 ZeroMemory( &playerCaps, sizeof(DPCAPS) );
1955
1956
1957 /* Uninitialized service provider */
1958 playerCaps.dwSize = 0;
1959 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
1960 checkHR( DPERR_UNINITIALIZED, hr );
1961
1962 playerCaps.dwSize = sizeof(DPCAPS);
1963 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
1964 checkHR( DPERR_UNINITIALIZED, hr );
1965
1966
1967 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
1968 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
1969
1970
1971 /* No session */
1972 playerCaps.dwSize = 0;
1973
1974 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
1975 todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
1976
1977 if ( hr == DPERR_UNINITIALIZED )
1978 {
1979 skip( "GetPlayerCaps not implemented\n" );
1980 return;
1981 }
1982
1983 playerCaps.dwSize = sizeof(DPCAPS);
1984
1985 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
1986 checkHR( DPERR_INVALIDPLAYER, hr );
1987
1988 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 2, &playerCaps, 0 );
1989 checkHR( DPERR_INVALIDPLAYER, hr );
1990
1991
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 );
1997
1998 for (i=0; i<2; i++)
1999 {
2000 hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i],
2001 NULL, NULL, NULL, 0, 0 );
2002 checkHR( DP_OK, hr );
2003 }
2004
2005
2006 /* Uninitialized playerCaps */
2007 playerCaps.dwSize = 0;
2008
2009 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
2010 checkHR( DPERR_INVALIDPARAMS, hr );
2011
2012 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 2, &playerCaps, 0 );
2013 checkHR( DPERR_INVALIDPARAMS, hr );
2014
2015 hr = IDirectPlayX_GetPlayerCaps( pDP[0], dpid[0], &playerCaps, 0 );
2016 checkHR( DPERR_INVALIDPARAMS, hr );
2017
2018
2019 /* Invalid player */
2020 playerCaps.dwSize = sizeof(DPCAPS);
2021
2022 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
2023 checkHR( DPERR_INVALIDPLAYER, hr );
2024
2025 hr = IDirectPlayX_GetPlayerCaps( pDP[0], 2, &playerCaps, 0 );
2026 checkHR( DPERR_INVALIDPLAYER, hr );
2027
2028 hr = IDirectPlayX_GetPlayerCaps( pDP[0], dpid[0], &playerCaps, 0 );
2029 checkHR( DP_OK, hr );
2030
2031
2032 /* Regular parameters */
2033 for (i=0; i<2; i++)
2034 {
2035 for (dwFlags=0;
2036 dwFlags<=DPGETCAPS_GUARANTEED;
2037 dwFlags+=DPGETCAPS_GUARANTEED)
2038 {
2039
2040 hr = IDirectPlayX_GetPlayerCaps( pDP[0], dpid[i],
2041 &playerCaps, dwFlags );
2042 checkHR( DP_OK, hr );
2043
2044
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 );
2052
2053 if ( i == 0 )
2054 {
2055 checkFlags( DPCAPS_ISHOST |
2056 DPCAPS_GUARANTEEDOPTIMIZED |
2057 DPCAPS_GUARANTEEDSUPPORTED |
2058 DPCAPS_ASYNCSUPPORTED |
2059 DPPLAYERCAPS_LOCAL,
2060 playerCaps.dwFlags, FLAGS_DPCAPS );
2061 }
2062 else
2063 checkFlags( DPCAPS_ISHOST |
2064 DPCAPS_GUARANTEEDOPTIMIZED |
2065 DPCAPS_GUARANTEEDSUPPORTED |
2066 DPCAPS_ASYNCSUPPORTED,
2067 playerCaps.dwFlags, FLAGS_DPCAPS );
2068
2069 if ( dwFlags == DPGETCAPS_GUARANTEED )
2070 {
2071 check( 1048547, playerCaps.dwMaxBufferSize );
2072 check( 64, playerCaps.dwMaxPlayers );
2073 }
2074 else
2075 {
2076 check( 65479, playerCaps.dwMaxBufferSize );
2077 check( 65536, playerCaps.dwMaxPlayers );
2078 }
2079
2080 }
2081 }
2082
2083
2084 IDirectPlayX_Release( pDP[0] );
2085 IDirectPlayX_Release( pDP[1] );
2086
2087 }
2088
2089 /* SetPlayerData
2090 GetPlayerData */
2091
2092 static void test_PlayerData(void)
2093 {
2094 LPDIRECTPLAY4 pDP;
2095 DPSESSIONDESC2 dpsd;
2096 DPID dpid;
2097 HRESULT hr;
2098
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;
2102
2103 LPCSTR lpData = "remote_data";
2104 DWORD dwDataSize = strlen(lpData)+1;
2105
2106 LPCSTR lpDataLocal = "local_data";
2107 DWORD dwDataSizeLocal = strlen(lpDataLocal)+1;
2108
2109 LPSTR lpDataGet = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
2110 dwDataSizeFake );
2111 DWORD dwDataSizeGet = dwDataSizeFake;
2112
2113
2114 CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
2115 &IID_IDirectPlay4A, (LPVOID*) &pDP );
2116
2117 /* No service provider */
2118 hr = IDirectPlayX_SetPlayerData( pDP, 0, (LPVOID) lpData,
2119 dwDataSize, 0 );
2120 checkHR( DPERR_UNINITIALIZED, hr );
2121
2122 hr = IDirectPlayX_GetPlayerData( pDP, 0, (LPVOID) lpDataGet,
2123 &dwDataSizeGet, 0 );
2124 checkHR( DPERR_UNINITIALIZED, hr );
2125
2126
2127 init_TCPIP_provider( pDP, "127.0.0.1", 0 );
2128
2129 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
2130 dpsd.dwSize = sizeof(DPSESSIONDESC2);
2131 dpsd.guidApplication = appGuid;
2132 IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE );
2133
2134
2135 /* Invalid player */
2136 hr = IDirectPlayX_SetPlayerData( pDP, 0, (LPVOID) lpData,
2137 dwDataSize, 0 );
2138 todo_wine checkHR( DPERR_INVALIDPLAYER, hr );
2139
2140 hr = IDirectPlayX_GetPlayerData( pDP, 0, (LPVOID) lpDataGet,
2141 &dwDataSizeGet, 0 );
2142 todo_wine checkHR( DPERR_INVALIDPLAYER, hr );
2143
2144 if ( hr == DPERR_UNINITIALIZED )
2145 {
2146 skip( "Get/SetPlayerData not implemented\n" );
2147 return;
2148 }
2149
2150 /* Create the player */
2151 /* By default, the data is remote */
2152 hr = IDirectPlayX_CreatePlayer( pDP, &dpid, NULL, NULL, (LPVOID) lpData,
2153 dwDataSize, 0 );
2154 checkHR( DP_OK, hr );
2155
2156 /* Invalid parameters */
2157 hr = IDirectPlayX_SetPlayerData( pDP, dpid, NULL,
2158 dwDataSize, 0 );
2159 checkHR( DPERR_INVALIDPARAMS, hr );
2160 hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataGet,
2161 -1, 0 );
2162 checkHR( DPERR_INVALIDPARAMS, hr );
2163
2164 hr = IDirectPlayX_GetPlayerData( pDP, dpid, (LPVOID) lpDataGet,
2165 NULL, 0 );
2166 checkHR( DPERR_INVALIDPARAMS, hr );
2167
2168
2169 /*
2170 * Remote data (default)
2171 */
2172
2173
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 );
2182
2183 dwDataSizeGet = 2;
2184 strcpy(lpDataGet, lpDataFake);
2185 hr = IDirectPlayX_GetPlayerData( pDP, dpid, (LPVOID) lpDataGet,
2186 &dwDataSizeGet, 0 );
2187 check( DPERR_BUFFERTOOSMALL, hr );
2188 check( dwDataSize, dwDataSizeGet );
2189
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 );
2196
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 );
2205
2206 /* Flag tests */
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 );
2214
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 );
2222
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 );
2230
2231 dwDataSizeGet = dwDataSizeFake;
2232 strcpy(lpDataGet, lpDataFake);
2233 hr = IDirectPlayX_GetPlayerData( pDP, dpid, (LPVOID) lpDataGet,
2234 &dwDataSizeGet,
2235 DPGET_LOCAL | DPGET_REMOTE );
2236 checkHR( DP_OK, hr );
2237 check( 0, dwDataSizeGet ); /* Same behaviour as in previous test */
2238 checkStr( lpDataFake, lpDataGet );
2239
2240 /* Getting local data (which doesn't exist), buffer size is ignored */
2241 dwDataSizeGet = 0;
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 );
2248
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 );
2256
2257
2258 /*
2259 * Local data
2260 */
2261
2262
2263 /* Invalid flags */
2264 hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataLocal,
2265 dwDataSizeLocal,
2266 DPSET_LOCAL | DPSET_GUARANTEED );
2267 checkHR( DPERR_INVALIDPARAMS, hr );
2268
2269 /* Correct parameters */
2270 hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataLocal,
2271 dwDataSizeLocal, DPSET_LOCAL );
2272 checkHR( DP_OK, hr );
2273
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 );
2282
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 );
2290
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 );
2298
2299 dwDataSizeGet = dwDataSizeFake;
2300 strcpy(lpDataGet, lpDataFake);
2301 hr = IDirectPlayX_GetPlayerData( pDP, dpid, (LPVOID) lpDataGet,
2302 &dwDataSizeGet,
2303 DPGET_LOCAL | DPGET_REMOTE );
2304 checkHR( DP_OK, hr );
2305 check( dwDataSizeLocal, dwDataSizeGet ); /* Like in previous test */
2306 checkStr( lpDataLocal, lpDataGet );
2307
2308 /* Small buffer works as expected again */
2309 dwDataSizeGet = 0;
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 );
2316
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 );
2324
2325
2326 /*
2327 * Changing remote data
2328 */
2329
2330
2331 /* Remote data := local data */
2332 hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataLocal,
2333 dwDataSizeLocal,
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 );
2339
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 );
2347
2348 /* Remote data := fake data */
2349 hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataFake,
2350 dwDataSizeFake, DPSET_REMOTE );
2351 checkHR( DP_OK, hr );
2352
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 );
2360
2361
2362 HeapFree( GetProcessHeap(), 0, lpDataGet );
2363 IDirectPlayX_Release( pDP );
2364 }
2365
2366 /* GetPlayerName
2367 SetPlayerName */
2368
2369 static void test_PlayerName(void)
2370 {
2371
2372 LPDIRECTPLAY4 pDP[2];
2373 DPSESSIONDESC2 dpsd;
2374 DPID dpid[2];
2375 HRESULT hr;
2376 UINT i;
2377
2378 DPNAME playerName;
2379 DWORD dwDataSize = 1024;
2380 LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
2381 CallbackData callbackData;
2382
2383
2384 for (i=0; i<2; i++)
2385 {
2386 CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
2387 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
2388 }
2389 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
2390 ZeroMemory( &playerName, sizeof(DPNAME) );
2391
2392
2393 /* Service provider not initialized */
2394 hr = IDirectPlayX_SetPlayerName( pDP[0], 0, &playerName, 0 );
2395 checkHR( DPERR_UNINITIALIZED, hr );
2396
2397 dwDataSize = 1024;
2398 hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize );
2399 checkHR( DPERR_UNINITIALIZED, hr );
2400 check( 1024, dwDataSize );
2401
2402
2403 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
2404 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
2405
2406
2407 /* Session not initialized */
2408 hr = IDirectPlayX_SetPlayerName( pDP[0], 0, &playerName, 0 );
2409 todo_wine checkHR( DPERR_INVALIDPLAYER, hr );
2410
2411 if ( hr == DPERR_UNINITIALIZED )
2412 {
2413 skip( "Get/SetPlayerName not implemented\n" );
2414 return;
2415 }
2416
2417 dwDataSize = 1024;
2418 hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize );
2419 checkHR( DPERR_INVALIDPLAYER, hr );
2420 check( 1024, dwDataSize );
2421
2422
2423 dpsd.dwSize = sizeof(DPSESSIONDESC2);
2424 dpsd.guidApplication = appGuid;
2425 dpsd.dwMaxPlayers = 10;
2426 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
2427 IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
2428 (LPVOID) pDP[1], 0 );
2429
2430 IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 );
2431 IDirectPlayX_CreatePlayer( pDP[1], &dpid[1], NULL, NULL, NULL, 0, 0 );
2432
2433
2434 /* Name not initialized */
2435 playerName.dwSize = -1;
2436 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, 0 );
2437 checkHR( DP_OK, hr );
2438
2439 dwDataSize = 1024;
2440 hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize );
2441 checkHR( DPERR_INVALIDPLAYER, hr );
2442 check( 1024, dwDataSize );
2443
2444
2445 playerName.dwSize = sizeof(DPNAME);
2446 playerName.lpszShortNameA = (LPSTR) "player_name";
2447 playerName.lpszLongNameA = (LPSTR) "player_long_name";
2448
2449
2450 /* Invalid parameters */
2451 hr = IDirectPlayX_SetPlayerName( pDP[0], -1, &playerName, 0 );
2452 checkHR( DPERR_INVALIDPLAYER, hr );
2453 hr = IDirectPlayX_SetPlayerName( pDP[0], 0, &playerName, 0 );
2454 checkHR( DPERR_INVALIDPLAYER, hr );
2455 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, -1 );
2456 checkHR( DPERR_INVALIDPARAMS, hr );
2457
2458 dwDataSize = 1024;
2459 hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize );
2460 checkHR( DPERR_INVALIDPLAYER, hr );
2461 check( 1024, dwDataSize );
2462
2463 dwDataSize = -1;
2464 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
2465 checkHR( DPERR_INVALIDPARAMS, hr );
2466 check( -1, dwDataSize );
2467
2468 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, NULL );
2469 checkHR( DPERR_INVALIDPARAMS, hr );
2470
2471 /* Trying to modify remote player */
2472 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[1], &playerName, 0 );
2473 checkHR( DPERR_ACCESSDENIED, hr );
2474
2475
2476 /* Regular operation */
2477 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, 0 );
2478
2479 dwDataSize = 1024;
2480 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
2481 checkHR( DP_OK, hr );
2482 check( 45, dwDataSize );
2483 checkStr( playerName.lpszShortNameA, ((LPDPNAME)lpData)->lpszShortNameA );
2484 checkStr( playerName.lpszLongNameA, ((LPDPNAME)lpData)->lpszLongNameA );
2485 check( 0, ((LPDPNAME)lpData)->dwFlags );
2486
2487 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], NULL, 0 );
2488
2489 dwDataSize = 1024;
2490 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
2491 checkHR( DP_OK, hr );
2492 check( 16, dwDataSize );
2493 checkLP( NULL, ((LPDPNAME)lpData)->lpszShortNameA );
2494 checkLP( NULL, ((LPDPNAME)lpData)->lpszLongNameA );
2495 check( 0, ((LPDPNAME)lpData)->dwFlags );
2496
2497
2498 /* Small buffer in get operation */
2499 dwDataSize = 1024;
2500 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], NULL, &dwDataSize );
2501 checkHR( DPERR_BUFFERTOOSMALL, hr );
2502 check( 16, dwDataSize );
2503
2504 dwDataSize = 0;
2505 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
2506 checkHR( DPERR_BUFFERTOOSMALL, hr );
2507 check( 16, dwDataSize );
2508
2509 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
2510 checkHR( DP_OK, hr );
2511 check( 16, dwDataSize );
2512 checkLP( NULL, ((LPDPNAME)lpData)->lpszShortNameA );
2513 checkLP( NULL, ((LPDPNAME)lpData)->lpszLongNameA );
2514 check( 0, ((LPDPNAME)lpData)->dwFlags );
2515
2516
2517 /* Flags */
2518 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName,
2519 DPSET_GUARANTEED );
2520 checkHR( DP_OK, hr );
2521
2522 /* - Local (no propagation) */
2523 playerName.lpszShortNameA = (LPSTR) "no_propagation";
2524 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName,
2525 DPSET_LOCAL );
2526 checkHR( DP_OK, hr );
2527
2528 dwDataSize = 1024;
2529 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0],
2530 lpData, &dwDataSize ); /* Local fetch */
2531 checkHR( DP_OK, hr );
2532 check( 48, dwDataSize );
2533 checkStr( "no_propagation", ((LPDPNAME)lpData)->lpszShortNameA );
2534
2535 dwDataSize = 1024;
2536 hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0],
2537 lpData, &dwDataSize ); /* Remote fetch */
2538 checkHR( DP_OK, hr );
2539 check( 45, dwDataSize );
2540 checkStr( "player_name", ((LPDPNAME)lpData)->lpszShortNameA );
2541
2542 /* -- 2 */
2543
2544 playerName.lpszShortNameA = (LPSTR) "no_propagation_2";
2545 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName,
2546 DPSET_LOCAL | DPSET_REMOTE );
2547 checkHR( DP_OK, hr );
2548
2549 dwDataSize = 1024;
2550 hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0],
2551 lpData, &dwDataSize ); /* Local fetch */
2552 checkHR( DP_OK, hr );
2553 check( 50, dwDataSize );
2554 checkStr( "no_propagation_2", ((LPDPNAME)lpData)->lpszShortNameA );
2555
2556 dwDataSize = 1024;
2557 hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0],
2558 lpData, &dwDataSize ); /* Remote fetch */
2559 checkHR( DP_OK, hr );
2560 check( 45, dwDataSize );
2561 checkStr( "player_name", ((LPDPNAME)lpData)->lpszShortNameA );
2562
2563 /* - Remote (propagation, default) */
2564 playerName.lpszShortNameA = (LPSTR) "propagation";
2565 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName,
2566 DPSET_REMOTE );
2567 checkHR( DP_OK, hr );
2568
2569 dwDataSize = 1024;
2570 hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0],
2571 lpData, &dwDataSize ); /* Remote fetch */
2572 checkHR( DP_OK, hr );
2573 check( 45, dwDataSize );
2574 checkStr( "propagation", ((LPDPNAME)lpData)->lpszShortNameA );
2575
2576 /* -- 2 */
2577 playerName.lpszShortNameA = (LPSTR) "propagation_2";
2578 hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName,
2579 0 );
2580 checkHR( DP_OK, hr );
2581
2582 dwDataSize = 1024;
2583 hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0],
2584 lpData, &dwDataSize ); /* Remote fetch */
2585 checkHR( DP_OK, hr );
2586 check( 47, dwDataSize );
2587 checkStr( "propagation_2", ((LPDPNAME)lpData)->lpszShortNameA );
2588
2589
2590 /* Checking system messages */
2591 check_messages( pDP[0], dpid, 2, &callbackData );
2592 checkStr( "S0,S0,S0,S0,S0,S0,S0,", callbackData.szTrace1 );
2593 checkStr( "48,28,57,28,57,57,59,", callbackData.szTrace2 );
2594 check_messages( pDP[1], dpid, 2, &callbackData );
2595 checkStr( "S1,S1,S1,S1,S1,S1,", callbackData.szTrace1 );
2596 checkStr( "28,57,28,57,57,59,", callbackData.szTrace2 );
2597
2598
2599 HeapFree( GetProcessHeap(), 0, lpData );
2600 IDirectPlayX_Release( pDP[0] );
2601 IDirectPlayX_Release( pDP[1] );
2602
2603 }
2604
2605 /* GetPlayerAccount */
2606
2607 static BOOL FAR PASCAL EnumSessions_cb_join_secure( LPCDPSESSIONDESC2 lpThisSD,
2608 LPDWORD lpdwTimeOut,
2609 DWORD dwFlags,
2610 LPVOID lpContext )
2611 {
2612 LPDIRECTPLAY4 pDP = (LPDIRECTPLAY4) lpContext;
2613 DPSESSIONDESC2 dpsd;
2614 DPCREDENTIALS dpCredentials;
2615 HRESULT hr;
2616
2617 if (dwFlags & DPESC_TIMEDOUT)
2618 {
2619 return FALSE;
2620 }
2621
2622 checkFlags( DPSESSION_SECURESERVER, lpThisSD->dwFlags, FLAGS_DPSESSION );
2623
2624 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
2625 dpsd.dwSize = sizeof(DPSESSIONDESC2);
2626 dpsd.guidApplication = appGuid;
2627 dpsd.guidInstance = lpThisSD->guidInstance;
2628
2629 ZeroMemory( &dpCredentials, sizeof(DPCREDENTIALS) );
2630 dpCredentials.dwSize = sizeof(DPCREDENTIALS);
2631 dpCredentials.lpszUsernameA = (LPSTR) "user";
2632 dpCredentials.lpszPasswordA = (LPSTR) "pass";
2633 hr = IDirectPlayX_SecureOpen( pDP, &dpsd, DPOPEN_JOIN,
2634 NULL, &dpCredentials );
2635 checkHR( DPERR_LOGONDENIED, hr ); /* TODO: Make this work */
2636
2637 return TRUE;
2638 }
2639
2640 static void test_GetPlayerAccount(void)
2641 {
2642
2643 LPDIRECTPLAY4 pDP[2];
2644 DPSESSIONDESC2 dpsd;
2645 DPID dpid[2];
2646 HRESULT hr;
2647 UINT i;
2648
2649 DWORD dwDataSize = 1024;
2650 LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
2651
2652
2653 for (i=0; i<2; i++)
2654 {
2655 CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
2656 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
2657 }
2658 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
2659 dpsd.dwSize = sizeof(DPSESSIONDESC2);
2660 dpsd.guidApplication = appGuid;
2661 dpsd.dwMaxPlayers = 10;
2662
2663 /* Uninitialized service provider */
2664 hr = IDirectPlayX_GetPlayerAccount( pDP[0], 0, 0, lpData, &dwDataSize );
2665 todo_wine checkHR( DPERR_UNINITIALIZED, hr );
2666
2667 if ( hr == DP_OK )
2668 {
2669 skip( "GetPlayerAccount not implemented\n" );
2670 return;
2671 }
2672
2673
2674 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
2675 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
2676
2677
2678 /* No session */
2679 hr = IDirectPlayX_GetPlayerAccount( pDP[0], 0, 0, lpData, &dwDataSize );
2680 checkHR( DPERR_NOSESSIONS, hr );
2681
2682
2683 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
2684 IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
2685 (LPVOID) pDP[1], 0 );
2686
2687 for (i=0; i<2; i++)
2688 {
2689 hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i], NULL, NULL, NULL,
2690 0, 0 );
2691 checkHR( DP_OK, hr );
2692 }
2693
2694
2695 /* Session is not secure */
2696 dwDataSize = 1024;
2697 hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0,
2698 lpData, &dwDataSize );
2699 checkHR( DPERR_UNSUPPORTED, hr );
2700 check( 1024, dwDataSize );
2701
2702
2703 /* Open a secure session */
2704 for (i=0; i<2; i++)
2705 {
2706 hr = IDirectPlayX_Close( pDP[i] );
2707 checkHR( DP_OK, hr );
2708 }
2709
2710 dpsd.dwFlags = DPSESSION_SECURESERVER;
2711 hr = IDirectPlayX_SecureOpen( pDP[0], &dpsd, DPOPEN_CREATE, NULL, NULL );
2712 checkHR( DP_OK, hr );
2713
2714 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[0],
2715 NULL, NULL, NULL, 0, 0 );
2716 checkHR( DP_OK, hr );
2717
2718 hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0,
2719 EnumSessions_cb_join_secure,
2720 (LPVOID) pDP[1], 0 );
2721 checkHR( DP_OK, hr );
2722
2723 hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid[1],
2724 NULL, NULL, NULL, 0, 0 );
2725 checkHR( DPERR_INVALIDPARAMS, hr );
2726
2727 /* TODO: Player creation so that this works */
2728
2729 /* Invalid player */
2730 dwDataSize = 1024;
2731 hr = IDirectPlayX_GetPlayerAccount( pDP[0], 0, 0,
2732 lpData, &dwDataSize );
2733 checkHR( DPERR_INVALIDPLAYER, hr );
2734 check( 1024, dwDataSize );
2735
2736 /* Invalid flags */
2737 dwDataSize = 1024;
2738 hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], -1,
2739 lpData, &dwDataSize );
2740 checkHR( DPERR_INVALIDFLAGS, hr );
2741 check( 1024, dwDataSize );
2742
2743 dwDataSize = 1024;
2744 hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 1,
2745 lpData, &dwDataSize );
2746 checkHR( DPERR_INVALIDFLAGS, hr );
2747 check( 1024, dwDataSize );
2748
2749 /* Small buffer */
2750 dwDataSize = 1024;
2751 hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0,
2752 NULL, &dwDataSize );
2753 checkHR( DPERR_INVALIDPLAYER, hr );
2754 check( 0, dwDataSize );
2755
2756 dwDataSize = 0;
2757 hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0,
2758 lpData, &dwDataSize );
2759 checkHR( DPERR_INVALIDPLAYER, hr );
2760 check( 0, dwDataSize );
2761
2762 hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0,
2763 lpData, &dwDataSize );
2764 checkHR( DPERR_INVALIDPLAYER, hr );
2765 check( 0, dwDataSize );
2766
2767 /* Normal operation */
2768 dwDataSize = 1024;
2769 hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0,
2770 lpData, &dwDataSize );
2771 checkHR( DPERR_INVALIDPLAYER, hr );
2772 check( 1024, dwDataSize );
2773
2774
2775 HeapFree( GetProcessHeap(), 0, lpData );
2776 IDirectPlayX_Release( pDP[0] );
2777 IDirectPlayX_Release( pDP[1] );
2778
2779 }
2780
2781 /* GetPlayerAddress */
2782
2783 static BOOL FAR PASCAL EnumAddress_cb( REFGUID guidDataType,
2784 DWORD dwDataSize,
2785 LPCVOID lpData,
2786 LPVOID lpContext )
2787 {
2788 lpCallbackData callbackData = (lpCallbackData) lpContext;
2789 static REFGUID types[] = { &DPAID_TotalSize,
2790 &DPAID_ServiceProvider,
2791 &DPAID_INet,
2792 &DPAID_INetW };
2793 static DWORD sizes[] = { 4, 16, 12, 24, 4, 16, 10, 20 };
2794
2795
2796 checkGuid( types[callbackData->dwCounter1%4], guidDataType );
2797 check( sizes[callbackData->dwCounter1], dwDataSize );
2798
2799 switch(callbackData->dwCounter1)
2800 {
2801 case 0:
2802 check( 136, *(LPDWORD) lpData );
2803 break;
2804 case 4:
2805 check( 130, *(LPDWORD) lpData );
2806 break;
2807 case 1:
2808 case 5:
2809 checkGuid( &DPSPGUID_TCPIP, (LPGUID) lpData );
2810 break;
2811 case 6:
2812 checkStr( "127.0.0.1", (LPSTR) lpData );
2813 break;
2814 default: break;
2815 }
2816
2817
2818 callbackData->dwCounter1++;
2819
2820 return TRUE;
2821 }
2822
2823 static void test_GetPlayerAddress(void)
2824 {
2825
2826 LPDIRECTPLAY4 pDP[2];
2827 LPDIRECTPLAYLOBBY3 pDPL;
2828 DPSESSIONDESC2 dpsd;
2829 DPID dpid[2];
2830 CallbackData callbackData;
2831 HRESULT hr;
2832 UINT i;
2833
2834 DWORD dwDataSize = 1024;
2835 LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
2836
2837
2838 for (i=0; i<2; i++)
2839 {
2840 CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
2841 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
2842 }
2843 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
2844 CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL,
2845 &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL );
2846
2847
2848 /* Uninitialized service provider */
2849 hr = IDirectPlayX_GetPlayerAddress( pDP[0], 0, lpData, &dwDataSize );
2850 todo_wine checkHR( DPERR_UNINITIALIZED, hr );
2851
2852 if ( hr == DP_OK )
2853 {
2854 skip( "GetPlayerAddress not implemented\n" );
2855 return;
2856 }
2857
2858 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
2859 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
2860
2861
2862 /* No session */
2863 dwDataSize = 1024;
2864 hr = IDirectPlayX_GetPlayerAddress( pDP[0], 0, lpData, &dwDataSize );
2865 checkHR( DPERR_UNSUPPORTED, hr );
2866 check( 1024, dwDataSize );
2867
2868 dwDataSize = 1024;
2869 hr = IDirectPlayX_GetPlayerAddress( pDP[0], 1, lpData, &dwDataSize );
2870 checkHR( DPERR_INVALIDPLAYER, hr );
2871 check( 1024, dwDataSize );
2872
2873
2874 dpsd.dwSize = sizeof(DPSESSIONDESC2);
2875 dpsd.guidApplication = appGuid;
2876 dpsd.dwMaxPlayers = 10;
2877 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
2878 IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
2879 (LPVOID) pDP[1], 0 );
2880
2881 for (i=0; i<2; i++)
2882 {
2883 hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i], NULL, NULL, NULL,
2884 0, 0 );
2885 checkHR( DP_OK, hr );
2886 }
2887
2888 /* Invalid player */
2889 dwDataSize = 1024;
2890 hr = IDirectPlayX_GetPlayerAddress( pDP[0], 0,
2891 lpData, &dwDataSize );
2892 checkHR( DPERR_UNSUPPORTED, hr );
2893 check( 1024, dwDataSize );
2894
2895 dwDataSize = 1024;
2896 hr = IDirectPlayX_GetPlayerAddress( pDP[0], 1,
2897 lpData, &dwDataSize );
2898 checkHR( DPERR_INVALIDPLAYER, hr );
2899 check( 1024, dwDataSize );
2900
2901 /* Small buffer */
2902 dwDataSize = 1024;
2903 hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0],
2904 NULL, &dwDataSize );
2905 checkHR( DPERR_BUFFERTOOSMALL, hr );
2906 check( 136, dwDataSize );
2907
2908 dwDataSize = 0;
2909 hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0],
2910 lpData, &dwDataSize );
2911 checkHR( DPERR_BUFFERTOOSMALL, hr );
2912 check( 136, dwDataSize );
2913
2914 hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0],
2915 lpData, &dwDataSize );
2916 checkHR( DP_OK, hr );
2917 check( 136, dwDataSize );
2918
2919
2920 /* Regular parameters */
2921 callbackData.dwCounter1 = 0;
2922
2923 /* - Local */
2924 dwDataSize = 1024;
2925 hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0],
2926 lpData, &dwDataSize );
2927 checkHR( DP_OK, hr );
2928 check( 136, dwDataSize );
2929
2930 hr = IDirectPlayLobby_EnumAddress( pDPL, EnumAddress_cb,
2931 (LPCVOID) lpData, dwDataSize,
2932 (LPVOID) &callbackData );
2933 checkHR( DP_OK, hr );
2934
2935 check( 4, callbackData.dwCounter1 );
2936
2937 /* - Remote */
2938 dwDataSize = 1024;
2939 hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[1],
2940 lpData, &dwDataSize );
2941 checkHR( DP_OK, hr );
2942 check( 130, dwDataSize );
2943
2944 hr = IDirectPlayLobby_EnumAddress( pDPL, EnumAddress_cb,
2945 (LPCVOID) lpData, dwDataSize,
2946 (LPVOID) &callbackData );
2947 checkHR( DP_OK, hr );
2948
2949 check( 8, callbackData.dwCounter1 );
2950
2951
2952 HeapFree( GetProcessHeap(), 0, lpData );
2953 IDirectPlayX_Release( pDP[0] );
2954 IDirectPlayX_Release( pDP[1] );
2955
2956 }
2957
2958 /* GetPlayerFlags */
2959
2960 static void test_GetPlayerFlags(void)
2961 {
2962
2963 LPDIRECTPLAY4 pDP[2];
2964 DPSESSIONDESC2 dpsd;
2965 DPID dpid[4];
2966 HRESULT hr;
2967 UINT i;
2968
2969 DWORD dwFlags = 0;
2970
2971
2972 for (i=0; i<2; i++)
2973 {
2974 CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
2975 &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
2976 }
2977 ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
2978 dpsd.dwSize = sizeof(DPSESSIONDESC2);
2979 dpsd.guidApplication = appGuid;
2980 dpsd.dwMaxPlayers = 10;
2981
2982 /* Uninitialized service provider */
2983 hr = IDirectPlayX_GetPlayerFlags( pDP[0], 0, &dwFlags );
2984 todo_wine checkHR( DPERR_UNINITIALIZED, hr );
2985
2986 if ( hr == DP_OK )
2987 {
2988 skip( "GetPlayerFlags not implemented\n" );
2989 return;
2990 }
2991
2992 init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
2993 init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
2994
2995
2996 /* No session */
2997 hr = IDirectPlayX_GetPlayerFlags( pDP[0], 0, &dwFlags );
2998 checkHR( DPERR_INVALIDPLAYER, hr );
2999
3000 hr = IDirectPlayX_GetPlayerFlags( pDP[0], 1, &dwFlags );
3001 checkHR( DPERR_INVALIDPLAYER, hr );
3002
3003
3004 IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
3005 IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
3006 (LPVOID) pDP[1], 0 );
3007
3008 for (i=0; i<2; i++)
3009 {
3010 hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i],
3011 NULL, NULL, NULL, 0, 0 );
3012 checkHR( DP_OK, hr );
3013 }
3014 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[2],
3015 NULL, NULL, NULL,
3016 0, DPPLAYER_SPECTATOR );
3017 checkHR( DP_OK, hr );
3018 hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[3],
3019 NULL, NULL, NULL,
3020 0, DPPLAYER_SERVERPLAYER );
3021 checkHR( DP_OK, hr );
3022
3023
3024 /* Invalid player */
3025 hr = IDirectPlayX_GetPlayerFlags( pDP[0], 0, &dwFlags );
3026 checkHR( DPERR_INVALIDPLAYER, hr );
3027
3028 hr = IDirectPlayX_GetPlayerFlags( pDP[0], 2, &dwFlags );
3029 checkHR( DPERR_INVALIDPLAYER, hr );
3030
3031 /* Invalid parameters */
3032 hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[0], NULL );
3033 checkHR( DPERR_INVALIDPARAMS, hr );
3034
3035
3036 /* Regular parameters */
3037 hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[0], &dwFlags );
3038 checkHR( DP_OK, hr );
3039 checkFlags( dwFlags, DPPLAYER_LOCAL, FLAGS_DPPLAYER );
3040
3041 hr = IDirectPlayX_GetPlayerFlags( pDP[1], dpid[1], &dwFlags );
3042 checkHR( DP_OK, hr );
3043 checkFlags( dwFlags, DPPLAYER_LOCAL, FLAGS_DPPLAYER );
3044
3045 hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[1], &dwFlags );
3046 checkHR( DP_OK, hr );
3047 checkFlags( dwFlags, 0, FLAGS_DPPLAYER );
3048
3049 hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[2], &dwFlags );
3050 checkHR( DP_OK, hr );
3051 checkFlags( dwFlags, DPPLAYER_SPECTATOR | DPPLAYER_LOCAL, FLAGS_DPPLAYER );
3052
3053 hr = IDirectPlayX_GetPlayerFlags( pDP[1], dpid[3], &dwFlags );
3054 checkHR( DP_OK, hr );
3055 checkFlags( dwFlags, DPPLAYER_SERVERPLAYER, FLAGS_DPPLAYER );
3056
3057
3058 IDirectPlayX_Release( pDP[0] );
3059 IDirectPlayX_Release( pDP[1] );
3060
3061 }
3062
3063
3064 START_TEST(dplayx)
3065 {
3066 CoInitialize( NULL );
3067
3068 test_DirectPlayCreate();
3069 test_EnumConnections();
3070 test_InitializeConnection();
3071
3072 test_GetCaps();
3073 test_Open();
3074 test_EnumSessions();
3075 test_SessionDesc();
3076
3077 test_CreatePlayer();
3078 test_GetPlayerCaps();
3079 test_PlayerData();
3080 test_PlayerName();
3081 test_GetPlayerAccount();
3082 test_GetPlayerAddress();
3083 test_GetPlayerFlags();
3084
3085 CoUninitialize();
3086 }
DirectPlay implementation for GSoC