projects / reactos.git / blob
? search:


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