dlls/taskschd/tests/scheduler.c

   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 "winternl.h"
  26 #include "winbase.h"
  27 #include "initguid.h"
  28 #include "objbase.h"
  29 #include "taskschd.h"
  30
  31 #include <wine/test.h>
  32
  33 static BOOL is_process_elevated(void)
  34 {
  35     HANDLE token;
  36     if (OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &token ))
  37     {
  38         TOKEN_ELEVATION_TYPE type;
  39         DWORD size;
  40         BOOL ret;
  41
  42         ret = GetTokenInformation( token, TokenElevationType, &type, sizeof(type), &size );
  43         CloseHandle( token );
  44         return (ret && type == TokenElevationTypeFull);
  45     }
  46     return FALSE;
  47 }
  48
  49 static BOOL check_win_version(int min_major, int min_minor)
  50 {
  51     HMODULE hntdll = GetModuleHandleA("ntdll.dll");
  52     NTSTATUS (WINAPI *pRtlGetVersion)(RTL_OSVERSIONINFOEXW *);
  53     RTL_OSVERSIONINFOEXW rtlver;
  54
  55     rtlver.dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOEXW);
  56     pRtlGetVersion = (void *)GetProcAddress(hntdll, "RtlGetVersion");
  57     pRtlGetVersion(&rtlver);
  58     return rtlver.dwMajorVersion > min_major ||
  59            (rtlver.dwMajorVersion == min_major &&
  60             rtlver.dwMinorVersion >= min_minor);
  61 }
  62 #define is_win8_plus() check_win_version(6, 2)
  63
  64 static void test_Connect(void)
  65 {
  66     WCHAR comp_name[MAX_COMPUTERNAME_LENGTH + 1];
  67     WCHAR user_name[256];
  68     DWORD len;
  69     HRESULT hr;
  70     BSTR bstr;
  71     VARIANT v_null, v_comp;
  72     VARIANT_BOOL vbool;
  73     BOOL was_connected;
  74     ITaskService *service;
  75
  76     hr = CoCreateInstance(&CLSID_TaskScheduler, NULL, CLSCTX_INPROC_SERVER, &IID_ITaskService, (void **)&service);
  77     if (hr != S_OK)
  78     {
  79         win_skip("CoCreateInstance(CLSID_TaskScheduler) error %#lx\n", hr);
  80         return;
  81     }
  82
  83     hr = ITaskService_get_Connected(service, NULL);
  84     ok(hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
  85
  86     vbool = 0xdead;
  87     hr = ITaskService_get_Connected(service, &vbool);
  88     ok(hr == S_OK, "get_Connected error %#lx\n", hr);
  89     ok(vbool == VARIANT_FALSE, "expected VARIANT_FALSE, got %d\n", vbool);
  90
  91     hr = ITaskService_get_TargetServer(service, NULL);
  92     ok(hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
  93
  94     hr = ITaskService_get_TargetServer(service, &bstr);
  95     ok(hr == HRESULT_FROM_WIN32(ERROR_ONLY_IF_CONNECTED), "expected ERROR_ONLY_IF_CONNECTED, got %#lx\n", hr);
  96
  97     hr = ITaskService_get_ConnectedUser(service, NULL);
  98     ok(hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
  99
 100     hr = ITaskService_get_ConnectedUser(service, &bstr);
 101     ok(hr == HRESULT_FROM_WIN32(ERROR_ONLY_IF_CONNECTED), "expected ERROR_ONLY_IF_CONNECTED, got %#lx\n", hr);
 102
 103     /* Win7 doesn't support UNC \\ prefix, but according to a user
 104      * comment on MSDN Win8 supports both ways.
 105      */
 106     len = ARRAY_SIZE(comp_name);
 107     GetComputerNameW(comp_name, &len);
 108
 109     V_VT(&v_null) = VT_NULL;
 110
 111     V_VT(&v_comp) = VT_BSTR;
 112     V_BSTR(&v_comp) = SysAllocString(comp_name);
 113
 114     hr = ITaskService_Connect(service, v_comp, v_null, v_null, v_null);
 115     ok(hr == S_OK || (hr == E_ACCESSDENIED && !is_process_elevated()),
 116        "Connect error %#lx\n", hr);
 117     was_connected = hr == S_OK;
 118     SysFreeString(V_BSTR(&v_comp));
 119
 120     V_BSTR(&v_comp) = SysAllocString(L"0.0.0.0");
 121     hr = ITaskService_Connect(service, v_comp, v_null, v_null, v_null);
 122     ok(hr == HRESULT_FROM_WIN32(RPC_S_INVALID_NET_ADDR) || hr == HRESULT_FROM_WIN32(ERROR_BAD_NETPATH) /* VM */,
 123        "expected RPC_S_INVALID_NET_ADDR, got %#lx\n", hr);
 124     SysFreeString(V_BSTR(&v_comp));
 125
 126     vbool = 0xdead;
 127     hr = ITaskService_get_Connected(service, &vbool);
 128     ok(hr == S_OK, "get_Connected error %#lx\n", hr);
 129     ok(vbool == VARIANT_FALSE || (was_connected && vbool == VARIANT_TRUE),
 130        "Connect shouldn't trash an existing connection, got %d (was connected %d)\n", vbool, was_connected);
 131
 132     V_BSTR(&v_comp) = SysAllocString(L"");
 133     hr = ITaskService_Connect(service, v_comp, v_null, v_null, v_null);
 134     ok(hr == S_OK, "Connect error %#lx\n", hr);
 135     SysFreeString(V_BSTR(&v_comp));
 136
 137     V_BSTR(&v_comp) = NULL;
 138     hr = ITaskService_Connect(service, v_comp, v_null, v_null, v_null);
 139     ok(hr == S_OK, "Connect error %#lx\n", hr);
 140
 141     hr = ITaskService_Connect(service, v_null, v_null, v_null, v_null);
 142     ok(hr == S_OK, "Connect error %#lx\n", hr);
 143
 144     vbool = 0xdead;
 145     hr = ITaskService_get_Connected(service, &vbool);
 146     ok(hr == S_OK, "get_Connected error %#lx\n", hr);
 147     ok(vbool == VARIANT_TRUE, "expected VARIANT_TRUE, got %d\n", vbool);
 148
 149     hr = ITaskService_get_TargetServer(service, &bstr);
 150     ok(hr == S_OK, "get_TargetServer error %#lx\n", hr);
 151     ok(!lstrcmpW(comp_name, bstr), "compname %s != server name %s\n", wine_dbgstr_w(comp_name), wine_dbgstr_w(bstr));
 152     SysFreeString(bstr);
 153
 154     len = ARRAY_SIZE(user_name);
 155     GetUserNameW(user_name, &len);
 156
 157     hr = ITaskService_get_ConnectedUser(service, &bstr);
 158     ok(hr == S_OK, "get_ConnectedUser error %#lx\n", hr);
 159     ok(!lstrcmpW(user_name, bstr), "username %s != user name %s\n", wine_dbgstr_w(user_name), wine_dbgstr_w(bstr));
 160     SysFreeString(bstr);
 161
 162     ITaskService_Release(service);
 163 }
 164
 165 static void test_GetFolder(void)
 166 {
 167     static WCHAR dot[] = L".";
 168     static WCHAR empty[] = L"";
 169     static WCHAR slash[] = L"/";
 170     static WCHAR bslash[] = L"\\";
 171     static WCHAR Wine[] = L"\\Wine";
 172     static WCHAR Wine_Folder1[] = L"\\Wine\\Folder1";
 173     static WCHAR Wine_Folder1_[] = L"\\Wine\\Folder1\\";
 174     static WCHAR Wine_Folder1_Folder2[] = L"\\Wine\\Folder1\\Folder2";
 175     static WCHAR Folder1_Folder2[] = L"\\Folder1\\Folder2";
 176     HRESULT hr;
 177     BSTR bstr;
 178     VARIANT v_null;
 179     ITaskService *service;
 180     ITaskFolder *folder, *subfolder, *subfolder2;
 181
 182     hr = CoCreateInstance(&CLSID_TaskScheduler, NULL, CLSCTX_INPROC_SERVER, &IID_ITaskService, (void **)&service);
 183     if (hr != S_OK)
 184     {
 185         win_skip("CoCreateInstance(CLSID_TaskScheduler) error %#lx\n", hr);
 186         return;
 187     }
 188
 189     hr = ITaskService_GetFolder(service, NULL, &folder);
 190     ok(hr == HRESULT_FROM_WIN32(ERROR_ONLY_IF_CONNECTED), "expected ERROR_ONLY_IF_CONNECTED, got %#lx\n", hr);
 191
 192     V_VT(&v_null) = VT_NULL;
 193
 194     hr = ITaskService_Connect(service, v_null, v_null, v_null, v_null);
 195     ok(hr == S_OK, "Connect error %#lx\n", hr);
 196
 197     hr = ITaskService_GetFolder(service, slash, &folder);
 198     todo_wine
 199     ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME), "expected ERROR_INVALID_NAME, got %#lx\n", hr);
 200
 201     hr = ITaskService_GetFolder(service, dot, &folder);
 202     todo_wine
 203     ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME) || hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) /* win7 */,
 204        "expected ERROR_INVALID_NAME, got %#lx\n", hr);
 205
 206     hr = ITaskService_GetFolder(service, bslash, &folder);
 207     ok(hr == S_OK, "GetFolder error %#lx\n", hr);
 208     ITaskFolder_Release(folder);
 209
 210     hr = ITaskService_GetFolder(service, NULL, NULL);
 211     ok(hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
 212
 213     hr = ITaskService_GetFolder(service, empty, &folder);
 214     ok(hr == S_OK, "GetFolder error %#lx\n", hr);
 215     ITaskFolder_Release(folder);
 216
 217     hr = ITaskService_GetFolder(service, NULL, &folder);
 218     ok(hr == S_OK, "GetFolder error %#lx\n", hr);
 219
 220     hr = ITaskFolder_get_Name(folder, NULL);
 221     ok(hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
 222
 223     hr = ITaskFolder_get_Name(folder, &bstr);
 224     ok (hr == S_OK, "get_Name error %#lx\n", hr);
 225     ok(!lstrcmpW(bstr, bslash), "expected '\\', got %s\n", wine_dbgstr_w(bstr));
 226     SysFreeString(bstr);
 227
 228     hr = ITaskFolder_get_Path(folder, NULL);
 229     ok(hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
 230
 231     hr = ITaskFolder_get_Path(folder, &bstr);
 232     ok(hr == S_OK, "get_Path error %#lx\n", hr);
 233     ok(!lstrcmpW(bstr, bslash), "expected '\\', got %s\n", wine_dbgstr_w(bstr));
 234     SysFreeString(bstr);
 235
 236     hr = ITaskFolder_CreateFolder(folder, NULL, v_null, &subfolder);
 237     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#lx\n", hr);
 238
 239     /* Just in case something was left from previous runs */
 240     ITaskFolder_DeleteFolder(folder, Wine_Folder1_Folder2, 0);
 241     ITaskFolder_DeleteFolder(folder, Wine_Folder1, 0);
 242     ITaskFolder_DeleteFolder(folder, Wine, 0);
 243
 244     hr = ITaskFolder_CreateFolder(folder, slash, v_null, &subfolder);
 245     todo_wine
 246     ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME), "expected ERROR_INVALID_NAME, got %#lx\n", hr);
 247
 248     hr = ITaskService_GetFolder(service, Wine_Folder1_Folder2, &subfolder);
 249     ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) || hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) /* win7 */,
 250        "expected ERROR_PATH_NOT_FOUND, got %#lx\n", hr);
 251
 252     hr = ITaskFolder_CreateFolder(folder, bslash, v_null, &subfolder);
 253     todo_wine
 254     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#lx\n", hr);
 255
 256     if (!is_process_elevated() && !is_win8_plus())
 257     {
 258         win_skip("Skipping CreateFolder tests because deleting folders requires elevated privileges on Windows 7\n");
 259         goto cleanup;
 260     }
 261
 262     hr = ITaskFolder_CreateFolder(folder, Wine_Folder1_Folder2, v_null, &subfolder);
 263     ok(hr == S_OK, "CreateFolder error %#lx\n", hr);
 264     ITaskFolder_Release(subfolder);
 265
 266     hr = ITaskFolder_CreateFolder(folder, Wine, v_null, NULL);
 267     ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#lx\n", hr);
 268
 269     hr = ITaskFolder_CreateFolder(folder, Wine_Folder1_, v_null, &subfolder);
 270     ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME), "expected ERROR_INVALID_NAME, got %#lx\n", hr);
 271
 272     hr = ITaskFolder_CreateFolder(folder, Wine, v_null, &subfolder);
 273     ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#lx\n", hr);
 274     hr = ITaskFolder_CreateFolder(folder, Wine+1, v_null, &subfolder);
 275     ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#lx\n", hr);
 276     hr = ITaskFolder_CreateFolder(folder, Wine_Folder1, v_null, &subfolder);
 277     ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#lx\n", hr);
 278     hr = ITaskFolder_CreateFolder(folder, Wine_Folder1+1, v_null, &subfolder);
 279     ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#lx\n", hr);
 280     hr = ITaskFolder_CreateFolder(folder, Wine_Folder1_Folder2, v_null, &subfolder);
 281     ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#lx\n", hr);
 282     hr = ITaskFolder_CreateFolder(folder, Wine_Folder1_Folder2+1, v_null, &subfolder);
 283     ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#lx\n", hr);
 284
 285     hr = ITaskService_GetFolder(service, Wine_Folder1_Folder2, NULL);
 286     ok(hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
 287
 288     hr = ITaskService_GetFolder(service, Wine_Folder1_Folder2, &subfolder);
 289     ok(hr == S_OK, "GetFolder error %#lx\n", hr);
 290
 291     hr = ITaskFolder_get_Name(subfolder, &bstr);
 292     ok (hr == S_OK, "get_Name error %#lx\n", hr);
 293     ok(!lstrcmpW(bstr, L"Folder2"), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
 294     SysFreeString(bstr);
 295     hr = ITaskFolder_get_Path(subfolder, &bstr);
 296     ok(hr == S_OK, "get_Path error %#lx\n", hr);
 297     ok(!lstrcmpW(bstr, Wine_Folder1_Folder2), "expected \\Wine\\Folder1\\Folder2, got %s\n", wine_dbgstr_w(bstr));
 298     SysFreeString(bstr);
 299     ITaskFolder_Release(subfolder);
 300
 301     hr = ITaskService_GetFolder(service, Wine_Folder1_Folder2+1, &subfolder);
 302     ok(hr == S_OK, "GetFolder error %#lx\n", hr);
 303     hr = ITaskFolder_get_Name(subfolder, &bstr);
 304     ok (hr == S_OK, "get_Name error %#lx\n", hr);
 305     ok(!lstrcmpW(bstr, L"Folder2"), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
 306     SysFreeString(bstr);
 307     hr = ITaskFolder_get_Path(subfolder, &bstr);
 308     ok(hr == S_OK, "get_Path error %#lx\n", hr);
 309     ok(!lstrcmpW(bstr, Wine_Folder1_Folder2+1), "expected Wine\\Folder1\\Folder2, got %s\n", wine_dbgstr_w(bstr));
 310     SysFreeString(bstr);
 311     ITaskFolder_Release(subfolder);
 312
 313     hr = ITaskService_GetFolder(service, Wine_Folder1, &subfolder);
 314     ok(hr == S_OK, "GetFolder error %#lx\n", hr);
 315     hr = ITaskFolder_get_Name(subfolder, &bstr);
 316     ok (hr == S_OK, "get_Name error %#lx\n", hr);
 317     ok(!lstrcmpW(bstr, L"Folder1"), "expected Folder1, got %s\n", wine_dbgstr_w(bstr));
 318     SysFreeString(bstr);
 319     hr = ITaskFolder_get_Path(subfolder, &bstr);
 320     ok(hr == S_OK, "get_Path error %#lx\n", hr);
 321     ok(!lstrcmpW(bstr, Wine_Folder1), "expected \\Wine\\Folder1, got %s\n", wine_dbgstr_w(bstr));
 322     SysFreeString(bstr);
 323     ITaskFolder_Release(subfolder);
 324
 325     hr = ITaskService_GetFolder(service, Wine, &subfolder);
 326     ok(hr == S_OK, "GetFolder error %#lx\n", hr);
 327     hr = ITaskFolder_get_Name(subfolder, &bstr);
 328     ok (hr == S_OK, "get_Name error %#lx\n", hr);
 329     ok(!lstrcmpW(bstr, Wine+1), "expected Wine, got %s\n", wine_dbgstr_w(bstr));
 330     SysFreeString(bstr);
 331     hr = ITaskFolder_get_Path(subfolder, &bstr);
 332     ok(hr == S_OK, "get_Path error %#lx\n", hr);
 333     ok(!lstrcmpW(bstr, Wine), "expected \\Wine, got %s\n", wine_dbgstr_w(bstr));
 334     SysFreeString(bstr);
 335     ITaskFolder_Release(subfolder);
 336
 337     hr = ITaskService_GetFolder(service, Wine+1, &subfolder);
 338     ok(hr == S_OK, "GetFolder error %#lx\n", hr);
 339     hr = ITaskFolder_get_Name(subfolder, &bstr);
 340     ok (hr == S_OK, "get_Name error %#lx\n", hr);
 341     ok(!lstrcmpW(bstr, Wine+1), "expected Wine, got %s\n", wine_dbgstr_w(bstr));
 342     SysFreeString(bstr);
 343     hr = ITaskFolder_get_Path(subfolder, &bstr);
 344     ok(hr == S_OK, "get_Path error %#lx\n", hr);
 345     ok(!lstrcmpW(bstr, Wine+1), "expected Wine, got %s\n", wine_dbgstr_w(bstr));
 346     SysFreeString(bstr);
 347
 348     hr = ITaskFolder_GetFolder(subfolder, bslash, &subfolder2);
 349     ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME), "expected ERROR_INVALID_NAME, got %#lx\n", hr);
 350
 351     hr = ITaskFolder_GetFolder(subfolder, NULL, &subfolder2);
 352     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#lx\n", hr);
 353
 354     hr = ITaskFolder_GetFolder(subfolder, empty, &subfolder2);
 355     ok(hr == S_OK, "GetFolder error %#lx\n", hr);
 356     hr = ITaskFolder_get_Name(subfolder2, &bstr);
 357     ok (hr == S_OK, "get_Name error %#lx\n", hr);
 358     ok(!lstrcmpW(bstr, Wine+1), "expected Wine, got %s\n", wine_dbgstr_w(bstr));
 359     SysFreeString(bstr);
 360     hr = ITaskFolder_get_Path(subfolder2, &bstr);
 361     ok(hr == S_OK, "get_Path error %#lx\n", hr);
 362     ok(!lstrcmpW(bstr, Wine+1), "expected Wine, got %s\n", wine_dbgstr_w(bstr));
 363     SysFreeString(bstr);
 364     ITaskFolder_Release(subfolder2);
 365
 366     hr = ITaskFolder_GetFolder(subfolder, Folder1_Folder2, &subfolder2);
 367     ok(hr == S_OK, "GetFolder error %#lx\n", hr);
 368     hr = ITaskFolder_get_Name(subfolder2, &bstr);
 369     ok (hr == S_OK, "get_Name error %#lx\n", hr);
 370     ok(!lstrcmpW(bstr, L"Folder2"), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
 371     SysFreeString(bstr);
 372     hr = ITaskFolder_get_Path(subfolder2, &bstr);
 373     ok(hr == S_OK, "get_Path error %#lx\n", hr);
 374     ok(!lstrcmpW(bstr, Wine_Folder1_Folder2+1), "expected Wine\\Folder1\\Folder2, got %s\n", wine_dbgstr_w(bstr));
 375     SysFreeString(bstr);
 376     ITaskFolder_Release(subfolder2);
 377
 378     hr = ITaskFolder_GetFolder(subfolder, Folder1_Folder2+1, &subfolder2);
 379     ok(hr == S_OK, "GetFolder error %#lx\n", hr);
 380
 381     hr = ITaskFolder_get_Name(subfolder2, &bstr);
 382     ok (hr == S_OK, "get_Name error %#lx\n", hr);
 383     ok(!lstrcmpW(bstr, L"Folder2"), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
 384     SysFreeString(bstr);
 385     hr = ITaskFolder_get_Path(subfolder2, &bstr);
 386     ok(hr == S_OK, "get_Path error %#lx\n", hr);
 387     ok(!lstrcmpW(bstr, Wine_Folder1_Folder2+1), "expected Wine\\Folder1\\Folder2, got %s\n", wine_dbgstr_w(bstr));
 388     SysFreeString(bstr);
 389     ITaskFolder_Release(subfolder2);
 390
 391     ITaskFolder_Release(subfolder);
 392
 393     hr = ITaskFolder_DeleteFolder(folder, Wine, 0);
 394     ok(hr == HRESULT_FROM_WIN32(ERROR_DIR_NOT_EMPTY), "expected ERROR_DIR_NOT_EMPTY, got %#lx\n", hr);
 395
 396     hr = ITaskFolder_DeleteFolder(folder, Wine_Folder1_Folder2, 0);
 397     ok(hr == S_OK, "DeleteFolder error %#lx\n", hr);
 398     hr = ITaskFolder_DeleteFolder(folder, Wine_Folder1+1, 0);
 399     ok(hr == S_OK, "DeleteFolder error %#lx\n", hr);
 400     hr = ITaskFolder_DeleteFolder(folder, Wine+1, 0);
 401     ok(hr == S_OK, "DeleteFolder error %#lx\n", hr);
 402
 403     hr = ITaskFolder_DeleteFolder(folder, Wine, 0);
 404     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) || hr == S_OK /* win7 */, "expected ERROR_FILE_NOT_FOUND, got %#lx\n", hr);
 405
 406     hr = ITaskFolder_DeleteFolder(folder, NULL, 0);
 407     ok(hr == E_ACCESSDENIED || hr == E_INVALIDARG /* Vista */, "expected E_ACCESSDENIED, got %#lx\n", hr);
 408
 409     hr = ITaskFolder_DeleteFolder(folder, empty, 0);
 410     ok(hr == E_ACCESSDENIED || hr == E_INVALIDARG /* Vista */, "expected E_ACCESSDENIED, got %#lx\n", hr);
 411
 412     hr = ITaskFolder_DeleteFolder(folder, slash, 0);
 413     todo_wine
 414     ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME), "expected ERROR_INVALID_NAME, got %#lx\n", hr);
 415
 416  cleanup:
 417     ITaskFolder_Release(folder);
 418     ITaskService_Release(service);
 419 }
 420
 421 static void set_var(int vt, VARIANT *var, LONG val)
 422 {
 423     V_VT(var) = vt;
 424
 425     switch(vt)
 426     {
 427     case VT_I1:
 428     case VT_UI1:
 429         V_UI1(var) = (BYTE)val;
 430         break;
 431
 432     case VT_I2:
 433     case VT_UI2:
 434         V_UI2(var) = (USHORT)val;
 435         break;
 436
 437     case VT_I4:
 438     case VT_UI4:
 439         V_UI4(var) = val;
 440         break;
 441
 442     case VT_I8:
 443     case VT_UI8:
 444         V_UI8(var) = val;
 445         break;
 446
 447     case VT_INT:
 448     case VT_UINT:
 449         V_UINT(var) = val;
 450         break;
 451
 452     default:
 453         assert(0);
 454         break;
 455     }
 456 }
 457
 458 static void test_FolderCollection(void)
 459 {
 460     static WCHAR Wine[] = L"\\Wine";
 461     static WCHAR Wine_Folder1[] = L"\\Wine\\Folder1";
 462     static WCHAR Wine_Folder2[] = L"\\Wine\\Folder2";
 463     static WCHAR Wine_Folder3[] = L"\\Wine\\Folder3";
 464     HRESULT hr;
 465     BSTR bstr;
 466     VARIANT v_null, var[3];
 467     ITaskService *service;
 468     ITaskFolder *root, *folder, *subfolder;
 469     ITaskFolderCollection *folders;
 470     IUnknown *unknown;
 471     IEnumVARIANT *enumvar;
 472     ULONG count, i;
 473     BOOL is_first;
 474     VARIANT idx;
 475     static const int vt[] = { VT_I1, VT_I2, VT_I4, VT_I8, VT_UI1, VT_UI2, VT_UI4, VT_UI8, VT_INT, VT_UINT };
 476
 477     if (!is_process_elevated() && !is_win8_plus())
 478     {
 479         win_skip("Skipping ITaskFolderCollection tests because deleting folders requires elevated privileges on Windows 7\n");
 480         return;
 481     }
 482
 483     hr = CoCreateInstance(&CLSID_TaskScheduler, NULL, CLSCTX_INPROC_SERVER, &IID_ITaskService, (void **)&service);
 484     if (hr != S_OK)
 485     {
 486         win_skip("CoCreateInstance(CLSID_TaskScheduler) error %#lx\n", hr);
 487         return;
 488     }
 489
 490     V_VT(&v_null) = VT_NULL;
 491
 492     hr = ITaskService_Connect(service, v_null, v_null, v_null, v_null);
 493     ok(hr == S_OK, "Connect error %#lx\n", hr);
 494
 495     hr = ITaskService_GetFolder(service, NULL, &root);
 496     ok(hr == S_OK, "GetFolder error %#lx\n", hr);
 497
 498     /* Just in case something was left from previous runs */
 499     ITaskFolder_DeleteFolder(root, Wine_Folder1, 0);
 500     ITaskFolder_DeleteFolder(root, Wine_Folder2, 0);
 501     ITaskFolder_DeleteFolder(root, Wine_Folder3, 0);
 502     ITaskFolder_DeleteFolder(root, Wine, 0);
 503
 504     hr = ITaskFolder_CreateFolder(root, Wine_Folder1, v_null, &subfolder);
 505     ok(hr == S_OK, "CreateFolder error %#lx\n", hr);
 506     ITaskFolder_Release(subfolder);
 507
 508     hr = ITaskFolder_CreateFolder(root, Wine_Folder2, v_null, &subfolder);
 509     ok(hr == S_OK, "CreateFolder error %#lx\n", hr);
 510     ITaskFolder_Release(subfolder);
 511
 512     hr = ITaskFolder_GetFolder(root, Wine, &folder);
 513     ok(hr == S_OK, "GetFolder error %#lx\n", hr);
 514
 515     hr = ITaskFolder_GetFolders(folder, 0, NULL);
 516     ok (hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
 517
 518     hr = ITaskFolder_GetFolders(folder, 0, &folders);
 519     ok(hr == S_OK, "GetFolders error %#lx\n", hr);
 520
 521     ITaskFolder_Release(folder);
 522
 523     hr = ITaskFolderCollection_get_Count(folders, NULL);
 524     ok (hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
 525
 526     count = 0;
 527     hr = ITaskFolderCollection_get_Count(folders, (LONG *)&count);
 528     ok(hr == S_OK, "get_Count error %#lx\n", hr);
 529     ok(count == 2, "expected 2, got %ld\n", count);
 530
 531     hr = ITaskFolder_CreateFolder(root, Wine_Folder3, v_null, &subfolder);
 532     ok(hr == S_OK, "CreateFolder error %#lx\n", hr);
 533     ITaskFolder_Release(subfolder);
 534
 535     count = 0;
 536     hr = ITaskFolderCollection_get_Count(folders, (LONG *)&count);
 537     ok(hr == S_OK, "get_Count error %#lx\n", hr);
 538     ok(count == 2, "expected 2, got %ld\n", count);
 539
 540     set_var(VT_INT, &idx, 0);
 541     hr = ITaskFolderCollection_get_Item(folders, idx, NULL);
 542     ok (hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
 543
 544     for (i = 0; i < ARRAY_SIZE(vt); i++)
 545     {
 546         set_var(vt[i], &idx, 1);
 547         hr = ITaskFolderCollection_get_Item(folders, idx, &subfolder);
 548         ok(hr == S_OK, "get_Item(vt = %d) error %#lx\n", vt[i], hr);
 549         ITaskFolder_Release(subfolder);
 550     }
 551
 552     for (i = 0; i <= count; i++)
 553     {
 554         V_VT(&idx) = VT_I4;
 555         V_UI4(&idx) = i;
 556         hr = ITaskFolderCollection_get_Item(folders, idx, &subfolder);
 557         if (i == 0)
 558         {
 559             ok (hr == E_INVALIDARG, "expected E_INVALIDARG, got %#lx\n", hr);
 560             continue;
 561         }
 562         ok(hr == S_OK, "get_Item error %#lx\n", hr);
 563
 564         hr = ITaskFolder_get_Path(subfolder, &bstr);
 565         ok(hr == S_OK, "get_Path error %#lx\n", hr);
 566         is_first = !lstrcmpW(bstr, Wine_Folder1);
 567         if (is_first)
 568             ok(!lstrcmpW(bstr, Wine_Folder1), "expected \\Wine\\Folder1, got %s\n", wine_dbgstr_w(bstr));
 569         else
 570             ok(!lstrcmpW(bstr, Wine_Folder2), "expected \\Wine\\Folder2, got %s\n", wine_dbgstr_w(bstr));
 571         SysFreeString(bstr);
 572
 573         hr = ITaskFolder_get_Name(subfolder, &bstr);
 574         ok(hr == S_OK, "get_Name error %#lx\n", hr);
 575         if (is_first)
 576             ok(!lstrcmpW(bstr, L"Folder1"), "expected Folder1, got %s\n", wine_dbgstr_w(bstr));
 577         else
 578             ok(!lstrcmpW(bstr, L"Folder2"), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
 579
 580         ITaskFolder_Release(subfolder);
 581
 582         V_VT(&idx) = VT_BSTR;
 583         V_BSTR(&idx) = bstr;
 584         hr = ITaskFolderCollection_get_Item(folders, idx, &subfolder);
 585         ok(hr == S_OK, "get_Item error %#lx\n", hr);
 586         SysFreeString(bstr);
 587
 588         hr = ITaskFolder_get_Path(subfolder, &bstr);
 589         ok(hr == S_OK, "get_Path error %#lx\n", hr);
 590         if (is_first)
 591             ok(!lstrcmpW(bstr, Wine_Folder1), "expected \\Wine\\Folder1, got %s\n", wine_dbgstr_w(bstr));
 592         else
 593             ok(!lstrcmpW(bstr, Wine_Folder2), "expected \\Wine\\Folder2, got %s\n", wine_dbgstr_w(bstr));
 594         SysFreeString(bstr);
 595
 596         hr = ITaskFolder_get_Name(subfolder, &bstr);
 597         ok(hr == S_OK, "get_Name error %#lx\n", hr);
 598         if (is_first)
 599             ok(!lstrcmpW(bstr, L"Folder1"), "expected Folder1, got %s\n", wine_dbgstr_w(bstr));
 600         else
 601             ok(!lstrcmpW(bstr, L"Folder2"), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
 602         SysFreeString(bstr);
 603
 604         ITaskFolder_Release(subfolder);
 605     }
 606
 607     V_VT(&idx) = VT_I4;
 608     V_UI4(&idx) = 3;
 609     hr = ITaskFolderCollection_get_Item(folders, idx, &subfolder);
 610     ok (hr == E_INVALIDARG, "expected E_INVALIDARG, got %#lx\n", hr);
 611
 612     hr = ITaskFolderCollection_QueryInterface(folders, &IID_IEnumVARIANT, (void **)&enumvar);
 613     ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#lx\n", hr);
 614     hr = ITaskFolderCollection_QueryInterface(folders, &IID_IEnumUnknown, (void **)&enumvar);
 615     ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#lx\n", hr);
 616
 617     hr = ITaskFolderCollection_get__NewEnum(folders, NULL);
 618     ok (hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
 619
 620     hr = ITaskFolderCollection_get__NewEnum(folders, &unknown);
 621     ok(hr == S_OK, "get__NewEnum error %#lx\n", hr);
 622     hr = IUnknown_QueryInterface(unknown, &IID_IEnumUnknown, (void **)&enumvar);
 623     ok(hr == E_NOINTERFACE, "expected E_NOINTERFACE, got %#lx\n", hr);
 624     hr = IUnknown_QueryInterface(unknown, &IID_IEnumVARIANT, (void **)&enumvar);
 625     ok(hr == S_OK, "QueryInterface error %#lx\n", hr);
 626     IEnumVARIANT_Release(enumvar);
 627
 628     hr = IUnknown_QueryInterface(unknown, &IID_IUnknown, (void **)&enumvar);
 629     ok(hr == S_OK, "QueryInterface error %#lx\n", hr);
 630     IUnknown_Release(unknown);
 631
 632     hr = IEnumVARIANT_Skip(enumvar, 0);
 633     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
 634     hr = IEnumVARIANT_Skip(enumvar, 2);
 635     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
 636     hr = IEnumVARIANT_Skip(enumvar, 1);
 637     ok(hr == S_FALSE, "expected S_FALSE, got %#lx\n", hr);
 638
 639     hr = IEnumVARIANT_Reset(enumvar);
 640     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
 641
 642     count = -1;
 643     hr = IEnumVARIANT_Next(enumvar, 1, NULL, &count);
 644     ok(hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
 645
 646     memset(var, 0, sizeof(var));
 647     count = -1;
 648     hr = IEnumVARIANT_Next(enumvar, 1, var, &count);
 649     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
 650     ok(count == 1, "expected 1, got %ld\n", count);
 651     hr = ITaskFolder_get_Path((ITaskFolder *)V_DISPATCH(&var[0]), &bstr);
 652     ok(hr == S_OK, "get_Path error %#lx\n", hr);
 653     is_first = !lstrcmpW(bstr, Wine_Folder1);
 654     if (is_first)
 655         ok(!lstrcmpW(bstr, Wine_Folder1), "expected \\Wine\\Folder1, got %s\n", wine_dbgstr_w(bstr));
 656     else
 657         ok(!lstrcmpW(bstr, Wine_Folder2), "expected \\Wine\\Folder2, got %s\n", wine_dbgstr_w(bstr));
 658     SysFreeString(bstr);
 659     hr = ITaskFolder_get_Name((ITaskFolder *)V_DISPATCH(&var[0]), &bstr);
 660     ok(hr == S_OK, "get_Name error %#lx\n", hr);
 661     if (is_first)
 662         ok(!lstrcmpW(bstr, L"Folder1"), "expected Folder1, got %s\n", wine_dbgstr_w(bstr));
 663     else
 664         ok(!lstrcmpW(bstr, L"Folder2"), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
 665     SysFreeString(bstr);
 666     IDispatch_Release(V_DISPATCH(&var[0]));
 667
 668     memset(var, 0, sizeof(var));
 669     count = -1;
 670     hr = IEnumVARIANT_Next(enumvar, 1, var, &count);
 671     ok(hr == S_FALSE, "expected S_FALSE, got %#lx\n", hr);
 672     ok(count == 0, "expected 0, got %ld\n", count);
 673
 674     count = -1;
 675     hr = IEnumVARIANT_Next(enumvar, 1, NULL, &count);
 676     ok(hr == S_FALSE, "expected S_FALSE, got %#lx\n", hr);
 677     ok(count == 0, "expected 0, got %ld\n", count);
 678
 679     hr = IEnumVARIANT_Reset(enumvar);
 680     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
 681
 682     memset(var, 0, sizeof(var));
 683     count = -1;
 684     hr = IEnumVARIANT_Next(enumvar, 3, var, &count);
 685     ok(hr == S_FALSE, "expected S_FALSE, got %#lx\n", hr);
 686     ok(count == 2, "expected 2, got %ld\n", count);
 687     ok(V_VT(&var[0]) == VT_DISPATCH, "expected VT_DISPATCH, got %d\n", V_VT(&var[0]));
 688     ok(V_VT(&var[1]) == VT_DISPATCH, "expected VT_DISPATCH, got %d\n", V_VT(&var[1]));
 689     IEnumVARIANT_Release(enumvar);
 690
 691     for (i = 0; i < count; i++)
 692     {
 693         hr = IDispatch_QueryInterface(V_DISPATCH(&var[i]), &IID_ITaskFolder, (void **)&subfolder);
 694         ok(hr == S_OK, "QueryInterface error %#lx\n", hr);
 695
 696         hr = ITaskFolder_get_Path(subfolder, &bstr);
 697         ok(hr == S_OK, "get_Path error %#lx\n", hr);
 698         is_first = !lstrcmpW(bstr, Wine_Folder1);
 699         if (is_first)
 700             ok(!lstrcmpW(bstr, Wine_Folder1), "expected \\Wine\\Folder1, got %s\n", wine_dbgstr_w(bstr));
 701         else
 702             ok(!lstrcmpW(bstr, Wine_Folder2), "expected \\Wine\\Folder2, got %s\n", wine_dbgstr_w(bstr));
 703         SysFreeString(bstr);
 704
 705         hr = ITaskFolder_get_Name(subfolder, &bstr);
 706         ok(hr == S_OK, "get_Name error %#lx\n", hr);
 707         if (is_first)
 708             ok(!lstrcmpW(bstr, L"Folder1"), "expected Folder1, got %s\n", wine_dbgstr_w(bstr));
 709         else
 710             ok(!lstrcmpW(bstr, L"Folder2"), "expected Folder2, got %s\n", wine_dbgstr_w(bstr));
 711         SysFreeString(bstr);
 712
 713         ITaskFolder_Release(subfolder);
 714     }
 715
 716     IDispatch_Release(V_DISPATCH(&var[0]));
 717     IDispatch_Release(V_DISPATCH(&var[1]));
 718
 719     ITaskFolderCollection_Release(folders);
 720
 721     hr = ITaskFolder_DeleteFolder(root, Wine_Folder1, 0);
 722     ok(hr == S_OK, "DeleteFolder error %#lx\n", hr);
 723     hr = ITaskFolder_DeleteFolder(root, Wine_Folder2, 0);
 724     ok(hr == S_OK, "DeleteFolder error %#lx\n", hr);
 725     hr = ITaskFolder_DeleteFolder(root, Wine_Folder3, 0);
 726     ok(hr == S_OK, "DeleteFolder error %#lx\n", hr);
 727     hr = ITaskFolder_DeleteFolder(root, Wine, 0);
 728     ok(hr == S_OK, "DeleteFolder error %#lx\n", hr);
 729
 730     ITaskFolder_Release(root);
 731     ITaskService_Release(service);
 732 }
 733
 734 static void test_GetTask(void)
 735 {
 736     static WCHAR Wine[] = L"\\Wine";
 737     static WCHAR Wine_Task1[] = L"\\Wine\\Task1";
 738     static WCHAR Wine_Task2[] = L"\\Wine\\Task2";
 739     static WCHAR Task1[] = L"Task1";
 740     static WCHAR Task2[] = L"Task2";
 741     static WCHAR xml1[] =
 742         L"<?xml version=\"1.0\"?>\n"
 743         "<Task xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
 744         "  <RegistrationInfo>\n"
 745         "    <Description>\"Task1\"</Description>\n"
 746         "  </RegistrationInfo>\n"
 747         "  <Settings>\n"
 748         "    <Enabled>false</Enabled>\n"
 749         "    <Hidden>false</Hidden>\n"
 750         "  </Settings>\n"
 751         "  <Actions>\n"
 752         "    <Exec>\n"
 753         "      <Command>\"task1.exe\"</Command>\n"
 754         "    </Exec>\n"
 755         "  </Actions>\n"
 756         "</Task>\n";
 757     static WCHAR xml2[] =
 758         L"<?xml version=\"1.0\"?>\n"
 759         "<Task xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
 760         "  <RegistrationInfo>\n"
 761         "    <Description>\"Task2\"</Description>\n"
 762         "  </RegistrationInfo>\n"
 763         "  <Settings>\n"
 764         "    <Enabled>true</Enabled>\n"
 765         "    <Hidden>true</Hidden>\n"
 766         "  </Settings>\n"
 767         "  <Actions>\n"
 768         "    <Exec>\n"
 769         "      <Command>\"task2.exe\"</Command>\n"
 770         "    </Exec>\n"
 771         "  </Actions>\n"
 772         "</Task>\n";
 773     static const struct
 774     {
 775         DWORD flags, hr;
 776     } create_new_task[] =
 777     {
 778         { 0, S_OK },
 779         { TASK_CREATE, S_OK },
 780         { TASK_UPDATE, __HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) },
 781         { TASK_CREATE | TASK_UPDATE, S_OK }
 782     };
 783     static const struct
 784     {
 785         DWORD flags, hr;
 786     } open_existing_task[] =
 787     {
 788         { 0, __HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS) },
 789         { TASK_CREATE, __HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS) },
 790         { TASK_UPDATE, S_OK },
 791         { TASK_CREATE | TASK_UPDATE, S_OK }
 792     };
 793     HRESULT hr;
 794     BSTR bstr;
 795     TASK_STATE state;
 796     VARIANT_BOOL vbool;
 797     VARIANT v_null;
 798     ITaskService *service;
 799     ITaskFolder *root, *folder;
 800     IRegisteredTask *task1, *task2;
 801     DATE date;
 802     IID iid;
 803     int i;
 804
 805     if (!is_process_elevated() && !is_win8_plus())
 806     {
 807         win_skip("Skipping task creation tests because deleting anything requires elevated privileges on Windows 7\n");
 808         return;
 809     }
 810
 811     hr = CoCreateInstance(&CLSID_TaskScheduler, NULL, CLSCTX_INPROC_SERVER, &IID_ITaskService, (void **)&service);
 812     if (hr != S_OK)
 813     {
 814         win_skip("CoCreateInstance(CLSID_TaskScheduler) error %#lx\n", hr);
 815         return;
 816     }
 817
 818     V_VT(&v_null) = VT_NULL;
 819
 820     hr = ITaskService_Connect(service, v_null, v_null, v_null, v_null);
 821     ok(hr == S_OK, "Connect error %#lx\n", hr);
 822
 823     hr = ITaskService_GetFolder(service, NULL, &root);
 824     ok(hr == S_OK, "GetFolder error %#lx\n", hr);
 825
 826     /* Just in case something was left from previous runs */
 827     ITaskFolder_DeleteTask(root, Wine_Task1, 0);
 828     ITaskFolder_DeleteTask(root, Wine_Task2, 0);
 829     ITaskFolder_DeleteFolder(root, Wine, 0);
 830
 831     hr = ITaskFolder_GetTask(root, Wine_Task1, &task1);
 832     ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) || hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) /* win7 */,
 833        "expected ERROR_PATH_NOT_FOUND, got %#lx\n", hr);
 834
 835     hr = ITaskFolder_RegisterTask(root, Wine, xml1, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, NULL);
 836     ok(hr == S_OK, "RegisterTask error %#lx\n", hr);
 837
 838     /* Without elevated privileges this fails on Windows 7 */
 839     hr = ITaskFolder_DeleteTask(root, Wine, 0);
 840     ok(hr == S_OK, "DeleteTask error %#lx\n", hr);
 841
 842     hr = ITaskFolder_CreateFolder(root, Wine, v_null, &folder);
 843     ok(hr == S_OK, "CreateFolder error %#lx\n", hr);
 844
 845     hr = ITaskFolder_RegisterTask(root, Wine, xml1, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, NULL);
 846     todo_wine
 847     ok(hr == HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED) || broken(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS)) /* Vista */, "expected ERROR_ACCESS_DENIED, got %#lx\n", hr);
 848
 849     /* Delete the folder and recreate it to prevent a crash on w1064v1507 */
 850     hr = ITaskFolder_DeleteFolder(root, Wine, 0);
 851     todo_wine
 852     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) || broken(hr == S_OK) /* w1064v1507 */,
 853        "expected ERROR_FILE_NOT_FOUND, got %#lx\n", hr);
 854     ITaskFolder_Release(folder);
 855
 856     hr = ITaskFolder_CreateFolder(root, Wine, v_null, &folder);
 857     ok(hr == S_OK, "CreateFolder error %#lx\n", hr);
 858
 859     hr = ITaskFolder_GetTask(root, Wine, &task1);
 860     ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) || hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) /* win7 */,
 861        "expected ERROR_PATH_NOT_FOUND, got %#lx\n", hr);
 862
 863     for (i = 0; i < ARRAY_SIZE(create_new_task); i++)
 864     {
 865         winetest_push_context("%d", i);
 866         hr = ITaskFolder_RegisterTask(root, Wine_Task1, xml1, create_new_task[i].flags, v_null, v_null, TASK_LOGON_NONE, v_null, &task1);
 867         ok(hr == create_new_task[i].hr, "expected %#lx, got %#lx\n", create_new_task[i].hr, hr);
 868         if (hr == S_OK)
 869         {
 870             hr = ITaskFolder_DeleteTask(root, Wine_Task1, 0);
 871             ok(hr == S_OK, "DeleteTask error %#lx\n", hr);
 872             IRegisteredTask_Release(task1);
 873         }
 874         winetest_pop_context();
 875     }
 876
 877     hr = ITaskFolder_RegisterTask(root, Wine_Task1, NULL, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, NULL);
 878     ok(hr == HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER), "expected RPC_X_NULL_REF_POINTER, got %#lx\n", hr);
 879
 880     hr = ITaskFolder_RegisterTask(root, Wine, xml1, TASK_VALIDATE_ONLY, v_null, v_null, TASK_LOGON_NONE, v_null, NULL);
 881     ok(hr == S_OK, "RegisterTask error %#lx\n", hr);
 882
 883     hr = ITaskFolder_RegisterTask(root, Wine_Task1, xml1, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, NULL);
 884     ok(hr == S_OK, "RegisterTask error %#lx\n", hr);
 885
 886     hr = ITaskFolder_RegisterTask(root, Wine_Task1, xml1, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, &task1);
 887     ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#lx\n", hr);
 888
 889     hr = ITaskFolder_RegisterTask(root, Wine_Task1, xml1, 0, v_null, v_null, TASK_LOGON_NONE, v_null, NULL);
 890     ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#lx\n", hr);
 891
 892     hr = ITaskFolder_RegisterTask(root, Wine_Task1, xml1, TASK_CREATE_OR_UPDATE, v_null, v_null, TASK_LOGON_NONE, v_null, &task1);
 893     ok(hr == S_OK, "RegisterTask error %#lx\n", hr);
 894
 895     for (i = 0; i < ARRAY_SIZE(open_existing_task); i++)
 896     {
 897         hr = ITaskFolder_RegisterTask(root, Wine_Task1, xml1, open_existing_task[i].flags, v_null, v_null, TASK_LOGON_NONE, v_null, &task2);
 898         ok(hr == open_existing_task[i].hr, "%d: expected %#lx, got %#lx\n", i, open_existing_task[i].hr, hr);
 899         if (hr == S_OK)
 900             IRegisteredTask_Release(task2);
 901     }
 902
 903     hr = IRegisteredTask_get_Name(task1, NULL);
 904     ok(hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
 905
 906     hr = IRegisteredTask_get_Name(task1, &bstr);
 907     ok(hr == S_OK, "get_Name error %#lx\n", hr);
 908     ok(!lstrcmpW(bstr, Task1), "expected Task1, got %s\n", wine_dbgstr_w(bstr));
 909     SysFreeString(bstr);
 910     hr = IRegisteredTask_get_Path(task1, &bstr);
 911     ok(hr == S_OK, "get_Path error %#lx\n", hr);
 912     ok(!lstrcmpW(bstr, Wine_Task1), "expected \\Wine\\Task1, got %s\n", wine_dbgstr_w(bstr));
 913     SysFreeString(bstr);
 914     hr = IRegisteredTask_get_State(task1, &state);
 915     ok(hr == S_OK, "get_State error %#lx\n", hr);
 916     ok(state == TASK_STATE_DISABLED, "expected TASK_STATE_DISABLED, got %d\n", state);
 917     hr = IRegisteredTask_get_Enabled(task1, &vbool);
 918     ok(hr == S_OK, "get_Enabled error %#lx\n", hr);
 919     ok(vbool == VARIANT_FALSE, "expected VARIANT_FALSE, got %d\n", vbool);
 920
 921     hr = IRegisteredTask_get_LastRunTime(task1, &date);
 922     ok(hr == SCHED_S_TASK_HAS_NOT_RUN, "got %#lx\n", hr);
 923
 924     IRegisteredTask_Release(task1);
 925
 926     hr = ITaskFolder_RegisterTask(folder, Task1, xml1, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, &task2);
 927     ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#lx\n", hr);
 928
 929     hr = ITaskFolder_RegisterTask(folder, Task2, xml2, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, &task2);
 930     ok(hr == S_OK, "RegisterTask error %#lx\n", hr);
 931
 932     hr = IRegisteredTask_get_Name(task2, &bstr);
 933     ok(hr == S_OK, "get_Name error %#lx\n", hr);
 934     ok(!lstrcmpW(bstr, Task2), "expected Task2, got %s\n", wine_dbgstr_w(bstr));
 935     SysFreeString(bstr);
 936     hr = IRegisteredTask_get_Path(task2, &bstr);
 937     ok(hr == S_OK, "get_Path error %#lx\n", hr);
 938     ok(!lstrcmpW(bstr, Wine_Task2), "expected \\Wine\\Task2, got %s\n", wine_dbgstr_w(bstr));
 939     SysFreeString(bstr);
 940     hr = IRegisteredTask_get_State(task2, &state);
 941     ok(hr == S_OK, "get_State error %#lx\n", hr);
 942     ok(state == TASK_STATE_READY, "expected TASK_STATE_READY, got %d\n", state);
 943     hr = IRegisteredTask_get_Enabled(task2, &vbool);
 944     ok(hr == S_OK, "get_Enabled error %#lx\n", hr);
 945     ok(vbool == VARIANT_TRUE, "expected VARIANT_TRUE, got %d\n", vbool);
 946
 947     hr = IRegisteredTask_get_LastRunTime(task2, &date);
 948     ok(hr == SCHED_S_TASK_HAS_NOT_RUN, "got %#lx\n", hr);
 949
 950     IRegisteredTask_Release(task2);
 951
 952     hr = ITaskFolder_GetTask(root, NULL, &task1);
 953     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#lx\n", hr);
 954
 955     hr = ITaskFolder_GetTask(root, Wine_Task1, NULL);
 956     ok(hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
 957
 958     hr = ITaskFolder_GetTask(root, Wine_Task1, &task1);
 959     ok(hr == S_OK, "GetTask error %#lx\n", hr);
 960
 961     hr = IRegisteredTask_get_Name(task1, &bstr);
 962     ok(hr == S_OK, "get_Name error %#lx\n", hr);
 963     ok(!lstrcmpW(bstr, Task1), "expected Task1, got %s\n", wine_dbgstr_w(bstr));
 964     SysFreeString(bstr);
 965     hr = IRegisteredTask_get_Path(task1, &bstr);
 966     ok(hr == S_OK, "get_Path error %#lx\n", hr);
 967     ok(!lstrcmpW(bstr, Wine_Task1), "expected \\Wine\\Task1, got %s\n", wine_dbgstr_w(bstr));
 968     SysFreeString(bstr);
 969     hr = IRegisteredTask_get_State(task1, &state);
 970     ok(hr == S_OK, "get_State error %#lx\n", hr);
 971     ok(state == TASK_STATE_DISABLED, "expected TASK_STATE_DISABLED, got %d\n", state);
 972     hr = IRegisteredTask_get_Enabled(task1, &vbool);
 973     ok(hr == S_OK, "get_Enabled error %#lx\n", hr);
 974     ok(vbool == VARIANT_FALSE, "expected VARIANT_FALSE, got %d\n", vbool);
 975
 976     hr = IRegisteredTask_get_LastRunTime(task1, &date);
 977     ok(hr == SCHED_S_TASK_HAS_NOT_RUN, "got %#lx\n", hr);
 978
 979     hr = IRegisteredTask_put_Enabled(task1, VARIANT_TRUE);
 980     ok(hr == S_OK, "put_Enabled error %#lx\n", hr);
 981     hr = IRegisteredTask_get_State(task1, &state);
 982     ok(hr == S_OK, "get_State error %#lx\n", hr);
 983     todo_wine
 984     ok(state == TASK_STATE_READY, "expected TASK_STATE_READY, got %d\n", state);
 985     hr = IRegisteredTask_get_Enabled(task1, &vbool);
 986     ok(hr == S_OK, "get_Enabled error %#lx\n", hr);
 987     todo_wine
 988     ok(vbool == VARIANT_TRUE, "expected VARIANT_TRUE, got %d\n", vbool);
 989
 990     hr = IRegisteredTask_get_LastRunTime(task1, &date);
 991     ok(hr == SCHED_S_TASK_HAS_NOT_RUN, "got %#lx\n", hr);
 992
 993     IRegisteredTask_Release(task1);
 994
 995     hr = ITaskFolder_GetTask(folder, Task2, &task2);
 996     ok(hr == S_OK, "GetTask error %#lx\n", hr);
 997
 998     hr = IRegisteredTask_get_Name(task2, &bstr);
 999     ok(hr == S_OK, "get_Name error %#lx\n", hr);
1000     ok(!lstrcmpW(bstr, Task2), "expected Task2, got %s\n", wine_dbgstr_w(bstr));
1001     SysFreeString(bstr);
1002     hr = IRegisteredTask_get_Path(task2, &bstr);
1003     ok(hr == S_OK, "get_Path error %#lx\n", hr);
1004     ok(!lstrcmpW(bstr, Wine_Task2), "expected \\Wine\\Task2, got %s\n", wine_dbgstr_w(bstr));
1005     SysFreeString(bstr);
1006     hr = IRegisteredTask_get_State(task2, &state);
1007     ok(hr == S_OK, "get_State error %#lx\n", hr);
1008     ok(state == TASK_STATE_READY, "expected TASK_STATE_READY, got %d\n", state);
1009     hr = IRegisteredTask_get_Enabled(task2, &vbool);
1010     ok(hr == S_OK, "get_Enabled error %#lx\n", hr);
1011     ok(vbool == VARIANT_TRUE, "expected VARIANT_TRUE, got %d\n", vbool);
1012
1013     hr = IRegisteredTask_get_LastRunTime(task2, &date);
1014     ok(hr == SCHED_S_TASK_HAS_NOT_RUN, "got %#lx\n", hr);
1015
1016     hr = IRegisteredTask_get_State(task2, NULL);
1017     ok(hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
1018     hr = IRegisteredTask_get_Enabled(task2, NULL);
1019     ok(hr == E_POINTER, "expected E_POINTER, got %#lx\n", hr);
1020
1021     IRegisteredTask_Release(task2);
1022
1023     hr = ITaskFolder_DeleteTask(folder, NULL, 0);
1024     todo_wine
1025     ok(hr == HRESULT_FROM_WIN32(ERROR_DIR_NOT_EMPTY), "expected ERROR_DIR_NOT_EMPTY, got %#lx\n", hr);
1026
1027     hr = ITaskFolder_DeleteTask(root, Wine_Task1, 0);
1028     ok(hr == S_OK, "DeleteTask error %#lx\n", hr);
1029     hr = ITaskFolder_DeleteTask(folder, Task2, 0);
1030     ok(hr == S_OK, "DeleteTask error %#lx\n", hr);
1031
1032     hr = ITaskFolder_DeleteTask(folder, Task2, 0);
1033     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) || hr == S_OK /* win7 */, "expected ERROR_FILE_NOT_FOUND, got %#lx\n", hr);
1034
1035     hr = ITaskFolder_RegisterTask(root, NULL, xml2, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, &task1);
1036     if(hr == E_ACCESSDENIED)
1037     {
1038         skip("Access denied\n");
1039         goto no_access;
1040     }
1041     ok(hr == S_OK, "RegisterTask error %#lx\n", hr);
1042
1043     hr = IRegisteredTask_get_Name(task1, &bstr);
1044     ok(hr == S_OK, "get_Name error %#lx\n", hr);
1045     hr = IIDFromString(bstr, &iid);
1046     ok(hr == S_OK, "IIDFromString error %#lx\n", hr);
1047
1048     IRegisteredTask_Release(task1);
1049
1050     hr = ITaskFolder_DeleteTask(root, bstr, 0);
1051     ok(hr == S_OK, "DeleteTask error %#lx\n", hr);
1052     SysFreeString(bstr);
1053
1054     hr = ITaskFolder_RegisterTask(folder, NULL, xml2, TASK_CREATE, v_null, v_null, TASK_LOGON_NONE, v_null, &task1);
1055     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#lx\n", hr);
1056
1057 no_access:
1058     ITaskFolder_Release(folder);
1059
1060     hr = ITaskFolder_DeleteFolder(root, Wine, 0);
1061     ok(hr == S_OK, "DeleteFolder error %#lx\n", hr);
1062
1063     ITaskFolder_Release(root);
1064     ITaskService_Release(service);
1065 }
1066
1067 struct settings
1068 {
1069     WCHAR restart_interval[20];
1070     WCHAR execution_time_limit[20];
1071     WCHAR delete_expired_task_after[20];
1072     int restart_count;
1073     int priority;
1074     TASK_INSTANCES_POLICY policy;
1075     TASK_COMPATIBILITY compatibility;
1076     VARIANT_BOOL allow_on_demand_start;
1077     VARIANT_BOOL stop_if_going_on_batteries;
1078     VARIANT_BOOL disallow_start_if_on_batteries;
1079     VARIANT_BOOL allow_hard_terminate;
1080     VARIANT_BOOL start_when_available;
1081     VARIANT_BOOL run_only_if_network_available;
1082     VARIANT_BOOL enabled;
1083     VARIANT_BOOL hidden;
1084     VARIANT_BOOL run_only_if_idle;
1085     VARIANT_BOOL wake_to_run;
1086 };
1087
1088 /* test the version 1 compatibility settings */
1089 static void test_settings_v1(ITaskDefinition *taskdef, struct settings *test, struct settings *def)
1090 {
1091     HRESULT hr;
1092     ITaskSettings *set;
1093     int vint;
1094     VARIANT_BOOL vbool;
1095     BSTR bstr;
1096     TASK_INSTANCES_POLICY policy;
1097     TASK_COMPATIBILITY compat;
1098
1099     hr = ITaskDefinition_get_Settings(taskdef, &set);
1100     ok(hr == S_OK, "get_Settings error %#lx\n", hr);
1101
1102     hr = ITaskSettings_get_AllowDemandStart(set, &vbool);
1103     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1104     ok(vbool == def->allow_on_demand_start, "expected %d, got %d\n", def->allow_on_demand_start, vbool);
1105
1106     hr = ITaskSettings_get_RestartInterval(set, &bstr);
1107     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1108     if (!def->restart_interval[0])
1109         ok(bstr == NULL, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1110     else
1111     {
1112         ok(!lstrcmpW(bstr, def->restart_interval), "expected %s, got %s\n", wine_dbgstr_w(def->restart_interval), wine_dbgstr_w(bstr));
1113         SysFreeString(bstr);
1114     }
1115
1116     hr = ITaskSettings_get_RestartCount(set, &vint);
1117     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1118     ok(vint == def->restart_count, "expected %d, got %d\n", def->restart_count, vint);
1119
1120     hr = ITaskSettings_get_MultipleInstances(set, &policy);
1121     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1122     ok(policy == def->policy, "expected %d, got %d\n", def->policy, policy);
1123
1124     hr = ITaskSettings_get_StopIfGoingOnBatteries(set, &vbool);
1125     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1126     ok(vbool == test->stop_if_going_on_batteries, "expected %d, got %d\n", test->stop_if_going_on_batteries, vbool);
1127
1128     hr = ITaskSettings_get_DisallowStartIfOnBatteries(set, &vbool);
1129     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1130     ok(vbool == test->disallow_start_if_on_batteries, "expected %d, got %d\n", test->disallow_start_if_on_batteries, vbool);
1131
1132     hr = ITaskSettings_get_AllowHardTerminate(set, &vbool);
1133     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1134     ok(vbool == def->allow_hard_terminate, "expected %d, got %d\n", def->allow_hard_terminate, vbool);
1135
1136     hr = ITaskSettings_get_StartWhenAvailable(set, &vbool);
1137     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1138     ok(vbool == def->start_when_available, "expected %d, got %d\n", def->start_when_available, vbool);
1139
1140     hr = ITaskSettings_get_RunOnlyIfNetworkAvailable(set, &vbool);
1141     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1142     ok(vbool == def->run_only_if_network_available, "expected %d, got %d\n", def->run_only_if_network_available, vbool);
1143
1144     hr = ITaskSettings_get_ExecutionTimeLimit(set, &bstr);
1145     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1146     if (!test->execution_time_limit[0])
1147         ok(bstr == NULL, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1148     else
1149     {
1150         ok(!lstrcmpW(bstr, test->execution_time_limit), "expected %s, got %s\n", wine_dbgstr_w(test->execution_time_limit), wine_dbgstr_w(bstr));
1151         SysFreeString(bstr);
1152     }
1153
1154     hr = ITaskSettings_get_Enabled(set, &vbool);
1155     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1156     ok(vbool == test->enabled, "expected %d, got %d\n", test->enabled, vbool);
1157
1158     hr = ITaskSettings_get_DeleteExpiredTaskAfter(set, &bstr);
1159     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1160     if (!test->delete_expired_task_after[0])
1161         ok(bstr == NULL, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1162     else
1163     {
1164         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));
1165         SysFreeString(bstr);
1166     }
1167
1168     hr = ITaskSettings_get_Priority(set, &vint);
1169     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1170     ok(vint == test->priority, "expected %d, got %d\n", test->priority, vint);
1171
1172     hr = ITaskSettings_get_Compatibility(set, &compat);
1173     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1174     ok(compat == test->compatibility, "expected %d, got %d\n", test->compatibility, compat);
1175
1176     hr = ITaskSettings_get_Hidden(set, &vbool);
1177     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1178     ok(vbool == test->hidden, "expected %d, got %d\n", test->hidden, vbool);
1179
1180     hr = ITaskSettings_get_RunOnlyIfIdle(set, &vbool);
1181     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1182     ok(vbool == test->run_only_if_idle, "expected %d, got %d\n", test->run_only_if_idle, vbool);
1183
1184     hr = ITaskSettings_get_WakeToRun(set, &vbool);
1185     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1186     ok(vbool == test->wake_to_run, "expected %d, got %d\n", test->wake_to_run, vbool);
1187
1188     /* FIXME: test IIdleSettings and INetworkSettings */
1189
1190     ITaskSettings_Release(set);
1191 }
1192
1193 static void change_settings(ITaskDefinition *taskdef, struct settings *test)
1194 {
1195     HRESULT hr;
1196     ITaskSettings *set;
1197     ITriggerCollection *triggers;
1198     IPrincipal *principal;
1199     IActionCollection *actions;
1200
1201     hr = ITaskDefinition_get_Settings(taskdef, &set);
1202     ok(hr == S_OK, "get_Settings error %#lx\n", hr);
1203
1204     if (!test->restart_interval[0])
1205         hr = ITaskSettings_put_RestartInterval(set, NULL);
1206     else
1207         hr = ITaskSettings_put_RestartInterval(set, test->restart_interval);
1208     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1209
1210     hr = ITaskSettings_put_RestartCount(set, test->restart_count);
1211     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1212
1213     hr = ITaskSettings_put_MultipleInstances(set, test->policy);
1214     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1215
1216     hr = ITaskSettings_put_StopIfGoingOnBatteries(set, test->stop_if_going_on_batteries);
1217     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1218
1219     hr = ITaskSettings_put_DisallowStartIfOnBatteries(set, test->disallow_start_if_on_batteries);
1220     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1221
1222     hr = ITaskSettings_put_AllowHardTerminate(set, test->allow_hard_terminate);
1223     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1224
1225     hr = ITaskSettings_put_StartWhenAvailable(set, test->start_when_available);
1226     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1227
1228     hr = ITaskSettings_put_RunOnlyIfNetworkAvailable(set, test->run_only_if_network_available);
1229     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1230
1231     if (!test->execution_time_limit[0])
1232         hr = ITaskSettings_put_ExecutionTimeLimit(set, NULL);
1233     else
1234         hr = ITaskSettings_put_ExecutionTimeLimit(set, test->execution_time_limit);
1235     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1236
1237     hr = ITaskSettings_put_Enabled(set, test->enabled);
1238     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1239
1240     if (!test->delete_expired_task_after[0])
1241         hr = ITaskSettings_put_DeleteExpiredTaskAfter(set, NULL);
1242     else
1243         hr = ITaskSettings_put_DeleteExpiredTaskAfter(set, test->delete_expired_task_after);
1244     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1245
1246     hr = ITaskSettings_put_Priority(set, test->priority);
1247     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1248
1249     hr = ITaskSettings_put_Compatibility(set, test->compatibility);
1250     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1251
1252     hr = ITaskSettings_put_Hidden(set, test->hidden);
1253     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1254
1255     hr = ITaskSettings_put_RunOnlyIfIdle(set, test->run_only_if_idle);
1256     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1257
1258     hr = ITaskSettings_put_WakeToRun(set, test->wake_to_run);
1259     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1260
1261     hr = ITaskSettings_put_AllowDemandStart(set, test->allow_on_demand_start);
1262     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1263
1264     triggers = NULL;
1265     hr = ITaskDefinition_get_Triggers(taskdef, &triggers);
1266     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1267     ok(triggers != NULL, "triggers not set\n");
1268
1269     hr = ITaskDefinition_put_Triggers(taskdef, triggers);
1270     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1271     if (triggers) ITriggerCollection_Release(triggers);
1272
1273     principal = NULL;
1274     hr = ITaskDefinition_get_Principal(taskdef, &principal);
1275     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1276     ok(principal != NULL, "principal not set\n");
1277
1278     hr = ITaskDefinition_put_Principal(taskdef, principal);
1279     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1280     if (principal) IPrincipal_Release(principal);
1281
1282     actions = NULL;
1283     hr = ITaskDefinition_get_Actions(taskdef, &actions);
1284     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1285     ok(actions != NULL, "actions not set\n");
1286
1287     hr = ITaskDefinition_put_Actions(taskdef, actions);
1288     ok(hr == S_OK, "expected S_OK, got %#lx\n", hr);
1289     if (actions) IActionCollection_Release(actions);
1290
1291     /* FIXME: set IIdleSettings and INetworkSettings */
1292
1293     ITaskSettings_Release(set);
1294 }
1295
1296 static void test_daily_trigger(ITrigger *trigger)
1297 {
1298     static const struct
1299     {
1300         const WCHAR *str;
1301         HRESULT      hr;
1302     }
1303     start_test[] =
1304     {
1305         {L"2004-01-01T00:00:00", S_OK},
1306         {L"2004-01-01T00:00:00Z", S_OK},
1307         {L"2004-01-01T00:00:00+01:00", S_OK},
1308         {L"2004.01.01T00.00.00", S_OK},
1309         {L"9999-99-99T99:99:99", S_OK},
1310         {L"invalid", S_OK},
1311     };
1312     IDailyTrigger *daily_trigger;
1313     BSTR start_boundary;
1314     VARIANT_BOOL enabled;
1315     short interval;
1316     HRESULT hr;
1317     ULONG i;
1318
1319     hr = ITrigger_QueryInterface(trigger, &IID_IDailyTrigger, (void**)&daily_trigger);
1320     ok(hr == S_OK, "Could not get IDailyTrigger iface: %08lx\n", hr);
1321
1322     interval = -1;
1323     hr = IDailyTrigger_get_DaysInterval(daily_trigger, &interval);
1324     ok(hr == S_OK, "get_DaysInterval failed: %08lx\n", hr);
1325     ok(interval == 1, "interval = %d\n", interval);
1326
1327     hr = IDailyTrigger_put_DaysInterval(daily_trigger, -2);
1328     ok(hr == E_INVALIDARG, "put_DaysInterval failed: %08lx\n", hr);
1329     hr = IDailyTrigger_put_DaysInterval(daily_trigger, 0);
1330     ok(hr == E_INVALIDARG, "put_DaysInterval failed: %08lx\n", hr);
1331
1332     interval = -1;
1333     hr = IDailyTrigger_get_DaysInterval(daily_trigger, &interval);
1334     ok(hr == S_OK, "get_DaysInterval failed: %08lx\n", hr);
1335     ok(interval == 1, "interval = %d\n", interval);
1336
1337     hr = IDailyTrigger_put_DaysInterval(daily_trigger, 2);
1338     ok(hr == S_OK, "put_DaysInterval failed: %08lx\n", hr);
1339
1340     interval = -1;
1341     hr = IDailyTrigger_get_DaysInterval(daily_trigger, &interval);
1342     ok(hr == S_OK, "get_DaysInterval failed: %08lx\n", hr);
1343     ok(interval == 2, "interval = %d\n", interval);
1344
1345     hr = IDailyTrigger_get_StartBoundary(daily_trigger, NULL);
1346     ok(hr == E_POINTER, "get_StartBoundary failed: %08lx\n", hr);
1347
1348     start_boundary = (BSTR)0xdeadbeef;
1349     hr = IDailyTrigger_get_StartBoundary(daily_trigger, &start_boundary);
1350     ok(hr == S_OK, "get_StartBoundary failed: %08lx\n", hr);
1351     ok(start_boundary == NULL, "start_boundary not set\n");
1352
1353     for (i = 0; i < ARRAY_SIZE(start_test); i++)
1354     {
1355         winetest_push_context("%lu", i);
1356         start_boundary = SysAllocString(start_test[i].str);
1357         hr = IDailyTrigger_put_StartBoundary(daily_trigger, start_boundary);
1358         ok(hr == start_test[i].hr, "got %08lx expected %08lx\n", hr, start_test[i].hr);
1359         SysFreeString(start_boundary);
1360         if (hr == S_OK)
1361         {
1362             start_boundary = NULL;
1363             hr = IDailyTrigger_get_StartBoundary(daily_trigger, &start_boundary);
1364             ok(hr == S_OK, "got %08lx\n", hr);
1365             ok(start_boundary != NULL, "start_boundary not set\n");
1366             ok(!lstrcmpW(start_boundary, start_test[i].str), "got %s\n", wine_dbgstr_w(start_boundary));
1367             SysFreeString(start_boundary);
1368         }
1369         winetest_pop_context();
1370     }
1371
1372     hr = IDailyTrigger_put_StartBoundary(daily_trigger, NULL);
1373     ok(hr == S_OK, "put_StartBoundary failed: %08lx\n", hr);
1374
1375     hr = IDailyTrigger_get_Enabled(daily_trigger, NULL);
1376     ok(hr == E_POINTER, "get_Enabled failed: %08lx\n", hr);
1377
1378     enabled = VARIANT_FALSE;
1379     hr = IDailyTrigger_get_Enabled(daily_trigger, &enabled);
1380     ok(hr == S_OK, "get_Enabled failed: %08lx\n", hr);
1381     ok(enabled == VARIANT_TRUE, "got %d\n", enabled);
1382
1383     hr = IDailyTrigger_put_Enabled(daily_trigger, VARIANT_FALSE);
1384     ok(hr == S_OK, "put_Enabled failed: %08lx\n", hr);
1385
1386     enabled = VARIANT_TRUE;
1387     hr = IDailyTrigger_get_Enabled(daily_trigger, &enabled);
1388     ok(hr == S_OK, "get_Enabled failed: %08lx\n", hr);
1389     ok(enabled == VARIANT_FALSE, "got %d\n", enabled);
1390
1391     IDailyTrigger_Release(daily_trigger);
1392 }
1393
1394 static void test_registration_trigger(ITrigger *trigger)
1395 {
1396     IRegistrationTrigger *reg_trigger;
1397     VARIANT_BOOL enabled;
1398     HRESULT hr;
1399
1400     hr = ITrigger_QueryInterface(trigger, &IID_IRegistrationTrigger, (void**)&reg_trigger);
1401     ok(hr == S_OK, "Could not get IRegistrationTrigger iface: %08lx\n", hr);
1402
1403     enabled = VARIANT_FALSE;
1404     hr = IRegistrationTrigger_get_Enabled(reg_trigger, &enabled);
1405     ok(hr == S_OK, "get_Enabled failed: %08lx\n", hr);
1406     ok(enabled == VARIANT_TRUE, "got %d\n", enabled);
1407
1408     hr = IRegistrationTrigger_put_Enabled(reg_trigger, VARIANT_FALSE);
1409     ok(hr == S_OK, "put_Enabled failed: %08lx\n", hr);
1410
1411     enabled = VARIANT_TRUE;
1412     hr = IRegistrationTrigger_get_Enabled(reg_trigger, &enabled);
1413     ok(hr == S_OK, "get_Enabled failed: %08lx\n", hr);
1414     ok(enabled == VARIANT_FALSE, "got %d\n", enabled);
1415
1416     IRegistrationTrigger_Release(reg_trigger);
1417 }
1418
1419 static void create_action(ITaskDefinition *taskdef)
1420 {
1421     static WCHAR task1_exe[] = L"task1.exe";
1422     static WCHAR workdir[] = L"workdir";
1423     static WCHAR args[] = L"arguments";
1424     static WCHAR comment[] = L"comment";
1425     HRESULT hr;
1426     IActionCollection *actions;
1427     IAction *action;
1428     IExecAction *exec_action;
1429     TASK_ACTION_TYPE type;
1430     BSTR path, str;
1431
1432     hr = ITaskDefinition_get_Actions(taskdef, NULL);
1433     ok(hr == E_POINTER, "got %#lx\n", hr);
1434
1435     hr = ITaskDefinition_get_Actions(taskdef, &actions);
1436     ok(hr == S_OK, "get_Actions error %#lx\n", hr);
1437
1438     hr = IActionCollection_Create(actions, TASK_ACTION_EXEC, &action);
1439     ok(hr == S_OK, "Create action error %#lx\n", hr);
1440
1441     hr = IAction_QueryInterface(action, &IID_IExecAction, (void **)&exec_action);
1442     ok(hr == S_OK, "QueryInterface error %#lx\n", hr);
1443
1444     type = 0xdeadbeef;
1445     hr = IExecAction_get_Type(exec_action, &type);
1446     ok(hr == S_OK, "get_Type error %#lx\n", hr);
1447     ok(type == TASK_ACTION_EXEC, "got %u\n", type );
1448
1449     hr = IExecAction_get_Path(exec_action, NULL);
1450     ok(hr == E_POINTER, "got %#lx\n", hr);
1451
1452     path = (BSTR)0xdeadbeef;
1453     hr = IExecAction_get_Path(exec_action, &path);
1454     ok(hr == S_OK, "get_Path error %#lx\n", hr);
1455     ok(path == NULL, "path not set\n");
1456
1457     hr = IExecAction_put_Path(exec_action, NULL);
1458     ok(hr == S_OK, "put_Path error %#lx\n", hr);
1459
1460     hr = IExecAction_put_Path(exec_action, task1_exe);
1461     ok(hr == S_OK, "put_Path error %#lx\n", hr);
1462
1463     path = NULL;
1464     hr = IExecAction_get_Path(exec_action, &path);
1465     ok(hr == S_OK, "get_Path error %#lx\n", hr);
1466     ok(path != NULL, "path not set\n");
1467     ok(!lstrcmpW(path, task1_exe), "got %s\n", wine_dbgstr_w(path));
1468     SysFreeString(path);
1469
1470     hr = IExecAction_get_WorkingDirectory(exec_action, NULL);
1471     ok(hr == E_POINTER, "got %#lx\n", hr);
1472
1473     path = (BSTR)0xdeadbeef;
1474     hr = IExecAction_get_WorkingDirectory(exec_action, &path);
1475     ok(hr == S_OK, "get_WorkingDirectory error %#lx\n", hr);
1476     ok(path == NULL, "workdir not set\n");
1477
1478     hr = IExecAction_put_WorkingDirectory(exec_action, NULL);
1479     ok(hr == S_OK, "put_WorkingDirectory error %#lx\n", hr);
1480
1481     hr = IExecAction_put_WorkingDirectory(exec_action, workdir);
1482     ok(hr == S_OK, "put_WorkingDirectory error %#lx\n", hr);
1483
1484     path = NULL;
1485     hr = IExecAction_get_WorkingDirectory(exec_action, &path);
1486     ok(hr == S_OK, "get_WorkingDirectory error %#lx\n", hr);
1487     ok(path != NULL, "workdir not set\n");
1488     ok(!lstrcmpW(path, workdir), "got %s\n", wine_dbgstr_w(path));
1489     SysFreeString(path);
1490
1491     hr = IExecAction_get_Arguments(exec_action, NULL);
1492     ok(hr == E_POINTER, "got %#lx\n", hr);
1493
1494     path = (BSTR)0xdeadbeef;
1495     hr = IExecAction_get_Arguments(exec_action, &path);
1496     ok(hr == S_OK, "get_Arguments error %#lx\n", hr);
1497     ok(path == NULL, "args not set\n");
1498
1499     hr = IExecAction_put_Arguments(exec_action, NULL);
1500     ok(hr == S_OK, "put_Arguments error %#lx\n", hr);
1501
1502     hr = IExecAction_put_Arguments(exec_action, args);
1503     ok(hr == S_OK, "put_Arguments error %#lx\n", hr);
1504
1505     path = NULL;
1506     hr = IExecAction_get_Arguments(exec_action, &path);
1507     ok(hr == S_OK, "get_Arguments error %#lx\n", hr);
1508     ok(path != NULL, "args not set\n");
1509     ok(!lstrcmpW(path, args), "got %s\n", wine_dbgstr_w(path));
1510     SysFreeString(path);
1511
1512
1513     str = (BSTR)0xdeadbeef;
1514     hr = IExecAction_get_Id(exec_action, &str);
1515     ok(hr == S_OK, "get_Id error %#lx\n", hr);
1516     ok(str == NULL, "id should be NULL\n");
1517
1518     hr = IExecAction_put_Id(exec_action, NULL);
1519     ok(hr == S_OK, "put_Id error %#lx\n", hr);
1520
1521     hr = IExecAction_put_Id(exec_action, comment);
1522     ok(hr == S_OK, "put_Id error %#lx\n", hr);
1523
1524     str = NULL;
1525     hr = IExecAction_get_Id(exec_action, &str);
1526     ok(hr == S_OK, "get_Id error %#lx\n", hr);
1527     ok(str != NULL, "should not be NULL\n");
1528     ok(!lstrcmpW(str, comment), "got %s\n", wine_dbgstr_w(str));
1529     SysFreeString(str);
1530
1531     IExecAction_Release(exec_action);
1532     IAction_Release(action);
1533     IActionCollection_Release(actions);
1534 }
1535
1536 static void test_TaskDefinition(void)
1537 {
1538     static WCHAR xml0[] = L"";
1539     static WCHAR xml1[] =
1540         L"<Task xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
1541         "  <RegistrationInfo>\n"
1542         "    <Description>\"Task1\"</Description>\n"
1543         "    <Author>author</Author>\n"
1544         "    <Version>1.0</Version>\n"
1545         "    <Date>2018-04-02T11:22:33</Date>\n"
1546         "    <Documentation>doc</Documentation>\n"
1547         "    <URI>uri</URI>\n"
1548         "    <Source>source</Source>\n"
1549         "  </RegistrationInfo>\n"
1550         "  <Settings>\n"
1551         "    <Enabled>false</Enabled>\n"
1552         "    <Hidden>false</Hidden>\n"
1553         "  </Settings>\n"
1554         "  <Actions>\n"
1555         "    <Exec>\n"
1556         "      <Command>\"task1.exe\"</Command>\n"
1557         "    </Exec>\n"
1558         "  </Actions>\n"
1559         "</Task>\n";
1560     static WCHAR xml2[] =
1561         L"<Task>\n"
1562         "  <RegistrationInfo>\n"
1563         "    <Description>\"Task1\"</Description>\n"
1564         "  </RegistrationInfo>\n"
1565         "  <Settings>\n"
1566         "    <Enabled>false</Enabled>\n"
1567         "    <Hidden>false</Hidden>\n"
1568         "  </Settings>\n"
1569         "  <Actions>\n"
1570         "    <Exec>\n"
1571         "      <Command>\"task1.exe\"</Command>\n"
1572         "    </Exec>\n"
1573         "  </Actions>\n"
1574         "</Task>\n";
1575     static WCHAR xml3[] =
1576         L"<TASK>\n"
1577         "  <RegistrationInfo>\n"
1578         "    <Description>\"Task1\"</Description>\n"
1579         "  </RegistrationInfo>\n"
1580         "  <Settings>\n"
1581         "    <Enabled>false</Enabled>\n"
1582         "    <Hidden>false</Hidden>\n"
1583         "  </Settings>\n"
1584         "  <Actions>\n"
1585         "    <Exec>\n"
1586         "      <Command>\"task1.exe\"</Command>\n"
1587         "    </Exec>\n"
1588         "  </Actions>\n"
1589         "</TASK>\n";
1590     static WCHAR xml4[] =
1591         L"<Task xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
1592         "  <RegistrationInfo/>\n"
1593         "  <Settings/>\n"
1594         "  <Actions>\n"
1595         "    <Exec>\n"
1596         "      <Command>\"task1.exe\"</Command>\n"
1597         "    </Exec>\n"
1598         "  </Actions>\n"
1599         "</Task>\n";
1600     static WCHAR xml5[] =
1601         L"<Task xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
1602         "  <RegistrationInfo/>\n"
1603         "  <Settings/>\n"
1604         "  <Actions/>\n"
1605         "</Task>\n";
1606     static WCHAR xml6[] =
1607         L"<Task xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
1608         "  <RegistrationInfo/>\n"
1609         "  <Actions>\n"
1610         "    <Exec>\n"
1611         "      <Command>\"task1.exe\"</Command>\n"
1612         "    </Exec>\n"
1613         "  </Actions>\n"
1614         "  <Settings>\n"
1615         "</Task>\n";
1616     static WCHAR xml7[] =
1617         L"<Task xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
1618         "  <RegistrationInfo/>\n"
1619         "  <Settings>\n"
1620         "    <Enabled>FALSE</Enabled>\n"
1621         "  </Settings>\n"
1622         "  <Actions>\n"
1623         "    <Exec>\n"
1624         "      <Command>\"task1.exe\"</Command>\n"
1625         "    </Exec>\n"
1626         "  </Actions>\n"
1627         "</Task>\n";
1628     static struct settings def_settings = { L"", L"PT72H", L"",
1629         0, 7, TASK_INSTANCES_IGNORE_NEW, TASK_COMPATIBILITY_V2, VARIANT_TRUE, VARIANT_TRUE,
1630         VARIANT_TRUE, VARIANT_TRUE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_TRUE, VARIANT_FALSE,
1631         VARIANT_FALSE, VARIANT_FALSE };
1632     static struct settings new_settings = { L"P1Y", L"PT10M", L"",
1633         100, 1, TASK_INSTANCES_STOP_EXISTING, TASK_COMPATIBILITY_V1, VARIANT_FALSE, VARIANT_FALSE,
1634         VARIANT_FALSE, VARIANT_FALSE, VARIANT_TRUE, VARIANT_TRUE, VARIANT_FALSE, VARIANT_TRUE,
1635         VARIANT_TRUE, VARIANT_TRUE };
1636     ITriggerCollection *trigger_col, *trigger_col2;
1637     HRESULT hr;
1638     ITaskService *service;
1639     ITaskDefinition *taskdef;
1640     IRegistrationInfo *reginfo;
1641     ITrigger *trigger;
1642     BSTR xml, bstr;
1643     VARIANT var;
1644
1645     hr = CoCreateInstance(&CLSID_TaskScheduler, NULL, CLSCTX_INPROC_SERVER, &IID_ITaskService, (void **)&service);
1646     if (hr != S_OK)
1647     {
1648         win_skip("CoCreateInstance(CLSID_TaskScheduler) error %#lx\n", hr);
1649         return;
1650     }
1651
1652     hr = ITaskService_NewTask(service, 0, &taskdef);
1653     ok(hr == S_OK, "NewTask error %#lx\n", hr);
1654
1655     test_settings_v1(taskdef, &def_settings, &def_settings);
1656     change_settings(taskdef, &new_settings);
1657
1658     /* Action is mandatory for v1 compatibility */
1659     create_action(taskdef);
1660
1661     hr = ITaskDefinition_get_XmlText(taskdef, &xml);
1662     ok(hr == S_OK, "get_XmlText error %#lx\n", hr);
1663
1664     ITaskDefinition_Release(taskdef);
1665
1666     hr = ITaskService_NewTask(service, 0, &taskdef);
1667     ok(hr == S_OK, "NewTask error %#lx\n", hr);
1668
1669     hr = ITaskDefinition_put_XmlText(taskdef, xml);
1670     ok(hr == S_OK, "put_XmlText error %#lx\n", hr);
1671     SysFreeString(xml);
1672
1673     /* FIXME: uncomment once changing settings is implemented
1674     test_settings_v1(taskdef, &new_settings, &def_settings);
1675     */
1676
1677     hr = ITaskDefinition_put_XmlText(taskdef, NULL);
1678     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#lx\n", hr);
1679
1680     hr = ITaskDefinition_put_XmlText(taskdef, xml1);
1681     ok(hr == S_OK, "put_XmlText error %#lx\n", hr);
1682
1683     hr = ITaskDefinition_put_XmlText(taskdef, xml2);
1684     ok(hr == SCHED_E_NAMESPACE, "expected SCHED_E_NAMESPACE, got %#lx\n", hr);
1685
1686     hr = ITaskDefinition_put_XmlText(taskdef, xml3);
1687     todo_wine
1688     ok(hr == SCHED_E_UNEXPECTEDNODE, "expected SCHED_E_UNEXPECTEDNODE, got %#lx\n", hr);
1689
1690     hr = ITaskDefinition_put_XmlText(taskdef, xml4);
1691     ok(hr == S_OK, "put_XmlText error %#lx\n", hr);
1692
1693     hr = ITaskDefinition_put_XmlText(taskdef, xml5);
1694     todo_wine
1695     ok(hr == SCHED_E_MISSINGNODE, "expected SCHED_E_MISSINGNODE, got %#lx\n", hr);
1696
1697     hr = ITaskDefinition_put_XmlText(taskdef, xml6);
1698     ok(hr == SCHED_E_MALFORMEDXML, "expected SCHED_E_MALFORMEDXML, got %#lx\n", hr);
1699
1700     hr = ITaskDefinition_put_XmlText(taskdef, xml7);
1701     ok(hr == SCHED_E_INVALIDVALUE, "expected SCHED_E_INVALIDVALUE, got %#lx\n", hr);
1702
1703     hr = ITaskDefinition_put_XmlText(taskdef, xml0);
1704     ok(hr == SCHED_E_MALFORMEDXML, "expected SCHED_E_MALFORMEDXML, got %#lx\n", hr);
1705
1706     /* test registration info */
1707     hr = ITaskDefinition_put_XmlText(taskdef, xml1);
1708     ok(hr == S_OK, "put_XmlText error %#lx\n", hr);
1709     hr = ITaskDefinition_get_RegistrationInfo(taskdef, &reginfo);
1710     ok(hr == S_OK, "get_RegistrationInfo error %#lx\n", hr);
1711
1712     hr = IRegistrationInfo_get_Description(reginfo, &bstr);
1713     ok(hr == S_OK, "get_Description error %#lx\n", hr);
1714     ok(!lstrcmpW(bstr, L"\"Task1\""), "expected \"Task1\", got %s\n", wine_dbgstr_w(bstr));
1715     SysFreeString(bstr);
1716     hr = IRegistrationInfo_put_Description(reginfo, NULL);
1717     ok(hr == S_OK, "put_Description error %#lx\n", hr);
1718     bstr = (BSTR)0xdeadbeef;
1719     hr = IRegistrationInfo_get_Description(reginfo, &bstr);
1720     ok(hr == S_OK, "get_Description error %#lx\n", hr);
1721     ok(!bstr, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1722
1723     hr = IRegistrationInfo_get_Author(reginfo, &bstr);
1724     ok(hr == S_OK, "get_Author error %#lx\n", hr);
1725     ok(!lstrcmpW(bstr, L"author"), "expected author, got %s\n", wine_dbgstr_w(bstr));
1726     SysFreeString(bstr);
1727     hr = IRegistrationInfo_put_Author(reginfo, NULL);
1728     ok(hr == S_OK, "put_Author error %#lx\n", hr);
1729     bstr = (BSTR)0xdeadbeef;
1730     hr = IRegistrationInfo_get_Author(reginfo, &bstr);
1731     ok(hr == S_OK, "get_Author error %#lx\n", hr);
1732     ok(!bstr, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1733
1734     hr = IRegistrationInfo_get_Version(reginfo, &bstr);
1735     ok(hr == S_OK, "get_Version error %#lx\n", hr);
1736     ok(!lstrcmpW(bstr, L"1.0"), "expected 1.0, got %s\n", wine_dbgstr_w(bstr));
1737     SysFreeString(bstr);
1738     hr = IRegistrationInfo_put_Version(reginfo, NULL);
1739     ok(hr == S_OK, "put_Version error %#lx\n", hr);
1740     bstr = (BSTR)0xdeadbeef;
1741     hr = IRegistrationInfo_get_Version(reginfo, &bstr);
1742     ok(hr == S_OK, "get_Version error %#lx\n", hr);
1743     ok(!bstr, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1744
1745     hr = IRegistrationInfo_get_Date(reginfo, &bstr);
1746     ok(hr == S_OK, "get_Date error %#lx\n", hr);
1747     ok(!lstrcmpW(bstr, L"2018-04-02T11:22:33"), "expected 2018-04-02T11:22:33, got %s\n", wine_dbgstr_w(bstr));
1748     SysFreeString(bstr);
1749     hr = IRegistrationInfo_put_Date(reginfo, NULL);
1750     ok(hr == S_OK, "put_Date error %#lx\n", hr);
1751     bstr = (BSTR)0xdeadbeef;
1752     hr = IRegistrationInfo_get_Date(reginfo, &bstr);
1753     ok(hr == S_OK, "get_Date error %#lx\n", hr);
1754     ok(!bstr, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1755
1756     hr = IRegistrationInfo_get_Documentation(reginfo, &bstr);
1757     ok(hr == S_OK, "get_Documentation error %#lx\n", hr);
1758     ok(!lstrcmpW(bstr, L"doc"), "expected doc, got %s\n", wine_dbgstr_w(bstr));
1759     SysFreeString(bstr);
1760     hr = IRegistrationInfo_put_Documentation(reginfo, NULL);
1761     ok(hr == S_OK, "put_Documentation error %#lx\n", hr);
1762     bstr = (BSTR)0xdeadbeef;
1763     hr = IRegistrationInfo_get_Documentation(reginfo, &bstr);
1764     ok(hr == S_OK, "get_Documentation error %#lx\n", hr);
1765     ok(!bstr, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1766
1767     hr = IRegistrationInfo_get_URI(reginfo, &bstr);
1768     ok(hr == S_OK, "get_URI error %#lx\n", hr);
1769     ok(!lstrcmpW(bstr, L"uri"), "expected uri, got %s\n", wine_dbgstr_w(bstr));
1770     SysFreeString(bstr);
1771     hr = IRegistrationInfo_put_URI(reginfo, NULL);
1772     ok(hr == S_OK, "put_URI error %#lx\n", hr);
1773     bstr = (BSTR)0xdeadbeef;
1774     hr = IRegistrationInfo_get_URI(reginfo, &bstr);
1775     ok(hr == S_OK, "get_URI error %#lx\n", hr);
1776     ok(!bstr, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1777
1778     hr = IRegistrationInfo_get_Source(reginfo, &bstr);
1779     ok(hr == S_OK, "get_Source error %#lx\n", hr);
1780     ok(!lstrcmpW(bstr, L"source"), "expected source, got %s\n", wine_dbgstr_w(bstr));
1781     SysFreeString(bstr);
1782     hr = IRegistrationInfo_put_Source(reginfo, NULL);
1783     ok(hr == S_OK, "put_Source error %#lx\n", hr);
1784     bstr = (BSTR)0xdeadbeef;
1785     hr = IRegistrationInfo_get_Source(reginfo, &bstr);
1786     ok(hr == S_OK, "get_Source error %#lx\n", hr);
1787     ok(!bstr, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1788
1789     V_VT(&var) = VT_BSTR;
1790     V_BSTR(&var) = NULL;
1791     hr = IRegistrationInfo_get_SecurityDescriptor(reginfo, &var);
1792     todo_wine
1793     ok(hr == S_OK, "get_SecurityDescriptor error %#lx\n", hr);
1794     if (hr == S_OK)
1795         ok(V_VT(&var) == VT_EMPTY, "expected VT_EMPTY, got %u\n", V_VT(&var));
1796
1797     IRegistrationInfo_Release(reginfo);
1798
1799     hr = ITaskDefinition_put_XmlText(taskdef, xml4);
1800     ok(hr == S_OK, "put_XmlText error %#lx\n", hr);
1801     hr = ITaskDefinition_get_RegistrationInfo(taskdef, &reginfo);
1802     ok(hr == S_OK, "get_RegistrationInfo error %#lx\n", hr);
1803
1804     hr = IRegistrationInfo_get_Description(reginfo, &bstr);
1805     ok(hr == S_OK, "get_Description error %#lx\n", hr);
1806     ok(!bstr, "expected NULL, got %s\n", wine_dbgstr_w(bstr));
1807
1808     hr = ITaskDefinition_get_Triggers(taskdef, &trigger_col);
1809     ok(hr == S_OK, "get_Triggers failed: %08lx\n", hr);
1810     ok(trigger_col != NULL, "Triggers = NULL\n");
1811
1812     hr = ITriggerCollection_Create(trigger_col, TASK_TRIGGER_DAILY, &trigger);
1813     ok(hr == S_OK, "Create failed: %08lx\n", hr);
1814     ok(trigger != NULL, "trigger = NULL\n");
1815     test_daily_trigger(trigger);
1816     ITrigger_Release(trigger);
1817
1818     hr = ITriggerCollection_Create(trigger_col, TASK_TRIGGER_REGISTRATION, &trigger);
1819     ok(hr == S_OK, "Create failed: %08lx\n", hr);
1820     ok(trigger != NULL, "trigger = NULL\n");
1821     test_registration_trigger(trigger);
1822     ITrigger_Release(trigger);
1823     ITriggerCollection_Release(trigger_col);
1824
1825     hr = ITaskDefinition_get_Triggers(taskdef, &trigger_col2);
1826     ok(hr == S_OK, "get_Triggers failed: %08lx\n", hr);
1827     ok(trigger_col == trigger_col2, "Mismatched triggers\n");
1828     ITriggerCollection_Release(trigger_col2);
1829
1830     IRegistrationInfo_Release(reginfo);
1831     ITaskDefinition_Release(taskdef);
1832     ITaskService_Release(service);
1833 }
1834
1835 START_TEST(scheduler)
1836 {
1837     OleInitialize(NULL);
1838
1839     test_Connect();
1840     test_GetFolder();
1841     test_FolderCollection();
1842     test_GetTask();
1843     test_TaskDefinition();
1844
1845     OleUninitialize();
1846 }