Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-10-30 19:41:57 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/rostests/winetests/dplayx/dplayx.c
Amine Khaldi ccad9a3981 [DPLAYX_WINETEST] 
* Sync with Wine 1.7.17.
CORE-8080

svn path=/trunk/; revision=62829
2014-04-20 00:08:29 +00:00

6586 lines
225 KiB
C
Raw Blame History

/* DirectPlay Conformance Tests
*
* Copyright 2007 - Alessandro Pignotti
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#define COBJMACROS
#include "wine/test.h"
#include <stdio.h>
#define INITGUID
#include <dplay.h>
#include <dplobby.h>
#define check(expected, result) \
ok( (expected) == (result), \
"expected=%d got=%d\n", \
(int)(expected), (int)(result) );
#define checkLP(expected, result) \
ok( (expected) == (result), \
"expected=%p got=%p\n", \
expected, result );
#define checkHR(expected, result) \
ok( (expected) == (result), \
"expected=%s got=%s\n", \
dpResult2str(expected), dpResult2str(result) );
#define checkStr(expected, result) \
ok( (result != NULL) && (!strcmp(expected, result)), \
"expected=%s got=%s\n", \
expected, result );
#define checkFlags(expected, result, flags) \
ok( (expected) == (result), \
"expected=0x%08x(%s) got=0x%08x(%s)\n", \
expected, dwFlags2str(expected, flags), \
result, dwFlags2str(result, flags) );
#define checkGuid(expected, result) \
ok( IsEqualGUID(expected, result), \
"expected=%s got=%s\n", \
Guid2str(expected), Guid2str(result) );
#define checkConv(expected, result, function) \
ok( (expected) == (result), \
"expected=0x%08x(%s) got=0x%08x(%s)\n", \
expected, function(expected), \
result, function(result) );
DEFINE_GUID(appGuid, 0xbdcfe03e, 0xf0ec, 0x415b, 0x82, 0x11, 0x6f, 0x86, 0xd8, 0x19, 0x7f, 0xe1);
DEFINE_GUID(appGuid2, 0x93417d3f, 0x7d26, 0x46ba, 0xb5, 0x76, 0xfe, 0x4b, 0x20, 0xbb, 0xad, 0x70);
DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
typedef struct tagCallbackData
{
IDirectPlay4 *pDP;
UINT dwCounter1, dwCounter2;
DWORD dwFlags;
char szTrace1[1024], szTrace2[1024];
DPID *dpid;
UINT dpidSize;
} CallbackData, *lpCallbackData;
static LPSTR get_temp_buffer(void)
{
static UINT index = 0;
static char buff[10][256];
index = (index + 1) % 10;
*buff[index] = 0;
return buff[index];
}
static LPCSTR Guid2str(const GUID *guid)
{
if (!guid) return "(null)";
/* Service providers */
if (IsEqualGUID(guid, &DPSPGUID_IPX))
return "DPSPGUID_IPX";
if (IsEqualGUID(guid, &DPSPGUID_TCPIP))
return "DPSPGUID_TCPIP";
if (IsEqualGUID(guid, &DPSPGUID_SERIAL))
return "DPSPGUID_SERIAL";
if (IsEqualGUID(guid, &DPSPGUID_MODEM))
return "DPSPGUID_MODEM";
/* DirectPlay Address IDs */
if (IsEqualGUID(guid, &DPAID_TotalSize))
return "DPAID_TotalSize";
if (IsEqualGUID(guid, &DPAID_ServiceProvider))
return "DPAID_ServiceProvider";
if (IsEqualGUID(guid, &DPAID_LobbyProvider))
return "DPAID_LobbyProvider";
if (IsEqualGUID(guid, &DPAID_Phone))
return "DPAID_Phone";
if (IsEqualGUID(guid, &DPAID_PhoneW))
return "DPAID_PhoneW";
if (IsEqualGUID(guid, &DPAID_Modem))
return "DPAID_Modem";
if (IsEqualGUID(guid, &DPAID_ModemW))
return "DPAID_ModemW";
if (IsEqualGUID(guid, &DPAID_INet))
return "DPAID_INet";
if (IsEqualGUID(guid, &DPAID_INetW))
return "DPAID_INetW";
if (IsEqualGUID(guid, &DPAID_INetPort))
return "DPAID_INetPort";
if (IsEqualGUID(guid, &DPAID_ComPort))
return "DPAID_ComPort";
return wine_dbgstr_guid(guid);
}
static LPCSTR dpResult2str(HRESULT hr)
{
switch (hr)
{
case DP_OK: return "DP_OK";
case DPERR_ALREADYINITIALIZED: return "DPERR_ALREADYINITIALIZED";
case DPERR_ACCESSDENIED: return "DPERR_ACCESSDENIED";
case DPERR_ACTIVEPLAYERS: return "DPERR_ACTIVEPLAYERS";
case DPERR_BUFFERTOOSMALL: return "DPERR_BUFFERTOOSMALL";
case DPERR_CANTADDPLAYER: return "DPERR_CANTADDPLAYER";
case DPERR_CANTCREATEGROUP: return "DPERR_CANTCREATEGROUP";
case DPERR_CANTCREATEPLAYER: return "DPERR_CANTCREATEPLAYER";
case DPERR_CANTCREATESESSION: return "DPERR_CANTCREATESESSION";
case DPERR_CAPSNOTAVAILABLEYET: return "DPERR_CAPSNOTAVAILABLEYET";
case DPERR_EXCEPTION: return "DPERR_EXCEPTION";
case DPERR_GENERIC: return "DPERR_GENERIC";
case DPERR_INVALIDFLAGS: return "DPERR_INVALIDFLAGS";
case DPERR_INVALIDOBJECT: return "DPERR_INVALIDOBJECT";
case DPERR_INVALIDPARAMS: return "DPERR_INVALIDPARAMS";
/* symbol with the same value: DPERR_INVALIDPARAM */
case DPERR_INVALIDPLAYER: return "DPERR_INVALIDPLAYER";
case DPERR_INVALIDGROUP: return "DPERR_INVALIDGROUP";
case DPERR_NOCAPS: return "DPERR_NOCAPS";
case DPERR_NOCONNECTION: return "DPERR_NOCONNECTION";
case DPERR_NOMEMORY: return "DPERR_NOMEMORY";
/* symbol with the same value: DPERR_OUTOFMEMORY */
case DPERR_NOMESSAGES: return "DPERR_NOMESSAGES";
case DPERR_NONAMESERVERFOUND: return "DPERR_NONAMESERVERFOUND";
case DPERR_NOPLAYERS: return "DPERR_NOPLAYERS";
case DPERR_NOSESSIONS: return "DPERR_NOSESSIONS";
case DPERR_PENDING: return "DPERR_PENDING";
case DPERR_SENDTOOBIG: return "DPERR_SENDTOOBIG";
case DPERR_TIMEOUT: return "DPERR_TIMEOUT";
case DPERR_UNAVAILABLE: return "DPERR_UNAVAILABLE";
case DPERR_UNSUPPORTED: return "DPERR_UNSUPPORTED";
case DPERR_BUSY: return "DPERR_BUSY";
case DPERR_USERCANCEL: return "DPERR_USERCANCEL";
case DPERR_NOINTERFACE: return "DPERR_NOINTERFACE";
case DPERR_CANNOTCREATESERVER: return "DPERR_CANNOTCREATESERVER";
case DPERR_PLAYERLOST: return "DPERR_PLAYERLOST";
case DPERR_SESSIONLOST: return "DPERR_SESSIONLOST";
case DPERR_UNINITIALIZED: return "DPERR_UNINITIALIZED";
case DPERR_NONEWPLAYERS: return "DPERR_NONEWPLAYERS";
case DPERR_INVALIDPASSWORD: return "DPERR_INVALIDPASSWORD";
case DPERR_CONNECTING: return "DPERR_CONNECTING";
case DPERR_CONNECTIONLOST: return "DPERR_CONNECTIONLOST";
case DPERR_UNKNOWNMESSAGE: return "DPERR_UNKNOWNMESSAGE";
case DPERR_CANCELFAILED: return "DPERR_CANCELFAILED";
case DPERR_INVALIDPRIORITY: return "DPERR_INVALIDPRIORITY";
case DPERR_NOTHANDLED: return "DPERR_NOTHANDLED";
case DPERR_CANCELLED: return "DPERR_CANCELLED";
case DPERR_ABORTED: return "DPERR_ABORTED";
case DPERR_BUFFERTOOLARGE: return "DPERR_BUFFERTOOLARGE";
case DPERR_CANTCREATEPROCESS: return "DPERR_CANTCREATEPROCESS";
case DPERR_APPNOTSTARTED: return "DPERR_APPNOTSTARTED";
case DPERR_INVALIDINTERFACE: return "DPERR_INVALIDINTERFACE";
case DPERR_NOSERVICEPROVIDER: return "DPERR_NOSERVICEPROVIDER";
case DPERR_UNKNOWNAPPLICATION: return "DPERR_UNKNOWNAPPLICATION";
case DPERR_NOTLOBBIED: return "DPERR_NOTLOBBIED";
case DPERR_SERVICEPROVIDERLOADED: return "DPERR_SERVICEPROVIDERLOADED";
case DPERR_ALREADYREGISTERED: return "DPERR_ALREADYREGISTERED";
case DPERR_NOTREGISTERED: return "DPERR_NOTREGISTERED";
case DPERR_AUTHENTICATIONFAILED: return "DPERR_AUTHENTICATIONFAILED";
case DPERR_CANTLOADSSPI: return "DPERR_CANTLOADSSPI";
case DPERR_ENCRYPTIONFAILED: return "DPERR_ENCRYPTIONFAILED";
case DPERR_SIGNFAILED: return "DPERR_SIGNFAILED";
case DPERR_CANTLOADSECURITYPACKAGE: return "DPERR_CANTLOADSECURITYPACKAGE";
case DPERR_ENCRYPTIONNOTSUPPORTED: return "DPERR_ENCRYPTIONNOTSUPPORTED";
case DPERR_CANTLOADCAPI: return "DPERR_CANTLOADCAPI";
case DPERR_NOTLOGGEDIN: return "DPERR_NOTLOGGEDIN";
case DPERR_LOGONDENIED: return "DPERR_LOGONDENIED";
case CLASS_E_NOAGGREGATION: return "CLASS_E_NOAGGREGATION";
default:
{
LPSTR buffer = get_temp_buffer();
sprintf( buffer, "%d", HRESULT_CODE(hr) );
return buffer;
}
}
}
static LPCSTR dpMsgType2str(DWORD dwType)
{
switch(dwType)
{
case DPSYS_CREATEPLAYERORGROUP: return "DPSYS_CREATEPLAYERORGROUP";
case DPSYS_DESTROYPLAYERORGROUP: return "DPSYS_DESTROYPLAYERORGROUP";
case DPSYS_ADDPLAYERTOGROUP: return "DPSYS_ADDPLAYERTOGROUP";
case DPSYS_DELETEPLAYERFROMGROUP: return "DPSYS_DELETEPLAYERFROMGROUP";
case DPSYS_SESSIONLOST: return "DPSYS_SESSIONLOST";
case DPSYS_HOST: return "DPSYS_HOST";
case DPSYS_SETPLAYERORGROUPDATA: return "DPSYS_SETPLAYERORGROUPDATA";
case DPSYS_SETPLAYERORGROUPNAME: return "DPSYS_SETPLAYERORGROUPNAME";
case DPSYS_SETSESSIONDESC: return "DPSYS_SETSESSIONDESC";
case DPSYS_ADDGROUPTOGROUP: return "DPSYS_ADDGROUPTOGROUP";
case DPSYS_DELETEGROUPFROMGROUP: return "DPSYS_DELETEGROUPFROMGROUP";
case DPSYS_SECUREMESSAGE: return "DPSYS_SECUREMESSAGE";
case DPSYS_STARTSESSION: return "DPSYS_STARTSESSION";
case DPSYS_CHAT: return "DPSYS_DPSYS_CHAT";
case DPSYS_SETGROUPOWNER: return "DPSYS_SETGROUPOWNER";
case DPSYS_SENDCOMPLETE: return "DPSYS_SENDCOMPLETE";
default: return "UNKNOWN";
}
}
static LPCSTR dwFlags2str(DWORD dwFlags, DWORD flagType)
{
#define FLAGS_DPCONNECTION (1<<0)
#define FLAGS_DPENUMPLAYERS (1<<1)
#define FLAGS_DPENUMGROUPS (1<<2)
#define FLAGS_DPPLAYER (1<<3)
#define FLAGS_DPGROUP (1<<4)
#define FLAGS_DPENUMSESSIONS (1<<5)
#define FLAGS_DPGETCAPS (1<<6)
#define FLAGS_DPGET (1<<7)
#define FLAGS_DPRECEIVE (1<<8)
#define FLAGS_DPSEND (1<<9)
#define FLAGS_DPSET (1<<10)
#define FLAGS_DPMESSAGEQUEUE (1<<11)
#define FLAGS_DPCONNECT (1<<12)
#define FLAGS_DPOPEN (1<<13)
#define FLAGS_DPSESSION (1<<14)
#define FLAGS_DPLCONNECTION (1<<15)
#define FLAGS_DPESC (1<<16)
#define FLAGS_DPCAPS (1<<17)
LPSTR flags = get_temp_buffer();
/* EnumConnections */
if (flagType & FLAGS_DPCONNECTION)
{
if (dwFlags & DPCONNECTION_DIRECTPLAY)
strcat(flags, "DPCONNECTION_DIRECTPLAY,");
if (dwFlags & DPCONNECTION_DIRECTPLAYLOBBY)
strcat(flags, "DPCONNECTION_DIRECTPLAYLOBBY,");
}
/* EnumPlayers,
EnumGroups */
if (flagType & FLAGS_DPENUMPLAYERS)
{
if (dwFlags == DPENUMPLAYERS_ALL)
strcat(flags, "DPENUMPLAYERS_ALL,");
if (dwFlags & DPENUMPLAYERS_LOCAL)
strcat(flags, "DPENUMPLAYERS_LOCAL,");
if (dwFlags & DPENUMPLAYERS_REMOTE)
strcat(flags, "DPENUMPLAYERS_REMOTE,");
if (dwFlags & DPENUMPLAYERS_GROUP)
strcat(flags, "DPENUMPLAYERS_GROUP,");
if (dwFlags & DPENUMPLAYERS_SESSION)
strcat(flags, "DPENUMPLAYERS_SESSION,");
if (dwFlags & DPENUMPLAYERS_SERVERPLAYER)
strcat(flags, "DPENUMPLAYERS_SERVERPLAYER,");
if (dwFlags & DPENUMPLAYERS_SPECTATOR)
strcat(flags, "DPENUMPLAYERS_SPECTATOR,");
if (dwFlags & DPENUMPLAYERS_OWNER)
strcat(flags, "DPENUMPLAYERS_OWNER,");
}
if (flagType & FLAGS_DPENUMGROUPS)
{
if (dwFlags == DPENUMGROUPS_ALL)
strcat(flags, "DPENUMGROUPS_ALL,");
if (dwFlags & DPENUMPLAYERS_LOCAL)
strcat(flags, "DPENUMGROUPS_LOCAL,");
if (dwFlags & DPENUMPLAYERS_REMOTE)
strcat(flags, "DPENUMGROUPS_REMOTE,");
if (dwFlags & DPENUMPLAYERS_GROUP)
strcat(flags, "DPENUMGROUPS_GROUP,");
if (dwFlags & DPENUMPLAYERS_SESSION)
strcat(flags, "DPENUMGROUPS_SESSION,");
if (dwFlags & DPENUMGROUPS_SHORTCUT)
strcat(flags, "DPENUMGROUPS_SHORTCUT,");
if (dwFlags & DPENUMGROUPS_STAGINGAREA)
strcat(flags, "DPENUMGROUPS_STAGINGAREA,");
if (dwFlags & DPENUMGROUPS_HIDDEN)
strcat(flags, "DPENUMGROUPS_HIDDEN,");
}
/* CreatePlayer */
if (flagType & FLAGS_DPPLAYER)
{
if (dwFlags & DPPLAYER_SERVERPLAYER)
strcat(flags, "DPPLAYER_SERVERPLAYER,");
if (dwFlags & DPPLAYER_SPECTATOR)
strcat(flags, "DPPLAYER_SPECTATOR,");
if (dwFlags & DPPLAYER_LOCAL)
strcat(flags, "DPPLAYER_LOCAL,");
if (dwFlags & DPPLAYER_OWNER)
strcat(flags, "DPPLAYER_OWNER,");
}
/* CreateGroup */
if (flagType & FLAGS_DPGROUP)
{
if (dwFlags & DPGROUP_STAGINGAREA)
strcat(flags, "DPGROUP_STAGINGAREA,");
if (dwFlags & DPGROUP_LOCAL)
strcat(flags, "DPGROUP_LOCAL,");
if (dwFlags & DPGROUP_HIDDEN)
strcat(flags, "DPGROUP_HIDDEN,");
}
/* EnumSessions */
if (flagType & FLAGS_DPENUMSESSIONS)
{
if (dwFlags & DPENUMSESSIONS_AVAILABLE)
strcat(flags, "DPENUMSESSIONS_AVAILABLE,");
if (dwFlags & DPENUMSESSIONS_ALL)
strcat(flags, "DPENUMSESSIONS_ALL,");
if (dwFlags & DPENUMSESSIONS_ASYNC)
strcat(flags, "DPENUMSESSIONS_ASYNC,");
if (dwFlags & DPENUMSESSIONS_STOPASYNC)
strcat(flags, "DPENUMSESSIONS_STOPASYNC,");
if (dwFlags & DPENUMSESSIONS_PASSWORDREQUIRED)
strcat(flags, "DPENUMSESSIONS_PASSWORDREQUIRED,");
if (dwFlags & DPENUMSESSIONS_RETURNSTATUS)
strcat(flags, "DPENUMSESSIONS_RETURNSTATUS,");
}
/* GetCaps,
GetPlayerCaps */
if (flagType & FLAGS_DPGETCAPS)
{
if (dwFlags & DPGETCAPS_GUARANTEED)
strcat(flags, "DPGETCAPS_GUARANTEED,");
}
/* GetGroupData,
GetPlayerData */
if (flagType & FLAGS_DPGET)
{
if (dwFlags == DPGET_REMOTE)
strcat(flags, "DPGET_REMOTE,");
if (dwFlags & DPGET_LOCAL)
strcat(flags, "DPGET_LOCAL,");
}
/* Receive */
if (flagType & FLAGS_DPRECEIVE)
{
if (dwFlags & DPRECEIVE_ALL)
strcat(flags, "DPRECEIVE_ALL,");
if (dwFlags & DPRECEIVE_TOPLAYER)
strcat(flags, "DPRECEIVE_TOPLAYER,");
if (dwFlags & DPRECEIVE_FROMPLAYER)
strcat(flags, "DPRECEIVE_FROMPLAYER,");
if (dwFlags & DPRECEIVE_PEEK)
strcat(flags, "DPRECEIVE_PEEK,");
}
/* Send */
if (flagType & FLAGS_DPSEND)
{
/*if (dwFlags == DPSEND_NONGUARANTEED)
strcat(flags, "DPSEND_NONGUARANTEED,");*/
if (dwFlags == DPSEND_MAX_PRIORITY) /* = DPSEND_MAX_PRI */
{
strcat(flags, "DPSEND_MAX_PRIORITY,");
}
else
{
if (dwFlags & DPSEND_GUARANTEED)
strcat(flags, "DPSEND_GUARANTEED,");
if (dwFlags & DPSEND_HIGHPRIORITY)
strcat(flags, "DPSEND_HIGHPRIORITY,");
if (dwFlags & DPSEND_OPENSTREAM)
strcat(flags, "DPSEND_OPENSTREAM,");
if (dwFlags & DPSEND_CLOSESTREAM)
strcat(flags, "DPSEND_CLOSESTREAM,");
if (dwFlags & DPSEND_SIGNED)
strcat(flags, "DPSEND_SIGNED,");
if (dwFlags & DPSEND_ENCRYPTED)
strcat(flags, "DPSEND_ENCRYPTED,");
if (dwFlags & DPSEND_LOBBYSYSTEMMESSAGE)
strcat(flags, "DPSEND_LOBBYSYSTEMMESSAGE,");
if (dwFlags & DPSEND_ASYNC)
strcat(flags, "DPSEND_ASYNC,");
if (dwFlags & DPSEND_NOSENDCOMPLETEMSG)
strcat(flags, "DPSEND_NOSENDCOMPLETEMSG,");
}
}
/* SetGroupData,
SetGroupName,
SetPlayerData,
SetPlayerName,
SetSessionDesc */
if (flagType & FLAGS_DPSET)
{
if (dwFlags == DPSET_REMOTE)
strcat(flags, "DPSET_REMOTE,");
if (dwFlags & DPSET_LOCAL)
strcat(flags, "DPSET_LOCAL,");
if (dwFlags & DPSET_GUARANTEED)
strcat(flags, "DPSET_GUARANTEED,");
}
/* GetMessageQueue */
if (flagType & FLAGS_DPMESSAGEQUEUE)
{
if (dwFlags & DPMESSAGEQUEUE_SEND)
strcat(flags, "DPMESSAGEQUEUE_SEND,");
if (dwFlags & DPMESSAGEQUEUE_RECEIVE)
strcat(flags, "DPMESSAGEQUEUE_RECEIVE,");
}
/* Connect */
if (flagType & FLAGS_DPCONNECT)
{
if (dwFlags & DPCONNECT_RETURNSTATUS)
strcat(flags, "DPCONNECT_RETURNSTATUS,");
}
/* Open */
if (flagType & FLAGS_DPOPEN)
{
if (dwFlags & DPOPEN_JOIN)
strcat(flags, "DPOPEN_JOIN,");
if (dwFlags & DPOPEN_CREATE)
strcat(flags, "DPOPEN_CREATE,");
if (dwFlags & DPOPEN_RETURNSTATUS)
strcat(flags, "DPOPEN_RETURNSTATUS,");
}
/* DPSESSIONDESC2 */
if (flagType & FLAGS_DPSESSION)
{
if (dwFlags & DPSESSION_NEWPLAYERSDISABLED)
strcat(flags, "DPSESSION_NEWPLAYERSDISABLED,");
if (dwFlags & DPSESSION_MIGRATEHOST)
strcat(flags, "DPSESSION_MIGRATEHOST,");
if (dwFlags & DPSESSION_NOMESSAGEID)
strcat(flags, "DPSESSION_NOMESSAGEID,");
if (dwFlags & DPSESSION_JOINDISABLED)
strcat(flags, "DPSESSION_JOINDISABLED,");
if (dwFlags & DPSESSION_KEEPALIVE)
strcat(flags, "DPSESSION_KEEPALIVE,");
if (dwFlags & DPSESSION_NODATAMESSAGES)
strcat(flags, "DPSESSION_NODATAMESSAGES,");
if (dwFlags & DPSESSION_SECURESERVER)
strcat(flags, "DPSESSION_SECURESERVER,");
if (dwFlags & DPSESSION_PRIVATE)
strcat(flags, "DPSESSION_PRIVATE,");
if (dwFlags & DPSESSION_PASSWORDREQUIRED)
strcat(flags, "DPSESSION_PASSWORDREQUIRED,");
if (dwFlags & DPSESSION_MULTICASTSERVER)
strcat(flags, "DPSESSION_MULTICASTSERVER,");
if (dwFlags & DPSESSION_CLIENTSERVER)
strcat(flags, "DPSESSION_CLIENTSERVER,");
if (dwFlags & DPSESSION_DIRECTPLAYPROTOCOL)
strcat(flags, "DPSESSION_DIRECTPLAYPROTOCOL,");
if (dwFlags & DPSESSION_NOPRESERVEORDER)
strcat(flags, "DPSESSION_NOPRESERVEORDER,");
if (dwFlags & DPSESSION_OPTIMIZELATENCY)
strcat(flags, "DPSESSION_OPTIMIZELATENCY,");
}
/* DPLCONNECTION */
if (flagType & FLAGS_DPLCONNECTION)
{
if (dwFlags & DPLCONNECTION_CREATESESSION)
strcat(flags, "DPLCONNECTION_CREATESESSION,");
if (dwFlags & DPLCONNECTION_JOINSESSION)
strcat(flags, "DPLCONNECTION_JOINSESSION,");
}
/* EnumSessionsCallback2 */
if (flagType & FLAGS_DPESC)
{
if (dwFlags & DPESC_TIMEDOUT)
strcat(flags, "DPESC_TIMEDOUT,");
}
/* GetCaps,
GetPlayerCaps */
if (flagType & FLAGS_DPCAPS)
{
if (dwFlags & DPCAPS_ISHOST)
strcat(flags, "DPCAPS_ISHOST,");
if (dwFlags & DPCAPS_GROUPOPTIMIZED)
strcat(flags, "DPCAPS_GROUPOPTIMIZED,");
if (dwFlags & DPCAPS_KEEPALIVEOPTIMIZED)
strcat(flags, "DPCAPS_KEEPALIVEOPTIMIZED,");
if (dwFlags & DPCAPS_GUARANTEEDOPTIMIZED)
strcat(flags, "DPCAPS_GUARANTEEDOPTIMIZED,");
if (dwFlags & DPCAPS_GUARANTEEDSUPPORTED)
strcat(flags, "DPCAPS_GUARANTEEDSUPPORTED,");
if (dwFlags & DPCAPS_SIGNINGSUPPORTED)
strcat(flags, "DPCAPS_SIGNINGSUPPORTED,");
if (dwFlags & DPCAPS_ENCRYPTIONSUPPORTED)
strcat(flags, "DPCAPS_ENCRYPTIONSUPPORTED,");
if (dwFlags & DPCAPS_ASYNCCANCELSUPPORTED)
strcat(flags, "DPCAPS_ASYNCCANCELSUPPORTED,");
if (dwFlags & DPCAPS_ASYNCCANCELALLSUPPORTED)
strcat(flags, "DPCAPS_ASYNCCANCELALLSUPPORTED,");
if (dwFlags & DPCAPS_SENDTIMEOUTSUPPORTED)
strcat(flags, "DPCAPS_SENDTIMEOUTSUPPORTED,");
if (dwFlags & DPCAPS_SENDPRIORITYSUPPORTED)
strcat(flags, "DPCAPS_SENDPRIORITYSUPPORTED,");
if (dwFlags & DPCAPS_ASYNCSUPPORTED)
strcat(flags, "DPCAPS_ASYNCSUPPORTED,");
if (dwFlags & DPPLAYERCAPS_LOCAL)
strcat(flags, "DPPLAYERCAPS_LOCAL,");
}
if ((strlen(flags) == 0) && (dwFlags != 0))
strcpy(flags, "UNKNOWN");
else
flags[strlen(flags)-1] = '\0';
return flags;
}
static char dpid2char(DPID* dpid, DWORD dpidSize, DPID idPlayer)
{
UINT i;
if ( idPlayer == DPID_SYSMSG )
return 'S';
for (i=0; i<dpidSize; i++)
{
if ( idPlayer == dpid[i] )
return (char)(i+48);
}
return '?';
}
static void check_messages( IDirectPlay4 *pDP, DPID *dpid, DWORD dpidSize,
lpCallbackData callbackData )
{
/* Retrieves all messages from the queue of pDP, performing tests
* to check if we are receiving what we expect.
*
* Information about the messages is stores in callbackData:
*
* callbackData->dwCounter1: Number of messages received.
* callbackData->szTrace1: Traces for sender and receiver.
* We store the position a dpid holds in the dpid array.
* Example:
*
* trace string: "01,02,03,14"
* expanded: [ '01', '02', '03', '14' ]
* \ \ \ \
* \ \ \ ) message 3: from 1 to 4
* \ \ ) message 2: from 0 to 3
* \ ) message 1: from 0 to 2
* ) message 0: from 0 to 1
*
* In general terms:
* sender of message i = character in place 3*i of the array
* receiver of message i = character in place 3*i+1 of the array
*
* A sender value of 'S' means DPID_SYSMSG, this is, a system message.
*
* callbackData->szTrace2: Traces for message sizes.
*/
DPID idFrom, idTo;
UINT i;
DWORD dwDataSize = 1024;
LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
HRESULT hr;
char temp[5];
callbackData->szTrace2[0] = '\0';
i = 0;
while ( DP_OK == (hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0,
lpData, &dwDataSize )) )
{
callbackData->szTrace1[ 3*i ] = dpid2char( dpid, dpidSize, idFrom );
callbackData->szTrace1[ 3*i+1 ] = dpid2char( dpid, dpidSize, idTo );
callbackData->szTrace1[ 3*i+2 ] = ',';
sprintf( temp, "%d,", dwDataSize );
strcat( callbackData->szTrace2, temp );
dwDataSize = 1024;
++i;
}
checkHR( DPERR_NOMESSAGES, hr );
callbackData->szTrace1[ 3*i ] = '\0';
callbackData->dwCounter1 = i;
HeapFree( GetProcessHeap(), 0, lpData );
}
static void init_TCPIP_provider( IDirectPlay4 *pDP, LPCSTR strIPAddressString, WORD port )
{
DPCOMPOUNDADDRESSELEMENT addressElements[3];
LPVOID pAddress = NULL;
DWORD dwAddressSize = 0;
IDirectPlayLobby3 *pDPL;
HRESULT hr;
hr = CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL,
&IID_IDirectPlayLobby3A, (LPVOID*) &pDPL );
ok (SUCCEEDED (hr), "CCI of CLSID_DirectPlayLobby / IID_IDirectPlayLobby3A failed\n");
if (FAILED (hr)) return;
/* Service provider */
addressElements[0].guidDataType = DPAID_ServiceProvider;
addressElements[0].dwDataSize = sizeof(GUID);
addressElements[0].lpData = (LPVOID) &DPSPGUID_TCPIP;
/* IP address string */
addressElements[1].guidDataType = DPAID_INet;
addressElements[1].dwDataSize = lstrlenA(strIPAddressString) + 1;
addressElements[1].lpData = (LPVOID) strIPAddressString;
/* Optional Port number */
if( port > 0 )
{
addressElements[2].guidDataType = DPAID_INetPort;
addressElements[2].dwDataSize = sizeof(WORD);
addressElements[2].lpData = &port;
}
hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2,
NULL, &dwAddressSize );
checkHR( DPERR_BUFFERTOOSMALL, hr );
if( hr == DPERR_BUFFERTOOSMALL )
{
pAddress = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwAddressSize );
hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2,
pAddress, &dwAddressSize );
checkHR( DP_OK, hr );
}
hr = IDirectPlayX_InitializeConnection( pDP, pAddress, 0 );
todo_wine checkHR( DP_OK, hr );
HeapFree( GetProcessHeap(), 0, pAddress );
}
static BOOL CALLBACK EnumSessions_cb_join( LPCDPSESSIONDESC2 lpThisSD,
LPDWORD lpdwTimeOut,
DWORD dwFlags,
LPVOID lpContext )
{
IDirectPlay4 *pDP = lpContext;
DPSESSIONDESC2 dpsd;
HRESULT hr;
if (dwFlags & DPESC_TIMEDOUT)
{
return FALSE;
}
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.guidInstance = lpThisSD->guidInstance;
hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
checkHR( DP_OK, hr );
return TRUE;
}
/* DirectPlayCreate */
static void test_DirectPlayCreate(void)
{
IDirectPlay *pDP;
HRESULT hr;
/* TODO: Check how it behaves with pUnk!=NULL */
/* pDP==NULL */
hr = DirectPlayCreate( NULL, NULL, NULL );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = DirectPlayCreate( (LPGUID) &GUID_NULL, NULL, NULL );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = DirectPlayCreate( (LPGUID) &DPSPGUID_TCPIP, NULL, NULL );
checkHR( DPERR_INVALIDPARAMS, hr );
/* pUnk==NULL, pDP!=NULL */
hr = DirectPlayCreate( NULL, &pDP, NULL );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = DirectPlayCreate( (LPGUID) &GUID_NULL, &pDP, NULL );
checkHR( DP_OK, hr );
if ( hr == DP_OK )
IDirectPlayX_Release( pDP );
hr = DirectPlayCreate( (LPGUID) &DPSPGUID_TCPIP, &pDP, NULL );
todo_wine checkHR( DP_OK, hr );
if ( hr == DP_OK )
IDirectPlayX_Release( pDP );
}
/* EnumConnections */
static BOOL CALLBACK EnumAddress_cb2( REFGUID guidDataType,
DWORD dwDataSize,
LPCVOID lpData,
LPVOID lpContext )
{
lpCallbackData callbackData = lpContext;
static REFGUID types[] = { &DPAID_TotalSize,
&DPAID_ServiceProvider,
&GUID_NULL };
static DWORD sizes[] = { 4, 16, 0 };
static REFGUID sps[] = { &DPSPGUID_SERIAL, &DPSPGUID_MODEM,
&DPSPGUID_IPX, &DPSPGUID_TCPIP };
checkGuid( types[ callbackData->dwCounter2 ], guidDataType );
check( sizes[ callbackData->dwCounter2 ], dwDataSize );
if ( IsEqualGUID( types[0], guidDataType ) )
{
todo_wine check( 80, *((LPDWORD) lpData) );
}
else if ( IsEqualGUID( types[1], guidDataType ) )
{
todo_wine checkGuid( sps[ callbackData->dwCounter1 ], lpData );
}
callbackData->dwCounter2++;
return TRUE;
}
static BOOL CALLBACK EnumConnections_cb( LPCGUID lpguidSP,
LPVOID lpConnection,
DWORD dwConnectionSize,
LPCDPNAME lpName,
DWORD dwFlags,
LPVOID lpContext )
{
lpCallbackData callbackData = lpContext;
IDirectPlayLobby *pDPL;
HRESULT hr;
if (!callbackData->dwFlags)
{
callbackData->dwFlags = DPCONNECTION_DIRECTPLAY;
}
checkFlags( callbackData->dwFlags, dwFlags, FLAGS_DPCONNECTION );
/* Get info from lpConnection */
hr = CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL,
&IID_IDirectPlayLobby3A, (LPVOID*) &pDPL );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlayLobby / IID_IDirectPlayLobby3A failed\n");
if (FAILED(hr))
return FALSE;
callbackData->dwCounter2 = 0;
IDirectPlayLobby_EnumAddress( pDPL, EnumAddress_cb2, lpConnection,
dwConnectionSize, callbackData );
todo_wine check( 3, callbackData->dwCounter2 );
callbackData->dwCounter1++;
return TRUE;
}
static void test_EnumConnections(void)
{
IDirectPlay4 *pDP;
CallbackData callbackData;
HRESULT hr;
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP );
ok (SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n");
if (FAILED(hr)) return;
callbackData.dwCounter1 = 0;
callbackData.dwFlags = 0;
hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 4, callbackData.dwCounter1 );
callbackData.dwCounter1 = 0;
callbackData.dwFlags = 0;
hr = IDirectPlayX_EnumConnections( pDP, NULL, EnumConnections_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 4, callbackData.dwCounter1 );
callbackData.dwCounter1 = 0;
callbackData.dwFlags = 0;
hr = IDirectPlayX_EnumConnections( pDP, &appGuid, NULL,
&callbackData, callbackData.dwFlags );
checkHR( DPERR_INVALIDPARAMS, hr );
check( 0, callbackData.dwCounter1 );
/* Flag tests */
callbackData.dwCounter1 = 0;
callbackData.dwFlags = DPCONNECTION_DIRECTPLAY;
hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 4, callbackData.dwCounter1 );
callbackData.dwCounter1 = 0;
callbackData.dwFlags = DPCONNECTION_DIRECTPLAYLOBBY;
hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 0, callbackData.dwCounter1 );
callbackData.dwCounter1 = 0;
callbackData.dwFlags = ( DPCONNECTION_DIRECTPLAY |
DPCONNECTION_DIRECTPLAYLOBBY );
hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 4, callbackData.dwCounter1 );
callbackData.dwCounter1 = 0;
callbackData.dwFlags = ~( DPCONNECTION_DIRECTPLAY |
DPCONNECTION_DIRECTPLAYLOBBY );
hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
&callbackData, callbackData.dwFlags );
checkHR( DPERR_INVALIDFLAGS, hr );
check( 0, callbackData.dwCounter1 );
IDirectPlayX_Release( pDP );
}
/* InitializeConnection */
static BOOL CALLBACK EnumConnections_cb2( LPCGUID lpguidSP,
LPVOID lpConnection,
DWORD dwConnectionSize,
LPCDPNAME lpName,
DWORD dwFlags,
LPVOID lpContext )
{
IDirectPlay4 *pDP = lpContext;
HRESULT hr;
/* Incorrect parameters */
hr = IDirectPlayX_InitializeConnection( pDP, NULL, 1 );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_InitializeConnection( pDP, lpConnection, 1 );
checkHR( DPERR_INVALIDFLAGS, hr );
/* Normal operation.
We're only interested in ensuring that the TCP/IP provider works */
if( IsEqualGUID(lpguidSP, &DPSPGUID_TCPIP) )
{
hr = IDirectPlayX_InitializeConnection( pDP, lpConnection, 0 );
todo_wine checkHR( DP_OK, hr );
hr = IDirectPlayX_InitializeConnection( pDP, lpConnection, 0 );
todo_wine checkHR( DPERR_ALREADYINITIALIZED, hr );
}
return TRUE;
}
static void test_InitializeConnection(void)
{
IDirectPlay4 *pDP;
HRESULT hr;
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP );
ok (SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n");
if (FAILED(hr)) return;
IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb2, pDP, 0 );
IDirectPlayX_Release( pDP );
}
/* GetCaps */
static void test_GetCaps(void)
{
IDirectPlay4 *pDP;
DPCAPS dpcaps;
DWORD dwFlags;
HRESULT hr;
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP );
ok (SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n");
if (FAILED(hr)) return;
ZeroMemory( &dpcaps, sizeof(DPCAPS) );
/* Service provider not ininitialized */
hr = IDirectPlayX_GetCaps( pDP, &dpcaps, 0 );
checkHR( DPERR_UNINITIALIZED, hr );
init_TCPIP_provider( pDP, "127.0.0.1", 0 );
/* dpcaps not ininitialized */
hr = IDirectPlayX_GetCaps( pDP, &dpcaps, 0 );
todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
dpcaps.dwSize = sizeof(DPCAPS);
for (dwFlags=0;
dwFlags<=DPGETCAPS_GUARANTEED;
dwFlags+=DPGETCAPS_GUARANTEED)
{
hr = IDirectPlayX_GetCaps( pDP, &dpcaps, dwFlags );
todo_wine checkHR( DP_OK, hr );
if ( hr == DP_OK )
{
check( sizeof(DPCAPS), dpcaps.dwSize );
check( DPCAPS_ASYNCSUPPORTED |
DPCAPS_GUARANTEEDOPTIMIZED |
DPCAPS_GUARANTEEDSUPPORTED,
dpcaps.dwFlags );
check( 0, dpcaps.dwMaxQueueSize );
check( 0, dpcaps.dwHundredBaud );
check( 500, dpcaps.dwLatency );
check( 65536, dpcaps.dwMaxLocalPlayers );
check( 20, dpcaps.dwHeaderLength );
check( 5000, dpcaps.dwTimeout );
switch (dwFlags)
{
case 0:
check( 65479, dpcaps.dwMaxBufferSize );
check( 65536, dpcaps.dwMaxPlayers );
break;
case DPGETCAPS_GUARANTEED:
check( 1048547, dpcaps.dwMaxBufferSize );
check( 64, dpcaps.dwMaxPlayers );
break;
default: break;
}
}
}
IDirectPlayX_Release( pDP );
}
/* Open */
static BOOL CALLBACK EnumSessions_cb2( LPCDPSESSIONDESC2 lpThisSD,
LPDWORD lpdwTimeOut,
DWORD dwFlags,
LPVOID lpContext )
{
IDirectPlay4 *pDP = lpContext;
DPSESSIONDESC2 dpsd;
HRESULT hr;
if (dwFlags & DPESC_TIMEDOUT)
return FALSE;
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.guidInstance = lpThisSD->guidInstance;
if ( lpThisSD->dwFlags & DPSESSION_PASSWORDREQUIRED )
{
/* Incorrect password */
U2(dpsd).lpszPasswordA = (LPSTR) "sonic boom";
hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
checkHR( DPERR_INVALIDPASSWORD, hr );
/* Correct password */
U2(dpsd).lpszPasswordA = (LPSTR) "hadouken";
hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
checkHR( DP_OK, hr );
}
else
{
hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
checkHR( DP_OK, hr );
}
hr = IDirectPlayX_Close( pDP );
checkHR( DP_OK, hr );
return TRUE;
}
static void test_Open(void)
{
IDirectPlay4 *pDP, *pDP_server;
DPSESSIONDESC2 dpsd, dpsd_server;
HRESULT hr;
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP_server );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
ZeroMemory( &dpsd_server, sizeof(DPSESSIONDESC2) );
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
/* Service provider not initialized */
hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
init_TCPIP_provider( pDP_server, "127.0.0.1", 0 );
init_TCPIP_provider( pDP, "127.0.0.1", 0 );
/* Uninitialized dpsd */
hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
dpsd_server.dwSize = sizeof(DPSESSIONDESC2);
dpsd_server.guidApplication = appGuid;
dpsd_server.dwMaxPlayers = 10;
/* Regular operation */
hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
todo_wine checkHR( DP_OK, hr );
/* Opening twice */
hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
todo_wine checkHR( DPERR_ALREADYINITIALIZED, hr );
/* Session flags */
IDirectPlayX_Close( pDP_server );
dpsd_server.dwFlags = DPSESSION_CLIENTSERVER | DPSESSION_MIGRATEHOST;
hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
todo_wine checkHR( DPERR_INVALIDFLAGS, hr );
dpsd_server.dwFlags = DPSESSION_MULTICASTSERVER | DPSESSION_MIGRATEHOST;
hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
todo_wine checkHR( DPERR_INVALIDFLAGS, hr );
dpsd_server.dwFlags = DPSESSION_SECURESERVER | DPSESSION_MIGRATEHOST;
hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
todo_wine checkHR( DPERR_INVALIDFLAGS, hr );
/* Joining sessions */
/* - Checking how strict dplay is with sizes */
dpsd.dwSize = 0;
hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
dpsd.dwSize = sizeof(DPSESSIONDESC2)-1;
hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
dpsd.dwSize = sizeof(DPSESSIONDESC2)+1;
hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
todo_wine checkHR( DPERR_NOSESSIONS, hr ); /* Only checks for size, not guids */
dpsd.guidApplication = appGuid;
dpsd.guidInstance = appGuid;
hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
todo_wine checkHR( DPERR_NOSESSIONS, hr );
hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN | DPOPEN_CREATE );
todo_wine checkHR( DPERR_NOSESSIONS, hr ); /* Second flag is ignored */
dpsd_server.dwFlags = 0;
/* Join to normal session */
hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
todo_wine checkHR( DP_OK, hr );
IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb2, pDP, 0 );
/* Already initialized session */
hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
todo_wine checkHR( DPERR_ALREADYINITIALIZED, hr );
/* Checking which is the error checking order */
dpsd_server.dwSize = 0;
hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
dpsd_server.dwSize = sizeof(DPSESSIONDESC2);
/* Join to protected session */
IDirectPlayX_Close( pDP_server );
U2(dpsd_server).lpszPasswordA = (LPSTR) "hadouken";
hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
todo_wine checkHR( DP_OK, hr );
IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb2,
pDP, DPENUMSESSIONS_PASSWORDREQUIRED );
IDirectPlayX_Release( pDP );
IDirectPlayX_Release( pDP_server );
}
/* EnumSessions */
static BOOL CALLBACK EnumSessions_cb( LPCDPSESSIONDESC2 lpThisSD,
LPDWORD lpdwTimeOut,
DWORD dwFlags,
LPVOID lpContext )
{
lpCallbackData callbackData = lpContext;
callbackData->dwCounter1++;
if ( dwFlags & DPESC_TIMEDOUT )
{
check( TRUE, lpThisSD == NULL );
return FALSE;
}
check( FALSE, lpThisSD == NULL );
if ( U2(*lpThisSD).lpszPasswordA != NULL )
{
check( TRUE, (lpThisSD->dwFlags & DPSESSION_PASSWORDREQUIRED) != 0 );
}
if ( lpThisSD->dwFlags & DPSESSION_NEWPLAYERSDISABLED )
{
check( 0, lpThisSD->dwCurrentPlayers );
}
check( sizeof(*lpThisSD), lpThisSD->dwSize );
checkLP( NULL, U2(*lpThisSD).lpszPasswordA );
return TRUE;
}
static IDirectPlay4 *create_session(DPSESSIONDESC2 *lpdpsd)
{
IDirectPlay4 *pDP;
DPNAME name;
DPID dpid;
HRESULT hr;
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return NULL;
init_TCPIP_provider( pDP, "127.0.0.1", 0 );
hr = IDirectPlayX_Open( pDP, lpdpsd, DPOPEN_CREATE );
todo_wine checkHR( DP_OK, hr );
if ( ! (lpdpsd->dwFlags & DPSESSION_NEWPLAYERSDISABLED) )
{
ZeroMemory( &name, sizeof(DPNAME) );
name.dwSize = sizeof(DPNAME);
U1(name).lpszShortNameA = (LPSTR) "bofh";
hr = IDirectPlayX_CreatePlayer( pDP, &dpid, &name, NULL, NULL,
0, DPPLAYER_SERVERPLAYER );
todo_wine checkHR( DP_OK, hr );
}
return pDP;
}
static void test_EnumSessions(void)
{
#define N_SESSIONS 6
IDirectPlay4 *pDP, *pDPserver[N_SESSIONS];
DPSESSIONDESC2 dpsd, dpsd_server[N_SESSIONS];
CallbackData callbackData;
HRESULT hr;
UINT i;
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
callbackData.dwCounter1 = -1; /* So that after a call to EnumSessions
we get the exact number of sessions */
callbackData.dwFlags = 0;
/* Service provider not initialized */
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, 0 );
checkHR( DPERR_UNINITIALIZED, hr );
init_TCPIP_provider( pDP, "127.0.0.1", 0 );
/* Session with no size */
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, 0 );
todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
if ( hr == DPERR_UNINITIALIZED )
{
todo_wine win_skip( "EnumSessions not implemented\n" );
return;
}
dpsd.dwSize = sizeof(DPSESSIONDESC2);
/* No sessions */
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, 0 );
checkHR( DP_OK, hr );
check( 0, callbackData.dwCounter1 );
dpsd.guidApplication = appGuid;
/* Set up sessions */
for (i=0; i<N_SESSIONS; i++)
{
memcpy( &dpsd_server[i], &dpsd, sizeof(DPSESSIONDESC2) );
}
U1(dpsd_server[0]).lpszSessionNameA = (LPSTR) "normal";
dpsd_server[0].dwFlags = ( DPSESSION_CLIENTSERVER |
DPSESSION_DIRECTPLAYPROTOCOL );
dpsd_server[0].dwMaxPlayers = 10;
U1(dpsd_server[1]).lpszSessionNameA = (LPSTR) "full";
dpsd_server[1].dwFlags = ( DPSESSION_CLIENTSERVER |
DPSESSION_DIRECTPLAYPROTOCOL );
dpsd_server[1].dwMaxPlayers = 1;
U1(dpsd_server[2]).lpszSessionNameA = (LPSTR) "no new";
dpsd_server[2].dwFlags = ( DPSESSION_CLIENTSERVER |
DPSESSION_DIRECTPLAYPROTOCOL |
DPSESSION_NEWPLAYERSDISABLED );
dpsd_server[2].dwMaxPlayers = 10;
U1(dpsd_server[3]).lpszSessionNameA = (LPSTR) "no join";
dpsd_server[3].dwFlags = ( DPSESSION_CLIENTSERVER |
DPSESSION_DIRECTPLAYPROTOCOL |
DPSESSION_JOINDISABLED );
dpsd_server[3].dwMaxPlayers = 10;
U1(dpsd_server[4]).lpszSessionNameA = (LPSTR) "private";
dpsd_server[4].dwFlags = ( DPSESSION_CLIENTSERVER |
DPSESSION_DIRECTPLAYPROTOCOL |
DPSESSION_PRIVATE );
dpsd_server[4].dwMaxPlayers = 10;
U2(dpsd_server[4]).lpszPasswordA = (LPSTR) "password";
U1(dpsd_server[5]).lpszSessionNameA = (LPSTR) "protected";
dpsd_server[5].dwFlags = ( DPSESSION_CLIENTSERVER |
DPSESSION_DIRECTPLAYPROTOCOL |
DPSESSION_PASSWORDREQUIRED );
dpsd_server[5].dwMaxPlayers = 10;
U2(dpsd_server[5]).lpszPasswordA = (LPSTR) "password";
for (i=0; i<N_SESSIONS; i++)
{
pDPserver[i] = create_session( &dpsd_server[i] );
if (!pDPserver[i]) return;
}
/* Invalid params */
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, -1 );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_EnumSessions( pDP, NULL, 0, EnumSessions_cb,
&callbackData, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
check( -1, callbackData.dwCounter1 );
/* Flag tests */
callbackData.dwFlags = DPENUMSESSIONS_ALL; /* Doesn't list private,
protected */
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( N_SESSIONS-2, callbackData.dwCounter1 );
/* Doesn't list private */
callbackData.dwFlags = ( DPENUMSESSIONS_ALL |
DPENUMSESSIONS_PASSWORDREQUIRED );
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( N_SESSIONS-1, callbackData.dwCounter1 );
/* Doesn't list full, no new, no join, private, protected */
callbackData.dwFlags = DPENUMSESSIONS_AVAILABLE;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( N_SESSIONS-5, callbackData.dwCounter1 );
/* Like with DPENUMSESSIONS_AVAILABLE */
callbackData.dwFlags = 0;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( N_SESSIONS-5, callbackData.dwCounter1 );
/* Doesn't list full, no new, no join, private */
callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( N_SESSIONS-4, callbackData.dwCounter1 );
/* Async enumeration */
callbackData.dwFlags = DPENUMSESSIONS_ASYNC;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( N_SESSIONS-4, callbackData.dwCounter1 ); /* Read cache of last
sync enumeration */
callbackData.dwFlags = DPENUMSESSIONS_STOPASYNC;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 0, callbackData.dwCounter1 ); /* Stop enumeration */
callbackData.dwFlags = DPENUMSESSIONS_ASYNC;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 0, callbackData.dwCounter1 ); /* Start enumeration */
Sleep(500); /* Give time to fill the cache */
callbackData.dwFlags = DPENUMSESSIONS_ASYNC;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( N_SESSIONS-5, callbackData.dwCounter1 ); /* Retrieve results */
callbackData.dwFlags = DPENUMSESSIONS_STOPASYNC;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 0, callbackData.dwCounter1 ); /* Stop enumeration */
/* Specific tests for passworded sessions */
for (i=0; i<N_SESSIONS; i++)
{
IDirectPlayX_Release( pDPserver[i] );
}
/* - Only session password set */
for (i=4;i<=5;i++)
{
U2(dpsd_server[i]).lpszPasswordA = (LPSTR) "password";
dpsd_server[i].dwFlags = 0;
pDPserver[i] = create_session( &dpsd_server[i] );
}
callbackData.dwFlags = 0;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 0, callbackData.dwCounter1 );
callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 2, callbackData.dwCounter1 ); /* Both sessions automatically
set DPSESSION_PASSWORDREQUIRED */
/* - Only session flag set */
for (i=4; i<=5; i++)
{
IDirectPlayX_Release( pDPserver[i] );
U2(dpsd_server[i]).lpszPasswordA = NULL;
}
dpsd_server[4].dwFlags = DPSESSION_PRIVATE;
dpsd_server[5].dwFlags = DPSESSION_PASSWORDREQUIRED;
for (i=4; i<=5; i++)
{
pDPserver[i] = create_session( &dpsd_server[i] );
}
callbackData.dwFlags = 0;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 2, callbackData.dwCounter1 ); /* Without password,
the flag is ignored */
/* - Both session flag and password set */
for (i=4; i<=5; i++)
{
IDirectPlayX_Release( pDPserver[i] );
U2(dpsd_server[i]).lpszPasswordA = (LPSTR) "password";
}
dpsd_server[4].dwFlags = DPSESSION_PRIVATE;
dpsd_server[5].dwFlags = DPSESSION_PASSWORDREQUIRED;
for (i=4; i<=5; i++)
{
pDPserver[i] = create_session( &dpsd_server[i] );
}
/* - Listing without password */
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 0, callbackData.dwCounter1 );
callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 1, callbackData.dwCounter1 );
/* - Listing with incorrect password */
U2(dpsd).lpszPasswordA = (LPSTR) "bad_password";
callbackData.dwFlags = 0;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 0, callbackData.dwCounter1 );
callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 1, callbackData.dwCounter1 );
/* - Listing with correct password */
U2(dpsd).lpszPasswordA = (LPSTR) "password";
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 2, callbackData.dwCounter1 );
U2(dpsd).lpszPasswordA = NULL;
callbackData.dwFlags = DPENUMSESSIONS_ASYNC;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 2, callbackData.dwCounter1 ); /* Read cache of last sync enumeration,
even private sessions */
/* GUID tests */
/* - Creating two servers with different application GUIDs */
for (i=4; i<=5; i++)
{
IDirectPlayX_Release( pDPserver[i] );
dpsd_server[i].dwFlags = ( DPSESSION_CLIENTSERVER |
DPSESSION_DIRECTPLAYPROTOCOL );
U2(dpsd_server[i]).lpszPasswordA = NULL;
dpsd_server[i].dwMaxPlayers = 10;
}
U1(dpsd_server[4]).lpszSessionNameA = (LPSTR) "normal1";
dpsd_server[4].guidApplication = appGuid;
U1(dpsd_server[5]).lpszSessionNameA = (LPSTR) "normal2";
dpsd_server[5].guidApplication = appGuid2;
for (i=4; i<=5; i++)
{
pDPserver[i] = create_session( &dpsd_server[i] );
}
callbackData.dwFlags = 0;
dpsd.guidApplication = appGuid2;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 1, callbackData.dwCounter1 ); /* Only one of the sessions */
dpsd.guidApplication = appGuid;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 1, callbackData.dwCounter1 ); /* The other session */
/* FIXME:
For some reason, if we enum 1st with appGuid and 2nd with appGuid2,
in the second enum we get the 2 sessions. Dplay fault? Elves? */
dpsd.guidApplication = GUID_NULL;
callbackData.dwCounter1 = -1;
hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
&callbackData, callbackData.dwFlags );
checkHR( DP_OK, hr );
check( 2, callbackData.dwCounter1 ); /* Both sessions */
for (i=4; i<=5; i++)
{
IDirectPlayX_Release( pDPserver[i] );
}
IDirectPlayX_Release( pDP );
}
/* SetSessionDesc
GetSessionDesc */
static void test_SessionDesc(void)
{
IDirectPlay4 *pDP[2];
DPSESSIONDESC2 dpsd;
LPDPSESSIONDESC2 lpData[2];
LPVOID lpDataMsg;
DPID dpid[2];
DWORD dwDataSize;
HRESULT hr;
UINT i;
CallbackData callbackData;
for (i=0; i<2; i++)
{
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
}
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
/* Service provider not initialized */
hr = IDirectPlayX_SetSessionDesc( pDP[0], NULL, 0 );
checkHR( DPERR_UNINITIALIZED, hr );
hr = IDirectPlayX_GetSessionDesc( pDP[0], NULL, NULL );
checkHR( DPERR_UNINITIALIZED, hr );
init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
/* No sessions open */
hr = IDirectPlayX_SetSessionDesc( pDP[0], NULL, 0 );
todo_wine checkHR( DPERR_NOSESSIONS, hr );
if ( hr == DPERR_UNINITIALIZED )
{
todo_wine win_skip("Get/SetSessionDesc not implemented\n");
return;
}
hr = IDirectPlayX_GetSessionDesc( pDP[0], NULL, NULL );
checkHR( DPERR_NOSESSIONS, hr );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.dwMaxPlayers = 10;
/* Host */
IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
/* Peer */
IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
pDP[1], 0 );
for (i=0; i<2; i++)
{
/* Players, only to receive messages */
IDirectPlayX_CreatePlayer( pDP[i], &dpid[i], NULL, NULL, NULL, 0, 0 );
lpData[i] = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 1024 );
}
lpDataMsg = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 1024 );
/* Incorrect parameters */
hr = IDirectPlayX_SetSessionDesc( pDP[0], NULL, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_GetSessionDesc( pDP[0], NULL, NULL );
checkHR( DPERR_INVALIDPARAM, hr );
hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], NULL );
checkHR( DPERR_INVALIDPARAM, hr );
dwDataSize=-1;
hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], &dwDataSize );
checkHR( DPERR_INVALIDPARAMS, hr );
check( -1, dwDataSize );
/* Get: Insufficient buffer size */
dwDataSize=0;
hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], &dwDataSize );
checkHR( DPERR_BUFFERTOOSMALL, hr );
check( dpsd.dwSize, dwDataSize );
dwDataSize=4;
hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], &dwDataSize );
checkHR( DPERR_BUFFERTOOSMALL, hr );
check( dpsd.dwSize, dwDataSize );
dwDataSize=1024;
hr = IDirectPlayX_GetSessionDesc( pDP[0], NULL, &dwDataSize );
checkHR( DPERR_BUFFERTOOSMALL, hr );
check( dpsd.dwSize, dwDataSize );
/* Get: Regular operation
* i=0: Local session
* i=1: Remote session */
for (i=0; i<2; i++)
{
hr = IDirectPlayX_GetSessionDesc( pDP[i], lpData[i], &dwDataSize );
checkHR( DP_OK, hr );
check( sizeof(DPSESSIONDESC2), dwDataSize );
check( sizeof(DPSESSIONDESC2), lpData[i]->dwSize );
checkGuid( &appGuid, &lpData[i]->guidApplication );
check( dpsd.dwMaxPlayers, lpData[i]->dwMaxPlayers );
}
checkGuid( &lpData[0]->guidInstance, &lpData[1]->guidInstance );
/* Set: Regular operation */
U1(dpsd).lpszSessionNameA = (LPSTR) "Wahaa";
hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
checkHR( DP_OK, hr );
dwDataSize = 1024;
hr = IDirectPlayX_GetSessionDesc( pDP[1], lpData[1], &dwDataSize );
checkHR( DP_OK, hr );
checkStr( U1(dpsd).lpszSessionNameA, U1(*lpData[1]).lpszSessionNameA );
/* Set: Failing to modify a remote session */
hr = IDirectPlayX_SetSessionDesc( pDP[1], &dpsd, 0 );
checkHR( DPERR_ACCESSDENIED, hr );
/* Trying to change immutable properties */
/* Flags */
hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
checkHR( DP_OK, hr );
dpsd.dwFlags = DPSESSION_SECURESERVER;
hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
dpsd.dwFlags = 0;
hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
checkHR( DP_OK, hr );
/* Size */
dpsd.dwSize = 2048;
hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
checkHR( DP_OK, hr );
/* Changing the GUIDs and size is ignored */
dpsd.guidApplication = appGuid2;
hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
checkHR( DP_OK, hr );
dpsd.guidInstance = appGuid2;
hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], &dwDataSize );
checkHR( DP_OK, hr );
checkGuid( &appGuid, &lpData[0]->guidApplication );
checkGuid( &lpData[1]->guidInstance, &lpData[0]->guidInstance );
check( sizeof(DPSESSIONDESC2), lpData[0]->dwSize );
/* Checking system messages */
check_messages( pDP[0], dpid, 2, &callbackData );
checkStr( "S0,S0,S0,S0,S0,S0,S0,", callbackData.szTrace1 );
checkStr( "48,90,90,90,90,90,90,", callbackData.szTrace2 );
check_messages( pDP[1], dpid, 2, &callbackData );
checkStr( "S1,S1,S1,S1,S1,S1,", callbackData.szTrace1 );
checkStr( "90,90,90,90,90,90,", callbackData.szTrace2 );
HeapFree( GetProcessHeap(), 0, lpDataMsg );
for (i=0; i<2; i++)
{
HeapFree( GetProcessHeap(), 0, lpData[i] );
IDirectPlayX_Release( pDP[i] );
}
}
/* CreatePlayer */
static void test_CreatePlayer(void)
{
IDirectPlay4 *pDP[2];
DPSESSIONDESC2 dpsd;
DPNAME name;
DPID dpid;
HRESULT hr;
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[0] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[1] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
ZeroMemory( &name, sizeof(DPNAME) );
/* Connection not initialized */
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 0, 0 );
checkHR( DPERR_UNINITIALIZED, hr );
init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
/* Session not open */
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 0, 0 );
todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
if ( hr == DPERR_UNINITIALIZED )
{
todo_wine win_skip( "CreatePlayer not implemented\n" );
return;
}
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
/* Player name */
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
name.dwSize = -1;
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, &name, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
name.dwSize = sizeof(DPNAME);
U1(name).lpszShortNameA = (LPSTR) "test";
U2(name).lpszLongNameA = NULL;
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, &name, NULL, NULL,
0, 0 );
checkHR( DP_OK, hr );
/* Null dpid */
hr = IDirectPlayX_CreatePlayer( pDP[0], NULL, NULL, NULL, NULL,
0, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
/* There can only be one server player */
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
0, DPPLAYER_SERVERPLAYER );
checkHR( DP_OK, hr );
check( DPID_SERVERPLAYER, dpid );
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
0, DPPLAYER_SERVERPLAYER );
checkHR( DPERR_CANTCREATEPLAYER, hr );
IDirectPlayX_DestroyPlayer( pDP[0], dpid );
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
0, DPPLAYER_SERVERPLAYER );
checkHR( DP_OK, hr );
check( DPID_SERVERPLAYER, dpid );
IDirectPlayX_DestroyPlayer( pDP[0], dpid );
/* Flags */
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
0, DPPLAYER_SERVERPLAYER );
checkHR( DP_OK, hr );
check( DPID_SERVERPLAYER, dpid );
IDirectPlayX_DestroyPlayer( pDP[0], dpid );
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
0, DPPLAYER_SPECTATOR );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
0, ( DPPLAYER_SERVERPLAYER |
DPPLAYER_SPECTATOR ) );
checkHR( DP_OK, hr );
check( DPID_SERVERPLAYER, dpid );
IDirectPlayX_DestroyPlayer( pDP[0], dpid );
/* Session with DPSESSION_NEWPLAYERSDISABLED */
IDirectPlayX_Close( pDP[0] );
dpsd.dwFlags = DPSESSION_NEWPLAYERSDISABLED;
hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
0, 0 );
checkHR( DPERR_CANTCREATEPLAYER, hr );
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
0, DPPLAYER_SERVERPLAYER );
checkHR( DPERR_CANTCREATEPLAYER, hr );
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
0, DPPLAYER_SPECTATOR );
checkHR( DPERR_CANTCREATEPLAYER, hr );
/* Creating players in a Client/Server session */
IDirectPlayX_Close( pDP[0] );
dpsd.dwFlags = DPSESSION_CLIENTSERVER;
hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
checkHR( DP_OK, hr );
hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
pDP[1], 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
0, 0 );
checkHR( DPERR_ACCESSDENIED, hr );
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
0, DPPLAYER_SERVERPLAYER );
checkHR( DP_OK, hr );
check( DPID_SERVERPLAYER, dpid );
hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid, NULL, NULL, NULL,
0, DPPLAYER_SERVERPLAYER );
checkHR( DPERR_INVALIDFLAGS, hr );
hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid, NULL, NULL, NULL,
0, 0 );
checkHR( DP_OK, hr );
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
}
/* GetPlayerCaps */
static void test_GetPlayerCaps(void)
{
IDirectPlay4 *pDP[2];
DPSESSIONDESC2 dpsd;
DPID dpid[2];
HRESULT hr;
UINT i;
DPCAPS playerCaps;
DWORD dwFlags;
for (i=0; i<2; i++)
{
hr= CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
}
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.dwMaxPlayers = 10;
ZeroMemory( &playerCaps, sizeof(DPCAPS) );
/* Uninitialized service provider */
playerCaps.dwSize = 0;
hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
checkHR( DPERR_UNINITIALIZED, hr );
playerCaps.dwSize = sizeof(DPCAPS);
hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
checkHR( DPERR_UNINITIALIZED, hr );
init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
/* No session */
playerCaps.dwSize = 0;
hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
if ( hr == DPERR_UNINITIALIZED )
{
todo_wine win_skip( "GetPlayerCaps not implemented\n" );
return;
}
playerCaps.dwSize = sizeof(DPCAPS);
hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
checkHR( DPERR_INVALIDPLAYER, hr );
hr = IDirectPlayX_GetPlayerCaps( pDP[0], 2, &playerCaps, 0 );
checkHR( DPERR_INVALIDPLAYER, hr );
hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
checkHR( DP_OK, hr );
hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
pDP[1], 0 );
checkHR( DP_OK, hr );
for (i=0; i<2; i++)
{
hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
}
/* Uninitialized playerCaps */
playerCaps.dwSize = 0;
hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_GetPlayerCaps( pDP[0], 2, &playerCaps, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_GetPlayerCaps( pDP[0], dpid[0], &playerCaps, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
/* Invalid player */
playerCaps.dwSize = sizeof(DPCAPS);
hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
checkHR( DPERR_INVALIDPLAYER, hr );
hr = IDirectPlayX_GetPlayerCaps( pDP[0], 2, &playerCaps, 0 );
checkHR( DPERR_INVALIDPLAYER, hr );
hr = IDirectPlayX_GetPlayerCaps( pDP[0], dpid[0], &playerCaps, 0 );
checkHR( DP_OK, hr );
/* Regular parameters */
for (i=0; i<2; i++)
{
for (dwFlags=0;
dwFlags<=DPGETCAPS_GUARANTEED;
dwFlags+=DPGETCAPS_GUARANTEED)
{
hr = IDirectPlayX_GetPlayerCaps( pDP[0], dpid[i],
&playerCaps, dwFlags );
checkHR( DP_OK, hr );
check( sizeof(DPCAPS), playerCaps.dwSize );
check( 40, playerCaps.dwSize );
check( 0, playerCaps.dwMaxQueueSize );
check( 0, playerCaps.dwHundredBaud );
check( 0, playerCaps.dwLatency );
check( 65536, playerCaps.dwMaxLocalPlayers );
check( 20, playerCaps.dwHeaderLength );
if ( i == 0 )
{
checkFlags( DPCAPS_ISHOST |
DPCAPS_GUARANTEEDOPTIMIZED |
DPCAPS_GUARANTEEDSUPPORTED |
DPCAPS_ASYNCSUPPORTED |
DPPLAYERCAPS_LOCAL,
playerCaps.dwFlags, FLAGS_DPCAPS );
}
else
checkFlags( DPCAPS_ISHOST |
DPCAPS_GUARANTEEDOPTIMIZED |
DPCAPS_GUARANTEEDSUPPORTED |
DPCAPS_ASYNCSUPPORTED,
playerCaps.dwFlags, FLAGS_DPCAPS );
if ( dwFlags == DPGETCAPS_GUARANTEED )
{
check( 1048547, playerCaps.dwMaxBufferSize );
check( 64, playerCaps.dwMaxPlayers );
}
else
{
check( 65479, playerCaps.dwMaxBufferSize );
check( 65536, playerCaps.dwMaxPlayers );
}
}
}
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
}
/* SetPlayerData
GetPlayerData */
static void test_PlayerData(void)
{
IDirectPlay4 *pDP;
DPSESSIONDESC2 dpsd;
DPID dpid;
HRESULT hr;
/* lpDataFake has to be bigger than the rest, limits lpDataGet size */
LPCSTR lpDataFake = "big_fake_data_chunk";
DWORD dwDataSizeFake = strlen(lpDataFake)+1;
LPCSTR lpData = "remote_data";
DWORD dwDataSize = strlen(lpData)+1;
LPCSTR lpDataLocal = "local_data";
DWORD dwDataSizeLocal = strlen(lpDataLocal)+1;
LPSTR lpDataGet = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
dwDataSizeFake );
DWORD dwDataSizeGet = dwDataSizeFake;
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
/* No service provider */
hr = IDirectPlayX_SetPlayerData( pDP, 0, (LPVOID) lpData,
dwDataSize, 0 );
checkHR( DPERR_UNINITIALIZED, hr );
hr = IDirectPlayX_GetPlayerData( pDP, 0, lpDataGet, &dwDataSizeGet, 0 );
checkHR( DPERR_UNINITIALIZED, hr );
init_TCPIP_provider( pDP, "127.0.0.1", 0 );
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE );
/* Invalid player */
hr = IDirectPlayX_SetPlayerData( pDP, 0, (LPVOID) lpData,
dwDataSize, 0 );
todo_wine checkHR( DPERR_INVALIDPLAYER, hr );
hr = IDirectPlayX_GetPlayerData( pDP, 0, lpDataGet, &dwDataSizeGet, 0 );
todo_wine checkHR( DPERR_INVALIDPLAYER, hr );
if ( hr == DPERR_UNINITIALIZED )
{
todo_wine win_skip( "Get/SetPlayerData not implemented\n" );
return;
}
/* Create the player */
/* By default, the data is remote */
hr = IDirectPlayX_CreatePlayer( pDP, &dpid, NULL, NULL, (LPVOID) lpData,
dwDataSize, 0 );
checkHR( DP_OK, hr );
/* Invalid parameters */
hr = IDirectPlayX_SetPlayerData( pDP, dpid, NULL, dwDataSize, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_SetPlayerData( pDP, dpid, lpDataGet, -1, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, NULL, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
/*
* Remote data (default)
*/
/* Buffer redimension */
dwDataSizeGet = dwDataSizeFake;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, NULL,
&dwDataSizeGet, 0 );
check( DPERR_BUFFERTOOSMALL, hr );
check( dwDataSize, dwDataSizeGet );
checkStr( lpDataFake, lpDataGet );
dwDataSizeGet = 2;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 );
check( DPERR_BUFFERTOOSMALL, hr );
check( dwDataSize, dwDataSizeGet );
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 );
checkHR( DP_OK, hr );
check( dwDataSize, dwDataSizeGet );
checkStr( lpData, lpDataGet );
/* Normal operation */
dwDataSizeGet = dwDataSizeFake;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 );
checkHR( DP_OK, hr );
check( dwDataSize, dwDataSizeGet );
checkStr( lpData, lpDataGet );
/* Flag tests */
dwDataSizeGet = dwDataSizeFake;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 );
checkHR( DP_OK, hr );
check( dwDataSize, dwDataSizeGet ); /* Remote: works as expected */
checkStr( lpData, lpDataGet );
dwDataSizeGet = dwDataSizeFake;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
DPGET_REMOTE );
checkHR( DP_OK, hr );
check( dwDataSize, dwDataSizeGet ); /* Same behaviour as in previous test */
checkStr( lpData, lpDataGet );
dwDataSizeGet = dwDataSizeFake;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
DPGET_LOCAL );
checkHR( DP_OK, hr );
check( 0, dwDataSizeGet ); /* Sets size to 0 (as local data doesn't exist) */
checkStr( lpDataFake, lpDataGet );
dwDataSizeGet = dwDataSizeFake;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
DPGET_LOCAL | DPGET_REMOTE );
checkHR( DP_OK, hr );
check( 0, dwDataSizeGet ); /* Same behaviour as in previous test */
checkStr( lpDataFake, lpDataGet );
/* Getting local data (which doesn't exist), buffer size is ignored */
dwDataSizeGet = 0;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
DPGET_LOCAL );
checkHR( DP_OK, hr );
check( 0, dwDataSizeGet ); /* Sets size to 0 */
checkStr( lpDataFake, lpDataGet );
dwDataSizeGet = dwDataSizeFake;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, NULL, &dwDataSizeGet,
DPGET_LOCAL );
checkHR( DP_OK, hr );
check( 0, dwDataSizeGet ); /* Sets size to 0 */
checkStr( lpDataFake, lpDataGet );
/*
* Local data
*/
/* Invalid flags */
hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataLocal,
dwDataSizeLocal,
DPSET_LOCAL | DPSET_GUARANTEED );
checkHR( DPERR_INVALIDPARAMS, hr );
/* Correct parameters */
hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataLocal,
dwDataSizeLocal, DPSET_LOCAL );
checkHR( DP_OK, hr );
/* Flag tests (again) */
dwDataSizeGet = dwDataSizeFake;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 );
checkHR( DP_OK, hr );
check( dwDataSize, dwDataSizeGet ); /* Remote: works as expected */
checkStr( lpData, lpDataGet );
dwDataSizeGet = dwDataSizeFake;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
DPGET_REMOTE );
checkHR( DP_OK, hr );
check( dwDataSize, dwDataSizeGet ); /* Like in previous test */
checkStr( lpData, lpDataGet );
dwDataSizeGet = dwDataSizeFake;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
DPGET_LOCAL );
checkHR( DP_OK, hr );
check( dwDataSizeLocal, dwDataSizeGet ); /* Local: works as expected */
checkStr( lpDataLocal, lpDataGet );
dwDataSizeGet = dwDataSizeFake;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
DPGET_LOCAL | DPGET_REMOTE );
checkHR( DP_OK, hr );
check( dwDataSizeLocal, dwDataSizeGet ); /* Like in previous test */
checkStr( lpDataLocal, lpDataGet );
/* Small buffer works as expected again */
dwDataSizeGet = 0;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
DPGET_LOCAL );
checkHR( DPERR_BUFFERTOOSMALL, hr );
check( dwDataSizeLocal, dwDataSizeGet );
checkStr( lpDataFake, lpDataGet );
dwDataSizeGet = dwDataSizeFake;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, NULL,
&dwDataSizeGet, DPGET_LOCAL );
check( DPERR_BUFFERTOOSMALL, hr );
check( dwDataSizeLocal, dwDataSizeGet );
checkStr( lpDataFake, lpDataGet );
/*
* Changing remote data
*/
/* Remote data := local data */
hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataLocal,
dwDataSizeLocal,
DPSET_GUARANTEED | DPSET_REMOTE );
checkHR( DP_OK, hr );
hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataLocal,
dwDataSizeLocal, 0 );
checkHR( DP_OK, hr );
dwDataSizeGet = dwDataSizeFake;
strcpy(lpDataGet, lpDataFake);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 );
checkHR( DP_OK, hr );
check( dwDataSizeLocal, dwDataSizeGet );
checkStr( lpDataLocal, lpDataGet );
/* Remote data := fake data */
hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataFake,
dwDataSizeFake, DPSET_REMOTE );
checkHR( DP_OK, hr );
dwDataSizeGet = dwDataSizeFake + 1;
strcpy(lpDataGet, lpData);
hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 );
checkHR( DP_OK, hr );
check( dwDataSizeFake, dwDataSizeGet );
checkStr( lpDataFake, lpDataGet );
HeapFree( GetProcessHeap(), 0, lpDataGet );
IDirectPlayX_Release( pDP );
}
/* GetPlayerName
SetPlayerName */
static void test_PlayerName(void)
{
IDirectPlay4 *pDP[2];
DPSESSIONDESC2 dpsd;
DPID dpid[2];
HRESULT hr;
UINT i;
DPNAME playerName;
DWORD dwDataSize = 1024;
LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
CallbackData callbackData;
for (i=0; i<2; i++)
{
hr= CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
}
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
ZeroMemory( &playerName, sizeof(DPNAME) );
/* Service provider not initialized */
hr = IDirectPlayX_SetPlayerName( pDP[0], 0, &playerName, 0 );
checkHR( DPERR_UNINITIALIZED, hr );
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize );
checkHR( DPERR_UNINITIALIZED, hr );
check( 1024, dwDataSize );
init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
/* Session not initialized */
hr = IDirectPlayX_SetPlayerName( pDP[0], 0, &playerName, 0 );
todo_wine checkHR( DPERR_INVALIDPLAYER, hr );
if ( hr == DPERR_UNINITIALIZED )
{
todo_wine win_skip( "Get/SetPlayerName not implemented\n" );
return;
}
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize );
checkHR( DPERR_INVALIDPLAYER, hr );
check( 1024, dwDataSize );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.dwMaxPlayers = 10;
IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
pDP[1], 0 );
IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 );
IDirectPlayX_CreatePlayer( pDP[1], &dpid[1], NULL, NULL, NULL, 0, 0 );
/* Name not initialized */
playerName.dwSize = -1;
hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, 0 );
checkHR( DP_OK, hr );
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize );
checkHR( DPERR_INVALIDPLAYER, hr );
check( 1024, dwDataSize );
playerName.dwSize = sizeof(DPNAME);
U1(playerName).lpszShortNameA = (LPSTR) "player_name";
U2(playerName).lpszLongNameA = (LPSTR) "player_long_name";
/* Invalid parameters */
hr = IDirectPlayX_SetPlayerName( pDP[0], -1, &playerName, 0 );
checkHR( DPERR_INVALIDPLAYER, hr );
hr = IDirectPlayX_SetPlayerName( pDP[0], 0, &playerName, 0 );
checkHR( DPERR_INVALIDPLAYER, hr );
hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, -1 );
checkHR( DPERR_INVALIDPARAMS, hr );
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize );
checkHR( DPERR_INVALIDPLAYER, hr );
check( 1024, dwDataSize );
dwDataSize = -1;
hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
checkHR( DPERR_INVALIDPARAMS, hr );
check( -1, dwDataSize );
hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, NULL );
checkHR( DPERR_INVALIDPARAMS, hr );
/* Trying to modify remote player */
hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[1], &playerName, 0 );
checkHR( DPERR_ACCESSDENIED, hr );
/* Regular operation */
hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, 0 );
checkHR( DP_OK, hr );
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
checkHR( DP_OK, hr );
check( 45, dwDataSize );
checkStr( U1(playerName).lpszShortNameA, U1(*(LPDPNAME)lpData).lpszShortNameA );
checkStr( U2(playerName).lpszLongNameA, U2(*(LPDPNAME)lpData).lpszLongNameA );
check( 0, ((LPDPNAME)lpData)->dwFlags );
hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], NULL, 0 );
checkHR( DP_OK, hr );
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
checkHR( DP_OK, hr );
check( 16, dwDataSize );
checkLP( NULL, U1(*(LPDPNAME)lpData).lpszShortNameA );
checkLP( NULL, U2(*(LPDPNAME)lpData).lpszLongNameA );
check( 0, ((LPDPNAME)lpData)->dwFlags );
/* Small buffer in get operation */
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], NULL, &dwDataSize );
checkHR( DPERR_BUFFERTOOSMALL, hr );
check( 16, dwDataSize );
dwDataSize = 0;
hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
checkHR( DPERR_BUFFERTOOSMALL, hr );
check( 16, dwDataSize );
hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
checkHR( DP_OK, hr );
check( 16, dwDataSize );
checkLP( NULL, U1(*(LPDPNAME)lpData).lpszShortNameA );
checkLP( NULL, U2(*(LPDPNAME)lpData).lpszLongNameA );
check( 0, ((LPDPNAME)lpData)->dwFlags );
/* Flags */
hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName,
DPSET_GUARANTEED );
checkHR( DP_OK, hr );
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
checkHR( DP_OK, hr );
check( 45, dwDataSize );
checkStr( U1(playerName).lpszShortNameA, U1(*(LPDPNAME)lpData).lpszShortNameA );
checkStr( U2(playerName).lpszLongNameA, U2(*(LPDPNAME)lpData).lpszLongNameA );
check( 0, ((LPDPNAME)lpData)->dwFlags );
/* - Local (no propagation) */
U1(playerName).lpszShortNameA = (LPSTR) "no_propagation";
hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName,
DPSET_LOCAL );
checkHR( DP_OK, hr );
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0],
lpData, &dwDataSize ); /* Local fetch */
checkHR( DP_OK, hr );
check( 48, dwDataSize );
checkStr( "no_propagation", U1(*(LPDPNAME)lpData).lpszShortNameA );
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0],
lpData, &dwDataSize ); /* Remote fetch */
checkHR( DP_OK, hr );
check( 45, dwDataSize );
checkStr( "player_name", U1(*(LPDPNAME)lpData).lpszShortNameA );
/* -- 2 */
U1(playerName).lpszShortNameA = (LPSTR) "no_propagation_2";
hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName,
DPSET_LOCAL | DPSET_REMOTE );
checkHR( DP_OK, hr );
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0],
lpData, &dwDataSize ); /* Local fetch */
checkHR( DP_OK, hr );
check( 50, dwDataSize );
checkStr( "no_propagation_2", U1(*(LPDPNAME)lpData).lpszShortNameA );
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0],
lpData, &dwDataSize ); /* Remote fetch */
checkHR( DP_OK, hr );
check( 45, dwDataSize );
checkStr( "player_name", U1(*(LPDPNAME)lpData).lpszShortNameA );
/* - Remote (propagation, default) */
U1(playerName).lpszShortNameA = (LPSTR) "propagation";
hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName,
DPSET_REMOTE );
checkHR( DP_OK, hr );
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0],
lpData, &dwDataSize ); /* Remote fetch */
checkHR( DP_OK, hr );
check( 45, dwDataSize );
checkStr( "propagation", U1(*(LPDPNAME)lpData).lpszShortNameA );
/* -- 2 */
U1(playerName).lpszShortNameA = (LPSTR) "propagation_2";
hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName,
0 );
checkHR( DP_OK, hr );
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0],
lpData, &dwDataSize ); /* Remote fetch */
checkHR( DP_OK, hr );
check( 47, dwDataSize );
checkStr( "propagation_2", U1(*(LPDPNAME)lpData).lpszShortNameA );
/* Checking system messages */
check_messages( pDP[0], dpid, 2, &callbackData );
checkStr( "S0,S0,S0,S0,S0,S0,S0,", callbackData.szTrace1 );
checkStr( "48,28,57,28,57,57,59,", callbackData.szTrace2 );
check_messages( pDP[1], dpid, 2, &callbackData );
checkStr( "S1,S1,S1,S1,S1,S1,", callbackData.szTrace1 );
checkStr( "28,57,28,57,57,59,", callbackData.szTrace2 );
HeapFree( GetProcessHeap(), 0, lpData );
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
}
/* GetPlayerAccount */
static BOOL CALLBACK EnumSessions_cb_join_secure( LPCDPSESSIONDESC2 lpThisSD,
LPDWORD lpdwTimeOut,
DWORD dwFlags,
LPVOID lpContext )
{
IDirectPlay4 *pDP = lpContext;
DPSESSIONDESC2 dpsd;
DPCREDENTIALS dpCredentials;
HRESULT hr;
if (dwFlags & DPESC_TIMEDOUT)
{
return FALSE;
}
checkFlags( DPSESSION_SECURESERVER, lpThisSD->dwFlags, FLAGS_DPSESSION );
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.guidInstance = lpThisSD->guidInstance;
ZeroMemory( &dpCredentials, sizeof(DPCREDENTIALS) );
dpCredentials.dwSize = sizeof(DPCREDENTIALS);
U1(dpCredentials).lpszUsernameA = (LPSTR) "user";
U2(dpCredentials).lpszPasswordA = (LPSTR) "pass";
hr = IDirectPlayX_SecureOpen( pDP, &dpsd, DPOPEN_JOIN,
NULL, &dpCredentials );
checkHR( DPERR_LOGONDENIED, hr ); /* TODO: Make this work */
return TRUE;
}
static void test_GetPlayerAccount(void)
{
IDirectPlay4 *pDP[2];
DPSESSIONDESC2 dpsd;
DPID dpid[2];
HRESULT hr;
UINT i;
DWORD dwDataSize = 1024;
LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
for (i=0; i<2; i++)
{
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
}
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.dwMaxPlayers = 10;
/* Uninitialized service provider */
hr = IDirectPlayX_GetPlayerAccount( pDP[0], 0, 0, lpData, &dwDataSize );
todo_wine checkHR( DPERR_UNINITIALIZED, hr );
if ( hr == DP_OK )
{
todo_wine win_skip( "GetPlayerAccount not implemented\n" );
return;
}
init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
/* No session */
hr = IDirectPlayX_GetPlayerAccount( pDP[0], 0, 0, lpData, &dwDataSize );
checkHR( DPERR_NOSESSIONS, hr );
IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
pDP[1], 0 );
for (i=0; i<2; i++)
{
hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i], NULL, NULL, NULL,
0, 0 );
checkHR( DP_OK, hr );
}
/* Session is not secure */
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0,
lpData, &dwDataSize );
checkHR( DPERR_UNSUPPORTED, hr );
check( 1024, dwDataSize );
/* Open a secure session */
for (i=0; i<2; i++)
{
hr = IDirectPlayX_Close( pDP[i] );
checkHR( DP_OK, hr );
}
dpsd.dwFlags = DPSESSION_SECURESERVER;
hr = IDirectPlayX_SecureOpen( pDP[0], &dpsd, DPOPEN_CREATE, NULL, NULL );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[0],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0,
EnumSessions_cb_join_secure, pDP[1], 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid[1],
NULL, NULL, NULL, 0, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
/* TODO: Player creation so that this works */
/* Invalid player */
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerAccount( pDP[0], 0, 0,
lpData, &dwDataSize );
checkHR( DPERR_INVALIDPLAYER, hr );
check( 1024, dwDataSize );
/* Invalid flags */
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], -1,
lpData, &dwDataSize );
checkHR( DPERR_INVALIDFLAGS, hr );
check( 1024, dwDataSize );
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 1,
lpData, &dwDataSize );
checkHR( DPERR_INVALIDFLAGS, hr );
check( 1024, dwDataSize );
/* Small buffer */
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0,
NULL, &dwDataSize );
checkHR( DPERR_INVALIDPLAYER, hr );
check( 0, dwDataSize );
dwDataSize = 0;
hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0,
lpData, &dwDataSize );
checkHR( DPERR_INVALIDPLAYER, hr );
check( 0, dwDataSize );
hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0,
lpData, &dwDataSize );
checkHR( DPERR_INVALIDPLAYER, hr );
check( 0, dwDataSize );
/* Normal operation */
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0,
lpData, &dwDataSize );
checkHR( DPERR_INVALIDPLAYER, hr );
check( 1024, dwDataSize );
HeapFree( GetProcessHeap(), 0, lpData );
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
}
/* GetPlayerAddress */
static BOOL CALLBACK EnumAddress_cb( REFGUID guidDataType,
DWORD dwDataSize,
LPCVOID lpData,
LPVOID lpContext )
{
lpCallbackData callbackData = lpContext;
static REFGUID types[] = { &DPAID_TotalSize,
&DPAID_ServiceProvider,
&DPAID_INet,
&DPAID_INetW };
static DWORD sizes[] = { 4, 16, 12, 24, 4, 16, 10, 20 };
checkGuid( types[callbackData->dwCounter1%4], guidDataType );
check( sizes[callbackData->dwCounter1], dwDataSize );
switch(callbackData->dwCounter1)
{
case 0:
check( 136, *(LPDWORD) lpData );
break;
case 4:
check( 130, *(LPDWORD) lpData );
break;
case 1:
case 5:
checkGuid( &DPSPGUID_TCPIP, lpData );
break;
case 6:
checkStr( "127.0.0.1", (LPSTR) lpData );
break;
default: break;
}
callbackData->dwCounter1++;
return TRUE;
}
static void test_GetPlayerAddress(void)
{
IDirectPlay4 *pDP[2];
IDirectPlayLobby3 *pDPL;
DPSESSIONDESC2 dpsd;
DPID dpid[2];
CallbackData callbackData;
HRESULT hr;
UINT i;
DWORD dwDataSize = 1024;
LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
for (i=0; i<2; i++)
{
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
}
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
hr = CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL,
&IID_IDirectPlayLobby3A, (LPVOID*) &pDPL );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlayLobby / IID_IDirectPlayLobby3A failed\n" );
if (FAILED(hr)) return;
/* Uninitialized service provider */
hr = IDirectPlayX_GetPlayerAddress( pDP[0], 0, lpData, &dwDataSize );
todo_wine checkHR( DPERR_UNINITIALIZED, hr );
if ( hr == DP_OK )
{
todo_wine win_skip( "GetPlayerAddress not implemented\n" );
return;
}
init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
/* No session */
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerAddress( pDP[0], 0, lpData, &dwDataSize );
checkHR( DPERR_UNSUPPORTED, hr );
check( 1024, dwDataSize );
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerAddress( pDP[0], 1, lpData, &dwDataSize );
checkHR( DPERR_INVALIDPLAYER, hr );
check( 1024, dwDataSize );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.dwMaxPlayers = 10;
IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
pDP[1], 0 );
for (i=0; i<2; i++)
{
hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i], NULL, NULL, NULL,
0, 0 );
checkHR( DP_OK, hr );
}
/* Invalid player */
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerAddress( pDP[0], 0,
lpData, &dwDataSize );
checkHR( DPERR_UNSUPPORTED, hr );
check( 1024, dwDataSize );
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerAddress( pDP[0], 1,
lpData, &dwDataSize );
checkHR( DPERR_INVALIDPLAYER, hr );
check( 1024, dwDataSize );
/* Small buffer */
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0],
NULL, &dwDataSize );
checkHR( DPERR_BUFFERTOOSMALL, hr );
check( 136, dwDataSize );
dwDataSize = 0;
hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0],
lpData, &dwDataSize );
checkHR( DPERR_BUFFERTOOSMALL, hr );
check( 136, dwDataSize );
hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0],
lpData, &dwDataSize );
checkHR( DP_OK, hr );
check( 136, dwDataSize );
/* Regular parameters */
callbackData.dwCounter1 = 0;
/* - Local */
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0],
lpData, &dwDataSize );
checkHR( DP_OK, hr );
check( 136, dwDataSize );
hr = IDirectPlayLobby_EnumAddress( pDPL, EnumAddress_cb, lpData, dwDataSize,
&callbackData );
checkHR( DP_OK, hr );
check( 4, callbackData.dwCounter1 );
/* - Remote */
dwDataSize = 1024;
hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[1],
lpData, &dwDataSize );
checkHR( DP_OK, hr );
check( 130, dwDataSize );
hr = IDirectPlayLobby_EnumAddress( pDPL, EnumAddress_cb, lpData, dwDataSize,
&callbackData );
checkHR( DP_OK, hr );
check( 8, callbackData.dwCounter1 );
HeapFree( GetProcessHeap(), 0, lpData );
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
}
/* GetPlayerFlags */
static void test_GetPlayerFlags(void)
{
IDirectPlay4 *pDP[2];
DPSESSIONDESC2 dpsd;
DPID dpid[4];
HRESULT hr;
UINT i;
DWORD dwFlags = 0;
for (i=0; i<2; i++)
{
hr= CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
}
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.dwMaxPlayers = 10;
/* Uninitialized service provider */
hr = IDirectPlayX_GetPlayerFlags( pDP[0], 0, &dwFlags );
todo_wine checkHR( DPERR_UNINITIALIZED, hr );
if ( hr == DP_OK )
{
todo_wine win_skip( "GetPlayerFlags not implemented\n" );
return;
}
init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
/* No session */
hr = IDirectPlayX_GetPlayerFlags( pDP[0], 0, &dwFlags );
checkHR( DPERR_INVALIDPLAYER, hr );
hr = IDirectPlayX_GetPlayerFlags( pDP[0], 1, &dwFlags );
checkHR( DPERR_INVALIDPLAYER, hr );
IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
pDP[1], 0 );
for (i=0; i<2; i++)
{
hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
}
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[2],
NULL, NULL, NULL,
0, DPPLAYER_SPECTATOR );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[3],
NULL, NULL, NULL,
0, DPPLAYER_SERVERPLAYER );
checkHR( DP_OK, hr );
/* Invalid player */
hr = IDirectPlayX_GetPlayerFlags( pDP[0], 0, &dwFlags );
checkHR( DPERR_INVALIDPLAYER, hr );
hr = IDirectPlayX_GetPlayerFlags( pDP[0], 2, &dwFlags );
checkHR( DPERR_INVALIDPLAYER, hr );
/* Invalid parameters */
hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[0], NULL );
checkHR( DPERR_INVALIDPARAMS, hr );
/* Regular parameters */
hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[0], &dwFlags );
checkHR( DP_OK, hr );
checkFlags( dwFlags, DPPLAYER_LOCAL, FLAGS_DPPLAYER );
hr = IDirectPlayX_GetPlayerFlags( pDP[1], dpid[1], &dwFlags );
checkHR( DP_OK, hr );
checkFlags( dwFlags, DPPLAYER_LOCAL, FLAGS_DPPLAYER );
hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[1], &dwFlags );
checkHR( DP_OK, hr );
checkFlags( dwFlags, 0, FLAGS_DPPLAYER );
hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[2], &dwFlags );
checkHR( DP_OK, hr );
checkFlags( dwFlags, DPPLAYER_SPECTATOR | DPPLAYER_LOCAL, FLAGS_DPPLAYER );
hr = IDirectPlayX_GetPlayerFlags( pDP[1], dpid[3], &dwFlags );
checkHR( DP_OK, hr );
checkFlags( dwFlags, DPPLAYER_SERVERPLAYER, FLAGS_DPPLAYER );
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
}
/* CreateGroup
CreateGroupInGroup */
static void test_CreateGroup(void)
{
IDirectPlay4 *pDP;
DPSESSIONDESC2 dpsd;
DPID idFrom, idTo, dpid, idGroup, idGroupParent;
DPNAME groupName;
HRESULT hr;
UINT i;
LPCSTR lpData = "data";
DWORD dwDataSize = strlen(lpData)+1;
LPDPMSG_CREATEPLAYERORGROUP lpDataGet = HeapAlloc( GetProcessHeap(),
HEAP_ZERO_MEMORY,
1024 );
DWORD dwDataSizeGet = 1024;
CallbackData callbackData;
hr= CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.dwMaxPlayers = 10;
ZeroMemory( &groupName, sizeof(DPNAME) );
/* No service provider */
hr = IDirectPlayX_CreateGroup( pDP, &idGroup, NULL, NULL, 0, 0 );
checkHR( DPERR_UNINITIALIZED, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP, 0, &idGroup, NULL, NULL, 0, 0 );
checkHR( DPERR_UNINITIALIZED, hr );
init_TCPIP_provider( pDP, "127.0.0.1", 0 );
/* No session */
hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
NULL, NULL, 0, 0 );
todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
if ( hr == DPERR_UNINITIALIZED )
{
todo_wine win_skip( "CreateGroup not implemented\n" );
return;
}
hr = IDirectPlayX_CreateGroupInGroup( pDP, 0, &idGroup,
NULL, NULL, 0, 0 );
checkHR( DPERR_INVALIDGROUP, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP, 2, &idGroup,
NULL, NULL, 0, 0 );
checkHR( DPERR_INVALIDGROUP, hr );
hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE );
checkHR( DP_OK, hr );
IDirectPlayX_CreatePlayer( pDP, &dpid,
NULL, NULL, NULL, 0, 0 );
/* With name */
hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup,
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
&groupName, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup,
&groupName, NULL, 0, 0 );
checkHR( DP_OK, hr );
groupName.dwSize = sizeof(DPNAME);
U1(groupName).lpszShortNameA = (LPSTR) lpData;
hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
&groupName, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup,
&groupName, NULL, 0, 0 );
checkHR( DP_OK, hr );
/* Message checking */
for (i=0; i<6; i++)
{
dwDataSizeGet = 1024;
hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpDataGet,
&dwDataSizeGet );
checkHR( DP_OK, hr );
if ( NULL == U1(lpDataGet->dpnName).lpszShortNameA )
{
check( 48, dwDataSizeGet );
}
else
{
check( 48 + dwDataSize, dwDataSizeGet );
checkStr( lpData, U1(lpDataGet->dpnName).lpszShortNameA );
}
check( DPID_SYSMSG, idFrom );
checkConv( DPSYS_CREATEPLAYERORGROUP, lpDataGet->dwType, dpMsgType2str );
check( DPPLAYERTYPE_GROUP, lpDataGet->dwPlayerType );
checkFlags( DPGROUP_LOCAL, lpDataGet->dwFlags, FLAGS_DPGROUP );
}
check_messages( pDP, &dpid, 1, &callbackData );
checkStr( "", callbackData.szTrace1 );
/* With data */
hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
NULL, (LPVOID) lpData, -1, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
NULL, (LPVOID) lpData, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
NULL, NULL, dwDataSize, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
NULL, (LPVOID) lpData, dwDataSize, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup,
NULL, (LPVOID) lpData, -1, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup,
NULL, (LPVOID) lpData, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup,
NULL, NULL, dwDataSize, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup,
NULL, (LPVOID)lpData, dwDataSize, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP, &idGroupParent,
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
/* Message checking */
for (i=0; i<5; i++)
{
dwDataSizeGet = 1024;
hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpDataGet,
&dwDataSizeGet );
checkHR( DP_OK, hr );
check( 48 + lpDataGet->dwDataSize, dwDataSizeGet );
check( DPID_SYSMSG, idFrom );
checkConv( DPSYS_CREATEPLAYERORGROUP, lpDataGet->dwType, dpMsgType2str );
check( DPPLAYERTYPE_GROUP, lpDataGet->dwPlayerType );
checkFlags( DPGROUP_LOCAL, lpDataGet->dwFlags, FLAGS_DPGROUP );
}
check_messages( pDP, &dpid, 1, &callbackData );
checkStr( "", callbackData.szTrace1 );
/* Flags and idGroupParent */
hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
NULL, NULL, 0, DPGROUP_HIDDEN );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
NULL, NULL, 0, DPGROUP_STAGINGAREA );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
NULL, NULL, 0,
DPGROUP_HIDDEN | DPGROUP_STAGINGAREA );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroupParent, &idGroup,
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroupParent, &idGroup,
NULL, NULL, 0, DPGROUP_HIDDEN );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroupParent, &idGroup,
NULL, NULL, 0, DPGROUP_STAGINGAREA );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroupParent, &idGroup,
NULL, NULL, 0,
DPGROUP_HIDDEN |
DPGROUP_STAGINGAREA );
checkHR( DP_OK, hr );
/* Message checking */
for (i=0; i<8; i++)
{
dwDataSizeGet = 1024;
hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpDataGet,
&dwDataSizeGet );
checkHR( DP_OK, hr );
check( 48, dwDataSizeGet );
check( DPID_SYSMSG, idFrom );
checkConv( DPSYS_CREATEPLAYERORGROUP, lpDataGet->dwType, dpMsgType2str );
check( DPPLAYERTYPE_GROUP, lpDataGet->dwPlayerType );
if ( lpDataGet->dpIdParent != 0 )
{
check( idGroupParent, lpDataGet->dpIdParent );
}
switch (i%4)
{
case 0:
checkFlags( DPGROUP_LOCAL,
lpDataGet->dwFlags, FLAGS_DPGROUP );
break;
case 1:
checkFlags( DPGROUP_LOCAL | DPGROUP_HIDDEN,
lpDataGet->dwFlags, FLAGS_DPGROUP );
break;
case 2:
checkFlags( DPGROUP_STAGINGAREA | DPGROUP_LOCAL,
lpDataGet->dwFlags, FLAGS_DPGROUP );
break;
case 3:
checkFlags( DPGROUP_STAGINGAREA | DPGROUP_LOCAL | DPGROUP_HIDDEN,
lpDataGet->dwFlags, FLAGS_DPGROUP );
break;
default: break;
}
}
check_messages( pDP, &dpid, 1, &callbackData );
checkStr( "", callbackData.szTrace1 );
/* If a group is created in C/S mode, no messages are sent */
/* - Peer 2 peer */
IDirectPlayX_Close( pDP );
dpsd.dwFlags = 0;
hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP, &dpid, NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP, &idGroup, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
/* Messages are received */
check_messages( pDP, &dpid, 1, &callbackData );
checkStr( "S0,", callbackData.szTrace1 );
/* - Client/Server */
IDirectPlayX_Close( pDP );
dpsd.dwFlags = DPSESSION_CLIENTSERVER;
hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP, &dpid,
NULL, NULL, NULL, 0,
DPPLAYER_SERVERPLAYER );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
/* No messages */
check_messages( pDP, &dpid, 1, &callbackData );
checkStr( "S0,", callbackData.szTrace1 ); /* Or at least there
shouldn't be messages... */
HeapFree( GetProcessHeap(), 0, lpDataGet );
IDirectPlayX_Release( pDP );
}
/* GroupOwner */
static void test_GroupOwner(void)
{
IDirectPlay4 *pDP[2];
DPSESSIONDESC2 dpsd;
DPID dpid[2], idGroup, idOwner;
HRESULT hr;
UINT i;
for (i=0; i<2; i++)
{
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
}
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.dwMaxPlayers = 10;
idGroup = 0;
idOwner = 0;
/* Service provider not initialized */
hr = IDirectPlayX_GetGroupOwner( pDP[0], idGroup, &idOwner );
todo_wine checkHR( DPERR_UNINITIALIZED, hr );
check( 0, idOwner );
if ( hr == DP_OK )
{
todo_wine win_skip( "GetGroupOwner not implemented\n" );
return;
}
for (i=0; i<2; i++)
init_TCPIP_provider( pDP[i], "127.0.0.1", 0 );
hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
checkHR( DP_OK, hr );
hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
pDP[1], 0 );
checkHR( DP_OK, hr );
for (i=0; i<2; i++)
{
hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
}
/* Invalid group */
hr = IDirectPlayX_GetGroupOwner( pDP[0], idGroup, &idOwner );
checkHR( DPERR_INVALIDGROUP, hr );
hr = IDirectPlayX_CreateGroup( pDP[0], &idGroup, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
/* Fails, because we need a lobby session */
hr = IDirectPlayX_GetGroupOwner( pDP[0], idGroup, &idOwner );
checkHR( DPERR_UNSUPPORTED, hr );
/* TODO:
* - Make this work
* - Check migration of the ownership of a group
* when the owner leaves
*/
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
}
/* EnumPlayers */
static BOOL CALLBACK EnumPlayers_cb( DPID dpId,
DWORD dwPlayerType,
LPCDPNAME lpName,
DWORD dwFlags,
LPVOID lpContext )
{
lpCallbackData callbackData = lpContext;
char playerIndex = dpid2char( callbackData->dpid,
callbackData->dpidSize,
dpId );
/* Trace to study player ids */
callbackData->szTrace1[ callbackData->dwCounter1 ] = playerIndex;
callbackData->dwCounter1++;
callbackData->szTrace1[ callbackData->dwCounter1 ] = '\0';
/* Trace to study flags received */
strcat( callbackData->szTrace2,
( dwFlags2str(dwFlags, FLAGS_DPENUMPLAYERS) +
strlen("DPENUMPLAYERS_") ) );
strcat( callbackData->szTrace2, ":" );
if ( playerIndex < '5' )
{
check( DPPLAYERTYPE_PLAYER, dwPlayerType );
}
else
{
check( DPPLAYERTYPE_GROUP, dwPlayerType );
}
return TRUE;
}
static BOOL CALLBACK EnumSessions_cb_EnumPlayers( LPCDPSESSIONDESC2 lpThisSD,
LPDWORD lpdwTimeOut,
DWORD dwFlags,
LPVOID lpContext )
{
lpCallbackData callbackData = lpContext;
HRESULT hr;
if (dwFlags & DPESC_TIMEDOUT)
{
return FALSE;
}
/* guid = NULL */
callbackData->dwCounter1 = 0;
hr = IDirectPlayX_EnumPlayers( callbackData->pDP, NULL, EnumPlayers_cb,
&callbackData, 0 );
checkHR( DPERR_NOSESSIONS, hr );
check( 0, callbackData->dwCounter1 );
/* guid = appGuid */
callbackData->dwCounter1 = 0;
hr = IDirectPlayX_EnumPlayers( callbackData->pDP, (LPGUID) &appGuid,
EnumPlayers_cb, &callbackData, 0 );
checkHR( DPERR_NOSESSIONS, hr );
check( 0, callbackData->dwCounter1 );
callbackData->dwCounter1 = 0;
hr = IDirectPlayX_EnumPlayers( callbackData->pDP, (LPGUID) &appGuid,
EnumPlayers_cb, &callbackData,
DPENUMPLAYERS_SESSION );
checkHR( DPERR_NOSESSIONS, hr );
check( 0, callbackData->dwCounter1 );
/* guid = guidInstance */
callbackData->dwCounter1 = 0;
hr = IDirectPlayX_EnumPlayers( callbackData->pDP,
(LPGUID) &lpThisSD->guidInstance,
EnumPlayers_cb, &callbackData, 0 );
checkHR( DPERR_NOSESSIONS, hr );
check( 0, callbackData->dwCounter1 );
callbackData->dwCounter1 = 0;
hr = IDirectPlayX_EnumPlayers( callbackData->pDP,
(LPGUID) &lpThisSD->guidInstance,
EnumPlayers_cb, &callbackData,
DPENUMPLAYERS_SESSION );
checkHR( DPERR_GENERIC, hr ); /* Why? */
check( 0, callbackData->dwCounter1 );
return TRUE;
}
static void test_EnumPlayers(void)
{
IDirectPlay4 *pDP[3];
DPSESSIONDESC2 dpsd[3];
DPID dpid[5+2]; /* 5 players, 2 groups */
CallbackData callbackData;
HRESULT hr;
UINT i;
for (i=0; i<3; i++)
{
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
ZeroMemory( &dpsd[i], sizeof(DPSESSIONDESC2) );
dpsd[i].dwSize = sizeof(DPSESSIONDESC2);
}
dpsd[0].guidApplication = appGuid;
dpsd[1].guidApplication = appGuid2;
dpsd[2].guidApplication = GUID_NULL;
callbackData.dpid = dpid;
callbackData.dpidSize = 5+2;
/* Uninitialized service provider */
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumPlayers( pDP[0], (LPGUID) &appGuid, NULL,
&callbackData, 0 );
checkHR( DPERR_UNINITIALIZED, hr );
check( 0, callbackData.dwCounter1 );
init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[2], "127.0.0.1", 0 );
/* No session */
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumPlayers( pDP[0], NULL, EnumPlayers_cb,
&callbackData, 0 );
todo_wine checkHR( DPERR_NOSESSIONS, hr );
check( 0, callbackData.dwCounter1 );
if ( hr == DPERR_UNINITIALIZED )
{
todo_wine win_skip( "EnumPlayers not implemented\n" );
return;
}
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumPlayers( pDP[0], (LPGUID) &appGuid, EnumPlayers_cb,
&callbackData, 0 );
checkHR( DPERR_NOSESSIONS, hr );
check( 0, callbackData.dwCounter1 );
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumPlayers( pDP[0], (LPGUID) &appGuid, EnumPlayers_cb,
&callbackData, DPENUMPLAYERS_SESSION );
checkHR( DPERR_NOSESSIONS, hr );
check( 0, callbackData.dwCounter1 );
hr = IDirectPlayX_Open( pDP[0], &dpsd[0], DPOPEN_CREATE );
checkHR( DP_OK, hr );
hr = IDirectPlayX_Open( pDP[1], &dpsd[1], DPOPEN_CREATE );
checkHR( DP_OK, hr );
/* No players */
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumPlayers( pDP[0], NULL, EnumPlayers_cb,
&callbackData, 0 );
checkHR( DP_OK, hr );
check( 0, callbackData.dwCounter1 );
/* Create players */
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[0],
NULL, NULL, NULL, 0,
DPPLAYER_SERVERPLAYER );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid[1],
NULL, NULL, NULL, 0,
0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[2],
NULL, NULL, NULL, 0,
0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[5],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
/* Invalid parameters */
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumPlayers( pDP[0], (LPGUID) &appGuid, NULL,
&callbackData, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
check( 0, callbackData.dwCounter1 );
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumPlayers( pDP[0], NULL, EnumPlayers_cb,
&callbackData, DPENUMPLAYERS_SESSION );
checkHR( DPERR_INVALIDPARAMS, hr );
check( 0, callbackData.dwCounter1 );
/* Regular operation */
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumPlayers( pDP[0], NULL, EnumPlayers_cb,
&callbackData, 0 );
checkHR( DP_OK, hr );
check( 2, callbackData.dwCounter1 );
checkStr( "20", callbackData.szTrace1 );
checkStr( "ALL:SERVERPLAYER:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumPlayers( pDP[1], NULL, EnumPlayers_cb,
&callbackData, 0 );
checkHR( DP_OK, hr );
check( 1, callbackData.dwCounter1 );
checkStr( "1", callbackData.szTrace1 );
checkStr( "ALL:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumPlayers( pDP[0], (LPGUID) &appGuid, EnumPlayers_cb,
&callbackData, 0 );
checkHR( DP_OK, hr );
check( 2, callbackData.dwCounter1 ); /* Guid is ignored */
checkStr( "20", callbackData.szTrace1 );
checkStr( "ALL:SERVERPLAYER:", callbackData.szTrace2 );
/* Enumerating from a remote session */
/* - Session not open */
callbackData.pDP = pDP[2];
hr = IDirectPlayX_EnumSessions( pDP[2], &dpsd[2], 0,
EnumSessions_cb_EnumPlayers,
&callbackData, 0 );
checkHR( DP_OK, hr );
/* - Open session */
callbackData.pDP = pDP[2];
hr = IDirectPlayX_EnumSessions( pDP[2], &dpsd[0], 0, EnumSessions_cb_join,
pDP[2], 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[2], &dpid[3],
NULL, NULL, NULL, 0,
DPPLAYER_SPECTATOR );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[2], &dpid[4],
NULL, NULL, NULL, 0,
0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP[2], &dpid[6],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb,
&callbackData, 0 );
checkHR( DP_OK, hr );
check( 4, callbackData.dwCounter1 );
checkStr( "4302", callbackData.szTrace1 );
checkStr( "ALL:SPECTATOR:SERVERPLAYER:ALL:", callbackData.szTrace2 );
/* Flag tests */
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb,
&callbackData, DPENUMPLAYERS_ALL );
checkHR( DP_OK, hr );
check( 4, callbackData.dwCounter1 );
checkStr( "4302", callbackData.szTrace1 );
checkStr( "ALL:SPECTATOR:SERVERPLAYER:ALL:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb,
&callbackData, DPENUMPLAYERS_GROUP );
checkHR( DP_OK, hr );
check( 6, callbackData.dwCounter1 );
checkStr( "430256", callbackData.szTrace1 );
checkStr( "GROUP:"
"GROUP,DPENUMPLAYERS_SPECTATOR:"
"GROUP,DPENUMPLAYERS_SERVERPLAYER:"
"GROUP:ALL:ALL:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb,
&callbackData, DPENUMPLAYERS_LOCAL );
checkHR( DP_OK, hr );
check( 2, callbackData.dwCounter1 );
checkStr( "43", callbackData.szTrace1 );
checkStr( "LOCAL:"
"LOCAL,DPENUMPLAYERS_SPECTATOR:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb,
&callbackData, DPENUMPLAYERS_SERVERPLAYER );
checkHR( DP_OK, hr );
check( 1, callbackData.dwCounter1 );
checkStr( "0", callbackData.szTrace1 );
checkStr( "SERVERPLAYER:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb,
&callbackData, DPENUMPLAYERS_SPECTATOR );
checkHR( DP_OK, hr );
check( 1, callbackData.dwCounter1 );
checkStr( "3", callbackData.szTrace1 );
checkStr( "SPECTATOR:", callbackData.szTrace2 );
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
IDirectPlayX_Release( pDP[2] );
}
/* EnumGroups */
static BOOL CALLBACK EnumGroups_cb( DPID dpId,
DWORD dwPlayerType,
LPCDPNAME lpName,
DWORD dwFlags,
LPVOID lpContext )
{
lpCallbackData callbackData = lpContext;
char playerIndex = dpid2char( callbackData->dpid,
callbackData->dpidSize,
dpId );
/* Trace to study player ids */
callbackData->szTrace1[ callbackData->dwCounter1 ] = playerIndex;
callbackData->dwCounter1++;
callbackData->szTrace1[ callbackData->dwCounter1 ] = '\0';
/* Trace to study flags received */
strcat( callbackData->szTrace2,
( dwFlags2str(dwFlags, FLAGS_DPENUMGROUPS) +
strlen("DPENUMGROUPS_") ) );
strcat( callbackData->szTrace2, ":" );
check( DPPLAYERTYPE_GROUP, dwPlayerType );
return TRUE;
}
static BOOL CALLBACK EnumSessions_cb_EnumGroups( LPCDPSESSIONDESC2 lpThisSD,
LPDWORD lpdwTimeOut,
DWORD dwFlags,
LPVOID lpContext )
{
lpCallbackData callbackData = lpContext;
HRESULT hr;
if (dwFlags & DPESC_TIMEDOUT)
{
return FALSE;
}
/* guid = NULL */
callbackData->dwCounter1 = 0;
hr = IDirectPlayX_EnumGroups( callbackData->pDP, NULL,
EnumGroups_cb, &callbackData, 0 );
checkHR( DPERR_NOSESSIONS, hr );
check( 0, callbackData->dwCounter1 );
/* guid = appGuid */
callbackData->dwCounter1 = 0;
hr = IDirectPlayX_EnumGroups( callbackData->pDP, (LPGUID) &appGuid,
EnumGroups_cb, &callbackData, 0 );
checkHR( DPERR_NOSESSIONS, hr );
check( 0, callbackData->dwCounter1 );
callbackData->dwCounter1 = 0;
hr = IDirectPlayX_EnumGroups( callbackData->pDP, (LPGUID) &appGuid,
EnumGroups_cb, &callbackData,
DPENUMGROUPS_SESSION );
checkHR( DPERR_NOSESSIONS, hr );
check( 0, callbackData->dwCounter1 );
/* guid = guidInstance */
callbackData->dwCounter1 = 0;
hr = IDirectPlayX_EnumGroups( callbackData->pDP,
(LPGUID) &lpThisSD->guidInstance,
EnumGroups_cb, &callbackData, 0 );
checkHR( DPERR_NOSESSIONS, hr );
check( 0, callbackData->dwCounter1 );
callbackData->dwCounter1 = 0;
hr = IDirectPlayX_EnumGroups( callbackData->pDP,
(LPGUID) &lpThisSD->guidInstance,
EnumGroups_cb, &callbackData,
DPENUMGROUPS_SESSION );
checkHR( DPERR_GENERIC, hr ); /* Why? */
check( 0, callbackData->dwCounter1 );
return TRUE;
}
static void test_EnumGroups(void)
{
IDirectPlay4 *pDP[3];
DPSESSIONDESC2 dpsd[3];
DPID dpid[5];
CallbackData callbackData;
HRESULT hr;
UINT i;
for (i=0; i<3; i++)
{
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
ZeroMemory( &dpsd[i], sizeof(DPSESSIONDESC2) );
dpsd[i].dwSize = sizeof(DPSESSIONDESC2);
}
dpsd[0].guidApplication = appGuid;
dpsd[1].guidApplication = appGuid2;
dpsd[2].guidApplication = GUID_NULL;
callbackData.dpid = dpid;
callbackData.dpidSize = 5;
/* Uninitialized service provider */
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumGroups( pDP[0], NULL, EnumGroups_cb,
&callbackData, 0 );
checkHR( DPERR_UNINITIALIZED, hr );
check( 0, callbackData.dwCounter1 );
init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[2], "127.0.0.1", 0 );
/* No session */
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumGroups( pDP[0], NULL, EnumGroups_cb,
&callbackData, 0 );
todo_wine checkHR( DPERR_NOSESSIONS, hr );
check( 0, callbackData.dwCounter1 );
if ( hr == DPERR_UNINITIALIZED )
{
todo_wine win_skip( "EnumGroups not implemented\n" );
return;
}
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumGroups( pDP[0], (LPGUID) &appGuid, EnumGroups_cb,
&callbackData, 0 );
checkHR( DPERR_NOSESSIONS, hr );
check( 0, callbackData.dwCounter1 );
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumGroups( pDP[0], (LPGUID) &appGuid, EnumGroups_cb,
&callbackData, DPENUMGROUPS_SESSION );
checkHR( DPERR_NOSESSIONS, hr );
check( 0, callbackData.dwCounter1 );
hr = IDirectPlayX_Open( pDP[0], &dpsd[0], DPOPEN_CREATE );
checkHR( DP_OK, hr );
hr = IDirectPlayX_Open( pDP[1], &dpsd[1], DPOPEN_CREATE );
checkHR( DP_OK, hr );
/* No groups */
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumGroups( pDP[0], NULL, EnumGroups_cb,
&callbackData, 0 );
checkHR( DP_OK, hr );
check( 0, callbackData.dwCounter1 );
/* Create groups */
hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[0],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP[0], dpid[0], &dpid[3],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr ); /* Not a superior level group,
won't appear in the enumerations */
hr = IDirectPlayX_CreateGroup( pDP[1], &dpid[1],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[2],
NULL, NULL, 0, DPGROUP_HIDDEN );
checkHR( DP_OK, hr );
/* Invalid parameters */
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumGroups( pDP[0], (LPGUID) &appGuid, NULL,
&callbackData, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
check( 0, callbackData.dwCounter1 );
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumGroups( pDP[0], NULL, EnumGroups_cb,
&callbackData, DPENUMGROUPS_SESSION );
checkHR( DPERR_INVALIDPARAMS, hr );
check( 0, callbackData.dwCounter1 );
/* Regular operation */
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroups( pDP[0], NULL, EnumGroups_cb,
&callbackData, 0 );
checkHR( DP_OK, hr );
check( 2, callbackData.dwCounter1 );
checkStr( "02", callbackData.szTrace1 );
checkStr( "ALL:HIDDEN:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroups( pDP[1], NULL, EnumGroups_cb,
&callbackData, 0 );
checkHR( DP_OK, hr );
check( 1, callbackData.dwCounter1 );
checkStr( "1", callbackData.szTrace1 );
checkStr( "ALL:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroups( pDP[0], (LPGUID) &appGuid, EnumGroups_cb,
&callbackData, 0 );
checkHR( DP_OK, hr );
check( 2, callbackData.dwCounter1 ); /* Guid is ignored */
checkStr( "02", callbackData.szTrace1 );
checkStr( "ALL:HIDDEN:", callbackData.szTrace2 );
/* Enumerating from a remote session */
/* - Session not open */
callbackData.pDP = pDP[2];
hr = IDirectPlayX_EnumSessions( pDP[2], &dpsd[2], 0,
EnumSessions_cb_EnumGroups,
&callbackData, 0 );
checkHR( DP_OK, hr );
/* - Open session */
callbackData.pDP = pDP[2];
hr = IDirectPlayX_EnumSessions( pDP[2], &dpsd[0], 0, EnumSessions_cb_join,
pDP[2], 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP[2], &dpid[3],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP[2], &dpid[4],
NULL, NULL, 0, DPGROUP_STAGINGAREA );
checkHR( DP_OK, hr );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb,
&callbackData, 0 );
checkHR( DP_OK, hr );
check( 4, callbackData.dwCounter1 );
checkStr( "0234", callbackData.szTrace1 );
checkStr( "ALL:HIDDEN:ALL:STAGINGAREA:", callbackData.szTrace2 );
/* Flag tests */
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb,
&callbackData, DPENUMGROUPS_ALL );
checkHR( DP_OK, hr );
check( 4, callbackData.dwCounter1 );
checkStr( "0234", callbackData.szTrace1 );
checkStr( "ALL:HIDDEN:ALL:STAGINGAREA:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb,
&callbackData, DPENUMGROUPS_HIDDEN );
checkHR( DP_OK, hr );
check( 1, callbackData.dwCounter1 );
checkStr( "2", callbackData.szTrace1 );
checkStr( "HIDDEN:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb,
&callbackData, DPENUMGROUPS_LOCAL );
checkHR( DP_OK, hr );
check( 2, callbackData.dwCounter1 );
checkStr( "34", callbackData.szTrace1 );
checkStr( "LOCAL:"
"LOCAL,DPENUMGROUPS_STAGINGAREA:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb,
&callbackData, DPENUMGROUPS_REMOTE );
checkHR( DP_OK, hr );
check( 2, callbackData.dwCounter1 );
checkStr( "02", callbackData.szTrace1 );
checkStr( "REMOTE:"
"REMOTE,DPENUMGROUPS_HIDDEN:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb,
&callbackData, DPENUMGROUPS_STAGINGAREA );
checkHR( DP_OK, hr );
check( 1, callbackData.dwCounter1 );
checkStr( "4", callbackData.szTrace1 );
checkStr( "STAGINGAREA:", callbackData.szTrace2 );
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
IDirectPlayX_Release( pDP[2] );
}
static void test_EnumGroupsInGroup(void)
{
IDirectPlay4 *pDP[2];
DPSESSIONDESC2 dpsd[2];
DPID dpid[6];
CallbackData callbackData;
HRESULT hr;
UINT i;
for (i=0; i<2; i++)
{
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
ZeroMemory( &dpsd[i], sizeof(DPSESSIONDESC2) );
dpsd[i].dwSize = sizeof(DPSESSIONDESC2);
}
dpsd[0].guidApplication = appGuid;
dpsd[1].guidApplication = GUID_NULL;
callbackData.dpid = dpid;
callbackData.dpidSize = 6;
/* Uninitialized service provider */
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], 0, NULL, EnumGroups_cb,
&callbackData, 0 );
checkHR( DPERR_UNINITIALIZED, hr );
check( 0, callbackData.dwCounter1 );
init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
hr = IDirectPlayX_Open( pDP[0], &dpsd[0], DPOPEN_CREATE );
todo_wine checkHR( DP_OK, hr );
if ( hr == DPERR_UNINITIALIZED )
{
todo_wine win_skip( "EnumGroupsInGroup not implemented\n" );
return;
}
/* Create groups */
/*
* 0
* / 2
* 1 | 3
* | 4
* \ 5 (shortcut)
*/
hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[0],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[1],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP[0], dpid[1], &dpid[2],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP[0], dpid[1], &dpid[3],
NULL, NULL, 0,
DPGROUP_HIDDEN );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP[0], dpid[1], &dpid[4],
NULL, NULL, 0,
DPGROUP_STAGINGAREA );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[5],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_AddGroupToGroup( pDP[0], dpid[1], dpid[5] );
checkHR( DP_OK, hr );
/* Invalid parameters */
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], 0, NULL, EnumGroups_cb,
&callbackData, 0 );
checkHR( DPERR_INVALIDGROUP, hr );
check( 0, callbackData.dwCounter1 );
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], 10, NULL, EnumGroups_cb,
&callbackData, 0 );
checkHR( DPERR_INVALIDGROUP, hr );
check( 0, callbackData.dwCounter1 );
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], (LPGUID) &appGuid,
NULL, &callbackData, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
check( 0, callbackData.dwCounter1 );
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
&callbackData, DPENUMGROUPS_SESSION );
checkHR( DPERR_INVALIDPARAMS, hr );
check( 0, callbackData.dwCounter1 );
/* Regular operation */
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[0], NULL, EnumGroups_cb,
&callbackData, 0 );
checkHR( DP_OK, hr );
check( 0, callbackData.dwCounter1 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
&callbackData, 0 );
checkHR( DP_OK, hr );
check( 4, callbackData.dwCounter1 );
checkStr( "5432", callbackData.szTrace1 );
checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], (LPGUID) &appGuid,
EnumGroups_cb, &callbackData, 0 );
checkHR( DP_OK, hr );
check( 4, callbackData.dwCounter1 ); /* Guid is ignored */
checkStr( "5432", callbackData.szTrace1 );
checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData.szTrace2 );
/* Enumerating from a remote session */
/* - Session not open */
callbackData.pDP = pDP[1];
hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd[1], 0,
EnumSessions_cb_EnumGroups,
&callbackData, 0 );
checkHR( DP_OK, hr );
/* - Open session */
hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd[0], 0, EnumSessions_cb_join,
pDP[1], 0 );
checkHR( DP_OK, hr );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[1], dpid[1], NULL, EnumGroups_cb,
&callbackData, 0 );
checkHR( DP_OK, hr );
check( 4, callbackData.dwCounter1 );
checkStr( "5432", callbackData.szTrace1 );
checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData.szTrace2 );
/* Flag tests */
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
&callbackData, DPENUMGROUPS_ALL );
checkHR( DP_OK, hr );
check( 4, callbackData.dwCounter1 );
checkStr( "5432", callbackData.szTrace1 );
checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
&callbackData, DPENUMGROUPS_HIDDEN );
checkHR( DP_OK, hr );
check( 1, callbackData.dwCounter1 );
checkStr( "3", callbackData.szTrace1 );
checkStr( "HIDDEN:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
&callbackData, DPENUMGROUPS_LOCAL );
checkHR( DP_OK, hr );
check( 4, callbackData.dwCounter1 );
checkStr( "5432", callbackData.szTrace1 );
checkStr( "LOCAL,DPENUMGROUPS_SHORTCUT:"
"LOCAL,DPENUMGROUPS_STAGINGAREA:"
"LOCAL,DPENUMGROUPS_HIDDEN:LOCAL:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
&callbackData, DPENUMGROUPS_REMOTE );
checkHR( DP_OK, hr );
check( 0, callbackData.dwCounter1 );
callbackData.dwCounter1 = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[1], dpid[1], NULL, EnumGroups_cb,
&callbackData, DPENUMGROUPS_LOCAL );
checkHR( DP_OK, hr );
check( 0, callbackData.dwCounter1 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[1], dpid[1], NULL, EnumGroups_cb,
&callbackData, DPENUMGROUPS_REMOTE );
checkHR( DP_OK, hr );
check( 4, callbackData.dwCounter1 );
checkStr( "5432", callbackData.szTrace1 );
checkStr( "REMOTE,DPENUMGROUPS_SHORTCUT:"
"REMOTE,DPENUMGROUPS_STAGINGAREA:"
"REMOTE,DPENUMGROUPS_HIDDEN:REMOTE:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
&callbackData, DPENUMGROUPS_SHORTCUT );
checkHR( DP_OK, hr );
check( 1, callbackData.dwCounter1 );
checkStr( "5", callbackData.szTrace1 );
checkStr( "SHORTCUT:", callbackData.szTrace2 );
callbackData.dwCounter1 = 0;
callbackData.szTrace2[0] = 0;
hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
&callbackData,
DPENUMGROUPS_STAGINGAREA );
checkHR( DP_OK, hr );
check( 1, callbackData.dwCounter1 );
checkStr( "4", callbackData.szTrace1 );
checkStr( "STAGINGAREA:", callbackData.szTrace2 );
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
}
static void test_groups_p2p(void)
{
IDirectPlay4 *pDP[2];
DPSESSIONDESC2 dpsd;
DPID idPlayer[6], idGroup[3];
HRESULT hr;
UINT i;
DWORD dwDataSize = 1024;
LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 1024 );
CallbackData callbackData;
for (i=0; i<2; i++)
{
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
}
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.dwMaxPlayers = 10;
init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
todo_wine checkHR( DP_OK, hr );
hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
pDP[1], 0 );
todo_wine checkHR( DP_OK, hr );
if ( hr == DPERR_UNINITIALIZED )
{
todo_wine win_skip( "dplay not implemented enough for this test yet\n" );
return;
}
/* Create players */
hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[0],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[1],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[2],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[3],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[4],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[5],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP[0], &idGroup[0],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP[1], &idGroup[2],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP[1], idGroup[2], &idGroup[1],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
/* Purge queues */
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "S0," "S1,S0,"
"S2,S1,S0," "S2,S1,S0,"
"S2,S1,S0," "S2,S1,S0,"
"S2,S1,S0," "S2,S1,S0,", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "S3," "S4,S3,"
"S5,S4,S3," "S5,S4,S3,"
"S5,S4,S3,", callbackData.szTrace1 );
/*
* Player 0 | |
* Player 1 | Group 0 | pDP 0
* Player 2 | |
* Player 3 | Group 1 ) |
* Player 4 | | Group 2 | pDP 1
* Player 5 | |
*/
/* Build groups */
hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[0] );
checkHR( DP_OK, hr );
hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[1] );
checkHR( DP_OK, hr );
hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[2] );
checkHR( DP_OK, hr );
hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[1], idPlayer[3] );
checkHR( DP_OK, hr );
hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[1], idPlayer[4] );
checkHR( DP_OK, hr );
hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[2], idPlayer[4] );
checkHR( DP_OK, hr );
hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[2], idPlayer[5] );
checkHR( DP_OK, hr );
hr = IDirectPlayX_AddGroupToGroup( pDP[1], idGroup[2], idGroup[1] );
checkHR( DP_OK, hr );
/* Purge queues */
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "S2,S1,S0," "S2,S1,S0," "S2,S1,S0,"
"S2,S1,S0," "S2,S1,S0," "S2,S1,S0,"
"S2,S1,S0,", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "S5,S4,S3," "S5,S4,S3," "S5,S4,S3,"
"S5,S4,S3," "S5,S4,S3," "S5,S4,S3,"
"S5,S4,S3,", callbackData.szTrace1 );
/* Sending broadcast messages, and checking who receives them */
dwDataSize = 4;
/* 0 -> * */
hr = IDirectPlayX_Send( pDP[0], idPlayer[0], DPID_ALLPLAYERS, 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "02,01,", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "05,04,03,", callbackData.szTrace1 );
/* 0 -> g0 */
hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[0], 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "02,01,", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
/* 0 -> g1 */
hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[1], 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "04,03,", callbackData.szTrace1 );
/* 0 -> g2 */
hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[2], 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "05,04,", callbackData.szTrace1 );
/* 3 -> * */
hr = IDirectPlayX_Send( pDP[1], idPlayer[3], DPID_ALLPLAYERS, 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "32,31,30,", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "35,34,", callbackData.szTrace1 );
/* 3 -> g0 */
hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[0], 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "32,31,30,", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
/* 3 -> g1 */
hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[1], 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "34,", callbackData.szTrace1 );
/* 3 -> g2 */
hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[2], 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "35,34,", callbackData.szTrace1 );
/* 5 -> * */
hr = IDirectPlayX_Send( pDP[1], idPlayer[5], DPID_ALLPLAYERS, 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "52,51,50,", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "54,53,", callbackData.szTrace1 );
/* 5 -> g0 */
hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[0], 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "52,51,50,", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
/* 5 -> g1 */
hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[1], 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "54,53,", callbackData.szTrace1 );
/* 5 -> g2 */
hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[2], 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "54,", callbackData.szTrace1 );
HeapFree( GetProcessHeap(), 0, lpData );
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
}
static void test_groups_cs(void)
{
IDirectPlay4 *pDP[2];
DPSESSIONDESC2 dpsd;
DPID idPlayer[6], idGroup[3];
CallbackData callbackData;
HRESULT hr;
UINT i;
DWORD dwDataSize = 1024;
LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 1024 );
for (i=0; i<2; i++)
{
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
}
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.dwMaxPlayers = 10;
init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
dpsd.dwFlags = DPSESSION_CLIENTSERVER;
hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
todo_wine checkHR( DP_OK, hr );
dpsd.dwFlags = 0;
hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
pDP[1], 0 );
todo_wine checkHR( DP_OK, hr );
if ( hr == DPERR_UNINITIALIZED )
{
todo_wine win_skip( "dplay not implemented enough for this test yet\n" );
return;
}
/* Create players */
hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[0],
NULL, NULL, NULL, 0, 0 );
checkHR( DPERR_ACCESSDENIED, hr );
hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[0],
NULL, NULL, NULL, 0,
DPPLAYER_SERVERPLAYER );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[1],
NULL, NULL, NULL, 0, 0 );
checkHR( DPERR_ACCESSDENIED, hr );
hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[1],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[2],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[3],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[4],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[5],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP[0], &idGroup[0],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroup( pDP[1], &idGroup[2],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreateGroupInGroup( pDP[1], idGroup[2], &idGroup[1],
NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
/* Purge queues */
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "S0,S0,S0,S0,S0,S0,", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "S1," "S2,S1," "S3,S2,S1," "S4,S3,S2,S1,"
"S5,S4,S3,S2,S1," "S5,S4,S3,S2,S1,", callbackData.szTrace1 );
/*
* Player 0 | | pDP 0
* Player 1 | Group 0 |
* Player 2 | |
* Player 3 | Group 1 ) |
* Player 4 | | Group 2 | pDP 1
* Player 5 | |
*/
/* Build groups */
hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[0] );
checkHR( DP_OK, hr );
hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[1] );
checkHR( DP_OK, hr );
hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[2] );
checkHR( DP_OK, hr );
hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[1], idPlayer[3] );
checkHR( DP_OK, hr );
hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[1], idPlayer[4] );
checkHR( DP_OK, hr );
hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[2], idPlayer[4] );
checkHR( DP_OK, hr );
hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[2], idPlayer[5] );
checkHR( DP_OK, hr );
hr = IDirectPlayX_AddGroupToGroup( pDP[1], idGroup[2], idGroup[1] );
checkHR( DP_OK, hr );
/* Purge queues */
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "S0,S0,S0,S0,", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "S5," "S4,S3,S2,S1," "S5,S4,S3,S2,S1,"
"S5,S4,S3,S2,S1," "S5,S4,S3,S2,S1,", callbackData.szTrace1 );
/* Sending broadcast messages, and checking who receives them */
dwDataSize = 4;
/* 0 -> * */
hr = IDirectPlayX_Send( pDP[0], idPlayer[0], DPID_ALLPLAYERS, 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "05,04,03,02,01,", callbackData.szTrace1 );
/* 0 -> g0 */
hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[0], 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "02,01,", callbackData.szTrace1 );
/* 0 -> g1 */
hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[1], 0,
lpData, dwDataSize );
checkHR( DPERR_INVALIDPARAMS, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
/* 0 -> g2 */
hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[2], 0,
lpData, dwDataSize );
checkHR( DPERR_INVALIDPARAMS, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
/* 3 -> * */
hr = IDirectPlayX_Send( pDP[1], idPlayer[3], DPID_ALLPLAYERS, 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "30,", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "35,34,32,31,", callbackData.szTrace1 );
/* 3 -> g0 */
hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[0], 0,
lpData, dwDataSize );
checkHR( DPERR_INVALIDPARAMS, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
/* 3 -> g1 */
hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[1], 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "34,", callbackData.szTrace1 );
/* 3 -> g2 */
hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[2], 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "35,34,", callbackData.szTrace1 );
/* 5 -> * */
hr = IDirectPlayX_Send( pDP[1], idPlayer[5], DPID_ALLPLAYERS, 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "50,", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "54,53,52,51,", callbackData.szTrace1 );
/* 5 -> g0 */
hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[0], 0,
lpData, dwDataSize );
checkHR( DPERR_INVALIDPARAMS, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
/* 5 -> g1 */
hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[1], 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "54,53,", callbackData.szTrace1 );
/* 5 -> g2 */
hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[2], 0,
lpData, dwDataSize );
checkHR( DP_OK, hr );
check_messages( pDP[0], idPlayer, 6, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], idPlayer, 6, &callbackData );
checkStr( "54,", callbackData.szTrace1 );
HeapFree( GetProcessHeap(), 0, lpData );
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
}
/* Send */
static void test_Send(void)
{
IDirectPlay4 *pDP[2];
DPSESSIONDESC2 dpsd;
DPID dpid[4], idFrom, idTo;
CallbackData callbackData;
HRESULT hr;
LPCSTR message = "message";
DWORD messageSize = strlen(message) + 1;
DWORD dwDataSize = 1024;
LPDPMSG_GENERIC lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
LPDPMSG_SECUREMESSAGE lpDataSecure;
UINT i;
for (i=0; i<2; i++)
{
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
}
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
/* Uninitialized service provider */
hr = IDirectPlayX_Send( pDP[0], 0, 0, 0,
(LPVOID) message, messageSize );
checkHR( DPERR_UNINITIALIZED, hr );
init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.dwMaxPlayers = 10;
IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
pDP[1], 0 );
IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
/* Incorrect players */
hr = IDirectPlayX_Send( pDP[0], 0, 1, 2,
(LPVOID) message, messageSize );
todo_wine checkHR( DPERR_INVALIDPLAYER, hr );
if ( hr == DPERR_UNINITIALIZED )
{
todo_wine win_skip( "Send not implemented\n" );
return;
}
IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 );
IDirectPlayX_CreatePlayer( pDP[0], &dpid[1], NULL, NULL, NULL, 0, 0 );
IDirectPlayX_CreatePlayer( pDP[0], &dpid[2], NULL, NULL, NULL, 0, 0 );
IDirectPlayX_CreatePlayer( pDP[1], &dpid[3], NULL, NULL, NULL, 0, 0 );
/* Purge player creation messages */
check_messages( pDP[0], dpid, 4, &callbackData );
checkStr( "S0," "S1,S0," "S2,S1,S0,", callbackData.szTrace1 );
check_messages( pDP[1], dpid, 4, &callbackData );
checkStr( "", callbackData.szTrace1 );
/* Message to self: no error, but no message is sent */
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[0], 0,
(LPVOID) message, messageSize );
checkHR( DP_OK, hr );
/* Send a message from a remote player */
hr = IDirectPlayX_Send( pDP[1], dpid[0], dpid[1], 0,
(LPVOID) message, messageSize );
checkHR( DPERR_ACCESSDENIED, hr );
hr = IDirectPlayX_Send( pDP[1], dpid[0], dpid[3], 0,
(LPVOID) message, messageSize );
checkHR( DPERR_ACCESSDENIED, hr );
/* Null message */
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 0,
NULL, messageSize );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 0,
(LPVOID) message, 0 );
checkHR( DPERR_INVALIDPARAMS, hr );
/* Checking no message was sent */
check_messages( pDP[0], dpid, 4, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], dpid, 4, &callbackData );
checkStr( "", callbackData.szTrace1 );
/* Regular parameters */
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
0,
(LPVOID) message, messageSize );
checkHR( DP_OK, hr );
hr = IDirectPlayX_Receive( pDP[0], &dpid[0], &dpid[1],
DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER,
lpData, &dwDataSize );
checkHR( DP_OK, hr );
checkStr( message, (LPSTR) lpData );
check( strlen(message)+1, dwDataSize );
check_messages( pDP[0], dpid, 4, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], dpid, 4, &callbackData );
checkStr( "", callbackData.szTrace1 );
/* Message to a remote player */
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[3], 0,
(LPVOID) message, messageSize );
checkHR( DP_OK, hr );
hr = IDirectPlayX_Receive( pDP[0], &dpid[0], &dpid[3],
DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER,
lpData, &dwDataSize );
checkHR( DPERR_NOMESSAGES, hr );
hr = IDirectPlayX_Receive( pDP[1], &dpid[0], &dpid[3],
DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER,
lpData, &dwDataSize );
checkHR( DP_OK, hr );
checkStr( message, (LPSTR) lpData );
check( strlen(message)+1, dwDataSize );
check_messages( pDP[0], dpid, 4, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], dpid, 4, &callbackData );
checkStr( "", callbackData.szTrace1 );
/* Broadcast */
hr = IDirectPlayX_Send( pDP[0], dpid[0], DPID_ALLPLAYERS, 0,
(LPVOID) message, messageSize );
checkHR( DP_OK, hr );
for (i=1; i<3; i++)
{
hr = IDirectPlayX_Receive( pDP[0], &dpid[0], &dpid[i],
DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER,
lpData, &dwDataSize );
checkHR( DP_OK, hr );
checkStr( message, (LPSTR) lpData );
}
hr = IDirectPlayX_Receive( pDP[1], &dpid[0], &dpid[3],
DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER,
lpData, &dwDataSize );
checkHR( DP_OK, hr );
checkStr( message, (LPSTR) lpData );
check_messages( pDP[0], dpid, 4, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], dpid, 4, &callbackData );
checkStr( "", callbackData.szTrace1 );
hr = IDirectPlayX_Send( pDP[0], DPID_ALLPLAYERS, dpid[1],
0,
(LPVOID) message, messageSize );
checkHR( DPERR_INVALIDPLAYER, hr );
hr = IDirectPlayX_Send( pDP[0], DPID_ALLPLAYERS, DPID_ALLPLAYERS,
0,
(LPVOID) message, messageSize );
checkHR( DPERR_INVALIDPLAYER, hr );
/* Flags */
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
DPSEND_GUARANTEED,
(LPVOID) message, messageSize );
checkHR( DP_OK, hr );
hr = IDirectPlayX_Receive( pDP[0], &dpid[0], &dpid[1],
DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER,
lpData, &dwDataSize );
checkHR( DP_OK, hr );
checkStr( message, (LPSTR)lpData );
/* - Inorrect flags */
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
DPSEND_ENCRYPTED,
(LPVOID) message, messageSize );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
DPSEND_SIGNED,
(LPVOID) message, messageSize );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
DPSEND_ENCRYPTED | DPSEND_SIGNED,
(LPVOID) message, messageSize );
checkHR( DPERR_INVALIDPARAMS, hr );
/* - Correct flags, but session is not secure */
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
DPSEND_ENCRYPTED | DPSEND_GUARANTEED,
(LPVOID) message, messageSize );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
DPSEND_SIGNED | DPSEND_GUARANTEED,
(LPVOID) message, messageSize );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
( DPSEND_ENCRYPTED |
DPSEND_SIGNED |
DPSEND_GUARANTEED ),
(LPVOID) message, messageSize );
checkHR( DPERR_INVALIDPARAMS, hr );
/* - Correct flags, secure session incorrectly opened (without flags) */
hr = IDirectPlayX_Close( pDP[0] );
checkHR( DP_OK, hr );
dpsd.dwFlags = 0;
hr = IDirectPlayX_SecureOpen( pDP[0], &dpsd, DPOPEN_CREATE, NULL, NULL );
checkHR( DP_OK, hr );
for (i=0; i<2; i++)
IDirectPlayX_CreatePlayer( pDP[0], &dpid[i], NULL, NULL, NULL, 0, 0 );
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
DPSEND_ENCRYPTED | DPSEND_GUARANTEED,
(LPVOID) message, messageSize );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
DPSEND_SIGNED | DPSEND_GUARANTEED,
(LPVOID) message, messageSize );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
( DPSEND_ENCRYPTED |
DPSEND_SIGNED |
DPSEND_GUARANTEED ),
(LPVOID) message, messageSize );
checkHR( DPERR_INVALIDPARAMS, hr );
/* - Correct flags, secure session */
hr = IDirectPlayX_Close( pDP[0] );
checkHR( DP_OK, hr );
dpsd.dwFlags = DPSESSION_SECURESERVER;
hr = IDirectPlayX_SecureOpen( pDP[0], &dpsd, DPOPEN_CREATE, NULL, NULL );
checkHR( DP_OK, hr );
IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 );
IDirectPlayX_CreatePlayer( pDP[0], &dpid[1], NULL, NULL, NULL, 0, 0 );
/* Purge */
check_messages( pDP[0], dpid, 6, &callbackData );
checkStr( "S0,", callbackData.szTrace1 );
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
DPSEND_ENCRYPTED | DPSEND_GUARANTEED,
(LPVOID) message, messageSize );
checkHR( DP_OK, hr );
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
DPSEND_SIGNED | DPSEND_GUARANTEED,
(LPVOID) message, messageSize );
checkHR( DP_OK, hr );
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
( DPSEND_ENCRYPTED |
DPSEND_SIGNED |
DPSEND_GUARANTEED ),
(LPVOID) message, messageSize );
checkHR( DP_OK, hr );
for (i=0; i<3; i++)
{
dwDataSize = 1024;
hr = IDirectPlayX_Receive( pDP[0], &idFrom, &idTo, 0, lpData,
&dwDataSize );
lpDataSecure = (LPDPMSG_SECUREMESSAGE) lpData;
checkHR( DP_OK, hr );
checkConv( DPSYS_SECUREMESSAGE, lpData->dwType, dpMsgType2str );
check( DPID_SYSMSG, idFrom );
check( dpid[1], idTo );
check( dpid[0], lpDataSecure->dpIdFrom );
checkStr( message, (LPSTR) lpDataSecure->lpData );
check( strlen(message)+1, lpDataSecure->dwDataSize );
switch(i)
{
case 0:
checkFlags( DPSEND_ENCRYPTED,
lpDataSecure->dwFlags,
FLAGS_DPSEND );
break;
case 1:
checkFlags( DPSEND_SIGNED,
lpDataSecure->dwFlags,
FLAGS_DPSEND );
break;
case 2:
checkFlags( DPSEND_SIGNED | DPSEND_ENCRYPTED,
lpDataSecure->dwFlags,
FLAGS_DPSEND );
break;
default: break;
}
}
check_messages( pDP[0], dpid, 4, &callbackData );
checkStr( "", callbackData.szTrace1 );
/* - Even in a secure session, incorrect flags still not working */
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
DPSEND_ENCRYPTED,
(LPVOID) message, messageSize );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
DPSEND_SIGNED,
(LPVOID) message, messageSize );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
DPSEND_ENCRYPTED | DPSEND_SIGNED,
(LPVOID) message, messageSize );
checkHR( DPERR_INVALIDPARAMS, hr );
HeapFree( GetProcessHeap(), 0, lpData );
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
}
/* Receive */
static void test_Receive(void)
{
IDirectPlay4 *pDP;
DPSESSIONDESC2 dpsd;
DPID dpid[4], idFrom, idTo;
HRESULT hr;
LPCSTR message = "message";
DWORD messageSize = strlen(message) + 1;
DWORD dwDataSize = 1024;
LPDPMSG_GENERIC lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
dwDataSize );
LPDPMSG_CREATEPLAYERORGROUP lpDataCreate;
LPDPMSG_DESTROYPLAYERORGROUP lpDataDestroy;
DWORD dwCount;
UINT i;
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
init_TCPIP_provider( pDP, "127.0.0.1", 0 );
IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE );
/* Invalid parameters */
hr = IDirectPlayX_Receive( pDP, NULL, &idTo, 0,
lpData, &dwDataSize );
todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
if ( hr == DPERR_UNINITIALIZED )
{
todo_wine win_skip( "Receive not implemented\n" );
return;
}
hr = IDirectPlayX_Receive( pDP, &idFrom, NULL, 0,
lpData, &dwDataSize );
checkHR( DPERR_INVALIDPARAMS, hr );
hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0,
lpData, NULL );
checkHR( DPERR_INVALIDPARAMS, hr );
dwDataSize = -1;
hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0,
lpData, &dwDataSize );
checkHR( DPERR_INVALIDPARAMS, hr );
/* No messages yet */
hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0,
NULL, &dwDataSize );
checkHR( DPERR_NOMESSAGES, hr );
dwDataSize = 0;
hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0,
lpData, &dwDataSize );
checkHR( DPERR_NOMESSAGES, hr );
IDirectPlayX_CreatePlayer( pDP, &dpid[0], NULL, 0, NULL, 0, 0 );
IDirectPlayX_CreatePlayer( pDP, &dpid[1], NULL, 0, NULL, 0,
DPPLAYER_SPECTATOR );
IDirectPlayX_CreatePlayer( pDP, &dpid[2], NULL, 0, NULL, 0, 0 );
IDirectPlayX_CreatePlayer( pDP, &dpid[3], NULL, 0, NULL, 0, 0 );
/* 0, 1, 2, 3 */
/* 3, 2, 1, 0 */
for (i=0; i<4; i++)
{
IDirectPlayX_GetMessageCount( pDP, dpid[i], &dwCount );
check( 3-i, dwCount );
}
IDirectPlayX_DestroyPlayer( pDP, dpid[3] );
IDirectPlayX_DestroyPlayer( pDP, dpid[1] );
/* 0, 1, 2, 3 */
/* 5, 5, 3, 3 */
IDirectPlayX_GetMessageCount( pDP, dpid[0], &dwCount );
check( 5, dwCount );
IDirectPlayX_GetMessageCount( pDP, dpid[1], &dwCount );
check( 5, dwCount );
IDirectPlayX_GetMessageCount( pDP, dpid[2], &dwCount );
check( 3, dwCount );
IDirectPlayX_GetMessageCount( pDP, dpid[3], &dwCount );
check( 3, dwCount );
/* Buffer too small */
hr = IDirectPlayX_Receive( pDP, &idFrom, &idFrom, 0,
NULL, &dwDataSize );
checkHR( DPERR_BUFFERTOOSMALL, hr );
check( 48, dwDataSize );
dwDataSize = 0;
hr = IDirectPlayX_Receive( pDP, &idTo, &idFrom, 0,
lpData, &dwDataSize );
checkHR( DPERR_BUFFERTOOSMALL, hr );
check( 48, dwDataSize );
/* Checking the order or reception */
for (i=0; i<11; i++)
{
dwDataSize = 1024;
hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0,
lpData, &dwDataSize );
checkHR( DP_OK, hr );
check( DPID_SYSMSG, idFrom );
if (i<6) /* Player creation */
{
checkConv( DPSYS_CREATEPLAYERORGROUP, lpData->dwType, dpMsgType2str );
check( 48, dwDataSize );
lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData;
check( DPPLAYERTYPE_PLAYER, lpDataCreate->dwPlayerType );
checkLP( NULL, lpDataCreate->lpData );
check( 0, lpDataCreate->dwDataSize );
checkLP( NULL, U1(lpDataCreate->dpnName).lpszShortNameA );
check( 0, lpDataCreate->dpIdParent );
}
else /* Player destruction */
{
checkConv( DPSYS_DESTROYPLAYERORGROUP, lpData->dwType,
dpMsgType2str );
check( 52, dwDataSize );
lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData;
check( DPPLAYERTYPE_PLAYER, lpDataDestroy->dwPlayerType );
checkLP( NULL, lpDataDestroy->lpLocalData );
check( 0, lpDataDestroy->dwLocalDataSize );
checkLP( NULL, lpDataDestroy->lpRemoteData );
check( 0, lpDataDestroy->dwRemoteDataSize );
checkLP( NULL, U1(lpDataDestroy->dpnName).lpszShortNameA );
check( 0, lpDataDestroy->dpIdParent );
}
switch(i)
{
/* 1 -> 0 */
case 0:
lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData;
check( dpid[0], idTo );
check( dpid[1], lpDataCreate->dpId );
check( 1, lpDataCreate->dwCurrentPlayers );
checkFlags( DPPLAYER_LOCAL|DPPLAYER_SPECTATOR, lpDataCreate->dwFlags,
FLAGS_DPPLAYER|FLAGS_DPGROUP );
break;
/* 2 -> 1,0 */
case 1:
check( dpid[1], idTo );
lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData;
check( dpid[2], lpDataCreate->dpId );
check( 2, lpDataCreate->dwCurrentPlayers );
checkFlags( DPPLAYER_LOCAL, lpDataCreate->dwFlags,
FLAGS_DPPLAYER | FLAGS_DPGROUP );
break;
case 2:
check( dpid[0], idTo );
lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData;
check( dpid[2], lpDataCreate->dpId );
check( 2, lpDataCreate->dwCurrentPlayers );
checkFlags( DPPLAYER_LOCAL, lpDataCreate->dwFlags,
FLAGS_DPPLAYER | FLAGS_DPGROUP );
break;
/* 3 -> 2,1,0 */
case 3:
check( dpid[2], idTo );
lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData;
check( dpid[3], lpDataCreate->dpId );
check( 3, lpDataCreate->dwCurrentPlayers );
checkFlags( DPPLAYER_LOCAL, lpDataCreate->dwFlags,
FLAGS_DPPLAYER | FLAGS_DPGROUP );
break;
case 4:
check( dpid[1], idTo );
lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData;
check( dpid[3], lpDataCreate->dpId );
check( 3, lpDataCreate->dwCurrentPlayers );
checkFlags( DPPLAYER_LOCAL, lpDataCreate->dwFlags,
FLAGS_DPPLAYER | FLAGS_DPGROUP );
break;
case 5:
check( dpid[0], idTo );
lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData;
check( dpid[3], lpDataCreate->dpId );
check( 3, lpDataCreate->dwCurrentPlayers );
checkFlags( DPPLAYER_LOCAL, lpDataCreate->dwFlags,
FLAGS_DPPLAYER | FLAGS_DPGROUP );
break;
/* 3 -> 2,1,0 */
case 6:
check( dpid[2], idTo );
lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData;
check( dpid[3], lpDataDestroy->dpId );
checkFlags( DPPLAYER_LOCAL, lpDataDestroy->dwFlags,
FLAGS_DPPLAYER | FLAGS_DPGROUP );
break;
case 7:
check( dpid[1], idTo );
lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData;
check( dpid[3], lpDataDestroy->dpId );
checkFlags( DPPLAYER_LOCAL, lpDataDestroy->dwFlags,
FLAGS_DPPLAYER | FLAGS_DPGROUP );
break;
case 8:
check( dpid[0], idTo );
lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData;
check( dpid[3], lpDataDestroy->dpId );
checkFlags( DPPLAYER_LOCAL, lpDataDestroy->dwFlags,
FLAGS_DPPLAYER | FLAGS_DPGROUP );
break;
/* 1 -> 2,0 */
case 9:
check( dpid[2], idTo );
lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData;
check( dpid[1], lpDataDestroy->dpId );
checkFlags( DPPLAYER_LOCAL |
DPPLAYER_SPECTATOR, lpDataDestroy->dwFlags,
FLAGS_DPPLAYER | FLAGS_DPGROUP );
break;
case 10:
check( dpid[0], idTo );
lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData;
check( dpid[1], lpDataDestroy->dpId );
checkFlags( DPPLAYER_LOCAL |
DPPLAYER_SPECTATOR, lpDataDestroy->dwFlags,
FLAGS_DPPLAYER | FLAGS_DPGROUP );
break;
default:
trace( "%s\n", dpMsgType2str(lpData->dwType) );
break;
}
}
hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpData, &dwDataSize );
checkHR( DPERR_NOMESSAGES, hr );
/* New data message */
hr = IDirectPlayX_Send( pDP, dpid[0], dpid[2], 0,
(LPVOID) message, messageSize );
checkHR( DP_OK, hr );
/* Ensuring DPRECEIVE_PEEK doesn't remove the messages from the queue */
for (i=0; i<10; i++)
{
hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, DPRECEIVE_PEEK,
lpData, &dwDataSize );
checkHR( DP_OK, hr );
checkStr( message, (LPSTR) lpData );
}
/* Removing the message from the queue */
hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpData, &dwDataSize );
checkHR( DP_OK, hr );
check( idFrom, dpid[0] );
check( idTo, dpid[2] );
checkStr( message, (LPSTR) lpData );
hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpData, &dwDataSize );
checkHR( DPERR_NOMESSAGES, hr );
HeapFree( GetProcessHeap(), 0, lpData );
IDirectPlayX_Release( pDP );
}
/* GetMessageCount */
static void test_GetMessageCount(void)
{
IDirectPlay4 *pDP[2];
DPSESSIONDESC2 dpsd;
DPID dpid[4];
HRESULT hr;
UINT i;
DWORD dwCount;
DWORD dwDataSize = 1024;
LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
CallbackData callbackData;
for (i=0; i<2; i++)
{
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
}
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount );
todo_wine checkHR( DPERR_UNINITIALIZED, hr );
check( -1, dwCount );
if ( hr == DP_OK )
{
todo_wine win_skip( "GetMessageCount not implemented\n" );
return;
}
init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount );
checkHR( DP_OK, hr );
check( 0, dwCount );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.dwMaxPlayers = 10;
IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
pDP[1], 0 );
IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 );
IDirectPlayX_CreatePlayer( pDP[0], &dpid[1], NULL, NULL, NULL, 0, 0 );
IDirectPlayX_CreatePlayer( pDP[1], &dpid[3], NULL, NULL, NULL, 0, 0 );
IDirectPlayX_CreatePlayer( pDP[0], &dpid[2], NULL, NULL, NULL, 0, 0 );
/* Incorrect parameters */
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[0], NULL );
checkHR( DPERR_INVALIDPARAMS, hr );
check( -1, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], 0, NULL );
checkHR( DPERR_INVALIDPARAMS, hr );
check( -1, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], -1, &dwCount );
checkHR( DPERR_INVALIDPLAYER, hr );
check( -1, dwCount );
/* Correct parameters */
/* Player creation messages */
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount );
checkHR( DP_OK, hr );
check( 5, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[1], 0, &dwCount );
checkHR( DP_OK, hr );
check( 1, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[0], &dwCount );
checkHR( DP_OK, hr );
check( 3, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[1], &dwCount );
checkHR( DP_OK, hr );
check( 2, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[3], &dwCount );
checkHR( DP_OK, hr );
/* Remote player: doesn't throw error but result is 0 and not 1 */
check( 0, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[1], dpid[3], &dwCount );
checkHR( DP_OK, hr );
check( 1, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[1], &dwCount );
checkHR( DP_OK, hr );
check( 2, dwCount );
/* Purge queues */
check_messages( pDP[0], dpid, 6, &callbackData );
checkStr( "S0,S1,S0,S1,S0,", callbackData.szTrace1 );
check_messages( pDP[1], dpid, 6, &callbackData );
checkStr( "S3,", callbackData.szTrace1 );
/* Ensure queues is purged */
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount );
checkHR( DP_OK, hr );
check( 0, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[1], 0, &dwCount );
checkHR( DP_OK, hr );
check( 0, dwCount );
/* Send data messages */
for (i=0; i<5; i++)
IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 0, lpData, dwDataSize );
for (i=0; i<6; i++)
IDirectPlayX_Send( pDP[0], dpid[1], dpid[2], 0, lpData, dwDataSize );
for (i=0; i<7; i++)
IDirectPlayX_Send( pDP[0], dpid[2], dpid[3], 0, lpData, dwDataSize );
/* Check all messages are in the queues */
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount );
checkHR( DP_OK, hr );
check( 11, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[1], 0, &dwCount );
checkHR( DP_OK, hr );
check( 7, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[0], &dwCount );
checkHR( DP_OK, hr );
check( 0, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[1], &dwCount );
checkHR( DP_OK, hr );
check( 5, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[2], &dwCount );
checkHR( DP_OK, hr );
check( 6, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[1], dpid[3], &dwCount );
checkHR( DP_OK, hr );
check( 7, dwCount );
/* Purge queues again */
check_messages( pDP[0], dpid, 6, &callbackData );
checkStr( "01,01,01,01,01,"
"12,12,12,12,12,12,", callbackData.szTrace1 );
check_messages( pDP[1], dpid, 6, &callbackData );
checkStr( "23,23,23,23,23,23,23,", callbackData.szTrace1 );
/* Check queues are purged */
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount );
checkHR( DP_OK, hr );
check( 0, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[1], 0, &dwCount );
checkHR( DP_OK, hr );
check( 0, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[0], &dwCount );
checkHR( DP_OK, hr );
check( 0, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[1], &dwCount );
checkHR( DP_OK, hr );
check( 0, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[2], &dwCount );
checkHR( DP_OK, hr );
check( 0, dwCount );
dwCount = -1;
hr = IDirectPlayX_GetMessageCount( pDP[1], dpid[3], &dwCount );
checkHR( DP_OK, hr );
check( 0, dwCount );
HeapFree( GetProcessHeap(), 0, lpData );
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
}
/* GetMessageQueue */
static void test_GetMessageQueue(void)
{
IDirectPlay4 *pDP[2];
DPSESSIONDESC2 dpsd;
DPID dpid[4];
CallbackData callbackData;
HRESULT hr;
UINT i;
DWORD dwNumMsgs, dwNumBytes;
DWORD dwDataSize = 1024;
LPVOID lpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
for (i=0; i<2; i++)
{
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
}
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, 0, 0,
&dwNumMsgs, &dwNumBytes );
todo_wine checkHR( DPERR_UNINITIALIZED, hr );
check( -1, dwNumMsgs );
check( -1, dwNumBytes );
if ( hr == DP_OK )
{
todo_wine win_skip( "GetMessageQueue not implemented\n" );
return;
}
init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, 0, 0,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 0, dwNumMsgs );
check( 0, dwNumBytes );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.dwMaxPlayers = 10;
IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
pDP[1], 0 );
IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 );
IDirectPlayX_CreatePlayer( pDP[0], &dpid[1], NULL, NULL, NULL, 0, 0 );
IDirectPlayX_CreatePlayer( pDP[1], &dpid[3], NULL, NULL, NULL, 0, 0 );
IDirectPlayX_CreatePlayer( pDP[0], &dpid[2], NULL, NULL, NULL, 0, 0 );
/* Incorrect parameters */
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], -1, dpid[1],
0,
&dwNumMsgs, &dwNumBytes );
checkHR( DPERR_INVALIDPLAYER, hr );
check( -1, dwNumMsgs );
check( -1, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], -1,
0,
&dwNumMsgs, &dwNumBytes );
checkHR( DPERR_INVALIDPLAYER, hr );
check( -1, dwNumMsgs );
check( -1, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[0],
-1,
&dwNumMsgs, &dwNumBytes );
checkHR( DPERR_INVALIDFLAGS, hr );
check( -1, dwNumMsgs );
check( -1, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
( DPMESSAGEQUEUE_SEND |
DPMESSAGEQUEUE_RECEIVE ),
&dwNumMsgs, &dwNumBytes );
checkHR( DPERR_INVALIDFLAGS, hr );
check( -1, dwNumMsgs );
check( -1, dwNumBytes );
/* - Remote players */
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, dpid[3],
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, &dwNumBytes );
checkHR( DPERR_INVALIDPLAYER, hr ); /* Player 3 is remote */
check( -1, dwNumMsgs );
check( -1, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[3], 0,
DPMESSAGEQUEUE_SEND,
&dwNumMsgs, &dwNumBytes );
checkHR( DPERR_INVALIDPLAYER, hr ); /* Player 3 is remote */
check( -1, dwNumMsgs );
check( -1, dwNumBytes );
/* - Remote players, this time in the right place */
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, dpid[3],
DPMESSAGEQUEUE_SEND,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 0, dwNumMsgs );
check( 0, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[3], 0,
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 0, dwNumMsgs );
check( 0, dwNumBytes );
/* Correct parameters */
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, dpid[1],
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 2, dwNumMsgs );
check( 96, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], 0,
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 0, dwNumMsgs );
check( 0, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, 0,
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 5, dwNumMsgs );
check( 240, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
DPMESSAGEQUEUE_RECEIVE,
NULL, &dwNumBytes );
checkHR( DP_OK, hr );
check( -1, dwNumMsgs );
check( 0, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, NULL );
checkHR( DP_OK, hr );
check( 0, dwNumMsgs );
check( -1, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
DPMESSAGEQUEUE_RECEIVE,
NULL, NULL );
checkHR( DP_OK, hr );
check( -1, dwNumMsgs );
check( -1, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 0, dwNumMsgs );
check( 0, dwNumBytes );
/* Purge messages */
check_messages( pDP[0], dpid, 6, &callbackData );
checkStr( "S0,S1,S0,S1,S0,", callbackData.szTrace1 );
check_messages( pDP[1], dpid, 6, &callbackData );
checkStr( "S3,", callbackData.szTrace1 );
/* Check queues are empty */
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, 0,
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 0, dwNumMsgs );
check( 0, dwNumBytes );
/* Sending 4 data messages from 0 to 1 */
/* 3 from 0 to 3 */
/* 2 from 1 to 3 */
for (i=0; i<4; i++)
IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 0, lpData, dwDataSize );
for (i=0; i<3; i++)
IDirectPlayX_Send( pDP[0], dpid[0], dpid[3], 0, lpData, dwDataSize );
for (i=0; i<2; i++)
IDirectPlayX_Send( pDP[0], dpid[1], dpid[3], 0, lpData, dwDataSize );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 4, dwNumMsgs );
check( 4*dwDataSize, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[1], dpid[0], dpid[3],
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 3, dwNumMsgs );
check( 3*dwDataSize, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[1], dpid[1], dpid[3],
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 2, dwNumMsgs );
check( 2*dwDataSize, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], 0,
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 4, dwNumMsgs );
check( 4*dwDataSize, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[1], dpid[0], 0,
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 3, dwNumMsgs );
check( 3*dwDataSize, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[1], 0, dpid[3],
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 5, dwNumMsgs );
check( 5*dwDataSize, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, 0,
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 4, dwNumMsgs );
check( 4*dwDataSize, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[1], 0, 0,
DPMESSAGEQUEUE_RECEIVE,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 5, dwNumMsgs );
check( 5*dwDataSize, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
DPMESSAGEQUEUE_SEND,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 0, dwNumMsgs );
check( 0, dwNumBytes );
dwNumMsgs = dwNumBytes = -1;
hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
0,
&dwNumMsgs, &dwNumBytes );
checkHR( DP_OK, hr );
check( 0, dwNumMsgs );
check( 0, dwNumBytes );
HeapFree( GetProcessHeap(), 0, lpData );
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
}
/* Remote data replication */
static void test_remote_data_replication(void)
{
IDirectPlay4 *pDP[2];
DPSESSIONDESC2 dpsd;
DPID dpid[2], idFrom, idTo;
CallbackData callbackData;
HRESULT hr;
UINT i, j;
DWORD dwFlags, dwDataSize = 1024;
DWORD dwCount;
LPDPMSG_SETPLAYERORGROUPDATA lpData = HeapAlloc( GetProcessHeap(),
HEAP_ZERO_MEMORY,
dwDataSize );
LPCSTR lpDataLocal[] = { "local_0", "local_1" };
LPCSTR lpDataRemote[] = { "remote_0", "remote_1" };
LPCSTR lpDataFake = "ugly_fake_data";
LPSTR lpDataGet = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 32 );
DWORD dwDataSizeLocal = strlen(lpDataLocal[0])+1,
dwDataSizeRemote = strlen(lpDataRemote[0])+1,
dwDataSizeFake = strlen(lpDataFake)+1,
dwDataSizeGet;
for (i=0; i<2; i++)
{
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
init_TCPIP_provider( pDP[i], "127.0.0.1", 0 );
}
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
/* Host */
hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
todo_wine checkHR( DP_OK, hr );
if ( hr == DPERR_UNINITIALIZED )
{
todo_wine win_skip( "dplay not implemented enough for this test yet\n" );
return;
}
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[0],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
/* Peer */
hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
pDP[1], 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid[1],
NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
/* Check players */
for (i=0; i<2; i++)
{
/* Local (0,0) (1,1) */
IDirectPlayX_GetPlayerFlags( pDP[i], dpid[i], &dwFlags );
checkFlags( DPPLAYER_LOCAL, dwFlags, FLAGS_DPPLAYER );
/* Remote (0,1) (1,0) */
IDirectPlayX_GetPlayerFlags( pDP[i], dpid[!i], &dwFlags );
checkFlags( 0, dwFlags, FLAGS_DPPLAYER );
}
/* Set data for a local player */
for (i=0; i<2; i++)
{
hr = IDirectPlayX_SetPlayerData( pDP[i], dpid[i],
(LPVOID) lpDataLocal[i],
dwDataSizeLocal,
DPSET_LOCAL );
checkHR( DP_OK, hr );
hr = IDirectPlayX_SetPlayerData( pDP[i], dpid[i],
(LPVOID) lpDataRemote[i],
dwDataSizeRemote,
DPSET_REMOTE );
checkHR( DP_OK, hr );
}
/* Retrieve data locally (0->0, 1->1) */
for (i=0; i<2; i++)
{
dwDataSizeGet = dwDataSizeFake;
strcpy( lpDataGet, lpDataFake );
hr = IDirectPlayX_GetPlayerData( pDP[i], dpid[i],
lpDataGet, &dwDataSizeGet,
DPGET_LOCAL );
checkHR( DP_OK, hr );
check( dwDataSizeLocal, dwDataSizeGet );
checkStr( lpDataLocal[i], lpDataGet );
dwDataSizeGet = dwDataSizeFake;
strcpy( lpDataGet, lpDataFake );
hr = IDirectPlayX_GetPlayerData( pDP[i], dpid[i],
lpDataGet, &dwDataSizeGet,
DPGET_REMOTE );
checkHR( DP_OK, hr );
check( dwDataSizeRemote, dwDataSizeGet );
checkStr( lpDataRemote[i], lpDataGet );
}
/* Set data for a remote player */
/* This should fail with DPERR_ACCESSDENIED,
but for some reason it doesn't */
for (i=0; i<2; i++)
{
IDirectPlayX_SetPlayerData( pDP[i], dpid[!i],
(LPVOID) lpDataLocal[!i],
dwDataSizeLocal,
DPSET_LOCAL );
checkHR( DP_OK, hr );
IDirectPlayX_SetPlayerData( pDP[i], dpid[!i],
(LPVOID) lpDataRemote[!i],
dwDataSizeRemote,
DPSET_REMOTE );
checkHR( DP_OK, hr );
}
/* Retrieve crossed data (0->1, 1->0) */
for (i=0; i<2; i++)
{
dwDataSizeGet = dwDataSizeFake;
strcpy( lpDataGet, lpDataFake );
hr = IDirectPlayX_GetPlayerData( pDP[i], dpid[!i],
lpDataGet, &dwDataSizeGet,
DPGET_LOCAL );
checkHR( DP_OK, hr );
check( dwDataSizeLocal, dwDataSizeGet );
checkStr( lpDataLocal[!i], lpDataGet );
dwDataSizeGet = dwDataSizeFake;
strcpy( lpDataGet, lpDataFake );
hr = IDirectPlayX_GetPlayerData( pDP[i], dpid[!i],
lpDataGet, &dwDataSizeGet,
DPGET_REMOTE );
checkHR( DP_OK, hr );
check( dwDataSizeRemote, dwDataSizeGet );
checkStr( lpDataRemote[!i], lpDataGet );
}
/* Purge "new player" messages from queue */
hr = IDirectPlayX_Receive( pDP[0], &idFrom, &idTo, 0, lpData, &dwDataSize );
checkHR( DP_OK, hr );
checkConv( DPSYS_CREATEPLAYERORGROUP, lpData->dwType, dpMsgType2str );
/* Check number of messages in queue */
for (i=0; i<2; i++)
{
IDirectPlayX_GetMessageCount( pDP[i], dpid[i], &dwCount );
check( 2, dwCount );
IDirectPlayX_GetMessageCount( pDP[i], dpid[!i], &dwCount );
check( 0, dwCount );
}
/* Checking system messages */
for (i=0; i<2; i++)
{
for (j=0; j<2; j++)
{
hr = IDirectPlayX_Receive( pDP[i], &idFrom, &idTo, 0, lpData,
&dwDataSize );
checkHR( DP_OK, hr );
check( 29, dwDataSize );
check( DPID_SYSMSG, idFrom );
check( dpid[i], idTo );
checkConv( DPSYS_SETPLAYERORGROUPDATA, lpData->dwType,
dpMsgType2str );
check( DPPLAYERTYPE_PLAYER, lpData->dwPlayerType );
check( dpid[j], lpData->dpId );
checkStr( lpDataRemote[j], (LPSTR) lpData->lpData );
check( dwDataSizeRemote, lpData->dwDataSize );
dwDataSize = 1024;
}
hr = IDirectPlayX_Receive( pDP[i], &idFrom, &idTo, 0,
lpData, &dwDataSize );
checkHR( DPERR_NOMESSAGES, hr );
}
/* Changing remote data */
hr = IDirectPlayX_SetPlayerData( pDP[0], dpid[0],
(LPVOID) lpDataRemote[0], dwDataSizeRemote,
DPSET_REMOTE );
checkHR( DP_OK, hr );
/* Checking system messages (j=0) */
for (i=0; i<2; i++)
{
hr = IDirectPlayX_Receive( pDP[i], &idFrom, &idTo, 0,
lpData, &dwDataSize );
checkHR( DP_OK, hr );
check( 29, dwDataSize );
check( DPID_SYSMSG, idFrom );
check( dpid[i], idTo );
checkConv( DPSYS_SETPLAYERORGROUPDATA, lpData->dwType, dpMsgType2str );
check( DPPLAYERTYPE_PLAYER, lpData->dwPlayerType );
check( dpid[0], lpData->dpId );
checkStr( lpDataRemote[0], (LPSTR) lpData->lpData );
check( dwDataSizeRemote, lpData->dwDataSize );
dwDataSize = 1024;
}
/* Queue is empty */
check_messages( pDP[0], dpid, 2, &callbackData );
checkStr( "", callbackData.szTrace1 );
check_messages( pDP[1], dpid, 2, &callbackData );
checkStr( "", callbackData.szTrace1 );
HeapFree( GetProcessHeap(), 0, lpDataGet );
HeapFree( GetProcessHeap(), 0, lpData );
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
}
/* Host migration */
static void test_host_migration(void)
{
IDirectPlay4 *pDP[2];
DPSESSIONDESC2 dpsd;
DPID dpid[2], idFrom, idTo;
HRESULT hr;
UINT i;
DWORD dwCount;
DWORD dwDataSize = 1024;
LPDPMSG_DESTROYPLAYERORGROUP lpData = HeapAlloc( GetProcessHeap(),
HEAP_ZERO_MEMORY,
dwDataSize );
for (i=0; i<2; i++)
{
hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
&IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
if (FAILED(hr)) return;
init_TCPIP_provider( pDP[i], "127.0.0.1", 0 );
}
ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
dpsd.dwSize = sizeof(DPSESSIONDESC2);
dpsd.guidApplication = appGuid;
dpsd.dwMaxPlayers = 10;
dpsd.dwFlags = DPSESSION_MIGRATEHOST;
/* Host */
hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
todo_wine checkHR( DP_OK, hr );
if ( hr != DP_OK )
{
todo_wine win_skip( "dplay not implemented enough for this test yet\n" );
return;
}
hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
/* Peer */
hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
pDP[1], 0 );
checkHR( DP_OK, hr );
hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid[1], NULL, NULL, NULL, 0, 0 );
checkHR( DP_OK, hr );
/* Host: One message in queue */
IDirectPlayX_GetMessageCount( pDP[0], dpid[0], &dwCount );
check( 1, dwCount );
dwDataSize = 1024;
hr = IDirectPlayX_Receive( pDP[0], &idFrom, &idTo, DPRECEIVE_PEEK,
lpData, &dwDataSize );
checkHR( DP_OK, hr );
checkConv( DPSYS_CREATEPLAYERORGROUP, lpData->dwType, dpMsgType2str );
/* Peer: No messages */
IDirectPlayX_GetMessageCount( pDP[1], dpid[1], &dwCount );
check( 0, dwCount );
hr = IDirectPlayX_Receive( pDP[1], &idFrom, &idTo, DPRECEIVE_PEEK,
lpData, &dwDataSize );
checkHR( DPERR_NOMESSAGES, hr );
/* Closing host */
IDirectPlayX_Close( pDP[0] );
/* Host: Queue is cleaned */
IDirectPlayX_GetMessageCount( pDP[0], dpid[0], &dwCount );
check( 0, dwCount );
hr = IDirectPlayX_Receive( pDP[0], &idFrom, &idTo, DPRECEIVE_PEEK,
lpData, &dwDataSize );
checkHR( DPERR_NOMESSAGES, hr );
/* Peer: gets message of player destruction */
IDirectPlayX_GetMessageCount( pDP[1], dpid[1], &dwCount );
check( 2, dwCount );
dwDataSize = 1024;
hr = IDirectPlayX_Receive( pDP[1], &idFrom, &idTo, DPRECEIVE_PEEK,
lpData, &dwDataSize );
checkHR( DP_OK, hr );
checkConv( DPSYS_DESTROYPLAYERORGROUP, lpData->dwType, dpMsgType2str );
/* Message analysis */
for (i=0; i<2; i++)
{
hr = IDirectPlayX_Receive( pDP[1], &idFrom, &idTo, 0,
lpData, &dwDataSize );
checkHR( DP_OK, hr );
check( DPID_SYSMSG, idFrom );
check( dpid[1], idTo ); /* Peer player id */
switch(i)
{
case 0:
checkConv( DPSYS_DESTROYPLAYERORGROUP, lpData->dwType,
dpMsgType2str );
check( DPPLAYERTYPE_PLAYER, lpData->dwPlayerType );
check( dpid[0], lpData->dpId ); /* Host player id */
checkLP( NULL, lpData->lpLocalData );
check( 0, lpData->dwLocalDataSize );
checkLP( NULL, lpData->lpRemoteData );
check( 0, lpData->dwRemoteDataSize );
checkLP( NULL, U1(lpData->dpnName).lpszShortNameA );
check( 0, lpData->dpIdParent );
checkFlags( 0, lpData->dwFlags,
FLAGS_DPPLAYER | FLAGS_DPGROUP );
break;
case 1:
checkConv( DPSYS_HOST, lpData->dwType, dpMsgType2str );
break;
default:
break;
}
dwDataSize = 1024;
}
hr = IDirectPlayX_Receive( pDP[1], &idFrom, &idTo, 0, lpData, &dwDataSize );
checkHR( DPERR_NOMESSAGES, hr );
HeapFree( GetProcessHeap(), 0, lpData );
IDirectPlayX_Release( pDP[0] );
IDirectPlayX_Release( pDP[1] );
}
static void test_COM(void)
{
IDirectPlay *dp;
IDirectPlay2A *dp2A;
IDirectPlay2 *dp2;
IDirectPlay3A *dp3A;
IDirectPlay3 *dp3;
IDirectPlay4A *dp4A;
IDirectPlay4 *dp4 = (IDirectPlay4*)0xdeadbeef;
IUnknown *unk;
ULONG refcount;
HRESULT hr;
/* COM aggregation */
hr = CoCreateInstance(&CLSID_DirectPlay, (IUnknown*)&dp4, CLSCTX_INPROC_SERVER, &IID_IUnknown,
(void**)&dp4);
ok(hr == CLASS_E_NOAGGREGATION || broken(hr == E_INVALIDARG),
"DirectPlay create failed: %08x, expected CLASS_E_NOAGGREGATION\n", hr);
ok(!dp4 || dp4 == (IDirectPlay4*)0xdeadbeef, "dp4 = %p\n", dp4);
/* Invalid RIID */
hr = CoCreateInstance(&CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlayLobby,
(void**)&dp4);
ok(hr == E_NOINTERFACE, "DirectPlay create failed: %08x, expected E_NOINTERFACE\n", hr);
/* Different refcount for all DirectPlay Interfaces */
hr = CoCreateInstance(&CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay4,
(void**)&dp4);
ok(hr == S_OK, "DirectPlay create failed: %08x, expected S_OK\n", hr);
refcount = IDirectPlayX_AddRef(dp4);
ok(refcount == 2, "refcount == %u, expected 2\n", refcount);
hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay2A, (void**)&dp2A);
ok(hr == S_OK, "QueryInterface for IID_IDirectPlay2A failed: %08x\n", hr);
refcount = IDirectPlay2_AddRef(dp2A);
ok(refcount == 2, "refcount == %u, expected 2\n", refcount);
IDirectPlay2_Release(dp2A);
hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay2, (void**)&dp2);
ok(hr == S_OK, "QueryInterface for IID_IDirectPlay2 failed: %08x\n", hr);
refcount = IDirectPlay2_AddRef(dp2);
ok(refcount == 2, "refcount == %u, expected 2\n", refcount);
IDirectPlay2_Release(dp2);
hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay3A, (void**)&dp3A);
ok(hr == S_OK, "QueryInterface for IID_IDirectPlay3A failed: %08x\n", hr);
refcount = IDirectPlay3_AddRef(dp3A);
ok(refcount == 2, "refcount == %u, expected 2\n", refcount);
IDirectPlay3_Release(dp3A);
hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay3, (void**)&dp3);
ok(hr == S_OK, "QueryInterface for IID_IDirectPlay3 failed: %08x\n", hr);
refcount = IDirectPlay3_AddRef(dp3);
ok(refcount == 2, "refcount == %u, expected 2\n", refcount);
IDirectPlay3_Release(dp3);
hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay4A, (void**)&dp4A);
ok(hr == S_OK, "QueryInterface for IID_IDirectPlay4A failed: %08x\n", hr);
refcount = IDirectPlayX_AddRef(dp4A);
ok(refcount == 2, "refcount == %u, expected 2\n", refcount);
IDirectPlayX_Release(dp4A);
/* IDirectPlay and IUnknown share a refcount */
hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay, (void**)&dp);
ok(hr == S_OK, "QueryInterface for IID_IDirectPlay failed: %08x\n", hr);
refcount = IDirectPlayX_AddRef(dp);
ok(refcount == 2, "refcount == %u, expected 2\n", refcount);
IDirectPlay_Release(dp);
hr = IDirectPlayX_QueryInterface(dp4, &IID_IUnknown, (void**)&unk);
ok(hr == S_OK, "QueryInterface for IID_IUnknown failed: %08x\n", hr);
refcount = IUnknown_AddRef(unk);
ok(refcount == 3, "refcount == %u, expected 3\n", refcount);
refcount = IUnknown_Release(unk);
ok(refcount == 2, "refcount == %u, expected 2\n", refcount);
IUnknown_Release(unk);
IDirectPlay_Release(dp);
IDirectPlayX_Release(dp4A);
IDirectPlay3_Release(dp3);
IDirectPlay3_Release(dp3A);
IDirectPlay2_Release(dp2);
IDirectPlay2_Release(dp2A);
IDirectPlayX_Release(dp4);
refcount = IDirectPlayX_Release(dp4);
ok(refcount == 0, "refcount == %u, expected 0\n", refcount);
}
static void test_COM_dplobby(void)
{
IDirectPlayLobby *dpl = (IDirectPlayLobby*)0xdeadbeef;
IDirectPlayLobbyA *dplA;
IDirectPlayLobby2A *dpl2A;
IDirectPlayLobby2 *dpl2;
IDirectPlayLobby3A *dpl3A;
IDirectPlayLobby3 *dpl3;
IUnknown *unk;
ULONG refcount;
HRESULT hr;
/* COM aggregation */
hr = CoCreateInstance(&CLSID_DirectPlayLobby, (IUnknown*)&dpl, CLSCTX_INPROC_SERVER,
&IID_IUnknown, (void**)&dpl);
ok(hr == CLASS_E_NOAGGREGATION || broken(hr == E_INVALIDARG),
"DirectPlayLobby create failed: %08x, expected CLASS_E_NOAGGREGATION\n", hr);
ok(!dpl || dpl == (IDirectPlayLobby*)0xdeadbeef, "dpl = %p\n", dpl);
/* Invalid RIID */
hr = CoCreateInstance(&CLSID_DirectPlayLobby, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay,
(void**)&dpl);
ok(hr == E_NOINTERFACE, "DirectPlayLobby create failed: %08x, expected E_NOINTERFACE\n", hr);
/* Different refcount for all DirectPlayLobby Interfaces */
hr = CoCreateInstance(&CLSID_DirectPlayLobby, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlayLobby,
(void**)&dpl);
ok(hr == S_OK, "DirectPlayLobby create failed: %08x, expected S_OK\n", hr);
refcount = IDirectPlayLobby_AddRef(dpl);
ok(refcount == 2, "refcount == %u, expected 2\n", refcount);
hr = IDirectPlayLobby_QueryInterface(dpl, &IID_IDirectPlayLobbyA, (void**)&dplA);
ok(hr == S_OK, "QueryInterface for IID_IDirectPlayLobbyA failed: %08x\n", hr);
refcount = IDirectPlayLobby_AddRef(dplA);
ok(refcount == 2, "refcount == %u, expected 2\n", refcount);
IDirectPlayLobby_Release(dplA);
hr = IDirectPlayLobby_QueryInterface(dpl, &IID_IDirectPlayLobby2, (void**)&dpl2);
ok(hr == S_OK, "QueryInterface for IID_IDirectPlayLobby2 failed: %08x\n", hr);
refcount = IDirectPlayLobby_AddRef(dpl2);
ok(refcount == 2, "refcount == %u, expected 2\n", refcount);
IDirectPlayLobby_Release(dpl2);
hr = IDirectPlayLobby_QueryInterface(dpl, &IID_IDirectPlayLobby2A, (void**)&dpl2A);
ok(hr == S_OK, "QueryInterface for IID_IDirectPlayLobby2A failed: %08x\n", hr);
refcount = IDirectPlayLobby_AddRef(dpl2A);
ok(refcount == 2, "refcount == %u, expected 2\n", refcount);
IDirectPlayLobby_Release(dpl2A);
hr = IDirectPlayLobby_QueryInterface(dpl, &IID_IDirectPlayLobby3, (void**)&dpl3);
ok(hr == S_OK, "QueryInterface for IID_IDirectPlayLobby3 failed: %08x\n", hr);
refcount = IDirectPlayLobby_AddRef(dpl3);
ok(refcount == 2, "refcount == %u, expected 2\n", refcount);
IDirectPlayLobby_Release(dpl3);
hr = IDirectPlayLobby_QueryInterface(dpl, &IID_IDirectPlayLobby3A, (void**)&dpl3A);
ok(hr == S_OK, "QueryInterface for IID_IDirectPlayLobby3A failed: %08x\n", hr);
refcount = IDirectPlayLobby_AddRef(dpl3A);
ok(refcount == 2, "refcount == %u, expected 2\n", refcount);
IDirectPlayLobby_Release(dpl3A);
/* IDirectPlayLobby and IUnknown share a refcount */
hr = IDirectPlayX_QueryInterface(dpl, &IID_IUnknown, (void**)&unk);
ok(hr == S_OK, "QueryInterface for IID_IUnknown failed: %08x\n", hr);
refcount = IUnknown_AddRef(unk);
ok(refcount == 4, "refcount == %u, expected 4\n", refcount);
IDirectPlayLobby_Release(unk);
IUnknown_Release(unk);
IDirectPlayLobby_Release(dpl3);
IDirectPlayLobby_Release(dpl3A);
IDirectPlayLobby_Release(dpl2);
IDirectPlayLobby_Release(dpl2A);
IDirectPlayLobby_Release(dplA);
IDirectPlayLobby_Release(dpl);
refcount = IDirectPlayLobby_Release(dpl);
ok(refcount == 0, "refcount == %u, expected 0\n", refcount);
}
START_TEST(dplayx)
{
CoInitialize( NULL );
test_COM();
test_COM_dplobby();
if (!winetest_interactive)
{
skip("Run in interactive mode to run dplayx tests.\n");
return;
}
trace("Running in interactive mode, tests will take a while\n");
test_DirectPlayCreate();
test_EnumConnections();
test_InitializeConnection();
test_GetCaps();
/* test_Open() takes almost a minute, */
test_Open();
/* test_EnumSession takes three minutes */
test_EnumSessions();
test_SessionDesc();
/* test_CreatePlayer() takes over a minute */
test_CreatePlayer();
test_GetPlayerCaps();
test_PlayerData();
test_PlayerName();
/* test_GetPlayerAccount() takes over 30s */
test_GetPlayerAccount();
test_GetPlayerAddress();
test_GetPlayerFlags();
test_CreateGroup();
test_GroupOwner();
test_EnumPlayers();
test_EnumGroups();
test_EnumGroupsInGroup();
test_groups_p2p();
test_groups_cs();
test_Send();
test_Receive();
test_GetMessageCount();
test_GetMessageQueue();
test_remote_data_replication();
test_host_migration();
CoUninitialize();
}
Reference in a new issue View git blame Copy permalink