?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dwrite: Implement CreateFontFaceFromHdc().
[wine.git] / dlls / taskschd / tests / scheduler.c
blob74a52632dce2f34c7ada4274b60fa339c70063bc
1 /*
2 * Copyright 2014 Dmitry Timoshkov
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 #include <stdarg.h>
20 #include <assert.h>
21
22 #define COBJMACROS
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "initguid.h"
27 #include "objbase.h"
28 #include "taskschd.h"
29
30 #include <wine/test.h>
31
32 static void test_Connect(void)
33 {
34 static WCHAR empty[] = { 0 };
35 static const WCHAR deadbeefW[] = { '0','.','0','.','0','.','0',0 };
36 WCHAR comp_name[MAX_COMPUTERNAME_LENGTH + 1];
37 DWORD len;
38 HRESULT hr;
39 BSTR bstr;
40 VARIANT v_null, v_comp;
41 VARIANT_BOOL vbool;
42 BOOL was_connected;
43 ITaskService *service;
44
45 hr = CoCreateInstance(&CLSID_TaskScheduler, NULL, CLSCTX_INPROC_SERVER, &IID_ITaskService, (void **)&service);
46 if (hr != S_OK)
47 {
48 win_skip("CoCreateInstance(CLSID_TaskScheduler) error %#x\n", hr);
49 return;
50 }
51
52 hr = ITaskService_get_Connected(service, NULL);
53 ok(hr == E_POINTER, "expected E_POINTER, got %#x\n", hr);
54
55 vbool = 0xdead;
56 hr = ITaskService_get_Connected(service, &vbool);
57 ok(hr == S_OK, "get_Connected error %#x\n", hr);
58 ok(vbool == VARIANT_FALSE, "expected VARIANT_FALSE, got %d\n", vbool);
59
60 hr = ITaskService_get_TargetServer(service, NULL);
61 ok(hr == E_POINTER, "expected E_POINTER, got %#x\n", hr);
62
63 hr = ITaskService_get_TargetServer(service, &bstr);
64 ok(hr == HRESULT_FROM_WIN32(ERROR_ONLY_IF_CONNECTED), "expected ERROR_ONLY_IF_CONNECTED, got %#x\n", hr);
65
66 /* Win7 doesn't support UNC \\ prefix, but according to a user
67 * comment on MSDN Win8 supports both ways.
68 */
69 len = sizeof(comp_name)/sizeof(comp_name[0]);
70 GetComputerNameW(comp_name, &len);
71
72 V_VT(&v_null) = VT_NULL;
73
74 V_VT(&v_comp) = VT_BSTR;
75 V_BSTR(&v_comp) = SysAllocString(comp_name);
76
77 hr = ITaskService_Connect(service, v_comp, v_null, v_null, v_null);
78 ok(hr == S_OK || hr == E_ACCESSDENIED /* not an administrator */, "Connect error %#x\n", hr);
79 was_connected = hr == S_OK;
80 SysFreeString(V_BSTR(&v_comp));
81
82 V_BSTR(&v_comp) = SysAllocString(deadbeefW);
83 hr = ITaskService_Connect(service, v_comp, v_null, v_null, v_null);
84 ok(hr == HRESULT_FROM_WIN32(RPC_S_INVALID_NET_ADDR) || hr == HRESULT_FROM_WIN32(ERROR_BAD_NETPATH) /* VM */,
85 "expected RPC_S_INVALID_NET_ADDR, got %#x\n", hr);
86 SysFreeString(V_BSTR(&v_comp));
87
88 vbool = 0xdead;
89 hr = ITaskService_get_Connected(service, &vbool);
90 ok(hr == S_OK, "get_Connected error %#x\n", hr);
91 ok(vbool == VARIANT_FALSE || (was_connected && vbool == VARIANT_TRUE),
92 "Connect shouldn't trash an existing connection, got %d (was connected %d)\n", vbool, was_connected);
93
94 V_BSTR(&v_comp) = SysAllocString(empty);
95 hr = ITaskService_Connect(service, v_comp, v_null, v_null, v_null);
96 ok(hr == S_OK, "Connect error %#x\n", hr);
97 SysFreeString(V_BSTR(&v_comp));
98
99 V_BSTR(&v_comp) = NULL;
100 hr = ITaskService_Connect(service, v_comp, v_null, v_null, v_null);
101 ok(hr == S_OK, "Connect error %#x\n", hr);
102
103 hr = ITaskService_Connect(service, v_null, v_null, v_null, v_null);
104 ok(hr == S_OK, "Connect error %#x\n", hr);
105
106 vbool = 0xdead;
107 hr = ITaskService_get_Connected(service, &vbool);
108 ok(hr == S_OK, "get_Connected error %#x\n", hr);
109 ok(vbool == VARIANT_TRUE, "expected VARIANT_TRUE, got %d\n", vbool);
110
111 hr = ITaskService_get_TargetServer(service, &bstr);
112 ok(hr == S_OK, "get_TargetServer error %#x\n", hr);
113 ok(!lstrcmpW(comp_name, bstr), "compname %s != server name %s\n", wine_dbgstr_w(comp_name), wine_dbgstr_w(bstr));
114 SysFreeString(bstr);
115
116 ITaskService_Release(service);
117 }
118
119 static void test_GetFolder(void)
120 {
121 static WCHAR dot[] = { '.',0 };
122 static WCHAR empty[] = { 0 };
123 static WCHAR slash[] = { '/',0 };
124 static WCHAR bslash[] = { '\\',0 };
125 static WCHAR Wine[] = { '\\','W','i','n','e',0 };
126 static WCHAR Wine_Folder1[] = { '\\','W','i','n','e','\\','F','o','l','d','e','r','1',0 };
127 static WCHAR Wine_Folder1_[] = { '\\','W','i','n','e','\\','F','o','l','d','e','r','1','\\',0 };
128 static WCHAR Wine_Folder1_Folder2[] = { '\\','W','i','n','e','\\','F','o','l','d','e','r','1','\\','F','o','l','d','e','r','2',0 };
129 static WCHAR Folder1_Folder2[] = { '\\','F','o','l','d','e','r','1','\\','F','o','l','d','e','r','2',0 };
130 static const WCHAR Folder1[] = { 'F','o','l','d','e','r','1',0 };
131 static const WCHAR Folder2[] = { 'F','o','l','d','e','r','2',0 };
132 HRESULT hr;
133 BSTR bstr;
134 VARIANT v_null;
135 ITaskService *service;
136 ITaskFolder *folder, *subfolder, *subfolder2;
137
138 hr = CoCreateInstance(&CLSID_TaskScheduler, NULL, CLSCTX_INPROC_SERVER, &IID_ITaskService, (void **)&service);
139 if (hr != S_OK)
140 {
141 win_skip("CoCreateInstance(CLSID_TaskScheduler) error %#x\n", hr);
142 return;
143 }
144
145 hr = ITaskService_GetFolder(service, NULL, &folder);
146 ok(hr == HRESULT_FROM_WIN32(ERROR_ONLY_IF_CONNECTED), "expected ERROR_ONLY_IF_CONNECTED, got %#x\n", hr);
147
148 V_VT(&v_null) = VT_NULL;
149
150 hr = ITaskService_Connect(service, v_null, v_null, v_null, v_null);
151 ok(hr == S_OK, "Connect error %#x\n", hr);
152
153 hr = ITaskService_GetFolder(service, slash, &folder);
154 todo_wine
155 ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME), "expected ERROR_INVALID_NAME, got %#x\n", hr);
156
157 hr = ITaskService_GetFolder(service, dot, &folder);
158 todo_wine
159 ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME), "expected ERROR_INVALID_NAME, got %#x\n", hr);
160
161 hr = ITaskService_GetFolder(service, bslash, &folder);
162 ok(hr == S_OK, "GetFolder error %#x\n", hr);
163 ITaskFolder_Release(folder);
164
165 hr = ITaskService_GetFolder(service, NULL, NULL);
166 ok(hr == E_POINTER, "expected E_POINTER, got %#x\n", hr);
167
168 hr = ITaskService_GetFolder(service, empty, &folder);
169 ok(hr == S_OK, "GetFolder error %#x\n", hr);
170 ITaskFolder_Release(folder);
171
172 hr = ITaskService_GetFolder(service, NULL, &folder);
173 ok(hr == S_OK, "GetFolder error %#x\n", hr);
174
175 hr = ITaskFolder_get_Name(folder, NULL);
176 ok(hr == E_POINTER, "expected E_POINTER, got %#x\n", hr);
177
178 hr = ITaskFolder_get_Name(folder, &bstr);
179 ok (hr == S_OK, "get_Name error %#x\n", hr);
180 ok(!lstrcmpW(bstr, bslash), "expected '\\', got %s\n", wine_dbgstr_w(bstr));
181 SysFreeString(bstr);
182
183 hr = ITaskFolder_get_Path(folder, NULL);
184 ok(hr == E_POINTER, "expected E_POINTER, got %#x\n", hr);
185
186 hr = ITaskFolder_get_Path(folder, &bstr);
187 ok(hr == S_OK, "get_Path error %#x\n", hr);
188 ok(!lstrcmpW(bstr, bslash), "expected '\\', got %s\n", wine_dbgstr_w(bstr));
189 SysFreeString(bstr);
190
191 hr = ITaskFolder_CreateFolder(folder, NULL, v_null, &subfolder);
192 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
193
194 /* Just in case something was left from previous runs */
195 ITaskFolder_DeleteFolder(folder, Wine_Folder1_Folder2, 0);
196 ITaskFolder_DeleteFolder(folder, Wine_Folder1, 0);
197 ITaskFolder_DeleteFolder(folder, Wine, 0);
198
199 hr = ITaskFolder_CreateFolder(folder, slash, v_null, &subfolder);
200 todo_wine
201 ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME), "expected ERROR_INVALID_NAME, got %#x\n", hr);
202
203 hr = ITaskService_GetFolder(service, Wine_Folder1_Folder2, &subfolder);
204 ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "expected ERROR_PATH_NOT_FOUND, got %#x\n", hr);
205
206 hr = ITaskFolder_CreateFolder(folder, bslash, v_null, &subfolder);
207 todo_wine
208 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
209
210 hr = ITaskFolder_CreateFolder(folder, Wine_Folder1_Folder2, v_null, &subfolder);
211 ok(hr == S_OK, "CreateFolder error %#x\n", hr);
212 ITaskFolder_Release(subfolder);
213
214 hr = ITaskFolder_CreateFolder(folder, Wine, v_null, NULL);
215 ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#x\n", hr);
216
217 hr = ITaskFolder_CreateFolder(folder, Wine_Folder1_, v_null, &subfolder);
218 todo_wine
219 ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME), "expected ERROR_INVALID_NAME, got %#x\n", hr);
220
221 hr = ITaskFolder_CreateFolder(folder, Wine, v_null, &subfolder);
222 ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#x\n", hr);
223 hr = ITaskFolder_CreateFolder(folder, Wine+1, v_null, &subfolder);
224 ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#x\n", hr);
225 hr = ITaskFolder_CreateFolder(folder, Wine_Folder1, v_null, &subfolder);
226 ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#x\n", hr);
227 hr = ITaskFolder_CreateFolder(folder, Wine_Folder1+1, v_null, &subfolder);
228 ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#x\n", hr);
229 hr = ITaskFolder_CreateFolder(folder, Wine_Folder1_Folder2, v_null, &subfolder);
230 ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#x\n", hr);
231 hr = ITaskFolder_CreateFolder(folder, Wine_Folder1_Folder2+1, v_null, &subfolder);
232 ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#x\n", hr);
233
234 hr = ITaskService_GetFolder(service, Wine_Folder1_Folder2, NULL);
235 ok(hr == E_POINTER, "expected E_POINTER, got %#x\n", hr);
236
237 hr = ITaskService_GetFolder(service, Wine_Folder1_Folder2, &subfolder);
238 ok(hr == S_OK, "GetFolder error %#x\n", hr);
239
240 hr = ITaskFolder_get_Name(subfolder, &bstr);
241 ok (hr == S_OK, "get_Name error %#x\n", hr);
242 ok(!lstrcmpW(bstr, Folder2), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
243 SysFreeString(bstr);
244 hr = ITaskFolder_get_Path(subfolder, &bstr);
245 ok(hr == S_OK, "get_Path error %#x\n", hr);
246 ok(!lstrcmpW(bstr, Wine_Folder1_Folder2), "expected \\Wine\\Folder1\\Folder2, got %s\n", wine_dbgstr_w(bstr));
247 SysFreeString(bstr);
248 ITaskFolder_Release(subfolder);
249
250 hr = ITaskService_GetFolder(service, Wine_Folder1_Folder2+1, &subfolder);
251 ok(hr == S_OK, "GetFolder error %#x\n", hr);
252 hr = ITaskFolder_get_Name(subfolder, &bstr);
253 ok (hr == S_OK, "get_Name error %#x\n", hr);
254 ok(!lstrcmpW(bstr, Folder2), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
255 SysFreeString(bstr);
256 hr = ITaskFolder_get_Path(subfolder, &bstr);
257 ok(hr == S_OK, "get_Path error %#x\n", hr);
258 ok(!lstrcmpW(bstr, Wine_Folder1_Folder2+1), "expected Wine\\Folder1\\Folder2, got %s\n", wine_dbgstr_w(bstr));
259 SysFreeString(bstr);
260 ITaskFolder_Release(subfolder);
261
262 hr = ITaskService_GetFolder(service, Wine_Folder1, &subfolder);
263 ok(hr == S_OK, "GetFolder error %#x\n", hr);
264 hr = ITaskFolder_get_Name(subfolder, &bstr);
265 ok (hr == S_OK, "get_Name error %#x\n", hr);
266 ok(!lstrcmpW(bstr, Folder1), "expected Folder1, got %s\n", wine_dbgstr_w(bstr));
267 SysFreeString(bstr);
268 hr = ITaskFolder_get_Path(subfolder, &bstr);
269 ok(hr == S_OK, "get_Path error %#x\n", hr);
270 ok(!lstrcmpW(bstr, Wine_Folder1), "expected \\Wine\\Folder1, got %s\n", wine_dbgstr_w(bstr));
271 SysFreeString(bstr);
272 ITaskFolder_Release(subfolder);
273
274 hr = ITaskService_GetFolder(service, Wine, &subfolder);
275 ok(hr == S_OK, "GetFolder error %#x\n", hr);
276 hr = ITaskFolder_get_Name(subfolder, &bstr);
277 ok (hr == S_OK, "get_Name error %#x\n", hr);
278 ok(!lstrcmpW(bstr, Wine+1), "expected Wine, got %s\n", wine_dbgstr_w(bstr));
279 SysFreeString(bstr);
280 hr = ITaskFolder_get_Path(subfolder, &bstr);
281 ok(hr == S_OK, "get_Path error %#x\n", hr);
282 ok(!lstrcmpW(bstr, Wine), "expected \\Wine, got %s\n", wine_dbgstr_w(bstr));
283 SysFreeString(bstr);
284 ITaskFolder_Release(subfolder);
285
286 hr = ITaskService_GetFolder(service, Wine+1, &subfolder);
287 ok(hr == S_OK, "GetFolder error %#x\n", hr);
288 hr = ITaskFolder_get_Name(subfolder, &bstr);
289 ok (hr == S_OK, "get_Name error %#x\n", hr);
290 ok(!lstrcmpW(bstr, Wine+1), "expected Wine, got %s\n", wine_dbgstr_w(bstr));
291 SysFreeString(bstr);
292 hr = ITaskFolder_get_Path(subfolder, &bstr);
293 ok(hr == S_OK, "get_Path error %#x\n", hr);
294 ok(!lstrcmpW(bstr, Wine+1), "expected Wine, got %s\n", wine_dbgstr_w(bstr));
295 SysFreeString(bstr);
296
297 hr = ITaskFolder_GetFolder(subfolder, bslash, &subfolder2);
298 todo_wine
299 ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME), "expected ERROR_INVALID_NAME, got %#x\n", hr);
300
301 hr = ITaskFolder_GetFolder(subfolder, NULL, &subfolder2);
302 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
303
304 hr = ITaskFolder_GetFolder(subfolder, empty, &subfolder2);
305 ok(hr == S_OK, "GetFolder error %#x\n", hr);
306 hr = ITaskFolder_get_Name(subfolder2, &bstr);
307 ok (hr == S_OK, "get_Name error %#x\n", hr);
308 ok(!lstrcmpW(bstr, Wine+1), "expected Wine, got %s\n", wine_dbgstr_w(bstr));
309 SysFreeString(bstr);
310 hr = ITaskFolder_get_Path(subfolder2, &bstr);
311 ok(hr == S_OK, "get_Path error %#x\n", hr);
312 ok(!lstrcmpW(bstr, Wine+1), "expected Wine, got %s\n", wine_dbgstr_w(bstr));
313 SysFreeString(bstr);
314 ITaskFolder_Release(subfolder2);
315
316 hr = ITaskFolder_GetFolder(subfolder, Folder1_Folder2, &subfolder2);
317 ok(hr == S_OK, "GetFolder error %#x\n", hr);
318 hr = ITaskFolder_get_Name(subfolder2, &bstr);
319 ok (hr == S_OK, "get_Name error %#x\n", hr);
320 ok(!lstrcmpW(bstr, Folder2), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
321 SysFreeString(bstr);
322 hr = ITaskFolder_get_Path(subfolder2, &bstr);
323 ok(hr == S_OK, "get_Path error %#x\n", hr);
324 ok(!lstrcmpW(bstr, Wine_Folder1_Folder2+1), "expected Wine\\Folder1\\Folder2, got %s\n", wine_dbgstr_w(bstr));
325 SysFreeString(bstr);
326 ITaskFolder_Release(subfolder2);
327
328 hr = ITaskFolder_GetFolder(subfolder, Folder1_Folder2+1, &subfolder2);
329 ok(hr == S_OK, "GetFolder error %#x\n", hr);
330
331 hr = ITaskFolder_get_Name(subfolder2, &bstr);
332 ok (hr == S_OK, "get_Name error %#x\n", hr);
333 ok(!lstrcmpW(bstr, Folder2), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
334 SysFreeString(bstr);
335 hr = ITaskFolder_get_Path(subfolder2, &bstr);
336 ok(hr == S_OK, "get_Path error %#x\n", hr);
337 ok(!lstrcmpW(bstr, Wine_Folder1_Folder2+1), "expected Wine\\Folder1\\Folder2, got %s\n", wine_dbgstr_w(bstr));
338 SysFreeString(bstr);
339 ITaskFolder_Release(subfolder2);
340
341 ITaskFolder_Release(subfolder);
342
343 hr = ITaskFolder_DeleteFolder(folder, Wine, 0);
344 ok(hr == HRESULT_FROM_WIN32(ERROR_DIR_NOT_EMPTY), "expected ERROR_DIR_NOT_EMPTY, got %#x\n", hr);
345
346 hr = ITaskFolder_DeleteFolder(folder, Wine_Folder1_Folder2, 0);
347 ok(hr == S_OK, "DeleteFolder error %#x\n", hr);
348 ITaskFolder_DeleteFolder(folder, Wine_Folder1+1, 0);
349 ok(hr == S_OK, "DeleteFolder error %#x\n", hr);
350 hr = ITaskFolder_DeleteFolder(folder, Wine+1, 0);
351 ok(hr == S_OK, "DeleteFolder error %#x\n", hr);
352
353 hr = ITaskFolder_DeleteFolder(folder, Wine, 0);
354 ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "expected ERROR_FILE_NOT_FOUND, got %#x\n", hr);
355
356 hr = ITaskFolder_DeleteFolder(folder, NULL, 0);
357 ok(hr == E_ACCESSDENIED || hr == E_INVALIDARG /* Vista */, "expected E_ACCESSDENIED, got %#x\n", hr);
358
359 hr = ITaskFolder_DeleteFolder(folder, empty, 0);
360 ok(hr == E_ACCESSDENIED || hr == E_INVALIDARG /* Vista */, "expected E_ACCESSDENIED, got %#x\n", hr);
361
362 hr = ITaskFolder_DeleteFolder(folder, slash, 0);
363 todo_wine
364 ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME), "expected ERROR_INVALID_NAME, got %#x\n", hr);
365
366 ITaskFolder_Release(folder);
367 ITaskService_Release(service);
368 }
369
370 static void set_var(int vt, VARIANT *var, LONG val)
371 {
372 V_VT(var) = vt;
373
374 switch(vt)
375 {
376 case VT_I1:
377 case VT_UI1:
378 V_UI1(var) = (BYTE)val;
379 break;
380
381 case VT_I2:
382 case VT_UI2:
383 V_UI2(var) = (USHORT)val;
384 break;
385
386 case VT_I4:
387 case VT_UI4:
388 V_UI4(var) = val;
389 break;
390
391 case VT_I8:
392 case VT_UI8:
393 V_UI8(var) = val;
394 break;
395
396 case VT_INT:
397 case VT_UINT:
398 V_UINT(var) = val;
399 break;
400
401 default:
402 assert(0);
403 break;
404 }
405 }
406
407 static void test_FolderCollection(void)
408 {
409 static WCHAR Wine[] = { '\\','W','i','n','e',0 };
410 static WCHAR Wine_Folder1[] = { '\\','W','i','n','e','\\','F','o','l','d','e','r','1',0 };
411 static WCHAR Wine_Folder2[] = { '\\','W','i','n','e','\\','F','o','l','d','e','r','2',0 };
412 static WCHAR Wine_Folder3[] = { '\\','W','i','n','e','\\','F','o','l','d','e','r','3',0 };
413 static const WCHAR Folder1[] = { 'F','o','l','d','e','r','1',0 };
414 static const WCHAR Folder2[] = { 'F','o','l','d','e','r','2',0 };
415 HRESULT hr;
416 BSTR bstr;
417 VARIANT v_null, var[3];
418 ITaskService *service;
419 ITaskFolder *root, *folder, *subfolder;
420 ITaskFolderCollection *folders;
421 IUnknown *unknown;
422 IEnumVARIANT *enumvar;
423 ULONG count, i;
424 VARIANT idx;
425 static const int vt[] = { VT_I1, VT_I2, VT_I4, VT_I8, VT_UI1, VT_UI2, VT_UI4, VT_UI8, VT_INT, VT_UINT };
426
427 hr = CoCreateInstance(&CLSID_TaskScheduler, NULL, CLSCTX_INPROC_SERVER, &IID_ITaskService, (void **)&service);
428 if (hr != S_OK)
429 {
430 win_skip("CoCreateInstance(CLSID_TaskScheduler) error %#x\n", hr);
431 return;
432 }
433
434 V_VT(&v_null) = VT_NULL;
435
436 hr = ITaskService_Connect(service, v_null, v_null, v_null, v_null);
437 ok(hr == S_OK, "Connect error %#x\n", hr);
438
439 hr = ITaskService_GetFolder(service, NULL, &root);
440 ok(hr == S_OK, "GetFolder error %#x\n", hr);
441
442 /* Just in case something was left from previous runs */
443 ITaskFolder_DeleteFolder(root, Wine_Folder1, 0);
444 ITaskFolder_DeleteFolder(root, Wine_Folder2, 0);
445 ITaskFolder_DeleteFolder(root, Wine_Folder3, 0);
446 ITaskFolder_DeleteFolder(root, Wine, 0);
447
448 hr = ITaskFolder_CreateFolder(root, Wine_Folder1, v_null, &subfolder);
449 ok(hr == S_OK, "CreateFolder error %#x\n", hr);
450 ITaskFolder_Release(subfolder);
451
452 hr = ITaskFolder_CreateFolder(root, Wine_Folder2, v_null, &subfolder);
453 ok(hr == S_OK, "CreateFolder error %#x\n", hr);
454 ITaskFolder_Release(subfolder);
455
456 hr = ITaskFolder_GetFolder(root, Wine, &folder);
457 ok(hr == S_OK, "GetFolder error %#x\n", hr);
458
459 hr = ITaskFolder_GetFolders(folder, 0, NULL);
460 ok (hr == E_POINTER, "expected E_POINTER, got %#x\n", hr);
461
462 hr = ITaskFolder_GetFolders(folder, 0, &folders);
463 ok(hr == S_OK, "GetFolders error %#x\n", hr);
464
465 ITaskFolder_Release(folder);
466
467 hr = ITaskFolderCollection_get_Count(folders, NULL);
468 ok (hr == E_POINTER, "expected E_POINTER, got %#x\n", hr);
469
470 count = 0;
471 hr = ITaskFolderCollection_get_Count(folders, (LONG *)&count);
472 ok(hr == S_OK, "get_Count error %#x\n", hr);
473 ok(count == 2, "expected 2, got %d\n", count);
474
475 hr = ITaskFolder_CreateFolder(root, Wine_Folder3, v_null, &subfolder);
476 ok(hr == S_OK, "CreateFolder error %#x\n", hr);
477 ITaskFolder_Release(subfolder);
478
479 count = 0;
480 hr = ITaskFolderCollection_get_Count(folders, (LONG *)&count);
481 ok(hr == S_OK, "get_Count error %#x\n", hr);
482 ok(count == 2, "expected 2, got %d\n", count);
483
484 set_var(VT_INT, &idx, 0);
485 hr = ITaskFolderCollection_get_Item(folders, idx, NULL);
486 ok (hr == E_POINTER, "expected E_POINTER, got %#x\n", hr);
487
488 for (i = 0; i < sizeof(vt)/sizeof(vt[0]); i++)
489 {
490 set_var(vt[i], &idx, 1);
491 hr = ITaskFolderCollection_get_Item(folders, idx, &subfolder);
492 ok(hr == S_OK, "get_Item(vt = %d) error %#x\n", vt[i], hr);
493 ITaskFolder_Release(subfolder);
494 }
495
496 for (i = 0; i <= count; i++)
497 {
498 V_VT(&idx) = VT_I4;
499 V_UI4(&idx) = i;
500 hr = ITaskFolderCollection_get_Item(folders, idx, &subfolder);
501 if (i == 0)
502 {
503 ok (hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
504 continue;
505 }
506 ok(hr == S_OK, "get_Item error %#x\n", hr);
507
508 hr = ITaskFolder_get_Path(subfolder, &bstr);
509 ok(hr == S_OK, "get_Path error %#x\n", hr);
510 if (i == 1)
511 ok(!lstrcmpW(bstr, Wine_Folder1), "expected \\Wine\\Folder1, got %s\n", wine_dbgstr_w(bstr));
512 else
513 ok(!lstrcmpW(bstr, Wine_Folder2), "expected \\Wine\\Folder2, got %s\n", wine_dbgstr_w(bstr));
514 SysFreeString(bstr);
515
516 hr = ITaskFolder_get_Name(subfolder, &bstr);
517 ok(hr == S_OK, "get_Name error %#x\n", hr);
518 if (i == 1)
519 ok(!lstrcmpW(bstr, Folder1), "expected Folder1, got %s\n", wine_dbgstr_w(bstr));
520 else
521 ok(!lstrcmpW(bstr, Folder2), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
522
523 ITaskFolder_Release(subfolder);
524
525 V_VT(&idx) = VT_BSTR;
526 V_BSTR(&idx) = bstr;
527 hr = ITaskFolderCollection_get_Item(folders, idx, &subfolder);
528 ok(hr == S_OK, "get_Item error %#x\n", hr);
529 SysFreeString(bstr);
530
531 hr = ITaskFolder_get_Path(subfolder, &bstr);
532 ok(hr == S_OK, "get_Path error %#x\n", hr);
533 if (i == 1)
534 ok(!lstrcmpW(bstr, Wine_Folder1), "expected \\Wine\\Folder1, got %s\n", wine_dbgstr_w(bstr));
535 else
536 ok(!lstrcmpW(bstr, Wine_Folder2), "expected \\Wine\\Folder2, got %s\n", wine_dbgstr_w(bstr));
537 SysFreeString(bstr);
538
539 hr = ITaskFolder_get_Name(subfolder, &bstr);
540 ok(hr == S_OK, "get_Name error %#x\n", hr);
541 if (i == 1)
542 ok(!lstrcmpW(bstr, Folder1), "expected Folder1, got %s\n", wine_dbgstr_w(bstr));
543 else
544 ok(!lstrcmpW(bstr, Folder2), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
545
546 ITaskFolder_Release(subfolder);
547 }
548
549 V_VT(&idx) = VT_I4;
550 V_UI4(&idx) = 3;
551 hr = ITaskFolderCollection_get_Item(folders, idx, &subfolder);
552 ok (hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
553
554 hr = ITaskFolderCollection_QueryInterface(folders, &IID_IEnumVARIANT, (void **)&enumvar);
555 ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#x\n", hr);
556 hr = ITaskFolderCollection_QueryInterface(folders, &IID_IEnumUnknown, (void **)&enumvar);
557 ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#x\n", hr);
558
559 hr = ITaskFolderCollection_get__NewEnum(folders, NULL);
560 ok (hr == E_POINTER, "expected E_POINTER, got %#x\n", hr);
561
562 hr = ITaskFolderCollection_get__NewEnum(folders, &unknown);
563 ok(hr == S_OK, "get__NewEnum error %#x\n", hr);
564 hr = IUnknown_QueryInterface(unknown, &IID_IEnumUnknown, (void **)&enumvar);
565 ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#x\n", hr);
566 hr = IUnknown_QueryInterface(unknown, &IID_IEnumVARIANT, (void **)&enumvar);
567 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
568 IEnumVARIANT_Release(enumvar);
569
570 hr = IUnknown_QueryInterface(unknown, &IID_IUnknown, (void **)&enumvar);
571 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
572
573 hr = IEnumVARIANT_Skip(enumvar, 0);
574 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
575 hr = IEnumVARIANT_Skip(enumvar, 2);
576 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
577 hr = IEnumVARIANT_Skip(enumvar, 1);
578 ok(hr == S_FALSE, "expected S_FALSE, got %#x\n", hr);
579
580 hr = IEnumVARIANT_Reset(enumvar);
581 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
582
583 count = -1;
584 hr = IEnumVARIANT_Next(enumvar, 1, NULL, &count);
585 ok(hr == E_POINTER, "expected E_POINTER, got %#x\n", hr);
586
587 memset(var, 0, sizeof(var));
588 count = -1;
589 hr = IEnumVARIANT_Next(enumvar, 1, var, &count);
590 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
591 ok(count == 1, "expected 1, got %d\n", count);
592 hr = ITaskFolder_get_Path((ITaskFolder *)V_DISPATCH(&var[0]), &bstr);
593 ok(hr == S_OK, "get_Path error %#x\n", hr);
594 ok(!lstrcmpW(bstr, Wine_Folder2), "expected \\Wine\\Folder2, got %s\n", wine_dbgstr_w(bstr));
595 SysFreeString(bstr);
596 hr = ITaskFolder_get_Name((ITaskFolder *)V_DISPATCH(&var[0]), &bstr);
597 ok(hr == S_OK, "get_Name error %#x\n", hr);
598 ok(!lstrcmpW(bstr, Folder2), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
599 IDispatch_Release(V_DISPATCH(&var[0]));
600
601 memset(var, 0, sizeof(var));
602 count = -1;
603 hr = IEnumVARIANT_Next(enumvar, 1, var, &count);
604 ok(hr == S_FALSE, "expected S_FALSE, got %#x\n", hr);
605 ok(count == 0, "expected 0, got %d\n", count);
606
607 count = -1;
608 hr = IEnumVARIANT_Next(enumvar, 1, NULL, &count);
609 ok(hr == S_FALSE, "expected S_FALSE, got %#x\n", hr);
610 ok(count == 0, "expected 0, got %d\n", count);
611
612 hr = IEnumVARIANT_Reset(enumvar);
613 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
614
615 memset(var, 0, sizeof(var));
616 count = -1;
617 hr = IEnumVARIANT_Next(enumvar, 3, var, &count);
618 ok(hr == S_FALSE, "expected S_FALSE, got %#x\n", hr);
619 ok(count == 2, "expected 2, got %d\n", count);
620 ok(V_VT(&var[0]) == VT_DISPATCH, "expected VT_DISPATCH, got %d\n", V_VT(&var[0]));
621 ok(V_VT(&var[1]) == VT_DISPATCH, "expected VT_DISPATCH, got %d\n", V_VT(&var[1]));
622 IEnumVARIANT_Release(enumvar);
623
624 for (i = 0; i < count; i++)
625 {
626 hr = IDispatch_QueryInterface(V_DISPATCH(&var[i]), &IID_ITaskFolder, (void **)&subfolder);
627 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
628
629 hr = ITaskFolder_get_Path(subfolder, &bstr);
630 ok(hr == S_OK, "get_Path error %#x\n", hr);
631 if (i == 0)
632 ok(!lstrcmpW(bstr, Wine_Folder1), "expected \\Wine\\Folder1, got %s\n", wine_dbgstr_w(bstr));
633 else
634 ok(!lstrcmpW(bstr, Wine_Folder2), "expected \\Wine\\Folder2, got %s\n", wine_dbgstr_w(bstr));
635 SysFreeString(bstr);
636
637 hr = ITaskFolder_get_Name(subfolder, &bstr);
638 ok(hr == S_OK, "get_Name error %#x\n", hr);
639 if (i == 0)
640 ok(!lstrcmpW(bstr, Folder1), "expected Folder1, got %s\n", wine_dbgstr_w(bstr));
641 else
642 ok(!lstrcmpW(bstr, Folder2), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
643
644 ITaskFolder_Release(subfolder);
645 }
646
647 IDispatch_Release(V_DISPATCH(&var[0]));
648 IDispatch_Release(V_DISPATCH(&var[1]));
649
650 ITaskFolderCollection_Release(folders);
651
652 hr = ITaskFolder_DeleteFolder(root, Wine_Folder1, 0);
653 ok(hr == S_OK, "DeleteFolder error %#x\n", hr);
654 hr = ITaskFolder_DeleteFolder(root, Wine_Folder2, 0);
655 ok(hr == S_OK, "DeleteFolder error %#x\n", hr);
656 hr = ITaskFolder_DeleteFolder(root, Wine_Folder3, 0);
657 ok(hr == S_OK, "DeleteFolder error %#x\n", hr);
658 hr = ITaskFolder_DeleteFolder(root, Wine, 0);
659 ok(hr == S_OK, "DeleteFolder error %#x\n", hr);
660
661 ITaskFolder_Release(root);
662 ITaskService_Release(service);
663 }
664
665 static void test_GetTask(void)
666 {
667 static WCHAR Wine[] = { '\\','W','i','n','e',0 };
668 static WCHAR Wine_Task1[] = { '\\','W','i','n','e','\\','T','a','s','k','1',0 };
669 static WCHAR Wine_Task2[] = { '\\','W','i','n','e','\\','T','a','s','k','2',0 };
670 static WCHAR Task1[] = { 'T','a','s','k','1',0 };
671 static WCHAR Task2[] = { 'T','a','s','k','2',0 };
672 static const char xml1[] =
673 "<?xml version=\"1.0\"?>\n"
674 "<Task xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
675 " <RegistrationInfo>\n"
676 " <Description>\"Task1\"</Description>\n"
677 " </RegistrationInfo>\n"
678 " <Settings>\n"
679 " <Enabled>false</Enabled>\n"
680 " <Hidden>false</Hidden>\n"
681 " </Settings>\n"
682 " <Actions>\n"
683 " <Exec>\n"
684 " <Command>\"task1.exe\"</Command>\n"
685 " </Exec>\n"
686 " </Actions>\n"
687 "</Task>\n";
688 static const char xml2[] =
689 "<?xml version=\"1.0\"?>\n"
690 "<Task xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
691 " <RegistrationInfo>\n"
692 " <Description>\"Task2\"</Description>\n"
693 " </RegistrationInfo>\n"
694 " <Settings>\n"
695 " <Enabled>true</Enabled>\n"
696 " <Hidden>true</Hidden>\n"
697 " </Settings>\n"
698 " <Actions>\n"
699 " <Exec>\n"
700 " <Command>\"task2.exe\"</Command>\n"
701 " </Exec>\n"
702 " </Actions>\n"
703 "</Task>\n";
704 static const struct
705 {
706 DWORD flags, hr;
707 } create_new_task[] =
708 {
709 { 0, S_OK },
710 { TASK_CREATE, S_OK },
711 { TASK_UPDATE, 0x80070002 /* HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) */ },
712 { TASK_CREATE | TASK_UPDATE, S_OK }
713 };
714 static const struct
715 {
716 DWORD flags, hr;
717 } open_existing_task[] =
718 {
719 { 0, 0x800700b7 /* HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS) */ },
720 { TASK_CREATE, 0x800700b7 /* HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS) */ },
721 { TASK_UPDATE, S_OK },
722 { TASK_CREATE | TASK_UPDATE, S_OK }
723 };
724 WCHAR xmlW[sizeof(xml1)];
725 HRESULT hr;
726 BSTR bstr;
727 TASK_STATE state;
728 VARIANT_BOOL vbool;
729 VARIANT v_null;
730 ITaskService *service;
731 ITaskFolder *root, *folder;
732 IRegisteredTask *task1, *task2;
733 IID iid;
734 int i;
735
736 hr = CoCreateInstance(&CLSID_TaskScheduler, NULL, CLSCTX_INPROC_SERVER, &IID_ITaskService, (void **)&service);
737 if (hr != S_OK)
738 {
739 win_skip("CoCreateInstance(CLSID_TaskScheduler) error %#x\n", hr);
740 return;
741 }
742
743 V_VT(&v_null) = VT_NULL;
744
745 hr = ITaskService_Connect(service, v_null, v_null, v_null, v_null);
746 ok(hr == S_OK, "Connect error %#x\n", hr);
747
748 hr = ITaskService_GetFolder(service, NULL, &root);
749 ok(hr == S_OK, "GetFolder error %#x\n", hr);
750
751 /* Just in case something was left from previous runs */
752 ITaskFolder_DeleteTask(root, Wine_Task1, 0);
753 ITaskFolder_DeleteTask(root, Wine_Task2, 0);
754 ITaskFolder_DeleteFolder(root, Wine, 0);
755
756 hr = ITaskFolder_GetTask(root, Wine_Task1, &task1);
757 ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "expected ERROR_PATH_NOT_FOUND, got %#x\n", hr);
758
759 hr = ITaskFolder_CreateFolder(root, Wine, v_null, &folder);
760 ok(hr == S_OK, "CreateFolder error %#x\n", hr);
761
762 hr = ITaskFolder_GetTask(root, Wine, &task1);
763 ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "expected ERROR_PATH_NOT_FOUND, got %#x\n", hr);
764
765 MultiByteToWideChar(CP_ACP, 0, xml1, -1, xmlW, sizeof(xmlW)/sizeof(xmlW[0]));
766
767 for (i = 0; i < sizeof(create_new_task)/sizeof(create_new_task[0]); i++)
768 {
769 hr = ITaskFolder_RegisterTask(root, Wine_Task1, xmlW, create_new_task[i].flags, v_null, v_null, TASK_LOGON_NONE, v_null, &task1);
770 ok(hr == create_new_task[i].hr, "%d: expected %#x, got %#x\n", i, create_new_task[i].hr, hr);
771 if (hr == S_OK)
772 {
773 hr = ITaskFolder_DeleteTask(root, Wine_Task1, 0);
774 ok(hr == S_OK, "DeleteTask error %#x\n", hr);
775 }
776 }
777
778 hr = ITaskFolder_RegisterTask(root, Wine_Task1, NULL, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, NULL);
779 ok(hr == HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER), "expected RPC_X_NULL_REF_POINTER, got %#x\n", hr);
780
781 hr = ITaskFolder_RegisterTask(root, Wine, xmlW, TASK_VALIDATE_ONLY, v_null, v_null, TASK_LOGON_NONE, v_null, NULL);
782 ok(hr == S_OK, "RegisterTask error %#x\n", hr);
783
784 hr = ITaskFolder_RegisterTask(root, Wine, xmlW, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, NULL);
785 todo_wine
786 ok(hr == HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED) || broken(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS)) /* Vista */, "expected ERROR_ACCESS_DENIED, got %#x\n", hr);
787
788 hr = ITaskFolder_RegisterTask(root, Wine_Task1, xmlW, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, NULL);
789 ok(hr == S_OK, "RegisterTask error %#x\n", hr);
790
791 hr = ITaskFolder_RegisterTask(root, Wine_Task1, xmlW, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, &task1);
792 ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#x\n", hr);
793
794 hr = ITaskFolder_RegisterTask(root, Wine_Task1, xmlW, 0, v_null, v_null, TASK_LOGON_NONE, v_null, NULL);
795 ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#x\n", hr);
796
797 hr = ITaskFolder_RegisterTask(root, Wine_Task1, xmlW, TASK_CREATE_OR_UPDATE, v_null, v_null, TASK_LOGON_NONE, v_null, &task1);
798 ok(hr == S_OK, "RegisterTask error %#x\n", hr);
799
800 for (i = 0; i < sizeof(open_existing_task)/sizeof(open_existing_task[0]); i++)
801 {
802 hr = ITaskFolder_RegisterTask(root, Wine_Task1, xmlW, open_existing_task[i].flags, v_null, v_null, TASK_LOGON_NONE, v_null, &task1);
803 ok(hr == open_existing_task[i].hr, "%d: expected %#x, got %#x\n", i, open_existing_task[i].hr, hr);
804 }
805
806 hr = IRegisteredTask_get_Name(task1, NULL);
807 ok(hr == E_POINTER, "expected E_POINTER, got %#x\n", hr);
808
809 hr = IRegisteredTask_get_Name(task1, &bstr);
810 ok(hr == S_OK, "get_Name error %#x\n", hr);
811 ok(!lstrcmpW(bstr, Task1), "expected Task1, got %s\n", wine_dbgstr_w(bstr));
812 SysFreeString(bstr);
813 hr = IRegisteredTask_get_Path(task1, &bstr);
814 ok(hr == S_OK, "get_Path error %#x\n", hr);
815 ok(!lstrcmpW(bstr, Wine_Task1), "expected \\Wine\\Task1, got %s\n", wine_dbgstr_w(bstr));
816 SysFreeString(bstr);
817 hr = IRegisteredTask_get_State(task1, &state);
818 ok(hr == S_OK, "get_State error %#x\n", hr);
819 ok(state == TASK_STATE_DISABLED, "expected TASK_STATE_DISABLED, got %d\n", state);
820 hr = IRegisteredTask_get_Enabled(task1, &vbool);
821 ok(hr == S_OK, "get_Enabled error %#x\n", hr);
822 ok(vbool == VARIANT_FALSE, "expected VARIANT_FALSE, got %d\n", vbool);
823
824 IRegisteredTask_Release(task1);
825
826 hr = ITaskFolder_RegisterTask(folder, Task1, xmlW, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, &task2);
827 ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#x\n", hr);
828
829 MultiByteToWideChar(CP_ACP, 0, xml2, -1, xmlW, sizeof(xmlW)/sizeof(xmlW[0]));
830
831 hr = ITaskFolder_RegisterTask(folder, Task2, xmlW, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, &task2);
832 ok(hr == S_OK, "RegisterTask error %#x\n", hr);
833
834 hr = IRegisteredTask_get_Name(task2, &bstr);
835 ok(hr == S_OK, "get_Name error %#x\n", hr);
836 ok(!lstrcmpW(bstr, Task2), "expected Task2, got %s\n", wine_dbgstr_w(bstr));
837 SysFreeString(bstr);
838 hr = IRegisteredTask_get_Path(task2, &bstr);
839 ok(hr == S_OK, "get_Path error %#x\n", hr);
840 ok(!lstrcmpW(bstr, Wine_Task2), "expected \\Wine\\Task2, got %s\n", wine_dbgstr_w(bstr));
841 SysFreeString(bstr);
842 hr = IRegisteredTask_get_State(task2, &state);
843 ok(hr == S_OK, "get_State error %#x\n", hr);
844 todo_wine
845 ok(state == TASK_STATE_READY, "expected TASK_STATE_READY, got %d\n", state);
846 hr = IRegisteredTask_get_Enabled(task2, &vbool);
847 ok(hr == S_OK, "get_Enabled error %#x\n", hr);
848 todo_wine
849 ok(vbool == VARIANT_TRUE, "expected VARIANT_TRUE, got %d\n", vbool);
850
851 IRegisteredTask_Release(task2);
852
853 hr = ITaskFolder_GetTask(root, NULL, &task1);
854 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
855
856 hr = ITaskFolder_GetTask(root, Wine_Task1, NULL);
857 ok(hr == E_POINTER, "expected E_POINTER, got %#x\n", hr);
858
859 hr = ITaskFolder_GetTask(root, Wine_Task1, &task1);
860 ok(hr == S_OK, "GetTask error %#x\n", hr);
861
862 hr = IRegisteredTask_get_Name(task1, &bstr);
863 ok(hr == S_OK, "get_Name error %#x\n", hr);
864 ok(!lstrcmpW(bstr, Task1), "expected Task1, got %s\n", wine_dbgstr_w(bstr));
865 SysFreeString(bstr);
866 hr = IRegisteredTask_get_Path(task1, &bstr);
867 ok(hr == S_OK, "get_Path error %#x\n", hr);
868 ok(!lstrcmpW(bstr, Wine_Task1), "expected \\Wine\\Task1, got %s\n", wine_dbgstr_w(bstr));
869 SysFreeString(bstr);
870 hr = IRegisteredTask_get_State(task1, &state);
871 ok(hr == S_OK, "get_State error %#x\n", hr);
872 ok(state == TASK_STATE_DISABLED, "expected TASK_STATE_DISABLED, got %d\n", state);
873 hr = IRegisteredTask_get_Enabled(task1, &vbool);
874 ok(hr == S_OK, "get_Enabled error %#x\n", hr);
875 ok(vbool == VARIANT_FALSE, "expected VARIANT_FALSE, got %d\n", vbool);
876
877 hr = IRegisteredTask_put_Enabled(task1, VARIANT_TRUE);
878 todo_wine
879 ok(hr == S_OK, "put_Enabled error %#x\n", hr);
880 hr = IRegisteredTask_get_State(task1, &state);
881 ok(hr == S_OK, "get_State error %#x\n", hr);
882 todo_wine
883 ok(state == TASK_STATE_READY, "expected TASK_STATE_READY, got %d\n", state);
884 hr = IRegisteredTask_get_Enabled(task1, &vbool);
885 ok(hr == S_OK, "get_Enabled error %#x\n", hr);
886 todo_wine
887 ok(vbool == VARIANT_TRUE, "expected VARIANT_TRUE, got %d\n", vbool);
888
889 IRegisteredTask_Release(task1);
890
891 hr = ITaskFolder_GetTask(folder, Task2, &task2);
892 ok(hr == S_OK, "GetTask error %#x\n", hr);
893
894 hr = IRegisteredTask_get_Name(task2, &bstr);
895 ok(hr == S_OK, "get_Name error %#x\n", hr);
896 ok(!lstrcmpW(bstr, Task2), "expected Task2, got %s\n", wine_dbgstr_w(bstr));
897 SysFreeString(bstr);
898 hr = IRegisteredTask_get_Path(task2, &bstr);
899 ok(hr == S_OK, "get_Path error %#x\n", hr);
900 ok(!lstrcmpW(bstr, Wine_Task2), "expected \\Wine\\Task2, got %s\n", wine_dbgstr_w(bstr));
901 SysFreeString(bstr);
902 hr = IRegisteredTask_get_State(task2, &state);
903 ok(hr == S_OK, "get_State error %#x\n", hr);
904 todo_wine
905 ok(state == TASK_STATE_READY, "expected TASK_STATE_READY, got %d\n", state);
906 hr = IRegisteredTask_get_Enabled(task2, &vbool);
907 ok(hr == S_OK, "get_Enabled error %#x\n", hr);
908 todo_wine
909 ok(vbool == VARIANT_TRUE, "expected VARIANT_TRUE, got %d\n", vbool);
910
911 hr = IRegisteredTask_get_State(task2, NULL);
912 ok(hr == E_POINTER, "expected E_POINTER, got %#x\n", hr);
913 hr = IRegisteredTask_get_Enabled(task2, NULL);
914 ok(hr == E_POINTER, "expected E_POINTER, got %#x\n", hr);
915
916 IRegisteredTask_Release(task2);
917
918 hr = ITaskFolder_DeleteTask(folder, NULL, 0);
919 todo_wine
920 ok(hr == HRESULT_FROM_WIN32(ERROR_DIR_NOT_EMPTY), "expected ERROR_DIR_NOT_EMPTY, got %#x\n", hr);
921
922 hr = ITaskFolder_DeleteTask(root, Wine_Task1, 0);
923 ok(hr == S_OK, "DeleteTask error %#x\n", hr);
924 hr = ITaskFolder_DeleteTask(folder, Task2, 0);
925 ok(hr == S_OK, "DeleteTask error %#x\n", hr);
926
927 hr = ITaskFolder_DeleteTask(folder, Task2, 0);
928 ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "expected ERROR_FILE_NOT_FOUND, got %#x\n", hr);
929
930 hr = ITaskFolder_RegisterTask(root, NULL, xmlW, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, &task1);
931 ok(hr == S_OK, "RegisterTask error %#x\n", hr);
932
933 hr = IRegisteredTask_get_Name(task1, &bstr);
934 ok(hr == S_OK, "get_Name error %#x\n", hr);
935 hr = IIDFromString(bstr, &iid);
936 ok(hr == S_OK, "IIDFromString error %#x\n", hr);
937
938 IRegisteredTask_Release(task1);
939
940 hr = ITaskFolder_DeleteTask(root, bstr, 0);
941 ok(hr == S_OK, "DeleteTask error %#x\n", hr);
942
943 hr = ITaskFolder_RegisterTask(folder, NULL, xmlW, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, &task1);
944 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
945
946 ITaskFolder_Release(folder);
947
948 hr = ITaskFolder_DeleteFolder(root, Wine, 0);
949 ok(hr == S_OK, "DeleteFolder error %#x\n", hr);
950
951 ITaskFolder_Release(root);
952 ITaskService_Release(service);
953 }
954
955 struct settings
956 {
957 WCHAR restart_interval[20];
958 WCHAR execution_time_limit[20];
959 WCHAR delete_expired_task_after[20];
960 int restart_count;
961 int priority;
962 TASK_INSTANCES_POLICY policy;
963 TASK_COMPATIBILITY compatibility;
964 VARIANT_BOOL allow_on_demand_start;
965 VARIANT_BOOL stop_if_going_on_batteries;
966 VARIANT_BOOL disallow_start_if_on_batteries;
967 VARIANT_BOOL allow_hard_terminate;
968 VARIANT_BOOL start_when_available;
969 VARIANT_BOOL run_only_if_network_available;
970 VARIANT_BOOL enabled;
971 VARIANT_BOOL hidden;
972 VARIANT_BOOL run_only_if_idle;
973 VARIANT_BOOL wake_to_run;
974 };
975
976 /* test the version 1 compatibility settings */
977 static void test_settings_v1(ITaskDefinition *taskdef, struct settings *test, struct settings *def)
978 {
979 HRESULT hr;
980 ITaskSettings *set;
981 int vint;
982 VARIANT_BOOL vbool;
983 BSTR bstr;
984 TASK_INSTANCES_POLICY policy;
985 TASK_COMPATIBILITY compat;
986
987 hr = ITaskDefinition_get_Settings(taskdef, &set);
988 ok(hr == S_OK, "get_Settings error %#x\n", hr);
989
990 hr = ITaskSettings_get_AllowDemandStart(set, &vbool);
991 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
992 ok(vbool == def->allow_on_demand_start, "expected %d, got %d\n", def->allow_on_demand_start, vbool);
993
994 hr = ITaskSettings_get_RestartInterval(set, &bstr);
995 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
996 if (!def->restart_interval[0])
997 ok(bstr == NULL, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
998 else
999 ok(!lstrcmpW(bstr, def->restart_interval), "expected %s, got %s\n", wine_dbgstr_w(def->restart_interval), wine_dbgstr_w(bstr));
1000
1001 hr = ITaskSettings_get_RestartCount(set, &vint);
1002 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1003 ok(vint == def->restart_count, "expected %d, got %d\n", def->restart_count, vint);
1004
1005 hr = ITaskSettings_get_MultipleInstances(set, &policy);
1006 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1007 ok(policy == def->policy, "expected %d, got %d\n", def->policy, policy);
1008
1009 hr = ITaskSettings_get_StopIfGoingOnBatteries(set, &vbool);
1010 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1011 ok(vbool == test->stop_if_going_on_batteries, "expected %d, got %d\n", test->stop_if_going_on_batteries, vbool);
1012
1013 hr = ITaskSettings_get_DisallowStartIfOnBatteries(set, &vbool);
1014 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1015 ok(vbool == test->disallow_start_if_on_batteries, "expected %d, got %d\n", test->disallow_start_if_on_batteries, vbool);
1016
1017 hr = ITaskSettings_get_AllowHardTerminate(set, &vbool);
1018 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1019 ok(vbool == def->allow_hard_terminate, "expected %d, got %d\n", def->allow_hard_terminate, vbool);
1020
1021 hr = ITaskSettings_get_StartWhenAvailable(set, &vbool);
1022 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1023 ok(vbool == def->start_when_available, "expected %d, got %d\n", def->start_when_available, vbool);
1024
1025 hr = ITaskSettings_get_RunOnlyIfNetworkAvailable(set, &vbool);
1026 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1027 ok(vbool == def->run_only_if_network_available, "expected %d, got %d\n", def->run_only_if_network_available, vbool);
1028
1029 hr = ITaskSettings_get_ExecutionTimeLimit(set, &bstr);
1030 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1031 if (!test->execution_time_limit[0])
1032 ok(bstr == NULL, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1033 else
1034 ok(!lstrcmpW(bstr, test->execution_time_limit), "expected %s, got %s\n", wine_dbgstr_w(test->execution_time_limit), wine_dbgstr_w(bstr));
1035
1036 hr = ITaskSettings_get_Enabled(set, &vbool);
1037 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1038 ok(vbool == test->enabled, "expected %d, got %d\n", test->enabled, vbool);
1039
1040 hr = ITaskSettings_get_DeleteExpiredTaskAfter(set, &bstr);
1041 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1042 if (!test->delete_expired_task_after[0])
1043 ok(bstr == NULL, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1044 else
1045 ok(!lstrcmpW(bstr, test->delete_expired_task_after), "expected %s, got %s\n", wine_dbgstr_w(test->delete_expired_task_after), wine_dbgstr_w(bstr));
1046
1047 hr = ITaskSettings_get_Priority(set, &vint);
1048 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1049 ok(vint == test->priority, "expected %d, got %d\n", test->priority, vint);
1050
1051 hr = ITaskSettings_get_Compatibility(set, &compat);
1052 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1053 ok(compat == test->compatibility, "expected %d, got %d\n", test->compatibility, compat);
1054
1055 hr = ITaskSettings_get_Hidden(set, &vbool);
1056 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1057 ok(vbool == test->hidden, "expected %d, got %d\n", test->hidden, vbool);
1058
1059 hr = ITaskSettings_get_RunOnlyIfIdle(set, &vbool);
1060 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1061 ok(vbool == test->run_only_if_idle, "expected %d, got %d\n", test->run_only_if_idle, vbool);
1062
1063 hr = ITaskSettings_get_WakeToRun(set, &vbool);
1064 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1065 ok(vbool == test->wake_to_run, "expected %d, got %d\n", test->wake_to_run, vbool);
1066
1067 /* FIXME: test IIdleSettings and INetworkSettings */
1068
1069 ITaskSettings_Release(set);
1070 }
1071
1072 static void change_settings(ITaskDefinition *taskdef, struct settings *test)
1073 {
1074 HRESULT hr;
1075 ITaskSettings *set;
1076
1077 hr = ITaskDefinition_get_Settings(taskdef, &set);
1078 ok(hr == S_OK, "get_Settings error %#x\n", hr);
1079
1080 if (!test->restart_interval[0])
1081 hr = ITaskSettings_put_RestartInterval(set, NULL);
1082 else
1083 hr = ITaskSettings_put_RestartInterval(set, test->restart_interval);
1084 todo_wine
1085 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1086 /* FIXME: Remove once implemented */
1087 if (hr != S_OK) return;
1088
1089 hr = ITaskSettings_put_RestartCount(set, test->restart_count);
1090 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1091
1092 hr = ITaskSettings_put_MultipleInstances(set, test->policy);
1093 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1094
1095 hr = ITaskSettings_put_StopIfGoingOnBatteries(set, test->stop_if_going_on_batteries);
1096 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1097
1098 hr = ITaskSettings_put_DisallowStartIfOnBatteries(set, test->disallow_start_if_on_batteries);
1099 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1100
1101 hr = ITaskSettings_put_AllowHardTerminate(set, test->allow_hard_terminate);
1102 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1103
1104 hr = ITaskSettings_put_StartWhenAvailable(set, test->start_when_available);
1105 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1106
1107 hr = ITaskSettings_put_RunOnlyIfNetworkAvailable(set, test->run_only_if_network_available);
1108 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1109
1110 if (!test->execution_time_limit[0])
1111 hr = ITaskSettings_put_ExecutionTimeLimit(set, NULL);
1112 else
1113 hr = ITaskSettings_put_ExecutionTimeLimit(set, test->execution_time_limit);
1114 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1115
1116 hr = ITaskSettings_put_Enabled(set, test->enabled);
1117 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1118
1119 if (!test->delete_expired_task_after[0])
1120 hr = ITaskSettings_put_DeleteExpiredTaskAfter(set, NULL);
1121 else
1122 hr = ITaskSettings_put_DeleteExpiredTaskAfter(set, test->delete_expired_task_after);
1123 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1124
1125 hr = ITaskSettings_put_Priority(set, test->priority);
1126 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1127
1128 hr = ITaskSettings_put_Compatibility(set, test->compatibility);
1129 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1130
1131 hr = ITaskSettings_put_Hidden(set, test->hidden);
1132 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1133
1134 hr = ITaskSettings_put_RunOnlyIfIdle(set, test->run_only_if_idle);
1135 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1136
1137 hr = ITaskSettings_put_WakeToRun(set, test->wake_to_run);
1138 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1139
1140 hr = ITaskSettings_put_AllowDemandStart(set, test->allow_on_demand_start);
1141 ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
1142
1143 /* FIXME: set IIdleSettings and INetworkSettings */
1144
1145 ITaskSettings_Release(set);
1146 }
1147
1148 static void create_action(ITaskDefinition *taskdef)
1149 {
1150 static WCHAR task1_exe[] = { 't','a','s','k','1','.','e','x','e',0 };
1151 HRESULT hr;
1152 IActionCollection *actions;
1153 IAction *action;
1154 IExecAction *exec_action;
1155
1156 hr = ITaskDefinition_get_Actions(taskdef, &actions);
1157 todo_wine
1158 ok(hr == S_OK, "get_Actions error %#x\n", hr);
1159 /* FIXME: Remove once implemented */
1160 if (hr != S_OK) return;
1161
1162 hr = IActionCollection_Create(actions, TASK_ACTION_EXEC, &action);
1163 ok(hr == S_OK, "Create action error %#x\n", hr);
1164
1165 hr = IAction_QueryInterface(action, &IID_IExecAction, (void **)&exec_action);
1166 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1167
1168 hr = IExecAction_put_Path(exec_action, task1_exe);
1169 ok(hr == S_OK, "put_Path error %#x\n", hr);
1170
1171 IExecAction_Release(exec_action);
1172 IAction_Release(action);
1173 IActionCollection_Release(actions);
1174 }
1175
1176 static void test_TaskDefinition(void)
1177 {
1178 static const char xml1[] =
1179 "<Task xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
1180 " <RegistrationInfo>\n"
1181 " <Description>\"Task1\"</Description>\n"
1182 " </RegistrationInfo>\n"
1183 " <Settings>\n"
1184 " <Enabled>false</Enabled>\n"
1185 " <Hidden>false</Hidden>\n"
1186 " </Settings>\n"
1187 " <Actions>\n"
1188 " <Exec>\n"
1189 " <Command>\"task1.exe\"</Command>\n"
1190 " </Exec>\n"
1191 " </Actions>\n"
1192 "</Task>\n";
1193 static const char xml2[] =
1194 "<Task>\n"
1195 " <RegistrationInfo>\n"
1196 " <Description>\"Task1\"</Description>\n"
1197 " </RegistrationInfo>\n"
1198 " <Settings>\n"
1199 " <Enabled>false</Enabled>\n"
1200 " <Hidden>false</Hidden>\n"
1201 " </Settings>\n"
1202 " <Actions>\n"
1203 " <Exec>\n"
1204 " <Command>\"task1.exe\"</Command>\n"
1205 " </Exec>\n"
1206 " </Actions>\n"
1207 "</Task>\n";
1208 static const char xml3[] =
1209 "<TASK>\n"
1210 " <RegistrationInfo>\n"
1211 " <Description>\"Task1\"</Description>\n"
1212 " </RegistrationInfo>\n"
1213 " <Settings>\n"
1214 " <Enabled>false</Enabled>\n"
1215 " <Hidden>false</Hidden>\n"
1216 " </Settings>\n"
1217 " <Actions>\n"
1218 " <Exec>\n"
1219 " <Command>\"task1.exe\"</Command>\n"
1220 " </Exec>\n"
1221 " </Actions>\n"
1222 "</TASK>\n";
1223 static const char xml4[] =
1224 "<Task xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
1225 " <RegistrationInfo/>\n"
1226 " <Settings/>\n"
1227 " <Actions>\n"
1228 " <Exec>\n"
1229 " <Command>\"task1.exe\"</Command>\n"
1230 " </Exec>\n"
1231 " </Actions>\n"
1232 "</Task>\n";
1233 static const char xml5[] =
1234 "<Task xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
1235 " <RegistrationInfo/>\n"
1236 " <Settings/>\n"
1237 " <Actions/>\n"
1238 "</Task>\n";
1239 static const char xml6[] =
1240 "<Task xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
1241 " <RegistrationInfo/>\n"
1242 " <Actions>\n"
1243 " <Exec>\n"
1244 " <Command>\"task1.exe\"</Command>\n"
1245 " </Exec>\n"
1246 " </Actions>\n"
1247 " <Settings>\n"
1248 "</Task>\n";
1249 static const char xml7[] =
1250 "<Task xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
1251 " <RegistrationInfo/>\n"
1252 " <Settings>\n"
1253 " <Enabled>FALSE</Enabled>\n"
1254 " </Settings>\n"
1255 " <Actions>\n"
1256 " <Exec>\n"
1257 " <Command>\"task1.exe\"</Command>\n"
1258 " </Exec>\n"
1259 " </Actions>\n"
1260 "</Task>\n";
1261 static WCHAR Task1[] = { '"','T','a','s','k','1','"',0 };
1262 static struct settings def_settings = { { 0 }, { 'P','T','7','2','H',0 }, { 0 },
1263 0, 7, TASK_INSTANCES_IGNORE_NEW, TASK_COMPATIBILITY_V2, VARIANT_TRUE, VARIANT_TRUE,
1264 VARIANT_TRUE, VARIANT_TRUE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_TRUE, VARIANT_FALSE,
1265 VARIANT_FALSE, VARIANT_FALSE };
1266 static struct settings new_settings = { { 'P','1','Y',0 }, { 'P','T','1','0','M',0 }, { 0 },
1267 100, 1, TASK_INSTANCES_STOP_EXISTING, TASK_COMPATIBILITY_V1, VARIANT_FALSE, VARIANT_FALSE,
1268 VARIANT_FALSE, VARIANT_FALSE, VARIANT_TRUE, VARIANT_TRUE, VARIANT_FALSE, VARIANT_TRUE,
1269 VARIANT_TRUE, VARIANT_TRUE };
1270 HRESULT hr;
1271 ITaskService *service;
1272 ITaskDefinition *taskdef;
1273 IRegistrationInfo *reginfo;
1274 BSTR xml, bstr;
1275 VARIANT var;
1276 WCHAR xmlW[sizeof(xml1)];
1277
1278 hr = CoCreateInstance(&CLSID_TaskScheduler, NULL, CLSCTX_INPROC_SERVER, &IID_ITaskService, (void **)&service);
1279 if (hr != S_OK)
1280 {
1281 win_skip("CoCreateInstance(CLSID_TaskScheduler) error %#x\n", hr);
1282 return;
1283 }
1284
1285 hr = ITaskService_NewTask(service, 0, &taskdef);
1286 ok(hr == S_OK, "NewTask error %#x\n", hr);
1287
1288 test_settings_v1(taskdef, &def_settings, &def_settings);
1289 change_settings(taskdef, &new_settings);
1290
1291 /* Action is mandatory for v1 compatibility */
1292 create_action(taskdef);
1293
1294 hr = ITaskDefinition_get_XmlText(taskdef, &xml);
1295 ok(hr == S_OK, "get_XmlText error %#x\n", hr);
1296
1297 ITaskDefinition_Release(taskdef);
1298
1299 hr = ITaskService_NewTask(service, 0, &taskdef);
1300 ok(hr == S_OK, "NewTask error %#x\n", hr);
1301
1302 hr = ITaskDefinition_put_XmlText(taskdef, xml);
1303 ok(hr == S_OK, "put_XmlText error %#x\n", hr);
1304 SysFreeString(xml);
1305
1306 /* FIXME: uncomment once changing settings is implemented
1307 test_settings_v1(taskdef, &new_settings, &def_settings);
1308 */
1309
1310 hr = ITaskDefinition_put_XmlText(taskdef, NULL);
1311 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
1312
1313 MultiByteToWideChar(CP_ACP, 0, xml1, -1, xmlW, sizeof(xmlW)/sizeof(xmlW[0]));
1314 hr = ITaskDefinition_put_XmlText(taskdef, xmlW);
1315 ok(hr == S_OK, "put_XmlText error %#x\n", hr);
1316
1317 MultiByteToWideChar(CP_ACP, 0, xml2, -1, xmlW, sizeof(xmlW)/sizeof(xmlW[0]));
1318 hr = ITaskDefinition_put_XmlText(taskdef, xmlW);
1319 ok(hr == SCHED_E_NAMESPACE, "expected SCHED_E_NAMESPACE, got %#x\n", hr);
1320
1321 MultiByteToWideChar(CP_ACP, 0, xml3, -1, xmlW, sizeof(xmlW)/sizeof(xmlW[0]));
1322 hr = ITaskDefinition_put_XmlText(taskdef, xmlW);
1323 todo_wine
1324 ok(hr == SCHED_E_UNEXPECTEDNODE, "expected SCHED_E_UNEXPECTEDNODE, got %#x\n", hr);
1325
1326 MultiByteToWideChar(CP_ACP, 0, xml4, -1, xmlW, sizeof(xmlW)/sizeof(xmlW[0]));
1327 hr = ITaskDefinition_put_XmlText(taskdef, xmlW);
1328 ok(hr == S_OK, "put_XmlText error %#x\n", hr);
1329
1330 MultiByteToWideChar(CP_ACP, 0, xml5, -1, xmlW, sizeof(xmlW)/sizeof(xmlW[0]));
1331 hr = ITaskDefinition_put_XmlText(taskdef, xmlW);
1332 todo_wine
1333 ok(hr == SCHED_E_MISSINGNODE, "expected SCHED_E_MISSINGNODE, got %#x\n", hr);
1334
1335 MultiByteToWideChar(CP_ACP, 0, xml6, -1, xmlW, sizeof(xmlW)/sizeof(xmlW[0]));
1336 hr = ITaskDefinition_put_XmlText(taskdef, xmlW);
1337 ok(hr == SCHED_E_MALFORMEDXML, "expected SCHED_E_MALFORMEDXML, got %#x\n", hr);
1338
1339 MultiByteToWideChar(CP_ACP, 0, xml7, -1, xmlW, sizeof(xmlW)/sizeof(xmlW[0]));
1340 hr = ITaskDefinition_put_XmlText(taskdef, xmlW);
1341 ok(hr == SCHED_E_INVALIDVALUE, "expected SCHED_E_INVALIDVALUE, got %#x\n", hr);
1342
1343 xmlW[0] = 0;
1344 hr = ITaskDefinition_put_XmlText(taskdef, xmlW);
1345 ok(hr == SCHED_E_MALFORMEDXML, "expected SCHED_E_MALFORMEDXML, got %#x\n", hr);
1346
1347 /* test registration info */
1348 MultiByteToWideChar(CP_ACP, 0, xml1, -1, xmlW, sizeof(xmlW)/sizeof(xmlW[0]));
1349 hr = ITaskDefinition_put_XmlText(taskdef, xmlW);
1350 ok(hr == S_OK, "put_XmlText error %#x\n", hr);
1351 hr = ITaskDefinition_get_RegistrationInfo(taskdef, &reginfo);
1352 ok(hr == S_OK, "get_RegistrationInfo error %#x\n", hr);
1353
1354 hr = IRegistrationInfo_get_Description(reginfo, &bstr);
1355 ok(hr == S_OK, "get_Description error %#x\n", hr);
1356 ok(!lstrcmpW(bstr, Task1), "expected Task1, got %s\n", wine_dbgstr_w(bstr));
1357 SysFreeString(bstr);
1358 hr = IRegistrationInfo_get_Author(reginfo, &bstr);
1359 ok(hr == S_OK, "get_Author error %#x\n", hr);
1360 ok(!bstr, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1361 hr = IRegistrationInfo_get_Version(reginfo, &bstr);
1362 ok(hr == S_OK, "get_Version error %#x\n", hr);
1363 ok(!bstr, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1364 hr = IRegistrationInfo_get_Date(reginfo, &bstr);
1365 ok(hr == S_OK, "get_Date error %#x\n", hr);
1366 ok(!bstr, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1367 hr = IRegistrationInfo_get_Documentation(reginfo, &bstr);
1368 ok(hr == S_OK, "get_Documentation error %#x\n", hr);
1369 ok(!bstr, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1370 hr = IRegistrationInfo_get_URI(reginfo, &bstr);
1371 ok(hr == S_OK, "get_URI error %#x\n", hr);
1372 ok(!bstr, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1373 hr = IRegistrationInfo_get_Source(reginfo, &bstr);
1374 ok(hr == S_OK, "get_Source error %#x\n", hr);
1375 ok(!bstr, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1376 V_VT(&var) = VT_BSTR;
1377 V_BSTR(&var) = NULL;
1378 hr = IRegistrationInfo_get_SecurityDescriptor(reginfo, &var);
1379 todo_wine
1380 ok(hr == S_OK, "get_SecurityDescriptor error %#x\n", hr);
1381 if (hr == S_OK)
1382 ok(V_VT(&var) == VT_EMPTY, "expected VT_EMPTY, got %u\n", V_VT(&var));
1383
1384 IRegistrationInfo_Release(reginfo);
1385
1386 MultiByteToWideChar(CP_ACP, 0, xml4, -1, xmlW, sizeof(xmlW)/sizeof(xmlW[0]));
1387 hr = ITaskDefinition_put_XmlText(taskdef, xmlW);
1388 ok(hr == S_OK, "put_XmlText error %#x\n", hr);
1389 hr = ITaskDefinition_get_RegistrationInfo(taskdef, &reginfo);
1390 ok(hr == S_OK, "get_RegistrationInfo error %#x\n", hr);
1391
1392 hr = IRegistrationInfo_get_Description(reginfo, &bstr);
1393 ok(hr == S_OK, "get_Description error %#x\n", hr);
1394 if (hr == S_OK)
1395 ok(!bstr, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1396
1397 IRegistrationInfo_Release(reginfo);
1398 ITaskDefinition_Release(taskdef);
1399 ITaskService_Release(service);
1400 }
1401
1402 START_TEST(scheduler)
1403 {
1404 OleInitialize(NULL);
1405
1406 test_Connect();
1407 test_GetFolder();
1408 test_FolderCollection();
1409 test_GetTask();
1410 test_TaskDefinition();
1411
1412 OleUninitialize();
1413 }
Windows API implementation