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