dlls/sapi/tests/token.c

   1 /*
   2  * Speech API (SAPI) token tests.
   3  *
   4  * Copyright (C) 2017 Huw Davies
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include "initguid.h"
  24 #include "sapiddk.h"
  25 #include "sperror.h"
  26
  27 #include "wine/test.h"
  28
  29 static void test_data_key(void)
  30 {
  31     ISpRegDataKey *data_key;
  32     ISpDataKey *sub;
  33     HRESULT hr;
  34     HKEY key;
  35     LONG res;
  36     WCHAR *value = NULL;
  37
  38     hr = CoCreateInstance( &CLSID_SpDataKey, NULL, CLSCTX_INPROC_SERVER,
  39                            &IID_ISpRegDataKey, (void **)&data_key );
  40     ok( hr == S_OK, "got %08lx\n", hr );
  41
  42     res = RegCreateKeyExA( HKEY_CURRENT_USER, "Software\\Winetest\\sapi", 0, NULL, 0, KEY_ALL_ACCESS,
  43                            NULL, &key, NULL );
  44     ok( res == ERROR_SUCCESS, "got %ld\n", res );
  45
  46     hr = ISpRegDataKey_CreateKey( data_key, L"Testing", &sub );
  47     ok( hr == E_HANDLE, "got %08lx\n", hr );
  48
  49     hr = ISpRegDataKey_GetStringValue( data_key, L"Voice", &value );
  50     ok( hr == E_HANDLE, "got %08lx\n", hr );
  51
  52     hr = ISpRegDataKey_SetStringValue( data_key, L"Voice", L"Test" );
  53     ok( hr == E_HANDLE, "got %08lx\n", hr );
  54
  55     hr = ISpRegDataKey_SetKey( data_key, key, FALSE );
  56     ok( hr == S_OK, "got %08lx\n", hr );
  57     hr = ISpRegDataKey_SetKey( data_key, key, FALSE );
  58     ok( hr == SPERR_ALREADY_INITIALIZED, "got %08lx\n", hr );
  59
  60     hr = ISpRegDataKey_GetStringValue( data_key, L"Voice", &value );
  61     ok( hr == SPERR_NOT_FOUND, "got %08lx\n", hr );
  62
  63     hr = ISpRegDataKey_GetStringValue( data_key, L"", &value );
  64     ok( hr == SPERR_NOT_FOUND, "got %08lx\n", hr );
  65
  66     hr = ISpRegDataKey_SetStringValue( data_key, L"Voice", L"Test" );
  67     ok( hr == S_OK, "got %08lx\n", hr );
  68
  69     hr = ISpRegDataKey_GetStringValue( data_key, L"Voice", &value );
  70     ok( hr == S_OK, "got %08lx\n", hr );
  71     ok( !wcscmp( value, L"Test" ), "got %s\n", wine_dbgstr_w(value) );
  72     CoTaskMemFree( value );
  73
  74     hr = ISpRegDataKey_OpenKey( data_key, L"Testing", &sub );
  75     ok( hr == SPERR_NOT_FOUND, "got %08lx\n", hr );
  76
  77     hr = ISpRegDataKey_CreateKey( data_key, L"Testing", &sub );
  78     ok( hr == S_OK, "got %08lx\n", hr );
  79     ISpDataKey_Release(sub);
  80
  81     hr = ISpRegDataKey_OpenKey( data_key, L"Testing", &sub );
  82     ok( hr == S_OK, "got %08lx\n", hr );
  83     ISpDataKey_Release(sub);
  84
  85     ISpRegDataKey_Release( data_key );
  86
  87     hr = CoCreateInstance( &CLSID_SpDataKey, NULL, CLSCTX_INPROC_SERVER,
  88                            &IID_ISpRegDataKey, (void **)&data_key );
  89     ok( hr == S_OK, "got %08lx\n", hr );
  90
  91     res = RegOpenKeyExA( HKEY_CURRENT_USER, "Software\\Winetest\\sapi", 0, KEY_ALL_ACCESS, &key );
  92     ok( res == ERROR_SUCCESS, "got %ld\n", res );
  93
  94     hr = ISpRegDataKey_SetKey( data_key, key, TRUE );
  95     ok( hr == S_OK, "got %08lx\n", hr );
  96
  97     hr = ISpRegDataKey_SetStringValue( data_key, L"Voice2", L"Test2" );
  98     ok( hr == S_OK, "got %08lx\n", hr );
  99
 100     hr = ISpRegDataKey_GetStringValue( data_key, L"Voice2", &value );
 101     ok( hr == S_OK, "got %08lx\n", hr );
 102     ok( !wcscmp( value, L"Test2" ), "got %s\n", wine_dbgstr_w(value) );
 103     CoTaskMemFree( value );
 104
 105     hr = ISpRegDataKey_CreateKey( data_key, L"Testing2", &sub );
 106     ok( hr == S_OK, "got %08lx\n", hr );
 107     ISpDataKey_Release(sub);
 108
 109     ISpRegDataKey_Release( data_key );
 110 }
 111
 112 static void test_token_category(void)
 113 {
 114     ISpObjectTokenCategory *cat;
 115     IEnumSpObjectTokens *enum_tokens;
 116     HRESULT hr;
 117     ULONG count;
 118
 119     hr = CoCreateInstance( &CLSID_SpObjectTokenCategory, NULL, CLSCTX_INPROC_SERVER,
 120                            &IID_ISpObjectTokenCategory, (void **)&cat );
 121     ok( hr == S_OK, "got %08lx\n", hr );
 122
 123     hr = ISpObjectTokenCategory_EnumTokens( cat, NULL, NULL, &enum_tokens );
 124     ok( hr == SPERR_UNINITIALIZED, "got %08lx\n", hr );
 125
 126     hr = ISpObjectTokenCategory_SetId( cat, L"bogus", FALSE );
 127     ok( hr == SPERR_INVALID_REGISTRY_KEY, "got %08lx\n", hr );
 128
 129     hr = ISpObjectTokenCategory_SetId( cat, SPCAT_VOICES, FALSE );
 130     ok( hr == S_OK, "got %08lx\n", hr );
 131
 132     hr = ISpObjectTokenCategory_SetId( cat, SPCAT_VOICES, FALSE );
 133     ok( hr == SPERR_ALREADY_INITIALIZED, "got %08lx\n", hr );
 134
 135     hr = ISpObjectTokenCategory_EnumTokens( cat, NULL, NULL, &enum_tokens );
 136     ok( hr == S_OK, "got %08lx\n", hr );
 137
 138     hr = IEnumSpObjectTokens_GetCount( enum_tokens, &count );
 139     ok( hr == S_OK, "got %08lx\n", hr );
 140
 141     IEnumSpObjectTokens_Release( enum_tokens );
 142     ISpObjectTokenCategory_Release( cat );
 143 }
 144
 145 static void test_token_enum(void)
 146 {
 147     ISpObjectTokenEnumBuilder *token_enum;
 148     HRESULT hr;
 149     ISpObjectToken *token;
 150     ULONG count;
 151
 152     hr = CoCreateInstance( &CLSID_SpObjectTokenEnum, NULL, CLSCTX_INPROC_SERVER,
 153                            &IID_ISpObjectTokenEnumBuilder, (void **)&token_enum );
 154     ok( hr == S_OK, "got %08lx\n", hr );
 155
 156     hr = ISpObjectTokenEnumBuilder_GetCount( token_enum, &count );
 157     ok( hr == SPERR_UNINITIALIZED, "got %08lx\n", hr );
 158
 159     hr = ISpObjectTokenEnumBuilder_Next( token_enum, 1, &token, &count );
 160     ok( hr == SPERR_UNINITIALIZED, "got %08lx\n", hr );
 161
 162     hr = ISpObjectTokenEnumBuilder_SetAttribs( token_enum, NULL, NULL );
 163     ok( hr == S_OK, "got %08lx\n", hr );
 164
 165     count = 0xdeadbeef;
 166     hr = ISpObjectTokenEnumBuilder_GetCount( token_enum, &count );
 167     ok( hr == S_OK, "got %08lx\n", hr );
 168     ok( count == 0, "got %lu\n", count );
 169
 170     count = 0xdeadbeef;
 171     hr = ISpObjectTokenEnumBuilder_Next( token_enum, 1, &token, &count );
 172     ok( hr == S_FALSE, "got %08lx\n", hr );
 173     ok( count == 0, "got %lu\n", count );
 174
 175     ISpObjectTokenEnumBuilder_Release( token_enum );
 176 }
 177
 178 static void test_default_token_id(void)
 179 {
 180     ISpObjectTokenCategory *cat;
 181     HRESULT hr;
 182     LPWSTR token_id = NULL;
 183     LONG res;
 184     WCHAR regvalue[512];
 185     DWORD regvalue_size;
 186
 187     hr = CoCreateInstance( &CLSID_SpObjectTokenCategory, NULL, CLSCTX_INPROC_SERVER,
 188                            &IID_ISpObjectTokenCategory, (void **)&cat );
 189     ok( hr == S_OK, "got %08lx\n", hr );
 190
 191     token_id = (LPWSTR)0xdeadbeef;
 192     hr = ISpObjectTokenCategory_GetDefaultTokenId( cat, &token_id );
 193     ok( hr == SPERR_UNINITIALIZED, "got %08lx\n", hr );
 194     ok( token_id == (LPWSTR)0xdeadbeef, "got %p\n", token_id );
 195
 196     hr = ISpObjectTokenCategory_GetDefaultTokenId( cat, NULL );
 197     ok( hr == SPERR_UNINITIALIZED, "got %08lx\n", hr );
 198
 199     hr = ISpObjectTokenCategory_SetId( cat, SPCAT_AUDIOOUT, FALSE );
 200     ok( hr == S_OK, "got %08lx\n", hr );
 201
 202     hr = ISpObjectTokenCategory_GetDefaultTokenId( cat, NULL );
 203     ok( hr == E_POINTER, "got %08lx\n", hr );
 204
 205     token_id = (LPWSTR)0xdeadbeef;
 206     hr = ISpObjectTokenCategory_GetDefaultTokenId( cat, &token_id );
 207
 208     /* AudioOutput under windows server returns this error */
 209     if (hr == SPERR_NOT_FOUND) {
 210         /* also happens if TokenEnums/Tokens is empty or doesn't exist */
 211         skip( "AudioOutput category not found for GetDefaultTokenId\n" );
 212         return;
 213     }
 214
 215     ok( hr == S_OK, "got %08lx\n", hr );
 216     ok( token_id != (LPWSTR)0xdeadbeef && token_id != NULL, "got %p\n", token_id );
 217
 218     regvalue_size = sizeof( regvalue );
 219     res = RegGetValueW( HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Speech\\AudioOutput",
 220                         L"DefaultDefaultTokenId", RRF_RT_REG_SZ, NULL,
 221                         (LPVOID)&regvalue, &regvalue_size);
 222     if (res == ERROR_FILE_NOT_FOUND) {
 223         skip( "DefaultDefaultTokenId not found for AudioOutput category (%s)\n",
 224               wine_dbgstr_w(token_id) );
 225     } else {
 226         ok( res == ERROR_SUCCESS, "got %08lx\n", res );
 227         ok( !wcscmp(regvalue, token_id),
 228             "GetDefaultTokenId (%s) should be equal to the DefaultDefaultTokenId key (%s)\n",
 229             wine_dbgstr_w(token_id), wine_dbgstr_w(regvalue) );
 230     }
 231
 232     CoTaskMemFree( token_id );
 233     ISpObjectTokenCategory_Release( cat );
 234 }
 235
 236 static void tests_token_voices(void)
 237 {
 238     ISpObjectTokenCategory *cat;
 239     HRESULT hr;
 240     IEnumSpObjectTokens *tokens;
 241     ISpObjectToken *item;
 242     ULONG fetched = 0;
 243     ULONG count;
 244
 245     hr = CoCreateInstance( &CLSID_SpObjectTokenCategory, NULL, CLSCTX_INPROC_SERVER,
 246                            &IID_ISpObjectTokenCategory, (void **)&cat );
 247     ok( hr == S_OK, "got %08lx\n", hr );
 248
 249     hr = ISpObjectTokenCategory_SetId( cat, SPCAT_VOICES, FALSE );
 250     ok( hr == S_OK, "got %08lx\n", hr );
 251
 252     hr = ISpObjectTokenCategory_EnumTokens(cat, NULL, NULL, &tokens);
 253     ok( hr == S_OK, "got %08lx\n", hr );
 254
 255     hr = IEnumSpObjectTokens_GetCount( tokens, &count );
 256     ok( hr == S_OK, "got %08lx\n", hr );
 257     ok( count != 0, "got %lu\n", count );
 258     ISpObjectTokenCategory_Release( cat );
 259
 260     hr = IEnumSpObjectTokens_Item(tokens, 0, &item);
 261     ok( hr == S_OK, "got %08lx\n", hr );
 262     ISpObjectToken_Release(item);
 263
 264     hr = IEnumSpObjectTokens_Next(tokens, 1, &item, &fetched);
 265     ok( hr == S_OK, "got %08lx\n", hr );
 266     ISpObjectToken_Release(item);
 267
 268     IEnumSpObjectTokens_Release(tokens);
 269 }
 270
 271
 272 #define TESTCLASS_CLSID L"{67DD26B6-50BA-3297-253E-619346F177F8}"
 273 static const GUID CLSID_TestClass = {0x67DD26B6,0x50BA,0x3297,{0x25,0x3E,0x61,0x93,0x46,0xF1,0x77,0xF8}};
 274
 275 static ISpObjectToken *test_class_token;
 276
 277 static HRESULT WINAPI test_class_QueryInterface(ISpObjectWithToken *iface, REFIID riid, void **ppv)
 278 {
 279     if (IsEqualGUID( riid, &IID_IUnknown ) || IsEqualGUID( riid, &IID_ISpObjectWithToken ))
 280     {
 281         *ppv = iface;
 282         return S_OK;
 283     }
 284
 285     *ppv = NULL;
 286     return E_NOINTERFACE;
 287 }
 288
 289 static ULONG WINAPI test_class_AddRef(ISpObjectWithToken *iface)
 290 {
 291     return 2;
 292 }
 293
 294 static ULONG WINAPI test_class_Release(ISpObjectWithToken *iface)
 295 {
 296     return 1;
 297 }
 298
 299 static HRESULT WINAPI test_class_SetObjectToken(ISpObjectWithToken *iface, ISpObjectToken *token)
 300 {
 301     ok( token != NULL, "token == NULL\n" );
 302     test_class_token = token;
 303     ISpObjectToken_AddRef(test_class_token);
 304     return S_OK;
 305 }
 306
 307 static HRESULT WINAPI test_class_GetObjectToken(ISpObjectWithToken *iface, ISpObjectToken **token)
 308 {
 309     ok( 0, "unexpected call\n" );
 310     return E_NOTIMPL;
 311 }
 312
 313 static const ISpObjectWithTokenVtbl test_class_vtbl = {
 314     test_class_QueryInterface,
 315     test_class_AddRef,
 316     test_class_Release,
 317     test_class_SetObjectToken,
 318     test_class_GetObjectToken
 319 };
 320
 321 static ISpObjectWithToken test_class = { &test_class_vtbl };
 322
 323 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 324 {
 325     if (IsEqualGUID( &IID_IUnknown, riid ) || IsEqualGUID( &IID_IClassFactory, riid ))
 326     {
 327         *ppv = iface;
 328         return S_OK;
 329     }
 330
 331     *ppv = NULL;
 332     return E_NOINTERFACE;
 333 }
 334
 335 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 336 {
 337     return 2;
 338 }
 339
 340 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 341 {
 342     return 1;
 343 }
 344
 345 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface,
 346         IUnknown *pUnkOuter, REFIID riid, void **ppv)
 347 {
 348     ok( pUnkOuter == NULL, "pUnkOuter != NULL\n" );
 349     ok( IsEqualGUID(riid, &IID_IUnknown), "riid = %s\n", wine_dbgstr_guid(riid) );
 350
 351     *ppv = &test_class;
 352     return S_OK;
 353 }
 354
 355 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL fLock)
 356 {
 357     ok( 0, "unexpected call\n" );
 358     return E_NOTIMPL;
 359 }
 360
 361 static const IClassFactoryVtbl ClassFactoryVtbl = {
 362     ClassFactory_QueryInterface,
 363     ClassFactory_AddRef,
 364     ClassFactory_Release,
 365     ClassFactory_CreateInstance,
 366     ClassFactory_LockServer
 367 };
 368
 369 static IClassFactory test_class_cf = { &ClassFactoryVtbl };
 370
 371 static void test_object_token(void)
 372 {
 373     static const WCHAR test_token_id[] = L"HKEY_CURRENT_USER\\Software\\Winetest\\sapi\\TestToken";
 374
 375     ISpObjectToken *token;
 376     ISpDataKey *sub_key;
 377     HRESULT hr;
 378     LPWSTR tempW, token_id;
 379     ISpObjectTokenCategory *cat;
 380     DWORD regid;
 381     IUnknown *obj;
 382
 383     hr = CoCreateInstance( &CLSID_SpObjectToken, NULL, CLSCTX_INPROC_SERVER,
 384                            &IID_ISpObjectToken, (void **)&token );
 385     ok( hr == S_OK, "got %08lx\n", hr );
 386
 387     hr = ISpObjectToken_GetId( token, NULL );
 388     ok( hr == SPERR_UNINITIALIZED, "got %08lx\n", hr );
 389
 390     tempW = (LPWSTR)0xdeadbeef;
 391     hr = ISpObjectToken_GetId( token, &tempW );
 392     ok( hr == SPERR_UNINITIALIZED, "got %08lx\n", hr );
 393     ok( tempW == (LPWSTR)0xdeadbeef, "got %s\n", wine_dbgstr_w(tempW) );
 394
 395     hr = ISpObjectToken_GetCategory( token, NULL );
 396     todo_wine ok( hr == SPERR_UNINITIALIZED, "got %08lx\n", hr );
 397
 398     cat = (LPVOID)0xdeadbeef;
 399     hr = ISpObjectToken_GetCategory( token, &cat );
 400     todo_wine ok( hr == SPERR_UNINITIALIZED, "got %08lx\n", hr );
 401     ok( cat == (LPVOID)0xdeadbeef, "got %p\n", cat );
 402
 403     hr = ISpObjectToken_SetId( token, NULL, NULL, FALSE );
 404     ok( hr == E_POINTER, "got %08lx\n", hr );
 405     hr = ISpObjectToken_SetId( token, L"bogus", NULL, FALSE );
 406     ok( hr == E_POINTER, "got %08lx\n", hr );
 407
 408     hr = ISpObjectToken_SetId( token, NULL, L"bogus", FALSE );
 409     ok( hr == SPERR_NOT_FOUND, "got %08lx\n", hr );
 410     hr = ISpObjectToken_SetId( token, NULL, L"HKEY_LOCAL_MACHINE\\SOFTWARE\\winetest bogus", FALSE );
 411     ok( hr == SPERR_NOT_FOUND, "got %08lx\n", hr );
 412
 413     /* SetId succeeds even if the key is invalid, but exists */
 414     hr = ISpObjectToken_SetId( token, NULL, L"HKEY_LOCAL_MACHINE\\SOFTWARE", FALSE );
 415     ok( hr == S_OK, "got %08lx\n", hr );
 416
 417     hr = ISpObjectToken_SetId( token, NULL, NULL, FALSE );
 418     ok( hr == SPERR_ALREADY_INITIALIZED, "got %08lx\n", hr );
 419     hr = ISpObjectToken_SetId( token, NULL, L"bogus", FALSE );
 420     ok( hr == SPERR_ALREADY_INITIALIZED, "got %08lx\n", hr );
 421
 422     hr = ISpObjectToken_GetId( token, NULL );
 423     ok( hr == E_POINTER, "got %08lx\n", hr );
 424
 425     hr = ISpObjectToken_GetCategory( token, NULL );
 426     todo_wine ok( hr == E_POINTER, "got %08lx\n", hr );
 427
 428     tempW = NULL;
 429     hr = ISpObjectToken_GetId( token, &tempW );
 430     ok( hr == S_OK, "got %08lx\n", hr );
 431     ok( tempW != NULL, "got %p\n", tempW );
 432     if (tempW) {
 433         ok( !wcscmp(tempW, L"HKEY_LOCAL_MACHINE\\SOFTWARE"), "got %s\n",
 434             wine_dbgstr_w(tempW) );
 435         CoTaskMemFree( tempW );
 436     }
 437
 438     hr = ISpObjectToken_OpenKey(token, L"Non-exist", &sub_key);
 439     ok( hr == SPERR_NOT_FOUND, "got %08lx\n", hr );
 440
 441     hr = ISpObjectToken_OpenKey(token, L"Classes", &sub_key);
 442     ok( hr == S_OK, "got %08lx\n", hr );
 443     ISpDataKey_Release(sub_key);
 444
 445     cat = (LPVOID)0xdeadbeef;
 446     hr = ISpObjectToken_GetCategory( token, &cat );
 447     todo_wine ok( hr == SPERR_INVALID_REGISTRY_KEY, "got %08lx\n", hr );
 448     ok( cat == (LPVOID)0xdeadbeef, "got %p\n", cat );
 449
 450     /* get the default token id for SPCAT_AUDIOOUT */
 451     hr = CoCreateInstance( &CLSID_SpObjectTokenCategory, NULL, CLSCTX_INPROC_SERVER,
 452                            &IID_ISpObjectTokenCategory, (void **)&cat );
 453     ok( hr == S_OK, "got %08lx\n", hr );
 454     hr = ISpObjectTokenCategory_SetId( cat, SPCAT_AUDIOOUT, FALSE );
 455     ok( hr == S_OK, "got %08lx\n", hr );
 456     token_id = (LPWSTR)0xdeadbeef;
 457     hr = ISpObjectTokenCategory_GetDefaultTokenId( cat, &token_id );
 458     if (hr == SPERR_NOT_FOUND) {
 459         skip( "AudioOutput category not found for GetDefaultTokenId\n" );
 460         return;
 461     }
 462     ok( hr == S_OK, "got %08lx\n", hr );
 463     ok( token_id != (LPWSTR)0xdeadbeef && token_id != NULL, "got %p\n", token_id );
 464     ISpObjectTokenCategory_Release( cat );
 465
 466     /* recreate token in order to SetId again */
 467     ISpObjectToken_Release( token );
 468     hr = CoCreateInstance( &CLSID_SpObjectToken, NULL, CLSCTX_INPROC_SERVER,
 469                            &IID_ISpObjectToken, (void **)&token );
 470     ok( hr == S_OK, "got %08lx\n", hr );
 471
 472     /* NULL appears to auto-detect the category */
 473     hr = ISpObjectToken_SetId( token, NULL, token_id, FALSE );
 474     ok( hr == S_OK, "got %08lx\n", hr );
 475
 476     tempW = NULL;
 477     hr = ISpObjectToken_GetId( token, &tempW );
 478     ok( hr == S_OK, "got %08lx\n", hr );
 479     ok( tempW != NULL, "got %p\n", tempW );
 480     if (tempW) {
 481         ok( !wcsncmp(tempW, token_id, wcslen(token_id)),
 482             "got %s (expected %s)\n", wine_dbgstr_w(tempW), wine_dbgstr_w(token_id) );
 483         CoTaskMemFree( tempW );
 484     }
 485
 486     cat = (LPVOID)0xdeadbeef;
 487     hr = ISpObjectToken_GetCategory( token, &cat );
 488     todo_wine ok( hr == S_OK, "got %08lx\n", hr );
 489     todo_wine ok( cat != (LPVOID)0xdeadbeef, "got %p\n", cat );
 490     if (cat != (LPVOID)0xdeadbeef) {
 491         tempW = NULL;
 492         hr = ISpObjectTokenCategory_GetId( cat, &tempW );
 493         todo_wine ok( hr == S_OK, "got %08lx\n", hr );
 494         todo_wine ok( tempW != NULL, "got %p\n", tempW );
 495         if (tempW) {
 496             ok( !wcscmp(tempW, SPCAT_AUDIOOUT), "got %s\n", wine_dbgstr_w(tempW) );
 497             CoTaskMemFree( tempW );
 498         }
 499
 500         /* not freed by ISpObjectToken_Release */
 501         ISpObjectTokenCategory_Release( cat );
 502     }
 503
 504     hr = CoRegisterClassObject( &CLSID_TestClass, (IUnknown *)&test_class_cf,
 505                                 CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid );
 506     ok( hr == S_OK, "got %08lx\n", hr );
 507
 508     ISpObjectToken_Release( token );
 509     hr = CoCreateInstance( &CLSID_SpObjectToken, NULL, CLSCTX_INPROC_SERVER,
 510                            &IID_ISpObjectToken, (void **)&token );
 511     ok( hr == S_OK, "got %08lx\n", hr );
 512
 513     hr = ISpObjectToken_SetId( token, NULL, test_token_id, TRUE );
 514     ok( hr == S_OK, "got %08lx\n", hr );
 515
 516     hr = ISpObjectToken_CreateKey( token, L"Attributes", &sub_key );
 517     ok( hr == S_OK, "got %08lx\n", hr );
 518     ISpDataKey_Release( sub_key );
 519
 520     hr = ISpObjectToken_SetStringValue( token, L"CLSID", TESTCLASS_CLSID );
 521     ok( hr == S_OK, "got %08lx\n", hr );
 522
 523     tempW = NULL;
 524     hr = ISpObjectToken_GetStringValue( token, L"CLSID", &tempW );
 525
 526     ok( hr == S_OK, "got %08lx\n", hr );
 527     if ( tempW ) {
 528         ok( !wcsncmp( tempW, TESTCLASS_CLSID, wcslen(TESTCLASS_CLSID) ),
 529             "got %s (expected %s)\n", wine_dbgstr_w(tempW), wine_dbgstr_w(TESTCLASS_CLSID) );
 530         CoTaskMemFree( tempW );
 531     }
 532
 533     test_class_token = NULL;
 534     hr = ISpObjectToken_CreateInstance( token, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)&obj );
 535     if ( hr == E_ACCESSDENIED ) {
 536         win_skip( "ISpObjectToken_CreateInstance returned E_ACCESSDENIED\n" );
 537         return;
 538     }
 539     ok( hr == S_OK, "got %08lx\n", hr );
 540     ok( test_class_token != NULL, "test_class_token not set\n" );
 541
 542     tempW = NULL;
 543     hr = ISpObjectToken_GetId( test_class_token, &tempW );
 544     ok( tempW != NULL, "got %p\n", tempW );
 545     if (tempW) {
 546         ok( !wcsncmp(tempW, test_token_id, wcslen(test_token_id)),
 547             "got %s (expected %s)\n", wine_dbgstr_w(tempW), wine_dbgstr_w(test_token_id) );
 548         CoTaskMemFree( tempW );
 549     }
 550
 551     ISpObjectToken_Release( test_class_token );
 552     IUnknown_Release( obj );
 553     ISpObjectToken_Release( token );
 554 }
 555
 556 START_TEST(token)
 557 {
 558     CoInitialize( NULL );
 559     RegDeleteTreeA( HKEY_CURRENT_USER, "Software\\Winetest\\sapi" );
 560     test_data_key();
 561     test_token_category();
 562     test_token_enum();
 563     test_default_token_id();
 564     test_object_token();
 565     tests_token_voices();
 566     CoUninitialize();
 567 }