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