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