?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wbemprox/tests: Add IEnumWbemClassObject::Next() tests.
[wine.git] / dlls / wbemprox / tests / query.c
blobe99e221c3052556bc63f52b687817e285eec9788
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 todo_wine ok( hr == S_OK, "got %08x\n", hr );
185 todo_wine 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 todo_wine ok( hr == S_OK, "got %08x\n", hr );
203 todo_wine 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 todo_wine ok( hr == S_FALSE, "got %08x\n", hr );
214 todo_wine 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;
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 goto out;
271 }
272
273 check_property( service, L"ProcessID", VT_I4, CIM_UINT32 );
274 type = 0xdeadbeef;
275 VariantInit( &state );
276 hr = IWbemClassObject_Get( service, L"State", 0, &state, &type, NULL );
277 ok( hr == S_OK, "failed to get service state %08x\n", hr );
278 ok( V_VT( &state ) == VT_BSTR, "unexpected variant type 0x%x\n", V_VT( &state ) );
279 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
280
281 if (!lstrcmpW( V_BSTR( &state ), L"Stopped" ))
282 {
283 out = NULL;
284 method = SysAllocString( L"StartService" );
285 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, NULL, &out, NULL );
286 ok( hr == S_OK, "failed to execute method %08x\n", hr );
287 SysFreeString( method );
288
289 VariantInit( &retval );
290 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, NULL, NULL );
291 ok( hr == S_OK, "failed to get return value %08x\n", hr );
292 ok( !V_I4( &retval ), "unexpected error %u\n", V_UI4( &retval ) );
293 IWbemClassObject_Release( out );
294 }
295 out = NULL;
296 method = SysAllocString( L"PauseService" );
297 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, NULL, &out, NULL );
298 ok( hr == S_OK, "failed to execute method %08x\n", hr );
299 SysFreeString( method );
300
301 VariantInit( &retval );
302 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, NULL, NULL );
303 ok( hr == S_OK, "failed to get return value %08x\n", hr );
304 ok( V_I4( &retval ), "unexpected success\n" );
305 IWbemClassObject_Release( out );
306
307 out = NULL;
308 method = SysAllocString( L"ResumeService" );
309 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, NULL, &out, NULL );
310 ok( hr == S_OK, "failed to execute method %08x\n", hr );
311 SysFreeString( method );
312
313 VariantInit( &retval );
314 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, NULL, NULL );
315 ok( hr == S_OK, "failed to get return value %08x\n", hr );
316 ok( V_I4( &retval ), "unexpected success\n" );
317 IWbemClassObject_Release( out );
318
319 if (!lstrcmpW( V_BSTR( &state ), L"Stopped" ))
320 {
321 out = NULL;
322 method = SysAllocString( L"StopService" );
323 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, NULL, &out, NULL );
324 ok( hr == S_OK, "failed to execute method %08x\n", hr );
325 SysFreeString( method );
326
327 VariantInit( &retval );
328 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, NULL, NULL );
329 ok( hr == S_OK, "failed to get return value %08x\n", hr );
330 ok( !V_I4( &retval ), "unexpected error %u\n", V_UI4( &retval ) );
331 IWbemClassObject_Release( out );
332 }
333 VariantClear( &state );
334 IWbemClassObject_Release( service );
335
336 service = NULL;
337 hr = IWbemServices_GetObject( services, NULL, 0, NULL, &service, NULL );
338 ok( hr == S_OK, "got %08x\n", hr );
339 if (service) IWbemClassObject_Release( service );
340
341 service = NULL;
342 hr = IWbemServices_GetObject( services, empty, 0, NULL, &service, NULL );
343 ok( hr == S_OK, "got %08x\n", hr );
344 if (service) IWbemClassObject_Release( service );
345
346 out:
347 SysFreeString( empty );
348 SysFreeString( class );
349 }
350
351 static void test_Win32_Bios( IWbemServices *services )
352 {
353 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_BIOS" );
354 IEnumWbemClassObject *result;
355 IWbemClassObject *obj;
356 CIMTYPE type;
357 ULONG count;
358 VARIANT val;
359 HRESULT hr;
360
361 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
362 ok( hr == S_OK, "IWbemServices_ExecQuery failed %08x\n", hr );
363
364 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
365 ok( hr == S_OK, "IEnumWbemClassObject_Next failed %08x\n", hr );
366
367 check_property( obj, L"Description", VT_BSTR, CIM_STRING );
368 check_property( obj, L"IdentificationCode", VT_NULL, CIM_STRING );
369 check_property( obj, L"Manufacturer", VT_BSTR, CIM_STRING );
370 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
371 check_property( obj, L"ReleaseDate", VT_BSTR, CIM_DATETIME );
372
373 type = 0xdeadbeef;
374 VariantInit( &val );
375 hr = IWbemClassObject_Get( obj, L"SerialNumber", 0, &val, &type, NULL );
376 ok( hr == S_OK, "failed to get serial number %08x\n", hr );
377 ok( V_VT( &val ) == VT_BSTR || V_VT( &val ) == VT_NULL /* Testbot VMs */,
378 "unexpected variant type 0x%x\n", V_VT( &val ) );
379 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
380 VariantClear( &val );
381
382 check_property( obj, L"SMBIOSBIOSVersion", VT_BSTR, CIM_STRING );
383 check_property( obj, L"SMBIOSMajorVersion", VT_I4, CIM_UINT16 );
384 check_property( obj, L"SMBIOSMinorVersion", VT_I4, CIM_UINT16 );
385 check_property( obj, L"Version", VT_BSTR, CIM_STRING );
386
387 IWbemClassObject_Release( obj );
388 IEnumWbemClassObject_Release( result );
389 SysFreeString( query );
390 SysFreeString( wql );
391 }
392
393 static void test_Win32_Baseboard( IWbemServices *services )
394 {
395 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_Baseboard" );
396 IEnumWbemClassObject *result;
397 IWbemClassObject *obj;
398 CIMTYPE type;
399 ULONG count;
400 VARIANT val;
401 HRESULT hr;
402
403 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
404 ok( hr == S_OK, "IWbemServices_ExecQuery failed %08x\n", hr );
405
406 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
407 if (hr != S_OK)
408 {
409 win_skip( "Win32_Baseboard not available\n" );
410 return;
411 }
412 ok( hr == S_OK, "IEnumWbemClassObject_Next failed %08x\n", hr );
413
414 check_property( obj, L"Manufacturer", VT_BSTR, CIM_STRING );
415
416 type = 0xdeadbeef;
417 VariantInit( &val );
418 hr = IWbemClassObject_Get( obj, L"Model", 0, &val, &type, NULL );
419 ok( hr == S_OK, "failed to get model %08x\n", hr );
420 ok( V_VT( &val ) == VT_BSTR || V_VT( &val ) == VT_NULL, "unexpected variant type 0x%x\n", V_VT( &val ) );
421 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
422 trace( "model: %s\n", wine_dbgstr_w(V_BSTR(&val)) );
423 VariantClear( &val );
424
425 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
426 check_property( obj, L"Product", VT_BSTR, CIM_STRING );
427 check_property( obj, L"Tag", VT_BSTR, CIM_STRING );
428 check_property( obj, L"Version", VT_BSTR, CIM_STRING );
429
430 IWbemClassObject_Release( obj );
431 IEnumWbemClassObject_Release( result );
432 SysFreeString( query );
433 SysFreeString( wql );
434 }
435
436 static void test_Win32_Process( IWbemServices *services, BOOL use_full_path )
437 {
438 static const LONG expected_flavor = WBEM_FLAVOR_FLAG_PROPAGATE_TO_INSTANCE |
439 WBEM_FLAVOR_NOT_OVERRIDABLE |
440 WBEM_FLAVOR_ORIGIN_PROPAGATED;
441 WCHAR full_path[MAX_COMPUTERNAME_LENGTH + ARRAY_SIZE( L"\\\\%s\\ROOT\\CIMV2:" )];
442 BSTR class, method;
443 IWbemClassObject *process, *sig_in, *out;
444 IWbemQualifierSet *qualifiers;
445 VARIANT retval, val;
446 DWORD full_path_len = 0;
447 LONG flavor;
448 CIMTYPE type;
449 HRESULT hr;
450
451 if (use_full_path)
452 {
453 WCHAR server[MAX_COMPUTERNAME_LENGTH+1];
454
455 full_path_len = ARRAY_SIZE(server);
456 ok( GetComputerNameW(server, &full_path_len), "GetComputerName failed\n" );
457 full_path_len = wsprintfW( full_path, L"\\\\%s\\ROOT\\CIMV2:", server );
458 }
459
460 class = SysAllocStringLen( NULL, full_path_len + ARRAY_SIZE( L"Win32_Process" ) );
461 memcpy( class, full_path, full_path_len * sizeof(WCHAR) );
462 memcpy( class + full_path_len, L"Win32_Process", sizeof(L"Win32_Process") );
463 hr = IWbemServices_GetObject( services, class, 0, NULL, &process, NULL );
464 SysFreeString( class );
465 if (hr != S_OK)
466 {
467 win_skip( "Win32_Process not available\n" );
468 return;
469 }
470 sig_in = (void*)0xdeadbeef;
471 hr = IWbemClassObject_GetMethod( process, L"GetOwner", 0, &sig_in, NULL );
472 ok( hr == S_OK, "failed to get GetOwner method %08x\n", hr );
473 ok( !sig_in, "sig_in != NULL\n");
474 IWbemClassObject_Release( process );
475
476 out = NULL;
477 method = SysAllocString( L"GetOwner" );
478 class = SysAllocStringLen( NULL, full_path_len + ARRAY_SIZE( L"Win32_Process.Handle=\"%u\"" ) + 10 );
479 memcpy( class, full_path, full_path_len * sizeof(WCHAR) );
480 wsprintfW( class + full_path_len, L"Win32_Process.Handle=\"%u\"", GetCurrentProcessId() );
481 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, NULL, &out, NULL );
482 ok( hr == S_OK, "failed to execute method %08x\n", hr );
483 SysFreeString( method );
484 SysFreeString( class );
485
486 type = 0xdeadbeef;
487 VariantInit( &retval );
488 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, &type, NULL );
489 ok( hr == S_OK, "failed to get return value %08x\n", hr );
490 ok( V_VT( &retval ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &retval ) );
491 ok( !V_I4( &retval ), "unexpected error %u\n", V_I4( &retval ) );
492 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
493
494 check_property( out, L"User", VT_BSTR, CIM_STRING );
495 check_property( out, L"Domain", VT_BSTR, CIM_STRING );
496
497 hr = IWbemClassObject_GetPropertyQualifierSet( out, L"User", &qualifiers );
498 ok( hr == S_OK, "failed to get qualifier set %08x\n", hr );
499
500 flavor = -1;
501 V_I4(&val) = -1;
502 V_VT(&val) = VT_ERROR;
503 hr = IWbemQualifierSet_Get( qualifiers, L"ID", 0, &val, &flavor );
504 ok( hr == S_OK, "got %08x\n", hr );
505 ok( flavor == expected_flavor, "got %d\n", flavor );
506 ok( V_VT(&val) == VT_I4, "got %u\n", V_VT(&val) );
507 ok( V_I4(&val) == 0, "got %u\n", V_I4(&val) );
508 VariantClear( &val );
509
510 IWbemQualifierSet_Release( qualifiers );
511 hr = IWbemClassObject_GetPropertyQualifierSet( out, L"Domain", &qualifiers );
512 ok( hr == S_OK, "failed to get qualifier set %08x\n", hr );
513
514 flavor = -1;
515 V_I4(&val) = -1;
516 V_VT(&val) = VT_ERROR;
517 hr = IWbemQualifierSet_Get( qualifiers, L"ID", 0, &val, &flavor );
518 ok( hr == S_OK, "got %08x\n", hr );
519 ok( flavor == expected_flavor, "got %d\n", flavor );
520 ok( V_VT(&val) == VT_I4, "got %u\n", V_VT(&val) );
521 ok( V_I4(&val) == 1, "got %u\n", V_I4(&val) );
522 VariantClear( &val );
523
524 IWbemQualifierSet_Release( qualifiers );
525 hr = IWbemClassObject_GetPropertyQualifierSet( out, L"ReturnValue", &qualifiers );
526 ok( hr == S_OK, "failed to get qualifier set %08x\n", hr );
527
528 hr = IWbemQualifierSet_Get( qualifiers, L"ID", 0, &val, &flavor );
529 ok( hr == WBEM_E_NOT_FOUND, "got %08x\n", hr );
530
531 IWbemQualifierSet_Release( qualifiers );
532 IWbemClassObject_Release( out );
533 }
534
535 static void test_Win32_ComputerSystem( IWbemServices *services )
536 {
537 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_ComputerSystem" );
538 IEnumWbemClassObject *result;
539 IWbemClassObject *obj;
540 VARIANT value;
541 CIMTYPE type;
542 HRESULT hr;
543 WCHAR compname[MAX_COMPUTERNAME_LENGTH + 1];
544 WCHAR username[128];
545 DWORD len, count;
546
547 len = ARRAY_SIZE( compname );
548 if (!GetComputerNameW( compname, &len ))
549 compname[0] = 0;
550
551 lstrcpyW( username, compname );
552 lstrcatW( username, L"\\" );
553 len = ARRAY_SIZE( username ) - lstrlenW( username );
554 if (!GetUserNameW( username + lstrlenW( username ), &len ))
555 username[0] = 0;
556
557 if (!compname[0] || !username[0])
558 {
559 skip( "Failed to get user or computer name\n" );
560 goto out;
561 }
562
563 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
564 if (hr != S_OK)
565 {
566 win_skip( "Win32_ComputerSystem not available\n" );
567 goto out;
568 }
569
570 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
571 ok( hr == S_OK, "got %08x\n", hr );
572
573 type = 0xdeadbeef;
574 VariantInit( &value );
575 hr = IWbemClassObject_Get( obj, L"MemoryType", 0, &value, &type, NULL );
576 ok( hr == WBEM_E_NOT_FOUND, "got %08x\n", hr );
577
578 check_property( obj, L"Model", VT_BSTR, CIM_STRING );
579
580 type = 0xdeadbeef;
581 VariantInit( &value );
582 hr = IWbemClassObject_Get( obj, L"Name", 0, &value, &type, NULL );
583 ok( hr == S_OK, "failed to get computer name %08x\n", hr );
584 ok( V_VT( &value ) == VT_BSTR, "unexpected variant type 0x%x\n", V_VT( &value ) );
585 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
586 ok( !lstrcmpiW( V_BSTR( &value ), compname ), "got %s, expected %s\n", wine_dbgstr_w(V_BSTR(&value)), wine_dbgstr_w(compname) );
587 VariantClear( &value );
588
589 type = 0xdeadbeef;
590 VariantInit( &value );
591 hr = IWbemClassObject_Get( obj, L"NumberOfLogicalProcessors", 0, &value, &type, NULL );
592 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND) /* win2k3 */, "got %08x\n", hr );
593 if (hr == S_OK)
594 {
595 ok( V_VT( &value ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &value ) );
596 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
597 trace( "numlogicalprocessors %u\n", V_I4( &value ) );
598 }
599
600 check_property( obj, L"NumberOfProcessors", VT_I4, CIM_UINT32 );
601
602 type = 0xdeadbeef;
603 VariantInit( &value );
604 hr = IWbemClassObject_Get( obj, L"UserName", 0, &value, &type, NULL );
605 ok( hr == S_OK, "failed to get computer name %08x\n", hr );
606 ok( V_VT( &value ) == VT_BSTR, "unexpected variant type 0x%x\n", V_VT( &value ) );
607 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
608 ok( !lstrcmpiW( V_BSTR( &value ), username ), "got %s, expected %s\n", wine_dbgstr_w(V_BSTR(&value)), wine_dbgstr_w(username) );
609 VariantClear( &value );
610
611 IWbemClassObject_Release( obj );
612 IEnumWbemClassObject_Release( result );
613 out:
614 SysFreeString( query );
615 SysFreeString( wql );
616 }
617
618 static void test_Win32_SystemEnclosure( IWbemServices *services )
619 {
620 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_SystemEnclosure" );
621 IEnumWbemClassObject *result;
622 IWbemClassObject *obj;
623 CIMTYPE type;
624 ULONG count;
625 VARIANT val;
626 DWORD *data;
627 HRESULT hr;
628
629 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
630 ok( hr == S_OK, "IWbemServices_ExecQuery failed %08x\n", hr );
631
632 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
633 ok( hr == S_OK, "IEnumWbemClassObject_Next failed %08x\n", hr );
634
635 check_property( obj, L"Caption", VT_BSTR, CIM_STRING );
636
637 type = 0xdeadbeef;
638 VariantInit( &val );
639 hr = IWbemClassObject_Get( obj, L"ChassisTypes", 0, &val, &type, NULL );
640 ok( hr == S_OK, "failed to get chassis types %08x\n", hr );
641 ok( V_VT( &val ) == (VT_I4|VT_ARRAY), "unexpected variant type 0x%x\n", V_VT( &val ) );
642 ok( type == (CIM_UINT16|CIM_FLAG_ARRAY), "unexpected type 0x%x\n", type );
643 hr = SafeArrayAccessData( V_ARRAY( &val ), (void **)&data );
644 ok( hr == S_OK, "SafeArrayAccessData failed %x\n", hr );
645 if (SUCCEEDED(hr))
646 {
647 LONG i, lower, upper;
648
649 hr = SafeArrayGetLBound( V_ARRAY( &val ), 1, &lower );
650 ok( hr == S_OK, "SafeArrayGetLBound failed %x\n", hr );
651 hr = SafeArrayGetUBound( V_ARRAY( &val ), 1, &upper );
652 ok( hr == S_OK, "SafeArrayGetUBound failed %x\n", hr );
653 if (V_VT( &val ) == (VT_I4|VT_ARRAY))
654 {
655 for (i = 0; i < upper - lower + 1; i++)
656 trace( "chassis type: %u\n", data[i] );
657 }
658 hr = SafeArrayUnaccessData( V_ARRAY( &val ) );
659 ok( hr == S_OK, "SafeArrayUnaccessData failed %x\n", hr );
660 }
661 VariantClear( &val );
662
663 check_property( obj, L"Description", VT_BSTR, CIM_STRING );
664 check_property( obj, L"LockPresent", VT_BOOL, CIM_BOOLEAN );
665 check_property( obj, L"Manufacturer", VT_BSTR, CIM_STRING );
666 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
667 check_property( obj, L"Tag", VT_BSTR, CIM_STRING );
668
669 IWbemClassObject_Release( obj );
670 IEnumWbemClassObject_Release( result );
671 SysFreeString( query );
672 SysFreeString( wql );
673 }
674
675 static void test_StdRegProv( IWbemServices *services )
676 {
677 BSTR class = SysAllocString( L"StdRegProv" ), method, name;
678 IWbemClassObject *reg, *sig_in, *sig_out, *in, *out;
679 VARIANT defkey, subkey, retval, valuename;
680 CIMTYPE type;
681 HRESULT hr;
682 LONG res;
683
684 hr = IWbemServices_GetObject( services, class, 0, NULL, &reg, NULL );
685 if (hr != S_OK)
686 {
687 win_skip( "StdRegProv not available\n" );
688 return;
689 }
690
691 hr = IWbemClassObject_BeginMethodEnumeration( reg, 0 );
692 ok( hr == S_OK, "got %08x\n", hr );
693
694 while (IWbemClassObject_NextMethod( reg, 0, &name, &sig_in, &sig_out ) == S_OK)
695 {
696 SysFreeString( name );
697 IWbemClassObject_Release( sig_in );
698 IWbemClassObject_Release( sig_out );
699 }
700
701 hr = IWbemClassObject_EndMethodEnumeration( reg );
702 ok( hr == S_OK, "got %08x\n", hr );
703
704 hr = IWbemClassObject_BeginEnumeration( reg, 0 );
705 ok( hr == S_OK, "got %08x\n", hr );
706
707 while (IWbemClassObject_Next( reg, 0, &name, NULL, NULL, NULL ) == S_OK)
708 SysFreeString( name );
709
710 hr = IWbemClassObject_EndEnumeration( reg );
711 ok( hr == S_OK, "got %08x\n", hr );
712
713 hr = IWbemClassObject_GetMethod( reg, L"CreateKey", 0, &sig_in, NULL );
714 ok( hr == S_OK, "failed to get CreateKey method %08x\n", hr );
715
716 hr = IWbemClassObject_SpawnInstance( sig_in, 0, &in );
717 ok( hr == S_OK, "failed to spawn instance %08x\n", hr );
718
719 V_VT( &defkey ) = VT_I4;
720 V_I4( &defkey ) = 0x80000001;
721 hr = IWbemClassObject_Put( in, L"hDefKey", 0, &defkey, 0 );
722 ok( hr == S_OK, "failed to set root %08x\n", hr );
723
724 V_VT( &subkey ) = VT_BSTR;
725 V_BSTR( &subkey ) = SysAllocString( L"Software\\StdRegProvTest" );
726 hr = IWbemClassObject_Put( in, L"sSubKeyName", 0, &subkey, 0 );
727 ok( hr == S_OK, "failed to set subkey %08x\n", hr );
728
729 out = NULL;
730 method = SysAllocString( L"CreateKey" );
731 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, in, &out, NULL );
732 ok( hr == S_OK, "failed to execute method %08x\n", hr );
733 SysFreeString( method );
734
735 type = 0xdeadbeef;
736 VariantInit( &retval );
737 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, &type, NULL );
738 ok( hr == S_OK, "failed to get return value %08x\n", hr );
739 ok( V_VT( &retval ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &retval ) );
740 ok( !V_I4( &retval ), "unexpected error %u\n", V_UI4( &retval ) );
741 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
742
743 res = RegDeleteKeyW( HKEY_CURRENT_USER, L"Software\\StdRegProvTest" );
744 ok( !res, "got %d\n", res );
745
746 VariantClear( &subkey );
747 IWbemClassObject_Release( in );
748 IWbemClassObject_Release( out );
749 IWbemClassObject_Release( sig_in );
750
751 hr = IWbemClassObject_GetMethod( reg, L"EnumKey", 0, &sig_in, NULL );
752 ok( hr == S_OK, "failed to get EnumKey method %08x\n", hr );
753
754 hr = IWbemClassObject_SpawnInstance( sig_in, 0, &in );
755 ok( hr == S_OK, "failed to spawn instance %08x\n", hr );
756
757 V_VT( &defkey ) = VT_I4;
758 V_I4( &defkey ) = 0x80000002;
759 hr = IWbemClassObject_Put( in, L"hDefKey", 0, &defkey, 0 );
760 ok( hr == S_OK, "failed to set root %08x\n", hr );
761
762 V_VT( &subkey ) = VT_BSTR;
763 V_BSTR( &subkey ) = SysAllocString( L"Software\\microsoft\\Windows\\CurrentVersion" );
764 hr = IWbemClassObject_Put( in, L"sSubKeyName", 0, &subkey, 0 );
765 ok( hr == S_OK, "failed to set subkey %08x\n", hr );
766
767 out = NULL;
768 method = SysAllocString( L"EnumKey" );
769 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, in, &out, NULL );
770 ok( hr == S_OK, "failed to execute method %08x\n", hr );
771 SysFreeString( method );
772
773 type = 0xdeadbeef;
774 VariantInit( &retval );
775 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, &type, NULL );
776 ok( hr == S_OK, "failed to get return value %08x\n", hr );
777 ok( V_VT( &retval ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &retval ) );
778 ok( !V_I4( &retval ), "unexpected error %u\n", V_UI4( &retval ) );
779 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
780
781 check_property( out, L"sNames", VT_BSTR|VT_ARRAY, CIM_STRING|CIM_FLAG_ARRAY );
782
783 VariantClear( &subkey );
784 IWbemClassObject_Release( in );
785 IWbemClassObject_Release( out );
786 IWbemClassObject_Release( sig_in );
787
788 hr = IWbemClassObject_GetMethod( reg, L"EnumValues", 0, &sig_in, NULL );
789 ok( hr == S_OK, "failed to get EnumValues method %08x\n", hr );
790
791 hr = IWbemClassObject_SpawnInstance( sig_in, 0, &in );
792 ok( hr == S_OK, "failed to spawn instance %08x\n", hr );
793
794 V_VT( &defkey ) = VT_I4;
795 V_I4( &defkey ) = 0x80000002;
796 hr = IWbemClassObject_Put( in, L"hDefKey", 0, &defkey, 0 );
797 ok( hr == S_OK, "failed to set root %08x\n", hr );
798
799 V_VT( &subkey ) = VT_BSTR;
800 V_BSTR( &subkey ) = SysAllocString( L"Software\\microsoft\\Windows\\CurrentVersion" );
801 hr = IWbemClassObject_Put( in, L"sSubKeyName", 0, &subkey, 0 );
802 ok( hr == S_OK, "failed to set subkey %08x\n", hr );
803
804 out = NULL;
805 method = SysAllocString( L"EnumValues" );
806 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, in, &out, NULL );
807 ok( hr == S_OK, "failed to execute method %08x\n", hr );
808 SysFreeString( method );
809
810 type = 0xdeadbeef;
811 VariantInit( &retval );
812 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, &type, NULL );
813 ok( hr == S_OK, "failed to get return value %08x\n", hr );
814 ok( V_VT( &retval ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &retval ) );
815 ok( !V_I4( &retval ), "unexpected error %u\n", V_I4( &retval ) );
816 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
817
818 check_property( out, L"sNames", VT_BSTR|VT_ARRAY, CIM_STRING|CIM_FLAG_ARRAY );
819 check_property( out, L"Types", VT_I4|VT_ARRAY, CIM_SINT32|CIM_FLAG_ARRAY );
820
821 VariantClear( &subkey );
822 IWbemClassObject_Release( in );
823 IWbemClassObject_Release( out );
824 IWbemClassObject_Release( sig_in );
825
826 hr = IWbemClassObject_GetMethod( reg, L"GetStringValue", 0, &sig_in, NULL );
827 ok( hr == S_OK, "failed to get GetStringValue method %08x\n", hr );
828
829 hr = IWbemClassObject_SpawnInstance( sig_in, 0, &in );
830 ok( hr == S_OK, "failed to spawn instance %08x\n", hr );
831
832 V_VT( &defkey ) = VT_I4;
833 V_I4( &defkey ) = 0x80000002;
834 hr = IWbemClassObject_Put( in, L"hDefKey", 0, &defkey, 0 );
835 ok( hr == S_OK, "failed to set root %08x\n", hr );
836
837 V_VT( &subkey ) = VT_BSTR;
838 V_BSTR( &subkey ) = SysAllocString( L"Software\\microsoft\\Windows\\CurrentVersion" );
839 hr = IWbemClassObject_Put( in, L"sSubKeyName", 0, &subkey, 0 );
840 ok( hr == S_OK, "failed to set subkey %08x\n", hr );
841
842 V_VT( &valuename ) = VT_BSTR;
843 V_BSTR( &valuename ) = SysAllocString( L"ProgramFilesDir" );
844 hr = IWbemClassObject_Put( in, L"sValueName", 0, &valuename, 0 );
845 ok( hr == S_OK, "failed to set value name %08x\n", hr );
846
847 out = NULL;
848 method = SysAllocString( L"GetStringValue" );
849 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, in, &out, NULL );
850 ok( hr == S_OK, "failed to execute method %08x\n", hr );
851 SysFreeString( method );
852
853 type = 0xdeadbeef;
854 VariantInit( &retval );
855 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, &type, NULL );
856 ok( hr == S_OK, "failed to get return value %08x\n", hr );
857 ok( V_VT( &retval ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &retval ) );
858 ok( !V_I4( &retval ), "unexpected error %u\n", V_I4( &retval ) );
859 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
860
861 check_property( out, L"sValue", VT_BSTR, CIM_STRING );
862
863 VariantClear( &valuename );
864 VariantClear( &subkey );
865 IWbemClassObject_Release( in );
866 IWbemClassObject_Release( out );
867 IWbemClassObject_Release( sig_in );
868
869 IWbemClassObject_Release( reg );
870 SysFreeString( class );
871 }
872
873 static HRESULT WINAPI sink_QueryInterface(
874 IWbemObjectSink *iface, REFIID riid, void **ppv )
875 {
876 *ppv = NULL;
877 if (IsEqualGUID( &IID_IUnknown, riid ) || IsEqualGUID( &IID_IWbemObjectSink, riid ))
878 {
879 *ppv = iface;
880 IWbemObjectSink_AddRef( iface );
881 return S_OK;
882 }
883 return E_NOINTERFACE;
884 }
885
886 static ULONG sink_refs;
887
888 static ULONG WINAPI sink_AddRef(
889 IWbemObjectSink *iface )
890 {
891 return ++sink_refs;
892 }
893
894 static ULONG WINAPI sink_Release(
895 IWbemObjectSink *iface )
896 {
897 return --sink_refs;
898 }
899
900 static HRESULT WINAPI sink_Indicate(
901 IWbemObjectSink *iface, LONG count, IWbemClassObject **objects )
902 {
903 trace("Indicate: %d, %p\n", count, objects);
904 return S_OK;
905 }
906
907 static HRESULT WINAPI sink_SetStatus(
908 IWbemObjectSink *iface, LONG flags, HRESULT hresult, BSTR str_param, IWbemClassObject *obj_param )
909 {
910 trace("SetStatus: %08x, %08x, %s, %p\n", flags, hresult, wine_dbgstr_w(str_param), obj_param);
911 return S_OK;
912 }
913
914 static IWbemObjectSinkVtbl sink_vtbl =
915 {
916 sink_QueryInterface,
917 sink_AddRef,
918 sink_Release,
919 sink_Indicate,
920 sink_SetStatus
921 };
922
923 static IWbemObjectSink sink = { &sink_vtbl };
924
925 static void test_notification_query_async( IWbemServices *services )
926 {
927 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_DeviceChangeEvent" );
928 ULONG prev_sink_refs;
929 HRESULT hr;
930
931 hr = IWbemServices_ExecNotificationQueryAsync( services, wql, query, 0, NULL, NULL );
932 ok( hr == WBEM_E_INVALID_PARAMETER, "got %08x\n", hr );
933
934 prev_sink_refs = sink_refs;
935 hr = IWbemServices_ExecNotificationQueryAsync( services, wql, query, 0, NULL, &sink );
936 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND), "got %08x\n", hr );
937 ok( sink_refs > prev_sink_refs || broken(!sink_refs), "got %u refs\n", sink_refs );
938
939 hr = IWbemServices_CancelAsyncCall( services, &sink );
940 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND), "got %08x\n", hr );
941
942 SysFreeString( wql );
943 SysFreeString( query );
944 }
945
946 static void test_query_async( IWbemServices *services )
947 {
948 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_Process" );
949 HRESULT hr;
950
951 hr = IWbemServices_ExecQueryAsync( services, wql, query, 0, NULL, NULL );
952 ok( hr == WBEM_E_INVALID_PARAMETER, "got %08x\n", hr );
953
954 hr = IWbemServices_ExecQueryAsync( services, wql, query, 0, NULL, &sink );
955 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND), "got %08x\n", hr );
956
957 hr = IWbemServices_CancelAsyncCall( services, NULL );
958 ok( hr == WBEM_E_INVALID_PARAMETER, "got %08x\n", hr );
959
960 hr = IWbemServices_CancelAsyncCall( services, &sink );
961 ok( hr == S_OK, "got %08x\n", hr );
962
963 SysFreeString( wql );
964 SysFreeString( query );
965 }
966
967 static void test_query_semisync( IWbemServices *services )
968 {
969 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_Dummy" );
970 IEnumWbemClassObject *result;
971 IWbemClassObject *obj;
972 ULONG count;
973 HRESULT hr;
974
975 hr = IWbemServices_ExecQuery( services, wql, query, WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY,
976 NULL, &result );
977 ok( hr == S_OK, "got %08x\n", hr );
978
979 count = 1;
980 obj = (void *)0xdeadbeef;
981 hr = IEnumWbemClassObject_Next( result, -1, 1, &obj, &count );
982 todo_wine
983 ok( hr == WBEM_E_INVALID_CLASS, "Unexpected hr %#x.\n", hr );
984 ok( count == 0, "Unexpected count %u.\n", count );
985 ok( obj == (void *)0xdeadbeef, "Got object %p\n", obj );
986
987 IEnumWbemClassObject_Release( result );
988
989 SysFreeString( wql );
990 SysFreeString( query );
991 }
992
993 static void test_GetNames( IWbemServices *services )
994 {
995 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_OperatingSystem" );
996 IEnumWbemClassObject *result;
997 HRESULT hr;
998
999 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1000 ok( hr == S_OK, "got %08x\n", hr );
1001
1002 for (;;)
1003 {
1004 IWbemClassObject *obj;
1005 SAFEARRAY *names;
1006 ULONG count;
1007 VARIANT val;
1008
1009 IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1010 if (!count) break;
1011
1012 VariantInit( &val );
1013 hr = IWbemClassObject_GetNames( obj, NULL, WBEM_FLAG_NONSYSTEM_ONLY, &val, &names );
1014 ok( hr == S_OK, "got %08x\n", hr );
1015
1016 SafeArrayDestroy( names );
1017 IWbemClassObject_Release( obj );
1018 }
1019 IEnumWbemClassObject_Release( result );
1020 SysFreeString( query );
1021 SysFreeString( wql );
1022 }
1023
1024 static void test_SystemSecurity( IWbemServices *services )
1025 {
1026 BSTR class = SysAllocString( L"__SystemSecurity" ), method;
1027 IWbemClassObject *reg, *out;
1028 VARIANT retval, var_sd;
1029 void *data;
1030 SECURITY_DESCRIPTOR_RELATIVE *sd;
1031 CIMTYPE type;
1032 HRESULT hr;
1033 BYTE sid_admin_buffer[SECURITY_MAX_SID_SIZE];
1034 SID *sid_admin = (SID*)sid_admin_buffer;
1035 DWORD sid_size;
1036 BOOL ret;
1037
1038 hr = IWbemServices_GetObject( services, class, 0, NULL, &reg, NULL );
1039 if (hr != S_OK)
1040 {
1041 win_skip( "__SystemSecurity not available\n" );
1042 return;
1043 }
1044 IWbemClassObject_Release( reg );
1045
1046 sid_size = sizeof(sid_admin_buffer);
1047 ret = CreateWellKnownSid( WinBuiltinAdministratorsSid, NULL, sid_admin, &sid_size );
1048 ok( ret, "CreateWellKnownSid failed\n" );
1049
1050 out = NULL;
1051 method = SysAllocString( L"GetSD" );
1052 hr = IWbemServices_ExecMethod( services, class, method, 0, NULL, NULL, &out, NULL );
1053 ok( hr == S_OK || hr == WBEM_E_ACCESS_DENIED, "failed to execute method %08x\n", hr );
1054 SysFreeString( method );
1055
1056 if (SUCCEEDED(hr))
1057 {
1058 type = 0xdeadbeef;
1059 VariantInit( &retval );
1060 hr = IWbemClassObject_Get( out, L"ReturnValue", 0, &retval, &type, NULL );
1061 ok( hr == S_OK, "failed to get return value %08x\n", hr );
1062 ok( V_VT( &retval ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &retval ) );
1063 ok( !V_I4( &retval ), "unexpected error %u\n", V_UI4( &retval ) );
1064 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
1065
1066 type = 0xdeadbeef;
1067 VariantInit( &var_sd );
1068 hr = IWbemClassObject_Get( out, L"SD", 0, &var_sd, &type, NULL );
1069 ok( hr == S_OK, "failed to get names %08x\n", hr );
1070 ok( V_VT( &var_sd ) == (VT_UI1|VT_ARRAY), "unexpected variant type 0x%x\n", V_VT( &var_sd ) );
1071 ok( type == (CIM_UINT8|CIM_FLAG_ARRAY), "unexpected type 0x%x\n", type );
1072
1073 hr = SafeArrayAccessData( V_ARRAY( &var_sd ), &data );
1074 ok( hr == S_OK, "SafeArrayAccessData failed %x\n", hr );
1075 if (SUCCEEDED(hr))
1076 {
1077 sd = data;
1078
1079 ok( (sd->Control & SE_SELF_RELATIVE) == SE_SELF_RELATIVE, "relative flag unset\n" );
1080 ok( sd->Owner != 0, "no owner SID\n");
1081 ok( sd->Group != 0, "no owner SID\n");
1082 ok( EqualSid( (PSID)((LPBYTE)sd + sd->Owner), sid_admin ), "unexpected owner SID\n" );
1083 ok( EqualSid( (PSID)((LPBYTE)sd + sd->Group), sid_admin ), "unexpected group SID\n" );
1084
1085 hr = SafeArrayUnaccessData( V_ARRAY( &var_sd ) );
1086 ok( hr == S_OK, "SafeArrayUnaccessData failed %x\n", hr );
1087 }
1088
1089 VariantClear( &var_sd );
1090 IWbemClassObject_Release( out );
1091 }
1092 else if (hr == WBEM_E_ACCESS_DENIED)
1093 win_skip( "insufficient privs to test __SystemSecurity\n" );
1094
1095 SysFreeString( class );
1096 }
1097
1098 static void test_Win32_OperatingSystem( IWbemServices *services )
1099 {
1100 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_OperatingSystem" );
1101 IEnumWbemClassObject *result;
1102 IWbemClassObject *obj;
1103 CIMTYPE type;
1104 ULONG count;
1105 VARIANT val;
1106 HRESULT hr;
1107
1108 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1109 ok( hr == S_OK, "IWbemServices_ExecQuery failed %08x\n", hr );
1110
1111 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1112 ok( hr == S_OK, "IEnumWbemClassObject_Next failed %08x\n", hr );
1113
1114 hr = IWbemClassObject_BeginEnumeration( obj, 0 );
1115 ok( hr == S_OK, "got %08x\n", hr );
1116
1117 while (IWbemClassObject_Next( obj, 0, NULL, NULL, NULL, NULL ) == S_OK) {}
1118
1119 hr = IWbemClassObject_EndEnumeration( obj );
1120 ok( hr == S_OK, "got %08x\n", hr );
1121
1122 check_property( obj, L"BuildNumber", VT_BSTR, CIM_STRING );
1123 check_property( obj, L"Caption", VT_BSTR, CIM_STRING );
1124
1125 type = 0xdeadbeef;
1126 VariantInit( &val );
1127 hr = IWbemClassObject_Get( obj, L"CSDVersion", 0, &val, &type, NULL );
1128 ok( hr == S_OK, "failed to get csdversion %08x\n", hr );
1129 ok( V_VT( &val ) == VT_BSTR || V_VT( &val ) == VT_NULL, "unexpected variant type 0x%x\n", V_VT( &val ) );
1130 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
1131 trace( "csdversion: %s\n", wine_dbgstr_w(V_BSTR( &val )) );
1132 VariantClear( &val );
1133
1134 check_property( obj, L"FreePhysicalMemory", VT_BSTR, CIM_UINT64 );
1135 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
1136
1137 type = 0xdeadbeef;
1138 VariantInit( &val );
1139 hr = IWbemClassObject_Get( obj, L"OperatingSystemSKU", 0, &val, &type, NULL );
1140 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND) /* winxp */, "failed to get operatingsystemsku %08x\n", hr );
1141 if (hr == S_OK)
1142 {
1143 ok( V_VT( &val ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &val ) );
1144 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
1145 trace( "operatingsystemsku: %08x\n", V_I4( &val ) );
1146 VariantClear( &val );
1147 }
1148
1149 type = 0xdeadbeef;
1150 VariantInit( &val );
1151 hr = IWbemClassObject_Get( obj, L"OSProductSuite", 0, &val, &type, NULL );
1152 ok( hr == S_OK, "failed to get osproductsuite %08x\n", hr );
1153 ok( V_VT( &val ) == VT_I4 || broken(V_VT( &val ) == VT_NULL) /* winxp */, "unexpected variant type 0x%x\n", V_VT( &val ) );
1154 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
1155 trace( "osproductsuite: %d (%08x)\n", V_I4( &val ), V_I4( &val ) );
1156 VariantClear( &val );
1157
1158 check_property( obj, L"CSName", VT_BSTR, CIM_STRING );
1159 check_property( obj, L"CurrentTimeZone", VT_I2, CIM_SINT16 );
1160 check_property( obj, L"Manufacturer", VT_BSTR, CIM_STRING );
1161 check_property( obj, L"OSType", VT_I4, CIM_UINT16 );
1162 check_property( obj, L"ServicePackMajorVersion", VT_I4, CIM_UINT16 );
1163 check_property( obj, L"ServicePackMinorVersion", VT_I4, CIM_UINT16 );
1164 check_property( obj, L"SuiteMask", VT_I4, CIM_UINT32 );
1165 check_property( obj, L"Version", VT_BSTR, CIM_STRING );
1166 check_property( obj, L"TotalVisibleMemorySize", VT_BSTR, CIM_UINT64 );
1167 check_property( obj, L"TotalVirtualMemorySize", VT_BSTR, CIM_UINT64 );
1168 check_property( obj, L"SystemDrive", VT_BSTR, CIM_STRING );
1169
1170 IWbemClassObject_Release( obj );
1171 IEnumWbemClassObject_Release( result );
1172 SysFreeString( query );
1173 SysFreeString( wql );
1174 }
1175
1176 static void test_Win32_ComputerSystemProduct( IWbemServices *services )
1177 {
1178 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_ComputerSystemProduct" );
1179 IEnumWbemClassObject *result;
1180 IWbemClassObject *obj;
1181 HRESULT hr;
1182 DWORD count;
1183
1184 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1185 if (hr != S_OK)
1186 {
1187 win_skip( "Win32_ComputerSystemProduct not available\n" );
1188 return;
1189 }
1190
1191 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1192 ok( hr == S_OK, "got %08x\n", hr );
1193
1194 check_property( obj, L"IdentifyingNumber", VT_BSTR, CIM_STRING );
1195 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
1196 check_property( obj, L"SKUNumber", VT_NULL, CIM_STRING );
1197 check_property( obj, L"UUID", VT_BSTR, CIM_STRING );
1198 check_property( obj, L"Vendor", VT_BSTR, CIM_STRING );
1199 check_property( obj, L"Version", VT_BSTR, CIM_STRING );
1200
1201 IWbemClassObject_Release( obj );
1202 IEnumWbemClassObject_Release( result );
1203 SysFreeString( query );
1204 SysFreeString( wql );
1205 }
1206
1207 static void test_Win32_PhysicalMemory( IWbemServices *services )
1208 {
1209 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_PhysicalMemory" );
1210 IEnumWbemClassObject *result;
1211 IWbemClassObject *obj;
1212 CIMTYPE type;
1213 VARIANT val;
1214 DWORD count;
1215 HRESULT hr;
1216
1217 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1218 if (hr != S_OK)
1219 {
1220 win_skip( "Win32_PhysicalMemory not available\n" );
1221 return;
1222 }
1223
1224 for (;;)
1225 {
1226 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1227 if (hr != S_OK) break;
1228
1229 check_property( obj, L"BankLabel", VT_BSTR, CIM_STRING );
1230 check_property( obj, L"Capacity", VT_BSTR, CIM_UINT64 );
1231 check_property( obj, L"Caption", VT_BSTR, CIM_STRING );
1232 check_property( obj, L"DeviceLocator", VT_BSTR, CIM_STRING );
1233 check_property( obj, L"FormFactor", VT_I4, CIM_UINT16 );
1234 check_property( obj, L"MemoryType", VT_I4, CIM_UINT16 );
1235
1236 type = 0xdeadbeef;
1237 VariantInit( &val );
1238 hr = IWbemClassObject_Get( obj, L"ConfiguredClockSpeed", 0, &val, &type, NULL );
1239 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND) /* < win10 */, "got %08x\n", hr );
1240 if (hr == S_OK)
1241 {
1242 ok( V_VT( &val ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &val ) );
1243 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
1244 trace( "ConfiguredClockSpeed %u\n", V_I4( &val ) );
1245 }
1246
1247 type = 0xdeadbeef;
1248 VariantInit( &val );
1249 hr = IWbemClassObject_Get( obj, L"PartNumber", 0, &val, &type, NULL );
1250 ok( hr == S_OK, "got %08x\n", hr );
1251 ok( V_VT( &val ) == VT_BSTR || V_VT( &val ) == VT_NULL, "unexpected variant type 0x%x\n", V_VT( &val ) );
1252 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
1253 trace( "PartNumber %s\n", wine_dbgstr_w(V_BSTR( &val )) );
1254 VariantClear( &val );
1255
1256 type = 0xdeadbeef;
1257 VariantInit( &val );
1258 hr = IWbemClassObject_Get( obj, L"SerialNumber", 0, &val, &type, NULL );
1259 ok( hr == S_OK, "got %08x\n", hr );
1260 ok( V_VT( &val ) == VT_BSTR || V_VT( &val ) == VT_NULL, "unexpected variant type 0x%x\n", V_VT( &val ) );
1261 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
1262 trace( "SerialNumber %s\n", wine_dbgstr_w(V_BSTR( &val )) );
1263 VariantClear( &val );
1264
1265 IWbemClassObject_Release( obj );
1266 }
1267
1268 IEnumWbemClassObject_Release( result );
1269 SysFreeString( query );
1270 SysFreeString( wql );
1271 }
1272
1273 static void test_Win32_IP4RouteTable( IWbemServices *services )
1274 {
1275 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_IP4RouteTable" );
1276 IEnumWbemClassObject *result;
1277 IWbemClassObject *obj;
1278 HRESULT hr;
1279 DWORD count;
1280
1281 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1282 if (hr != S_OK)
1283 {
1284 win_skip( "Win32_IP4RouteTable not available\n" );
1285 return;
1286 }
1287
1288 for (;;)
1289 {
1290 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1291 if (hr != S_OK) break;
1292
1293 check_property( obj, L"Destination", VT_BSTR, CIM_STRING );
1294 check_property( obj, L"InterfaceIndex", VT_I4, CIM_SINT32 );
1295 check_property( obj, L"NextHop", VT_BSTR, CIM_STRING );
1296 IWbemClassObject_Release( obj );
1297 }
1298
1299 IEnumWbemClassObject_Release( result );
1300 SysFreeString( query );
1301 SysFreeString( wql );
1302 }
1303
1304 static void test_Win32_Processor( IWbemServices *services )
1305 {
1306 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_Processor" );
1307 IEnumWbemClassObject *result;
1308 IWbemClassObject *obj;
1309 VARIANT val;
1310 CIMTYPE type;
1311 HRESULT hr;
1312 DWORD count;
1313
1314 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1315 ok( hr == S_OK, "got %08x\n", hr );
1316
1317 for (;;)
1318 {
1319 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1320 if (hr != S_OK) break;
1321
1322 check_property( obj, L"Architecture", VT_I4, CIM_UINT16 );
1323 check_property( obj, L"Caption", VT_BSTR, CIM_STRING );
1324 check_property( obj, L"CpuStatus", VT_I4, CIM_UINT16 );
1325 check_property( obj, L"Family", VT_I4, CIM_UINT16 );
1326 check_property( obj, L"Level", VT_I4, CIM_UINT16 );
1327 check_property( obj, L"Manufacturer", VT_BSTR, CIM_STRING );
1328 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
1329 check_property( obj, L"ProcessorId", VT_BSTR, CIM_STRING );
1330 check_property( obj, L"Revision", VT_I4, CIM_UINT16 );
1331 check_property( obj, L"Version", VT_BSTR, CIM_STRING );
1332
1333 type = 0xdeadbeef;
1334 VariantInit( &val );
1335 hr = IWbemClassObject_Get( obj, L"NumberOfLogicalProcessors", 0, &val, &type, NULL );
1336 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND) /* win2k3 */, "got %08x\n", hr );
1337 if (hr == S_OK)
1338 {
1339 ok( V_VT( &val ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &val ) );
1340 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
1341 trace( "numlogicalprocessors %u\n", V_I4( &val ) );
1342 }
1343
1344 type = 0xdeadbeef;
1345 VariantInit( &val );
1346 hr = IWbemClassObject_Get( obj, L"NumberOfCores", 0, &val, &type, NULL );
1347 ok( hr == S_OK || broken(hr == WBEM_E_NOT_FOUND) /* win2k3 */, "got %08x\n", hr );
1348 if (hr == S_OK)
1349 {
1350 ok( V_VT( &val ) == VT_I4, "unexpected variant type 0x%x\n", V_VT( &val ) );
1351 ok( type == CIM_UINT32, "unexpected type 0x%x\n", type );
1352 trace( "numcores %u\n", V_I4( &val ) );
1353 }
1354
1355 IWbemClassObject_Release( obj );
1356 }
1357
1358 IEnumWbemClassObject_Release( result );
1359 SysFreeString( query );
1360 SysFreeString( wql );
1361 }
1362
1363 static void test_Win32_VideoController( IWbemServices *services )
1364 {
1365 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_VideoController" );
1366 IEnumWbemClassObject *result;
1367 IWbemClassObject *obj;
1368 VARIANT val;
1369 CIMTYPE type;
1370 HRESULT hr;
1371 DWORD count;
1372
1373 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1374 if (hr != S_OK)
1375 {
1376 win_skip( "Win32_VideoController not available\n" );
1377 return;
1378 }
1379
1380 for (;;)
1381 {
1382 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1383 if (hr != S_OK) break;
1384
1385 check_property( obj, L"AdapterCompatibility", VT_BSTR, CIM_STRING );
1386 check_property( obj, L"Availability", VT_I4, CIM_UINT16 );
1387 check_property( obj, L"ConfigManagerErrorCode", VT_I4, CIM_UINT32 );
1388 check_property( obj, L"DriverDate", VT_BSTR, CIM_DATETIME );
1389
1390 type = 0xdeadbeef;
1391 VariantInit( &val );
1392 hr = IWbemClassObject_Get( obj, L"InstalledDisplayDrivers", 0, &val, &type, NULL );
1393 ok( hr == S_OK, "got %08x\n", hr );
1394 ok( V_VT( &val ) == VT_BSTR || V_VT( &val ) == VT_NULL, "unexpected variant type 0x%x\n", V_VT( &val ) );
1395 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
1396 trace( "installeddisplaydrivers %s\n", wine_dbgstr_w(V_BSTR( &val )) );
1397 VariantClear( &val );
1398
1399 check_property( obj, L"Status", VT_BSTR, CIM_STRING );
1400 IWbemClassObject_Release( obj );
1401 }
1402
1403 IEnumWbemClassObject_Release( result );
1404 SysFreeString( query );
1405 SysFreeString( wql );
1406 }
1407
1408 static void test_Win32_Printer( IWbemServices *services )
1409 {
1410 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_Printer" );
1411 IEnumWbemClassObject *result;
1412 IWbemClassObject *obj;
1413 VARIANT val;
1414 CIMTYPE type;
1415 HRESULT hr;
1416 DWORD count;
1417
1418 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1419 if (hr != S_OK)
1420 {
1421 win_skip( "Win32_Printer not available\n" );
1422 return;
1423 }
1424
1425 for (;;)
1426 {
1427 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1428 if (hr != S_OK) break;
1429
1430 check_property( obj, L"Attributes", VT_I4, CIM_UINT32 );
1431 check_property( obj, L"DeviceId", VT_BSTR, CIM_STRING );
1432 check_property( obj, L"HorizontalResolution", VT_I4, CIM_UINT32 );
1433
1434 type = 0xdeadbeef;
1435 memset( &val, 0, sizeof(val) );
1436 hr = IWbemClassObject_Get( obj, L"Location", 0, &val, &type, NULL );
1437 ok( hr == S_OK, "got %08x\n", hr );
1438 ok( V_VT( &val ) == VT_BSTR || V_VT( &val ) == VT_NULL, "unexpected variant type 0x%x\n", V_VT( &val ) );
1439 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
1440 trace( "location %s\n", wine_dbgstr_w(V_BSTR( &val )) );
1441 VariantClear( &val );
1442
1443 check_property( obj, L"PortName", VT_BSTR, CIM_STRING );
1444 IWbemClassObject_Release( obj );
1445 }
1446
1447 IEnumWbemClassObject_Release( result );
1448 SysFreeString( query );
1449 SysFreeString( wql );
1450 }
1451
1452 static void test_Win32_PnPEntity( IWbemServices *services )
1453 {
1454 HRESULT hr;
1455 IEnumWbemClassObject *enm;
1456 IWbemClassObject *obj;
1457 VARIANT val;
1458 CIMTYPE type;
1459 ULONG count, i;
1460 BSTR bstr;
1461
1462 bstr = SysAllocString( L"Win32_PnPEntity" );
1463 hr = IWbemServices_CreateInstanceEnum( services, bstr, 0, NULL, &enm );
1464 ok( hr == S_OK, "got %08x\n", hr );
1465 SysFreeString( bstr );
1466
1467 bstr = SysAllocString( L"DeviceId" );
1468 while (1)
1469 {
1470 hr = IEnumWbemClassObject_Next( enm, 1000, 1, &obj, &count );
1471 ok( (count == 1 && (hr == WBEM_S_FALSE || hr == WBEM_S_NO_ERROR)) ||
1472 (count == 0 && (hr == WBEM_S_FALSE || hr == WBEM_S_TIMEDOUT)),
1473 "got %08x with %u objects returned\n", hr, count );
1474
1475 if (count == 0)
1476 break;
1477
1478 for (i = 0; i < count; ++i)
1479 {
1480 hr = IWbemClassObject_Get( obj, bstr, 0, &val, &type, NULL );
1481 ok( hr == S_OK, "got %08x\n", hr );
1482
1483 if (SUCCEEDED( hr ))
1484 {
1485 ok( V_VT( &val ) == VT_BSTR, "unexpected variant type 0x%x\n", V_VT( &val ) );
1486 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
1487 VariantClear( &val );
1488 }
1489 }
1490 IWbemClassObject_Release( obj );
1491 }
1492
1493 SysFreeString( bstr );
1494 IEnumWbemClassObject_Release( enm );
1495 }
1496
1497 static void test_Win32_WinSAT( IWbemServices *services )
1498 {
1499 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_WinSAT" );
1500 IEnumWbemClassObject *result;
1501 IWbemClassObject *obj;
1502 HRESULT hr;
1503 DWORD count;
1504
1505 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1506 ok( hr == S_OK || broken(hr == WBEM_E_INVALID_CLASS) /* win2k8 */, "got %08x\n", hr );
1507 if (hr == WBEM_E_INVALID_CLASS)
1508 {
1509 win_skip( "class not found\n" );
1510 return;
1511 }
1512
1513 for (;;)
1514 {
1515 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1516 if (hr != S_OK) break;
1517
1518 check_property( obj, L"CPUScore", VT_R4, CIM_REAL32 );
1519 check_property( obj, L"D3DScore", VT_R4, CIM_REAL32 );
1520 check_property( obj, L"DiskScore", VT_R4, CIM_REAL32 );
1521 check_property( obj, L"GraphicsScore", VT_R4, CIM_REAL32 );
1522 check_property( obj, L"MemoryScore", VT_R4, CIM_REAL32 );
1523 check_property( obj, L"WinSATAssessmentState", VT_I4, CIM_UINT32 );
1524 check_property( obj, L"WinSPRLevel", VT_R4, CIM_REAL32 );
1525 IWbemClassObject_Release( obj );
1526 }
1527
1528 IEnumWbemClassObject_Release( result );
1529 SysFreeString( query );
1530 SysFreeString( wql );
1531 }
1532
1533 static void test_Win32_DesktopMonitor( IWbemServices *services )
1534 {
1535 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_DesktopMonitor" );
1536 IEnumWbemClassObject *result;
1537 IWbemClassObject *obj;
1538 HRESULT hr;
1539 DWORD count;
1540
1541 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1542 ok( hr == S_OK, "got %08x\n", hr );
1543
1544 for (;;)
1545 {
1546 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1547 if (hr != S_OK) break;
1548
1549 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
1550 check_property( obj, L"PixelsPerXlogicalInch", VT_I4, CIM_UINT32 );
1551 IWbemClassObject_Release( obj );
1552 }
1553
1554 IEnumWbemClassObject_Release( result );
1555 SysFreeString( query );
1556 SysFreeString( wql );
1557 }
1558
1559 static void test_Win32_DiskDrive( IWbemServices *services )
1560 {
1561 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_DiskDrive" );
1562 IEnumWbemClassObject *result;
1563 IWbemClassObject *obj;
1564 HRESULT hr;
1565 DWORD count;
1566
1567 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1568 ok( hr == S_OK, "got %08x\n", hr );
1569
1570 for (;;)
1571 {
1572 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1573 if (hr != S_OK) break;
1574
1575 check_property( obj, L"DeviceID", VT_BSTR, CIM_STRING );
1576 IWbemClassObject_Release( obj );
1577 }
1578
1579 IEnumWbemClassObject_Release( result );
1580 SysFreeString( query );
1581 SysFreeString( wql );
1582 }
1583
1584 static void test_Win32_DisplayControllerConfiguration( IWbemServices *services )
1585 {
1586 BSTR wql = SysAllocString( L"wql" );
1587 BSTR query = SysAllocString( L"SELECT * FROM Win32_DisplayControllerConfiguration" );
1588 IEnumWbemClassObject *result;
1589 IWbemClassObject *obj;
1590 HRESULT hr;
1591 DWORD count;
1592
1593 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1594 ok( hr == S_OK, "got %08x\n", hr );
1595
1596 for (;;)
1597 {
1598 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1599 if (hr != S_OK) break;
1600
1601 check_property( obj, L"BitsPerPixel", VT_I4, CIM_UINT32 );
1602 check_property( obj, L"Caption", VT_BSTR, CIM_STRING );
1603 check_property( obj, L"HorizontalResolution", VT_I4, CIM_UINT32 );
1604 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
1605 check_property( obj, L"VerticalResolution", VT_I4, CIM_UINT32 );
1606 IWbemClassObject_Release( obj );
1607 }
1608
1609 IEnumWbemClassObject_Release( result );
1610 SysFreeString( query );
1611 SysFreeString( wql );
1612 }
1613
1614 static void test_Win32_QuickFixEngineering( IWbemServices *services )
1615 {
1616 BSTR wql = SysAllocString( L"wql" ), query = SysAllocString( L"SELECT * FROM Win32_QuickFixEngineering" );
1617 IEnumWbemClassObject *result;
1618 IWbemClassObject *obj;
1619 HRESULT hr;
1620 DWORD count, total = 0;
1621 VARIANT caption;
1622 CIMTYPE type;
1623
1624 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1625 ok( hr == S_OK, "got %08x\n", hr );
1626
1627 for (;;)
1628 {
1629 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1630 if (hr != S_OK) break;
1631
1632 type = 0xdeadbeef;
1633 VariantInit( &caption );
1634 hr = IWbemClassObject_Get( obj, L"Caption", 0, &caption, &type, NULL );
1635 ok( hr == S_OK, "failed to get caption %08x\n", hr );
1636 ok( V_VT( &caption ) == VT_BSTR || V_VT( &caption ) == VT_NULL /* winxp */,
1637 "unexpected variant type 0x%x\n", V_VT( &caption ) );
1638 ok( type == CIM_STRING, "unexpected type 0x%x\n", type );
1639
1640 check_property( obj, L"HotFixID", VT_BSTR, CIM_STRING );
1641 IWbemClassObject_Release( obj );
1642 if (total++ >= 10) break;
1643 }
1644
1645 IEnumWbemClassObject_Release( result );
1646 SysFreeString( query );
1647 SysFreeString( wql );
1648 }
1649
1650 static void test_Win32_SoundDevice( IWbemServices *services )
1651 {
1652 BSTR wql = SysAllocString( L"wql" );
1653 BSTR query = SysAllocString( L"SELECT * FROM Win32_SoundDevice" );
1654 IEnumWbemClassObject *result;
1655 IWbemClassObject *obj;
1656 HRESULT hr;
1657 DWORD count;
1658
1659 hr = IWbemServices_ExecQuery( services, wql, query, 0, NULL, &result );
1660 ok( hr == S_OK, "got %08x\n", hr );
1661
1662 for (;;)
1663 {
1664 hr = IEnumWbemClassObject_Next( result, 10000, 1, &obj, &count );
1665 if (hr != S_OK) break;
1666
1667 check_property( obj, L"Name", VT_BSTR, CIM_STRING );
1668 check_property( obj, L"ProductName", VT_BSTR, CIM_STRING );
1669 check_property( obj, L"StatusInfo", VT_I4, CIM_UINT16 );
1670 check_property( obj, L"Manufacturer", VT_BSTR, CIM_STRING );
1671 IWbemClassObject_Release( obj );
1672 }
1673
1674 IEnumWbemClassObject_Release( result );
1675 SysFreeString( query );
1676 SysFreeString( wql );
1677 }
1678
1679 START_TEST(query)
1680 {
1681 BSTR path = SysAllocString( L"ROOT\\CIMV2" );
1682 IWbemLocator *locator;
1683 IWbemServices *services;
1684 HRESULT hr;
1685
1686 CoInitialize( NULL );
1687 CoInitializeSecurity( NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_DEFAULT,
1688 RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL );
1689 hr = CoCreateInstance( &CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER, &IID_IWbemLocator,
1690 (void **)&locator );
1691 if (hr != S_OK)
1692 {
1693 win_skip("can't create instance of WbemLocator\n");
1694 return;
1695 }
1696 hr = IWbemLocator_ConnectServer( locator, path, NULL, NULL, NULL, 0, NULL, NULL, &services );
1697 ok( hr == S_OK, "failed to get IWbemServices interface %08x\n", hr );
1698
1699 hr = CoSetProxyBlanket( (IUnknown *)services, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL,
1700 RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE );
1701 ok( hr == S_OK, "failed to set proxy blanket %08x\n", hr );
1702
1703 test_GetNames( services );
1704 test_IEnumWbemClassObject_Next( services );
1705 test_associators( services );
1706 test_notification_query_async( services );
1707 test_query_async( services );
1708 test_query_semisync( services );
1709 test_select( services );
1710
1711 /* classes */
1712 test_StdRegProv( services );
1713 test_SystemSecurity( services );
1714 test_Win32_Baseboard( services );
1715 test_Win32_ComputerSystem( services );
1716 test_Win32_ComputerSystemProduct( services );
1717 test_Win32_Bios( services );
1718 test_Win32_DesktopMonitor( services );
1719 test_Win32_DiskDrive( services );
1720 test_Win32_DisplayControllerConfiguration( services );
1721 test_Win32_IP4RouteTable( services );
1722 test_Win32_OperatingSystem( services );
1723 test_Win32_PhysicalMemory( services );
1724 test_Win32_PnPEntity( services );
1725 test_Win32_Printer( services );
1726 test_Win32_Process( services, FALSE );
1727 test_Win32_Process( services, TRUE );
1728 test_Win32_Processor( services );
1729 test_Win32_QuickFixEngineering( services );
1730 test_Win32_Service( services );
1731 test_Win32_SoundDevice( services );
1732 test_Win32_SystemEnclosure( services );
1733 test_Win32_VideoController( services );
1734 test_Win32_WinSAT( services );
1735
1736 SysFreeString( path );
1737 IWbemServices_Release( services );
1738 IWbemLocator_Release( locator );
1739 CoUninitialize();
1740 }
Windows API implementation