dlls/mstask/tests/task_trigger.c

   1 /*
   2  * Test suite for Task 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 "mstask.h"
  27 #include "wine/test.h"
  28
  29 static ITaskScheduler *test_task_scheduler;
  30
  31 static BOOL compare_trigger_state(TASK_TRIGGER found_state,
  32         TASK_TRIGGER expected_state)
  33 {
  34     ok(found_state.cbTriggerSize == expected_state.cbTriggerSize,
  35             "cbTriggerSize: Found %d but expected %d\n",
  36             found_state.cbTriggerSize, expected_state.cbTriggerSize);
  37
  38     ok(found_state.Reserved1 == expected_state.Reserved1,
  39             "Reserved1: Found %d but expected %d\n",
  40             found_state.Reserved1, expected_state.Reserved1);
  41
  42     ok(found_state.wBeginYear == expected_state.wBeginYear,
  43             "wBeginYear: Found %d but expected %d\n",
  44             found_state.wBeginYear, expected_state.wBeginYear);
  45
  46     ok(found_state.wBeginMonth == expected_state.wBeginMonth,
  47             "wBeginMonth: Found %d but expected %d\n",
  48             found_state.wBeginMonth, expected_state.wBeginMonth);
  49
  50     ok(found_state.wBeginDay == expected_state.wBeginDay,
  51             "wBeginDay: Found %d but expected %d\n",
  52             found_state.wBeginDay, expected_state.wBeginDay);
  53
  54     ok(found_state.wEndYear == expected_state.wEndYear,
  55             "wEndYear: Found %d but expected %d\n",
  56             found_state.wEndYear, expected_state.wEndYear);
  57
  58     ok(found_state.wEndMonth == expected_state.wEndMonth,
  59             "wEndMonth: Found %d but expected %d\n",
  60             found_state.wEndMonth, expected_state.wEndMonth);
  61
  62     ok(found_state.wEndDay == expected_state.wEndDay,
  63             "wEndDay: Found %d but expected %d\n",
  64             found_state.wEndDay, expected_state.wEndDay);
  65
  66     ok(found_state.wStartHour == expected_state.wStartHour,
  67             "wStartHour: Found %d but expected %d\n",
  68             found_state.wStartHour, expected_state.wStartHour);
  69
  70     ok(found_state.wStartMinute == expected_state.wStartMinute,
  71             "wStartMinute: Found %d but expected %d\n",
  72             found_state.wStartMinute, expected_state.wStartMinute);
  73
  74     ok(found_state.MinutesDuration == expected_state.MinutesDuration,
  75             "MinutesDuration: Found %d but expected %d\n",
  76             found_state.MinutesDuration, expected_state.MinutesDuration);
  77
  78     ok(found_state.MinutesInterval == expected_state.MinutesInterval,
  79             "MinutesInterval: Found %d but expected %d\n",
  80             found_state.MinutesInterval, expected_state.MinutesInterval);
  81
  82     ok(found_state.rgFlags == expected_state.rgFlags,
  83             "rgFlags: Found %d but expected %d\n",
  84             found_state.rgFlags, expected_state.rgFlags);
  85
  86     ok(found_state.TriggerType == expected_state.TriggerType,
  87             "TriggerType: Found %d but expected %d\n",
  88             found_state.TriggerType, expected_state.TriggerType);
  89
  90     ok(found_state.Type.Daily.DaysInterval == expected_state.Type.Daily.DaysInterval,
  91             "Type.Daily.DaysInterval: Found %d but expected %d\n",
  92             found_state.Type.Daily.DaysInterval, expected_state.Type.Daily.DaysInterval);
  93
  94     ok(found_state.Reserved2 == expected_state.Reserved2,
  95             "Reserved2: Found %d but expected %d\n",
  96             found_state.Reserved2, expected_state.Reserved2);
  97
  98     ok(found_state.wRandomMinutesInterval == expected_state.wRandomMinutesInterval,
  99             "wRandomMinutesInterval: Found %d but expected %d\n",
 100             found_state.wRandomMinutesInterval, expected_state.wRandomMinutesInterval);
 101
 102     return TRUE;
 103 }
 104
 105 static void test_SetTrigger_GetTrigger(void)
 106 {
 107     static const WCHAR task_name[] = { 'T','e','s','t','i','n','g',0 };
 108     ITask *test_task;
 109     ITaskTrigger *test_trigger;
 110     HRESULT hres;
 111     WORD idx;
 112     TASK_TRIGGER trigger_state;
 113     TASK_TRIGGER empty_trigger_state = {
 114         sizeof(trigger_state), 0,
 115         0, 0, 0,
 116         0, 0, 0,
 117         0, 0, 0, 0,
 118         TASK_TRIGGER_FLAG_DISABLED, TASK_TIME_TRIGGER_DAILY, {{1}},
 119         0, 0
 120     };
 121     TASK_TRIGGER normal_trigger_state = {
 122         sizeof(trigger_state), 0,
 123         1980, 1, 1,
 124         2980, 2, 2,
 125         3, 3,
 126         0, 0,
 127         TASK_TRIGGER_FLAG_DISABLED, TASK_TIME_TRIGGER_DAILY, {{1}},
 128         0, 0
 129     };
 130     SYSTEMTIME time;
 131
 132     hres = ITaskScheduler_NewWorkItem(test_task_scheduler, task_name, &CLSID_CTask,
 133                                       &IID_ITask, (IUnknown **)&test_task);
 134     ok(hres == S_OK, "got %#x\n", hres);
 135
 136     hres = ITask_CreateTrigger(test_task, &idx, &test_trigger);
 137     ok(hres == S_OK, "got %#x\n", hres);
 138
 139     /* Setup a trigger with base values for this test run */
 140     GetLocalTime(&time);
 141     empty_trigger_state.wStartHour = time.wHour;
 142     empty_trigger_state.wStartMinute = time.wMinute;
 143     empty_trigger_state.wBeginYear = time.wYear;
 144     empty_trigger_state.wBeginMonth = time.wMonth;
 145     empty_trigger_state.wBeginDay = time.wDay;
 146
 147     /* Test trigger state after trigger creation but before setting * state */
 148     memset(&trigger_state, 0xcf, sizeof(trigger_state));
 149     trigger_state.cbTriggerSize = sizeof(trigger_state);
 150     hres = ITaskTrigger_GetTrigger(test_trigger, &trigger_state);
 151     ok(hres == S_OK, "Failed to set trigger: 0x%08x\n", hres);
 152     compare_trigger_state(trigger_state, empty_trigger_state);
 153
 154     /* Test setting basic empty trigger */
 155     hres = ITaskTrigger_SetTrigger(test_trigger, &empty_trigger_state);
 156     ok(hres == S_OK, "Failed to set trigger: 0x%08x\n", hres);
 157     memset(&trigger_state, 0xcf, sizeof(trigger_state));
 158     trigger_state.cbTriggerSize = sizeof(trigger_state);
 159     hres = ITaskTrigger_GetTrigger(test_trigger, &trigger_state);
 160     ok(hres == S_OK, "Failed to GetTrigger\n");
 161     compare_trigger_state(trigger_state, empty_trigger_state);
 162
 163     /* Test setting basic non-empty trigger */
 164     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 165     ok(hres == S_OK, "Failed to set trigger: 0x%08x\n", hres);
 166     memset(&trigger_state, 0xcf, sizeof(trigger_state));
 167     trigger_state.cbTriggerSize = sizeof(trigger_state);
 168     hres = ITaskTrigger_GetTrigger(test_trigger, &trigger_state);
 169     ok(hres == S_OK, "Failed to GetTrigger\n");
 170     compare_trigger_state(trigger_state, normal_trigger_state);
 171
 172     /* The following tests modify the normal_trigger_state structure
 173      * before each test, and return the normal_trigger_state structure
 174      * back to its original valid state after each test.  This keeps
 175      * each test run independent. */
 176
 177     /* Test setting trigger with invalid cbTriggerSize */
 178     normal_trigger_state.cbTriggerSize = sizeof(trigger_state) - 1;
 179     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 180     ok(hres == E_INVALIDARG, "Expected E_INVALIDARG: 0x%08x\n", hres);
 181     normal_trigger_state.cbTriggerSize = sizeof(trigger_state) + 1;
 182     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 183     ok(hres == E_INVALIDARG, "Expected E_INVALIDARG: 0x%08x\n", hres);
 184     normal_trigger_state.cbTriggerSize = sizeof(trigger_state);
 185
 186     /* Test setting trigger with invalid Reserved fields */
 187     normal_trigger_state.Reserved1 = 80;
 188     normal_trigger_state.Reserved2 = 80;
 189     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 190     ok(hres == S_OK, "Failed to set trigger: 0x%08x\n", hres);
 191     memset(&trigger_state, 0xcf, sizeof(trigger_state));
 192     trigger_state.cbTriggerSize = sizeof(trigger_state);
 193     hres = ITaskTrigger_GetTrigger(test_trigger, &trigger_state);
 194     ok(hres == S_OK, "Expected S_OK: 0x%08x\n", hres);
 195     ok(trigger_state.Reserved1 == 0 && trigger_state.Reserved2 == 0,
 196             "Reserved fields should be set to zero\n");
 197     normal_trigger_state.Reserved1 = 0;
 198     normal_trigger_state.Reserved2 = 0;
 199
 200     /* Test setting trigger with invalid month */
 201     normal_trigger_state.wBeginMonth = 0;
 202     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 203     ok(hres == E_INVALIDARG, "Expected E_INVALIDARG: 0x%08x\n", hres);
 204     normal_trigger_state.wBeginMonth = 13;
 205     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 206     ok(hres == E_INVALIDARG, "Expected E_INVALIDARG: 0x%08x\n", hres);
 207     normal_trigger_state.wBeginMonth = 1;
 208
 209     /* Test setting trigger with invalid begin date */
 210     normal_trigger_state.wBeginDay = 0;
 211     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 212     ok(hres == E_INVALIDARG, "Expected E_INVALIDARG: 0x%08x\n", hres);
 213     normal_trigger_state.wBeginDay = 32;
 214     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 215     ok(hres == E_INVALIDARG, "Expected E_INVALIDARG: 0x%08x\n", hres);
 216     normal_trigger_state.wBeginMonth = 2;
 217     normal_trigger_state.wBeginDay = 30;
 218     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 219     ok(hres == E_INVALIDARG, "Expected E_INVALIDARG: 0x%08x\n", hres);
 220     normal_trigger_state.wBeginMonth = 1;
 221     normal_trigger_state.wBeginDay = 1;
 222
 223     /* Test setting trigger invalid end date */
 224     normal_trigger_state.wEndYear = 0;
 225     normal_trigger_state.wEndMonth = 200;
 226     normal_trigger_state.wEndDay = 200;
 227     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 228     ok(hres == S_OK, "Failed to set trigger: 0x%08x\n", hres);
 229     memset(&trigger_state, 0xcf, sizeof(trigger_state));
 230     trigger_state.cbTriggerSize = sizeof(trigger_state);
 231     hres = ITaskTrigger_GetTrigger(test_trigger, &trigger_state);
 232     ok(hres == S_OK, "Expected S_OK: 0x%08x\n", hres);
 233     ok(trigger_state.wEndYear == 0, "End year should be 0: %d\n",
 234             trigger_state.wEndYear);
 235     ok(trigger_state.wEndMonth == 200, "End month should be 200: %d\n",
 236             trigger_state.wEndMonth);
 237     ok(trigger_state.wEndDay == 200, "End day should be 200: %d\n",
 238             trigger_state.wEndDay);
 239     normal_trigger_state.rgFlags =
 240             TASK_TRIGGER_FLAG_DISABLED | TASK_TRIGGER_FLAG_HAS_END_DATE;
 241     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 242     ok(hres == E_INVALIDARG, "Expected E_INVALIDARG: 0x%08x\n", hres);
 243     normal_trigger_state.rgFlags = TASK_TRIGGER_FLAG_DISABLED;
 244     normal_trigger_state.wEndYear = 2980;
 245     normal_trigger_state.wEndMonth = 1;
 246     normal_trigger_state.wEndDay = 1;
 247
 248     /* Test setting trigger with invalid hour or minute*/
 249     normal_trigger_state.wStartHour = 24;
 250     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 251     ok(hres == E_INVALIDARG, "Expected E_INVALIDARG: 0x%08x\n", hres);
 252     normal_trigger_state.wStartHour = 60;
 253     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 254     ok(hres == E_INVALIDARG, "Expected E_INVALIDARG: 0x%08x\n", hres);
 255     normal_trigger_state.wStartHour = 3;
 256
 257     /* Test setting trigger with invalid duration / interval pairs */
 258     normal_trigger_state.MinutesDuration = 5;
 259     normal_trigger_state.MinutesInterval = 5;
 260     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 261     ok(hres == E_INVALIDARG, "Expected E_INVALIDARG: 0x%08x\n", hres);
 262     normal_trigger_state.MinutesDuration = 5;
 263     normal_trigger_state.MinutesInterval = 6;
 264     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 265     ok(hres == E_INVALIDARG, "Expected E_INVALIDARG: 0x%08x\n", hres);
 266     normal_trigger_state.MinutesDuration = 0;
 267     normal_trigger_state.MinutesInterval = 6;
 268     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 269     ok(hres == E_INVALIDARG, "Expected E_INVALIDARG: 0x%08x\n", hres);
 270     normal_trigger_state.MinutesDuration = 5;
 271     normal_trigger_state.MinutesInterval = 0;
 272     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 273     ok(hres == S_OK, "Failed to set trigger: 0x%08x\n", hres);
 274     normal_trigger_state.MinutesDuration = 0;
 275     normal_trigger_state.MinutesInterval = 0;
 276
 277     /* Test setting trigger with end date before start date */
 278     normal_trigger_state.wEndYear = 1979;
 279     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 280     ok(hres == S_OK, "Failed to set trigger: 0x%08x\n", hres);
 281     normal_trigger_state.rgFlags =
 282             TASK_TRIGGER_FLAG_DISABLED | TASK_TRIGGER_FLAG_HAS_END_DATE;
 283     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 284     ok(hres == S_OK, "Failed to set trigger: 0x%08x\n", hres);
 285     normal_trigger_state.rgFlags = TASK_TRIGGER_FLAG_DISABLED;
 286     normal_trigger_state.wEndYear = 2980;
 287     normal_trigger_state.wEndMonth = 1;
 288     normal_trigger_state.wEndDay = 1;
 289
 290
 291     /* Test setting trigger with invalid TriggerType and Type */
 292     normal_trigger_state.TriggerType = TASK_TIME_TRIGGER_ONCE;
 293     normal_trigger_state.Type.Weekly.WeeksInterval = 2;
 294     normal_trigger_state.Type.Weekly.rgfDaysOfTheWeek = (TASK_MONDAY | TASK_TUESDAY);
 295     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 296     ok(hres == S_OK, "Failed to set trigger: 0x%08x\n", hres);
 297     memset(&trigger_state, 0xcf, sizeof(trigger_state));
 298     trigger_state.cbTriggerSize = sizeof(trigger_state);
 299     hres = ITaskTrigger_GetTrigger(test_trigger, &trigger_state);
 300     ok(hres == S_OK, "Expected S_OK: 0x%08x\n", hres);
 301     ok(trigger_state.Type.Weekly.WeeksInterval == 0xcfcf,
 302             "Expected WeeksInterval set remain untouched: %d\n",
 303             trigger_state.Type.Weekly.WeeksInterval);
 304     ok(trigger_state.Type.Weekly.rgfDaysOfTheWeek == 0xcfcf,
 305             "Expected WeeksInterval set remain untouched: %d\n",
 306             trigger_state.Type.Weekly.rgfDaysOfTheWeek);
 307     normal_trigger_state.TriggerType = TASK_TIME_TRIGGER_DAILY;
 308     normal_trigger_state.Type.Daily.DaysInterval = 1;
 309     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 310     ok(hres == S_OK, "Expected S_OK: 0x%08x\n", hres);
 311
 312     /* Test setting trigger with set wRandomMinutesInterval */
 313     normal_trigger_state.wRandomMinutesInterval = 5;
 314     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 315     ok(hres == S_OK, "Failed to set trigger: 0x%08x\n", hres);
 316     memset(&trigger_state, 0xcf, sizeof(trigger_state));
 317     trigger_state.cbTriggerSize = sizeof(trigger_state);
 318     hres = ITaskTrigger_GetTrigger(test_trigger, &trigger_state);
 319     ok(hres == S_OK, "Expected S_OK: 0x%08x\n", hres);
 320     ok(trigger_state.wRandomMinutesInterval == 0,
 321             "wRandomMinutesInterval should be set to zero\n");
 322     normal_trigger_state.wRandomMinutesInterval = 0;
 323
 324     /* Test GetTrigger using invalid cbTriggerSiz in pTrigger.  In
 325      * contrast to available documentation, this succeeds in practice. */
 326     hres = ITaskTrigger_SetTrigger(test_trigger, &normal_trigger_state);
 327     ok(hres == S_OK, "Failed to set trigger: 0x%08x\n", hres);
 328     memset(&trigger_state, 0xcf, sizeof(trigger_state));
 329     trigger_state.cbTriggerSize = sizeof(trigger_state) - 1;
 330     hres = ITaskTrigger_GetTrigger(test_trigger, &trigger_state);
 331     ok(hres == S_OK, "Failed to GetTrigger\n");
 332     ok(compare_trigger_state(trigger_state, normal_trigger_state),
 333             "Invalid state\n");
 334     memset(&trigger_state, 0xcf, sizeof(trigger_state));
 335     trigger_state.cbTriggerSize = 0;
 336     hres = ITaskTrigger_GetTrigger(test_trigger, &trigger_state);
 337     ok(hres == S_OK, "Failed to GetTrigger\n");
 338     ok(compare_trigger_state(trigger_state, normal_trigger_state),
 339             "Invalid state\n");
 340
 341     ITaskTrigger_Release(test_trigger);
 342     ITask_Release(test_task);
 343 }
 344
 345 static void test_task_trigger(void)
 346 {
 347     static const WCHAR task_name[] = { 'T','e','s','t','i','n','g',0 };
 348     HRESULT hr;
 349     ITask *task;
 350     ITaskTrigger *trigger, *trigger2;
 351     WORD count, idx;
 352     DWORD ref;
 353
 354     hr = ITaskScheduler_NewWorkItem(test_task_scheduler, task_name, &CLSID_CTask,
 355                                     &IID_ITask, (IUnknown **)&task);
 356     ok(hr == S_OK, "got %#x\n", hr);
 357
 358     count = 0xdead;
 359     hr = ITask_GetTriggerCount(task, &count);
 360     ok(hr == S_OK, "got %#x\n", hr);
 361     ok(count == 0, "got %u\n", count);
 362
 363     hr = ITask_DeleteTrigger(task, 0);
 364     ok(hr == SCHED_E_TRIGGER_NOT_FOUND, "got %#x\n", hr);
 365
 366     hr = ITask_GetTrigger(task, 0, &trigger);
 367     ok(hr == SCHED_E_TRIGGER_NOT_FOUND, "got %#x\n", hr);
 368
 369     idx = 0xdead;
 370     hr = ITask_CreateTrigger(task, &idx, &trigger);
 371     ok(hr == S_OK, "got %#x\n", hr);
 372     ok(idx == 0, "got %u\n", idx);
 373
 374     hr = ITask_GetTrigger(task, 0, &trigger2);
 375     ok(hr == S_OK, "got %#x\n", hr);
 376     ok(trigger != trigger2, "%p != %p\n", trigger, trigger2);
 377
 378     ref = ITaskTrigger_Release(trigger2);
 379     ok(ref == 0, "got %u\n", ref);
 380
 381     ref = ITaskTrigger_Release(trigger);
 382     ok(ref == 0, "got %u\n", ref);
 383
 384     count = 0xdead;
 385     hr = ITask_GetTriggerCount(task, &count);
 386     ok(hr == S_OK, "got %#x\n", hr);
 387     ok(count == 1, "got %u\n", count);
 388
 389     hr = ITask_DeleteTrigger(task, 0);
 390     ok(hr == S_OK, "got %#x\n", hr);
 391
 392     idx = 0xdead;
 393     hr = ITask_CreateTrigger(task, &idx, &trigger);
 394     ok(hr == S_OK, "got %#x\n", hr);
 395     ok(idx == 0, "got %u\n", idx);
 396
 397     hr = ITask_DeleteTrigger(task, 0);
 398     ok(hr == S_OK, "got %#x\n", hr);
 399
 400     count = 0xdead;
 401     hr = ITask_GetTriggerCount(task, &count);
 402     ok(hr == S_OK, "got %#x\n", hr);
 403     ok(count == 0, "got %u\n", count);
 404
 405     ref = ITaskTrigger_Release(trigger);
 406     ok(ref == 0, "got %u\n", ref);
 407
 408     ref = ITask_Release(task);
 409     ok(ref == 0, "got %u\n", ref);
 410 }
 411
 412 static void test_GetNextRunTime(void)
 413 {
 414     static const WCHAR task_name[] = { 'T','e','s','t','i','n','g',0 };
 415     static const SYSTEMTIME st_empty;
 416     HRESULT hr;
 417     ITask *task;
 418     ITaskTrigger *trigger;
 419     WORD idx;
 420     SYSTEMTIME st;
 421
 422     hr = ITaskScheduler_NewWorkItem(test_task_scheduler, task_name, &CLSID_CTask,
 423                                     &IID_ITask, (IUnknown **)&task);
 424     ok(hr == S_OK, "got %#x\n", hr);
 425
 426     if (0) /* crashes under Windows */
 427         hr = ITask_GetNextRunTime(task, NULL);
 428
 429     memset(&st, 0xff, sizeof(st));
 430     hr = ITask_GetNextRunTime(task, &st);
 431     ok(hr == SCHED_S_TASK_NO_VALID_TRIGGERS, "got %#x\n", hr);
 432     ok(!memcmp(&st, &st_empty, sizeof(st)), "got %d/%d/%d wday %d %d:%d:%d.%03d\n",
 433        st.wDay, st.wMonth, st.wYear, st.wDayOfWeek,
 434        st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
 435
 436     hr = ITask_CreateTrigger(task, &idx, &trigger);
 437     ok(hr == S_OK, "got %#x\n", hr);
 438
 439     memset(&st, 0xff, sizeof(st));
 440     hr = ITask_GetNextRunTime(task, &st);
 441     ok(hr == SCHED_S_TASK_NO_VALID_TRIGGERS, "got %#x\n", hr);
 442     ok(!memcmp(&st, &st_empty, sizeof(st)), "got %d/%d/%d wday %d %d:%d:%d.%03d\n",
 443        st.wDay, st.wMonth, st.wYear, st.wDayOfWeek,
 444        st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
 445
 446     ITaskTrigger_Release(trigger);
 447     ITask_Release(task);
 448 }
 449
 450 START_TEST(task_trigger)
 451 {
 452     HRESULT hr;
 453
 454     CoInitialize(NULL);
 455
 456     hr = CoCreateInstance(&CLSID_CTaskScheduler, NULL, CLSCTX_INPROC_SERVER,
 457                           &IID_ITaskScheduler, (void **)&test_task_scheduler);
 458     ok(hr == S_OK, "error creating TaskScheduler instance %#x\n", hr);
 459
 460     test_SetTrigger_GetTrigger();
 461     test_task_trigger();
 462     test_GetNextRunTime();
 463
 464     ITaskScheduler_Release(test_task_scheduler);
 465     CoUninitialize();
 466 }