Sweden-Number/dlls/gameux/tests/gameexplorer.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");
}