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