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