dlls/schedsvc/tests/rpcapi.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 <stdio.h>
  20 #include <windows.h>
  21 #include <ole2.h>
  22 #include <rpcdce.h>
  23 #include <taskschd.h>
  24 #include "schrpc.h"
  25
  26 #include "wine/test.h"
  27
  28 extern handle_t rpc_handle;
  29
  30 static LONG CALLBACK rpc_exception_filter(EXCEPTION_POINTERS *ptrs)
  31 {
  32     skip("Can't connect to Scheduler service: %#x\n", ptrs->ExceptionRecord->ExceptionCode);
  33
  34     if (winetest_debug)
  35     {
  36         fprintf(stdout, "rpcapi: 0 tests executed (0 marked as todo, 0 failures), 1 skipped.\n");
  37         fflush(stdout);
  38     }
  39     ExitProcess(0);
  40 }
  41
  42 START_TEST(rpcapi)
  43 {
  44     static unsigned char ncalrpc[] = "ncalrpc";
  45     static const WCHAR empty[] = { 0 };
  46     static const WCHAR Wine[] = { '\\','W','i','n','e',0 };
  47     static const WCHAR Wine_Folder1[] = { '\\','W','i','n','e','\\','F','o','l','d','e','r','1',0 };
  48     static const WCHAR Wine_Folder2[] = { '\\','W','i','n','e','\\','F','o','l','d','e','r','2',0 };
  49     static const WCHAR Folder1[] = { 'F','o','l','d','e','r','1',0 };
  50     static const WCHAR Folder2[] = { 'F','o','l','d','e','r','2',0 };
  51     static const WCHAR Wine_Task1[] = { '\\','W','i','n','e','\\','T','a','s','k','1',0 };
  52     static const WCHAR Wine_Task2[] = { '\\','W','i','n','e','\\','T','a','s','k','2',0 };
  53     static const WCHAR Wine_Task3[] = { '\\','W','i','n','e','\\','T','a','s','k','3',0 };
  54     static const WCHAR Wine_Folder1_Task1[] = { '\\','W','i','n','e','\\','F','o','l','d','e','r','1','\\','T','a','s','k','1',0 };
  55     static const WCHAR Task1[] = { 'T','a','s','k','1',0 };
  56     static const WCHAR Task2[] = { 'T','a','s','k','2',0 };
  57     static const WCHAR Task3[] = { 'T','a','s','k','3',0 };
  58     static const char xml1[] =
  59         "<?xml version=\"1.0\"?>\n"
  60         "<Task xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\n"
  61         "  <RegistrationInfo>\n"
  62         "    <Description>\"Task1\"</Description>\n"
  63         "  </RegistrationInfo>\n"
  64         "  <Settings>\n"
  65         "    <Enabled>false</Enabled>\n"
  66         "    <Hidden>false</Hidden>\n"
  67         "  </Settings>\n"
  68         "  <Actions>\n"
  69         "    <Exec>\n"
  70         "      <Command>\"task1.exe\"</Command>\n"
  71         "    </Exec>\n"
  72         "  </Actions>\n"
  73         "</Task>\n";
  74     static const struct
  75     {
  76         DWORD flags, hr;
  77     } create_new_task[] =
  78     {
  79         { 0, S_OK },
  80         { TASK_CREATE, S_OK },
  81         { TASK_UPDATE, 0x80070002 /* HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) */ },
  82         { TASK_CREATE | TASK_UPDATE, S_OK }
  83     };
  84     static const struct
  85     {
  86         DWORD flags, hr;
  87     } open_existing_task[] =
  88     {
  89         { 0, 0x800700b7 /* HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS) */ },
  90         { TASK_CREATE, 0x800700b7 /* HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS) */ },
  91         { TASK_UPDATE, S_OK },
  92         { TASK_CREATE | TASK_UPDATE, S_OK }
  93     };
  94     WCHAR xmlW[sizeof(xml1)], *xml;
  95     HRESULT hr;
  96     DWORD version, start_index, count, i, enumed, enabled, state;
  97     WCHAR *path;
  98     TASK_XML_ERROR_INFO *info;
  99     TASK_NAMES names;
 100     unsigned char *binding_str;
 101     PTOP_LEVEL_EXCEPTION_FILTER old_exception_filter;
 102     IID iid;
 103
 104     hr = RpcStringBindingComposeA(NULL, ncalrpc, NULL, NULL, NULL, &binding_str);
 105     ok(hr == RPC_S_OK, "RpcStringBindingCompose error %#x\n", hr);
 106     hr = RpcBindingFromStringBindingA(binding_str, &rpc_handle);
 107     ok(hr == RPC_S_OK, "RpcBindingFromStringBinding error %#x\n", hr);
 108     hr = RpcStringFreeA(&binding_str);
 109     ok(hr == RPC_S_OK, "RpcStringFree error %#x\n", hr);
 110
 111     /* widl generated RpcTryExcept/RpcExcept can't catch raised exceptions */
 112     old_exception_filter = SetUnhandledExceptionFilter(rpc_exception_filter);
 113
 114     version = 0;
 115     hr = SchRpcHighestVersion(&version);
 116     ok(version == 0x10002 /* vista */ || version == 0x10003 /* win7 */ || version == 0x10004 /* win8 */,
 117        "wrong version %#x\n", version);
 118
 119     SetUnhandledExceptionFilter(old_exception_filter);
 120
 121     hr = SchRpcCreateFolder(Wine_Folder1, NULL, 1);
 122     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
 123
 124     hr = SchRpcCreateFolder(Wine_Folder1, NULL, 0);
 125     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 126
 127     hr = SchRpcCreateFolder(Wine_Folder1, NULL, 0);
 128     ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#x\n", hr);
 129
 130     hr = SchRpcCreateFolder(Wine_Folder2+1, empty, 0);
 131     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 132
 133     hr = SchRpcDelete(Wine+1, 0);
 134     ok(hr == HRESULT_FROM_WIN32(ERROR_DIR_NOT_EMPTY), "expected ERROR_DIR_NOT_EMPTY, got %#x\n", hr);
 135
 136     hr = SchRpcDelete(Wine_Folder1+1, 1);
 137     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
 138
 139     hr = SchRpcDelete(Wine_Folder1+1, 0);
 140     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 141
 142     hr = SchRpcDelete(Wine_Folder2, 0);
 143     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 144
 145     hr = SchRpcDelete(Wine, 0);
 146     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 147
 148     hr = SchRpcDelete(Wine, 0);
 149     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "expected ERROR_FILE_NOT_FOUND, got %#x\n", hr);
 150
 151     hr = SchRpcDelete(empty, 0);
 152     ok(hr == E_ACCESSDENIED /* win7 */ || hr == E_INVALIDARG /* vista */, "expected E_ACCESSDENIED, got %#x\n", hr);
 153
 154     hr = SchRpcCreateFolder(Wine, NULL, 0);
 155     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 156
 157     MultiByteToWideChar(CP_ACP, 0, xml1, -1, xmlW, sizeof(xmlW)/sizeof(xmlW[0]));
 158
 159     path = NULL;
 160     info = NULL;
 161     hr = SchRpcRegisterTask(Wine+1, xmlW, TASK_VALIDATE_ONLY, NULL, TASK_LOGON_NONE, 0, NULL, &path, &info);
 162     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 163     ok(!path, "expected NULL, path %p\n", path);
 164     ok(!info, "expected NULL, info %p\n", info);
 165
 166     for (i = 0; i < sizeof(create_new_task)/sizeof(create_new_task[0]); i++)
 167     {
 168         path = NULL;
 169         info = NULL;
 170         hr = SchRpcRegisterTask(Wine_Task1, xmlW, create_new_task[i].flags, NULL, TASK_LOGON_NONE, 0, NULL, &path, &info);
 171         ok(hr == create_new_task[i].hr, "%u: expected %#x, got %#x\n", i, create_new_task[i].hr, hr);
 172
 173         if (hr == S_OK)
 174         {
 175             hr = SchRpcDelete(Wine_Task1, 0);
 176             ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 177             ok(!info, "expected NULL, info %p\n", info);
 178             MIDL_user_free(path);
 179         }
 180     }
 181
 182     path = NULL;
 183     info = NULL;
 184     hr = SchRpcRegisterTask(Wine_Task1, xmlW, TASK_VALIDATE_ONLY, NULL, TASK_LOGON_NONE, 0, NULL, &path, &info);
 185     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 186     ok(!path, "expected NULL, path %p\n", path);
 187     ok(!info, "expected NULL, info %p\n", info);
 188
 189     path = NULL;
 190     info = NULL;
 191     hr = SchRpcRegisterTask(NULL, xmlW, TASK_VALIDATE_ONLY, NULL, TASK_LOGON_NONE, 0, NULL, &path, &info);
 192     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 193     ok(!path, "expected NULL, path %p\n", path);
 194     ok(!info, "expected NULL, info %p\n", info);
 195
 196     path = NULL;
 197     info = NULL;
 198     hr = SchRpcRegisterTask(Wine_Folder1_Task1+1, xmlW, TASK_CREATE, NULL, TASK_LOGON_NONE, 0, NULL, &path, &info);
 199     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 200     ok(!lstrcmpW(path, Wine_Folder1_Task1) /* win7 */ || !lstrcmpW(path, Wine_Folder1_Task1+1) /* vista */,
 201        "expected \\Wine\\Folder1\\Task1, task actual path %s\n", wine_dbgstr_w(path));
 202     ok(!info, "expected NULL, info %p\n", info);
 203     MIDL_user_free(path);
 204
 205     for (i = 0; i < sizeof(open_existing_task)/sizeof(open_existing_task[0]); i++)
 206     {
 207         path = NULL;
 208         info = NULL;
 209         hr = SchRpcRegisterTask(Wine_Folder1_Task1+1, xmlW, open_existing_task[i].flags, NULL, TASK_LOGON_NONE, 0, NULL, &path, &info);
 210         ok(hr == open_existing_task[i].hr, "%u: expected %#x, got %#x\n", i, open_existing_task[i].hr, hr);
 211         if (hr == S_OK)
 212         {
 213             ok(!lstrcmpW(path, Wine_Folder1_Task1) /* win7 */ || !lstrcmpW(path, Wine_Folder1_Task1+1) /* vista */,
 214                "expected \\Wine\\Folder1\\Task1, task actual path %s\n", wine_dbgstr_w(path));
 215             MIDL_user_free(path);
 216         }
 217         else
 218             ok(!path, "%u: expected NULL, path %p\n", i, path);
 219         ok(!info, "%u: expected NULL, info %p\n", i, info);
 220     }
 221
 222     path = NULL;
 223     info = NULL;
 224     hr = SchRpcRegisterTask(Wine_Folder1_Task1+1, xmlW, TASK_CREATE, NULL, TASK_LOGON_NONE, 0, NULL, &path, &info);
 225     ok(hr == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), "expected ERROR_ALREADY_EXISTS, got %#x\n", hr);
 226     ok(!path, "expected NULL, path %p\n", path);
 227     ok(!info, "expected NULL, info %p\n", info);
 228
 229     count = 0;
 230     xml = NULL;
 231     hr = SchRpcRetrieveTask(Wine_Folder1_Task1, empty, &count, &xml);
 232     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 233     if (hr == S_OK) trace("%s\n", wine_dbgstr_w(xml));
 234     MIDL_user_free(xml);
 235
 236     hr = SchRpcDelete(Wine_Folder1_Task1+1, 0);
 237     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 238     hr = SchRpcDelete(Wine_Folder1+1, 0);
 239     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 240     hr = SchRpcDelete(Wine+1, 0);
 241     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 242
 243     start_index = 0;
 244     count = 0xdeadbeef;
 245     names = NULL;
 246     hr = SchRpcEnumFolders(Wine, TASK_ENUM_HIDDEN, &start_index, 0, &count, &names);
 247     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "expected ERROR_FILE_NOT_FOUND, got %#x\n", hr);
 248     ok(!count, "expected 0, got %u\n", count);
 249     ok(!start_index, "expected 0, got %u\n", start_index);
 250     ok(!names, "expected NULL, got %p\n", names);
 251
 252     hr = SchRpcCreateFolder(Wine, NULL, 0);
 253     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 254
 255     start_index = 0;
 256     count = 0xdeadbeef;
 257     names = NULL;
 258     hr = SchRpcEnumFolders(Wine, 0, &start_index, 0, &count, &names);
 259     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 260     ok(!count, "expected 0, got %u\n", count);
 261     ok(!start_index, "expected 0, got %u\n", start_index);
 262     ok(!names, "expected NULL, got %p\n", names);
 263
 264     hr = SchRpcCreateFolder(Wine_Folder1, NULL, 0);
 265     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 266     hr = SchRpcCreateFolder(Wine_Folder2, NULL, 0);
 267     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 268
 269     start_index = 0;
 270     count = 0xdeadbeef;
 271     names = NULL;
 272     hr = SchRpcEnumFolders(Wine, 0, &start_index, 0, &count, &names);
 273     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 274     ok(count == 2, "expected 2, got %u\n", count);
 275     ok(start_index == 2, "expected 2, got %u\n", start_index);
 276     ok(names != NULL, "names should not be NULL\n");
 277     enumed = 0;
 278     for (i = 0; i < count; i++)
 279     {
 280         if (!lstrcmpW(names[i], Folder1))
 281             enumed += 1;
 282         else if (!lstrcmpW(names[i], Folder2))
 283             enumed += 2;
 284         MIDL_user_free(names[i]);
 285     }
 286     MIDL_user_free(names);
 287     ok(enumed == 3, "expected 3, got %u\n", enumed);
 288
 289     start_index = 0;
 290     count = 0xdeadbeef;
 291     names = NULL;
 292     hr = SchRpcEnumFolders(Wine, 0, &start_index, 1, &count, &names);
 293     ok(hr == S_FALSE, "expected S_FALSE, got %#x\n", hr);
 294     ok(count == 1, "expected 1, got %u\n", count);
 295     ok(start_index == 1, "expected 1, got %u\n", start_index);
 296     ok(names != NULL, "names should not be NULL\n");
 297     ok(!lstrcmpW(names[0], Folder1), "expected Folder1, got %s\n", wine_dbgstr_w(names[0]));
 298     MIDL_user_free(names[0]);
 299     MIDL_user_free(names);
 300
 301     start_index = 0;
 302     count = 0xdeadbeef;
 303     names = NULL;
 304     hr = SchRpcEnumFolders(Wine, 0, &start_index, 2, &count, &names);
 305     ok(hr == S_FALSE, "expected S_FALSE, got %#x\n", hr);
 306     ok(count == 2, "expected 2, got %u\n", count);
 307     ok(start_index == 2, "expected 2, got %u\n", start_index);
 308     ok(names != NULL, "names should not be NULL\n");
 309     enumed = 0;
 310     for (i = 0; i < count; i++)
 311     {
 312         if (!lstrcmpW(names[i], Folder1))
 313             enumed += 1;
 314         else if (!lstrcmpW(names[i], Folder2))
 315             enumed += 2;
 316         MIDL_user_free(names[i]);
 317     }
 318     MIDL_user_free(names);
 319     ok(enumed == 3, "expected 3, got %u\n", enumed);
 320
 321     start_index = 0;
 322     count = 0xdeadbeef;
 323     names = NULL;
 324     hr = SchRpcEnumFolders(Wine, 0, &start_index, 10, &count, &names);
 325     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 326     ok(count == 2, "expected 2, got %u\n", count);
 327     ok(start_index == 2, "expected 2, got %u\n", start_index);
 328     ok(names != NULL, "names should not be NULL\n");
 329     enumed = 0;
 330     for (i = 0; i < count; i++)
 331     {
 332         if (!lstrcmpW(names[i], Folder1))
 333             enumed += 1;
 334         else if (!lstrcmpW(names[i], Folder2))
 335             enumed += 2;
 336         MIDL_user_free(names[i]);
 337     }
 338     MIDL_user_free(names);
 339     ok(enumed == 3, "expected 3, got %u\n", enumed);
 340
 341     start_index = 10;
 342     count = 0xdeadbeef;
 343     names = NULL;
 344     hr = SchRpcEnumFolders(Wine, 0, &start_index, 0, &count, &names);
 345     ok(hr == S_FALSE, "expected S_FALSE, got %#x\n", hr);
 346     ok(!count, "expected 0, got %u\n", count);
 347     ok(start_index == 10, "expected 10, got %u\n", start_index);
 348     ok(!names, "expected NULL, got %p\n", names);
 349
 350     hr = SchRpcDelete(Wine_Folder1+1, 0);
 351     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 352     hr = SchRpcDelete(Wine_Folder2, 0);
 353     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 354
 355     start_index = 0;
 356     count = 0xdeadbeef;
 357     names = NULL;
 358     hr = SchRpcEnumTasks(Wine_Folder1, TASK_ENUM_HIDDEN, &start_index, 0, &count, &names);
 359     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "expected ERROR_FILE_NOT_FOUND, got %#x\n", hr);
 360     ok(!count, "expected 0, got %u\n", count);
 361     ok(!start_index, "expected 0, got %u\n", start_index);
 362     ok(!names, "expected NULL, got %p\n", names);
 363
 364     path = NULL;
 365     info = NULL;
 366     hr = SchRpcRegisterTask(Wine_Task1+1, xmlW, TASK_CREATE, NULL, TASK_LOGON_NONE, 0, NULL, &path, &info);
 367     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 368     ok(!lstrcmpW(path, Wine_Task1) /* win7 */ || !lstrcmpW(path, Wine_Task1+1) /* vista */,
 369        "expected \\Wine\\Task1, task actual path %s\n", wine_dbgstr_w(path));
 370     ok(!info, "expected NULL, info %p\n", info);
 371     MIDL_user_free(path);
 372
 373     path = NULL;
 374     info = NULL;
 375     hr = SchRpcRegisterTask(Wine_Task2, xmlW, TASK_CREATE, NULL, TASK_LOGON_NONE, 0, NULL, &path, &info);
 376     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 377     ok(!lstrcmpW(path, Wine_Task2), "expected \\Wine\\Task2, task actual path %s\n", wine_dbgstr_w(path));
 378     ok(!info, "expected NULL, info %p\n", info);
 379     MIDL_user_free(path);
 380
 381     start_index = 0;
 382     count = 0xdeadbeef;
 383     names = NULL;
 384     hr = SchRpcEnumTasks(Wine, 0, &start_index, 0, &count, &names);
 385     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 386     ok(count == 2, "expected 2, got %u\n", count);
 387     ok(start_index == 2, "expected 2, got %u\n", start_index);
 388     ok(names != NULL, "names should not be NULL\n");
 389     enumed = 0;
 390     for (i = 0; i < count; i++)
 391     {
 392         if (!lstrcmpW(names[i], Task1))
 393             enumed += 1;
 394         else if (!lstrcmpW(names[i], Task2))
 395             enumed += 2;
 396         MIDL_user_free(names[i]);
 397     }
 398     MIDL_user_free(names);
 399     ok(enumed == 3, "expected 3, got %u\n", enumed);
 400
 401     start_index = 0;
 402     count = 0xdeadbeef;
 403     names = NULL;
 404     hr = SchRpcEnumTasks(Wine, 0, &start_index, 1, &count, &names);
 405     ok(hr == S_FALSE, "expected S_FALSE, got %#x\n", hr);
 406     ok(count == 1, "expected 1, got %u\n", count);
 407     ok(start_index == 1, "expected 1, got %u\n", start_index);
 408     ok(names != NULL, "names should not be NULL\n");
 409     /* returned name depends whether directory randomization is on */
 410     ok(!lstrcmpW(names[0], Task1) || !lstrcmpW(names[0], Task2),
 411        "expected Task1, got %s\n", wine_dbgstr_w(names[0]));
 412     MIDL_user_free(names[0]);
 413     MIDL_user_free(names);
 414
 415     start_index = 0;
 416     count = 0xdeadbeef;
 417     names = NULL;
 418     hr = SchRpcEnumTasks(Wine, 0, &start_index, 2, &count, &names);
 419     ok(hr == S_FALSE, "expected S_FALSE, got %#x\n", hr);
 420     ok(count == 2, "expected 2, got %u\n", count);
 421     ok(start_index == 2, "expected 2, got %u\n", start_index);
 422     ok(names != NULL, "names should not be NULL\n");
 423     enumed = 0;
 424     for (i = 0; i < count; i++)
 425     {
 426         if (!lstrcmpW(names[i], Task1))
 427             enumed += 1;
 428         else if (!lstrcmpW(names[i], Task2))
 429             enumed += 2;
 430         MIDL_user_free(names[i]);
 431     }
 432     MIDL_user_free(names);
 433     ok(enumed == 3, "expected 3, got %u\n", enumed);
 434
 435     start_index = 0;
 436     count = 0xdeadbeef;
 437     names = NULL;
 438     hr = SchRpcEnumTasks(Wine, 0, &start_index, 10, &count, &names);
 439     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 440     ok(count == 2, "expected 2, got %u\n", count);
 441     ok(start_index == 2, "expected 2, got %u\n", start_index);
 442     ok(names != NULL, "names should not be NULL\n");
 443     enumed = 0;
 444     for (i = 0; i < count; i++)
 445     {
 446         if (!lstrcmpW(names[i], Task1))
 447             enumed += 1;
 448         else if (!lstrcmpW(names[i], Task2))
 449             enumed += 2;
 450         MIDL_user_free(names[i]);
 451     }
 452     MIDL_user_free(names);
 453     ok(enumed == 3, "expected 3, got %u\n", enumed);
 454
 455     path = NULL;
 456     info = NULL;
 457     hr = SchRpcRegisterTask(Wine_Task3+1, xmlW, TASK_CREATE, NULL, TASK_LOGON_NONE, 0, NULL, &path, &info);
 458     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 459     ok(!lstrcmpW(path, Wine_Task3) /* win7 */ || !lstrcmpW(path, Wine_Task3+1) /* vista */,
 460        "expected \\Wine\\Task3, task actual path %s\n", wine_dbgstr_w(path));
 461     ok(!info, "expected NULL, info %p\n", info);
 462     MIDL_user_free(path);
 463
 464     count = 0xdeadbeef;
 465     names = NULL;
 466     hr = SchRpcEnumTasks(Wine+1, 0, &start_index, 10, &count, &names);
 467     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 468     ok(count == 1, "expected 1, got %u\n", count);
 469     ok(start_index == 3, "expected 3, got %u\n", start_index);
 470     ok(names != NULL, "names should not be NULL\n");
 471     /* returned name depends whether directory randomization is on */
 472     ok(!lstrcmpW(names[0], Task1) || !lstrcmpW(names[0], Task2) || !lstrcmpW(names[0], Task3),
 473        "expected Task3, got %s\n", wine_dbgstr_w(names[0]));
 474     MIDL_user_free(names[0]);
 475     MIDL_user_free(names);
 476
 477     if (0) /* crashes under win7 */
 478     {
 479     hr = SchRpcGetTaskInfo(NULL, 0, NULL, NULL);
 480     hr = SchRpcGetTaskInfo(Task1, 0, NULL, NULL);
 481     hr = SchRpcGetTaskInfo(Task1, 0, &enabled, NULL);
 482     hr = SchRpcGetTaskInfo(Task1, 0, NULL, &state);
 483     }
 484
 485     hr = SchRpcGetTaskInfo(Task1, 0, &enabled, &state);
 486     ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "expected ERROR_FILE_NOT_FOUND, got %#x\n", hr);
 487
 488     enabled = state = 0xdeadbeef;
 489     hr = SchRpcGetTaskInfo(Wine_Task1, 0, &enabled, &state);
 490     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 491     ok(enabled == 0, "expected 0, got %u\n", enabled);
 492     ok(state == TASK_STATE_UNKNOWN, "expected TASK_STATE_UNKNOWN, got %u\n", state);
 493
 494     enabled = state = 0xdeadbeef;
 495     hr = SchRpcGetTaskInfo(Wine_Task1, SCH_FLAG_STATE, &enabled, &state);
 496     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 497     ok(enabled == 0, "expected 0, got %u\n", enabled);
 498     ok(state == TASK_STATE_DISABLED, "expected TASK_STATE_DISABLED, got %u\n", state);
 499
 500     hr = SchRpcEnableTask(Wine_Task1, 0xdeadbeef);
 501 todo_wine
 502     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 503
 504     enabled = state = 0xdeadbeef;
 505     hr = SchRpcGetTaskInfo(Wine_Task1, SCH_FLAG_STATE, &enabled, &state);
 506     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 507 todo_wine
 508     ok(enabled == 1, "expected 1, got %u\n", enabled);
 509 todo_wine
 510     ok(state == TASK_STATE_READY, "expected TASK_STATE_READY, got %u\n", state);
 511
 512     hr = SchRpcDelete(Wine_Task1+1, 0);
 513     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 514     hr = SchRpcDelete(Wine_Task2+1, 0);
 515     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 516     hr = SchRpcDelete(Wine_Task3+1, 0);
 517     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 518     hr = SchRpcDelete(Wine, 0);
 519     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 520
 521     path = NULL;
 522     info = NULL;
 523     hr = SchRpcRegisterTask(NULL, xmlW, TASK_CREATE, NULL, TASK_LOGON_NONE, 0, NULL, &path, &info);
 524     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 525     ok(!info, "expected NULL, info %p\n", info);
 526     hr = IIDFromString(path, &iid);
 527     ok(hr == S_OK, "IIDFromString(%s) error %#x\n", wine_dbgstr_w(path), hr);
 528     hr = SchRpcDelete(path, 0);
 529     ok(hr == S_OK, "expected S_OK, got %#x\n", hr);
 530     MIDL_user_free(path);
 531
 532     hr = RpcBindingFree(&rpc_handle);
 533     ok(hr == RPC_S_OK, "RpcBindingFree error %#x\n", hr);
 534 }
 535
 536 void __RPC_FAR *__RPC_USER MIDL_user_allocate(SIZE_T n)
 537 {
 538     return HeapAlloc(GetProcessHeap(), 0, n);
 539 }
 540
 541 void __RPC_USER MIDL_user_free(void __RPC_FAR *p)
 542 {
 543     HeapFree(GetProcessHeap(), 0, p);
 544 }