?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
makefiles: Explicitly create destination dirs when installing symlinks.
[wine/zf.git] / dlls / wbemprox / tests / query.c
blob7ba55dffdfb46d59a768f54a6370224d913daa58
1 /*
2 * Copyright 2012 Hans Leidekker for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #define COBJMACROS
20
21 #include <stdio.h>
22 #include "windows.h"
23 #include "ocidl.h"
24 #include "sddl.h"
25 #include "initguid.h"
26 #include "objidl.h"
27 #include "wbemcli.h"
28 #include "wine/heap.h"
29 #include "wine/test.h"
30
31 static HRESULT exec_query( IWbemServices *services, const WCHAR *str, IEnumWbemClassObject **result )
32 {
33 HRESULT hr;
34 IWbemClassObject *obj;
35 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( str );
36 LONG flags = WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY;
37 ULONG count;
38
39 hr = IWbemServices_ExecQuery( services, wql, query, flags, NULL, result );
40 if (hr == S_OK)
41 {
42 trace("%s\n", wine_dbgstr_w(str));
43 for (;;)
44 {
45 VARIANT var;
46 IWbemQualifierSet *qualifiers;
47 SAFEARRAY *names;
48
49 IEnumWbemClassObject_Next( *result, 10000, 1, &obj, &count );
50 if (!count) break;
51
52 if (IWbemClassObject_Get( obj, L"Caption", 0, &var, NULL, NULL ) == WBEM_S_NO_ERROR)
53 {
54 trace("caption: %s\n", wine_dbgstr_w(V_BSTR(&var)));
55 VariantClear( &var );
56 }
57 if (IWbemClassObject_Get( obj, L"Description", 0, &var, NULL, NULL ) == WBEM_S_NO_ERROR)
58 {
59 trace("description: %s\n", wine_dbgstr_w(V_BSTR(&var)));
60 VariantClear( &var );
61 }
62
63 hr = IWbemClassObject_GetQualifierSet( obj, &qualifiers );
64 ok( hr == S_OK, "got %08x\n", hr );
65
66 hr = IWbemQualifierSet_GetNames( qualifiers, 0, &names );
67 ok( hr == S_OK, "got %08x\n", hr );
68
69 SafeArrayDestroy( names );
70 IWbemQualifierSet_Release( qualifiers );
71 IWbemClassObject_Release( obj );
72 }
73 }
74 SysFreeString( wql );
75 SysFreeString( query );
76 return hr;
77 }
78
79 static void test_select( IWbemServices *services )
80 {
81 static const WCHAR *test[] =
82 {
83 L"SELECT HOTFIXID FROM Win32_QuickFixEngineering",
84 L"SELECT * FROM Win32_BIOS",
85 L"SELECT * FROM Win32_LogicalDisk WHERE \"NTFS\" = FileSystem",
86 L"SELECT a FROM b",
87 L"SELECT a FROM Win32_Bios",
88 L"SELECT Description FROM Win32_Bios",
89 L"SELECT * FROM Win32_Process WHERE Caption LIKE '%%REGEDIT%'",
90 L"SELECT * FROM Win32_DiskDrive WHERE DeviceID=\"\\\\\\\\.\\\\PHYSICALDRIVE0\"",
91 L"SELECT\na\rFROM\tb",
92 L"SELECT * FROM Win32_Process WHERE Caption LIKE \"%firefox.exe\"",
93 L"SELECT * FROM Win32_VideoController where availability = '3'",
94 L"SELECT * FROM Win3_BIOS WHERE NAME <> NULL",
95 L"SELECT * FROM Win32_BIOS WHERE NULL = NAME",
96 L"SELECT * FROM Win32_LogicalDiskToPartition",
97 L"SELECT * FROM Win32_DiskDriveToDiskPartition",
98 };
99 HRESULT hr;
100 IEnumWbemClassObject *result;
101 BSTR wql = SysAllocString( L"wql" );
102 BSTR sql = SysAllocString( L"SQL" );
103 BSTR query = SysAllocString( L"SELECT * FROM Win32_BIOS" );
104 UINT i;
105
106 hr = IWbemServices_ExecQuery( services, NULL, NULL, 0, NULL, &result );
107 ok( hr == WBEM_E_INVALID_PARAMETER, "query failed %08x\n", hr );
108
109 hr = IWbemServices_ExecQuery( services, NULL, query, 0, NULL, &result );
110 ok( hr == WBEM_E_INVALID_PARAMETER, "query failed %08x\n", hr );
111
112 hr = IWbemServices_ExecQuery( services, wql, NULL, 0, NULL, &result );
113 ok( hr == WBEM_E_INVALID_PARAMETER, "query failed %08x\n", hr );
114
115 hr = IWbemServices_ExecQuery( services, sql, query, 0, NULL, &result );
116 ok( hr == WBEM_E_INVALID_QUERY_TYPE, "query failed %08x\n", hr );
117
118 hr = IWbemServices_ExecQuery( services, sql, NULL, 0, NULL, &result );
119 ok( hr == WBEM_E_INVALID_PARAMETER, "query failed %08x\n", hr );
120
121 SysFreeString( query );
122 query = SysAllocString( L"" );
123 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
124 ok( hr == WBEM_E_INVALID_PARAMETER, "query failed %08x\n", hr );
125
126 for (i = 0; i < ARRAY_SIZE( test ); i++)
127 {
128 hr = exec_query( services, test[i], &result );
129 ok( hr == S_OK, "query %u failed: %08x\n", i, hr );
130 if (result) IEnumWbemClassObject_Release( result );
131 }
132
133 SysFreeString( wql );
134 SysFreeString( sql );
135 SysFreeString( query );
136 }
137
138 static void test_associators( IWbemServices *services )
139 {
140 static const WCHAR *test[] =
141 {
142 L"ASSOCIATORS OF{Win32_LogicalDisk.DeviceID=\"C:\"}",
143 L"ASSOCIATORS OF {Win32_LogicalDisk.DeviceID=\"C:\"} WHERE AssocClass=Win32_LogicalDiskToPartition",
144 L"ASSOCIATORS OF {Win32_LogicalDisk.DeviceID}",
145 L"ASSOCIATORS OF {Win32_DiskDrive.DeviceID='\\\\.\\PHYSICALDRIVE0'}",
146 L"ASSOCIATORS OF {Win32_LogicalDisk.DeviceID=\"C:\"} WHERE AssocClass=Win32_LogicalDiskToPartition ClassDefsOnly",
147 L"ASSOCIATORS OF {Win32_LogicalDisk.DeviceID=\"C:\"} WHERE ClassDefsOnly",
148 L"ASSOCIATORS OF {Win32_LogicalDisk.DeviceID=\"C:\"} WHERE ClassDefsOnly AssocClass = Win32_LogicalDiskToPartition",
149 };
150 HRESULT hr;
151 IEnumWbemClassObject *result;
152 UINT i;
153
154 for (i = 0; i < ARRAY_SIZE( test ); i++)
155 {
156 hr = exec_query( services, test[i], &result );
157 ok( hr == S_OK, "query %u failed: %08x\n", i, hr );
158 if (result) IEnumWbemClassObject_Release( result );
159 }
160 }
161
162 static void test_IEnumWbemClassObject_Next( IWbemServices *services )
163 {
164 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_IP4RouteTable" );
165 IWbemClassObject **obj, *obj1;
166 IEnumWbemClassObject *result;
167 DWORD count, num_objects = 0;
168 HRESULT hr;
169 int i;
170
171 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
172 ok( hr == S_OK, "got %08x\n", hr );
173
174 count = 2;
175 hr = IEnumWbemClassObject_Next( result, 10000, 1, NULL, &count );
176 ok( hr == WBEM_E_INVALID_PARAMETER, "got %08x\n", hr );
177 ok( count == 2, "expected 0, got %u\n", count );
178
179 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj1, NULL );
180 ok( hr == WBEM_E_INVALID_PARAMETER, "got %08x\n", hr );
181
182 count = 2;
183 hr = IEnumWbemClassObject_Next( result, 10000, 0, &obj1, &count );
184 ok( hr == S_OK, "got %08x\n", hr );
185 ok( count == 0, "expected 0, got %u\n", count );
186
187 for (;;)
188 {
189 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj1, &count );
190 if (hr != S_OK) break;
191 num_objects++;
192 IWbemClassObject_Release(obj1);
193 }
194
195 hr = IEnumWbemClassObject_Reset( result );
196 ok( hr == S_OK, "got %08x\n", hr );
197
198 obj = heap_alloc( num_objects * sizeof( IWbemClassObject * ) );
199
200 count = 0;
201 hr = IEnumWbemClassObject_Next( result, 10000, num_objects, obj, &count );
202 ok( hr == S_OK, "got %08x\n", hr );
203 ok( count == num_objects, "expected %u, got %u\n", num_objects, count );
204
205 for (i = 0; i < count; i++)
206 IWbemClassObject_Release( obj[i] );
207
208 hr = IEnumWbemClassObject_Reset( result );
209 ok( hr == S_OK, "got %08x\n", hr );
210
211 count = 0;
212 hr = IEnumWbemClassObject_Next( result, 10000, num_objects + 1, obj, &count );
213 ok( hr == S_FALSE, "got %08x\n", hr );
214 ok( count == num_objects, "expected %u, got %u\n", num_objects, count );
215
216 for (i = 0; i < count; i++)
217 IWbemClassObject_Release( obj[i] );
218
219 heap_free( obj );
220
221 IEnumWbemClassObject_Release( result );
222 SysFreeString( query );
223 SysFreeString( wql );
224 }
225
226 static void _check_property( ULONG line, IWbemClassObject *obj, const WCHAR *prop, VARTYPE vartype, CIMTYPE cimtype )
227 {
228 CIMTYPE type = 0xdeadbeef;
229 VARIANT val;
230 HRESULT hr;
231
232 VariantInit( &val );
233 hr = IWbemClassObject_Get( obj, prop, 0, &val, &type, NULL );
234 ok( hr == S_OK, "%u: failed to get description %08x\n", line, hr );
235 ok( V_VT( &val ) == vartype, "%u: unexpected variant type 0x%x\n", line, V_VT(&val) );
236 ok( type == cimtype, "%u: unexpected type 0x%x\n", line, type );
237 switch (V_VT(&val))
238 {
239 case VT_BSTR:
240 trace( "%s: %s\n", wine_dbgstr_w(prop), wine_dbgstr_w(V_BSTR(&val)) );
241 break;
242 case VT_I2:
243 trace( "%s: %d\n", wine_dbgstr_w(prop), V_I2(&val) );
244 break;
245 case VT_I4:
246 trace( "%s: %d\n", wine_dbgstr_w(prop), V_I4(&val) );
247 break;
248 case VT_R4:
249 trace( "%s: %f\n", wine_dbgstr_w(prop), V_R4(&val) );
250 break;
251 default:
252 break;
253 }
254 VariantClear( &val );
255 }
256 #define check_property(a,b,c,d) _check_property(__LINE__,a,b,c,d)
257
258 static void test_Win32_Service( IWbemServices *services )
259 {
260 BSTR class = SysAllocString( L"Win32_Service.Name=\"Spooler\"" ), empty = SysAllocString( L"" ), method;
261 IWbemClassObject *service, *out;
262 VARIANT state, retval, classvar;
263 CIMTYPE type;
264 HRESULT hr;
265
266 hr = IWbemServices_GetObject( services, class, 0, NULL, &service, NULL );
267 if (hr != S_OK)
268 {
269 win_skip( "Win32_Service not available\n" );
270 SysFreeString( empty );
271 SysFreeString( class );
272 return;
273 }
274
275 check_property( service, L"ProcessID", VT_I4, CIM_UINT32 );
276 type = 0xdeadbeef;
277 VariantInit( &state );
278 hr = IWbemClassObject_Get( service, L"State", 0, &state, &type, NULL );
279 ok( hr == S_OK, "failed to get service state %08x\n", hr );
280 ok( V_VT( &state ) == VT_BSTR, "unexpected variant type 0x%x\n", V_VT( &state ) );
281 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
282
283 if (!lstrcmpW( V_BSTR( &state ), L"Stopped" ))
284 {
285 out = NULL;
286 method = SysAllocString( L"StartService" );
287 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, NULL, &out, NULL );
288 ok( hr == S_OK, "failed to execute method %08x\n", hr );
289 SysFreeString( method );
290
291 VariantInit( &retval );
292 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, NULL, NULL );
293 ok( hr == S_OK, "failed to get return value %08x\n", hr );
294 ok( !V_I4( &retval ), "unexpected error %u\n", V_UI4( &retval ) );
295 IWbemClassObject_Release( out );
296 }
297 out = NULL;
298 method = SysAllocString( L"PauseService" );
299 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, NULL, &out, NULL );
300 ok( hr == S_OK, "failed to execute method %08x\n", hr );
301 SysFreeString( method );
302
303 VariantInit( &retval );
304 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, NULL, NULL );
305 ok( hr == S_OK, "failed to get return value %08x\n", hr );
306 ok( V_I4( &retval ), "unexpected success\n" );
307 IWbemClassObject_Release( out );
308
309 out = NULL;
310 method = SysAllocString( L"ResumeService" );
311 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, NULL, &out, NULL );
312 ok( hr == S_OK, "failed to execute method %08x\n", hr );
313 SysFreeString( method );
314
315 VariantInit( &retval );
316 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, NULL, NULL );
317 ok( hr == S_OK, "failed to get return value %08x\n", hr );
318 ok( V_I4( &retval ), "unexpected success\n" );
319 IWbemClassObject_Release( out );
320
321 if (!lstrcmpW( V_BSTR( &state ), L"Stopped" ))
322 {
323 out = NULL;
324 method = SysAllocString( L"StopService" );
325 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, NULL, &out, NULL );
326 ok( hr == S_OK, "failed to execute method %08x\n", hr );
327 SysFreeString( method );
328
329 VariantInit( &retval );
330 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, NULL, NULL );
331 ok( hr == S_OK, "failed to get return value %08x\n", hr );
332 ok( !V_I4( &retval ), "unexpected error %u\n", V_UI4( &retval ) );
333 IWbemClassObject_Release( out );
334 }
335 VariantClear( &state );
336 IWbemClassObject_Release( service );
337
338 service = NULL;
339 hr = IWbemServices_GetObject( services, NULL, 0, NULL, &service, NULL );
340 ok( hr == S_OK, "got %08x\n", hr );
341 ok( !!service, "expected non-NULL service\n" );
342
343 VariantInit(&classvar);
344 V_VT(&classvar) = VT_BSTR;
345 V_BSTR(&classvar) = SysAllocString(L"MyClass");
346 hr = IWbemClassObject_Put(service, L"__CLASS", 0, &classvar, 0);
347 ok( hr == S_OK, "got %08x\n", hr );
348 VariantClear(&classvar);
349 IWbemClassObject_Release( service );
350
351 service = NULL;
352 hr = IWbemServices_GetObject( services, empty, 0, NULL, &service, NULL );
353 ok( hr == S_OK, "got %08x\n", hr );
354 ok( !!service, "expected non-NULL service\n" );
355 IWbemClassObject_Release( service );
356
357 SysFreeString( empty );
358 SysFreeString( class );
359
360 class = SysAllocString( L"Win32_Service.Name=\"nonexistent\"" );
361 service = (IWbemClassObject *)0xdeadbeef;
362 hr = IWbemServices_GetObject( services, class, 0, NULL, &service, NULL );
363 ok( hr == WBEM_E_NOT_FOUND, "got %#08x\n", hr );
364 ok( service == NULL, "expected NULL service, got %p\n", service );
365 SysFreeString( class );
366 }
367
368 static void test_Win32_Bios( IWbemServices *services )
369 {
370 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_BIOS" );
371 IEnumWbemClassObject *result;
372 IWbemClassObject *obj;
373 CIMTYPE type;
374 ULONG count;
375 VARIANT val;
376 HRESULT hr;
377
378 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
379 ok( hr == S_OK, "IWbemServices_ExecQuery failed %08x\n", hr );
380
381 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
382 ok( hr == S_OK, "IEnumWbemClassObject_Next failed %08x\n", hr );
383
384 check_property( obj, L"Description", VT_BSTR, CIM_STRING );
385 check_property( obj, L"IdentificationCode", VT_NULL, CIM_STRING );
386 check_property( obj, L"Manufacturer", VT_BSTR, CIM_STRING );
387 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
388 check_property( obj, L"ReleaseDate", VT_BSTR, CIM_DATETIME );
389
390 type = 0xdeadbeef;
391 VariantInit( &val );
392 hr = IWbemClassObject_Get( obj, L"SerialNumber", 0, &val, &type, NULL );
393 ok( hr == S_OK, "failed to get serial number %08x\n", hr );
394 ok( V_VT( &val ) == VT_BSTR || V_VT( &val ) == VT_NULL /* Testbot VMs */,
395 "unexpected variant type 0x%x\n", V_VT( &val ) );
396 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
397 VariantClear( &val );
398
399 check_property( obj, L"SMBIOSBIOSVersion", VT_BSTR, CIM_STRING );
400 check_property( obj, L"SMBIOSMajorVersion", VT_I4, CIM_UINT16 );
401 check_property( obj, L"SMBIOSMinorVersion", VT_I4, CIM_UINT16 );
402 check_property( obj, L"Version", VT_BSTR, CIM_STRING );
403
404 IWbemClassObject_Release( obj );
405 IEnumWbemClassObject_Release( result );
406 SysFreeString( query );
407 SysFreeString( wql );
408 }
409
410 static void test_Win32_Baseboard( IWbemServices *services )
411 {
412 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_Baseboard" );
413 IEnumWbemClassObject *result;
414 IWbemClassObject *obj;
415 CIMTYPE type;
416 ULONG count;
417 VARIANT val;
418 HRESULT hr;
419
420 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
421 ok( hr == S_OK, "IWbemServices_ExecQuery failed %08x\n", hr );
422
423 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
424 if (hr != S_OK)
425 {
426 win_skip( "Win32_Baseboard not available\n" );
427 return;
428 }
429 ok( hr == S_OK, "IEnumWbemClassObject_Next failed %08x\n", hr );
430
431 check_property( obj, L"Manufacturer", VT_BSTR, CIM_STRING );
432
433 type = 0xdeadbeef;
434 VariantInit( &val );
435 hr = IWbemClassObject_Get( obj, L"Model", 0, &val, &type, NULL );
436 ok( hr == S_OK, "failed to get model %08x\n", hr );
437 ok( V_VT( &val ) == VT_BSTR || V_VT( &val ) == VT_NULL, "unexpected variant type 0x%x\n", V_VT( &val ) );
438 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
439 trace( "model: %s\n", wine_dbgstr_w(V_BSTR(&val)) );
440 VariantClear( &val );
441
442 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
443 check_property( obj, L"Product", VT_BSTR, CIM_STRING );
444 check_property( obj, L"Tag", VT_BSTR, CIM_STRING );
445 check_property( obj, L"Version", VT_BSTR, CIM_STRING );
446
447 IWbemClassObject_Release( obj );
448 IEnumWbemClassObject_Release( result );
449 SysFreeString( query );
450 SysFreeString( wql );
451 }
452
453 static void test_Win32_Process( IWbemServices *services, BOOL use_full_path )
454 {
455 static const LONG expected_flavor = WBEM_FLAVOR_FLAG_PROPAGATE_TO_INSTANCE |
456 WBEM_FLAVOR_NOT_OVERRIDABLE |
457 WBEM_FLAVOR_ORIGIN_PROPAGATED;
458 WCHAR full_path[MAX_COMPUTERNAME_LENGTH + ARRAY_SIZE( L"\\\\%s\\ROOT\\CIMV2:" )];
459 BSTR class, method;
460 IWbemClassObject *process, *sig_in, *out;
461 IWbemQualifierSet *qualifiers;
462 VARIANT retval, val;
463 SAFEARRAY *names;
464 LONG bound, i;
465 DWORD full_path_len = 0;
466 LONG flavor;
467 CIMTYPE type;
468 HRESULT hr;
469
470 if (use_full_path)
471 {
472 WCHAR server[MAX_COMPUTERNAME_LENGTH+1];
473
474 full_path_len = ARRAY_SIZE(server);
475 ok( GetComputerNameW(server, &full_path_len), "GetComputerName failed\n" );
476 full_path_len = wsprintfW( full_path, L"\\\\%s\\ROOT\\CIMV2:", server );
477 }
478
479 class = SysAllocStringLen( NULL, full_path_len + ARRAY_SIZE( L"Win32_Process" ) );
480 memcpy( class, full_path, full_path_len * sizeof(WCHAR) );
481 memcpy( class + full_path_len, L"Win32_Process", sizeof(L"Win32_Process") );
482 hr = IWbemServices_GetObject( services, class, 0, NULL, &process, NULL );
483 SysFreeString( class );
484 if (hr != S_OK)
485 {
486 win_skip( "Win32_Process not available\n" );
487 return;
488 }
489 names = NULL;
490 hr = IWbemClassObject_GetNames( process, NULL, 0, NULL, &names );
491 ok( hr == S_OK, "got %08x\n", hr );
492 ok( names != NULL, "names not set\n" );
493 hr = SafeArrayGetUBound( names, 1, &bound );
494 ok( hr == S_OK, "got %08x\n", hr );
495 for (i = 0; i <= bound; i++)
496 {
497 BSTR str;
498 hr = SafeArrayGetElement( names, &i, &str );
499 ok( hr == S_OK, "%d: got %08x\n", i, hr );
500 SysFreeString( str );
501 }
502 SafeArrayDestroy( names );
503
504 sig_in = (void*)0xdeadbeef;
505 hr = IWbemClassObject_GetMethod( process, L"GetOwner", 0, &sig_in, NULL );
506 ok( hr == S_OK, "failed to get GetOwner method %08x\n", hr );
507 ok( !sig_in, "sig_in != NULL\n");
508 IWbemClassObject_Release( process );
509
510 out = NULL;
511 method = SysAllocString( L"GetOwner" );
512 class = SysAllocStringLen( NULL, full_path_len + ARRAY_SIZE( L"Win32_Process.Handle=\"%u\"" ) + 10 );
513 memcpy( class, full_path, full_path_len * sizeof(WCHAR) );
514 wsprintfW( class + full_path_len, L"Win32_Process.Handle=\"%u\"", GetCurrentProcessId() );
515 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, NULL, &out, NULL );
516 ok( hr == S_OK, "failed to execute method %08x\n", hr );
517 SysFreeString( method );
518 SysFreeString( class );
519
520 type = 0xdeadbeef;
521 VariantInit( &retval );
522 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, &type, NULL );
523 ok( hr == S_OK, "failed to get return value %08x\n", hr );
524 ok( V_VT( &retval ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &retval ) );
525 ok( !V_I4( &retval ), "unexpected error %u\n", V_I4( &retval ) );
526 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
527
528 check_property( out, L"User", VT_BSTR, CIM_STRING );
529 check_property( out, L"Domain", VT_BSTR, CIM_STRING );
530
531 hr = IWbemClassObject_GetPropertyQualifierSet( out, L"User", &qualifiers );
532 ok( hr == S_OK, "failed to get qualifier set %08x\n", hr );
533
534 flavor = -1;
535 V_I4(&val) = -1;
536 V_VT(&val) = VT_ERROR;
537 hr = IWbemQualifierSet_Get( qualifiers, L"ID", 0, &val, &flavor );
538 ok( hr == S_OK, "got %08x\n", hr );
539 ok( flavor == expected_flavor, "got %d\n", flavor );
540 ok( V_VT(&val) == VT_I4, "got %u\n", V_VT(&val) );
541 ok( V_I4(&val) == 0, "got %u\n", V_I4(&val) );
542 VariantClear( &val );
543
544 IWbemQualifierSet_Release( qualifiers );
545 hr = IWbemClassObject_GetPropertyQualifierSet( out, L"Domain", &qualifiers );
546 ok( hr == S_OK, "failed to get qualifier set %08x\n", hr );
547
548 flavor = -1;
549 V_I4(&val) = -1;
550 V_VT(&val) = VT_ERROR;
551 hr = IWbemQualifierSet_Get( qualifiers, L"ID", 0, &val, &flavor );
552 ok( hr == S_OK, "got %08x\n", hr );
553 ok( flavor == expected_flavor, "got %d\n", flavor );
554 ok( V_VT(&val) == VT_I4, "got %u\n", V_VT(&val) );
555 ok( V_I4(&val) == 1, "got %u\n", V_I4(&val) );
556 VariantClear( &val );
557
558 IWbemQualifierSet_Release( qualifiers );
559 hr = IWbemClassObject_GetPropertyQualifierSet( out, L"ReturnValue", &qualifiers );
560 ok( hr == S_OK, "failed to get qualifier set %08x\n", hr );
561
562 hr = IWbemQualifierSet_Get( qualifiers, L"ID", 0, &val, &flavor );
563 ok( hr == WBEM_E_NOT_FOUND, "got %08x\n", hr );
564
565 IWbemQualifierSet_Release( qualifiers );
566 IWbemClassObject_Release( out );
567 }
568
569 static void test_Win32_ComputerSystem( IWbemServices *services )
570 {
571 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_ComputerSystem" );
572 IEnumWbemClassObject *result;
573 IWbemClassObject *obj;
574 VARIANT value;
575 CIMTYPE type;
576 HRESULT hr;
577 WCHAR compname[MAX_COMPUTERNAME_LENGTH + 1];
578 WCHAR username[128];
579 DWORD len, count;
580
581 len = ARRAY_SIZE( compname );
582 if (!GetComputerNameW( compname, &len ))
583 compname[0] = 0;
584
585 lstrcpyW( username, compname );
586 lstrcatW( username, L"\\" );
587 len = ARRAY_SIZE( username ) - lstrlenW( username );
588 if (!GetUserNameW( username + lstrlenW( username ), &len ))
589 username[0] = 0;
590
591 if (!compname[0] || !username[0])
592 {
593 skip( "Failed to get user or computer name\n" );
594 goto out;
595 }
596
597 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
598 if (hr != S_OK)
599 {
600 win_skip( "Win32_ComputerSystem not available\n" );
601 goto out;
602 }
603
604 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
605 ok( hr == S_OK, "got %08x\n", hr );
606
607 type = 0xdeadbeef;
608 VariantInit( &value );
609 hr = IWbemClassObject_Get( obj, L"MemoryType", 0, &value, &type, NULL );
610 ok( hr == WBEM_E_NOT_FOUND, "got %08x\n", hr );
611
612 check_property( obj, L"Model", VT_BSTR, CIM_STRING );
613
614 type = 0xdeadbeef;
615 VariantInit( &value );
616 hr = IWbemClassObject_Get( obj, L"Name", 0, &value, &type, NULL );
617 ok( hr == S_OK, "failed to get computer name %08x\n", hr );
618 ok( V_VT( &value ) == VT_BSTR, "unexpected variant type 0x%x\n", V_VT( &value ) );
619 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
620 ok( !lstrcmpiW( V_BSTR( &value ), compname ), "got %s, expected %s\n", wine_dbgstr_w(V_BSTR(&value)), wine_dbgstr_w(compname) );
621 VariantClear( &value );
622
623 type = 0xdeadbeef;
624 VariantInit( &value );
625 hr = IWbemClassObject_Get( obj, L"NumberOfLogicalProcessors", 0, &value, &type, NULL );
626 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND) /* win2k3 */, "got %08x\n", hr );
627 if (hr == S_OK)
628 {
629 ok( V_VT( &value ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &value ) );
630 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
631 trace( "numlogicalprocessors %u\n", V_I4( &value ) );
632 }
633
634 check_property( obj, L"NumberOfProcessors", VT_I4, CIM_UINT32 );
635
636 type = 0xdeadbeef;
637 VariantInit( &value );
638 hr = IWbemClassObject_Get( obj, L"UserName", 0, &value, &type, NULL );
639 ok( hr == S_OK, "failed to get computer name %08x\n", hr );
640 ok( V_VT( &value ) == VT_BSTR, "unexpected variant type 0x%x\n", V_VT( &value ) );
641 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
642 ok( !lstrcmpiW( V_BSTR( &value ), username ), "got %s, expected %s\n", wine_dbgstr_w(V_BSTR(&value)), wine_dbgstr_w(username) );
643 VariantClear( &value );
644
645 IWbemClassObject_Release( obj );
646 IEnumWbemClassObject_Release( result );
647 out:
648 SysFreeString( query );
649 SysFreeString( wql );
650 }
651
652 static void test_Win32_SystemEnclosure( IWbemServices *services )
653 {
654 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_SystemEnclosure" );
655 IEnumWbemClassObject *result;
656 IWbemClassObject *obj;
657 CIMTYPE type;
658 ULONG count;
659 VARIANT val;
660 DWORD *data;
661 HRESULT hr;
662
663 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
664 ok( hr == S_OK, "IWbemServices_ExecQuery failed %08x\n", hr );
665
666 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
667 ok( hr == S_OK, "IEnumWbemClassObject_Next failed %08x\n", hr );
668
669 check_property( obj, L"Caption", VT_BSTR, CIM_STRING );
670
671 type = 0xdeadbeef;
672 VariantInit( &val );
673 hr = IWbemClassObject_Get( obj, L"ChassisTypes", 0, &val, &type, NULL );
674 ok( hr == S_OK, "failed to get chassis types %08x\n", hr );
675 ok( V_VT( &val ) == (VT_I4|VT_ARRAY), "unexpected variant type 0x%x\n", V_VT( &val ) );
676 ok( type == (CIM_UINT16|CIM_FLAG_ARRAY), "unexpected type 0x%x\n", type );
677 hr = SafeArrayAccessData( V_ARRAY( &val ), (void **)&data );
678 ok( hr == S_OK, "SafeArrayAccessData failed %x\n", hr );
679 if (SUCCEEDED(hr))
680 {
681 LONG i, lower, upper;
682
683 hr = SafeArrayGetLBound( V_ARRAY( &val ), 1, &lower );
684 ok( hr == S_OK, "SafeArrayGetLBound failed %x\n", hr );
685 hr = SafeArrayGetUBound( V_ARRAY( &val ), 1, &upper );
686 ok( hr == S_OK, "SafeArrayGetUBound failed %x\n", hr );
687 if (V_VT( &val ) == (VT_I4|VT_ARRAY))
688 {
689 for (i = 0; i < upper - lower + 1; i++)
690 trace( "chassis type: %u\n", data[i] );
691 }
692 hr = SafeArrayUnaccessData( V_ARRAY( &val ) );
693 ok( hr == S_OK, "SafeArrayUnaccessData failed %x\n", hr );
694 }
695 VariantClear( &val );
696
697 check_property( obj, L"Description", VT_BSTR, CIM_STRING );
698 check_property( obj, L"LockPresent", VT_BOOL, CIM_BOOLEAN );
699 check_property( obj, L"Manufacturer", VT_BSTR, CIM_STRING );
700 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
701 check_property( obj, L"Tag", VT_BSTR, CIM_STRING );
702
703 IWbemClassObject_Release( obj );
704 IEnumWbemClassObject_Release( result );
705 SysFreeString( query );
706 SysFreeString( wql );
707 }
708
709 static void test_StdRegProv( IWbemServices *services )
710 {
711 BSTR class = SysAllocString( L"StdRegProv" ), method, name;
712 IWbemClassObject *reg, *sig_in, *sig_out, *in, *out;
713 VARIANT defkey, subkey, retval, valuename;
714 CIMTYPE type;
715 HRESULT hr;
716 LONG res;
717
718 hr = IWbemServices_GetObject( services, class, 0, NULL, &reg, NULL );
719 if (hr != S_OK)
720 {
721 win_skip( "StdRegProv not available\n" );
722 return;
723 }
724
725 hr = IWbemClassObject_BeginMethodEnumeration( reg, 0 );
726 ok( hr == S_OK, "got %08x\n", hr );
727
728 while (IWbemClassObject_NextMethod( reg, 0, &name, &sig_in, &sig_out ) == S_OK)
729 {
730 SysFreeString( name );
731 IWbemClassObject_Release( sig_in );
732 IWbemClassObject_Release( sig_out );
733 }
734
735 hr = IWbemClassObject_EndMethodEnumeration( reg );
736 ok( hr == S_OK, "got %08x\n", hr );
737
738 hr = IWbemClassObject_BeginEnumeration( reg, 0 );
739 ok( hr == S_OK, "got %08x\n", hr );
740
741 while (IWbemClassObject_Next( reg, 0, &name, NULL, NULL, NULL ) == S_OK)
742 SysFreeString( name );
743
744 hr = IWbemClassObject_EndEnumeration( reg );
745 ok( hr == S_OK, "got %08x\n", hr );
746
747 hr = IWbemClassObject_GetMethod( reg, L"CreateKey", 0, &sig_in, NULL );
748 ok( hr == S_OK, "failed to get CreateKey method %08x\n", hr );
749
750 hr = IWbemClassObject_SpawnInstance( sig_in, 0, &in );
751 ok( hr == S_OK, "failed to spawn instance %08x\n", hr );
752
753 V_VT( &defkey ) = VT_I4;
754 V_I4( &defkey ) = 0x80000001;
755 hr = IWbemClassObject_Put( in, L"hDefKey", 0, &defkey, 0 );
756 ok( hr == S_OK, "failed to set root %08x\n", hr );
757
758 V_VT( &subkey ) = VT_BSTR;
759 V_BSTR( &subkey ) = SysAllocString( L"Software\\StdRegProvTest" );
760 hr = IWbemClassObject_Put( in, L"sSubKeyName", 0, &subkey, 0 );
761 ok( hr == S_OK, "failed to set subkey %08x\n", hr );
762
763 out = NULL;
764 method = SysAllocString( L"CreateKey" );
765 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, in, &out, NULL );
766 ok( hr == S_OK, "failed to execute method %08x\n", hr );
767 SysFreeString( method );
768
769 type = 0xdeadbeef;
770 VariantInit( &retval );
771 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, &type, NULL );
772 ok( hr == S_OK, "failed to get return value %08x\n", hr );
773 ok( V_VT( &retval ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &retval ) );
774 ok( !V_I4( &retval ), "unexpected error %u\n", V_UI4( &retval ) );
775 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
776
777 res = RegDeleteKeyW( HKEY_CURRENT_USER, L"Software\\StdRegProvTest" );
778 ok( !res, "got %d\n", res );
779
780 VariantClear( &subkey );
781 IWbemClassObject_Release( in );
782 IWbemClassObject_Release( out );
783 IWbemClassObject_Release( sig_in );
784
785 hr = IWbemClassObject_GetMethod( reg, L"EnumKey", 0, &sig_in, NULL );
786 ok( hr == S_OK, "failed to get EnumKey method %08x\n", hr );
787
788 hr = IWbemClassObject_SpawnInstance( sig_in, 0, &in );
789 ok( hr == S_OK, "failed to spawn instance %08x\n", hr );
790
791 V_VT( &defkey ) = VT_I4;
792 V_I4( &defkey ) = 0x80000002;
793 hr = IWbemClassObject_Put( in, L"hDefKey", 0, &defkey, 0 );
794 ok( hr == S_OK, "failed to set root %08x\n", hr );
795
796 V_VT( &subkey ) = VT_BSTR;
797 V_BSTR( &subkey ) = SysAllocString( L"Software\\microsoft\\Windows\\CurrentVersion" );
798 hr = IWbemClassObject_Put( in, L"sSubKeyName", 0, &subkey, 0 );
799 ok( hr == S_OK, "failed to set subkey %08x\n", hr );
800
801 out = NULL;
802 method = SysAllocString( L"EnumKey" );
803 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, in, &out, NULL );
804 ok( hr == S_OK, "failed to execute method %08x\n", hr );
805 SysFreeString( method );
806
807 type = 0xdeadbeef;
808 VariantInit( &retval );
809 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, &type, NULL );
810 ok( hr == S_OK, "failed to get return value %08x\n", hr );
811 ok( V_VT( &retval ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &retval ) );
812 ok( !V_I4( &retval ), "unexpected error %u\n", V_UI4( &retval ) );
813 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
814
815 check_property( out, L"sNames", VT_BSTR|VT_ARRAY, CIM_STRING|CIM_FLAG_ARRAY );
816
817 VariantClear( &subkey );
818 IWbemClassObject_Release( in );
819 IWbemClassObject_Release( out );
820 IWbemClassObject_Release( sig_in );
821
822 hr = IWbemClassObject_GetMethod( reg, L"EnumValues", 0, &sig_in, NULL );
823 ok( hr == S_OK, "failed to get EnumValues method %08x\n", hr );
824
825 hr = IWbemClassObject_SpawnInstance( sig_in, 0, &in );
826 ok( hr == S_OK, "failed to spawn instance %08x\n", hr );
827
828 V_VT( &defkey ) = VT_I4;
829 V_I4( &defkey ) = 0x80000002;
830 hr = IWbemClassObject_Put( in, L"hDefKey", 0, &defkey, 0 );
831 ok( hr == S_OK, "failed to set root %08x\n", hr );
832
833 V_VT( &subkey ) = VT_BSTR;
834 V_BSTR( &subkey ) = SysAllocString( L"Software\\microsoft\\Windows\\CurrentVersion" );
835 hr = IWbemClassObject_Put( in, L"sSubKeyName", 0, &subkey, 0 );
836 ok( hr == S_OK, "failed to set subkey %08x\n", hr );
837
838 out = NULL;
839 method = SysAllocString( L"EnumValues" );
840 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, in, &out, NULL );
841 ok( hr == S_OK, "failed to execute method %08x\n", hr );
842 SysFreeString( method );
843
844 type = 0xdeadbeef;
845 VariantInit( &retval );
846 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, &type, NULL );
847 ok( hr == S_OK, "failed to get return value %08x\n", hr );
848 ok( V_VT( &retval ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &retval ) );
849 ok( !V_I4( &retval ), "unexpected error %u\n", V_I4( &retval ) );
850 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
851
852 check_property( out, L"sNames", VT_BSTR|VT_ARRAY, CIM_STRING|CIM_FLAG_ARRAY );
853 check_property( out, L"Types", VT_I4|VT_ARRAY, CIM_SINT32|CIM_FLAG_ARRAY );
854
855 VariantClear( &subkey );
856 IWbemClassObject_Release( in );
857 IWbemClassObject_Release( out );
858 IWbemClassObject_Release( sig_in );
859
860 hr = IWbemClassObject_GetMethod( reg, L"GetStringValue", 0, &sig_in, NULL );
861 ok( hr == S_OK, "failed to get GetStringValue method %08x\n", hr );
862
863 hr = IWbemClassObject_SpawnInstance( sig_in, 0, &in );
864 ok( hr == S_OK, "failed to spawn instance %08x\n", hr );
865
866 V_VT( &defkey ) = VT_I4;
867 V_I4( &defkey ) = 0x80000002;
868 hr = IWbemClassObject_Put( in, L"hDefKey", 0, &defkey, 0 );
869 ok( hr == S_OK, "failed to set root %08x\n", hr );
870
871 V_VT( &subkey ) = VT_BSTR;
872 V_BSTR( &subkey ) = SysAllocString( L"Software\\microsoft\\Windows\\CurrentVersion" );
873 hr = IWbemClassObject_Put( in, L"sSubKeyName", 0, &subkey, 0 );
874 ok( hr == S_OK, "failed to set subkey %08x\n", hr );
875
876 V_VT( &valuename ) = VT_BSTR;
877 V_BSTR( &valuename ) = SysAllocString( L"ProgramFilesDir" );
878 hr = IWbemClassObject_Put( in, L"sValueName", 0, &valuename, 0 );
879 ok( hr == S_OK, "failed to set value name %08x\n", hr );
880
881 out = NULL;
882 method = SysAllocString( L"GetStringValue" );
883 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, in, &out, NULL );
884 ok( hr == S_OK, "failed to execute method %08x\n", hr );
885 SysFreeString( method );
886
887 type = 0xdeadbeef;
888 VariantInit( &retval );
889 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, &type, NULL );
890 ok( hr == S_OK, "failed to get return value %08x\n", hr );
891 ok( V_VT( &retval ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &retval ) );
892 ok( !V_I4( &retval ), "unexpected error %u\n", V_I4( &retval ) );
893 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
894
895 check_property( out, L"sValue", VT_BSTR, CIM_STRING );
896
897 VariantClear( &valuename );
898 VariantClear( &subkey );
899 IWbemClassObject_Release( in );
900 IWbemClassObject_Release( out );
901 IWbemClassObject_Release( sig_in );
902
903 IWbemClassObject_Release( reg );
904 SysFreeString( class );
905 }
906
907 static HRESULT WINAPI sink_QueryInterface(
908 IWbemObjectSink *iface, REFIID riid, void **ppv )
909 {
910 *ppv = NULL;
911 if (IsEqualGUID( &IID_IUnknown, riid ) || IsEqualGUID( &IID_IWbemObjectSink, riid ))
912 {
913 *ppv = iface;
914 IWbemObjectSink_AddRef( iface );
915 return S_OK;
916 }
917 return E_NOINTERFACE;
918 }
919
920 static ULONG sink_refs;
921
922 static ULONG WINAPI sink_AddRef(
923 IWbemObjectSink *iface )
924 {
925 return ++sink_refs;
926 }
927
928 static ULONG WINAPI sink_Release(
929 IWbemObjectSink *iface )
930 {
931 return --sink_refs;
932 }
933
934 static HRESULT WINAPI sink_Indicate(
935 IWbemObjectSink *iface, LONG count, IWbemClassObject **objects )
936 {
937 trace("Indicate: %d, %p\n", count, objects);
938 return S_OK;
939 }
940
941 static HRESULT WINAPI sink_SetStatus(
942 IWbemObjectSink *iface, LONG flags, HRESULT hresult, BSTR str_param, IWbemClassObject *obj_param )
943 {
944 trace("SetStatus: %08x, %08x, %s, %p\n", flags, hresult, wine_dbgstr_w(str_param), obj_param);
945 return S_OK;
946 }
947
948 static IWbemObjectSinkVtbl sink_vtbl =
949 {
950 sink_QueryInterface,
951 sink_AddRef,
952 sink_Release,
953 sink_Indicate,
954 sink_SetStatus
955 };
956
957 static IWbemObjectSink sink = { &sink_vtbl };
958
959 static void test_notification_query_async( IWbemServices *services )
960 {
961 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_DeviceChangeEvent" );
962 ULONG prev_sink_refs;
963 HRESULT hr;
964
965 hr = IWbemServices_ExecNotificationQueryAsync( services, wql, query, 0, NULL, NULL );
966 ok( hr == WBEM_E_INVALID_PARAMETER, "got %08x\n", hr );
967
968 prev_sink_refs = sink_refs;
969 hr = IWbemServices_ExecNotificationQueryAsync( services, wql, query, 0, NULL, &sink );
970 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND), "got %08x\n", hr );
971 ok( sink_refs > prev_sink_refs || broken(!sink_refs), "got %u refs\n", sink_refs );
972
973 hr = IWbemServices_CancelAsyncCall( services, &sink );
974 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND), "got %08x\n", hr );
975
976 SysFreeString( wql );
977 SysFreeString( query );
978 }
979
980 static void test_query_async( IWbemServices *services )
981 {
982 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_Process" );
983 HRESULT hr;
984
985 hr = IWbemServices_ExecQueryAsync( services, wql, query, 0, NULL, NULL );
986 ok( hr == WBEM_E_INVALID_PARAMETER, "got %08x\n", hr );
987
988 hr = IWbemServices_ExecQueryAsync( services, wql, query, 0, NULL, &sink );
989 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND), "got %08x\n", hr );
990
991 hr = IWbemServices_CancelAsyncCall( services, NULL );
992 ok( hr == WBEM_E_INVALID_PARAMETER, "got %08x\n", hr );
993
994 hr = IWbemServices_CancelAsyncCall( services, &sink );
995 ok( hr == S_OK, "got %08x\n", hr );
996
997 SysFreeString( wql );
998 SysFreeString( query );
999 }
1000
1001 static void test_query_semisync( IWbemServices *services )
1002 {
1003 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_Dummy" );
1004 IEnumWbemClassObject *result;
1005 IWbemClassObject *obj;
1006 ULONG count;
1007 HRESULT hr;
1008
1009 hr = IWbemServices_ExecQuery( services, wql, query, WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY,
1010 NULL, &result );
1011 ok( hr == S_OK, "got %08x\n", hr );
1012
1013 count = 1;
1014 obj = (void *)0xdeadbeef;
1015 hr = IEnumWbemClassObject_Next( result, -1, 1, &obj, &count );
1016 todo_wine
1017 ok( hr == WBEM_E_INVALID_CLASS, "Unexpected hr %#x.\n", hr );
1018 ok( count == 0, "Unexpected count %u.\n", count );
1019 ok( obj == (void *)0xdeadbeef, "Got object %p\n", obj );
1020
1021 IEnumWbemClassObject_Release( result );
1022
1023 SysFreeString( wql );
1024 SysFreeString( query );
1025 }
1026
1027 static void test_GetNames( IWbemServices *services )
1028 {
1029 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_OperatingSystem" );
1030 IEnumWbemClassObject *result;
1031 HRESULT hr;
1032
1033 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1034 ok( hr == S_OK, "got %08x\n", hr );
1035
1036 for (;;)
1037 {
1038 IWbemClassObject *obj;
1039 SAFEARRAY *names;
1040 ULONG count;
1041 VARIANT val;
1042
1043 IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1044 if (!count) break;
1045
1046 hr = IWbemClassObject_GetNames( obj, NULL, 0, NULL, NULL );
1047 ok( hr == WBEM_E_INVALID_PARAMETER, "got %08x\n", hr );
1048
1049 hr = IWbemClassObject_GetNames( obj, NULL, 0, NULL, &names );
1050 ok( hr == S_OK, "got %08x\n", hr );
1051 SafeArrayDestroy( names );
1052
1053 hr = IWbemClassObject_GetNames( obj, NULL, WBEM_FLAG_ALWAYS, NULL, &names );
1054 ok( hr == S_OK, "got %08x\n", hr );
1055 SafeArrayDestroy( names );
1056
1057 hr = IWbemClassObject_GetNames( obj, NULL, WBEM_FLAG_ALWAYS | WBEM_MASK_CONDITION_ORIGIN, NULL, &names );
1058 ok( hr == S_OK, "got %08x\n", hr );
1059 SafeArrayDestroy( names );
1060
1061 VariantInit( &val );
1062 hr = IWbemClassObject_GetNames( obj, NULL, WBEM_FLAG_NONSYSTEM_ONLY, &val, &names );
1063 ok( hr == S_OK, "got %08x\n", hr );
1064
1065 SafeArrayDestroy( names );
1066 IWbemClassObject_Release( obj );
1067 }
1068 IEnumWbemClassObject_Release( result );
1069 SysFreeString( query );
1070 SysFreeString( wql );
1071 }
1072
1073 static void test_SystemSecurity( IWbemServices *services )
1074 {
1075 BSTR class = SysAllocString( L"__SystemSecurity" ), method;
1076 IWbemClassObject *reg, *out;
1077 VARIANT retval, var_sd;
1078 void *data;
1079 SECURITY_DESCRIPTOR_RELATIVE *sd;
1080 CIMTYPE type;
1081 HRESULT hr;
1082 BYTE sid_admin_buffer[SECURITY_MAX_SID_SIZE];
1083 SID *sid_admin = (SID*)sid_admin_buffer;
1084 DWORD sid_size;
1085 BOOL ret;
1086
1087 hr = IWbemServices_GetObject( services, class, 0, NULL, &reg, NULL );
1088 if (hr != S_OK)
1089 {
1090 win_skip( "__SystemSecurity not available\n" );
1091 return;
1092 }
1093 IWbemClassObject_Release( reg );
1094
1095 sid_size = sizeof(sid_admin_buffer);
1096 ret = CreateWellKnownSid( WinBuiltinAdministratorsSid, NULL, sid_admin, &sid_size );
1097 ok( ret, "CreateWellKnownSid failed\n" );
1098
1099 out = NULL;
1100 method = SysAllocString( L"GetSD" );
1101 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, NULL, &out, NULL );
1102 ok( hr == S_OK || hr == WBEM_E_ACCESS_DENIED, "failed to execute method %08x\n", hr );
1103 SysFreeString( method );
1104
1105 if (SUCCEEDED(hr))
1106 {
1107 type = 0xdeadbeef;
1108 VariantInit( &retval );
1109 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, &type, NULL );
1110 ok( hr == S_OK, "failed to get return value %08x\n", hr );
1111 ok( V_VT( &retval ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &retval ) );
1112 ok( !V_I4( &retval ), "unexpected error %u\n", V_UI4( &retval ) );
1113 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
1114
1115 type = 0xdeadbeef;
1116 VariantInit( &var_sd );
1117 hr = IWbemClassObject_Get( out, L"SD", 0, &var_sd, &type, NULL );
1118 ok( hr == S_OK, "failed to get names %08x\n", hr );
1119 ok( V_VT( &var_sd ) == (VT_UI1|VT_ARRAY), "unexpected variant type 0x%x\n", V_VT( &var_sd ) );
1120 ok( type == (CIM_UINT8|CIM_FLAG_ARRAY), "unexpected type 0x%x\n", type );
1121
1122 hr = SafeArrayAccessData( V_ARRAY( &var_sd ), &data );
1123 ok( hr == S_OK, "SafeArrayAccessData failed %x\n", hr );
1124 if (SUCCEEDED(hr))
1125 {
1126 sd = data;
1127
1128 ok( (sd->Control & SE_SELF_RELATIVE) == SE_SELF_RELATIVE, "relative flag unset\n" );
1129 ok( sd->Owner != 0, "no owner SID\n");
1130 ok( sd->Group != 0, "no owner SID\n");
1131 ok( EqualSid( (PSID)((LPBYTE)sd + sd->Owner), sid_admin ), "unexpected owner SID\n" );
1132 ok( EqualSid( (PSID)((LPBYTE)sd + sd->Group), sid_admin ), "unexpected group SID\n" );
1133
1134 hr = SafeArrayUnaccessData( V_ARRAY( &var_sd ) );
1135 ok( hr == S_OK, "SafeArrayUnaccessData failed %x\n", hr );
1136 }
1137
1138 VariantClear( &var_sd );
1139 IWbemClassObject_Release( out );
1140 }
1141 else if (hr == WBEM_E_ACCESS_DENIED)
1142 win_skip( "insufficient privs to test __SystemSecurity\n" );
1143
1144 SysFreeString( class );
1145 }
1146
1147 static void test_Win32_OperatingSystem( IWbemServices *services )
1148 {
1149 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_OperatingSystem" );
1150 IEnumWbemClassObject *result;
1151 IWbemClassObject *obj;
1152 CIMTYPE type;
1153 ULONG count;
1154 VARIANT val;
1155 HRESULT hr;
1156
1157 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1158 ok( hr == S_OK, "IWbemServices_ExecQuery failed %08x\n", hr );
1159
1160 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1161 ok( hr == S_OK, "IEnumWbemClassObject_Next failed %08x\n", hr );
1162
1163 hr = IWbemClassObject_BeginEnumeration( obj, 0 );
1164 ok( hr == S_OK, "got %08x\n", hr );
1165
1166 while (IWbemClassObject_Next( obj, 0, NULL, NULL, NULL, NULL ) == S_OK) {}
1167
1168 hr = IWbemClassObject_EndEnumeration( obj );
1169 ok( hr == S_OK, "got %08x\n", hr );
1170
1171 check_property( obj, L"BuildNumber", VT_BSTR, CIM_STRING );
1172 check_property( obj, L"Caption", VT_BSTR, CIM_STRING );
1173
1174 type = 0xdeadbeef;
1175 VariantInit( &val );
1176 hr = IWbemClassObject_Get( obj, L"CSDVersion", 0, &val, &type, NULL );
1177 ok( hr == S_OK, "failed to get csdversion %08x\n", hr );
1178 ok( V_VT( &val ) == VT_BSTR || V_VT( &val ) == VT_NULL, "unexpected variant type 0x%x\n", V_VT( &val ) );
1179 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
1180 trace( "csdversion: %s\n", wine_dbgstr_w(V_BSTR( &val )) );
1181 VariantClear( &val );
1182
1183 check_property( obj, L"FreePhysicalMemory", VT_BSTR, CIM_UINT64 );
1184 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
1185
1186 type = 0xdeadbeef;
1187 VariantInit( &val );
1188 hr = IWbemClassObject_Get( obj, L"OperatingSystemSKU", 0, &val, &type, NULL );
1189 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND) /* winxp */, "failed to get operatingsystemsku %08x\n", hr );
1190 if (hr == S_OK)
1191 {
1192 ok( V_VT( &val ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &val ) );
1193 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
1194 trace( "operatingsystemsku: %08x\n", V_I4( &val ) );
1195 VariantClear( &val );
1196 }
1197
1198 type = 0xdeadbeef;
1199 VariantInit( &val );
1200 hr = IWbemClassObject_Get( obj, L"OSProductSuite", 0, &val, &type, NULL );
1201 ok( hr == S_OK, "failed to get osproductsuite %08x\n", hr );
1202 ok( V_VT( &val ) == VT_I4 || broken(V_VT( &val ) == VT_NULL) /* winxp */, "unexpected variant type 0x%x\n", V_VT( &val ) );
1203 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
1204 trace( "osproductsuite: %d (%08x)\n", V_I4( &val ), V_I4( &val ) );
1205 VariantClear( &val );
1206
1207 check_property( obj, L"CSName", VT_BSTR, CIM_STRING );
1208 check_property( obj, L"CurrentTimeZone", VT_I2, CIM_SINT16 );
1209 check_property( obj, L"Manufacturer", VT_BSTR, CIM_STRING );
1210 check_property( obj, L"OSType", VT_I4, CIM_UINT16 );
1211 check_property( obj, L"ServicePackMajorVersion", VT_I4, CIM_UINT16 );
1212 check_property( obj, L"ServicePackMinorVersion", VT_I4, CIM_UINT16 );
1213 check_property( obj, L"SuiteMask", VT_I4, CIM_UINT32 );
1214 check_property( obj, L"Version", VT_BSTR, CIM_STRING );
1215 check_property( obj, L"TotalVisibleMemorySize", VT_BSTR, CIM_UINT64 );
1216 check_property( obj, L"TotalVirtualMemorySize", VT_BSTR, CIM_UINT64 );
1217 check_property( obj, L"SystemDrive", VT_BSTR, CIM_STRING );
1218
1219 IWbemClassObject_Release( obj );
1220 IEnumWbemClassObject_Release( result );
1221 SysFreeString( query );
1222 SysFreeString( wql );
1223 }
1224
1225 static void test_Win32_ComputerSystemProduct( IWbemServices *services )
1226 {
1227 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_ComputerSystemProduct" );
1228 IEnumWbemClassObject *result;
1229 IWbemClassObject *obj;
1230 HRESULT hr;
1231 DWORD count;
1232
1233 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1234 if (hr != S_OK)
1235 {
1236 win_skip( "Win32_ComputerSystemProduct not available\n" );
1237 return;
1238 }
1239
1240 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1241 ok( hr == S_OK, "got %08x\n", hr );
1242
1243 check_property( obj, L"IdentifyingNumber", VT_BSTR, CIM_STRING );
1244 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
1245 check_property( obj, L"SKUNumber", VT_NULL, CIM_STRING );
1246 check_property( obj, L"UUID", VT_BSTR, CIM_STRING );
1247 check_property( obj, L"Vendor", VT_BSTR, CIM_STRING );
1248 check_property( obj, L"Version", VT_BSTR, CIM_STRING );
1249
1250 IWbemClassObject_Release( obj );
1251 IEnumWbemClassObject_Release( result );
1252 SysFreeString( query );
1253 SysFreeString( wql );
1254 }
1255
1256 static void test_Win32_PhysicalMemory( IWbemServices *services )
1257 {
1258 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_PhysicalMemory" );
1259 IEnumWbemClassObject *result;
1260 IWbemClassObject *obj;
1261 CIMTYPE type;
1262 VARIANT val;
1263 DWORD count;
1264 HRESULT hr;
1265
1266 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1267 if (hr != S_OK)
1268 {
1269 win_skip( "Win32_PhysicalMemory not available\n" );
1270 return;
1271 }
1272
1273 for (;;)
1274 {
1275 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1276 if (hr != S_OK) break;
1277
1278 check_property( obj, L"BankLabel", VT_BSTR, CIM_STRING );
1279 check_property( obj, L"Capacity", VT_BSTR, CIM_UINT64 );
1280 check_property( obj, L"Caption", VT_BSTR, CIM_STRING );
1281 check_property( obj, L"DeviceLocator", VT_BSTR, CIM_STRING );
1282 check_property( obj, L"FormFactor", VT_I4, CIM_UINT16 );
1283 check_property( obj, L"MemoryType", VT_I4, CIM_UINT16 );
1284
1285 type = 0xdeadbeef;
1286 VariantInit( &val );
1287 hr = IWbemClassObject_Get( obj, L"ConfiguredClockSpeed", 0, &val, &type, NULL );
1288 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND) /* < win10 */, "got %08x\n", hr );
1289 if (hr == S_OK)
1290 {
1291 ok( V_VT( &val ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &val ) );
1292 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
1293 trace( "ConfiguredClockSpeed %u\n", V_I4( &val ) );
1294 }
1295
1296 type = 0xdeadbeef;
1297 VariantInit( &val );
1298 hr = IWbemClassObject_Get( obj, L"PartNumber", 0, &val, &type, NULL );
1299 ok( hr == S_OK, "got %08x\n", hr );
1300 ok( V_VT( &val ) == VT_BSTR || V_VT( &val ) == VT_NULL, "unexpected variant type 0x%x\n", V_VT( &val ) );
1301 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
1302 trace( "PartNumber %s\n", wine_dbgstr_w(V_BSTR( &val )) );
1303 VariantClear( &val );
1304
1305 type = 0xdeadbeef;
1306 VariantInit( &val );
1307 hr = IWbemClassObject_Get( obj, L"SerialNumber", 0, &val, &type, NULL );
1308 ok( hr == S_OK, "got %08x\n", hr );
1309 ok( V_VT( &val ) == VT_BSTR || V_VT( &val ) == VT_NULL, "unexpected variant type 0x%x\n", V_VT( &val ) );
1310 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
1311 trace( "SerialNumber %s\n", wine_dbgstr_w(V_BSTR( &val )) );
1312 VariantClear( &val );
1313
1314 IWbemClassObject_Release( obj );
1315 }
1316
1317 IEnumWbemClassObject_Release( result );
1318 SysFreeString( query );
1319 SysFreeString( wql );
1320 }
1321
1322 static void test_Win32_IP4RouteTable( IWbemServices *services )
1323 {
1324 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_IP4RouteTable" );
1325 IEnumWbemClassObject *result;
1326 IWbemClassObject *obj;
1327 HRESULT hr;
1328 DWORD count;
1329
1330 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1331 if (hr != S_OK)
1332 {
1333 win_skip( "Win32_IP4RouteTable not available\n" );
1334 return;
1335 }
1336
1337 for (;;)
1338 {
1339 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1340 if (hr != S_OK) break;
1341
1342 check_property( obj, L"Destination", VT_BSTR, CIM_STRING );
1343 check_property( obj, L"InterfaceIndex", VT_I4, CIM_SINT32 );
1344 check_property( obj, L"NextHop", VT_BSTR, CIM_STRING );
1345 IWbemClassObject_Release( obj );
1346 }
1347
1348 IEnumWbemClassObject_Release( result );
1349 SysFreeString( query );
1350 SysFreeString( wql );
1351 }
1352
1353 static void test_Win32_Processor( IWbemServices *services )
1354 {
1355 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_Processor" );
1356 IEnumWbemClassObject *result;
1357 IWbemClassObject *obj;
1358 VARIANT val;
1359 CIMTYPE type;
1360 HRESULT hr;
1361 DWORD count;
1362
1363 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1364 ok( hr == S_OK, "got %08x\n", hr );
1365
1366 for (;;)
1367 {
1368 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1369 if (hr != S_OK) break;
1370
1371 check_property( obj, L"Architecture", VT_I4, CIM_UINT16 );
1372 check_property( obj, L"Caption", VT_BSTR, CIM_STRING );
1373 check_property( obj, L"CpuStatus", VT_I4, CIM_UINT16 );
1374 check_property( obj, L"Family", VT_I4, CIM_UINT16 );
1375 check_property( obj, L"Level", VT_I4, CIM_UINT16 );
1376 check_property( obj, L"Manufacturer", VT_BSTR, CIM_STRING );
1377 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
1378 check_property( obj, L"ProcessorId", VT_BSTR, CIM_STRING );
1379 check_property( obj, L"Revision", VT_I4, CIM_UINT16 );
1380 check_property( obj, L"Version", VT_BSTR, CIM_STRING );
1381
1382 type = 0xdeadbeef;
1383 VariantInit( &val );
1384 hr = IWbemClassObject_Get( obj, L"NumberOfLogicalProcessors", 0, &val, &type, NULL );
1385 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND) /* win2k3 */, "got %08x\n", hr );
1386 if (hr == S_OK)
1387 {
1388 ok( V_VT( &val ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &val ) );
1389 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
1390 trace( "numlogicalprocessors %u\n", V_I4( &val ) );
1391 }
1392
1393 type = 0xdeadbeef;
1394 VariantInit( &val );
1395 hr = IWbemClassObject_Get( obj, L"NumberOfCores", 0, &val, &type, NULL );
1396 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND) /* win2k3 */, "got %08x\n", hr );
1397 if (hr == S_OK)
1398 {
1399 ok( V_VT( &val ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &val ) );
1400 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
1401 trace( "numcores %u\n", V_I4( &val ) );
1402 }
1403
1404 IWbemClassObject_Release( obj );
1405 }
1406
1407 IEnumWbemClassObject_Release( result );
1408 SysFreeString( query );
1409 SysFreeString( wql );
1410 }
1411
1412 static void test_Win32_VideoController( IWbemServices *services )
1413 {
1414 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_VideoController" );
1415 IEnumWbemClassObject *result;
1416 IWbemClassObject *obj;
1417 VARIANT val;
1418 CIMTYPE type;
1419 HRESULT hr;
1420 DWORD count;
1421
1422 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1423 if (hr != S_OK)
1424 {
1425 win_skip( "Win32_VideoController not available\n" );
1426 return;
1427 }
1428
1429 for (;;)
1430 {
1431 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1432 if (hr != S_OK) break;
1433
1434 check_property( obj, L"__CLASS", VT_BSTR, CIM_STRING );
1435 check_property( obj, L"__GENUS", VT_I4, CIM_SINT32 );
1436 check_property( obj, L"__NAMESPACE", VT_BSTR, CIM_STRING );
1437 check_property( obj, L"__PATH", VT_BSTR, CIM_STRING );
1438 check_property( obj, L"__PROPERTY_COUNT", VT_I4, CIM_SINT32 );
1439 check_property( obj, L"__RELPATH", VT_BSTR, CIM_STRING );
1440 check_property( obj, L"__SERVER", VT_BSTR, CIM_STRING );
1441 check_property( obj, L"AdapterCompatibility", VT_BSTR, CIM_STRING );
1442 check_property( obj, L"Availability", VT_I4, CIM_UINT16 );
1443 check_property( obj, L"ConfigManagerErrorCode", VT_I4, CIM_UINT32 );
1444 check_property( obj, L"DriverDate", VT_BSTR, CIM_DATETIME );
1445
1446 type = 0xdeadbeef;
1447 VariantInit( &val );
1448 hr = IWbemClassObject_Get( obj, L"InstalledDisplayDrivers", 0, &val, &type, NULL );
1449 ok( hr == S_OK, "got %08x\n", hr );
1450 ok( V_VT( &val ) == VT_BSTR || V_VT( &val ) == VT_NULL, "unexpected variant type 0x%x\n", V_VT( &val ) );
1451 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
1452 trace( "installeddisplaydrivers %s\n", wine_dbgstr_w(V_BSTR( &val )) );
1453 VariantClear( &val );
1454
1455 check_property( obj, L"Status", VT_BSTR, CIM_STRING );
1456 IWbemClassObject_Release( obj );
1457 }
1458
1459 IEnumWbemClassObject_Release( result );
1460 SysFreeString( query );
1461
1462 query = SysAllocString( L"SELECT AdapterRAM FROM Win32_VideoController" );
1463 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1464 if (hr != S_OK)
1465 {
1466 win_skip( "Win32_VideoController not available\n" );
1467 return;
1468 }
1469
1470 for (;;)
1471 {
1472 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1473 if (hr != S_OK) break;
1474 check_property( obj, L"__CLASS", VT_BSTR, CIM_STRING );
1475 check_property( obj, L"__GENUS", VT_I4, CIM_SINT32 );
1476 check_property( obj, L"__NAMESPACE", VT_NULL, CIM_STRING );
1477 check_property( obj, L"__PATH", VT_NULL, CIM_STRING );
1478 check_property( obj, L"__PROPERTY_COUNT", VT_I4, CIM_SINT32 );
1479 check_property( obj, L"__RELPATH", VT_NULL, CIM_STRING );
1480 check_property( obj, L"__SERVER", VT_NULL, CIM_STRING );
1481 IWbemClassObject_Release( obj );
1482 }
1483
1484 IEnumWbemClassObject_Release( result );
1485 SysFreeString( query );
1486 SysFreeString( wql );
1487 }
1488
1489 static void test_Win32_Printer( IWbemServices *services )
1490 {
1491 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_Printer" );
1492 IEnumWbemClassObject *result;
1493 IWbemClassObject *obj;
1494 VARIANT val;
1495 CIMTYPE type;
1496 HRESULT hr;
1497 DWORD count;
1498
1499 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1500 if (hr != S_OK)
1501 {
1502 win_skip( "Win32_Printer not available\n" );
1503 return;
1504 }
1505
1506 for (;;)
1507 {
1508 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1509 if (hr != S_OK) break;
1510
1511 check_property( obj, L"Attributes", VT_I4, CIM_UINT32 );
1512 check_property( obj, L"DeviceId", VT_BSTR, CIM_STRING );
1513 check_property( obj, L"HorizontalResolution", VT_I4, CIM_UINT32 );
1514
1515 type = 0xdeadbeef;
1516 memset( &val, 0, sizeof(val) );
1517 hr = IWbemClassObject_Get( obj, L"Location", 0, &val, &type, NULL );
1518 ok( hr == S_OK, "got %08x\n", hr );
1519 ok( V_VT( &val ) == VT_BSTR || V_VT( &val ) == VT_NULL, "unexpected variant type 0x%x\n", V_VT( &val ) );
1520 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
1521 trace( "location %s\n", wine_dbgstr_w(V_BSTR( &val )) );
1522 VariantClear( &val );
1523
1524 check_property( obj, L"PortName", VT_BSTR, CIM_STRING );
1525 IWbemClassObject_Release( obj );
1526 }
1527
1528 IEnumWbemClassObject_Release( result );
1529 SysFreeString( query );
1530 SysFreeString( wql );
1531 }
1532
1533 static void test_Win32_PnPEntity( IWbemServices *services )
1534 {
1535 HRESULT hr;
1536 IEnumWbemClassObject *enm;
1537 IWbemClassObject *obj;
1538 VARIANT val;
1539 CIMTYPE type;
1540 ULONG count, i;
1541 BSTR bstr;
1542
1543 bstr = SysAllocString( L"Win32_PnPEntity" );
1544 hr = IWbemServices_CreateInstanceEnum( services, bstr, 0, NULL, &enm );
1545 ok( hr == S_OK, "got %08x\n", hr );
1546 SysFreeString( bstr );
1547
1548 bstr = SysAllocString( L"DeviceId" );
1549 while (1)
1550 {
1551 hr = IEnumWbemClassObject_Next( enm, 1000, 1, &obj, &count );
1552 ok( (count == 1 && (hr == WBEM_S_FALSE || hr == WBEM_S_NO_ERROR)) ||
1553 (count == 0 && (hr == WBEM_S_FALSE || hr == WBEM_S_TIMEDOUT)),
1554 "got %08x with %u objects returned\n", hr, count );
1555
1556 if (count == 0)
1557 break;
1558
1559 for (i = 0; i < count; ++i)
1560 {
1561 hr = IWbemClassObject_Get( obj, bstr, 0, &val, &type, NULL );
1562 ok( hr == S_OK, "got %08x\n", hr );
1563
1564 if (SUCCEEDED( hr ))
1565 {
1566 ok( V_VT( &val ) == VT_BSTR, "unexpected variant type 0x%x\n", V_VT( &val ) );
1567 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
1568 VariantClear( &val );
1569 }
1570 }
1571 IWbemClassObject_Release( obj );
1572 }
1573
1574 SysFreeString( bstr );
1575 IEnumWbemClassObject_Release( enm );
1576 }
1577
1578 static void test_Win32_WinSAT( IWbemServices *services )
1579 {
1580 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_WinSAT" );
1581 IEnumWbemClassObject *result;
1582 IWbemClassObject *obj;
1583 HRESULT hr;
1584 DWORD count;
1585
1586 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1587 ok( hr == S_OK || broken(hr == WBEM_E_INVALID_CLASS) /* win2k8 */, "got %08x\n", hr );
1588 if (hr == WBEM_E_INVALID_CLASS)
1589 {
1590 win_skip( "class not found\n" );
1591 return;
1592 }
1593
1594 for (;;)
1595 {
1596 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1597 if (hr != S_OK) break;
1598
1599 check_property( obj, L"CPUScore", VT_R4, CIM_REAL32 );
1600 check_property( obj, L"D3DScore", VT_R4, CIM_REAL32 );
1601 check_property( obj, L"DiskScore", VT_R4, CIM_REAL32 );
1602 check_property( obj, L"GraphicsScore", VT_R4, CIM_REAL32 );
1603 check_property( obj, L"MemoryScore", VT_R4, CIM_REAL32 );
1604 check_property( obj, L"WinSATAssessmentState", VT_I4, CIM_UINT32 );
1605 check_property( obj, L"WinSPRLevel", VT_R4, CIM_REAL32 );
1606 IWbemClassObject_Release( obj );
1607 }
1608
1609 IEnumWbemClassObject_Release( result );
1610 SysFreeString( query );
1611 SysFreeString( wql );
1612 }
1613
1614 static void test_Win32_DesktopMonitor( IWbemServices *services )
1615 {
1616 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_DesktopMonitor" );
1617 IEnumWbemClassObject *result;
1618 IWbemClassObject *obj;
1619 HRESULT hr;
1620 DWORD count;
1621
1622 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1623 ok( hr == S_OK, "got %08x\n", hr );
1624
1625 for (;;)
1626 {
1627 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1628 if (hr != S_OK) break;
1629
1630 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
1631 check_property( obj, L"PixelsPerXlogicalInch", VT_I4, CIM_UINT32 );
1632 IWbemClassObject_Release( obj );
1633 }
1634
1635 IEnumWbemClassObject_Release( result );
1636 SysFreeString( query );
1637 SysFreeString( wql );
1638 }
1639
1640 static void test_Win32_DiskDrive( IWbemServices *services )
1641 {
1642 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_DiskDrive" );
1643 IEnumWbemClassObject *result;
1644 IWbemClassObject *obj;
1645 HRESULT hr;
1646 DWORD count;
1647
1648 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1649 ok( hr == S_OK, "got %08x\n", hr );
1650
1651 for (;;)
1652 {
1653 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1654 if (hr != S_OK) break;
1655
1656 check_property( obj, L"DeviceID", VT_BSTR, CIM_STRING );
1657 IWbemClassObject_Release( obj );
1658 }
1659
1660 IEnumWbemClassObject_Release( result );
1661 SysFreeString( query );
1662 SysFreeString( wql );
1663 }
1664
1665 static void test_Win32_DisplayControllerConfiguration( IWbemServices *services )
1666 {
1667 BSTR wql = SysAllocString( L"wql" );
1668 BSTR query = SysAllocString( L"SELECT * FROM Win32_DisplayControllerConfiguration" );
1669 IEnumWbemClassObject *result;
1670 IWbemClassObject *obj;
1671 HRESULT hr;
1672 DWORD count;
1673
1674 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1675 ok( hr == S_OK, "got %08x\n", hr );
1676
1677 for (;;)
1678 {
1679 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1680 if (hr != S_OK) break;
1681
1682 check_property( obj, L"BitsPerPixel", VT_I4, CIM_UINT32 );
1683 check_property( obj, L"Caption", VT_BSTR, CIM_STRING );
1684 check_property( obj, L"HorizontalResolution", VT_I4, CIM_UINT32 );
1685 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
1686 check_property( obj, L"VerticalResolution", VT_I4, CIM_UINT32 );
1687 IWbemClassObject_Release( obj );
1688 }
1689
1690 IEnumWbemClassObject_Release( result );
1691 SysFreeString( query );
1692 SysFreeString( wql );
1693 }
1694
1695 static void test_Win32_QuickFixEngineering( IWbemServices *services )
1696 {
1697 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_QuickFixEngineering" );
1698 IEnumWbemClassObject *result;
1699 IWbemClassObject *obj;
1700 HRESULT hr;
1701 DWORD count, total = 0;
1702 VARIANT caption;
1703 CIMTYPE type;
1704
1705 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1706 ok( hr == S_OK, "got %08x\n", hr );
1707
1708 for (;;)
1709 {
1710 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1711 if (hr != S_OK) break;
1712
1713 type = 0xdeadbeef;
1714 VariantInit( &caption );
1715 hr = IWbemClassObject_Get( obj, L"Caption", 0, &caption, &type, NULL );
1716 ok( hr == S_OK, "failed to get caption %08x\n", hr );
1717 ok( V_VT( &caption ) == VT_BSTR || V_VT( &caption ) == VT_NULL /* winxp */,
1718 "unexpected variant type 0x%x\n", V_VT( &caption ) );
1719 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
1720
1721 check_property( obj, L"HotFixID", VT_BSTR, CIM_STRING );
1722 IWbemClassObject_Release( obj );
1723 if (total++ >= 10) break;
1724 }
1725
1726 IEnumWbemClassObject_Release( result );
1727 SysFreeString( query );
1728 SysFreeString( wql );
1729 }
1730
1731 static void test_Win32_SoundDevice( IWbemServices *services )
1732 {
1733 BSTR wql = SysAllocString( L"wql" );
1734 BSTR query = SysAllocString( L"SELECT * FROM Win32_SoundDevice" );
1735 IEnumWbemClassObject *result;
1736 IWbemClassObject *obj;
1737 HRESULT hr;
1738 DWORD count;
1739
1740 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1741 ok( hr == S_OK, "got %08x\n", hr );
1742
1743 for (;;)
1744 {
1745 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1746 if (hr != S_OK) break;
1747
1748 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
1749 check_property( obj, L"ProductName", VT_BSTR, CIM_STRING );
1750 check_property( obj, L"StatusInfo", VT_I4, CIM_UINT16 );
1751 check_property( obj, L"Manufacturer", VT_BSTR, CIM_STRING );
1752 IWbemClassObject_Release( obj );
1753 }
1754
1755 IEnumWbemClassObject_Release( result );
1756 SysFreeString( query );
1757 SysFreeString( wql );
1758 }
1759
1760 START_TEST(query)
1761 {
1762 BSTR path = SysAllocString( L"ROOT\\CIMV2" );
1763 IWbemLocator *locator;
1764 IWbemServices *services;
1765 DWORD authn_svc;
1766 HRESULT hr;
1767
1768 CoInitialize( NULL );
1769 CoInitializeSecurity( NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_DEFAULT,
1770 RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL );
1771 hr = CoCreateInstance( &CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER, &IID_IWbemLocator,
1772 (void **)&locator );
1773 if (hr != S_OK)
1774 {
1775 win_skip("can't create instance of WbemLocator\n");
1776 return;
1777 }
1778 hr = IWbemLocator_ConnectServer( locator, path, NULL, NULL, NULL, 0, NULL, NULL, &services );
1779 ok( hr == S_OK, "failed to get IWbemServices interface %08x\n", hr );
1780
1781 hr = CoQueryProxyBlanket( (IUnknown *)services, NULL, NULL, NULL, NULL, NULL, NULL, NULL );
1782 ok( hr == S_OK, "failed to query proxy blanket %08x\n", hr );
1783
1784 hr = CoQueryProxyBlanket( (IUnknown *)services, &authn_svc, NULL, NULL, NULL, NULL, NULL, NULL );
1785 ok( hr == S_OK, "failed to query proxy blanket %08x\n", hr );
1786
1787 hr = CoSetProxyBlanket( (IUnknown *)services, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL,
1788 RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE );
1789 ok( hr == S_OK, "failed to set proxy blanket %08x\n", hr );
1790
1791 test_GetNames( services );
1792 test_IEnumWbemClassObject_Next( services );
1793 test_associators( services );
1794 test_notification_query_async( services );
1795 test_query_async( services );
1796 test_query_semisync( services );
1797 test_select( services );
1798
1799 /* classes */
1800 test_StdRegProv( services );
1801 test_SystemSecurity( services );
1802 test_Win32_Baseboard( services );
1803 test_Win32_ComputerSystem( services );
1804 test_Win32_ComputerSystemProduct( services );
1805 test_Win32_Bios( services );
1806 test_Win32_DesktopMonitor( services );
1807 test_Win32_DiskDrive( services );
1808 test_Win32_DisplayControllerConfiguration( services );
1809 test_Win32_IP4RouteTable( services );
1810 test_Win32_OperatingSystem( services );
1811 test_Win32_PhysicalMemory( services );
1812 test_Win32_PnPEntity( services );
1813 test_Win32_Printer( services );
1814 test_Win32_Process( services, FALSE );
1815 test_Win32_Process( services, TRUE );
1816 test_Win32_Processor( services );
1817 test_Win32_QuickFixEngineering( services );
1818 test_Win32_Service( services );
1819 test_Win32_SoundDevice( services );
1820 test_Win32_SystemEnclosure( services );
1821 test_Win32_VideoController( services );
1822 test_Win32_WinSAT( services );
1823
1824 SysFreeString( path );
1825 IWbemServices_Release( services );
1826 IWbemLocator_Release( locator );
1827 CoUninitialize();
1828 }
Zebediah Figura's local tree