void Test_RtlInitializeBitMap(void) { RTL_BITMAP BitMapHeader; ULONG Buffer[2]; BOOLEAN Exception = FALSE; _SEH2_TRY { RtlInitializeBitMap(NULL, NULL, 0); } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { Exception = TRUE; } _SEH2_END; ok_int(Exception, 1); memset(Buffer, 0xcc, sizeof(Buffer)); RtlInitializeBitMap(&BitMapHeader, Buffer, 0); ok_int(BitMapHeader.SizeOfBitMap, 0); ok_ptr(BitMapHeader.Buffer, Buffer); ok_hex(Buffer[0], 0xcccccccc); RtlInitializeBitMap(&BitMapHeader, Buffer, 8); ok_int(BitMapHeader.SizeOfBitMap, 8); ok_hex(Buffer[0], 0xcccccccc); }
void Test_RtlNumberOfClearBits(void) { RTL_BITMAP BitMapHeader; ULONG *Buffer; Buffer = AllocateGuarded(2 * sizeof(*Buffer)); Buffer[0] = 0xff00fff0; Buffer[1] = 0x3F303F30; RtlInitializeBitMap(&BitMapHeader, Buffer, 0); ok_int(RtlNumberOfClearBits(&BitMapHeader), 0); RtlInitializeBitMap(&BitMapHeader, Buffer, 4); ok_int(RtlNumberOfClearBits(&BitMapHeader), 4); RtlInitializeBitMap(&BitMapHeader, Buffer, 31); ok_int(RtlNumberOfClearBits(&BitMapHeader), 12); RtlInitializeBitMap(&BitMapHeader, Buffer, 56); ok_int(RtlNumberOfClearBits(&BitMapHeader), 26); RtlInitializeBitMap(&BitMapHeader, Buffer, 64); ok_int(RtlNumberOfClearBits(&BitMapHeader), 28); FreeGuarded(Buffer); }
int main(int argc, char **argv) { int ret, r2; runcmd_init(); t_set_colors(0); t_start("exec output comparison"); { int i; char *out = calloc(1, BUF_SIZE); for (i = 0; cases[i].input != NULL; i++) { memset(out, 0, BUF_SIZE); int pfd[2] = {-1, -1}, pfderr[2] = {-1, -1}; int fd; char *cmd; asprintf(&cmd, "/bin/echo -n %s", cases[i].input); fd = runcmd_open(cmd, pfd, pfderr, NULL); read(pfd[0], out, BUF_SIZE); ok_str(cases[i].output, out, "Echoing a command should give expected output"); close(pfd[0]); close(pfderr[0]); close(fd); } } ret = t_end(); t_reset(); t_start("anomaly detection"); { int i; for (i = 0; anomaly[i].cmd; i++) { int out_argc; char *out_argv[256]; int result = runcmd_cmd2strv(anomaly[i].cmd, &out_argc, out_argv); ok_int(result, anomaly[i].ret, anomaly[i].cmd); } } r2 = t_end(); ret = r2 ? r2 : ret; t_reset(); t_start("argument splitting"); { int i; for (i = 0; parse_case[i].cmd; i++) { int x, out_argc; char *out_argv[256]; int result = runcmd_cmd2strv(parse_case[i].cmd, &out_argc, out_argv); out_argv[out_argc] = NULL; ok_int(result, 0, parse_case[i].cmd); ok_int(out_argc, parse_case[i].argc_exp, parse_case[i].cmd); for (x = 0; x < parse_case[x].argc_exp && out_argv[x]; x++) { ok_str(parse_case[i].argv_exp[x], out_argv[x], "argv comparison test"); } } } r2 = t_end(); return r2 ? r2 : ret; }
void Test_RtlFindLeastSignificantBit(void) { ok_int(RtlFindLeastSignificantBit(0), -1); ok_int(RtlFindLeastSignificantBit(0x0000000000000001ULL), 0); ok_int(RtlFindLeastSignificantBit(0x0000000000000002ULL), 1); ok_int(RtlFindLeastSignificantBit(0x1000000000000000ULL), 60); ok_int(RtlFindLeastSignificantBit(0x8000000000000000ULL), 63); ok_int(RtlFindLeastSignificantBit(0x8000000000000000ULL), 63); ok_int(RtlFindLeastSignificantBit(0xFFFFFFFFFFFFFFFFULL), 0); ok_int(RtlFindLeastSignificantBit(0x0000000070000000ULL), 28); }
int main(int argc, char **argv) { unsigned long k; struct test_data *td; t_set_colors(0); t_start("fanout tests"); run_tests(10, 64); run_tests(512, 64); run_tests(64, 64); run_tests(511, 17); destroyed = 0; fot = fanout_create(512); ok_int(fanout_remove(fot, 12398) == NULL, 1, "remove on empty table must yield NULL"); ok_int(fanout_get(fot, 123887987) == NULL, 1, "get on empty table must yield NULL"); for (k = 0; k < 16385; k++) { struct test_data *tdata = calloc(1, sizeof(*td)); tdata->key = k; asprintf(&tdata->name, "%lu", k); fanout_add(fot, k, tdata); } td = fanout_get(fot, k - 1); ok_int(td != NULL, 1, "get must get what add inserts"); ok_int(fanout_remove(fot, k + 1) == NULL, 1, "remove on non-inserted key must yield NULL"); ok_int(fanout_get(fot, k + 1) == NULL, 1, "get on non-inserted must yield NULL"); fanout_destroy(fot, pdest); ok_int((int)destroyed, (int)k, "destroy counter while free()'ing"); return t_end(); }
static void run_tests(int ntests, int fo_size) { struct tcase *tc; unsigned long last_ptr, *ptr; int i, added = 0, removed = 0; fanout_table *fo; last_ptr = ntests; fo = fanout_create(fo_size); tc = calloc(ntests, sizeof(*tc)); for (i = 0; i < ntests; i++) { tc[i].value = i; if (!fanout_add(fo, tc[i].key, &tc[i].value)) added++; } ok_int(added, ntests, "Adding stuff must work"); while ((ptr = (unsigned long *)fanout_remove(fo, 0))) { ok_int((int)*ptr, (int)last_ptr - 1, "Removing a bunch of them"); removed++; last_ptr = *ptr; } ok_int(added, removed, "Removing should work as well as adding"); fanout_destroy(fo, destructor); ok_int(destroyed, 0, "Expected no entries in destructor"); fo = fanout_create(fo_size); for (i = 0; i < ntests; i++) { tc[i].value = i; if (!fanout_add(fo, tc[i].key, &tc[i].value)) added++; } fanout_destroy(fo, destructor); ok_int(destroyed, ntests, "Expected ntest entries in destructor"); destroyed = 0; free(tc); }
int main(int argc, char **argv) { int listen_fd, flags, sockopt = 1; struct sockaddr_in sain; int error; const char *err_msg; t_set_colors(0); t_start("iobroker ipc test"); error = iobroker_get_max_fds(NULL); ok_int(error, IOBROKER_ENOSET, "test errors when passing null"); err_msg = iobroker_strerror(error); test(err_msg && !strcmp(err_msg, iobroker_errors[(~error) + 1].string), "iobroker_strerror() returns the right string"); iobs = iobroker_create(); error = iobroker_get_max_fds(iobs); test(iobs && error >= 0, "max fd's for real iobroker set must be > 0"); listen_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); flags = fcntl(listen_fd, F_GETFD); flags |= FD_CLOEXEC; fcntl(listen_fd, F_SETFD, flags); (void)setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &sockopt, sizeof(sockopt)); memset(&sain, 0, sizeof(sain)); sain.sin_port = ntohs(9123); sain.sin_family = AF_INET; bind(listen_fd, (struct sockaddr *)&sain, sizeof(sain)); listen(listen_fd, 128); iobroker_register(iobs, listen_fd, iobs, listen_handler); if (argc == 1) conn_spam(&sain); for (;;) { iobroker_poll(iobs, -1); if (iobroker_get_num_fds(iobs) <= 1) { break; } } iobroker_close(iobs, listen_fd); iobroker_destroy(iobs, 0); t_end(); return 0; }
static int echo_service(int fd, int events, void *arg) { char buf[1024]; int len; len = read(fd, buf, sizeof(buf)); if (len < 0) { perror("read"); iobroker_close(iobs, fd); ok_int(iobroker_is_registered(iobs, fd), 0, "Closing must deregister"); return 0; } /* zero read means we're disconnected */ if (!len) { iobroker_close(iobs, fd); ok_int(iobroker_is_registered(iobs, fd), 0, "Closing must deregister"); return 0; } if (write(fd, buf, len) < 0) t_fail("write returned failure: %s", strerror(errno)); return 0; }
int gretl_isdiscrete (int t1, int t2, const double *x) { int t, n = 0, d = 1; double r = 0; for (t=t1; t<=t2; t++) { if (na(x[t])) { continue; } n++; if (!ok_int(x[t])) { d = 0; break; } r = x[t] - floor(x[t]); if (r != 0.0 && r != 0.25 && r != 0.5 && r != 0.75) { d = 0; break; } } if (n == 0) { d = 0; } if (d) { n = few_vals(t1, t2, x, &r); if (n > FEWVALS) { d = 0; } else if (r > 0.9 && n > 30) { /* somewhat arbitrary: but if r (= ratio of distinct values to number of cases) is "too high", and the number of observations is not tiny, perhaps we should not take the var as discrete */ d = 0; } else if (n < 5) { d = 2; } } return d; }
static int listen_handler(int fd, int events, void *arg) { int sock; struct sockaddr_in sain; socklen_t addrlen; if (!arg || arg != iobs) { printf("Argument passing seems to fail spectacularly\n"); } addrlen = sizeof(sain); //printf("listen_handler(%d, %d, %p) called\n", fd, events, arg); sock = accept(fd, (struct sockaddr *)&sain, &addrlen); if (sock < 0) { perror("accept"); return -1; } if (write(sock, msg[0], strlen(msg[0])) < 0) t_fail("write returned failure: %s", strerror(errno)); iobroker_register(iobs, sock, iobs, echo_service); ok_int(iobroker_is_registered(iobs, sock), 1, "is_registered must be true"); return 0; }
void Test_GetRandomRgn_Params() { HDC hdc; HRGN hrgn; INT ret; hdc = CreateCompatibleDC(0); if (!hdc) { printf("Coun't create a dc\n"); return; } hrgn = CreateRectRgn(11, 17, 23, 42); if (!hrgn) { printf("Coun't create a region\n"); return; } SetLastError(0xbadbad00); ret = GetRandomRgn(NULL, NULL, 0); ok_int(ret, -1); ok((GetLastError() == 0xbadbad00) || (GetLastError() == ERROR_INVALID_HANDLE), "wrong error: %ld\n", GetLastError()); SetLastError(0xbadbad00); ret = GetRandomRgn(NULL, NULL, CLIPRGN); ok_int(ret, -1); ok((GetLastError() == 0xbadbad00) || (GetLastError() == ERROR_INVALID_HANDLE), "wrong error: %ld\n", GetLastError()); SetLastError(0xbadbad00); ret = GetRandomRgn(NULL, hrgn, 0); ok_int(ret, -1); ok((GetLastError() == 0xbadbad00) || (GetLastError() == ERROR_INVALID_HANDLE), "wrong error: %ld\n", GetLastError()); SetLastError(0xbadbad00); ret = GetRandomRgn(NULL, hrgn, CLIPRGN); ok_int(ret, -1); ok((GetLastError() == 0xbadbad00) || (GetLastError() == ERROR_INVALID_HANDLE), "wrong error: %ld\n", GetLastError()); SetLastError(0xbadbad00); ret = GetRandomRgn(hdc, NULL, 0); ok_int(ret, 0); ok_err(0xbadbad00); SetLastError(0xbadbad00); ret = GetRandomRgn(hdc, NULL, CLIPRGN); ok_int(ret, 0); ok_err(0xbadbad00); SetLastError(0xbadbad00); ret = GetRandomRgn(hdc, hrgn, 0); ok_int(ret, 0); ok_err(0xbadbad00); #if 0 // this is vista+ SetLastError(0xbadbad00); ret = GetRandomRgn(hdc, hrgn, 5); ok_int(ret, 1); ok_err(0xbadbad00); #endif SetLastError(0xbadbad00); ret = GetRandomRgn(hdc, hrgn, 6); ok_int(ret, 0); ok_err(0xbadbad00); SetLastError(0xbadbad00); ret = GetRandomRgn(hdc, hrgn, 27); ok_int(ret, 0); ok_err(0xbadbad00); SetLastError(0xbadbad00); ret = GetRandomRgn(hdc, hrgn, -1); ok_int(ret, 0); ok_err(0xbadbad00); SetLastError(0xbadbad00); ret = GetRandomRgn(hdc, hrgn, CLIPRGN); ok_int(ret, 0); ok_err(0xbadbad00); SetLastError(0xbadbad00); ret = GetRandomRgn((HDC)0x123, hrgn, CLIPRGN); ok_int(ret, -1); ok((GetLastError() == 0xbadbad00) || (GetLastError() == ERROR_INVALID_HANDLE), "wrong error: %ld\n", GetLastError()); DeleteObject(hrgn); DeleteDC(hdc); }
void Test_GetRandomRgn_CLIPRGN() { HDC hdc; HRGN hrgn1, hrgn2; INT ret; RECT rect; hrgn1 = CreateRectRgn(11, 17, 23, 42); if (!hrgn1) { printf("Coun't create a region\n"); return; } hdc = CreateCompatibleDC(0); if (!hdc) { printf("Coun't create a dc\n"); return; } ret = GetRandomRgn(hdc, hrgn1, CLIPRGN); ok_int(ret, 0); GetRgnBox(hrgn1, &rect); ok_long(rect.left, 11); ok_long(rect.top, 17); ok_long(rect.right, 23); ok_long(rect.bottom, 42); hrgn2 = CreateRectRgn(1, 2, 3, 4); SelectClipRgn(hdc, hrgn2); DeleteObject(hrgn2); ret = GetRandomRgn(hdc, hrgn1, CLIPRGN); ok_int(ret, 1); GetRgnBox(hrgn1, &rect); ok_long(rect.left, 1); ok_long(rect.top, 2); ok_long(rect.right, 3); ok_long(rect.bottom, 4); hrgn2 = CreateRectRgn(2, 3, 4, 5); SelectClipRgn(ghdcWindow, hrgn2); DeleteObject(hrgn2); ret = GetRandomRgn(ghdcWindow, hrgn1, CLIPRGN); ok_int(ret, 1); GetRgnBox(hrgn1, &rect); ok_long(rect.left, 2); ok_long(rect.top, 3); ok_long(rect.right, 4); ok_long(rect.bottom, 5); MoveWindow(ghwnd, 200, 400, 100, 100, 0); ret = GetRandomRgn(ghdcWindow, hrgn1, CLIPRGN); ok_int(ret, 1); GetRgnBox(hrgn1, &rect); ok_long(rect.left, 2); ok_long(rect.top, 3); ok_long(rect.right, 4); ok_long(rect.bottom, 5); DeleteObject(hrgn1); DeleteDC(hdc); }
void Test_OffsetRgn() { HRGN hrgn1, hrgn2; HDC hdc; hrgn1 = CreateRectRgn(0, 0, 0, 0); ok(hrgn1 != NULL, "CreateRectRgn failed\n"); ok_int(OffsetRgn(hrgn1, INT_MIN + 10, 10), NULLREGION); ok_int(OffsetRgn(hrgn1, 0xF000000, 0xF000000), NULLREGION); DeleteObject(hrgn1); hrgn1 = CreateRectRgn(0, 0, 100, 100); ok(hrgn1 != NULL, "CreateRectRgn failed\n"); ok_int(OffsetRgn(hrgn1, 10, 10), SIMPLEREGION); ok_int(OffsetRgn(hrgn1, 0x8000000 - 110, 10), ERROR); ok_int(OffsetRgn(hrgn1, 0x8000000 - 111, 10), SIMPLEREGION); DeleteObject(hrgn1); hrgn1 = CreateRectRgn(0, 0, 100, 100); ok(hrgn1 != NULL, "CreateRectRgn failed\n"); ok_int(OffsetRgn(hrgn1, -10, 10), SIMPLEREGION); ok_int(OffsetRgn(hrgn1, -(0x8000000 - 9), 10), ERROR); ok_int(OffsetRgn(hrgn1, -(0x8000000 - 10), 10), SIMPLEREGION); DeleteObject(hrgn1); hrgn1 = CreateRectRgn(0, 0, 10, 10); hrgn2 = CreateRectRgn(1000, 20, 1010, 30); ok_int(CombineRgn(hrgn1, hrgn1, hrgn2, RGN_OR), COMPLEXREGION); ok_int(OffsetRgn(hrgn1, 0x8000000 - 100, 10), ERROR); ok_int(CombineRgn(hrgn1, hrgn1, hrgn2, RGN_XOR), SIMPLEREGION); DeleteObject(hrgn2); hrgn2 = CreateRectRgn(0, 0, 10, 10); ok_int(CombineRgn(hrgn1, hrgn1, hrgn2, RGN_XOR), NULLREGION); hrgn1 = CreateRectRgn(0, 0, 0, 0); hdc = CreateCompatibleDC(NULL); ok_int(GetClipRgn(hdc, hrgn1), 0); ok_int(OffsetRgn(hrgn1, 10, 10), NULLREGION); }
int main(int argc, char **argv) { int ret, r2; runcmd_init(); t_set_colors(0); t_start("exec output comparison"); { int i; char *out = calloc(1, BUF_SIZE); for (i = 0; cases[i].input != NULL; i++) { memset(out, 0, BUF_SIZE); int pfd[2] = {-1, -1}, pfderr[2] = {-1, -1}; /* We need a stub iobregarg since runcmd_open()'s prototype * declares it attribute non-null. */ int stub_iobregarg = 0; int fd; char *cmd; asprintf(&cmd, ECHO_COMMAND " -n %s", cases[i].input); fd = runcmd_open(cmd, pfd, pfderr, NULL, stub_iobreg, &stub_iobregarg); free(cmd); read(pfd[0], out, BUF_SIZE); ok_str(cases[i].output, out, "Echoing a command should give expected output"); close(pfd[0]); close(pfderr[0]); close(fd); } free(out); } ret = t_end(); t_reset(); t_start("anomaly detection"); { int i; for (i = 0; anomaly[i].cmd; i++) { int out_argc; char *out_argv[256]; int result = runcmd_cmd2strv(anomaly[i].cmd, &out_argc, out_argv); ok_int(result, anomaly[i].ret, anomaly[i].cmd); if (out_argv[0]) free(out_argv[0]); } } r2 = t_end(); ret = r2 ? r2 : ret; t_reset(); t_start("argument splitting"); { int i; for (i = 0; parse_case[i].cmd; i++) { int x, out_argc; char *out_argv[256]; int result = runcmd_cmd2strv(parse_case[i].cmd, &out_argc, out_argv); /*out_argv[out_argc] = NULL;*//* This must be NULL terminated already. */ ok_int(result, parse_case[i].ret, parse_case[i].cmd); ok_int(out_argc, parse_case[i].argc_exp, parse_case[i].cmd); for (x = 0; x < parse_case[x].argc_exp && out_argv[x]; x++) { ok_str(parse_case[i].argv_exp[x], out_argv[x], "argv comparison test"); } if (out_argv[0]) free(out_argv[0]); } } r2 = t_end(); return r2 ? r2 : ret; }
int main(int argc, char **argv) { dkhash_table *tx, *t; unsigned int x; int ret, r2; struct test_data s; char *p1, *p2; char *strs[10]; char tmp[32]; t_set_colors(0); t_start("dkhash basic test"); t = dkhash_create(512); p1 = strdup("a not-so secret value"); dkhash_insert(t, "nisse", NULL, p1); ok_int(dkhash_num_entries_max(t), 1, "Added one entry, so that's max"); ok_int(dkhash_num_entries_added(t), 1, "Added one entry, so one added"); ok_int(dkhash_table_size(t), 512, "Table must be sized properly"); ok_int(dkhash_collisions(t), 0, "One entry, so zero collisions"); p2 = dkhash_get(t, "nisse", NULL); test(p1 == p2, "get should get what insert set"); dkhash_insert(t, "kalle", "bananas", p1); p2 = dkhash_get(t, "kalle", "bezinga"); test(p1 != p2, "we should never get the wrong key"); ok_int(2, dkhash_num_entries(t), "should be 2 entries after 2 inserts"); p2 = dkhash_remove(t, "kalle", "bezinga"); ok_int(2, dkhash_num_entries(t), "should be 2 entries after 2 inserts and 1 failed remove"); ok_int(0, dkhash_num_entries_removed(t), "should be 0 removed entries after failed remove"); p2 = dkhash_remove(t, "kalle", "bananas"); test(p1 == p2, "dkhash_remove() should return removed data"); ok_int(dkhash_num_entries(t), 1, "should be 1 entries after 2 inserts and 1 successful remove"); p2 = dkhash_remove(t, "nisse", NULL); test(p1 == p2, "dkhash_remove() should return removed data"); ret = t_end(); t_reset(); /* lots of tests below, so we shut up while they're running */ t_verbose = 0; t_start("dkhash_walk_data() test"); memset(&s, 0, sizeof(s)); /* first we set up the dkhash-tables */ tx = dkhash_create(16); for (x = 0; x < ARRAY_SIZE(keys); x++) { dkhash_insert(tx, keys[x].k1, NULL, ddup(x, 0, 0)); dkhash_insert(tx, keys[x].k2, NULL, ddup(x, 0, 0)); dkhash_insert(tx, keys[x].k1, keys[x].k2, ddup(x, 0, 0)); s.x += 3; ok_int(s.x, dkhash_num_entries(tx), "x table adding"); } ok_int(s.x, dkhash_num_entries(tx), "x table done adding"); for (x = 0; x < ARRAY_SIZE(keys); x++) { del.x = x; del.i = del.j = 0; ok_int(s.x, dkhash_num_entries(tx), "x table pre-delete"); s.x -= 3; dkhash_walk_data(tx, del_matching); ok_int(s.x, dkhash_num_entries(tx), "x table post-delete"); } test(0 == dkhash_num_entries(tx), "x table post all ops"); test(0 == dkhash_check_table(tx), "x table consistency post all ops"); dkhash_debug_table(tx, 0); r2 = t_end(); ret = r2 ? r2 : ret; t_reset(); for (x = 0; x < 10; x++) { sprintf(tmp, "string %d", x); strs[x] = strdup(tmp); } t_start("dkhash single bucket add remove forward"); t = dkhash_create(1); for (x = 0; x < 10; x++) { dkhash_insert(t, strs[x], NULL, strs[x]); } for (x = 0; x < 10; x++) { p1 = strs[x]; p2 = dkhash_remove(t, p1, NULL); test(p1 == p2, "remove should return a value"); } r2 = t_end(); ret = r2 ? r2 : ret; t_reset(); t_start("dkhash single bucket add remove backward"); t = dkhash_create(1); for (x = 0; x < 10; x++) { dkhash_insert(t, strs[x], NULL, strs[x]); } for (x = 9; x; x--) { p1 = strs[x]; p2 = dkhash_remove(t, p1, NULL); test(p1 == p2, "remove should return a value"); } dkhash_destroy(t); r2 = t_end(); return r2 ? r2 : ret; }
void Test_RtlFindClearBits(void) { RTL_BITMAP BitMapHeader; ULONG *Buffer; Buffer = AllocateGuarded(2 * sizeof(*Buffer)); Buffer[0] = 0x060F874D; Buffer[1] = 0x3F303F30; RtlInitializeBitMap(&BitMapHeader, Buffer, 0); ok_int(RtlFindClearBits(&BitMapHeader, 0, 0), 0); ok_int(RtlFindClearBits(&BitMapHeader, 0, 3), 0); ok_int(RtlFindClearBits(&BitMapHeader, 1, 0), -1); ok_int(RtlFindClearBits(&BitMapHeader, 1, 1), -1); RtlInitializeBitMap(&BitMapHeader, Buffer, 8); ok_int(RtlFindClearBits(&BitMapHeader, 0, 3), 0); ok_int(RtlFindClearBits(&BitMapHeader, 1, 0), 1); ok_int(RtlFindClearBits(&BitMapHeader, 1, 1), 1); ok_int(RtlFindClearBits(&BitMapHeader, 1, 2), 4); ok_int(RtlFindClearBits(&BitMapHeader, 2, 0), 4); ok_int(RtlFindClearBits(&BitMapHeader, 3, 0), -1); RtlInitializeBitMap(&BitMapHeader, Buffer, 32); ok_int(RtlFindClearBits(&BitMapHeader, 0, 3), 0); ok_int(RtlFindClearBits(&BitMapHeader, 0, 21), 16); ok_int(RtlFindClearBits(&BitMapHeader, 0, 12), 8); ok_int(RtlFindClearBits(&BitMapHeader, 0, 31), 24); ok_int(RtlFindClearBits(&BitMapHeader, 0, 32), 0); ok_int(RtlFindClearBits(&BitMapHeader, 0, 39), 0); ok_int(RtlFindClearBits(&BitMapHeader, 4, 0), 11); ok_int(RtlFindClearBits(&BitMapHeader, 5, 0), 20); ok_int(RtlFindClearBits(&BitMapHeader, 4, 11), 11); ok_int(RtlFindClearBits(&BitMapHeader, 4, 12), 20); ok_int(RtlFindClearBits(&BitMapHeader, 2, 11), 11); ok_int(RtlFindClearBits(&BitMapHeader, 2, 12), 12); ok_int(RtlFindClearBits(&BitMapHeader, 1, 32), 1); ok_int(RtlFindClearBits(&BitMapHeader, 4, 32), 11); ok_int(RtlFindClearBits(&BitMapHeader, 5, 32), 20); RtlInitializeBitMap(&BitMapHeader, Buffer, 64); ok_int(RtlFindClearBits(&BitMapHeader, 5, 64), 20); ok_int(RtlFindClearBits(&BitMapHeader, 9, 28), 27); ok_int(RtlFindClearBits(&BitMapHeader, 10, 0), -1); Buffer[1] = 0xFF303F30; ok_int(RtlFindClearBits(&BitMapHeader, 1, 56), 1); FreeGuarded(Buffer); }
void Test_RtlFindSetBitsAndClear(void) { RTL_BITMAP BitMapHeader; ULONG *Buffer; Buffer = AllocateGuarded(2 * sizeof(*Buffer)); Buffer[0] = 0xF9F078B2; Buffer[1] = 0x3F303F30; RtlInitializeBitMap(&BitMapHeader, Buffer, 0); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 0, 0), 0); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 0, 3), 0); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 0), -1); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 1), -1); ok_hex(Buffer[0], 0xF9F078B2); Buffer[0] = 0xF9F078B2; RtlInitializeBitMap(&BitMapHeader, Buffer, 8); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 0), 1); ok_hex(Buffer[0], 0xf9f078b0); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 1), 4); ok_hex(Buffer[0], 0xf9f078a0); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 2), 5); ok_hex(Buffer[0], 0xf9f07880); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 2, 0), -1); ok_hex(Buffer[0], 0xf9f07880); Buffer[0] = 0xF9F078B2; RtlInitializeBitMap(&BitMapHeader, Buffer, 32); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 4, 0), 11); ok_hex(Buffer[0], 0xf9f000b2); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 5, 0), 20); ok_hex(Buffer[0], 0xf80000b2); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 4, 11), 27); ok_hex(Buffer[0], 0x800000b2); Buffer[0] = 0xF9F078B2; ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 4, 12), 20); ok_hex(Buffer[0], 0xf90078b2); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 2, 11), 11); ok_hex(Buffer[0], 0xf90060b2); ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 2, 12), 13); ok_hex(Buffer[0], 0xf90000b2); FreeGuarded(Buffer); }
void Test_CombineTransform_Inval(float eInval, float eOut) { XFORM xform1, xform2, xform3; /* zero matrix / M11 invalid */ set_xform(&xform1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); set_xform(&xform2, eInval, 0.0, 0.0, 0.0, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, eOut, 0.0, 0.0, 0.0, 0.0, 0.0); // -> M21 ok_int(CombineTransform(&xform3, &xform2, &xform1), 1); ok_xform(xform3, eOut, 0.0, 0.0, 0.0, 0.0, 0.0); // -> M12 /* zero matrix / M12 invalid */ set_xform(&xform1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); set_xform(&xform2, 0.0, eInval, 0.0, 0.0, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, 0.0, eOut, 0.0, eOut, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform2, &xform1), 1); ok_xform(xform3, eOut, eOut, 0.0, 0.0, 0.0, 0.0); /* zero matrix / M21 invalid */ set_xform(&xform1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); set_xform(&xform2, 0.0, 0.0, eInval, 0.0, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, eOut, 0.0, eOut, 0.0, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform2, &xform1), 1); ok_xform(xform3, 0.0, 0.0, eOut, eOut, 0.0, 0.0); /* zero matrix / M22 invalid */ set_xform(&xform1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); set_xform(&xform2, 0.0, 0.0, 0.0, eInval, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, 0.0, 0.0, 0.0, eOut, 0.0, 0.0); // -> M12 ok_int(CombineTransform(&xform3, &xform2, &xform1), 1); ok_xform(xform3, 0.0, 0.0, 0.0, eOut, 0.0, 0.0); // -> M21 /* zero matrix / M11,M12 invalid */ set_xform(&xform1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); set_xform(&xform2, eInval, eInval, 0.0, 0.0, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, eOut, eOut, eOut, eOut, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform2, &xform1), 1); ok_xform(xform3, eOut, eOut, 0.0, 0.0, 0.0, 0.0); /* zero matrix / M11,M21 invalid */ set_xform(&xform1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); set_xform(&xform2, eInval, 0.0, eInval, 0.0, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, eOut, 0.0, eOut, 0.0, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform2, &xform1), 1); ok_xform(xform3, eOut, eOut, eOut, eOut, 0.0, 0.0); /* zero matrix / M11,M22 invalid */ set_xform(&xform1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); set_xform(&xform2, eInval, 0.0, 0.0, eInval, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, eOut, 0.0, 0.0, eOut, 0.0, 0.0); // -> M12, M21 ok_int(CombineTransform(&xform3, &xform2, &xform1), 1); ok_xform(xform3, eOut, 0.0, 0.0, eOut, 0.0, 0.0); /* zero matrix / M12,M21 invalid */ set_xform(&xform1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); set_xform(&xform2, 0.0, eInval, eInval, 0.0, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, eOut, eOut, eOut, eOut, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform2, &xform1), 1); ok_xform(xform3, eOut, eOut, eOut, eOut, 0.0, 0.0); }
int main(int argc, char **argv) { int i, j; struct kvvec *kvv, *kvv2, *kvv3; struct kvvec_buf *kvvb, *kvvb2; struct kvvec k = KVVEC_INITIALIZER; t_set_colors(0); t_start("key/value vector tests"); kvv = kvvec_create(1); ok_int(kvvec_capacity(kvv), 1, "capacity of one should be guaranteed"); kvv2 = kvvec_create(1); kvv3 = kvvec_create(1); add_vars(kvv, test_data, 1239819); add_vars(kvv, (const char **)argv + 1, argc - 1); kvvec_sort(kvv); kvvec_foreach(kvv, NULL, walker); /* kvvec2buf -> buf2kvvec -> kvvec2buf -> buf2kvvec conversion */ kvvb = kvvec2buf(kvv, KVSEP, PAIRSEP, OVERALLOC); kvv3 = buf2kvvec(kvvb->buf, kvvb->buflen, KVSEP, PAIRSEP, KVVEC_COPY); kvvb2 = kvvec2buf(kvv3, KVSEP, PAIRSEP, OVERALLOC); buf2kvvec_prealloc(kvv2, kvvb->buf, kvvb->buflen, KVSEP, PAIRSEP, KVVEC_ASSIGN); kvvec_foreach(kvv2, kvv, walker); kvvb = kvvec2buf(kvv, KVSEP, PAIRSEP, OVERALLOC); test(kvv->kv_pairs == kvv2->kv_pairs, "pairs should be identical"); for (i = 0; i < kvv->kv_pairs; i++) { struct key_value *kv1, *kv2; kv1 = &kvv->kv[i]; if (i >= kvv2->kv_pairs) { t_fail("missing var %d in kvv2", i); printf("[%s=%s] (%d+%d)\n", kv1->key, kv1->value, kv1->key_len, kv1->value_len); continue; } kv2 = &kvv2->kv[i]; if (!test(!kv_compare(kv1, kv2), "kv pair %d must match", i)) { printf("%d failed: [%s=%s] (%d+%d) != [%s=%s (%d+%d)]\n", i, kv1->key, kv1->value, kv1->key_len, kv1->value_len, kv2->key, kv2->value, kv2->key_len, kv2->value_len); } } test(kvvb2->buflen == kvvb->buflen, "buflens must match"); test(kvvb2->bufsize == kvvb->bufsize, "bufsizes must match"); if (kvvb2->buflen == kvvb->buflen && kvvb2->bufsize == kvvb->bufsize && !memcmp(kvvb2->buf, kvvb->buf, kvvb->bufsize)) { t_pass("kvvec -> buf -> kvvec conversion works flawlessly"); } else { t_fail("kvvec -> buf -> kvvec conversion failed :'("); } free(kvvb->buf); free(kvvb); free(kvvb2->buf); free(kvvb2); kvvec_destroy(kvv, 1); kvvec_destroy(kvv3, KVVEC_FREE_ALL); for (j = 0; pair_term_missing[j]; j++) { buf2kvvec_prealloc(&k, strdup(pair_term_missing[j]), strlen(pair_term_missing[j]), '=', ';', KVVEC_COPY); for (i = 0; i < k.kv_pairs; i++) { struct key_value *kv = &k.kv[i]; test(kv->key_len == kv->value_len, "%d.%d; key_len=%d; value_len=%d (%s = %s)", j, i, kv->key_len, kv->value_len, kv->key, kv->value); test(kv->value_len == (int)strlen(kv->value), "%d.%d; kv->value_len(%d) == strlen(%s)(%d)", j, i, kv->value_len, kv->value, (int)strlen(kv->value)); } } t_end(); return 0; }
void Test_RtlFindSetBits(void) { RTL_BITMAP BitMapHeader; ULONG *Buffer; Buffer = AllocateGuarded(2 * sizeof(*Buffer)); Buffer[0] = 0xF9F078B2; Buffer[1] = 0x3F303F30; RtlInitializeBitMap(&BitMapHeader, Buffer, 0); ok_int(RtlFindSetBits(&BitMapHeader, 0, 0), 0); ok_int(RtlFindSetBits(&BitMapHeader, 0, 3), 0); ok_int(RtlFindSetBits(&BitMapHeader, 1, 0), -1); ok_int(RtlFindSetBits(&BitMapHeader, 1, 1), -1); RtlInitializeBitMap(&BitMapHeader, Buffer, 8); ok_int(RtlFindSetBits(&BitMapHeader, 0, 3), 0); ok_int(RtlFindSetBits(&BitMapHeader, 1, 0), 1); ok_int(RtlFindSetBits(&BitMapHeader, 1, 1), 1); ok_int(RtlFindSetBits(&BitMapHeader, 1, 2), 4); ok_int(RtlFindSetBits(&BitMapHeader, 2, 0), 4); ok_int(RtlFindSetBits(&BitMapHeader, 3, 0), -1); RtlInitializeBitMap(&BitMapHeader, Buffer, 32); ok_int(RtlFindSetBits(&BitMapHeader, 0, 3), 0); ok_int(RtlFindSetBits(&BitMapHeader, 0, 21), 16); ok_int(RtlFindSetBits(&BitMapHeader, 0, 12), 8); ok_int(RtlFindSetBits(&BitMapHeader, 0, 31), 24); ok_int(RtlFindSetBits(&BitMapHeader, 0, 32), 0); ok_int(RtlFindSetBits(&BitMapHeader, 0, 39), 0); ok_int(RtlFindSetBits(&BitMapHeader, 4, 0), 11); ok_int(RtlFindSetBits(&BitMapHeader, 5, 0), 20); ok_int(RtlFindSetBits(&BitMapHeader, 4, 11), 11); ok_int(RtlFindSetBits(&BitMapHeader, 4, 12), 20); ok_int(RtlFindSetBits(&BitMapHeader, 2, 11), 11); ok_int(RtlFindSetBits(&BitMapHeader, 1, 32), 1); ok_int(RtlFindSetBits(&BitMapHeader, 4, 32), 11); ok_int(RtlFindSetBits(&BitMapHeader, 5, 32), 20); RtlInitializeBitMap(&BitMapHeader, Buffer, 64); ok_int(RtlFindSetBits(&BitMapHeader, 5, 64), 20); ok_int(RtlFindSetBits(&BitMapHeader, 6, 57), 40); ok_int(RtlFindSetBits(&BitMapHeader, 7, 0), -1); ok_int(RtlFindSetBits(&BitMapHeader, 1, 62), 1); FreeGuarded(Buffer); }
void Test_RtlFindClearBitsAndSet(void) { RTL_BITMAP BitMapHeader; ULONG *Buffer; Buffer = AllocateGuarded(2 * sizeof(*Buffer)); Buffer[0] = 0x060F874D; Buffer[1] = 0x3F303F30; RtlInitializeBitMap(&BitMapHeader, Buffer, 0); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 0, 0), 0); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 0, 3), 0); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 0), -1); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 1), -1); ok_hex(Buffer[0], 0x060F874D); Buffer[0] = 0x060F874D; RtlInitializeBitMap(&BitMapHeader, Buffer, 8); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 0), 1); ok_hex(Buffer[0], 0x60f874f); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 1), 4); ok_hex(Buffer[0], 0x60f875f); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 2), 5); ok_hex(Buffer[0], 0x60f877f); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 2, 0), -1); ok_hex(Buffer[0], 0x60f877f); Buffer[0] = 0x060F874D; RtlInitializeBitMap(&BitMapHeader, Buffer, 32); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 4, 0), 11); ok_hex(Buffer[0], 0x60fff4d); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 5, 0), 20); ok_hex(Buffer[0], 0x7ffff4d); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 4, 11), 27); ok_hex(Buffer[0], 0x7fffff4d); Buffer[0] = 0x060F874D; ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 4, 12), 20); ok_hex(Buffer[0], 0x6ff874d); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 2, 11), 11); ok_hex(Buffer[0], 0x6ff9f4d); ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 2, 12), 13); ok_hex(Buffer[0], 0x6ffff4d); FreeGuarded(Buffer); }
static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { static BOOL s_bReach_WM_MOUSEMOVE; static BOOL s_bReach_WM_LBUTTONDOWN; static BOOL s_bReach_WM_LBUTTONUP; switch (uMsg) { case WM_CREATE: s_nCount = 0; s_nMsgTime = GetMessageTime(); SetTimer(hwnd, TIMER_ID, TIMER_INTERVAL, NULL); s_bReach_WM_MOUSEMOVE = FALSE; s_bReach_WM_LBUTTONDOWN = FALSE; s_bReach_WM_LBUTTONUP = FALSE; break; case WM_TIMER: if (s_nCount == 5) { KillTimer(hwnd, TIMER_ID); DestroyWindow(hwnd); break; } if (s_nCount != 0) { ok(GetMessageTime() - s_nMsgTime >= TIMER_INTERVAL / 2, "GetMessageTime() is wrong, compared to previous one\n"); ok(GetTickCount() - (DWORD)GetMessageTime() < TIMER_INTERVAL / 2, "GetMessageTime() is wrong, compared to GetTickCount()\n"); } s_nMsgTime = GetMessageTime(); ok(s_nMsgTime != 0, "message time was zero.\n"); s_nCount++; if (s_nCount == 5) { mouse_event(MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE, MOUSE_LOCATION_X(WIN_X + WIN_CX / 2), MOUSE_LOCATION_Y(WIN_Y + WIN_CY / 2), 0, 0); mouse_event(MOUSEEVENTF_MOVE, 1, 1, 0, 0); mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0); mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0); } break; case WM_MOUSEMOVE: trace("WM_MOUSEMOVE\n"); ok_int(s_nCount, 5); ok(GetMessageTime() - s_nMsgTime < TIMER_INTERVAL, "GetMessageTime() is wrong, compared to previous one\n"); ok(GetTickCount() - (DWORD)GetMessageTime() < TIMER_INTERVAL / 2, "GetMessageTime() is wrong, compared to GetTickCount()\n"); s_bReach_WM_MOUSEMOVE = TRUE; break; case WM_LBUTTONDOWN: trace("WM_LBUTTONDOWN\n"); ok_int(s_nCount, 5); ok(GetMessageTime() - s_nMsgTime < TIMER_INTERVAL, "GetMessageTime() is wrong, compared to previous one\n"); ok(GetTickCount() - (DWORD)GetMessageTime() < TIMER_INTERVAL / 2, "GetMessageTime() is wrong, compared to GetTickCount()\n"); s_bReach_WM_LBUTTONDOWN = TRUE; break; case WM_LBUTTONUP: trace("WM_LBUTTONUP\n"); ok_int(s_nCount, 5); ok(GetMessageTime() - s_nMsgTime < TIMER_INTERVAL, "GetMessageTime() is wrong, compared to previous one\n"); ok(GetTickCount() - (DWORD)GetMessageTime() < TIMER_INTERVAL / 2, "GetMessageTime() is wrong, compared to GetTickCount()\n"); s_bReach_WM_LBUTTONUP = TRUE; break; case WM_DESTROY: ok_int(s_bReach_WM_MOUSEMOVE, TRUE); ok_int(s_bReach_WM_LBUTTONDOWN, TRUE); ok_int(s_bReach_WM_LBUTTONUP, TRUE); PostQuitMessage(0); break; default: return DefWindowProcW(hwnd, uMsg, wParam, lParam); } return 0; }
int main(int argc, char *argv[]) { char* str = "defaultstring"; if (argc > 2) str = argv[1]; ok_int(CdeclFunc0(), 0); ok_int(CdeclFunc1(str), 1); ok_int(CdeclFunc2(str), 1); ok_int(CdeclFunc3(str), 0x10001); ok_int(StdcallFunc0(), 0x10); ok_int(StdcallFunc1(str), 0x11); ok_int(StdcallFunc2(str), 0x11); ok_int(StdcallFunc3(str), 0x10011); #ifdef _M_IX86 ok_int(StdcallFunc4(str), 0x21); #endif ok_int(StdcallFunc5(str), 0x10021); #ifdef _M_IX86 ok_int(DecoratedStdcallFunc1(str), 0x21); ok_int(DecoratedStdcallFunc2(str), 0x11); //ok_int(DecoratedStdcallFunc3(str), 11); ok_int(DecoratedStdcallFunc4(str), 0x21); ok_int(DecoratedStdcallFunc5(str), 0x10021); #endif ok_int(FastcallFunc0(), 0x30); ok_int(FastcallFunc1(str), 0x31); ok_int(FastcallFunc2(str), 0x31); ok_int(FastcallFunc3(str), 0x10031); #ifdef _M_IX86 ok_int(FastcallFunc4(str), 0x42); ok_int(FastcallFunc5(str), 0x10041); #endif #ifdef _M_IX86 ok_int(DecoratedFastcallFunc1(str), 0x42); ok_int(DecoratedFastcallFunc2(str), 0x31); //ok_int(DecoratedFastcallFunc3(str), 11); ok_int(DecoratedFastcallFunc4(str), 0x42); ok_int(DecoratedFastcallFunc5(str), 0x10041); #endif ok_int(DataItem1, 0x51); ok_int(DataItem2, 0x51); ok_int(DataItem3, 0x10051); printf("done.\n"); return 0; }
void Test_GetRandomRgn_RGN5() { HDC hdc; HRGN hrgn1, hrgn2; INT ret; RECT rect, rect2; HBITMAP hbmp; DBG_UNREFERENCED_LOCAL_VARIABLE(hrgn2); DBG_UNREFERENCED_LOCAL_VARIABLE(rect2); hrgn1 = CreateRectRgn(11, 17, 23, 42); if (!hrgn1) { printf("Coun't create a region\n"); return; } hdc = CreateCompatibleDC(0); if (!hdc) { printf("Coun't create a dc\n"); return; } #if 0 // this is vista+ ret = GetRandomRgn(hdc, hrgn1, RGN5); ok_int(ret, 1); GetRgnBox(hrgn1, &rect); ok_long(rect.left, 0); ok_long(rect.top, 0); ok_long(rect.right, 1); ok_long(rect.bottom, 1); hrgn2 = CreateRectRgn(1, 2, 3, 4); SelectClipRgn(hdc, hrgn2); DeleteObject(hrgn2); ret = GetRandomRgn(hdc, hrgn1, RGN5); ok_int(ret, 1); GetRgnBox(hrgn1, &rect); ok_long(rect.left, 0); ok_long(rect.top, 0); ok_long(rect.right, 1); ok_long(rect.bottom, 1); #endif hbmp = CreateCompatibleBitmap(hdc, 4, 7); SelectObject(hdc, hbmp); ret = GetRandomRgn(hdc, hrgn1, SYSRGN); ok_int(ret, 1); GetRgnBox(hrgn1, &rect); ok_long(rect.left, 0); ok_long(rect.top, 0); ok_long(rect.right, 4); ok_long(rect.bottom, 7); DeleteObject(hbmp); #if 0 // this is vista+ MoveWindow(ghwnd, 100, 100, 100, 100, 0); ret = GetRandomRgn(ghdcWindow, hrgn1, RGN5); ok_int(ret, 1); GetRgnBox(hrgn1, &rect); DPtoLP(ghdcWindow, (LPPOINT)&rect, 2); ok_long(rect.left, 104); ok_long(rect.top, 124); ok_long(rect.right, 209); ok_long(rect.bottom, 196); MoveWindow(ghwnd, 200, 400, 200, 200, 0); ret = GetRandomRgn(ghdcWindow, hrgn1, RGN5); ok_int(ret, 1); GetRgnBox(hrgn1, &rect2); DPtoLP(ghdcWindow, (LPPOINT)&rect2, 2); ok_long(rect2.left, rect.left + 100); ok_long(rect2.top, rect.top + 300); ok_long(rect2.right, rect.right + 200 - 13); ok_long(rect2.bottom, rect.bottom + 400); #endif DeleteObject(hrgn1); DeleteDC(hdc); }
void Test_CombineTransform() { XFORM xform1, xform2, xform3; /* Test NULL paramters */ set_xform(&xform1, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0); set_xform(&xform2, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0); SetLastError(ERROR_SUCCESS); ok_int(CombineTransform(&xform3, &xform1, NULL), 0); ok_int(CombineTransform(&xform3, NULL, &xform2), 0); ok_int(CombineTransform(NULL, &xform1, &xform2), 0); ok_int(GetLastError(), ERROR_SUCCESS); /* 2 zero matrices */ set_xform(&xform1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); set_xform(&xform2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); SetLastError(ERROR_SUCCESS); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); ok_int(GetLastError(), ERROR_SUCCESS); /* 2 Identity matrices */ set_xform(&xform1, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0); set_xform(&xform2, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0); SetLastError(ERROR_SUCCESS); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, 1.0, 0., 0., 1.0, 0., 0.); ok_int(GetLastError(), ERROR_SUCCESS); /* 2 Identity matrices with offsets */ set_xform(&xform1, 1.0, 0.0, 0.0, 1.0, 20.0, -100.0); set_xform(&xform2, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, 1.0, 0., 0., 1.0, 20.0, -100.0); xform2.eDx = -60.0; xform2.eDy = -20; ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_flt(xform3.eDx, -40.0); ok_flt(xform3.eDy, -120.0); /* add some stretching */ xform2.eM11 = 2; xform2.eM22 = 4; ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, 2.0, 0., 0., 4.0, -20.0, -420.0); /* add some more stretching */ xform1.eM11 = -2.5; xform1.eM22 = 0.5; ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, -5.0, 0., 0., 2.0, -20.0, -420.0); xform1.eM12 = 2.0; xform1.eM21 = -0.5; ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, -5.0, 8.0, -1.0, 2.0, -20.0, -420.0); xform2.eM12 = 4.0; xform2.eM21 = 6.5; ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, 8.0, -2.0, 2.25, 0.0, -670.0, -340.0); set_xform(&xform1, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0); set_xform(&xform2, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0); set_xform(&xform3, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); xform1.eDx = (FLOAT)4294967167.999999761; ok(xform1.eDx == 4294967040.0, "float rounding error.\n"); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, 1.0, 0.0, 0.0, 1.0, 4294967040.0, 0.0); set_xform(&xform3, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); xform1.eDx = (FLOAT)4294967167.999999762; ok(xform1.eDx == 4294967296.0, "float rounding error.\n"); ok_int(CombineTransform(&xform3, &xform1, &xform2), 0); ok_int(GetLastError(), ERROR_SUCCESS); ok_xform(xform3, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); xform1.eDx = (FLOAT)-4294967167.999999761; ok(xform1.eDx == -4294967040.0, "float rounding error.\n"); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); xform1.eDx = (FLOAT)-4294967167.999999762; ok(xform1.eDx == -4294967296.0, "float rounding error.\n"); ok_int(CombineTransform(&xform3, &xform1, &xform2), 0); ok_int(GetLastError(), ERROR_SUCCESS); xform1.eDx = 0; xform1.eDy = (FLOAT)4294967167.999999761; ok(xform1.eDy == 4294967040.0, "float rounding error.\n"); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); xform2.eDy = 1; ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_flt(xform3.eDy, 4294967040.0); xform1.eDy = (FLOAT)4294967167.999999762; ok(xform1.eDy == 4294967296.0, "float rounding error.\n"); ok_int(CombineTransform(&xform3, &xform1, &xform2), 0); ok_int(GetLastError(), ERROR_SUCCESS); xform1.eDy = (FLOAT)-4294967167.999999761; ok(xform1.eDy == -4294967040.0, "float rounding error.\n"); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); xform1.eDy = (FLOAT)-4294967167.999999762; ok(xform1.eDy == -4294967296.0, "float rounding error.\n"); ok_int(CombineTransform(&xform3, &xform1, &xform2), 0); ok_int(GetLastError(), ERROR_SUCCESS); xform2.eDy = 10000; ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); set_xform(&xform1, 1000.0, 0.0, 0.0, 0.0, 0.0, 0.0); xform1.eDx = (FLOAT)-4294967167.999999762; xform2.eM11 = 1000.0; ok_int(CombineTransform(&xform3, &xform1, &xform2), 0); ok_int(GetLastError(), ERROR_SUCCESS); xform1.eDx = 100000.0; xform2.eM11 = 100000.0; ok_int(CombineTransform(&xform3, &xform1, &xform2), 0); ok_int(GetLastError(), ERROR_SUCCESS); /* Some undefined values */ set_xform(&xform1, geIND, 0.0, 0.0, geINF, 0.0, 0.0); xform2 = xform1; SetLastError(ERROR_SUCCESS); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, geIND, 0.0, 0.0, geINF, 0.0, 0.0); ok_int(GetLastError(), ERROR_SUCCESS); set_xform(&xform2, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, geIND, geIND, geINF, geINF, 0.0, 0.0); ok_int(GetLastError(), ERROR_SUCCESS); set_xform(&xform1, (FLOAT)18446743500000000000.0, 0.0, 1.0, 0.0, 0.0, 0.0); xform2 = xform1; ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_flt(xform3.eM11, 340282326356119260000000000000000000000.0); xform1.eM11 = (FLOAT)18446745000000000000.0; ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_flt(xform3.eM11, 340282346638528860000000000000000000000.0); xform1.eM11 = (FLOAT)18446746000000000000.0; ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_long(*(DWORD*)&xform3.eM11, 0x7f800000); /* zero matrix + 1 invalid */ set_xform(&xform1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); set_xform(&xform2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); *(DWORD*)&xform2.eM22 = 0x7f800000; // (0.0F/0.0F) ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, 0.0, 0.0, 0.0, geIND, 0.0, 0.0); /* zero matrix + 1 invalid */ xform2 = xform1; *(DWORD*)&xform2.eM12 = 0x7f800000; // (0.0F/0.0F) ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, 0.0, geIND, 0.0, geIND, 0.0, 0.0); /* Some undefined values */ set_xform(&xform1, 0.0, geIND, 0.0, 0.0, 0.0, 0.0); set_xform(&xform2, geIND, 0.0, 0.0, geINF, 0.0, 0.0); ok_int(CombineTransform(&xform3, &xform1, &xform2), 1); ok_xform(xform3, geIND, geIND, geIND, geIND, 0.0, 0.0); }
void Test_CreateBitmap() { HBITMAP hbmp; BITMAP bitmap; ULONG cjWidthBytes, cBitsPixel, cExpectedBitsPixel; int result, TestBitsPixel, ExpectedBitsPixel; hbmp = CreateBitmap(0, 0, 0, 0, NULL); ok(hbmp != 0, "should get a 1x1 bitmap\n"); ok(hbmp == GetStockObject(DEFAULT_BITMAP), "\n"); ok_int(GetObject(hbmp, sizeof(bitmap), &bitmap), sizeof(BITMAP)); ok_int(bitmap.bmType, 0); ok_int(bitmap.bmWidth, 1); ok_int(bitmap.bmHeight, 1); ok_int(bitmap.bmWidthBytes, 2); ok_int(bitmap.bmPlanes, 1); ok_int(bitmap.bmBitsPixel, 1); ok_ptr(bitmap.bmBits, 0); DeleteObject(hbmp); /* Above 32 bpp should fail */ hbmp = CreateBitmap(1, 2, 1, 33, NULL); ok(hbmp == 0, "should fail\n"); for (TestBitsPixel = 0; TestBitsPixel <= 32; TestBitsPixel++) { /* CreateBitmap API accepts any number as BitsPixels param. but it can only create 1, 4, 8, 16, 24, 32 bpp bitmaps */ if (TestBitsPixel <= 1) ExpectedBitsPixel = 1; else if(TestBitsPixel <= 4) ExpectedBitsPixel = 4; else if(TestBitsPixel <= 8) ExpectedBitsPixel = 8; else if(TestBitsPixel <= 16) ExpectedBitsPixel = 16; else if(TestBitsPixel <= 24) ExpectedBitsPixel = 24; else if(TestBitsPixel <= 32) ExpectedBitsPixel = 32; /* Calculate proper bmWidthBytes */ hbmp = CreateBitmap(1, 2, 1, TestBitsPixel, NULL); ok(hbmp != 0, "should get a 1x2 bitmap\n"); result = GetObject(hbmp, sizeof(bitmap), &bitmap); ok(result > 0, "result = %d\n", result); ok(bitmap.bmType == 0, "bmType = %ld\n", bitmap.bmType); ok(bitmap.bmWidth == 1, "bmWidth = %ld\n", bitmap.bmWidth); ok(bitmap.bmHeight == 2, "bmHeight = %ld\n", bitmap.bmHeight); ok(bitmap.bmPlanes == 1, "bmPlanes = %d\n", bitmap.bmPlanes); ok(bitmap.bmBitsPixel == ExpectedBitsPixel, "bmBitsPixel = %d ExpectedBitsPixel= %d \n", bitmap.bmBitsPixel, ExpectedBitsPixel); ok(bitmap.bmBits == 0, "bmBits = %p\n", bitmap.bmBits); DeleteObject(hbmp); } hbmp = CreateBitmap(1, 2, 1, 1, NULL); ok(hbmp != 0, "should get a 1x2 bitmap\n"); ok_int(GetObject(hbmp, sizeof(bitmap), &bitmap), sizeof(BITMAP)); ok_int(bitmap.bmType, 0); ok_int(bitmap.bmWidth, 1); ok_int(bitmap.bmHeight, 2); ok_int(bitmap.bmWidthBytes, 2); ok_int(bitmap.bmPlanes, 1); ok_int(bitmap.bmBitsPixel, 1); ok_ptr(bitmap.bmBits, 0); DeleteObject(hbmp); for (cBitsPixel = 0; cBitsPixel <= 32; cBitsPixel++) { /* CreateBitmap API accepts any number as BitsPixels param. but it just can create 1, 4, 8, 16, 24, 32 bpp Bitmaps */ if (cBitsPixel <= 1) cExpectedBitsPixel = 1; else if (cBitsPixel <= 4) cExpectedBitsPixel = 4; else if (cBitsPixel <= 8) cExpectedBitsPixel = 8; else if (cBitsPixel <= 16) cExpectedBitsPixel = 16; else if (cBitsPixel <= 24) cExpectedBitsPixel = 24; else if (cBitsPixel <= 32) cExpectedBitsPixel = 32; hbmp = CreateBitmap(1, 2, 1, cBitsPixel, NULL); ok(hbmp != 0, "should get a 1x2 bitmap %ld\n", cBitsPixel); ok_int(GetObject(hbmp, sizeof(bitmap), &bitmap), sizeof(BITMAP)); /* calculate expected line width */ cjWidthBytes = ((((ULONG)bitmap.bmWidth) * ((ULONG)bitmap.bmBitsPixel) + 15) & ~15) >> 3; ok_int(bitmap.bmType, 0); ok_int(bitmap.bmWidth, 1); ok_int(bitmap.bmHeight, 2); ok_int(bitmap.bmPlanes, 1); ok_int(bitmap.bmBitsPixel, cExpectedBitsPixel); ok_int(bitmap.bmWidthBytes, cjWidthBytes); ok_ptr(bitmap.bmBits, 0); DeleteObject(hbmp); } hbmp = CreateBitmap(1, 2, 1, 33, NULL); ok(hbmp == 0, "Expected failure for 33 bpp\n"); }
void Test_RtlFindNextForwardRunClear(void) { RTL_BITMAP BitMapHeader; ULONG *Buffer; ULONG Index; Buffer = AllocateGuarded(2 * sizeof(*Buffer)); Buffer[0] = 0xF9F078B2; Buffer[1] = 0x3F303F30; RtlInitializeBitMap(&BitMapHeader, Buffer, 0); ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 0, &Index), 0); ok_int(Index, 0); ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 1, &Index), 0); ok_int(Index, 1); Index = -1; RtlInitializeBitMap(&BitMapHeader, Buffer, 8); ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 0, &Index), 1); ok_int(Index, 0); ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 1, &Index), 2); ok_int(Index, 2); ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 7, &Index), 0); ok_int(Index, 8); ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 17, &Index), 0); ok_int(Index, 17); ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 39, &Index), 0); ok_int(Index, 39); FreeGuarded(Buffer); }