dlls/mstask/tests/task.c

   1 /*
   2  * Test suite for Task interface
   3  *
   4  * Copyright (C) 2008 Google (Roy Shea)
   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 #define COBJMACROS
  22
  23 #include "corerror.h"
  24 #include "mstask.h"
  25 #include "wine/test.h"
  26
  27 static ITaskScheduler *test_task_scheduler;
  28 static ITask *test_task;
  29 static const WCHAR empty[] = {0};
  30
  31 static BOOL setup_task(void)
  32 {
  33     HRESULT hres;
  34     const WCHAR task_name[] = {'T','e','s','t','i','n','g', 0};
  35
  36     hres = CoCreateInstance(&CLSID_CTaskScheduler, NULL, CLSCTX_INPROC_SERVER,
  37             &IID_ITaskScheduler, (void **) &test_task_scheduler);
  38     if(hres != S_OK)
  39         return FALSE;
  40     hres = ITaskScheduler_NewWorkItem(test_task_scheduler, task_name, &CLSID_CTask,
  41             &IID_ITask, (IUnknown**)&test_task);
  42     if(hres != S_OK)
  43     {
  44         ITaskScheduler_Release(test_task_scheduler);
  45         return FALSE;
  46     }
  47     return TRUE;
  48 }
  49
  50 static void cleanup_task(void)
  51 {
  52     ITask_Release(test_task);
  53     ITaskScheduler_Release(test_task_scheduler);
  54 }
  55
  56 static LPCWSTR path_resolve_name(LPCWSTR base_name)
  57 {
  58     static WCHAR buffer[MAX_PATH];
  59     int len;
  60
  61     len = SearchPathW(NULL, base_name, NULL, 0, NULL, NULL);
  62     if (len == 0)
  63         return base_name;
  64     else if (len < MAX_PATH)
  65     {
  66         SearchPathW(NULL, base_name, NULL, MAX_PATH, buffer, NULL);
  67         return buffer;
  68     }
  69     return NULL;
  70 }
  71
  72 static void test_SetApplicationName_GetApplicationName(void)
  73 {
  74     BOOL setup;
  75     HRESULT hres;
  76     LPWSTR stored_name;
  77     LPCWSTR full_name;
  78     const WCHAR non_application_name[] = {'N','o','S','u','c','h',
  79             'A','p','p','l','i','c','a','t','i','o','n', 0};
  80     const WCHAR notepad_exe[] = {
  81             'n','o','t','e','p','a','d','.','e','x','e', 0};
  82     const WCHAR notepad[] = {'n','o','t','e','p','a','d', 0};
  83
  84     setup = setup_task();
  85     ok(setup, "Failed to setup test_task\n");
  86     if (!setup)
  87     {
  88         skip("Failed to create task.  Skipping tests.\n");
  89         return;
  90     }
  91
  92     /* Attempt getting before setting application name */
  93     hres = ITask_GetApplicationName(test_task, &stored_name);
  94     ok(hres == S_OK, "GetApplicationName failed: %08x\n", hres);
  95     if (hres == S_OK)
  96     {
  97         ok(!lstrcmpiW(stored_name, empty),
  98                 "Got %s, expected empty string\n", wine_dbgstr_w(stored_name));
  99         CoTaskMemFree(stored_name);
 100     }
 101
 102     /* Set application name to a nonexistent application and then get
 103      * the application name that is actually stored */
 104     hres = ITask_SetApplicationName(test_task, non_application_name);
 105     ok(hres == S_OK, "Failed setting name %s: %08x\n",
 106             wine_dbgstr_w(non_application_name), hres);
 107     hres = ITask_GetApplicationName(test_task, &stored_name);
 108     ok(hres == S_OK, "GetApplicationName failed: %08x\n", hres);
 109     if (hres == S_OK)
 110     {
 111         full_name = path_resolve_name(non_application_name);
 112         ok(!lstrcmpiW(stored_name, full_name), "Got %s, expected %s\n",
 113                 wine_dbgstr_w(stored_name), wine_dbgstr_w(full_name));
 114         CoTaskMemFree(stored_name);
 115     }
 116
 117     /* Set a valid application name with program type extension and then
 118      * get the stored name */
 119     hres = ITask_SetApplicationName(test_task, notepad_exe);
 120     ok(hres == S_OK, "Failed setting name %s: %08x\n",
 121             wine_dbgstr_w(notepad_exe), hres);
 122     hres = ITask_GetApplicationName(test_task, &stored_name);
 123     ok(hres == S_OK, "GetApplicationName failed: %08x\n", hres);
 124     if (hres == S_OK)
 125     {
 126         full_name = path_resolve_name(notepad_exe);
 127         ok(!lstrcmpiW(stored_name, full_name), "Got %s, expected %s\n",
 128                 wine_dbgstr_w(stored_name), wine_dbgstr_w(full_name));
 129         CoTaskMemFree(stored_name);
 130     }
 131
 132     /* Set a valid application name without program type extension and
 133      * then get the stored name */
 134     hres = ITask_SetApplicationName(test_task, notepad);
 135     ok(hres == S_OK, "Failed setting name %s: %08x\n", wine_dbgstr_w(notepad), hres);
 136     hres = ITask_GetApplicationName(test_task, &stored_name);
 137     ok(hres == S_OK, "GetApplicationName failed: %08x\n", hres);
 138     if (hres == S_OK)
 139     {
 140         full_name = path_resolve_name(notepad_exe);  /* XP SP1 appends .exe */
 141         if (lstrcmpiW(stored_name, full_name) != 0)
 142         {
 143             full_name = path_resolve_name(notepad);
 144             ok(!lstrcmpiW(stored_name, full_name), "Got %s, expected %s\n",
 145                wine_dbgstr_w(stored_name), wine_dbgstr_w(full_name));
 146         }
 147         CoTaskMemFree(stored_name);
 148     }
 149
 150     /* After having a valid application name set, set application the name
 151      * to a nonexistent application and then get the name that is
 152      * actually stored */
 153     hres = ITask_SetApplicationName(test_task, non_application_name);
 154     ok(hres == S_OK, "Failed setting name %s: %08x\n",
 155             wine_dbgstr_w(non_application_name), hres);
 156     hres = ITask_GetApplicationName(test_task, &stored_name);
 157     ok(hres == S_OK, "GetApplicationName failed: %08x\n", hres);
 158     if (hres == S_OK)
 159     {
 160         full_name = path_resolve_name(non_application_name);
 161         ok(!lstrcmpiW(stored_name, full_name), "Got %s, expected %s\n",
 162                 wine_dbgstr_w(stored_name), wine_dbgstr_w(full_name));
 163         CoTaskMemFree(stored_name);
 164     }
 165
 166     /* Clear application name */
 167     hres = ITask_SetApplicationName(test_task, empty);
 168     ok(hres == S_OK, "Failed setting name %s: %08x\n", wine_dbgstr_w(empty), hres);
 169     hres = ITask_GetApplicationName(test_task, &stored_name);
 170     ok(hres == S_OK, "GetApplicationName failed: %08x\n", hres);
 171     if (hres == S_OK)
 172     {
 173         ok(!lstrcmpiW(stored_name, empty),
 174                 "Got %s, expected empty string\n", wine_dbgstr_w(stored_name));
 175         CoTaskMemFree(stored_name);
 176     }
 177
 178     cleanup_task();
 179     return;
 180 }
 181
 182 static void test_CreateTrigger(void)
 183 {
 184     BOOL setup;
 185     HRESULT hres;
 186     WORD trigger_index;
 187     ITaskTrigger *test_trigger;
 188
 189     setup = setup_task();
 190     ok(setup, "Failed to setup test_task\n");
 191     if (!setup)
 192     {
 193         skip("Failed to create task.  Skipping tests.\n");
 194         return;
 195     }
 196
 197     hres = ITask_CreateTrigger(test_task, &trigger_index, &test_trigger);
 198     ok(hres == S_OK, "Failed to create trigger: 0x%08x\n", hres);
 199     if (hres != S_OK)
 200     {
 201         cleanup_task();
 202         return;
 203     }
 204
 205     ITaskTrigger_Release(test_trigger);
 206     cleanup_task();
 207     return;
 208 }
 209
 210 static void test_SetParameters_GetParameters(void)
 211 {
 212     BOOL setup;
 213     HRESULT hres;
 214     LPWSTR parameters;
 215     const WCHAR parameters_a[] = {'f','o','o','.','t','x','t', 0};
 216     const WCHAR parameters_b[] = {'f','o','o','.','t','x','t',' ',
 217         'b','a','r','.','t','x','t', 0};
 218
 219     setup = setup_task();
 220     ok(setup, "Failed to setup test_task\n");
 221     if (!setup)
 222     {
 223         skip("Failed to create task.  Skipping tests.\n");
 224         return;
 225     }
 226
 227     /* Get parameters before setting them */
 228     hres = ITask_GetParameters(test_task, &parameters);
 229     ok(hres == S_OK, "GetParameters failed: %08x\n", hres);
 230     if (hres == S_OK)
 231     {
 232         ok(!lstrcmpW(parameters, empty),
 233                 "Got %s, expected empty string\n", wine_dbgstr_w(parameters));
 234         CoTaskMemFree(parameters);
 235     }
 236
 237     /* Set parameters to a simple string */
 238     hres = ITask_SetParameters(test_task, parameters_a);
 239     ok(hres == S_OK, "Failed setting parameters %s: %08x\n",
 240             wine_dbgstr_w(parameters_a), hres);
 241     hres = ITask_GetParameters(test_task, &parameters);
 242     ok(hres == S_OK, "GetParameters failed: %08x\n", hres);
 243     if (hres == S_OK)
 244     {
 245         ok(!lstrcmpW(parameters, parameters_a), "Got %s, expected %s\n",
 246                 wine_dbgstr_w(parameters), wine_dbgstr_w(parameters_a));
 247         CoTaskMemFree(parameters);
 248     }
 249
 250     /* Update parameters to a different simple string */
 251     hres = ITask_SetParameters(test_task, parameters_b);
 252     ok(hres == S_OK, "Failed setting parameters %s: %08x\n",
 253             wine_dbgstr_w(parameters_b), hres);
 254     hres = ITask_GetParameters(test_task, &parameters);
 255     ok(hres == S_OK, "GetParameters failed: %08x\n", hres);
 256     if (hres == S_OK)
 257     {
 258         ok(!lstrcmpW(parameters, parameters_b), "Got %s, expected %s\n",
 259                 wine_dbgstr_w(parameters), wine_dbgstr_w(parameters_b));
 260         CoTaskMemFree(parameters);
 261     }
 262
 263     /* Clear parameters */
 264     hres = ITask_SetParameters(test_task, empty);
 265     ok(hres == S_OK, "Failed setting parameters %s: %08x\n",
 266             wine_dbgstr_w(empty), hres);
 267     hres = ITask_GetParameters(test_task, &parameters);
 268     ok(hres == S_OK, "GetParameters failed: %08x\n", hres);
 269     if (hres == S_OK)
 270     {
 271         ok(!lstrcmpW(parameters, empty),
 272                 "Got %s, expected empty string\n", wine_dbgstr_w(parameters));
 273         CoTaskMemFree(parameters);
 274     }
 275
 276     cleanup_task();
 277     return;
 278 }
 279
 280 static void test_SetComment_GetComment(void)
 281 {
 282     BOOL setup;
 283     HRESULT hres;
 284     LPWSTR comment;
 285     const WCHAR comment_a[] = {'C','o','m','m','e','n','t','.', 0};
 286     const WCHAR comment_b[] = {'L','o','n','g','e','r',' ',
 287             'c','o','m','m','e','n','t','.', 0};
 288
 289     setup = setup_task();
 290     ok(setup, "Failed to setup test_task\n");
 291     if (!setup)
 292     {
 293         skip("Failed to create task.  Skipping tests.\n");
 294         return;
 295     }
 296
 297     /* Get comment before setting it*/
 298     hres = ITask_GetComment(test_task, &comment);
 299     ok(hres == S_OK, "GetComment failed: %08x\n", hres);
 300     if (hres == S_OK)
 301     {
 302         ok(!lstrcmpW(comment, empty),
 303                 "Got %s, expected empty string\n", wine_dbgstr_w(comment));
 304         CoTaskMemFree(comment);
 305     }
 306
 307     /* Set comment to a simple string */
 308     hres = ITask_SetComment(test_task, comment_a);
 309     ok(hres == S_OK, "Failed setting comment %s: %08x\n",
 310             wine_dbgstr_w(comment_a), hres);
 311     hres = ITask_GetComment(test_task, &comment);
 312     ok(hres == S_OK, "GetComment failed: %08x\n", hres);
 313     if (hres == S_OK)
 314     {
 315         ok(!lstrcmpW(comment, comment_a), "Got %s, expected %s\n",
 316                 wine_dbgstr_w(comment), wine_dbgstr_w(comment_a));
 317         CoTaskMemFree(comment);
 318     }
 319
 320     /* Update comment to a different simple string */
 321     hres = ITask_SetComment(test_task, comment_b);
 322     ok(hres == S_OK, "Failed setting comment %s: %08x\n",
 323             wine_dbgstr_w(comment_b), hres);
 324     hres = ITask_GetComment(test_task, &comment);
 325     ok(hres == S_OK, "GetComment failed: %08x\n", hres);
 326     if (hres == S_OK)
 327     {
 328         ok(!lstrcmpW(comment, comment_b), "Got %s, expected %s\n",
 329                 wine_dbgstr_w(comment), wine_dbgstr_w(comment_b));
 330         CoTaskMemFree(comment);
 331     }
 332
 333     /* Clear comment */
 334     hres = ITask_SetComment(test_task, empty);
 335     ok(hres == S_OK, "Failed setting comment %s: %08x\n",
 336             wine_dbgstr_w(empty), hres);
 337     hres = ITask_GetComment(test_task, &comment);
 338     ok(hres == S_OK, "GetComment failed: %08x\n", hres);
 339     if (hres == S_OK)
 340     {
 341         ok(!lstrcmpW(comment, empty),
 342                 "Got %s, expected empty string\n", wine_dbgstr_w(comment));
 343         CoTaskMemFree(comment);
 344     }
 345
 346     cleanup_task();
 347     return;
 348 }
 349
 350 static void test_SetMaxRunTime_GetMaxRunTime(void)
 351 {
 352     BOOL setup;
 353     HRESULT hres;
 354     DWORD max_run_time;
 355
 356     setup = setup_task();
 357     ok(setup, "Failed to setup test_task\n");
 358     if (!setup)
 359     {
 360         skip("Failed to create task.  Skipping tests.\n");
 361         return;
 362     }
 363
 364     /* Default time is 3 days:
 365      * 3 days * 24 hours * 60 minutes * 60 seconds * 1000 ms = 259200000 */
 366     max_run_time = 0;
 367     hres = ITask_GetMaxRunTime(test_task, &max_run_time);
 368     ok(hres == S_OK, "Failed to get max runtime: 0x%08x\n", hres);
 369     ok(max_run_time == 259200000, "Expected 259200000: %d\n", max_run_time);
 370
 371     /* Basic set test */
 372     max_run_time = 0;
 373     hres = ITask_SetMaxRunTime(test_task, 1234);
 374     ok(hres == S_OK, "Failed to set max runtime: 0x%08x\n", hres);
 375     hres = ITask_GetMaxRunTime(test_task, &max_run_time);
 376     ok(hres == S_OK, "Failed to get max runtime: 0x%08x\n", hres);
 377     ok(max_run_time == 1234, "Expected 1234: %d\n", max_run_time);
 378
 379     /* Verify that time can be set to zero */
 380     max_run_time = 1;
 381     hres = ITask_SetMaxRunTime(test_task, 0);
 382     ok(hres == S_OK, "Failed to set max runtime: 0x%08x\n", hres);
 383     hres = ITask_GetMaxRunTime(test_task, &max_run_time);
 384     ok(hres == S_OK, "Failed to get max runtime: 0x%08x\n", hres);
 385     ok(max_run_time == 0, "Expected 0: %d\n", max_run_time);
 386
 387     /* Check resolution by setting time to one */
 388     max_run_time = 0;
 389     hres = ITask_SetMaxRunTime(test_task, 1);
 390     ok(hres == S_OK, "Failed to set max runtime: 0x%08x\n", hres);
 391     hres = ITask_GetMaxRunTime(test_task, &max_run_time);
 392     ok(hres == S_OK, "Failed to get max runtime: 0x%08x\n", hres);
 393     ok(max_run_time == 1, "Expected 1: %d\n", max_run_time);
 394
 395     /* Verify that time can be set to INFINITE */
 396     max_run_time = 0;
 397     hres = ITask_SetMaxRunTime(test_task, INFINITE);
 398     ok(hres == S_OK, "Failed to set max runtime: 0x%08x\n", hres);
 399     hres = ITask_GetMaxRunTime(test_task, &max_run_time);
 400     ok(hres == S_OK, "Failed to get max runtime: 0x%08x\n", hres);
 401     ok(max_run_time == INFINITE, "Expected INFINITE: %d\n", max_run_time);
 402
 403     cleanup_task();
 404     return;
 405 }
 406
 407 static void test_SetAccountInformation_GetAccountInformation(void)
 408 {
 409     BOOL setup;
 410     HRESULT hres;
 411     LPWSTR account_name;
 412     const WCHAR dummy_account_name[] = {'N', 'o', 'S', 'u', 'c', 'h',
 413             'A', 'c', 'c', 'o', 'u', 'n', 't', 0};
 414     const WCHAR dummy_account_name_b[] = {'N', 'o', 'S', 'u', 'c', 'h',
 415             'A', 'c', 'c', 'o', 'u', 'n', 't', 'B', 0};
 416
 417     setup = setup_task();
 418     ok(setup, "Failed to setup test_task\n");
 419     if (!setup)
 420     {
 421         skip("Failed to create task.  Skipping tests.\n");
 422         return;
 423     }
 424
 425     /* Get account information before it is set */
 426     hres = ITask_GetAccountInformation(test_task, &account_name);
 427     /* WinXP returns HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND): 0x80070002 but
 428      * Win2K returns SCHED_E_CANNOT_OPEN_TASK: 0x8004130d
 429      * Win9x doesn't support security services */
 430     if (hres == SCHED_E_NO_SECURITY_SERVICES || hres == SCHED_E_SERVICE_NOT_RUNNING)
 431     {
 432         win_skip("Security services are not supported\n");
 433         cleanup_task();
 434         return;
 435     }
 436     ok(hres == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) ||
 437             hres == SCHED_E_CANNOT_OPEN_TASK,
 438             "Unset account name generated: 0x%08x\n", hres);
 439
 440     /* Attempt to set to a dummy account without a password */
 441     /* This test passes on WinXP but fails on Win2K */
 442     hres = ITask_SetAccountInformation(test_task, dummy_account_name, NULL);
 443     ok(hres == S_OK,
 444             "Failed setting dummy account with no password: %08x\n", hres);
 445     hres = ITask_GetAccountInformation(test_task, &account_name);
 446     ok(hres == S_OK ||
 447        broken(hres == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) ||
 448               hres == SCHED_E_CANNOT_OPEN_TASK ||
 449               hres == 0x200),  /* win2k */
 450        "GetAccountInformation failed: %08x\n", hres);
 451     if (hres == S_OK)
 452     {
 453         ok(!lstrcmpW(account_name, dummy_account_name),
 454                 "Got %s, expected %s\n", wine_dbgstr_w(account_name),
 455                 wine_dbgstr_w(dummy_account_name));
 456         CoTaskMemFree(account_name);
 457     }
 458
 459     /* Attempt to set to a dummy account with a (invalid) password */
 460     /* This test passes on WinXP but fails on Win2K */
 461     hres = ITask_SetAccountInformation(test_task, dummy_account_name_b,
 462             dummy_account_name_b);
 463     ok(hres == S_OK,
 464             "Failed setting dummy account with password: %08x\n", hres);
 465     hres = ITask_GetAccountInformation(test_task, &account_name);
 466     ok(hres == S_OK ||
 467        broken(hres == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) ||
 468               hres == SCHED_E_CANNOT_OPEN_TASK ||
 469               hres == 0x200),  /* win2k */
 470        "GetAccountInformation failed: %08x\n", hres);
 471     if (hres == S_OK)
 472     {
 473         ok(!lstrcmpW(account_name, dummy_account_name_b),
 474                 "Got %s, expected %s\n", wine_dbgstr_w(account_name),
 475                 wine_dbgstr_w(dummy_account_name_b));
 476         CoTaskMemFree(account_name);
 477     }
 478
 479     /* Attempt to set to the local system account */
 480     hres = ITask_SetAccountInformation(test_task, empty, NULL);
 481     ok(hres == S_OK, "Failed setting system account: %08x\n", hres);
 482     hres = ITask_GetAccountInformation(test_task, &account_name);
 483     ok(hres == S_OK ||
 484        broken(hres == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) ||
 485               hres == SCHED_E_CANNOT_OPEN_TASK ||
 486               hres == 0x200),  /* win2k */
 487        "GetAccountInformation failed: %08x\n", hres);
 488     if (hres == S_OK)
 489     {
 490         ok(!lstrcmpW(account_name, empty),
 491                 "Got %s, expected empty string\n", wine_dbgstr_w(account_name));
 492         CoTaskMemFree(account_name);
 493     }
 494
 495     cleanup_task();
 496     return;
 497 }
 498
 499 START_TEST(task)
 500 {
 501     CoInitialize(NULL);
 502     test_SetApplicationName_GetApplicationName();
 503     test_CreateTrigger();
 504     test_SetParameters_GetParameters();
 505     test_SetComment_GetComment();
 506     test_SetMaxRunTime_GetMaxRunTime();
 507     test_SetAccountInformation_GetAccountInformation();
 508     CoUninitialize();
 509 }