695 lines
27 KiB
C
695 lines
27 KiB
C
/*
|
|
* IGameExplorer and IGameExplorer2 tests
|
|
*
|
|
* Copyright (C) 2010 Mariusz Pluciński
|
|
*
|
|
* 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 "windows.h"
|
|
#include "ole2.h"
|
|
#include "objsafe.h"
|
|
#include "objbase.h"
|
|
#include "shlwapi.h"
|
|
#include "sddl.h"
|
|
#include "shobjidl.h"
|
|
|
|
#include "initguid.h"
|
|
#include "gameux.h"
|
|
|
|
#include "wine/test.h"
|
|
|
|
/*******************************************************************************
|
|
* Pointers used instead of direct calls. These procedures are not available on
|
|
* older system, which causes problem while loading test binary.
|
|
*/
|
|
static BOOL WINAPI (*_ConvertSidToStringSidW)(PSID,LPWSTR*);
|
|
static LONG WINAPI (*_RegGetValueW)(HKEY,LPCWSTR,LPCWSTR,DWORD,LPDWORD,PVOID,LPDWORD);
|
|
|
|
/*******************************************************************************
|
|
*_loadDynamicRoutines
|
|
*
|
|
* Helper function, prepares pointers to system procedures which may be not
|
|
* available on older operating systems.
|
|
*
|
|
* Returns:
|
|
* TRUE procedures were loaded successfully
|
|
* FALSE procedures were not loaded successfully
|
|
*/
|
|
static BOOL _loadDynamicRoutines(void)
|
|
{
|
|
HMODULE hAdvapiModule = GetModuleHandleA( "advapi32.dll" );
|
|
|
|
_ConvertSidToStringSidW = (LPVOID)GetProcAddress(hAdvapiModule, "ConvertSidToStringSidW");
|
|
if (!_ConvertSidToStringSidW) return FALSE;
|
|
_RegGetValueW = (LPVOID)GetProcAddress(hAdvapiModule, "RegGetValueW");
|
|
if (!_RegGetValueW) return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* _buildGameRegistryPath
|
|
*
|
|
* Helper function, builds registry path to key, where game's data are stored
|
|
*
|
|
* Parameters:
|
|
* installScope [I] the scope which was used in AddGame/InstallGame call
|
|
* gameInstanceId [I] game instance GUID. If NULL, then only
|
|
* path to scope is returned
|
|
* lpRegistryPath [O] pointer which will receive address to string
|
|
* containing expected registry path. Path
|
|
* is relative to HKLM registry key. It
|
|
* must be freed by calling CoTaskMemFree
|
|
*/
|
|
static HRESULT _buildGameRegistryPath(GAME_INSTALL_SCOPE installScope,
|
|
LPCGUID gameInstanceId,
|
|
LPWSTR* lpRegistryPath)
|
|
{
|
|
static const WCHAR sGameUxRegistryPath[] = {'S','O','F','T','W','A','R','E','\\',
|
|
'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
|
|
'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','G','a','m','e','U','X',0};
|
|
static const WCHAR sGames[] = {'G','a','m','e','s',0};
|
|
static const WCHAR sBackslash[] = {'\\',0};
|
|
|
|
HRESULT hr = S_OK;
|
|
HANDLE hToken = NULL;
|
|
PTOKEN_USER pTokenUser = NULL;
|
|
DWORD dwLength;
|
|
LPWSTR lpSID = NULL;
|
|
WCHAR sInstanceId[40];
|
|
WCHAR sRegistryPath[8192];
|
|
|
|
lstrcpyW(sRegistryPath, sGameUxRegistryPath);
|
|
lstrcatW(sRegistryPath, sBackslash);
|
|
|
|
if(installScope == GIS_CURRENT_USER)
|
|
{
|
|
/* build registry path containing user's SID */
|
|
if(!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
if(!GetTokenInformation(hToken, TokenUser, NULL, 0, &dwLength) &&
|
|
GetLastError()!=ERROR_INSUFFICIENT_BUFFER)
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
pTokenUser = CoTaskMemAlloc(dwLength);
|
|
if(!pTokenUser)
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
if(SUCCEEDED(hr))
|
|
if(!GetTokenInformation(hToken, TokenUser, (LPVOID)pTokenUser, dwLength, &dwLength))
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
|
|
if(SUCCEEDED(hr))
|
|
if(!_ConvertSidToStringSidW(pTokenUser->User.Sid, &lpSID))
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
lstrcatW(sRegistryPath, lpSID);
|
|
LocalFree(lpSID);
|
|
}
|
|
|
|
CoTaskMemFree(pTokenUser);
|
|
CloseHandle(hToken);
|
|
}
|
|
}
|
|
else if(installScope == GIS_ALL_USERS)
|
|
/* build registry path without SID */
|
|
lstrcatW(sRegistryPath, sGames);
|
|
else
|
|
hr = E_INVALIDARG;
|
|
|
|
/* put game's instance id on the end of path, but only if id was passes */
|
|
if(gameInstanceId)
|
|
{
|
|
if(SUCCEEDED(hr))
|
|
hr = (StringFromGUID2(gameInstanceId, sInstanceId, sizeof(sInstanceId)/sizeof(sInstanceId[0])) ? S_OK : E_FAIL);
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
lstrcatW(sRegistryPath, sBackslash);
|
|
lstrcatW(sRegistryPath, sInstanceId);
|
|
}
|
|
}
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
*lpRegistryPath = CoTaskMemAlloc((lstrlenW(sRegistryPath)+1)*sizeof(WCHAR));
|
|
if(!*lpRegistryPath)
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
if(SUCCEEDED(hr))
|
|
lstrcpyW(*lpRegistryPath, sRegistryPath);
|
|
|
|
return hr;
|
|
}
|
|
/*******************************************************************************
|
|
* _validateRegistryValue
|
|
*
|
|
* Helper function, verifies single registry value with expected
|
|
*
|
|
* Parameters:
|
|
* hKey [I] handle to game's key. Key must be opened
|
|
* keyPath [I] string with path to game's key. Used only
|
|
* to display more useful message on test fail
|
|
* valueName [I] name of value to check
|
|
* dwExpectedType [I] expected type of value. It should be
|
|
* one of RRF_RT_* flags
|
|
* lpExpectedContent [I] expected content of value. It should be
|
|
* pointer to variable with same type as
|
|
* passed in dwExpectedType
|
|
*
|
|
* Returns:
|
|
* S_OK value exists and contains expected data
|
|
* S_FALSE value exists, but contains other data
|
|
* than expected
|
|
* E_OUTOFMEMORY allocation problem
|
|
* HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)
|
|
* value does not exist
|
|
*
|
|
* Note: this function returns error codes instead of failing test case, because
|
|
* it is sometimes expected that given value may not exist on some systems, or
|
|
* contain other data.
|
|
*/
|
|
static HRESULT _validateRegistryValue(
|
|
HKEY hKey,
|
|
LPCWSTR keyPath,
|
|
LPCWSTR valueName,
|
|
DWORD dwExpectedType,
|
|
LPCVOID lpExpectedContent)
|
|
{
|
|
HRESULT hr;
|
|
DWORD dwType, dwSize;
|
|
LPVOID lpData = NULL;
|
|
|
|
hr = HRESULT_FROM_WIN32(_RegGetValueW(hKey, NULL, valueName, dwExpectedType, &dwType, NULL, &dwSize));
|
|
if(FAILED(hr)) trace("registry value cannot be opened\n"
|
|
" key: %s\n"
|
|
" value: %s\n"
|
|
" expected type: 0x%x\n"
|
|
" found type: 0x%x\n"
|
|
" result code: 0x%0x\n",
|
|
wine_dbgstr_w(keyPath),
|
|
wine_dbgstr_w(valueName),
|
|
dwExpectedType,
|
|
dwType,
|
|
hr);
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
lpData = CoTaskMemAlloc(dwSize);
|
|
if(!lpData)
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
if(SUCCEEDED(hr))
|
|
hr = HRESULT_FROM_WIN32(_RegGetValueW(hKey, NULL, valueName, dwExpectedType, &dwType, lpData, &dwSize));
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
if(memcmp(lpData, lpExpectedContent, dwSize)==0)
|
|
hr = S_OK;
|
|
else
|
|
{
|
|
if(dwExpectedType == RRF_RT_REG_SZ)
|
|
/* if value type is REG_SZ, display expected and found values */
|
|
trace("not expected content of registry value\n"
|
|
" key: %s\n"
|
|
" value: %s\n"
|
|
" expected REG_SZ content: %s\n"
|
|
" found REG_SZ content: %s\n",
|
|
wine_dbgstr_w(keyPath),
|
|
wine_dbgstr_w(valueName),
|
|
wine_dbgstr_w(lpExpectedContent),
|
|
wine_dbgstr_w(lpData));
|
|
else
|
|
/* in the other case, do not display content */
|
|
trace("not expected content of registry value\n"
|
|
" key: %s\n"
|
|
" value: %s\n"
|
|
" value type: 0x%x\n",
|
|
wine_dbgstr_w(keyPath),
|
|
wine_dbgstr_w(valueName),
|
|
dwType);
|
|
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
|
|
CoTaskMemFree(lpData);
|
|
return hr;
|
|
}
|
|
/*******************************************************************************
|
|
* _validateGameRegistryValues
|
|
*
|
|
* Helper function, verifies values in game's registry key
|
|
*
|
|
* Parameters:
|
|
* line [I] place of original call. Used only to display
|
|
* more useful message on test fail
|
|
* hKey [I] handle to game's key. Key must be opened
|
|
* with KEY_READ access permission
|
|
* keyPath [I] string with path to game's key. Used only
|
|
* to display more useful message on test fail
|
|
* gameApplicationId [I] game application identifier
|
|
* gameExePath [I] directory where game executable is stored
|
|
* gameExeName [I] full path to executable, including directory and file name
|
|
*/
|
|
static void _validateGameRegistryValues(int line,
|
|
HKEY hKey,
|
|
LPCWSTR keyPath,
|
|
LPCGUID gameApplicationId,
|
|
LPCWSTR gameExePath,
|
|
LPCWSTR gameExeName)
|
|
{
|
|
static const WCHAR sApplicationId[] = {'A','p','p','l','i','c','a','t','i','o','n','I','d',0};
|
|
static const WCHAR sConfigApplicationPath[] = {'C','o','n','f','i','g','A','p','p','l','i','c','a','t','i','o','n','P','a','t','h',0};
|
|
static const WCHAR sConfigGDFBinaryPath[] = {'C','o','n','f','i','g','G','D','F','B','i','n','a','r','y','P','a','t','h',0};
|
|
static const WCHAR sDescription[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
|
|
static const WCHAR sExampleGame[] = {'E','x','a','m','p','l','e',' ','G','a','m','e',0};
|
|
static const WCHAR sGameDescription[] = {'G','a','m','e',' ','D','e','s','c','r','i','p','t','i','o','n',0};
|
|
static const WCHAR sTitle[] = {'T','i','t','l','e',0};
|
|
|
|
HRESULT hr;
|
|
WCHAR sGameApplicationId[40];
|
|
|
|
hr = (StringFromGUID2(gameApplicationId, sGameApplicationId, sizeof(sGameApplicationId)/sizeof(sGameApplicationId[0])) ? S_OK : E_FAIL);
|
|
ok_(__FILE__, line)(hr == S_OK, "cannot convert game application id to string\n");
|
|
|
|
/* these values exist up from Vista */
|
|
hr = _validateRegistryValue(hKey, keyPath, sApplicationId, RRF_RT_REG_SZ, sGameApplicationId);
|
|
ok_(__FILE__, line)(hr==S_OK, "failed while checking registry value (error 0x%x)\n", hr);
|
|
hr = _validateRegistryValue(hKey, keyPath, sConfigApplicationPath, RRF_RT_REG_SZ, gameExePath);
|
|
ok_(__FILE__, line)(hr==S_OK, "failed while checking registry value (error 0x%x)\n", hr);
|
|
hr = _validateRegistryValue(hKey, keyPath, sConfigGDFBinaryPath, RRF_RT_REG_SZ, gameExeName);
|
|
ok_(__FILE__, line)(hr==S_OK, "failed while checking registry value (error 0x%x)\n", hr);
|
|
hr = _validateRegistryValue(hKey, keyPath, sTitle, RRF_RT_REG_SZ, sExampleGame);
|
|
ok_(__FILE__, line)(hr==S_OK, "failed while checking registry value (error 0x%x)\n", hr);
|
|
|
|
/* this value exists up from Win7 */
|
|
hr = _validateRegistryValue(hKey, keyPath, sDescription, RRF_RT_REG_SZ, sGameDescription);
|
|
ok_(__FILE__, line)(hr==S_OK || broken(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)), "failed while checking registry value (error 0x%x)\n", hr);
|
|
}
|
|
/*******************************************************************************
|
|
* _validateGameKey
|
|
*
|
|
* Helper function, verifies current state of game's registry key with expected.
|
|
*
|
|
* Parameters:
|
|
* line [I] place of original call. Used only to display
|
|
* more useful message on test fail
|
|
* installScope [I] the scope which was used in AddGame/InstallGame call
|
|
* gameInstanceId [I] game instance identifier
|
|
* gameApplicationId [I] game application identifier
|
|
* gameExePath [I] directory where game executable is stored
|
|
* gameExeName [I] full path to executable, including directory and file name
|
|
* presenceExpected [I] is it expected that game should be currently
|
|
* registered or not. Should be TRUE if checking
|
|
* after using AddGame/InstallGame, and FALSE
|
|
* if checking after RemoveGame/UninstallGame
|
|
*/
|
|
static void _validateGameRegistryKey(int line,
|
|
GAME_INSTALL_SCOPE installScope,
|
|
LPCGUID gameInstanceId,
|
|
LPCGUID gameApplicationId,
|
|
LPCWSTR gameExePath,
|
|
LPCWSTR gameExeName,
|
|
BOOL presenceExpected)
|
|
{
|
|
HRESULT hr;
|
|
LPWSTR lpRegistryPath = NULL;
|
|
HKEY hKey;
|
|
|
|
/* check key presence */
|
|
hr = _buildGameRegistryPath(installScope, gameInstanceId, &lpRegistryPath);
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_LOCAL_MACHINE, lpRegistryPath, 0,
|
|
KEY_READ | KEY_WOW64_64KEY, &hKey));
|
|
|
|
if(presenceExpected)
|
|
ok_(__FILE__, line)(hr == S_OK,
|
|
"problem while trying to open registry key (HKLM): %s, error: 0x%x\n", wine_dbgstr_w(lpRegistryPath), hr);
|
|
else
|
|
ok_(__FILE__, line)(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
|
|
"other than expected (FILE_NOT_FOUND) error while trying to open registry key (HKLM): %s, error: 0x%x\n", wine_dbgstr_w(lpRegistryPath), hr);
|
|
}
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
if(presenceExpected)
|
|
/* if the key exists and we expected it, let's verify its content */
|
|
_validateGameRegistryValues(line, hKey, lpRegistryPath, gameApplicationId, gameExePath, gameExeName);
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
CoTaskMemFree(lpRegistryPath);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* _LoadRegistryString
|
|
*
|
|
* Helper function, loads string from registry value and allocates buffer for it
|
|
*
|
|
* Parameters:
|
|
* hRootKey [I] base key for reading. Should be opened
|
|
* with KEY_READ permission
|
|
* lpRegistryKey [I] name of registry key, subkey of root key
|
|
* lpRegistryValue [I] name of registry value
|
|
* lpValue [O] pointer where address of received
|
|
* value will be stored. Value should be
|
|
* freed by CoTaskMemFree call
|
|
*/
|
|
static HRESULT _LoadRegistryString(HKEY hRootKey,
|
|
LPCWSTR lpRegistryKey,
|
|
LPCWSTR lpRegistryValue,
|
|
LPWSTR* lpValue)
|
|
{
|
|
HRESULT hr;
|
|
DWORD dwSize;
|
|
|
|
*lpValue = NULL;
|
|
|
|
hr = HRESULT_FROM_WIN32(_RegGetValueW(hRootKey, lpRegistryKey, lpRegistryValue,
|
|
RRF_RT_REG_SZ, NULL, NULL, &dwSize));
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
*lpValue = CoTaskMemAlloc(dwSize);
|
|
if(!*lpValue)
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
if(SUCCEEDED(hr))
|
|
hr = HRESULT_FROM_WIN32(_RegGetValueW(hRootKey, lpRegistryKey, lpRegistryValue,
|
|
RRF_RT_REG_SZ, NULL, *lpValue, &dwSize));
|
|
|
|
return hr;
|
|
}
|
|
/*******************************************************************************
|
|
* _findGameInstanceId
|
|
*
|
|
* Helper function. Searches for instance identifier of given game in given
|
|
* installation scope.
|
|
*
|
|
* Parameters:
|
|
* line [I] line to display messages
|
|
* sGDFBinaryPath [I] path to binary containing GDF
|
|
* installScope [I] game install scope to search in
|
|
* pInstanceId [O] instance identifier of given game
|
|
*/
|
|
static void _findGameInstanceId(int line,
|
|
LPWSTR sGDFBinaryPath,
|
|
GAME_INSTALL_SCOPE installScope,
|
|
GUID* pInstanceId)
|
|
{
|
|
static const WCHAR sConfigGDFBinaryPath[] =
|
|
{'C','o','n','f','i','g','G','D','F','B','i','n','a','r','y','P','a','t','h',0};
|
|
|
|
HRESULT hr;
|
|
BOOL found = FALSE;
|
|
LPWSTR lpRegistryPath = NULL;
|
|
HKEY hRootKey;
|
|
DWORD dwSubKeys, dwSubKeyLen, dwMaxSubKeyLen, i;
|
|
LPWSTR lpName = NULL, lpValue = NULL;
|
|
|
|
hr = _buildGameRegistryPath(installScope, NULL, &lpRegistryPath);
|
|
ok_(__FILE__, line)(SUCCEEDED(hr), "cannot get registry path to given scope: %d\n", installScope);
|
|
|
|
if(SUCCEEDED(hr))
|
|
/* enumerate all subkeys of received one and search them for value "ConfigGGDFBinaryPath" */
|
|
hr = HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_LOCAL_MACHINE,
|
|
lpRegistryPath, 0, KEY_READ | KEY_WOW64_64KEY, &hRootKey));
|
|
ok_(__FILE__, line)(SUCCEEDED(hr), "cannot open key registry key: %s\n", wine_dbgstr_w(lpRegistryPath));
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(RegQueryInfoKeyW(hRootKey, NULL, NULL, NULL,
|
|
&dwSubKeys, &dwMaxSubKeyLen, NULL, NULL, NULL, NULL, NULL, NULL));
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
++dwMaxSubKeyLen; /* for string terminator */
|
|
lpName = CoTaskMemAlloc(dwMaxSubKeyLen*sizeof(WCHAR));
|
|
if(!lpName) hr = E_OUTOFMEMORY;
|
|
ok_(__FILE__, line)(SUCCEEDED(hr), "cannot allocate memory for key name");
|
|
}
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
for(i=0; i<dwSubKeys && !found; ++i)
|
|
{
|
|
dwSubKeyLen = dwMaxSubKeyLen;
|
|
hr = HRESULT_FROM_WIN32(RegEnumKeyExW(hRootKey, i, lpName, &dwSubKeyLen,
|
|
NULL, NULL, NULL, NULL));
|
|
|
|
if(SUCCEEDED(hr))
|
|
hr = _LoadRegistryString(hRootKey, lpName,
|
|
sConfigGDFBinaryPath, &lpValue);
|
|
|
|
if(SUCCEEDED(hr))
|
|
if(lstrcmpW(lpValue, sGDFBinaryPath)==0)
|
|
{
|
|
/* key found, let's copy instance id and exit */
|
|
hr = CLSIDFromString(lpName, pInstanceId);
|
|
ok(SUCCEEDED(hr), "cannot convert subkey to guid: %s\n",
|
|
wine_dbgstr_w(lpName));
|
|
|
|
found = TRUE;
|
|
}
|
|
CoTaskMemFree(lpValue);
|
|
}
|
|
}
|
|
|
|
CoTaskMemFree(lpName);
|
|
RegCloseKey(hRootKey);
|
|
}
|
|
|
|
CoTaskMemFree(lpRegistryPath);
|
|
ok_(__FILE__, line)(found==TRUE, "cannot find game with GDF path %s in scope %d\n",
|
|
wine_dbgstr_w(sGDFBinaryPath), installScope);
|
|
}
|
|
/*******************************************************************************
|
|
* Test routines
|
|
*/
|
|
static void test_create(BOOL* gameExplorerAvailable, BOOL* gameExplorer2Available)
|
|
{
|
|
HRESULT hr;
|
|
|
|
IGameExplorer* ge = NULL;
|
|
IGameExplorer2* ge2 = NULL;
|
|
|
|
/* interface available up from Vista */
|
|
hr = CoCreateInstance( &CLSID_GameExplorer, NULL, CLSCTX_INPROC_SERVER, &IID_IGameExplorer, (LPVOID*)&ge);
|
|
if(ge)
|
|
{
|
|
ok(hr == S_OK, "IGameExplorer creating failed (result false)\n");
|
|
*gameExplorerAvailable = TRUE;
|
|
IGameExplorer_Release(ge);
|
|
}
|
|
else
|
|
win_skip("IGameExplorer cannot be created\n");
|
|
|
|
/* interface available up from Win7 */
|
|
hr = CoCreateInstance( &CLSID_GameExplorer, NULL, CLSCTX_INPROC_SERVER, &IID_IGameExplorer2, (LPVOID*)&ge2);
|
|
if(ge2)
|
|
{
|
|
ok( hr == S_OK, "IGameExplorer2 creating failed (result false)\n");
|
|
*gameExplorer2Available = TRUE;
|
|
IGameExplorer2_Release(ge2);
|
|
}
|
|
else
|
|
win_skip("IGameExplorer2 cannot be created\n");
|
|
}
|
|
|
|
static void test_add_remove_game(void)
|
|
{
|
|
static const GUID defaultGUID = {0x01234567, 0x89AB, 0xCDEF,
|
|
{ 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}};
|
|
static const GUID applicationId = { 0x17A6558E, 0x60BE, 0x4078,
|
|
{ 0xB6, 0x6F, 0x9C, 0x3A, 0xDA, 0x2A, 0x32, 0xE6 }};
|
|
|
|
HRESULT hr;
|
|
|
|
IGameExplorer* ge = NULL;
|
|
WCHAR sExeName[MAX_PATH];
|
|
WCHAR sExePath[MAX_PATH];
|
|
BSTR bstrExeName = NULL, bstrExePath = NULL;
|
|
DWORD dwExeNameLen;
|
|
GUID guid;
|
|
|
|
hr = CoCreateInstance(&CLSID_GameExplorer, NULL, CLSCTX_INPROC_SERVER, &IID_IGameExplorer, (LPVOID*) & ge);
|
|
ok(ge != NULL, "cannot create coclass IGameExplorer\n");
|
|
ok(hr == S_OK, "cannot create coclass IGameExplorer\n");
|
|
|
|
if(ge)
|
|
{
|
|
/* prepare path to binary */
|
|
dwExeNameLen = GetModuleFileNameW(NULL, sExeName, sizeof (sExeName) / sizeof (sExeName[0]));
|
|
ok(dwExeNameLen != 0, "GetModuleFileNameW returned invalid value\n");
|
|
lstrcpynW(sExePath, sExeName, StrRChrW(sExeName, NULL, '\\') - sExeName + 1);
|
|
bstrExeName = SysAllocString(sExeName);
|
|
ok(bstrExeName != NULL, "cannot allocate string for exe name\n");
|
|
bstrExePath = SysAllocString(sExePath);
|
|
ok(bstrExePath != NULL, "cannot allocate string for exe path\n");
|
|
|
|
if(bstrExeName && bstrExePath)
|
|
{
|
|
trace("prepared EXE name: %s\n", wine_dbgstr_w(bstrExeName));
|
|
trace("prepared EXE path: %s\n", wine_dbgstr_w(bstrExePath));
|
|
|
|
|
|
/* try to register game with provided guid */
|
|
memcpy(&guid, &defaultGUID, sizeof (guid));
|
|
|
|
hr = IGameExplorer_AddGame(ge, bstrExeName, bstrExePath, GIS_CURRENT_USER, &guid);
|
|
ok(SUCCEEDED(hr), "IGameExplorer::AddGame failed (error 0x%08x)\n", hr);
|
|
ok(memcmp(&guid, &defaultGUID, sizeof (guid)) == 0, "AddGame unexpectedly modified GUID\n");
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
_validateGameRegistryKey(__LINE__, GIS_CURRENT_USER, &guid, &applicationId, sExePath, sExeName, TRUE);
|
|
|
|
hr = IGameExplorer_RemoveGame(ge, guid);
|
|
ok(SUCCEEDED(hr), "IGameExplorer::RemoveGame failed (error 0x%08x)\n", hr);
|
|
}
|
|
|
|
_validateGameRegistryKey(__LINE__, GIS_CURRENT_USER, &guid, &applicationId, sExePath, sExeName, FALSE);
|
|
|
|
|
|
/* try to register game with empty guid */
|
|
memcpy(&guid, &GUID_NULL, sizeof (guid));
|
|
|
|
hr = IGameExplorer_AddGame(ge, bstrExeName, bstrExePath, GIS_CURRENT_USER, &guid);
|
|
ok(SUCCEEDED(hr), "IGameExplorer::AddGame failed (error 0x%08x)\n", hr);
|
|
ok(memcmp(&guid, &GUID_NULL, sizeof (guid)) != 0, "AddGame did not modify GUID\n");
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
_validateGameRegistryKey(__LINE__, GIS_CURRENT_USER, &guid, &applicationId, sExePath, sExeName, TRUE);
|
|
|
|
hr = IGameExplorer_RemoveGame(ge, guid);
|
|
ok(SUCCEEDED(hr), "IGameExplorer::RemoveGame failed (error 0x%08x)\n", hr);
|
|
}
|
|
|
|
_validateGameRegistryKey(__LINE__, GIS_CURRENT_USER, &guid, &applicationId, sExePath, sExeName, FALSE);
|
|
}
|
|
|
|
/* free allocated resources */
|
|
SysFreeString(bstrExePath);
|
|
SysFreeString(bstrExeName);
|
|
|
|
IGameExplorer_Release(ge);
|
|
}
|
|
}
|
|
|
|
static void test_install_uninstall_game(void)
|
|
{
|
|
static const GUID applicationId = { 0x17A6558E, 0x60BE, 0x4078,
|
|
{ 0xB6, 0x6F, 0x9C, 0x3A, 0xDA, 0x2A, 0x32, 0xE6 }};
|
|
|
|
HRESULT hr;
|
|
|
|
IGameExplorer2* ge2 = NULL;
|
|
WCHAR sExeName[MAX_PATH];
|
|
WCHAR sExePath[MAX_PATH];
|
|
DWORD dwExeNameLen;
|
|
GUID guid;
|
|
|
|
hr = CoCreateInstance(&CLSID_GameExplorer, NULL, CLSCTX_INPROC_SERVER, &IID_IGameExplorer2, (LPVOID*)&ge2);
|
|
ok(ge2 != NULL, "cannot create coclass IGameExplorer2\n");
|
|
ok(hr == S_OK, "cannot create coclass IGameExplorer2\n");
|
|
|
|
if(ge2)
|
|
{
|
|
/* prepare path to binary */
|
|
dwExeNameLen = GetModuleFileNameW(NULL, sExeName, sizeof (sExeName) / sizeof (sExeName[0]));
|
|
ok(dwExeNameLen != 0, "GetModuleFileNameW returned invalid value\n");
|
|
lstrcpynW(sExePath, sExeName, StrRChrW(sExeName, NULL, '\\') - sExeName + 1);
|
|
|
|
trace("prepared EXE name: %s\n", wine_dbgstr_w(sExeName));
|
|
trace("prepared EXE path: %s\n", wine_dbgstr_w(sExePath));
|
|
|
|
|
|
hr = IGameExplorer2_InstallGame(ge2, sExeName, sExePath, GIS_CURRENT_USER);
|
|
ok(SUCCEEDED(hr), "IGameExplorer2::InstallGame failed (error 0x%08x)\n", hr);
|
|
/* in comparison to AddGame, InstallGame does not return instance ID,
|
|
* so we need to find it manually */
|
|
_findGameInstanceId(__LINE__, sExeName, GIS_CURRENT_USER, &guid);
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
_validateGameRegistryKey(__LINE__, GIS_CURRENT_USER, &guid, &applicationId, sExePath, sExeName, TRUE);
|
|
|
|
hr = IGameExplorer2_UninstallGame(ge2, sExeName);
|
|
ok(SUCCEEDED(hr), "IGameExplorer2::UninstallGame failed (error 0x%08x)\n", hr);
|
|
}
|
|
|
|
_validateGameRegistryKey(__LINE__, GIS_CURRENT_USER, &guid, &applicationId, sExePath, sExeName, FALSE);
|
|
|
|
IGameExplorer2_Release(ge2);
|
|
}
|
|
}
|
|
|
|
static void run_tests(void)
|
|
{
|
|
BOOL gameExplorerAvailable = FALSE;
|
|
BOOL gameExplorer2Available = FALSE;
|
|
|
|
test_create(&gameExplorerAvailable, &gameExplorer2Available);
|
|
|
|
if(gameExplorerAvailable)
|
|
test_add_remove_game();
|
|
|
|
if(gameExplorer2Available)
|
|
test_install_uninstall_game();
|
|
}
|
|
|
|
START_TEST(gameexplorer)
|
|
{
|
|
if(_loadDynamicRoutines())
|
|
{
|
|
HRESULT hr;
|
|
|
|
hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
|
|
ok(hr == S_OK, "Failed to initialize COM, hr %#x.\n", hr);
|
|
trace("Running multithreaded tests.\n");
|
|
run_tests();
|
|
if(SUCCEEDED(hr))
|
|
CoUninitialize();
|
|
|
|
hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
|
|
ok(hr == S_OK, "Failed to initialize COM, hr %#x.\n", hr);
|
|
trace("Running apartment threaded tests.\n");
|
|
run_tests();
|
|
if(SUCCEEDED(hr))
|
|
CoUninitialize();
|
|
}
|
|
else
|
|
/* this is not a failure, because both procedures loaded by address
|
|
* are always available on systems which has gameux.dll */
|
|
win_skip("too old system, cannot load required dynamic procedures\n");
|
|
}
|