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