ReactOS 0.4.15-dev-8116-gf69e256
job.c
Go to the documentation of this file.
1/*
2 * Unit test suite for Background Copy Job Interface
3 *
4 * Copyright 2007 Google (Roy Shea)
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21#include <stdio.h>
22
23#define COBJMACROS
24
25#include "wine/test.h"
26#include "bits.h"
27#include "initguid.h"
28#include "bits2_0.h"
29#include "bits2_5.h"
30
31/* Globals used by many tests */
32static const WCHAR test_displayName[] = {'T', 'e', 's', 't', 0};
40static BG_JOB_TYPE test_type;
41
43{
46
47 /* Creating BITS instance */
48 hres = CoCreateInstance(&CLSID_BackgroundCopyManager, NULL, CLSCTX_LOCAL_SERVER,
49 &IID_IBackgroundCopyManager, (void **) &manager);
50
52 win_skip("Needed Service is disabled\n");
53 return hres;
54 }
55
56 if (hres == S_OK)
57 IBackgroundCopyManager_Release(manager);
58
59 return hres;
60}
61
62static void init_paths(void)
63{
64 WCHAR tmpDir[MAX_PATH];
65 WCHAR prefix[] = {'q', 'm', 'g', 'r', 0};
66
67 GetTempPathW(MAX_PATH, tmpDir);
68
69 GetTempFileNameW(tmpDir, prefix, 0, test_localPathA);
70 GetTempFileNameW(tmpDir, prefix, 0, test_localPathB);
71 GetTempFileNameW(tmpDir, prefix, 0, test_remotePathA);
72 GetTempFileNameW(tmpDir, prefix, 0, test_remotePathB);
73}
74
75/* Generic test setup */
76static BOOL setup(void)
77{
79
81 test_job = NULL;
82 memset(&test_jobId, 0, sizeof test_jobId);
83 test_type = BG_JOB_TYPE_DOWNLOAD;
84
85 hres = CoCreateInstance(&CLSID_BackgroundCopyManager, NULL,
86 CLSCTX_LOCAL_SERVER,
87 &IID_IBackgroundCopyManager,
88 (void **) &test_manager);
89 if(hres != S_OK)
90 return FALSE;
91
92 hres = IBackgroundCopyManager_CreateJob(test_manager, test_displayName,
94 if(hres != S_OK)
95 {
96 IBackgroundCopyManager_Release(test_manager);
97 return FALSE;
98 }
99
100 return TRUE;
101}
102
103/* Generic test cleanup */
104static void teardown(void)
105{
106 IBackgroundCopyJob_Cancel(test_job);
107 IBackgroundCopyJob_Release(test_job);
108 IBackgroundCopyManager_Release(test_manager);
109}
110
111static BOOL check_bits20(void)
112{
114 IBackgroundCopyManager *manager;
115 IBackgroundCopyJob *job, *job3;
116
117 hres = CoCreateInstance(&CLSID_BackgroundCopyManager, NULL,
118 CLSCTX_LOCAL_SERVER, &IID_IBackgroundCopyManager,
119 (void **)&manager);
120 if (hres != S_OK) return FALSE;
121
122 hres = IBackgroundCopyManager_CreateJob(manager, test_displayName, test_type, &test_jobId, &job);
123 if (hres != S_OK)
124 {
125 IBackgroundCopyManager_Release(manager);
126 return FALSE;
127 }
128
129 hres = IBackgroundCopyJob_QueryInterface(job, &IID_IBackgroundCopyJob3, (void **)&job3);
130 IBackgroundCopyJob_Cancel(job);
131 IBackgroundCopyJob_Release(job);
132 if (hres != S_OK)
133 {
134 IBackgroundCopyManager_Release(manager);
135 return FALSE;
136 }
137
138 IBackgroundCopyJob_Release(job3);
139 IBackgroundCopyManager_Release(manager);
140 return TRUE;
141}
142
143static BOOL check_bits25(void)
144{
146 IBackgroundCopyManager *manager;
149
150 hres = CoCreateInstance(&CLSID_BackgroundCopyManager, NULL,
151 CLSCTX_LOCAL_SERVER, &IID_IBackgroundCopyManager,
152 (void **)&manager);
153 if (hres != S_OK) return FALSE;
154
155 hres = IBackgroundCopyManager_CreateJob(manager, test_displayName, test_type, &test_jobId, &job);
156 if (hres != S_OK)
157 {
158 IBackgroundCopyManager_Release(manager);
159 return FALSE;
160 }
161
162 hres = IBackgroundCopyJob_QueryInterface(job, &IID_IBackgroundCopyJobHttpOptions, (void **)&options);
163 IBackgroundCopyJob_Cancel(job);
164 IBackgroundCopyJob_Release(job);
165 if (hres != S_OK)
166 {
167 IBackgroundCopyManager_Release(manager);
168 return FALSE;
169 }
170
171 IBackgroundCopyJobHttpOptions_Release(options);
172 IBackgroundCopyManager_Release(manager);
173 return TRUE;
174}
175
176/* Test that the jobId is properly set */
177static void test_GetId(void)
178{
180 GUID tmpId;
181
182 hres = IBackgroundCopyJob_GetId(test_job, &tmpId);
183 ok(hres == S_OK, "GetId failed: %08x\n", hres);
184 ok(memcmp(&tmpId, &test_jobId, sizeof tmpId) == 0, "Got incorrect GUID\n");
185}
186
187/* Test that the type is properly set */
188static void test_GetType(void)
189{
191 BG_JOB_TYPE type;
192
193 hres = IBackgroundCopyJob_GetType(test_job, &type);
194 ok(hres == S_OK, "GetType failed: %08x\n", hres);
195 ok(type == test_type, "Got incorrect type\n");
196}
197
198/* Test that the display name is properly set */
199static void test_GetName(void)
200{
203
204 hres = IBackgroundCopyJob_GetDisplayName(test_job, &displayName);
205 ok(hres == S_OK, "GetName failed: %08x\n", hres);
206 ok(lstrcmpW(displayName, test_displayName) == 0, "Got incorrect type\n");
208}
209
210/* Test adding a file */
211static void test_AddFile(void)
212{
214
215 hres = IBackgroundCopyJob_AddFile(test_job, test_remotePathA,
217 ok(hres == S_OK, "First call to AddFile failed: 0x%08x\n", hres);
218
219 hres = IBackgroundCopyJob_AddFile(test_job, test_remotePathB,
221 ok(hres == S_OK, "Second call to AddFile failed: 0x%08x\n", hres);
222}
223
224/* Test adding a set of files */
225static void test_AddFileSet(void)
226{
228 BG_FILE_INFO files[2] =
229 {
232 };
233 hres = IBackgroundCopyJob_AddFileSet(test_job, 2, files);
234 ok(hres == S_OK, "AddFileSet failed: 0x%08x\n", hres);
235}
236
237/* Test creation of a job enumerator */
238static void test_EnumFiles(void)
239{
241 IEnumBackgroundCopyFiles *enumFiles;
242 ULONG res;
243
244 hres = IBackgroundCopyJob_AddFile(test_job, test_remotePathA,
246 ok(hres == S_OK, "got 0x%08x\n", hres);
247
248 hres = IBackgroundCopyJob_EnumFiles(test_job, &enumFiles);
249 ok(hres == S_OK, "EnumFiles failed: 0x%08x\n", hres);
250
251 res = IEnumBackgroundCopyFiles_Release(enumFiles);
252 ok(res == 0, "Bad ref count on release: %u\n", res);
253}
254
255/* Test getting job progress */
257{
259 BG_JOB_PROGRESS progress;
260
261 hres = IBackgroundCopyJob_GetProgress(test_job, &progress);
262 ok(hres == S_OK, "GetProgress failed: 0x%08x\n", hres);
263
264 ok(progress.BytesTotal == 0, "Incorrect BytesTotal: %s\n",
265 wine_dbgstr_longlong(progress.BytesTotal));
266 ok(progress.BytesTransferred == 0, "Incorrect BytesTransferred: %s\n",
267 wine_dbgstr_longlong(progress.BytesTransferred));
268 ok(progress.FilesTotal == 0, "Incorrect FilesTotal: %u\n", progress.FilesTotal);
269 ok(progress.FilesTransferred == 0, "Incorrect FilesTransferred %u\n", progress.FilesTransferred);
270}
271
272/* Test getting job state */
273static void test_GetState(void)
274{
276 BG_JOB_STATE state;
277
278 state = BG_JOB_STATE_ERROR;
279 hres = IBackgroundCopyJob_GetState(test_job, &state);
280 ok(hres == S_OK, "GetState failed: 0x%08x\n", hres);
281 ok(state == BG_JOB_STATE_SUSPENDED, "Incorrect job state: %d\n", state);
282}
283
284/* Test resuming a job */
285static void test_ResumeEmpty(void)
286{
288 BG_JOB_STATE state;
289
290 hres = IBackgroundCopyJob_Resume(test_job);
291 ok(hres == BG_E_EMPTY, "Resume failed to return BG_E_EMPTY error: 0x%08x\n", hres);
292
293 state = BG_JOB_STATE_ERROR;
294 hres = IBackgroundCopyJob_GetState(test_job, &state);
295 ok(hres == S_OK, "got 0x%08x\n", hres);
296 ok(state == BG_JOB_STATE_SUSPENDED, "Incorrect job state: %d\n", state);
297}
298
299static void makeFile(WCHAR *name, const char *contents)
300{
301 HANDLE file;
303
307 ok(file != INVALID_HANDLE_VALUE, "CreateFile\n");
308 ok(WriteFile(file, contents, len, &w, NULL), "WriteFile\n");
310}
311
312static void compareFiles(WCHAR *n1, WCHAR *n2)
313{
314 char b1[256];
315 char b2[256];
316 DWORD s1, s2;
317 HANDLE f1, f2;
318
321 ok(f1 != INVALID_HANDLE_VALUE, "CreateFile\n");
322
325 ok(f2 != INVALID_HANDLE_VALUE, "CreateFile\n");
326
327 /* Neither of these files is very big */
328 ok(ReadFile(f1, b1, sizeof b1, &s1, NULL), "ReadFile\n");
329 ok(ReadFile(f2, b2, sizeof b2, &s2, NULL), "ReadFile\n");
330
333
334 ok(s1 == s2, "Files differ in length\n");
335 ok(memcmp(b1, b2, s1) == 0, "Files differ in contents\n");
336}
337
338/* Test a complete transfer for local files */
339static void test_CompleteLocal(void)
340{
341 static const int timeout_sec = 30;
343 BG_JOB_STATE state;
344 int i;
345
348 makeFile(test_remotePathA, "This is a WINE test file for BITS\n");
349 makeFile(test_remotePathB, "This is another WINE test file for BITS\n");
350
351 hres = IBackgroundCopyJob_AddFile(test_job, test_remotePathA,
353 ok(hres == S_OK, "got 0x%08x\n", hres);
354
355 hres = IBackgroundCopyJob_AddFile(test_job, test_remotePathB,
357 ok(hres == S_OK, "got 0x%08x\n", hres);
358
359 hres = IBackgroundCopyJob_Resume(test_job);
360 ok(hres == S_OK, "IBackgroundCopyJob_Resume\n");
361
363 for (i = 0; i < timeout_sec; ++i)
364 {
365 hres = IBackgroundCopyJob_GetState(test_job, &state);
366 ok(hres == S_OK, "IBackgroundCopyJob_GetState\n");
367 ok(state == BG_JOB_STATE_QUEUED || state == BG_JOB_STATE_CONNECTING
368 || state == BG_JOB_STATE_TRANSFERRING || state == BG_JOB_STATE_TRANSFERRED,
369 "Bad state: %d\n", state);
370 if (state == BG_JOB_STATE_TRANSFERRED)
371 break;
372 Sleep(1000);
373 }
374
375 ok(i < timeout_sec, "BITS jobs timed out\n");
376 hres = IBackgroundCopyJob_Complete(test_job);
377 ok(hres == S_OK, "IBackgroundCopyJob_Complete\n");
378 hres = IBackgroundCopyJob_GetState(test_job, &state);
379 ok(hres == S_OK, "IBackgroundCopyJob_GetState\n");
380 ok(state == BG_JOB_STATE_ACKNOWLEDGED, "Bad state: %d\n", state);
381
384
385 ok(DeleteFileW(test_remotePathA), "DeleteFile\n");
386 ok(DeleteFileW(test_remotePathB), "DeleteFile\n");
389}
390
391/* Test a complete transfer for local files */
392static void test_CompleteLocalURL(void)
393{
394 static const WCHAR prot[] = {'f','i','l','e',':','/','/', 0};
395 static const int timeout_sec = 30;
396 WCHAR *urlA, *urlB;
398 BG_JOB_STATE state;
399 int i;
400
403 makeFile(test_remotePathA, "This is a WINE test file for BITS\n");
404 makeFile(test_remotePathB, "This is another WINE test file for BITS\n");
405
406 urlA = HeapAlloc(GetProcessHeap(), 0,
407 (7 + lstrlenW(test_remotePathA) + 1) * sizeof urlA[0]);
408 urlB = HeapAlloc(GetProcessHeap(), 0,
409 (7 + lstrlenW(test_remotePathB) + 1) * sizeof urlB[0]);
410 if (!urlA || !urlB)
411 {
412 skip("Unable to allocate memory for URLs\n");
413 HeapFree(GetProcessHeap(), 0, urlA);
414 HeapFree(GetProcessHeap(), 0, urlB);
415 return;
416 }
417
418 lstrcpyW(urlA, prot);
420 lstrcpyW(urlB, prot);
422
423 hres = IBackgroundCopyJob_AddFile(test_job, urlA, test_localPathA);
424 ok(hres == S_OK, "got 0x%08x\n", hres);
425
426 hres = IBackgroundCopyJob_AddFile(test_job, urlB, test_localPathB);
427 ok(hres == S_OK, "got 0x%08x\n", hres);
428
429 hres = IBackgroundCopyJob_Resume(test_job);
430 ok(hres == S_OK, "IBackgroundCopyJob_Resume\n");
431
433 for (i = 0; i < timeout_sec; ++i)
434 {
435 hres = IBackgroundCopyJob_GetState(test_job, &state);
436 ok(hres == S_OK, "IBackgroundCopyJob_GetState\n");
437 ok(state == BG_JOB_STATE_QUEUED || state == BG_JOB_STATE_CONNECTING
438 || state == BG_JOB_STATE_TRANSFERRING || state == BG_JOB_STATE_TRANSFERRED,
439 "Bad state: %d\n", state);
440 if (state == BG_JOB_STATE_TRANSFERRED)
441 break;
442 Sleep(1000);
443 }
444
445 ok(i < timeout_sec, "BITS jobs timed out\n");
446 hres = IBackgroundCopyJob_Complete(test_job);
447 ok(hres == S_OK, "IBackgroundCopyJob_Complete\n");
448 hres = IBackgroundCopyJob_GetState(test_job, &state);
449 ok(hres == S_OK, "IBackgroundCopyJob_GetState\n");
450 ok(state == BG_JOB_STATE_ACKNOWLEDGED, "Bad state: %d\n", state);
451
454
455 ok(DeleteFileW(test_remotePathA), "DeleteFile\n");
456 ok(DeleteFileW(test_remotePathB), "DeleteFile\n");
459
460 HeapFree(GetProcessHeap(), 0, urlA);
461 HeapFree(GetProcessHeap(), 0, urlB);
462}
463
464static void test_NotifyFlags(void)
465{
466 ULONG flags;
467 HRESULT hr;
468
469 /* check default flags */
470 flags = 0;
471 hr = IBackgroundCopyJob_GetNotifyFlags(test_job, &flags);
472 ok(hr == S_OK, "got 0x%08x\n", hr);
473 ok(flags == (BG_NOTIFY_JOB_ERROR | BG_NOTIFY_JOB_TRANSFERRED), "flags 0x%08x\n", flags);
474}
475
476static void test_NotifyInterface(void)
477{
478 HRESULT hr;
479 IUnknown *unk;
480
481 unk = (IUnknown*)0xdeadbeef;
482 hr = IBackgroundCopyJob_GetNotifyInterface(test_job, &unk);
483 ok(hr == S_OK, "got 0x%08x\n", hr);
484 ok(unk == NULL, "got %p\n", unk);
485}
486
487static void test_Cancel(void)
488{
489 HRESULT hr;
490 BG_JOB_STATE state;
491
492 state = BG_JOB_STATE_ERROR;
493 hr = IBackgroundCopyJob_GetState(test_job, &state);
494 ok(hr == S_OK, "got 0x%08x\n", hr);
495 ok(state != BG_JOB_STATE_CANCELLED, "got %u\n", state);
496
497 hr = IBackgroundCopyJob_Cancel(test_job);
498 ok(hr == S_OK, "got 0x%08x\n", hr);
499
500 state = BG_JOB_STATE_ERROR;
501 hr = IBackgroundCopyJob_GetState(test_job, &state);
502 ok(hr == S_OK, "got 0x%08x\n", hr);
503 ok(state == BG_JOB_STATE_CANCELLED, "got %u\n", state);
504
505 hr = IBackgroundCopyJob_Cancel(test_job);
506 ok(hr == BG_E_INVALID_STATE, "got 0x%08x\n", hr);
507}
508
509static void test_HttpOptions(void)
510{
511 static const WCHAR urlW[] =
512 {'h','t','t','p','s',':','/','/','t','e','s','t','.','w','i','n','e','h','q','.','o','r','g','/',0};
513 static const WCHAR winetestW[] =
514 {'W','i','n','e',':',' ','t','e','s','t','\r','\n',0};
515 static const unsigned int timeout = 30;
516 HRESULT hr;
519 BG_JOB_STATE state;
520 unsigned int i;
521 WCHAR *headers;
522 ULONG flags, orig_flags;
523
525 hr = IBackgroundCopyJob_AddFile(test_job, urlW, test_localPathA);
526 ok(hr == S_OK, "got 0x%08x\n", hr);
527
528 hr = IBackgroundCopyJob_QueryInterface(test_job, &IID_IBackgroundCopyJobHttpOptions, (void **)&options);
529 ok(hr == S_OK, "got 0x%08x\n", hr);
530
531 if (options)
532 {
533 headers = (WCHAR *)0xdeadbeef;
534 hr = IBackgroundCopyJobHttpOptions_GetCustomHeaders(options, &headers);
535 ok(hr == S_FALSE, "got 0x%08x\n", hr);
536 ok(headers == NULL, "got %p\n", headers);
537
538 hr = IBackgroundCopyJobHttpOptions_SetCustomHeaders(options, winetestW);
539 ok(hr == S_OK, "got 0x%08x\n", hr);
540
541 headers = (WCHAR *)0xdeadbeef;
542 hr = IBackgroundCopyJobHttpOptions_GetCustomHeaders(options, &headers);
543 ok(hr == S_OK, "got 0x%08x\n", hr);
544 if (hr == S_OK)
545 {
548 }
549
550 hr = IBackgroundCopyJobHttpOptions_SetCustomHeaders(options, NULL);
551 ok(hr == S_OK, "got 0x%08x\n", hr);
552
553 headers = (WCHAR *)0xdeadbeef;
554 hr = IBackgroundCopyJobHttpOptions_GetCustomHeaders(options, &headers);
555 ok(hr == S_FALSE, "got 0x%08x\n", hr);
556 ok(headers == NULL, "got %p\n", headers);
557
558 orig_flags = 0xdeadbeef;
559 hr = IBackgroundCopyJobHttpOptions_GetSecurityFlags(options, &orig_flags);
560 ok(hr == S_OK, "got 0x%08x\n", hr);
561 ok(!orig_flags, "got 0x%08x\n", orig_flags);
562
563 hr = IBackgroundCopyJobHttpOptions_SetSecurityFlags(options, 0);
564 ok(hr == S_OK, "got 0x%08x\n", hr);
565
566 flags = 0xdeadbeef;
567 hr = IBackgroundCopyJobHttpOptions_GetSecurityFlags(options, &flags);
568 ok(hr == S_OK, "got 0x%08x\n", hr);
569 ok(!flags, "got 0x%08x\n", flags);
570 }
571
572 hr = IBackgroundCopyJob_Resume(test_job);
573 ok(hr == S_OK, "got 0x%08x\n", hr);
574
576 for (i = 0; i < timeout; i++)
577 {
578 hr = IBackgroundCopyJob_GetState(test_job, &state);
579 ok(hr == S_OK, "got 0x%08x\n", hr);
580
581 ok(state == BG_JOB_STATE_QUEUED ||
582 state == BG_JOB_STATE_CONNECTING ||
583 state == BG_JOB_STATE_TRANSFERRING ||
584 state == BG_JOB_STATE_TRANSFERRED, "unexpected state: %u\n", state);
585
586 if (state == BG_JOB_STATE_TRANSFERRED) break;
587 Sleep(1000);
588 }
589 ok(i < timeout, "BITS job timed out\n");
590 if (i < timeout)
591 {
592 hr = IBackgroundCopyJob_GetError(test_job, &error);
593 ok(hr == BG_E_ERROR_INFORMATION_UNAVAILABLE, "got 0x%08x\n", hr);
594 }
595
596 if (options)
597 {
598 headers = (WCHAR *)0xdeadbeef;
599 hr = IBackgroundCopyJobHttpOptions_GetCustomHeaders(options, &headers);
600 ok(hr == S_FALSE, "got 0x%08x\n", hr);
601 ok(headers == NULL, "got %p\n", headers);
602
603 hr = IBackgroundCopyJobHttpOptions_SetCustomHeaders(options, NULL);
604 ok(hr == S_OK, "got 0x%08x\n", hr);
605
606 hr = IBackgroundCopyJobHttpOptions_GetCustomHeaders(options, &headers);
607 ok(hr == S_FALSE, "got 0x%08x\n", hr);
608
609 flags = 0xdeadbeef;
610 hr = IBackgroundCopyJobHttpOptions_GetSecurityFlags(options, &flags);
611 ok(hr == S_OK, "got 0x%08x\n", hr);
612 ok(!flags, "got 0x%08x\n", flags);
613
614 hr = IBackgroundCopyJobHttpOptions_SetSecurityFlags(options, orig_flags);
615 ok(hr == S_OK, "got 0x%08x\n", hr);
616
617 IBackgroundCopyJobHttpOptions_Release(options);
618 }
619
620 hr = IBackgroundCopyJob_Complete(test_job);
621 ok(hr == S_OK, "got 0x%08x\n", hr);
622
623 hr = IBackgroundCopyJob_GetState(test_job, &state);
624 ok(hr == S_OK, "got 0x%08x\n", hr);
625 ok(state == BG_JOB_STATE_ACKNOWLEDGED, "unexpected state: %u\n", state);
626
627 hr = IBackgroundCopyJob_Complete(test_job);
628 ok(hr == BG_E_INVALID_STATE, "got 0x%08x\n", hr);
629
631}
632
633typedef void (*test_t)(void);
634
636{
637 static const test_t tests[] = {
646 0
647 };
648 static const test_t tests_bits20[] = {
654 test_Cancel, /* must be last */
655 0
656 };
657 static const test_t tests_bits25[] = {
659 0
660 };
661 const test_t *test;
662 int i;
663
664 init_paths();
665
667
669 {
671 win_skip("Failed to create Manager instance, skipping tests\n");
672 return;
673 }
674
675 for (test = tests, i = 0; *test; ++test, ++i)
676 {
677 /* Keep state separate between tests. */
678 if (!setup())
679 {
680 ok(0, "tests:%d: Unable to setup test\n", i);
681 break;
682 }
683 (*test)();
684 teardown();
685 }
686
687 if (check_bits20())
688 {
689 for (test = tests_bits20, i = 0; *test; ++test, ++i)
690 {
691 /* Keep state separate between tests. */
692 if (!setup())
693 {
694 ok(0, "tests_bits20:%d: Unable to setup test\n", i);
695 break;
696 }
697 (*test)();
698 teardown();
699 }
700 }
701 else
702 {
703 win_skip("Tests need BITS 2.0 or higher\n");
704 }
705
706 if (check_bits25())
707 {
708 for (test = tests_bits25, i = 0; *test; ++test, ++i)
709 {
710 /* Keep state separate between tests. */
711 if (!setup())
712 {
713 ok(0, "tests_bits25:%d: Unable to setup test\n", i);
714 break;
715 }
716 (*test)();
717 teardown();
718 }
719 }
720 else
721 {
722 win_skip("Tests need BITS 2.5 or higher\n");
723 }
724
726}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
static int state
Definition: maze.c:121
#define ok(value,...)
Definition: atltest.h:57
#define skip(...)
Definition: atltest.h:64
#define START_TEST(x)
Definition: atltest.h:75
#define BG_E_EMPTY
Definition: bitsmsg.h:40
#define BG_E_ERROR_INFORMATION_UNAVAILABLE
Definition: bitsmsg.h:45
#define BG_E_INVALID_STATE
Definition: bitsmsg.h:39
cd_progress_ptr progress
Definition: cdjpeg.h:152
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define CloseHandle
Definition: compat.h:739
#define GetProcessHeap()
Definition: compat.h:736
#define OPEN_EXISTING
Definition: compat.h:775
#define ReadFile(a, b, c, d, e)
Definition: compat.h:742
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define HeapAlloc
Definition: compat.h:733
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
#define GENERIC_READ
Definition: compat.h:135
#define MAX_PATH
Definition: compat.h:34
#define HeapFree(x, y, z)
Definition: compat.h:735
#define CreateFileW
Definition: compat.h:741
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
#define lstrcpyW
Definition: compat.h:749
#define FILE_SHARE_READ
Definition: compat.h:136
#define lstrlenW
Definition: compat.h:750
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
DWORD WINAPI GetTempPathW(IN DWORD count, OUT LPWSTR path)
Definition: path.c:2080
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4242
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3325
HRESULT WINAPI CoInitialize(LPVOID lpReserved)
Definition: compobj.c:1964
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
UINT WINAPI GetTempFileNameW(IN LPCWSTR lpPathName, IN LPCWSTR lpPrefixString, IN UINT uUnique, OUT LPWSTR lpTempFileName)
Definition: filename.c:84
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLuint res
Definition: glext.h:9613
GLbitfield flags
Definition: glext.h:7161
GLenum GLsizei len
Definition: glext.h:6722
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
#define S_OK
Definition: intsafe.h:52
#define FAILED(hr)
Definition: intsafe.h:51
#define wine_dbgstr_w
Definition: kernel32.h:34
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
struct S1 s1
struct S2 s2
#define error(str)
Definition: mkdosfs.c:1605
#define CREATE_ALWAYS
Definition: disk.h:72
static struct test_info tests[]
static CRYPT_DATA_BLOB b2[]
Definition: msg.c:582
static CRYPT_DATA_BLOB b1[]
Definition: msg.c:573
HRESULT hres
Definition: protocol.c:465
static HANDLE job
Definition: process.c:77
static void test_AddFile(void)
Definition: job.c:211
static BOOL check_bits20(void)
Definition: job.c:111
static GUID test_jobId
Definition: job.c:39
static void test_GetProgress_preTransfer(void)
Definition: job.c:256
static void init_paths(void)
Definition: job.c:62
static void test_NotifyInterface(void)
Definition: job.c:476
static WCHAR test_localPathA[MAX_PATH]
Definition: job.c:35
static void test_GetName(void)
Definition: job.c:199
static void teardown(void)
Definition: job.c:104
static void test_CompleteLocal(void)
Definition: job.c:339
static WCHAR test_localPathB[MAX_PATH]
Definition: job.c:36
static void test_EnumFiles(void)
Definition: job.c:238
static void test_ResumeEmpty(void)
Definition: job.c:285
static void test_NotifyFlags(void)
Definition: job.c:464
static void test_GetState(void)
Definition: job.c:273
static WCHAR test_remotePathA[MAX_PATH]
Definition: job.c:33
static void test_HttpOptions(void)
Definition: job.c:509
static void test_AddFileSet(void)
Definition: job.c:225
static WCHAR test_remotePathB[MAX_PATH]
Definition: job.c:34
static void makeFile(WCHAR *name, const char *contents)
Definition: job.c:299
static void test_GetId(void)
Definition: job.c:177
static BOOL setup(void)
Definition: job.c:76
static void test_CompleteLocalURL(void)
Definition: job.c:392
static void compareFiles(WCHAR *n1, WCHAR *n2)
Definition: job.c:312
static BG_JOB_TYPE test_type
Definition: job.c:40
static void test_Cancel(void)
Definition: job.c:487
static IBackgroundCopyJob * test_job
Definition: job.c:38
static BOOL check_bits25(void)
Definition: job.c:143
static void test_GetType(void)
Definition: job.c:188
static IBackgroundCopyManager * test_manager
Definition: job.c:37
static const WCHAR test_displayName[]
Definition: job.c:32
static HRESULT test_create_manager(void)
Definition: job.c:42
void(* test_t)(void)
Definition: job.c:633
static const char * contents
Definition: parser.c:511
#define GENERIC_WRITE
Definition: nt_native.h:90
#define test
Definition: rosglue.h:37
int n2
Definition: dwarfget.c:147
int n1
Definition: dwarfget.c:147
#define win_skip
Definition: test.h:163
#define disable_success_count
Definition: test.h:184
#define f2(x, y, z)
Definition: sha1.c:31
#define f1(x, y, z)
Definition: sha1.c:30
#define memset(x, y, z)
Definition: compat.h:39
vector< Header * > headers
Definition: sdkparse.cpp:39
static const WCHAR winetestW[]
Definition: shelldispatch.c:47
HRESULT hr
Definition: shlfolder.c:183
Definition: fci.c:127
Definition: name.c:39
Definition: dhcpd.h:245
VOID WINAPI DECLSPEC_HOTPATCH Sleep(IN DWORD dwMilliseconds)
Definition: synch.c:790
char displayName[]
Definition: tftpd.cpp:35
uint32_t ULONG
Definition: typedefs.h:59
#define S_FALSE
Definition: winerror.h:2357
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
#define ERROR_SERVICE_DISABLED
Definition: winerror.h:609
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184