?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pdh: Implement and test PdhGetDllVersion.
[wine/multimedia.git] / dlls / pdh / tests / pdh.c
blob094ad74f14bef17c64d764e309149121c26d6f86
1 /*
2 * Tests for pdh.dll (Performance Data Helper)
3 *
4 * Copyright 2007 Hans Leidekker
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdio.h>
22
23 #include "windows.h"
24
25 #include "pdh.h"
26 #include "pdhmsg.h"
27
28 #include "wine/test.h"
29
30 static HMODULE pdh;
31
32 static PDH_STATUS (WINAPI *pPdhAddEnglishCounterA)(PDH_HQUERY, LPCSTR, DWORD_PTR, PDH_HCOUNTER *);
33 static PDH_STATUS (WINAPI *pPdhAddEnglishCounterW)(PDH_HQUERY, LPCWSTR, DWORD_PTR, PDH_HCOUNTER *);
34 static PDH_STATUS (WINAPI *pPdhCollectQueryDataWithTime)(PDH_HQUERY, LONGLONG *);
35 static PDH_STATUS (WINAPI *pPdhValidatePathExA)(PDH_HLOG, LPCSTR);
36 static PDH_STATUS (WINAPI *pPdhValidatePathExW)(PDH_HLOG, LPCWSTR);
37
38 #define GETFUNCPTR(func) p##func = (void *)GetProcAddress( pdh, #func );
39
40 static void init_function_ptrs( void )
41 {
42 pdh = GetModuleHandle( "pdh" );
43 GETFUNCPTR( PdhAddEnglishCounterA )
44 GETFUNCPTR( PdhAddEnglishCounterW )
45 GETFUNCPTR( PdhCollectQueryDataWithTime )
46 GETFUNCPTR( PdhValidatePathExA )
47 GETFUNCPTR( PdhValidatePathExW )
48 }
49
50 static const WCHAR processor_time[] =
51 {'%',' ','P','r','o','c','e','s','s','o','r',' ','T','i','m','e',0};
52 static const WCHAR uptime[] =
53 {'S','y','s','t','e','m',' ','U','p',' ','T','i','m','e',0};
54
55 static const WCHAR system_uptime[] =
56 {'\\','S','y','s','t','e','m','\\','S','y','s','t','e','m',' ','U','p',' ','T','i','m','e',0};
57 static const WCHAR system_downtime[] = /* does not exist */
58 {'\\','S','y','s','t','e','m','\\','S','y','s','t','e','m',' ','D','o','w','n',' ','T','i','m','e',0};
59 static const WCHAR percentage_processor_time[] =
60 {'\\','P','r','o','c','e','s','s','o','r','(','_','T','o','t','a','l',')',
61 '\\','%',' ','P','r','o','c','e','s','s','o','r',' ','T','i','m','e',0};
62
63 static void test_PdhOpenQueryA( void )
64 {
65 PDH_STATUS ret;
66 PDH_HQUERY query;
67
68 ret = PdhOpenQueryA( NULL, 0, NULL );
69 ok(ret == PDH_INVALID_ARGUMENT, "PdhOpenQueryA failed 0x%08x\n", ret);
70
71 ret = PdhOpenQueryA( NULL, 0, &query );
72 ok(ret == ERROR_SUCCESS, "PdhOpenQueryA failed 0x%08x\n", ret);
73
74 ret = PdhCloseQuery( NULL );
75 ok(ret == PDH_INVALID_HANDLE, "PdhCloseQuery failed 0x%08x\n", ret);
76
77 ret = PdhCloseQuery( &query );
78 ok(ret == PDH_INVALID_HANDLE, "PdhCloseQuery failed 0x%08x\n", ret);
79
80 ret = PdhCloseQuery( query );
81 ok(ret == ERROR_SUCCESS, "PdhCloseQuery failed 0x%08x\n", ret);
82
83 ret = PdhCloseQuery( query );
84 ok(ret == PDH_INVALID_HANDLE, "PdhCloseQuery failed 0x%08x\n", ret);
85 }
86
87 static void test_PdhOpenQueryW( void )
88 {
89 PDH_STATUS ret;
90 PDH_HQUERY query;
91
92 ret = PdhOpenQueryW( NULL, 0, NULL );
93 ok(ret == PDH_INVALID_ARGUMENT, "PdhOpenQueryW failed 0x%08x\n", ret);
94
95 ret = PdhOpenQueryW( NULL, 0, &query );
96 ok(ret == ERROR_SUCCESS, "PdhOpenQueryW failed 0x%08x\n", ret);
97
98 ret = PdhCloseQuery( NULL );
99 ok(ret == PDH_INVALID_HANDLE, "PdhCloseQuery failed 0x%08x\n", ret);
100
101 ret = PdhCloseQuery( &query );
102 ok(ret == PDH_INVALID_HANDLE, "PdhCloseQuery failed 0x%08x\n", ret);
103
104 ret = PdhCloseQuery( query );
105 ok(ret == ERROR_SUCCESS, "PdhCloseQuery failed 0x%08x\n", ret);
106
107 ret = PdhCloseQuery( query );
108 ok(ret == PDH_INVALID_HANDLE, "PdhCloseQuery failed 0x%08x\n", ret);
109 }
110
111 static void test_PdhAddCounterA( void )
112 {
113 PDH_STATUS ret;
114 PDH_HQUERY query;
115 PDH_HCOUNTER counter;
116
117 ret = PdhOpenQueryA( NULL, 0, &query );
118 ok(ret == ERROR_SUCCESS, "PdhOpenQueryA failed 0x%08x\n", ret);
119
120 ret = PdhAddCounterA( NULL, "\\System\\System Up Time", 0, NULL );
121 ok(ret == PDH_INVALID_ARGUMENT, "PdhAddCounterA failed 0x%08x\n", ret);
122
123 ret = PdhAddCounterA( NULL, "\\System\\System Up Time", 0, &counter );
124 ok(ret == PDH_INVALID_HANDLE, "PdhAddCounterA failed 0x%08x\n", ret);
125
126 ret = PdhAddCounterA( query, NULL, 0, &counter );
127 ok(ret == PDH_INVALID_ARGUMENT, "PdhAddCounterA failed 0x%08x\n", ret);
128
129 ret = PdhAddCounterA( query, "\\System\\System Up Time", 0, NULL );
130 ok(ret == PDH_INVALID_ARGUMENT, "PdhAddCounterA failed 0x%08x\n", ret);
131
132 ret = PdhAddCounterA( query, "\\System\\System Down Time", 0, &counter );
133 ok(ret == PDH_CSTATUS_NO_COUNTER, "PdhAddCounterA failed 0x%08x\n", ret);
134 ok(!counter, "PdhAddCounterA failed %p\n", counter);
135
136 ret = PdhAddCounterA( query, "\\System\\System Up Time", 0, &counter );
137 ok(ret == ERROR_SUCCESS, "PdhAddCounterA failed 0x%08x\n", ret);
138
139 ret = PdhCollectQueryData( NULL );
140 ok(ret == PDH_INVALID_HANDLE, "PdhCollectQueryData failed 0x%08x\n", ret);
141
142 ret = PdhCollectQueryData( counter );
143 ok(ret == PDH_INVALID_HANDLE, "PdhCollectQueryData failed 0x%08x\n", ret);
144
145 ret = PdhCollectQueryData( query );
146 ok(ret == ERROR_SUCCESS, "PdhCollectQueryData failed 0x%08x\n", ret);
147
148 ret = PdhRemoveCounter( NULL );
149 ok(ret == PDH_INVALID_HANDLE, "PdhRemoveCounter failed 0x%08x\n", ret);
150
151 ret = PdhRemoveCounter( counter );
152 ok(ret == ERROR_SUCCESS, "PdhRemoveCounter failed 0x%08x\n", ret);
153
154 ret = PdhCloseQuery( query );
155 ok(ret == ERROR_SUCCESS, "PdhCloseQuery failed 0x%08x\n", ret);
156 }
157
158 static void test_PdhAddCounterW( void )
159 {
160 PDH_STATUS ret;
161 PDH_HQUERY query;
162 PDH_HCOUNTER counter;
163
164 ret = PdhOpenQueryW( NULL, 0, &query );
165 ok(ret == ERROR_SUCCESS, "PdhOpenQueryW failed 0x%08x\n", ret);
166
167 ret = PdhAddCounterW( NULL, percentage_processor_time, 0, NULL );
168 ok(ret == PDH_INVALID_ARGUMENT, "PdhAddCounterW failed 0x%08x\n", ret);
169
170 ret = PdhAddCounterW( NULL, percentage_processor_time, 0, &counter );
171 ok(ret == PDH_INVALID_HANDLE, "PdhAddCounterW failed 0x%08x\n", ret);
172
173 ret = PdhAddCounterW( query, NULL, 0, &counter );
174 ok(ret == PDH_INVALID_ARGUMENT, "PdhAddCounterW failed 0x%08x\n", ret);
175
176 ret = PdhAddCounterW( query, percentage_processor_time, 0, NULL );
177 ok(ret == PDH_INVALID_ARGUMENT, "PdhAddCounterW failed 0x%08x\n", ret);
178
179 ret = PdhAddCounterW( query, system_downtime, 0, &counter );
180 ok(ret == PDH_CSTATUS_NO_COUNTER, "PdhAddCounterW failed 0x%08x\n", ret);
181 ok(!counter, "PdhAddCounterW failed %p\n", counter);
182
183 ret = PdhAddCounterW( query, percentage_processor_time, 0, &counter );
184 ok(ret == ERROR_SUCCESS, "PdhAddCounterW failed 0x%08x\n", ret);
185
186 ret = PdhCollectQueryData( NULL );
187 ok(ret == PDH_INVALID_HANDLE, "PdhCollectQueryData failed 0x%08x\n", ret);
188
189 ret = PdhCollectQueryData( counter );
190 ok(ret == PDH_INVALID_HANDLE, "PdhCollectQueryData failed 0x%08x\n", ret);
191
192 ret = PdhCollectQueryData( query );
193 ok(ret == ERROR_SUCCESS, "PdhCollectQueryData failed 0x%08x\n", ret);
194
195 ret = PdhRemoveCounter( NULL );
196 ok(ret == PDH_INVALID_HANDLE, "PdhRemoveCounter failed 0x%08x\n", ret);
197
198 ret = PdhRemoveCounter( counter );
199 ok(ret == ERROR_SUCCESS, "PdhRemoveCounter failed 0x%08x\n", ret);
200
201 ret = PdhCloseQuery( query );
202 ok(ret == ERROR_SUCCESS, "PdhCloseQuery failed 0x%08x\n", ret);
203 }
204
205 static void test_PdhAddEnglishCounterA( void )
206 {
207 PDH_STATUS ret;
208 PDH_HQUERY query;
209 PDH_HCOUNTER counter;
210
211 ret = PdhOpenQueryA( NULL, 0, &query );
212 ok(ret == ERROR_SUCCESS, "PdhOpenQueryA failed 0x%08x\n", ret);
213
214 ret = PdhCollectQueryData( query );
215 ok(ret == PDH_NO_DATA, "PdhCollectQueryData failed 0x%08x\n", ret);
216
217 ret = pPdhAddEnglishCounterA( NULL, "\\System\\System Up Time", 0, NULL );
218 ok(ret == PDH_INVALID_ARGUMENT, "PdhAddEnglishCounterA failed 0x%08x\n", ret);
219
220 ret = pPdhAddEnglishCounterA( NULL, "\\System\\System Up Time", 0, &counter );
221 ok(ret == PDH_INVALID_ARGUMENT, "PdhAddEnglishCounterA failed 0x%08x\n", ret);
222
223 ret = pPdhAddEnglishCounterA( query, NULL, 0, &counter );
224 ok(ret == PDH_INVALID_ARGUMENT, "PdhAddEnglishCounterA failed 0x%08x\n", ret);
225
226 ret = pPdhAddEnglishCounterA( query, "\\System\\System Up Time", 0, NULL );
227 ok(ret == PDH_INVALID_ARGUMENT, "PdhAddEnglishCounterA failed 0x%08x\n", ret);
228
229 ret = pPdhAddEnglishCounterA( query, "\\System\\System Down Time", 0, &counter );
230 ok(ret == PDH_CSTATUS_NO_COUNTER, "PdhAddEnglishCounterA failed 0x%08x\n", ret);
231 ok(!counter, "PdhAddEnglishCounterA failed %p\n", counter);
232
233 ret = pPdhAddEnglishCounterA( query, "\\System\\System Up Time", 0, &counter );
234 ok(ret == ERROR_SUCCESS, "PdhAddEnglishCounterA failed 0x%08x\n", ret);
235
236 ret = PdhCollectQueryData( query );
237 ok(ret == ERROR_SUCCESS, "PdhCollectQueryData failed 0x%08x\n", ret);
238
239 ret = PdhRemoveCounter( counter );
240 ok(ret == ERROR_SUCCESS, "PdhRemoveCounter failed 0x%08x\n", ret);
241
242 ret = PdhCloseQuery( query );
243 ok(ret == ERROR_SUCCESS, "PdhCloseQuery failed 0x%08x\n", ret);
244 }
245
246 static void test_PdhAddEnglishCounterW( void )
247 {
248 PDH_STATUS ret;
249 PDH_HQUERY query;
250 PDH_HCOUNTER counter;
251
252 ret = PdhOpenQueryW( NULL, 0, &query );
253 ok(ret == ERROR_SUCCESS, "PdhOpenQueryW failed 0x%08x\n", ret);
254
255 ret = PdhCollectQueryData( query );
256 ok(ret == PDH_NO_DATA, "PdhCollectQueryData failed 0x%08x\n", ret);
257
258 ret = pPdhAddEnglishCounterW( NULL, system_uptime, 0, NULL );
259 ok(ret == PDH_INVALID_ARGUMENT, "PdhAddEnglishCounterW failed 0x%08x\n", ret);
260
261 ret = pPdhAddEnglishCounterW( NULL, system_uptime, 0, &counter );
262 ok(ret == PDH_INVALID_ARGUMENT, "PdhAddEnglishCounterW failed 0x%08x\n", ret);
263
264 ret = pPdhAddEnglishCounterW( query, NULL, 0, &counter );
265 ok(ret == PDH_INVALID_ARGUMENT, "PdhAddEnglishCounterW failed 0x%08x\n", ret);
266
267 ret = pPdhAddEnglishCounterW( query, system_uptime, 0, NULL );
268 ok(ret == PDH_INVALID_ARGUMENT, "PdhAddEnglishCounterW failed 0x%08x\n", ret);
269
270 ret = pPdhAddEnglishCounterW( query, system_downtime, 0, &counter );
271 ok(ret == PDH_CSTATUS_NO_COUNTER, "PdhAddEnglishCounterW failed 0x%08x\n", ret);
272 ok(!counter, "PdhAddEnglishCounterA failed %p\n", counter);
273
274 ret = pPdhAddEnglishCounterW( query, system_uptime, 0, &counter );
275 ok(ret == ERROR_SUCCESS, "PdhAddEnglishCounterW failed 0x%08x\n", ret);
276
277 ret = PdhCollectQueryData( query );
278 ok(ret == ERROR_SUCCESS, "PdhCollectQueryData failed 0x%08x\n", ret);
279
280 ret = PdhRemoveCounter( counter );
281 ok(ret == ERROR_SUCCESS, "PdhRemoveCounter failed 0x%08x\n", ret);
282
283 ret = PdhCloseQuery( query );
284 ok(ret == ERROR_SUCCESS, "PdhCloseQuery failed 0x%08x\n", ret);
285 }
286
287 static void test_PdhCollectQueryDataWithTime( void )
288 {
289 PDH_STATUS ret;
290 PDH_HQUERY query;
291 PDH_HCOUNTER counter;
292 LONGLONG time;
293
294 ret = PdhOpenQueryA( NULL, 0, &query );
295 ok(ret == ERROR_SUCCESS, "PdhOpenQueryA failed 0x%08x\n", ret);
296
297 ret = PdhCollectQueryData( query );
298 ok(ret == PDH_NO_DATA, "PdhCollectQueryData failed 0x%08x\n", ret);
299
300 ret = PdhAddCounterA( query, "\\System\\System Up Time", 0, &counter );
301 ok(ret == ERROR_SUCCESS, "PdhAddCounterA failed 0x%08x\n", ret);
302
303 ret = pPdhCollectQueryDataWithTime( NULL, NULL );
304 ok(ret == PDH_INVALID_ARGUMENT, "PdhCollectQueryDataWithTime failed 0x%08x\n", ret);
305
306 ret = pPdhCollectQueryDataWithTime( query, NULL );
307 ok(ret == PDH_INVALID_ARGUMENT, "PdhCollectQueryDataWithTime failed 0x%08x\n", ret);
308
309 ret = pPdhCollectQueryDataWithTime( NULL, &time );
310 ok(ret == PDH_INVALID_HANDLE, "PdhCollectQueryDataWithTime failed 0x%08x\n", ret);
311
312 ret = pPdhCollectQueryDataWithTime( query, &time );
313 ok(ret == ERROR_SUCCESS, "PdhCollectQueryDataWithTime failed 0x%08x\n", ret);
314
315 ret = PdhCloseQuery( query );
316 ok(ret == ERROR_SUCCESS, "PdhCloseQuery failed 0x%08x\n", ret);
317 }
318
319 static void test_PdhGetFormattedCounterValue( void )
320 {
321 PDH_STATUS ret;
322 PDH_HQUERY query;
323 PDH_HCOUNTER counter;
324 PDH_FMT_COUNTERVALUE value;
325
326 ret = PdhOpenQueryA( NULL, 0, &query );
327 ok(ret == ERROR_SUCCESS, "PdhOpenQueryA failed 0x%08x\n", ret);
328
329 ret = PdhAddCounterA( query, "\\System\\System Up Time", 0, &counter );
330 ok(ret == ERROR_SUCCESS, "PdhAddCounterA failed 0x%08x\n", ret);
331
332 ret = PdhGetFormattedCounterValue( NULL, PDH_FMT_LARGE, NULL, NULL );
333 ok(ret == PDH_INVALID_ARGUMENT, "PdhGetFormattedCounterValue failed 0x%08x\n", ret);
334
335 ret = PdhGetFormattedCounterValue( NULL, PDH_FMT_LARGE, NULL, &value );
336 ok(ret == PDH_INVALID_HANDLE, "PdhGetFormattedCounterValue failed 0x%08x\n", ret);
337
338 ret = PdhGetFormattedCounterValue( counter, PDH_FMT_LARGE, NULL, NULL );
339 ok(ret == PDH_INVALID_ARGUMENT, "PdhGetFormattedCounterValue failed 0x%08x\n", ret);
340
341 ret = PdhGetFormattedCounterValue( counter, PDH_FMT_LARGE, NULL, &value );
342 ok(ret == ERROR_SUCCESS, "PdhGetFormattedCounterValue failed 0x%08x\n", ret);
343
344 ret = PdhCollectQueryData( query );
345 ok(ret == ERROR_SUCCESS, "PdhCollectQueryData failed 0x%08x\n", ret);
346
347 ret = PdhGetFormattedCounterValue( counter, PDH_FMT_LARGE, NULL, &value );
348 ok(ret == ERROR_SUCCESS, "PdhGetFormattedCounterValue failed 0x%08x\n", ret);
349
350 ret = PdhGetFormattedCounterValue( counter, PDH_FMT_LARGE | PDH_FMT_NOSCALE, NULL, &value );
351 ok(ret == ERROR_SUCCESS, "PdhGetFormattedCounterValue failed 0x%08x\n", ret);
352
353 ret = PdhGetFormattedCounterValue( counter, PDH_FMT_LARGE | PDH_FMT_NOCAP100, NULL, &value );
354 ok(ret == ERROR_SUCCESS, "PdhGetFormattedCounterValue failed 0x%08x\n", ret);
355
356 ret = PdhGetFormattedCounterValue( counter, PDH_FMT_LARGE | PDH_FMT_1000, NULL, &value );
357 ok(ret == ERROR_SUCCESS, "PdhGetFormattedCounterValue failed 0x%08x\n", ret);
358
359 ret = PdhSetCounterScaleFactor( counter, 2 );
360 ok(ret == ERROR_SUCCESS, "PdhSetCounterScaleFactor failed 0x%08x\n", ret);
361
362 ret = PdhGetFormattedCounterValue( counter, PDH_FMT_LARGE, NULL, &value );
363 ok(ret == ERROR_SUCCESS, "PdhGetFormattedCounterValue failed 0x%08x\n", ret);
364
365 ret = PdhCloseQuery( query );
366 ok(ret == ERROR_SUCCESS, "PdhCloseQuery failed 0x%08x\n", ret);
367 }
368
369 static void test_PdhGetRawCounterValue( void )
370 {
371 PDH_STATUS ret;
372 PDH_HQUERY query;
373 PDH_HCOUNTER counter;
374 PDH_RAW_COUNTER value;
375
376 ret = PdhOpenQueryA( NULL, 0, &query );
377 ok(ret == ERROR_SUCCESS, "PdhOpenQueryA failed 0x%08x\n", ret);
378
379 ret = PdhAddCounterA( query, "\\System\\System Up Time", 0, &counter );
380 ok(ret == ERROR_SUCCESS, "PdhAddCounterA failed 0x%08x\n", ret);
381
382 ret = PdhGetRawCounterValue( NULL, NULL, &value );
383 ok(ret == PDH_INVALID_HANDLE, "PdhGetRawCounterValue failed 0x%08x\n", ret);
384
385 ret = PdhGetRawCounterValue( counter, NULL, NULL );
386 ok(ret == PDH_INVALID_ARGUMENT, "PdhGetRawCounterValue failed 0x%08x\n", ret);
387
388 ret = PdhGetRawCounterValue( counter, NULL, &value );
389 ok(ret == ERROR_SUCCESS, "PdhGetRawCounterValue failed 0x%08x\n", ret);
390 ok(value.CStatus == ERROR_SUCCESS, "expected ERROR_SUCCESS got %x\n", value.CStatus);
391
392 ret = PdhCollectQueryData( query );
393 ok(ret == ERROR_SUCCESS, "PdhCollectQueryData failed 0x%08x\n", ret);
394
395 ret = PdhGetRawCounterValue( counter, NULL, &value );
396 ok(ret == ERROR_SUCCESS, "PdhGetRawCounterValue failed 0x%08x\n", ret);
397 ok(value.CStatus == ERROR_SUCCESS, "expected ERROR_SUCCESS got %x\n", value.CStatus);
398
399 ret = PdhCloseQuery( query );
400 ok(ret == ERROR_SUCCESS, "PdhCloseQuery failed 0x%08x\n", ret);
401 }
402
403 static void test_PdhSetCounterScaleFactor( void )
404 {
405 PDH_STATUS ret;
406 PDH_HQUERY query;
407 PDH_HCOUNTER counter;
408
409 ret = PdhOpenQueryA( NULL, 0, &query );
410 ok(ret == ERROR_SUCCESS, "PdhOpenQueryA failed 0x%08x\n", ret);
411
412 ret = PdhAddCounterA( query, "\\System\\System Up Time", 0, &counter );
413 ok(ret == ERROR_SUCCESS, "PdhAddCounterA failed 0x%08x\n", ret);
414
415 ret = PdhSetCounterScaleFactor( NULL, 8 );
416 ok(ret == PDH_INVALID_HANDLE, "PdhSetCounterScaleFactor failed 0x%08x\n", ret);
417
418 ret = PdhSetCounterScaleFactor( NULL, 1 );
419 ok(ret == PDH_INVALID_HANDLE, "PdhSetCounterScaleFactor failed 0x%08x\n", ret);
420
421 ret = PdhSetCounterScaleFactor( counter, 8 );
422 ok(ret == PDH_INVALID_ARGUMENT, "PdhSetCounterScaleFactor failed 0x%08x\n", ret);
423
424 ret = PdhSetCounterScaleFactor( counter, -8 );
425 ok(ret == PDH_INVALID_ARGUMENT, "PdhSetCounterScaleFactor failed 0x%08x\n", ret);
426
427 ret = PdhSetCounterScaleFactor( counter, 7 );
428 ok(ret == ERROR_SUCCESS, "PdhSetCounterScaleFactor failed 0x%08x\n", ret);
429
430 ret = PdhSetCounterScaleFactor( counter, 0 );
431 ok(ret == ERROR_SUCCESS, "PdhSetCounterScaleFactor failed 0x%08x\n", ret);
432
433 ret = PdhCloseQuery( query );
434 ok(ret == ERROR_SUCCESS, "PdhCloseQuery failed 0x%08x\n", ret);
435 }
436
437 static void test_PdhGetCounterTimeBase( void )
438 {
439 PDH_STATUS ret;
440 PDH_HQUERY query;
441 PDH_HCOUNTER counter;
442 LONGLONG base;
443
444 ret = PdhOpenQueryA( NULL, 0, &query );
445 ok(ret == ERROR_SUCCESS, "PdhOpenQueryA failed 0x%08x\n", ret);
446
447 ret = PdhAddCounterA( query, "\\System\\System Up Time", 0, &counter );
448 ok(ret == ERROR_SUCCESS, "PdhAddCounterA failed 0x%08x\n", ret);
449
450 ret = PdhGetCounterTimeBase( NULL, NULL );
451 ok(ret == PDH_INVALID_ARGUMENT, "PdhGetCounterTimeBase failed 0x%08x\n", ret);
452
453 ret = PdhGetCounterTimeBase( NULL, &base );
454 ok(ret == PDH_INVALID_HANDLE, "PdhGetCounterTimeBase failed 0x%08x\n", ret);
455
456 ret = PdhGetCounterTimeBase( counter, NULL );
457 ok(ret == PDH_INVALID_ARGUMENT, "PdhGetCounterTimeBase failed 0x%08x\n", ret);
458
459 ret = PdhGetCounterTimeBase( counter, &base );
460 ok(ret == ERROR_SUCCESS, "PdhGetCounterTimeBase failed 0x%08x\n", ret);
461
462 ret = PdhCloseQuery( query );
463 ok(ret == ERROR_SUCCESS, "PdhCloseQuery failed 0x%08x\n", ret);
464 }
465
466 static void test_PdhGetCounterInfoA( void )
467 {
468 PDH_STATUS ret;
469 PDH_HQUERY query;
470 PDH_HCOUNTER counter;
471 PDH_COUNTER_INFO_A info;
472 DWORD size;
473
474 ret = PdhOpenQueryA( NULL, 0, &query );
475 ok(ret == ERROR_SUCCESS, "PdhOpenQueryA failed 0x%08x\n", ret);
476
477 ret = PdhAddCounterA( query, "\\System\\System Up Time", 0, &counter );
478 ok(ret == ERROR_SUCCESS, "PdhAddCounterA failed 0x%08x\n", ret);
479
480 ret = PdhGetCounterInfoA( NULL, 0, NULL, NULL );
481 ok(ret == PDH_INVALID_HANDLE || ret == PDH_INVALID_ARGUMENT, "PdhGetCounterInfoA failed 0x%08x\n", ret);
482
483 ret = PdhGetCounterInfoA( counter, 0, NULL, NULL );
484 ok(ret == PDH_INVALID_ARGUMENT, "PdhGetCounterInfoA failed 0x%08x\n", ret);
485
486 ret = PdhGetCounterInfoA( counter, 0, NULL, &info );
487 ok(ret == PDH_INVALID_ARGUMENT, "PdhGetCounterInfoA failed 0x%08x\n", ret);
488
489 size = sizeof(info) - 1;
490 ret = PdhGetCounterInfoA( counter, 0, &size, NULL );
491 ok(ret == PDH_MORE_DATA || ret == PDH_INVALID_ARGUMENT, "PdhGetCounterInfoA failed 0x%08x\n", ret);
492
493 size = sizeof(info);
494 ret = PdhGetCounterInfoA( counter, 0, &size, &info );
495 ok(ret == ERROR_SUCCESS, "PdhGetCounterInfoA failed 0x%08x\n", ret);
496 ok(size == sizeof(info), "PdhGetCounterInfoA failed %d\n", size);
497
498 ret = PdhGetCounterInfoA( counter, 0, &size, &info );
499 ok(ret == ERROR_SUCCESS, "PdhGetCounterInfoA failed 0x%08x\n", ret);
500 ok(info.lScale == 0, "lScale %d\n", info.lScale);
501
502 ret = PdhSetCounterScaleFactor( counter, 0 );
503 ok(ret == ERROR_SUCCESS, "PdhSetCounterScaleFactor failed 0x%08x\n", ret);
504
505 ret = PdhGetCounterInfoA( counter, 0, &size, &info );
506 ok(ret == ERROR_SUCCESS, "PdhGetCounterInfoA failed 0x%08x\n", ret);
507 ok(info.lScale == 0, "lScale %d\n", info.lScale);
508
509 ret = PdhSetCounterScaleFactor( counter, -5 );
510 ok(ret == ERROR_SUCCESS, "PdhSetCounterScaleFactor failed 0x%08x\n", ret);
511
512 ret = PdhGetCounterInfoA( counter, 0, &size, &info );
513 ok(ret == ERROR_SUCCESS, "PdhGetCounterInfoA failed 0x%08x\n", ret);
514 ok(info.lScale == -5, "lScale %d\n", info.lScale);
515
516 ret = PdhCloseQuery( query );
517 ok(ret == ERROR_SUCCESS, "PdhCloseQuery failed 0x%08x\n", ret);
518 }
519
520 static void test_PdhGetCounterInfoW( void )
521 {
522 PDH_STATUS ret;
523 PDH_HQUERY query;
524 PDH_HCOUNTER counter;
525 PDH_COUNTER_INFO_W info;
526 DWORD size;
527
528 ret = PdhOpenQueryW( NULL, 0, &query );
529 ok(ret == ERROR_SUCCESS, "PdhOpenQueryW failed 0x%08x\n", ret);
530
531 ret = PdhAddCounterW( query, percentage_processor_time, 0, &counter );
532 ok(ret == ERROR_SUCCESS, "PdhAddCounterW failed 0x%08x\n", ret);
533
534 ret = PdhGetCounterInfoW( NULL, 0, NULL, NULL );
535 ok(ret == PDH_INVALID_HANDLE || ret == PDH_INVALID_ARGUMENT, "PdhGetCounterInfoW failed 0x%08x\n", ret);
536
537 ret = PdhGetCounterInfoW( counter, 0, NULL, NULL );
538 ok(ret == PDH_INVALID_ARGUMENT, "PdhGetCounterInfoW failed 0x%08x\n", ret);
539
540 ret = PdhGetCounterInfoW( counter, 0, NULL, &info );
541 ok(ret == PDH_INVALID_ARGUMENT, "PdhGetCounterInfoW failed 0x%08x\n", ret);
542
543 size = sizeof(info) - 1;
544 ret = PdhGetCounterInfoW( counter, 0, &size, NULL );
545 ok(ret == PDH_MORE_DATA || ret == PDH_INVALID_ARGUMENT, "PdhGetCounterInfoW failed 0x%08x\n", ret);
546
547 size = sizeof(info);
548 ret = PdhGetCounterInfoW( counter, 0, &size, &info );
549 ok(ret == ERROR_SUCCESS, "PdhGetCounterInfoW failed 0x%08x\n", ret);
550 ok(size == sizeof(info), "PdhGetCounterInfoW failed %d\n", size);
551
552 ret = PdhGetCounterInfoW( counter, 0, &size, &info );
553 ok(ret == ERROR_SUCCESS, "PdhGetCounterInfoW failed 0x%08x\n", ret);
554 ok(info.lScale == 0, "lScale %d\n", info.lScale);
555
556 ret = PdhSetCounterScaleFactor( counter, 0 );
557 ok(ret == ERROR_SUCCESS, "PdhSetCounterScaleFactor failed 0x%08x\n", ret);
558
559 ret = PdhGetCounterInfoW( counter, 0, &size, &info );
560 ok(ret == ERROR_SUCCESS, "PdhGetCounterInfoW failed 0x%08x\n", ret);
561 ok(info.lScale == 0, "lScale %d\n", info.lScale);
562
563 ret = PdhSetCounterScaleFactor( counter, -5 );
564 ok(ret == ERROR_SUCCESS, "PdhSetCounterScaleFactor failed 0x%08x\n", ret);
565
566 ret = PdhGetCounterInfoW( counter, 0, &size, &info );
567 ok(ret == ERROR_SUCCESS, "PdhGetCounterInfoW failed 0x%08x\n", ret);
568 ok(info.lScale == -5, "lScale %d\n", info.lScale);
569
570 ret = PdhCloseQuery( query );
571 ok(ret == ERROR_SUCCESS, "PdhCloseQuery failed 0x%08x\n", ret);
572 }
573
574 static void test_PdhLookupPerfIndexByNameA( void )
575 {
576 PDH_STATUS ret;
577 DWORD index;
578
579 ret = PdhLookupPerfIndexByNameA( NULL, NULL, NULL );
580 ok(ret == PDH_INVALID_ARGUMENT, "PdhLookupPerfIndexByNameA failed 0x%08x\n", ret);
581
582 ret = PdhLookupPerfIndexByNameA( NULL, NULL, &index );
583 ok(ret == PDH_INVALID_ARGUMENT, "PdhLookupPerfIndexByNameA failed 0x%08x\n", ret);
584
585 ret = PdhLookupPerfIndexByNameA( NULL, "No Counter", &index );
586 ok(ret == PDH_STRING_NOT_FOUND, "PdhLookupPerfIndexByNameA failed 0x%08x\n", ret);
587
588 ret = PdhLookupPerfIndexByNameA( NULL, "% Processor Time", NULL );
589 ok(ret == PDH_INVALID_ARGUMENT, "PdhLookupPerfIndexByNameA failed 0x%08x\n", ret);
590
591 ret = PdhLookupPerfIndexByNameA( NULL, "% Processor Time", &index );
592 ok(ret == ERROR_SUCCESS, "PdhLookupPerfIndexByNameA failed 0x%08x\n", ret);
593 ok(index == 6, "PdhLookupPerfIndexByNameA failed %d\n", index);
594
595 ret = PdhLookupPerfIndexByNameA( NULL, "System Up Time", &index );
596 ok(ret == ERROR_SUCCESS, "PdhLookupPerfIndexByNameA failed 0x%08x\n", ret);
597 ok(index == 674, "PdhLookupPerfIndexByNameA failed %d\n", index);
598 }
599
600 static void test_PdhLookupPerfIndexByNameW( void )
601 {
602 PDH_STATUS ret;
603 DWORD index;
604
605 static const WCHAR no_counter[] = {'N','o',' ','C','o','u','n','t','e','r',0};
606
607 ret = PdhLookupPerfIndexByNameW( NULL, NULL, NULL );
608 ok(ret == PDH_INVALID_ARGUMENT, "PdhLookupPerfIndexByNameW failed 0x%08x\n", ret);
609
610 ret = PdhLookupPerfIndexByNameW( NULL, NULL, &index );
611 ok(ret == PDH_INVALID_ARGUMENT, "PdhLookupPerfIndexByNameW failed 0x%08x\n", ret);
612
613 ret = PdhLookupPerfIndexByNameW( NULL, no_counter, &index );
614 ok(ret == PDH_STRING_NOT_FOUND, "PdhLookupPerfIndexByNameW failed 0x%08x\n", ret);
615
616 ret = PdhLookupPerfIndexByNameW( NULL, processor_time, NULL );
617 ok(ret == PDH_INVALID_ARGUMENT, "PdhLookupPerfIndexByNameW failed 0x%08x\n", ret);
618
619 ret = PdhLookupPerfIndexByNameW( NULL, processor_time, &index );
620 ok(ret == ERROR_SUCCESS, "PdhLookupPerfIndexByNameW failed 0x%08x\n", ret);
621 ok(index == 6, "PdhLookupPerfIndexByNameW failed %d\n", index);
622
623 ret = PdhLookupPerfIndexByNameW( NULL, uptime, &index );
624 ok(ret == ERROR_SUCCESS, "PdhLookupPerfIndexByNameW failed 0x%08x\n", ret);
625 ok(index == 674, "PdhLookupPerfIndexByNameW failed %d\n", index);
626 }
627
628 static void test_PdhLookupPerfNameByIndexA( void )
629 {
630 PDH_STATUS ret;
631 char buffer[PDH_MAX_COUNTER_NAME] = "!!";
632 DWORD size;
633
634 ret = PdhLookupPerfNameByIndexA( NULL, 0, NULL, NULL );
635 ok(ret == PDH_INVALID_ARGUMENT, "PdhLookupPerfNameByIndexA failed 0x%08x\n", ret);
636
637 size = 0;
638 ret = PdhLookupPerfNameByIndexA( NULL, 6, buffer, &size );
639 ok(ret == PDH_MORE_DATA || ret == PDH_INSUFFICIENT_BUFFER, "PdhLookupPerfNameByIndexA failed 0x%08x\n", ret);
640
641 size = sizeof(buffer);
642 ret = PdhLookupPerfNameByIndexA( NULL, 6, buffer, &size );
643 ok(ret == ERROR_SUCCESS, "PdhLookupPerfNameByIndexA failed 0x%08x\n", ret);
644 ok(!lstrcmpA( buffer, "% Processor Time" ),
645 "PdhLookupPerfNameByIndexA failed, got %s expected \'%% Processor Time\'\n", buffer);
646 ok(size == sizeof("% Processor Time"), "PdhLookupPerfNameByIndexA failed %d\n", size);
647
648 size = sizeof(buffer);
649 ret = PdhLookupPerfNameByIndexA( NULL, 674, NULL, &size );
650 ok(ret == PDH_INVALID_ARGUMENT ||
651 ret == PDH_MORE_DATA, /* win2k3 */
652 "PdhLookupPerfNameByIndexA failed 0x%08x\n", ret);
653
654 size = sizeof(buffer);
655 ret = PdhLookupPerfNameByIndexA( NULL, 674, buffer, &size );
656 ok(ret == ERROR_SUCCESS, "PdhLookupPerfNameByIndexA failed 0x%08x\n", ret);
657 ok(!lstrcmpA( buffer, "System Up Time" ),
658 "PdhLookupPerfNameByIndexA failed, got %s expected \'System Up Time\'\n", buffer);
659 ok(size == sizeof("System Up Time"), "PdhLookupPerfNameByIndexA failed %d\n", size);
660 }
661
662 static void test_PdhLookupPerfNameByIndexW( void )
663 {
664 PDH_STATUS ret;
665 WCHAR buffer[PDH_MAX_COUNTER_NAME];
666 DWORD size;
667
668 ret = PdhLookupPerfNameByIndexW( NULL, 0, NULL, NULL );
669 ok(ret == PDH_INVALID_ARGUMENT, "PdhLookupPerfNameByIndexW failed 0x%08x\n", ret);
670
671 size = 0;
672 ret = PdhLookupPerfNameByIndexW( NULL, 6, buffer, &size );
673 ok(ret == PDH_MORE_DATA || ret == PDH_INSUFFICIENT_BUFFER, "PdhLookupPerfNameByIndexW failed 0x%08x\n", ret);
674
675 size = sizeof(buffer) / sizeof(WCHAR);
676 ret = PdhLookupPerfNameByIndexW( NULL, 6, buffer, &size );
677 ok(ret == ERROR_SUCCESS, "PdhLookupPerfNameByIndexW failed 0x%08x\n", ret);
678 ok(size == sizeof(processor_time) / sizeof(WCHAR), "PdhLookupPerfNameByIndexW failed %d\n", size);
679
680 size = sizeof(buffer) / sizeof(WCHAR);
681 ret = PdhLookupPerfNameByIndexW( NULL, 674, NULL, &size );
682 ok(ret == PDH_INVALID_ARGUMENT ||
683 ret == PDH_MORE_DATA, /* win2k3 */
684 "PdhLookupPerfNameByIndexW failed 0x%08x\n", ret);
685
686 size = sizeof(buffer) / sizeof(WCHAR);
687 ret = PdhLookupPerfNameByIndexW( NULL, 674, buffer, &size );
688 ok(ret == ERROR_SUCCESS, "PdhLookupPerfNameByIndexW failed 0x%08x\n", ret);
689 ok(size == sizeof(uptime) / sizeof(WCHAR), "PdhLookupPerfNameByIndexW failed %d\n", size);
690 }
691
692 static void test_PdhValidatePathA( void )
693 {
694 PDH_STATUS ret;
695
696 ret = PdhValidatePathA( NULL );
697 ok(ret == PDH_INVALID_ARGUMENT, "PdhValidatePathA failed 0x%08x\n", ret);
698
699 ret = PdhValidatePathA( "" );
700 ok(ret == PDH_INVALID_ARGUMENT, "PdhValidatePathA failed 0x%08x\n", ret);
701
702 ret = PdhValidatePathA( "\\System" );
703 ok(ret == PDH_CSTATUS_BAD_COUNTERNAME, "PdhValidatePathA failed 0x%08x\n", ret);
704
705 ret = PdhValidatePathA( "System Up Time" );
706 ok(ret == PDH_CSTATUS_BAD_COUNTERNAME, "PdhValidatePathA failed 0x%08x\n", ret);
707
708 ret = PdhValidatePathA( "\\System\\System Down Time" );
709 ok(ret == PDH_CSTATUS_NO_COUNTER, "PdhValidatePathA failed 0x%08x\n", ret);
710
711 ret = PdhValidatePathA( "\\System\\System Up Time" );
712 ok(ret == ERROR_SUCCESS, "PdhValidatePathA failed 0x%08x\n", ret);
713 }
714
715 static void test_PdhValidatePathW( void )
716 {
717 PDH_STATUS ret;
718
719 static const WCHAR empty[] = {0};
720 static const WCHAR system[] = {'\\','S','y','s','t','e','m',0};
721
722 ret = PdhValidatePathW( NULL );
723 ok(ret == PDH_INVALID_ARGUMENT, "PdhValidatePathW failed 0x%08x\n", ret);
724
725 ret = PdhValidatePathW( empty );
726 ok(ret == PDH_INVALID_ARGUMENT, "PdhValidatePathW failed 0x%08x\n", ret);
727
728 ret = PdhValidatePathW( system );
729 ok(ret == PDH_CSTATUS_BAD_COUNTERNAME, "PdhValidatePathW failed 0x%08x\n", ret);
730
731 ret = PdhValidatePathW( uptime );
732 ok(ret == PDH_CSTATUS_BAD_COUNTERNAME, "PdhValidatePathW failed 0x%08x\n", ret);
733
734 ret = PdhValidatePathW( system_downtime );
735 ok(ret == PDH_CSTATUS_NO_COUNTER, "PdhValidatePathW failed 0x%08x\n", ret);
736
737 ret = PdhValidatePathW( system_uptime );
738 ok(ret == ERROR_SUCCESS, "PdhValidatePathW failed 0x%08x\n", ret);
739 }
740
741 static void test_PdhValidatePathExA( void )
742 {
743 PDH_STATUS ret;
744
745 ret = pPdhValidatePathExA( NULL, NULL );
746 ok(ret == PDH_INVALID_ARGUMENT, "PdhValidatePathExA failed 0x%08x\n", ret);
747
748 ret = pPdhValidatePathExA( NULL, "" );
749 ok(ret == PDH_INVALID_ARGUMENT, "PdhValidatePathExA failed 0x%08x\n", ret);
750
751 ret = pPdhValidatePathExA( NULL, "\\System" );
752 ok(ret == PDH_CSTATUS_BAD_COUNTERNAME, "PdhValidatePathExA failed 0x%08x\n", ret);
753
754 ret = pPdhValidatePathExA( NULL, "System Up Time" );
755 ok(ret == PDH_CSTATUS_BAD_COUNTERNAME, "PdhValidatePathExA failed 0x%08x\n", ret);
756
757 ret = pPdhValidatePathExA( NULL, "\\System\\System Down Time" );
758 ok(ret == PDH_CSTATUS_NO_COUNTER, "PdhValidatePathExA failed 0x%08x\n", ret);
759
760 ret = pPdhValidatePathExA( NULL, "\\System\\System Up Time" );
761 ok(ret == ERROR_SUCCESS, "PdhValidatePathExA failed 0x%08x\n", ret);
762 }
763
764 static void test_PdhValidatePathExW( void )
765 {
766 PDH_STATUS ret;
767
768 static const WCHAR empty[] = {0};
769 static const WCHAR system[] = {'\\','S','y','s','t','e','m',0};
770
771 ret = pPdhValidatePathExW( NULL, NULL );
772 ok(ret == PDH_INVALID_ARGUMENT, "PdhValidatePathExW failed 0x%08x\n", ret);
773
774 ret = pPdhValidatePathExW( NULL, empty );
775 ok(ret == PDH_INVALID_ARGUMENT, "PdhValidatePathExW failed 0x%08x\n", ret);
776
777 ret = pPdhValidatePathExW( NULL, system );
778 ok(ret == PDH_CSTATUS_BAD_COUNTERNAME, "PdhValidatePathExW failed 0x%08x\n", ret);
779
780 ret = pPdhValidatePathExW( NULL, uptime );
781 ok(ret == PDH_CSTATUS_BAD_COUNTERNAME, "PdhValidatePathExW failed 0x%08x\n", ret);
782
783 ret = pPdhValidatePathExW( NULL, system_downtime );
784 ok(ret == PDH_CSTATUS_NO_COUNTER, "PdhValidatePathExW failed 0x%08x\n", ret);
785
786 ret = pPdhValidatePathExW( NULL, system_uptime );
787 ok(ret == ERROR_SUCCESS, "PdhValidatePathExW failed 0x%08x\n", ret);
788 }
789
790 static void test_PdhCollectQueryDataEx(void)
791 {
792 PDH_STATUS status;
793 PDH_HQUERY query;
794 PDH_HCOUNTER counter;
795 HANDLE event;
796 BOOL ret;
797 UINT i;
798
799 status = PdhOpenQueryA( NULL, 0, &query );
800 ok(status == ERROR_SUCCESS, "PdhOpenQuery failed 0x%08x\n", status);
801
802 event = CreateEventA( NULL, FALSE, FALSE, "winetest" );
803 ok(event != NULL, "CreateEvent failed\n");
804
805 status = PdhAddCounterA( query, "\\System\\System Up Time", 0, &counter );
806 ok(status == ERROR_SUCCESS, "PdhAddCounterA failed 0x%08x\n", status);
807
808 status = PdhCollectQueryDataEx( NULL, 1, event );
809 ok(status == PDH_INVALID_HANDLE, "PdhCollectQueryDataEx failed 0x%08x\n", status);
810
811 status = PdhCollectQueryDataEx( query, 1, NULL );
812 ok(status == ERROR_SUCCESS, "PdhCollectQueryDataEx failed 0x%08x\n", status);
813
814 status = PdhCollectQueryDataEx( query, 1, event );
815 ok(status == ERROR_SUCCESS, "PdhCollectQueryDataEx failed 0x%08x\n", status);
816
817 status = PdhCollectQueryData( query );
818 ok(status == ERROR_SUCCESS, "PdhCollectQueryData failed 0x%08x\n", status);
819
820 for (i = 0; i < 3; i++)
821 {
822 if (WaitForSingleObject( event, INFINITE ) == WAIT_OBJECT_0)
823 {
824 PDH_FMT_COUNTERVALUE value;
825
826 status = PdhGetFormattedCounterValue( counter, PDH_FMT_LARGE, NULL, &value );
827 ok(status == ERROR_SUCCESS, "PdhGetFormattedCounterValue failed 0x%08x\n", status);
828
829 trace( "uptime %x%08x\n", (DWORD)(U(value).largeValue >> 32), (DWORD)U(value).largeValue );
830 }
831 }
832
833 ret = CloseHandle( event );
834 ok(ret, "CloseHandle failed\n");
835
836 status = PdhCloseQuery( query );
837 ok(status == ERROR_SUCCESS, "PdhCloseQuery failed 0x%08x\n", status);
838 }
839
840 static void test_PdhMakeCounterPathA(void)
841 {
842 PDH_STATUS ret;
843 PDH_COUNTER_PATH_ELEMENTS_A e;
844 char buffer[1024];
845 DWORD buflen;
846
847 ret = PdhMakeCounterPathA(NULL, NULL, NULL, 0);
848 ok(ret == PDH_INVALID_ARGUMENT, "PdhMakeCounterPathA failed 0x%08x\n", ret);
849
850 buflen = 0;
851 ret = PdhMakeCounterPathA(NULL, NULL, &buflen, 0);
852 ok(ret == PDH_INVALID_ARGUMENT, "PdhMakeCounterPathA failed 0x%08x\n", ret);
853
854 buflen = 0;
855 ret = PdhMakeCounterPathA(NULL, buffer, &buflen, 0);
856 ok(ret == PDH_INVALID_ARGUMENT, "PdhMakeCounterPathA failed 0x%08x\n", ret);
857
858 buflen = sizeof(buffer);
859 memset(&e, 0, sizeof(e));
860 ret = PdhMakeCounterPathA(&e, buffer, &buflen, 0);
861 ok(ret == PDH_INVALID_ARGUMENT, "PdhMakeCounterPathA failed 0x%08x\n", ret);
862
863 buffer[0] = 0;
864 buflen = sizeof(buffer);
865 e.szMachineName = (char *)"machine";
866 ret = PdhMakeCounterPathA(&e, buffer, &buflen, 0);
867 ok(ret == PDH_INVALID_ARGUMENT, "PdhMakeCounterPathA failed 0x%08x\n", ret);
868 ok(!strcmp(buffer, ""), "expected \"machine\" got %s\n", buffer);
869
870 buffer[0] = 0;
871 buflen = sizeof(buffer);
872 e.szObjectName = (char *)"object";
873 ret = PdhMakeCounterPathA(&e, buffer, &buflen, 0);
874 ok(ret == PDH_INVALID_ARGUMENT, "PdhMakeCounterPathA failed 0x%08x\n", ret);
875 ok(!strcmp(buffer, ""), "expected \"machine\" got %s\n", buffer);
876
877 buffer[0] = 0;
878 buflen = sizeof(buffer);
879 e.szInstanceName = (char *)"instance";
880 ret = PdhMakeCounterPathA(&e, buffer, &buflen, 0);
881 ok(ret == PDH_INVALID_ARGUMENT, "PdhMakeCounterPathA failed 0x%08x\n", ret);
882 ok(!strcmp(buffer, ""), "expected \"machine\" got %s\n", buffer);
883
884 buffer[0] = 0;
885 buflen = sizeof(buffer);
886 e.szParentInstance = (char *)"parent";
887 ret = PdhMakeCounterPathA(&e, buffer, &buflen, 0);
888 ok(ret == PDH_INVALID_ARGUMENT, "PdhMakeCounterPathA failed 0x%08x\n", ret);
889 ok(!strcmp(buffer, ""), "expected \"machine\" got %s\n", buffer);
890
891 buffer[0] = 0;
892 buflen = sizeof(buffer);
893 e.dwInstanceIndex = 1;
894 ret = PdhMakeCounterPathA(&e, buffer, &buflen, 0);
895 ok(ret == PDH_INVALID_ARGUMENT, "PdhMakeCounterPathA failed 0x%08x\n", ret);
896 ok(!strcmp(buffer, ""), "expected \"machine\" got %s\n", buffer);
897
898 buffer[0] = 0;
899 buflen = sizeof(buffer);
900 e.szCounterName = (char *)"counter";
901 ret = PdhMakeCounterPathA(&e, buffer, &buflen, 0);
902 ok(ret == ERROR_SUCCESS, "PdhMakeCounterPathA failed 0x%08x\n", ret);
903 ok(!strcmp(buffer, "\\\\machine\\object(parent/instance#1)\\counter"),
904 "expected \"\\\\machine\\object(parent/instance#1)\\counter\" got %s\n", buffer);
905
906 buffer[0] = 0;
907 buflen = sizeof(buffer);
908 e.szParentInstance = NULL;
909 ret = PdhMakeCounterPathA(&e, buffer, &buflen, 0);
910 ok(ret == ERROR_SUCCESS, "PdhMakeCounterPathA failed 0x%08x\n", ret);
911 ok(!strcmp(buffer, "\\\\machine\\object(instance#1)\\counter"),
912 "expected \"\\\\machine\\object(instance#1)\\counter\" got %s\n", buffer);
913
914 buffer[0] = 0;
915 buflen = sizeof(buffer);
916 e.szInstanceName = NULL;
917 ret = PdhMakeCounterPathA(&e, buffer, &buflen, 0);
918 ok(ret == ERROR_SUCCESS, "PdhMakeCounterPathA failed 0x%08x\n", ret);
919 ok(!strcmp(buffer, "\\\\machine\\object\\counter"),
920 "expected \"\\\\machine\\object\\counter\" got %s\n", buffer);
921
922 buffer[0] = 0;
923 buflen = sizeof(buffer);
924 e.szMachineName = NULL;
925 ret = PdhMakeCounterPathA(&e, buffer, &buflen, 0);
926 ok(ret == ERROR_SUCCESS, "PdhMakeCounterPathA failed 0x%08x\n", ret);
927 ok(!strcmp(buffer, "\\object\\counter"),
928 "expected \"\\object\\counter\" got %s\n", buffer);
929
930 buffer[0] = 0;
931 buflen = sizeof(buffer);
932 e.szObjectName = NULL;
933 ret = PdhMakeCounterPathA(&e, buffer, &buflen, 0);
934 ok(ret == PDH_INVALID_ARGUMENT, "PdhMakeCounterPathA failed 0x%08x\n", ret);
935 }
936
937 static void test_PdhGetDllVersion(void)
938 {
939 PDH_STATUS ret;
940 DWORD version;
941
942 ret = PdhGetDllVersion(NULL);
943 ok(ret == PDH_INVALID_ARGUMENT ||
944 broken(ret == ERROR_SUCCESS), /* Vista+ */
945 "Expected PdhGetDllVersion to return PDH_INVALID_ARGUMENT, got %d\n", ret);
946
947 ret = PdhGetDllVersion(&version);
948 ok(ret == ERROR_SUCCESS,
949 "Expected PdhGetDllVersion to return ERROR_SUCCESS, got %d\n", ret);
950
951 if (ret == ERROR_SUCCESS)
952 {
953 ok(version == PDH_CVERSION_WIN50 ||
954 version == PDH_VERSION,
955 "Expected version number to be PDH_CVERSION_WIN50 or PDH_VERSION, got %u\n", version);
956 }
957 }
958
959 START_TEST(pdh)
960 {
961 if (PRIMARYLANGID(LANGIDFROMLCID(GetThreadLocale())) != LANG_ENGLISH)
962 {
963 skip("non-english locale\n");
964 return;
965 }
966 init_function_ptrs();
967
968 test_PdhOpenQueryA();
969 test_PdhOpenQueryW();
970
971 test_PdhAddCounterA();
972 test_PdhAddCounterW();
973
974 if (pPdhAddEnglishCounterA) test_PdhAddEnglishCounterA();
975 if (pPdhAddEnglishCounterW) test_PdhAddEnglishCounterW();
976 if (pPdhCollectQueryDataWithTime) test_PdhCollectQueryDataWithTime();
977
978 test_PdhGetFormattedCounterValue();
979 test_PdhGetRawCounterValue();
980 test_PdhSetCounterScaleFactor();
981 test_PdhGetCounterTimeBase();
982
983 test_PdhGetCounterInfoA();
984 test_PdhGetCounterInfoW();
985
986 test_PdhLookupPerfIndexByNameA();
987 test_PdhLookupPerfIndexByNameW();
988
989 test_PdhLookupPerfNameByIndexA();
990 test_PdhLookupPerfNameByIndexW();
991
992 test_PdhValidatePathA();
993 test_PdhValidatePathW();
994
995 if (pPdhValidatePathExA) test_PdhValidatePathExA();
996 if (pPdhValidatePathExW) test_PdhValidatePathExW();
997
998 test_PdhCollectQueryDataEx();
999 test_PdhMakeCounterPathA();
1000 test_PdhGetDllVersion();
1001 }
Maarten's multimedia branch