| /* |
| * 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"); |
| } |
