dlls/mstask/tests/task_scheduler.c

   1 /*
   2  * Test suite for TaskScheduler interface
   3  *
   4  * Copyright (C) 2008 Google (Roy Shea)
   5  * Copyright (C) 2018 Dmitry Timoshkov
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define COBJMACROS
  23
  24 #include "corerror.h"
  25
  26 #include "initguid.h"
  27 #include "mstask.h"
  28 #include "wine/test.h"
  29
  30 static ITaskScheduler *test_task_scheduler;
  31
  32 static const WCHAR does_not_existW[] = {'\\','\\','d','o','e','s','_','n','o','t','_','e','x','i','s','t',0};
  33
  34
  35 HRESULT taskscheduler_delete(ITaskScheduler *scheduler, const WCHAR *name)
  36 {
  37     HRESULT hr;
  38     int i = 0;
  39
  40     while (1)
  41     {
  42         hr = ITaskScheduler_Delete(scheduler, name);
  43         if (hr != HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION)) break;
  44         if (++i == 5) break;
  45
  46         /* The task scheduler locked the file to load the task (see
  47          * ITaskScheduler_Activate()). It should be done soon.
  48          */
  49         trace("Got a sharing violation deleting %s, retrying...\n", wine_dbgstr_w(name));
  50         Sleep(100);
  51     }
  52     return hr;
  53 }
  54
  55 static void test_NewWorkItem(void)
  56 {
  57     HRESULT hres;
  58     ITask *task;
  59     const WCHAR task_name[] = {'T', 'e', 's', 't', 'i', 'n', 'g', 0};
  60     GUID GUID_BAD;
  61
  62     /* Initialize a GUID that will not be a recognized CLSID or a IID */
  63     CoCreateGuid(&GUID_BAD);
  64
  65     /* Create TaskScheduler */
  66     hres = CoCreateInstance(&CLSID_CTaskScheduler, NULL, CLSCTX_INPROC_SERVER,
  67             &IID_ITaskScheduler, (void **) &test_task_scheduler);
  68     ok(hres == S_OK, "CTaskScheduler CoCreateInstance failed: %08lx\n", hres);
  69     if (hres != S_OK)
  70     {
  71         skip("Failed to create task scheduler.  Skipping tests.\n");
  72         return;
  73     }
  74
  75     /* Test basic task creation */
  76     hres = ITaskScheduler_NewWorkItem(test_task_scheduler, task_name,
  77             &CLSID_CTask, &IID_ITask, (IUnknown**)&task);
  78     ok(hres == S_OK, "NewNetworkItem failed: %08lx\n", hres);
  79     if (hres == S_OK)
  80         ITask_Release(task);
  81
  82     /* Task creation attempt using invalid work item class ID */
  83     hres = ITaskScheduler_NewWorkItem(test_task_scheduler, task_name,
  84             &GUID_BAD, &IID_ITask, (IUnknown**)&task);
  85     ok(hres == CLASS_E_CLASSNOTAVAILABLE,
  86             "Expected CLASS_E_CLASSNOTAVAILABLE: %08lx\n", hres);
  87
  88     /* Task creation attempt using invalid interface ID */
  89     hres = ITaskScheduler_NewWorkItem(test_task_scheduler, task_name,
  90             &CLSID_CTask, &GUID_BAD, (IUnknown**)&task);
  91     ok(hres == E_NOINTERFACE, "Expected E_NOINTERFACE: %08lx\n", hres);
  92
  93     /* Task creation attempt using invalid work item class and interface ID */
  94     hres = ITaskScheduler_NewWorkItem(test_task_scheduler, task_name,
  95             &GUID_BAD, &GUID_BAD, (IUnknown**)&task);
  96     ok(hres == CLASS_E_CLASSNOTAVAILABLE,
  97             "Expected CLASS_E_CLASSNOTAVAILABLE: %08lx\n", hres);
  98
  99     ITaskScheduler_Release(test_task_scheduler);
 100     return;
 101 }
 102
 103 static void test_Activate(void)
 104 {
 105     HRESULT hres;
 106     ITask *task = NULL;
 107     const WCHAR not_task_name[] =
 108             {'N', 'o', 'S', 'u', 'c', 'h', 'T', 'a', 's', 'k', 0};
 109
 110     /* Create TaskScheduler */
 111     hres = CoCreateInstance(&CLSID_CTaskScheduler, NULL, CLSCTX_INPROC_SERVER,
 112             &IID_ITaskScheduler, (void **) &test_task_scheduler);
 113     ok(hres == S_OK, "CTaskScheduler CoCreateInstance failed: %08lx\n", hres);
 114     if (hres != S_OK)
 115     {
 116         skip("Failed to create task scheduler.  Skipping tests.\n");
 117         return;
 118     }
 119
 120     /* Attempt to activate a nonexistent task */
 121     hres = ITaskScheduler_Activate(test_task_scheduler, not_task_name,
 122             &IID_ITask, (IUnknown**)&task);
 123     ok(hres == COR_E_FILENOTFOUND, "Expected COR_E_FILENOTFOUND: %08lx\n", hres);
 124
 125     ITaskScheduler_Release(test_task_scheduler);
 126     return;
 127 }
 128
 129 static void test_GetTargetComputer(void)
 130 {
 131     HRESULT hres;
 132     WCHAR *oldname;
 133
 134     /* Create TaskScheduler */
 135     hres = CoCreateInstance(&CLSID_CTaskScheduler, NULL, CLSCTX_INPROC_SERVER,
 136             &IID_ITaskScheduler, (void **) &test_task_scheduler);
 137     ok(hres == S_OK, "CTaskScheduler CoCreateInstance failed: %08lx\n", hres);
 138     if (hres != S_OK)
 139     {
 140         skip("Failed to create task scheduler.\n");
 141         return;
 142     }
 143
 144     if (0)
 145     {
 146         /* This crashes on w2k */
 147         hres = ITaskScheduler_GetTargetComputer(test_task_scheduler, NULL);
 148         ok(hres == E_INVALIDARG, "got 0x%lx (expected E_INVALIDARG)\n", hres);
 149     }
 150
 151     hres = ITaskScheduler_GetTargetComputer(test_task_scheduler, &oldname);
 152     ok((hres == S_OK) && oldname && oldname[0] == '\\' && oldname[1] == '\\' && oldname[2],
 153         "got 0x%lx and %s (expected S_OK and an unc name)\n", hres, wine_dbgstr_w(oldname));
 154
 155     CoTaskMemFree(oldname);
 156
 157     ITaskScheduler_Release(test_task_scheduler);
 158     return;
 159 }
 160
 161 static void test_SetTargetComputer(void)
 162 {
 163     WCHAR buffer[MAX_COMPUTERNAME_LENGTH + 3];  /* extra space for two '\' and a zero */
 164     DWORD len = MAX_COMPUTERNAME_LENGTH + 1;    /* extra space for a zero */
 165     WCHAR *oldname = NULL;
 166     WCHAR *name = NULL;
 167     HRESULT hres;
 168
 169
 170     buffer[0] = '\\';
 171     buffer[1] = '\\';
 172     if (!GetComputerNameW(buffer + 2, &len))
 173         return;
 174
 175     /* Create TaskScheduler */
 176     hres = CoCreateInstance(&CLSID_CTaskScheduler, NULL, CLSCTX_INPROC_SERVER,
 177             &IID_ITaskScheduler, (void **) &test_task_scheduler);
 178     ok(hres == S_OK, "CTaskScheduler CoCreateInstance failed: %08lx\n", hres);
 179     if (hres != S_OK)
 180     {
 181         skip("Failed to create task scheduler.  Skipping tests.\n");
 182         return;
 183     }
 184
 185     hres = ITaskScheduler_GetTargetComputer(test_task_scheduler, &oldname);
 186     ok(hres == S_OK, "got 0x%lx and %s (expected S_OK)\n", hres, wine_dbgstr_w(oldname));
 187
 188     /* NULL is an alias for the local computer */
 189     hres = ITaskScheduler_SetTargetComputer(test_task_scheduler, NULL);
 190     ok(hres == S_OK, "got 0x%lx (expected S_OK)\n", hres);
 191     hres = ITaskScheduler_GetTargetComputer(test_task_scheduler, &name);
 192     ok((hres == S_OK && !lstrcmpiW(name, buffer)),
 193         "got 0x%lx with %s (expected S_OK and %s)\n",
 194         hres, wine_dbgstr_w(name), wine_dbgstr_w(buffer));
 195     CoTaskMemFree(name);
 196
 197     /* The name must be valid */
 198     hres = ITaskScheduler_SetTargetComputer(test_task_scheduler, does_not_existW);
 199     ok(hres == HRESULT_FROM_WIN32(ERROR_BAD_NETPATH), "got 0x%lx (expected 0x80070035)\n", hres);
 200     /* the name of the target computer is unchanged */
 201     hres = ITaskScheduler_GetTargetComputer(test_task_scheduler, &name);
 202     ok((hres == S_OK && !lstrcmpiW(name, buffer)),
 203         "got 0x%lx with %s (expected S_OK and %s)\n",
 204         hres, wine_dbgstr_w(name), wine_dbgstr_w(buffer));
 205     CoTaskMemFree(name);
 206
 207     /* the two backslashes are optional */
 208     hres = ITaskScheduler_SetTargetComputer(test_task_scheduler, oldname + 2);
 209     if (hres == E_ACCESSDENIED)
 210     {
 211         skip("SetTargetComputer failed with E_ACCESSDENIED (needs admin rights)\n");
 212         goto done;
 213     }
 214     ok(hres == S_OK, "got 0x%lx (expected S_OK)\n", hres);
 215
 216     /* the case is ignored */
 217     CharUpperW(buffer);
 218     hres = ITaskScheduler_SetTargetComputer(test_task_scheduler, buffer);
 219     ok(hres == S_OK, "got 0x%lx (expected S_OK)\n", hres);
 220     CharLowerW(buffer);
 221     hres = ITaskScheduler_SetTargetComputer(test_task_scheduler, buffer);
 222     ok(hres == S_OK, "got 0x%lx (expected S_OK)\n", hres);
 223
 224     /* cleanup */
 225     hres = ITaskScheduler_SetTargetComputer(test_task_scheduler, oldname);
 226     ok(hres == S_OK, "got 0x%lx (expected S_OK)\n", hres);
 227
 228 done:
 229     CoTaskMemFree(oldname);
 230     ITaskScheduler_Release(test_task_scheduler);
 231     return;
 232 }
 233
 234 static void test_Enum(void)
 235 {
 236     static const WCHAR Task1[] = { 'w','i','n','e','t','a','s','k','1',0 };
 237     ITaskScheduler *scheduler;
 238     ITask *task;
 239     IEnumWorkItems *tasks;
 240     WCHAR **names;
 241     ULONG fetched;
 242     HRESULT hr;
 243
 244     hr = CoCreateInstance(&CLSID_CTaskScheduler, NULL, CLSCTX_INPROC_SERVER,
 245             &IID_ITaskScheduler, (void **)&scheduler);
 246     ok(hr == S_OK, "got %#lx\n", hr);
 247
 248     /* cleanup after previous runs */
 249     taskscheduler_delete(scheduler, Task1);
 250
 251     hr = ITaskScheduler_NewWorkItem(scheduler, Task1, &CLSID_CTask, &IID_ITask, (IUnknown **)&task);
 252     ok(hr == S_OK, "got %#lx\n", hr);
 253     hr = ITaskScheduler_AddWorkItem(scheduler, Task1, (IScheduledWorkItem *)task);
 254     ok(hr == S_OK, "got %#lx\n", hr);
 255
 256     ITask_Release(task);
 257
 258     hr = ITaskScheduler_Enum(scheduler, NULL);
 259     ok(hr == E_INVALIDARG, "got %#lx\n", hr);
 260
 261     hr = ITaskScheduler_Enum(scheduler, &tasks);
 262     ok(hr == S_OK, "got %#lx\n", hr);
 263
 264     names = (void *)0xdeadbeef;
 265     fetched = 0xdeadbeef;
 266     hr = IEnumWorkItems_Next(tasks, 0, &names, &fetched);
 267     ok(hr == E_INVALIDARG, "got %#lx\n", hr);
 268     ok(names == (void *)0xdeadbeef, "got %p\n", names);
 269     ok(fetched == 0xdeadbeef, "got %#lx\n", fetched);
 270
 271     hr = IEnumWorkItems_Next(tasks, 1, NULL, NULL);
 272     ok(hr == E_INVALIDARG, "got %#lx\n", hr);
 273
 274     names = NULL;
 275     hr = IEnumWorkItems_Next(tasks, 1, &names, NULL);
 276     ok(hr == S_OK, "got %#lx\n", hr);
 277     ok(names != NULL, "got NULL\n");
 278     ok(names[0] != NULL, "got NULL\n");
 279     CoTaskMemFree(names[0]);
 280     CoTaskMemFree(names);
 281
 282     names = (void *)0xdeadbeef;
 283     hr = IEnumWorkItems_Next(tasks, 2, &names, NULL);
 284     ok(hr == E_INVALIDARG, "got %#lx\n", hr);
 285     ok(names == (void *)0xdeadbeef, "got %p\n", names);
 286
 287     hr = IEnumWorkItems_Reset(tasks);
 288     ok(hr == S_OK, "got %#lx\n", hr);
 289
 290     names = NULL;
 291     fetched = 0xdeadbeef;
 292     hr = IEnumWorkItems_Next(tasks, 1, &names, &fetched);
 293     ok(hr == S_OK, "got %#lx\n", hr);
 294     ok(names != NULL, "got NULL\n");
 295     ok(names[0] != NULL, "got NULL\n");
 296     ok(fetched == 1, "got %lu\n", fetched);
 297     CoTaskMemFree(names[0]);
 298     CoTaskMemFree(names);
 299
 300     while (IEnumWorkItems_Skip(tasks, 1) == S_OK)
 301         /* do nothing*/;
 302
 303     hr = IEnumWorkItems_Skip(tasks, 1);
 304     ok(hr == S_FALSE, "got %#lx\n", hr);
 305
 306     names = (void *)0xdeadbeef;
 307     fetched = 0xdeadbeef;
 308     hr = IEnumWorkItems_Next(tasks, 1, &names, &fetched);
 309     ok(hr == S_FALSE, "got %#lx\n", hr);
 310     ok(names == NULL, "got %p\n", names);
 311     ok(fetched == 0, "got %lu\n", fetched);
 312
 313     IEnumWorkItems_Release(tasks);
 314
 315     hr = taskscheduler_delete(scheduler, Task1);
 316     ok(hr == S_OK, "got %#lx\n", hr);
 317
 318     ITaskScheduler_Release(scheduler);
 319 }
 320
 321 static BOOL file_exists(const WCHAR *name)
 322 {
 323     return GetFileAttributesW(name) != INVALID_FILE_ATTRIBUTES;
 324 }
 325
 326 static void test_save_task_curfile(ITask *task)
 327 {
 328     HRESULT hr;
 329     IPersistFile *pfile;
 330     WCHAR *curfile;
 331
 332     hr = ITask_QueryInterface(task, &IID_IPersistFile, (void **)&pfile);
 333     ok(hr == S_OK, "QueryInterface error %#lx\n", hr);
 334
 335     curfile = NULL;
 336     hr = IPersistFile_GetCurFile(pfile, &curfile);
 337     ok(hr == S_OK, "GetCurFile error %#lx\n", hr);
 338     ok(curfile && curfile[0], "curfile should not be NULL\n");
 339
 340     ok(file_exists(curfile), "curfile should exist\n");
 341
 342     hr = IPersistFile_Save(pfile, curfile, FALSE);
 343     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), "wrong error %#lx\n", hr);
 344
 345     hr = IPersistFile_Save(pfile, curfile, TRUE);
 346     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), "wrong error %#lx\n", hr);
 347
 348     hr = IPersistFile_Save(pfile, NULL, FALSE);
 349     ok(hr == S_OK, "Save error %#lx\n", hr);
 350
 351     hr = IPersistFile_Save(pfile, NULL, TRUE);
 352     ok(hr == S_OK, "Save error %#lx\n", hr);
 353     CoTaskMemFree(curfile);
 354
 355     curfile = NULL;
 356     hr = IPersistFile_GetCurFile(pfile, &curfile);
 357     ok(hr == S_OK, "GetCurFile error %#lx\n", hr);
 358     ok(curfile && curfile[0] , "curfile should not be NULL\n");
 359     CoTaskMemFree(curfile);
 360
 361     IPersistFile_Release(pfile);
 362 }
 363
 364 static WCHAR *get_task_curfile(ITask *task, BOOL should_exist, BOOL is_dirty, int line)
 365 {
 366     HRESULT hr;
 367     IPersistFile *pfile;
 368     WCHAR *curfile;
 369     CLSID clsid;
 370
 371     hr = ITask_QueryInterface(task, &IID_IPersistFile, (void **)&pfile);
 372     ok_(__FILE__, line)(hr == S_OK, "QueryInterface error %#lx\n", hr);
 373
 374     hr = IPersistFile_IsDirty(pfile);
 375     ok_(__FILE__, line)(hr == is_dirty ? S_OK : S_FALSE, "got %#lx\n", hr);
 376
 377     curfile = NULL;
 378     hr = IPersistFile_GetCurFile(pfile, &curfile);
 379     ok_(__FILE__, line)(hr == S_OK, "GetCurFile error %#lx\n", hr);
 380     ok_(__FILE__, line)(curfile && curfile[0] , "curfile should not be NULL\n");
 381
 382     hr = IPersistFile_Load(pfile, curfile, STGM_READ);
 383     if (should_exist)
 384         ok_(__FILE__, line)(hr == S_OK, "Load error %#lx\n", hr);
 385     else
 386         ok_(__FILE__, line)(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "wrong error %#lx\n", hr);
 387
 388     if (0) /* crashes under Windows */
 389         hr = IPersistFile_GetClassID(pfile, NULL);
 390
 391     hr = IPersistFile_GetClassID(pfile, &clsid);
 392     ok_(__FILE__, line)(hr == S_OK, "GetClassID error %#lx\n", hr);
 393     ok_(__FILE__, line)(IsEqualCLSID(&clsid, &CLSID_CTask), "got %s\n", wine_dbgstr_guid(&clsid));
 394
 395     IPersistFile_Release(pfile);
 396
 397     return curfile;
 398 }
 399
 400 static void test_task_storage(void)
 401 {
 402     static const WCHAR Task1[] = { 'w','i','n','e','t','a','s','k','1',0 };
 403     static const WCHAR Task2[] = { 'w','i','n','e','t','a','s','k','2',0 };
 404     static const WCHAR Task3[] = { 'w','i','n','e','t','a','s','k','3',0 };
 405     static const WCHAR Task1_ext[] = { 'w','i','n','e','t','a','s','k','.','e','x','t',0 };
 406     static const WCHAR Task1_job[] = { '\\','T','a','s','k','s','\\','w','i','n','e','t','a','s','k','1','.','j','o','b',0 };
 407     static const WCHAR Task2_job[] = { '\\','T','a','s','k','s','\\','w','i','n','e','t','a','s','k','2','.','j','o','b',0 };
 408     static const WCHAR Task3_job[] = { '\\','T','a','s','k','s','\\','w','i','n','e','t','a','s','k','3','.','j','o','b',0 };
 409     WCHAR task1_full_name[MAX_PATH], task2_full_name[MAX_PATH], task3_full_name[MAX_PATH];
 410     HRESULT hr;
 411     ITaskScheduler *scheduler;
 412     ITask *task, *task2;
 413     WCHAR *curfile, *curfile2;
 414
 415     GetWindowsDirectoryW(task1_full_name, MAX_PATH);
 416     lstrcatW(task1_full_name, Task1_job);
 417     GetWindowsDirectoryW(task2_full_name, MAX_PATH);
 418     lstrcatW(task2_full_name, Task2_job);
 419     GetWindowsDirectoryW(task3_full_name, MAX_PATH);
 420     lstrcatW(task3_full_name, Task3_job);
 421
 422     /* cleanup after previous runs */
 423     DeleteFileW(task1_full_name);
 424     DeleteFileW(task2_full_name);
 425     DeleteFileW(task3_full_name);
 426
 427     hr = CoCreateInstance(&CLSID_CTaskScheduler, NULL, CLSCTX_INPROC_SERVER, &IID_ITaskScheduler, (void **)&scheduler);
 428     if (hr != S_OK)
 429     {
 430         win_skip("CoCreateInstance(CLSID_CTaskScheduler) error %#lx\n", hr);
 431         return;
 432     }
 433
 434     hr = ITaskScheduler_Delete(scheduler, Task1_ext);
 435     ok(hr == E_INVALIDARG, "wrong error %#lx\n", hr);
 436
 437     hr = ITaskScheduler_Delete(scheduler, Task1);
 438     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "wrong error %#lx\n", hr);
 439
 440     hr = ITaskScheduler_NewWorkItem(scheduler, Task1_ext, &CLSID_CTask, &IID_ITask, (IUnknown **)&task);
 441     ok(hr == E_INVALIDARG, "wrong error %#lx\n", hr);
 442
 443     hr = ITaskScheduler_NewWorkItem(scheduler, Task1, &CLSID_CTask, &IID_ITask, (IUnknown **)&task);
 444     ok(hr == S_OK, "NewWorkItem error %#lx\n", hr);
 445
 446     curfile = get_task_curfile(task, FALSE, FALSE, __LINE__);
 447     ok(!file_exists(curfile), "curfile should not exist\n");
 448     ok(!lstrcmpW(curfile, task1_full_name), "name is wrong %s\n", wine_dbgstr_w(curfile));
 449
 450     hr = ITask_SetComment(task, Task1);
 451     ok(hr == S_OK, "got %#lx\n", hr);
 452
 453     curfile2 = get_task_curfile(task, FALSE, TRUE, __LINE__);
 454     ok(!file_exists(curfile2), "curfile should not exist\n");
 455     ok(!lstrcmpW(curfile2, task1_full_name), "name is wrong %s\n", wine_dbgstr_w(curfile2));
 456     CoTaskMemFree(curfile2);
 457
 458     hr = ITaskScheduler_NewWorkItem(scheduler, Task1, &CLSID_CTask, &IID_ITask, (IUnknown **)&task2);
 459     ok(hr == S_OK, "NewWorkItem error %#lx\n", hr);
 460     ok(task2 != task, "tasks should not be equal\n");
 461
 462     curfile2 = get_task_curfile(task2, FALSE, FALSE, __LINE__);
 463     ok(!file_exists(curfile2), "curfile2 should not exist\n");
 464     ok(!lstrcmpW(curfile2, task1_full_name), "name is wrong %s\n", wine_dbgstr_w(curfile2));
 465
 466     CoTaskMemFree(curfile);
 467     CoTaskMemFree(curfile2);
 468     ITask_Release(task2);
 469
 470     task2 = (ITask *)0xdeadbeef;
 471     hr = ITaskScheduler_Activate(scheduler, Task1, &IID_ITask, (IUnknown **)&task2);
 472     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "wrong error %#lx\n", hr);
 473     ok(task2 == (ITask *)0xdeadbeef, "task should not be set to NULL\n");
 474
 475     hr = ITaskScheduler_AddWorkItem(scheduler, Task2, (IScheduledWorkItem *)task);
 476     ok(hr == S_OK, "AddWorkItem error %#lx\n", hr);
 477     curfile = get_task_curfile(task, TRUE, FALSE, __LINE__);
 478     ok(file_exists(curfile), "curfile should exist\n");
 479     ok(!lstrcmpW(curfile, task2_full_name), "name is wrong %s\n", wine_dbgstr_w(curfile));
 480     CoTaskMemFree(curfile);
 481
 482     hr = ITaskScheduler_AddWorkItem(scheduler, Task3, (IScheduledWorkItem *)task);
 483     ok(hr == S_OK, "AddWorkItem error %#lx\n", hr);
 484     curfile = get_task_curfile(task, TRUE, FALSE, __LINE__);
 485     ok(file_exists(curfile), "curfile should exist\n");
 486     ok(!lstrcmpW(curfile, task3_full_name), "name is wrong %s\n", wine_dbgstr_w(curfile));
 487     CoTaskMemFree(curfile);
 488
 489     hr = ITaskScheduler_AddWorkItem(scheduler, Task1, (IScheduledWorkItem *)task);
 490     ok(hr == S_OK, "AddWorkItem error %#lx\n", hr);
 491     curfile = get_task_curfile(task, TRUE, FALSE, __LINE__);
 492     ok(file_exists(curfile), "curfile should exist\n");
 493     ok(!lstrcmpW(curfile, task1_full_name), "name is wrong %s\n", wine_dbgstr_w(curfile));
 494     CoTaskMemFree(curfile);
 495
 496     hr = ITaskScheduler_AddWorkItem(scheduler, Task1, (IScheduledWorkItem *)task);
 497     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), "wrong error %#lx\n", hr);
 498
 499     curfile = get_task_curfile(task, TRUE, FALSE, __LINE__);
 500     ok(file_exists(curfile), "curfile should exist\n");
 501
 502     CoTaskMemFree(curfile);
 503     ITask_Release(task);
 504
 505     task = NULL;
 506     hr = ITaskScheduler_Activate(scheduler, Task1, &IID_ITask, (IUnknown **)&task);
 507     ok(hr == S_OK, "Activate error %#lx\n", hr);
 508     ok(task != NULL, "task should not be set to NULL\n");
 509
 510     curfile = get_task_curfile(task, TRUE, FALSE, __LINE__);
 511     ok(file_exists(curfile), "curfile2 should exist\n");
 512     ok(!lstrcmpW(curfile, task1_full_name), "name is wrong %s\n", wine_dbgstr_w(curfile));
 513
 514     CoTaskMemFree(curfile);
 515
 516     test_save_task_curfile(task);
 517
 518     hr = taskscheduler_delete(scheduler, Task1);
 519     ok(hr == S_OK, "got %#lx\n", hr);
 520     hr = taskscheduler_delete(scheduler, Task2);
 521     ok(hr == S_OK, "got %#lx\n", hr);
 522     hr = taskscheduler_delete(scheduler, Task3);
 523     ok(hr == S_OK, "got %#lx\n", hr);
 524
 525     ITask_Release(task);
 526     ITaskScheduler_Release(scheduler);
 527 }
 528
 529 START_TEST(task_scheduler)
 530 {
 531     CoInitialize(NULL);
 532
 533     test_task_storage();
 534     test_NewWorkItem();
 535     test_Activate();
 536     test_GetTargetComputer();
 537     test_SetTargetComputer();
 538     test_Enum();
 539     CoUninitialize();
 540 }