Use ok("xxx\n") in the ntdll tests
Francois Gouget
fgouget at free.fr
Sat Oct 18 17:50:22 CDT 2003
I'll try to regularly submit patches to convert the tests to use
ok("...\n") so that someday everythin is as it should be and we can
remove the hack that adds a '\n' if there is none.
I'll try to avoid sending patches when a etst is actively modified to
minimize the risk of conflicts. The ntdll tests did not seem to be
modified too much lately so here goes.
Note: I'm sending a separate patch to fix the generation of the
generated.c tests and then they can all be fixed in one go.
Changelog:
* dlls/ntdll/tests/env.c,
dlls/ntdll/tests/error.c,
dlls/ntdll/tests/large_int.c,
dlls/ntdll/tests/path.c,
dlls/ntdll/tests/rtl.c,
dlls/ntdll/tests/rtlbitmap.c,
dlls/ntdll/tests/rtlstr.c,
dlls/ntdll/tests/string.c
Modify ok("xxx") calls into ok("xxx\n") as is now expected.
Index: dlls/ntdll/tests/env.c
===================================================================
RCS file: /home/cvs/wine/dlls/ntdll/tests/env.c,v
retrieving revision 1.4
diff -u -r1.4 env.c
--- dlls/ntdll/tests/env.c 5 Sep 2003 23:08:34 -0000 1.4
+++ dlls/ntdll/tests/env.c 9 Sep 2003 19:04:11 -0000
@@ -106,22 +106,22 @@
pRtlMultiByteToUnicodeN( bn, sizeof(bn), NULL, test->var, strlen(test->var)+1 );
nts = pRtlQueryEnvironmentVariable_U(small_env, &name, &value);
- ok( nts == test->status, "[%d]: Wrong status for '%s', expecting %lx got %lx",
+ ok( nts == test->status, "[%d]: Wrong status for '%s', expecting %lx got %lx\n",
test - tests, test->var, test->status, nts );
if (nts == test->status) switch (nts)
{
case STATUS_SUCCESS:
pRtlMultiByteToUnicodeN( bn, sizeof(bn), NULL, test->val, strlen(test->val)+1 );
- ok( value.Length == strlen(test->val) * sizeof(WCHAR), "Wrong length %d/%d for %s",
+ ok( value.Length == strlen(test->val) * sizeof(WCHAR), "Wrong length %d/%d for %s\n",
value.Length, strlen(test->val) * sizeof(WCHAR), test->var );
ok((value.Length == strlen(test->val) * sizeof(WCHAR) && strncmpW(bv, bn, test->len) == 0) ||
strcmpW(bv, bn) == 0,
- "Wrong result for %s/%d", test->var, test->len);
- ok(bv[test->len] == '@', "Writing too far away in the buffer for %s/%d", test->var, test->len);
+ "Wrong result for %s/%d\n", test->var, test->len);
+ ok(bv[test->len] == '@', "Writing too far away in the buffer for %s/%d\n", test->var, test->len);
break;
case STATUS_BUFFER_TOO_SMALL:
ok( value.Length == strlen(test->val) * sizeof(WCHAR),
- "Wrong returned length %d/%d (too small buffer) for %s",
+ "Wrong returned length %d/%d (too small buffer) for %s\n",
value.Length, strlen(test->val) * sizeof(WCHAR), test->var );
break;
}
@@ -147,7 +147,7 @@
pRtlMultiByteToUnicodeN( bval1, sizeof(bval1), NULL, val, strlen(val)+1 );
}
nts = pRtlSetEnvironmentVariable(env, &uvar, val ? &uval : NULL);
- ok(nts == ret, "Setting var %s=%s (%lx/%lx)", var, val, nts, ret);
+ ok(nts == ret, "Setting var %s=%s (%lx/%lx)\n", var, val, nts, ret);
if (nts == STATUS_SUCCESS)
{
uval.Length = 0;
@@ -157,13 +157,13 @@
switch (nts)
{
case STATUS_SUCCESS:
- ok(strcmpW(bval1, bval2) == 0, "Cannot get value written to environment");
+ ok(strcmpW(bval1, bval2) == 0, "Cannot get value written to environment\n");
break;
case STATUS_VARIABLE_NOT_FOUND:
- ok(val == NULL, "Couldn't find variable, but didn't delete it");
+ ok(val == NULL, "Couldn't find variable, but didn't delete it\n");
break;
default:
- ok(0, "Wrong ret %lu for %s", nts, var);
+ ok(0, "Wrong ret %lu for %s\n", nts, var);
break;
}
}
@@ -175,7 +175,7 @@
char tmp[16];
int i;
- ok(pRtlCreateEnvironment(FALSE, &env) == STATUS_SUCCESS, "Creating environment");
+ ok(pRtlCreateEnvironment(FALSE, &env) == STATUS_SUCCESS, "Creating environment\n");
memmove(env, small_env, sizeof(small_env));
testSetHelper(&env, "cat", "dog", STATUS_SUCCESS);
@@ -202,7 +202,7 @@
}
testSetHelper(&env, "fOo", NULL, STATUS_SUCCESS);
- ok(pRtlDestroyEnvironment(env) == STATUS_SUCCESS, "Destroying environment");
+ ok(pRtlDestroyEnvironment(env) == STATUS_SUCCESS, "Destroying environment\n");
}
static void testExpand(void)
@@ -248,7 +248,7 @@
nts = pRtlExpandEnvironmentStrings_U(small_env, &us_src, &us_dst, &ul);
ok(ul == strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR),
- "Wrong returned length for %s: %lu <> %u",
+ "Wrong returned length for %s: %lu <> %u\n",
test->src, ul, strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR));
us_dst.Length = 0;
@@ -256,14 +256,14 @@
us_dst.Buffer = dst;
nts = pRtlExpandEnvironmentStrings_U(small_env, &us_src, &us_dst, &ul);
- ok(nts == STATUS_SUCCESS, "Call failed (%lu)", nts);
+ ok(nts == STATUS_SUCCESS, "Call failed (%lu)\n", nts);
ok(ul == us_dst.Length + sizeof(WCHAR),
- "Wrong returned length for %s: %lu <> %u",
+ "Wrong returned length for %s: %lu <> %u\n",
test->src, ul, us_dst.Length + sizeof(WCHAR));
ok(ul == strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR),
- "Wrong returned length for %s: %lu <> %u",
+ "Wrong returned length for %s: %lu <> %u\n",
test->src, ul, strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR));
- ok(strcmpW(dst, rst) == 0, "Wrong result for %s: expecting %s",
+ ok(strcmpW(dst, rst) == 0, "Wrong result for %s: expecting %s\n",
test->src, test->dst);
us_dst.Length = 0;
@@ -271,14 +271,14 @@
us_dst.Buffer = dst;
dst[8] = '-';
nts = pRtlExpandEnvironmentStrings_U(small_env, &us_src, &us_dst, &ul);
- ok(nts == STATUS_BUFFER_TOO_SMALL, "Call failed (%lu)", nts);
+ ok(nts == STATUS_BUFFER_TOO_SMALL, "Call failed (%lu)\n", nts);
ok(ul == strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR),
- "Wrong returned length for %s (with buffer too small): %lu <> %u",
+ "Wrong returned length for %s (with buffer too small): %lu <> %u\n",
test->src, ul, strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR));
ok(strncmpW(dst, rst, 8) == 0,
- "Wrong result for %s (with buffer too small): expecting %s",
+ "Wrong result for %s (with buffer too small): expecting %s\n",
test->src, test->dst);
- ok(dst[8] == '-', "Writing too far in buffer (got %c/%d)", dst[8], dst[8]);
+ ok(dst[8] == '-', "Writing too far in buffer (got %c/%d)\n", dst[8], dst[8]);
}
}
Index: dlls/ntdll/tests/error.c
===================================================================
RCS file: /home/cvs/wine/dlls/ntdll/tests/error.c,v
retrieving revision 1.6
diff -u -r1.6 error.c
--- dlls/ntdll/tests/error.c 4 Oct 2003 03:04:47 -0000 1.6
+++ dlls/ntdll/tests/error.c 17 Oct 2003 13:53:18 -0000
@@ -72,7 +72,7 @@
err = statustodoserror(win_nt);
ok(err == win32,
- "%s (%lx): got %ld, expected %ld",
+ "%s (%lx): got %ld, expected %ld\n",
message, win_nt, err, win32);
}
@@ -83,7 +83,7 @@
err = statustodoserror(win_nt);
ok(err == win32 ||
(!strict && err == ERROR_MR_MID_NOT_FOUND),
- "%s (%lx): got %ld, expected %ld (or MID_NOT_FOUND)",
+ "%s (%lx): got %ld, expected %ld (or MID_NOT_FOUND)\n",
message, win_nt, err, win32);
}
@@ -93,7 +93,7 @@
err = statustodoserror(win_nt);
ok(err == win32_1 || (!strict && err == win32_2),
- "%s (%lx): got %ld, expected %ld or %ld",
+ "%s (%lx): got %ld, expected %ld or %ld\n",
message, win_nt, err, win32_1, win32_2);
}
@@ -104,7 +104,7 @@
err = statustodoserror(win_nt);
ok(err == win32_1 ||
(!strict && (err == win32_2 || err == ERROR_MR_MID_NOT_FOUND)),
- "%s (%lx): got %ld, expected %ld or %ld",
+ "%s (%lx): got %ld, expected %ld or %ld\n",
message, win_nt, err, win32_1, win32_2);
}
Index: dlls/ntdll/tests/generated.c
===================================================================
RCS file: /home/cvs/wine/dlls/ntdll/tests/generated.c,v
retrieving revision 1.7
diff -u -r1.7 generated.c
--- dlls/ntdll/tests/generated.c 5 Sep 2003 23:08:34 -0000 1.7
+++ dlls/ntdll/tests/generated.c 9 Sep 2003 19:04:10 -0000
@@ -72,20 +72,20 @@
#ifdef _TYPE_ALIGNMENT
#define TEST__TYPE_ALIGNMENT(type, align) \
- ok(_TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")", _TYPE_ALIGNMENT(type))
+ ok(_TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(\n" #type ") == %d (expected " #align ")", _TYPE_ALIGNMENT(type))
#else
# define TEST__TYPE_ALIGNMENT(type, align) do { } while (0)
#endif
#ifdef TYPE_ALIGNMENT
#define TEST_TYPE_ALIGNMENT(type, align) \
- ok(TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")", TYPE_ALIGNMENT(type))
+ ok(TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(\n" #type ") == %d (expected " #align ")", TYPE_ALIGNMENT(type))
#else
# define TEST_TYPE_ALIGNMENT(type, align) do { } while (0)
#endif
#define TEST_TYPE_SIZE(type, size) \
- ok(sizeof(type) == size, "sizeof(" #type ") == %d (expected " #size ")", sizeof(type))
+ ok(sizeof(type) == size, "sizeof(\n" #type ") == %d (expected " #size ")", sizeof(type))
/***********************************************************************
* Test macros
@@ -105,10 +105,10 @@
TEST_TYPE_SIZE(*(type)0, size)
#define TEST_TYPE_SIGNED(type) \
- ok((type) -1 < 0, "(" #type ") -1 < 0");
+ ok((type) -1 < 0, "(\n" #type ") -1 < 0");
#define TEST_TYPE_UNSIGNED(type) \
- ok((type) -1 > 0, "(" #type ") -1 > 0");
+ ok((type) -1 > 0, "(\n" #type ") -1 > 0");
static void test_pack_DWORD32(void)
{
Index: dlls/ntdll/tests/large_int.c
===================================================================
RCS file: /home/cvs/wine/dlls/ntdll/tests/large_int.c,v
retrieving revision 1.4
diff -u -r1.4 large_int.c
--- dlls/ntdll/tests/large_int.c 4 Oct 2003 03:04:47 -0000 1.4
+++ dlls/ntdll/tests/large_int.c 17 Oct 2003 13:53:19 -0000
@@ -45,7 +45,7 @@
static void InitFunctionPtrs()
{
hntdll = LoadLibraryA("ntdll.dll");
- ok(hntdll != 0, "LoadLibrary failed");
+ ok(hntdll != 0, "LoadLibrary failed\n");
if (hntdll) {
pRtlExtendedMagicDivide = (void *)GetProcAddress(hntdll, "RtlExtendedMagicDivide");
pRtlFreeAnsiString = (void *)GetProcAddress(hntdll, "RtlFreeAnsiString");
@@ -120,7 +120,7 @@
for (i = 0; i < NB_MAGIC_DIVIDE; i++) {
result = pRtlExtendedMagicDivide(magic_divide[i].a, magic_divide[i].b, magic_divide[i].shift);
ok(result == magic_divide[i].result,
- "call failed: RtlExtendedMagicDivide(%lld, %llu, %d) has result %llx, expected %llx",
+ "call failed: RtlExtendedMagicDivide(%lld, %llu, %d) has result %llx, expected %llx\n",
magic_divide[i].a, magic_divide[i].b, magic_divide[i].shift, result, magic_divide[i].result);
}
}
@@ -329,22 +329,22 @@
} /* if */
} else {
ok(result == largeint2str->result,
- "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) has result %lx, expected: %lx",
+ "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) has result %lx, expected: %lx\n",
test_num, largeint2str->value, largeint2str->base, result, largeint2str->result);
if (result == STATUS_SUCCESS) {
ok(unicode_string.Buffer[unicode_string.Length/sizeof(WCHAR)] == '\0',
- "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) string \"%s\" is not NULL terminated",
+ "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) string \"%s\" is not NULL terminated\n",
test_num, largeint2str->value, largeint2str->base, ansi_str.Buffer);
} /* if */
} /* if */
ok(memcmp(unicode_string.Buffer, expected_unicode_string.Buffer, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
- "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) assigns string \"%s\", expected: \"%s\"\n",
test_num, largeint2str->value, largeint2str->base, ansi_str.Buffer, expected_ansi_str.Buffer);
ok(unicode_string.Length == expected_unicode_string.Length,
- "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) string has Length %d, expected: %d",
+ "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) string has Length %d, expected: %d\n",
test_num, largeint2str->value, largeint2str->base, unicode_string.Length, expected_unicode_string.Length);
ok(unicode_string.MaximumLength == expected_unicode_string.MaximumLength,
- "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) string has MaximumLength %d, expected: %d",
+ "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) string has MaximumLength %d, expected: %d\n",
test_num, largeint2str->value, largeint2str->base, unicode_string.MaximumLength, expected_unicode_string.MaximumLength);
pRtlFreeAnsiString(&expected_ansi_str);
pRtlFreeAnsiString(&ansi_str);
@@ -376,10 +376,10 @@
result = pRtlLargeIntegerToChar(&value, largeint2str->base, largeint2str->MaximumLength, dest_str);
} /* if */
ok(result == largeint2str->result,
- "(test %d): RtlLargeIntegerToChar(%llu, %d, %d, [out]) has result %lx, expected: %lx",
+ "(test %d): RtlLargeIntegerToChar(%llu, %d, %d, [out]) has result %lx, expected: %lx\n",
test_num, largeint2str->value, largeint2str->base, largeint2str->MaximumLength, result, largeint2str->result);
ok(memcmp(dest_str, largeint2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
- "(test %d): RtlLargeIntegerToChar(%llu, %d, %d, [out]) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): RtlLargeIntegerToChar(%llu, %d, %d, [out]) assigns string \"%s\", expected: \"%s\"\n",
test_num, largeint2str->value, largeint2str->base, largeint2str->MaximumLength, dest_str, largeint2str->Buffer);
}
@@ -397,22 +397,22 @@
value = largeint2str[0].value;
result = pRtlLargeIntegerToChar(&value, 20, largeint2str[0].MaximumLength, NULL);
ok(result == STATUS_INVALID_PARAMETER,
- "(test a): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x",
+ "(test a): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x\n",
largeint2str[0].value, 20, largeint2str[0].MaximumLength, result, STATUS_INVALID_PARAMETER);
result = pRtlLargeIntegerToChar(&value, 20, 0, NULL);
ok(result == STATUS_INVALID_PARAMETER,
- "(test b): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x",
+ "(test b): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x\n",
largeint2str[0].value, 20, largeint2str[0].MaximumLength, result, STATUS_INVALID_PARAMETER);
result = pRtlLargeIntegerToChar(&value, largeint2str[0].base, 0, NULL);
ok(result == STATUS_BUFFER_OVERFLOW,
- "(test c): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x",
+ "(test c): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x\n",
largeint2str[0].value, largeint2str[0].base, 0, result, STATUS_BUFFER_OVERFLOW);
result = pRtlLargeIntegerToChar(&value, largeint2str[0].base, largeint2str[0].MaximumLength, NULL);
ok(result == STATUS_ACCESS_VIOLATION,
- "(test d): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x",
+ "(test d): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x\n",
largeint2str[0].value, largeint2str[0].base, largeint2str[0].MaximumLength, result, STATUS_ACCESS_VIOLATION);
}
Index: dlls/ntdll/tests/path.c
===================================================================
RCS file: /home/cvs/wine/dlls/ntdll/tests/path.c,v
retrieving revision 1.4
diff -u -r1.4 path.c
--- dlls/ntdll/tests/path.c 6 Oct 2003 21:03:32 -0000 1.4
+++ dlls/ntdll/tests/path.c 17 Oct 2003 13:53:19 -0000
@@ -84,7 +84,7 @@
{
pRtlMultiByteToUnicodeN( buffer, sizeof(buffer), NULL, test->path, strlen(test->path)+1 );
ret = pRtlDetermineDosPathNameType_U( buffer );
- ok( ret == test->ret, "Wrong result %d/%d for %s", ret, test->ret, test->path );
+ ok( ret == test->ret, "Wrong result %d/%d for %s\n", ret, test->ret, test->path );
}
}
@@ -148,7 +148,7 @@
pRtlMultiByteToUnicodeN( buffer, sizeof(buffer), NULL, test->path, strlen(test->path)+1 );
ret = pRtlIsDosDeviceName_U( buffer );
ok( ret == MAKELONG( test->len, test->pos ),
- "Wrong result (%d,%d)/(%d,%d) for %s",
+ "Wrong result (%d,%d)/(%d,%d) for %s\n",
HIWORD(ret), LOWORD(ret), test->pos, test->len, test->path );
}
}
@@ -209,18 +209,18 @@
oem_ret.Length = oem_ret.MaximumLength = sizeof(buff2);
oem_ret.Buffer = buff2;
ret = pRtlIsNameLegalDOS8Dot3( &ustr, &oem_ret, &spaces );
- ok( ret == test->result, "Wrong result %d/%d for '%s'", ret, test->result, test->path );
- ok( spaces == test->spaces, "Wrong spaces value %d/%d for '%s'", spaces, test->spaces, test->path );
+ ok( ret == test->result, "Wrong result %d/%d for '%s'\n", ret, test->result, test->path );
+ ok( spaces == test->spaces, "Wrong spaces value %d/%d for '%s'\n", spaces, test->spaces, test->path );
if (strlen(test->path) <= 12)
{
char str[13];
int i;
strcpy( str, test->path );
for (i = 0; str[i]; i++) str[i] = toupper(str[i]);
- ok( oem_ret.Length == strlen(test->path), "Wrong length %d/%d for '%s'",
+ ok( oem_ret.Length == strlen(test->path), "Wrong length %d/%d for '%s'\n",
oem_ret.Length, strlen(test->path), test->path );
ok( !memcmp( oem_ret.Buffer, str, oem_ret.Length ),
- "Wrong string '%.*s'/'%s'", oem_ret.Length, oem_ret.Buffer, str );
+ "Wrong string '%.*s'/'%s'\n", oem_ret.Length, oem_ret.Buffer, str );
}
}
}
Index: dlls/ntdll/tests/rtl.c
===================================================================
RCS file: /home/cvs/wine/dlls/ntdll/tests/rtl.c,v
retrieving revision 1.5
diff -u -r1.5 rtl.c
--- dlls/ntdll/tests/rtl.c 5 Sep 2003 23:08:34 -0000 1.5
+++ dlls/ntdll/tests/rtl.c 9 Sep 2003 19:04:11 -0000
@@ -58,7 +58,7 @@
static void InitFunctionPtrs(void)
{
hntdll = LoadLibraryA("ntdll.dll");
- ok(hntdll != 0, "LoadLibrary failed");
+ ok(hntdll != 0, "LoadLibrary failed\n");
if (hntdll) {
pRtlCompareMemory = (void *)GetProcAddress(hntdll, "RtlCompareMemory");
pRtlCompareMemoryUlong = (void *)GetProcAddress(hntdll, "RtlCompareMemoryUlong");
@@ -241,7 +241,7 @@
result = pRtlUlonglongByteSwap( ((ULONGLONG)0x76543210 << 32) | 0x87654321 );
ok( (((ULONGLONG)0x21436587 << 32) | 0x10325476) == result,
- "RtlUlonglongByteSwap(0x7654321087654321) returns 0x%llx, expected 0x2143658710325476",
+ "RtlUlonglongByteSwap(0x7654321087654321) returns 0x%llx, expected 0x2143658710325476\n",
result);
}
@@ -276,7 +276,7 @@
expected = 0x7fffffc3;
result = pRtlUniform(&seed);
ok(result == expected,
- "RtlUniform(&seed (seed == 0)) returns %lx, expected %lx",
+ "RtlUniform(&seed (seed == 0)) returns %lx, expected %lx\n",
result, expected);
/*
* The algorithm is now:
@@ -297,7 +297,7 @@
expected = seed * 0xffffffed + 0x7fffffc3 + 1;
result = pRtlUniform(&seed);
ok(result == expected,
- "RtlUniform(&seed (seed == 1)) returns %lx, expected %lx",
+ "RtlUniform(&seed (seed == 1)) returns %lx, expected %lx\n",
result, expected);
/*
* For seed = 2 the const_2 is 0x7fffffc3:
@@ -306,7 +306,7 @@
expected = seed * 0xffffffed + 0x7fffffc3;
result = pRtlUniform(&seed);
ok(result == expected,
- "RtlUniform(&seed (seed == 2)) returns %lx, expected %lx",
+ "RtlUniform(&seed (seed == 2)) returns %lx, expected %lx\n",
result, expected);
/*
* More tests show that if seed is odd the result must be incremented by 1:
@@ -315,21 +315,21 @@
expected = seed * 0xffffffed + 0x7fffffc3 + (seed & 1);
result = pRtlUniform(&seed);
ok(result == expected,
- "RtlUniform(&seed (seed == 2)) returns %lx, expected %lx",
+ "RtlUniform(&seed (seed == 2)) returns %lx, expected %lx\n",
result, expected);
seed = 0x6bca1aa;
expected = seed * 0xffffffed + 0x7fffffc3;
result = pRtlUniform(&seed);
ok(result == expected,
- "RtlUniform(&seed (seed == 0x6bca1aa)) returns %lx, expected %lx",
+ "RtlUniform(&seed (seed == 0x6bca1aa)) returns %lx, expected %lx\n",
result, expected);
seed = 0x6bca1ab;
expected = seed * 0xffffffed + 0x7fffffc3 + 1;
result = pRtlUniform(&seed);
ok(result == expected,
- "RtlUniform(&seed (seed == 0x6bca1ab)) returns %lx, expected %lx",
+ "RtlUniform(&seed (seed == 0x6bca1ab)) returns %lx, expected %lx\n",
result, expected);
/*
* When seed is 0x6bca1ac there is an exception:
@@ -338,7 +338,7 @@
expected = seed * 0xffffffed + 0x7fffffc3 + 2;
result = pRtlUniform(&seed);
ok(result == expected,
- "RtlUniform(&seed (seed == 0x6bca1ac)) returns %lx, expected %lx",
+ "RtlUniform(&seed (seed == 0x6bca1ac)) returns %lx, expected %lx\n",
result, expected);
/*
* Note that up to here const_3 is not used
@@ -350,14 +350,14 @@
expected = (seed * 0xffffffed + 0x7fffffc3) & MAXLONG;
result = pRtlUniform(&seed);
ok(result == expected,
- "RtlUniform(&seed (seed == 0x6bca1ad)) returns %lx, expected %lx",
+ "RtlUniform(&seed (seed == 0x6bca1ad)) returns %lx, expected %lx\n",
result, expected);
seed = 0x6bca1ae;
expected = (seed * 0xffffffed + 0x7fffffc3 + 1) & MAXLONG;
result = pRtlUniform(&seed);
ok(result == expected,
- "RtlUniform(&seed (seed == 0x6bca1ae)) returns %lx, expected %lx",
+ "RtlUniform(&seed (seed == 0x6bca1ae)) returns %lx, expected %lx\n",
result, expected);
/*
* There are several ranges where for odd or even seed the result must be
@@ -465,10 +465,10 @@
seed_bak = seed;
result = pRtlUniform(&seed);
ok(result == expected,
- "test: %llu RtlUniform(&seed (seed == %lx)) returns %lx, expected %lx",
+ "test: %llu RtlUniform(&seed (seed == %lx)) returns %lx, expected %lx\n",
num, seed_bak, result, expected);
ok(seed == expected,
- "test: %llu RtlUniform(&seed (seed == %lx)) sets seed to %lx, expected %lx",
+ "test: %llu RtlUniform(&seed (seed == %lx)) sets seed to %lx, expected %lx\n",
num, seed_bak, seed, expected);
} /* for */
/*
@@ -512,10 +512,10 @@
seed_bak = seed;
result = pRtlUniform(&seed);
ok(result == expected,
- "test: %llu RtlUniform(&seed (seed == %lx)) returns %lx, expected %lx",
+ "test: %llu RtlUniform(&seed (seed == %lx)) returns %lx, expected %lx\n",
num, seed_bak, result, expected);
ok(seed == expected,
- "test: %llu RtlUniform(&seed (seed == %lx)) sets seed to %lx, expected %lx",
+ "test: %llu RtlUniform(&seed (seed == %lx)) sets seed to %lx, expected %lx\n",
num, seed_bak, seed, expected);
} /* for */
/*
@@ -592,10 +592,10 @@
seed_expected =0x44b;
result = pRtlRandom(&seed);
ok(result == result_expected,
- "pRtlRandom(&seed (seed == 0)) returns %lx, expected %lx",
+ "pRtlRandom(&seed (seed == 0)) returns %lx, expected %lx\n",
result, result_expected);
ok(seed == seed_expected,
- "pRtlRandom(&seed (seed == 0)) sets seed to %lx, expected %lx",
+ "pRtlRandom(&seed (seed == 0)) sets seed to %lx, expected %lx\n",
seed, seed_expected);
/*
* Seed is not equal to result as with RtlUniform. To see more we
@@ -606,10 +606,10 @@
seed_expected =0x44b;
result = pRtlRandom(&seed);
ok(result == result_expected,
- "RtlRandom(&seed (seed == 0)) returns %lx, expected %lx",
+ "RtlRandom(&seed (seed == 0)) returns %lx, expected %lx\n",
result, result_expected);
ok(seed == seed_expected,
- "RtlRandom(&seed (seed == 0)) sets seed to %lx, expected %lx",
+ "RtlRandom(&seed (seed == 0)) sets seed to %lx, expected %lx\n",
seed, seed_expected);
/*
* Seed is set to the same value as before but the result is different.
@@ -620,10 +620,10 @@
seed_expected =0x44b;
result = pRtlRandom(&seed);
ok(result == result_expected,
- "RtlRandom(&seed (seed == 0)) returns %lx, expected %lx",
+ "RtlRandom(&seed (seed == 0)) returns %lx, expected %lx\n",
result, result_expected);
ok(seed == seed_expected,
- "RtlRandom(&seed (seed == 0)) sets seed to %lx, expected %lx",
+ "RtlRandom(&seed (seed == 0)) sets seed to %lx, expected %lx\n",
seed, seed_expected);
/*
* Seed is aggain set to the same value as before. This time we also
@@ -668,10 +668,10 @@
seed_expected =0x5a1;
result = pRtlRandom(&seed);
ok(result == result_expected,
- "RtlRandom(&seed (seed == 1)) returns %lx, expected %lx",
+ "RtlRandom(&seed (seed == 1)) returns %lx, expected %lx\n",
result, result_expected);
ok(seed == seed_expected,
- "RtlRandom(&seed (seed == 1)) sets seed to %lx, expected %lx",
+ "RtlRandom(&seed (seed == 1)) sets seed to %lx, expected %lx\n",
seed, seed_expected);
/*
* If there is just one saved_value the result now would be
@@ -729,10 +729,10 @@
} /* if */
result = pRtlRandom(&seed);
ok(result == result_expected,
- "test: %llu RtlUniform(&seed (seed == %lx)) returns %lx, expected %lx",
+ "test: %llu RtlUniform(&seed (seed == %lx)) returns %lx, expected %lx\n",
num, seed_bak, result, result_expected);
ok(seed == seed_expected,
- "test: %llu RtlUniform(&seed (seed == %lx)) sets seed to %lx, expected %lx",
+ "test: %llu RtlUniform(&seed (seed == %lx)) sets seed to %lx, expected %lx\n",
num, seed_bak, seed, seed_expected);
} /* for */
}
@@ -768,7 +768,7 @@
result = pRtlAreAllAccessesGranted(all_accesses[test_num].GrantedAccess,
all_accesses[test_num].DesiredAccess);
ok(all_accesses[test_num].result == result,
- "(test %d): RtlAreAllAccessesGranted(%08lx, %08lx) returns %d, expected %d",
+ "(test %d): RtlAreAllAccessesGranted(%08lx, %08lx) returns %d, expected %d\n",
test_num, all_accesses[test_num].GrantedAccess,
all_accesses[test_num].DesiredAccess,
result, all_accesses[test_num].result);
@@ -805,7 +805,7 @@
result = pRtlAreAnyAccessesGranted(any_accesses[test_num].GrantedAccess,
any_accesses[test_num].DesiredAccess);
ok(any_accesses[test_num].result == result,
- "(test %d): RtlAreAnyAccessesGranted(%08lx, %08lx) returns %d, expected %d",
+ "(test %d): RtlAreAnyAccessesGranted(%08lx, %08lx) returns %d, expected %d\n",
test_num, any_accesses[test_num].GrantedAccess,
any_accesses[test_num].DesiredAccess,
result, any_accesses[test_num].result);
Index: dlls/ntdll/tests/rtlbitmap.c
===================================================================
RCS file: /home/cvs/wine/dlls/ntdll/tests/rtlbitmap.c,v
retrieving revision 1.5
diff -u -r1.5 rtlbitmap.c
--- dlls/ntdll/tests/rtlbitmap.c 5 Sep 2003 23:08:34 -0000 1.5
+++ dlls/ntdll/tests/rtlbitmap.c 9 Sep 2003 19:04:10 -0000
@@ -56,7 +56,7 @@
static void InitFunctionPtrs()
{
hntdll = LoadLibraryA("ntdll.dll");
- ok(hntdll != 0, "LoadLibrary failed");
+ ok(hntdll != 0, "LoadLibrary failed\n");
if (hntdll)
{
pRtlInitializeBitMap = (void *)GetProcAddress(hntdll, "RtlInitializeBitMap");
@@ -89,15 +89,15 @@
buff[79] = 77;
pRtlInitializeBitMap(&bm, buff, 800);
- ok(bm.SizeOfBitMap == 800, "size uninitialised");
- ok(bm.BitMapBuffer == buff,"buffer uninitialised");
- ok(buff[0] == 77 && buff[79] == 77, "wrote to buffer");
+ ok(bm.SizeOfBitMap == 800, "size uninitialised\n");
+ ok(bm.BitMapBuffer == buff,"buffer uninitialised\n");
+ ok(buff[0] == 77 && buff[79] == 77, "wrote to buffer\n");
/* Test inlined version */
RtlInitializeBitMap(&bm, buff, 800);
- ok(bm.SizeOfBitMap == 800, "size uninitialised");
- ok(bm.BitMapBuffer == buff,"buffer uninitialised");
- ok(buff[0] == 77 && buff[79] == 77, "wrote to buffer");
+ ok(bm.SizeOfBitMap == 800, "size uninitialised\n");
+ ok(bm.BitMapBuffer == buff,"buffer uninitialised\n");
+ ok(buff[0] == 77 && buff[79] == 77, "wrote to buffer\n");
}
static void test_RtlSetAllBits(void)
@@ -110,15 +110,15 @@
pRtlSetAllBits(&bm);
ok(buff[0] == 0xff && buff[1] == 0xff && buff[2] == 0xff &&
- buff[3] == 0xff, "didnt round up size");
- ok(buff[4] == 0, "set more than rounded size");
+ buff[3] == 0xff, "didnt round up size\n");
+ ok(buff[4] == 0, "set more than rounded size\n");
/* Test inlined version */
memset(buff, 0 , sizeof(buff));
RtlSetAllBits(&bm);
ok(buff[0] == 0xff && buff[1] == 0xff && buff[2] == 0xff &&
- buff[3] == 0xff, "didnt round up size");
- ok(buff[4] == 0, "set more than rounded size");
+ buff[3] == 0xff, "didnt round up size\n");
+ ok(buff[4] == 0, "set more than rounded size\n");
}
static void test_RtlClearAllBits()
@@ -130,14 +130,14 @@
pRtlInitializeBitMap(&bm, buff, 1);
pRtlClearAllBits(&bm);
- ok(!buff[0] && !buff[1] && !buff[2] && !buff[3], "didnt round up size");
- ok(buff[4] == 0xff, "cleared more than rounded size");
+ ok(!buff[0] && !buff[1] && !buff[2] && !buff[3], "didnt round up size\n");
+ ok(buff[4] == 0xff, "cleared more than rounded size\n");
/* Test inlined version */
memset(buff, 0xff , sizeof(buff));
RtlClearAllBits(&bm);
- ok(!buff[0] && !buff[1] && !buff[2] && !buff[3] , "didnt round up size");
- ok(buff[4] == 0xff, "cleared more than rounded size");
+ ok(!buff[0] && !buff[1] && !buff[2] && !buff[3] , "didnt round up size\n");
+ ok(buff[4] == 0xff, "cleared more than rounded size\n");
}
static void test_RtlSetBits()
@@ -149,23 +149,23 @@
pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
pRtlSetBits(&bm, 0, 1);
- ok(buff[0] == 1, "didnt set 1st bit");
+ ok(buff[0] == 1, "didnt set 1st bit\n");
buff[0] = 0;
pRtlSetBits(&bm, 7, 2);
- ok(buff[0] == 0x80 && buff[1] == 1, "didnt span w/len < 8");
+ ok(buff[0] == 0x80 && buff[1] == 1, "didnt span w/len < 8\n");
buff[0] = buff[1] = 0;
pRtlSetBits(&bm, 7, 10);
- ok(buff[0] == 0x80 && buff[1] == 0xff && buff[2] == 1, "didnt span w/len > 8");
+ ok(buff[0] == 0x80 && buff[1] == 0xff && buff[2] == 1, "didnt span w/len > 8\n");
buff[0] = buff[1] = buff[2] = 0;
pRtlSetBits(&bm, 0, 8); /* 1st byte */
- ok(buff[0] == 0xff, "didnt set all bits");
- ok(!buff[1], "set too many bits");
+ ok(buff[0] == 0xff, "didnt set all bits\n");
+ ok(!buff[1], "set too many bits\n");
pRtlSetBits(&bm, sizeof(buff)*8-1, 1); /* last bit */
- ok(buff[sizeof(buff)-1] == 0x80, "didnt set last bit");
+ ok(buff[sizeof(buff)-1] == 0x80, "didnt set last bit\n");
}
static void test_RtlClearBits()
@@ -177,23 +177,23 @@
pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
pRtlClearBits(&bm, 0, 1);
- ok(buff[0] == 0xfe, "didnt clear 1st bit");
+ ok(buff[0] == 0xfe, "didnt clear 1st bit\n");
buff[0] = 0xff;
pRtlClearBits(&bm, 7, 2);
- ok(buff[0] == 0x7f && buff[1] == 0xfe, "didnt span w/len < 8");
+ ok(buff[0] == 0x7f && buff[1] == 0xfe, "didnt span w/len < 8\n");
buff[0] = buff[1] = 0xff;
pRtlClearBits(&bm, 7, 10);
- ok(buff[0] == 0x7f && buff[1] == 0 && buff[2] == 0xfe, "didnt span w/len > 8");
+ ok(buff[0] == 0x7f && buff[1] == 0 && buff[2] == 0xfe, "didnt span w/len > 8\n");
buff[0] = buff[1] = buff[2] = 0xff;
pRtlClearBits(&bm, 0, 8); /* 1st byte */
- ok(!buff[0], "didnt clear all bits");
- ok(buff[1] == 0xff, "cleared too many bits");
+ ok(!buff[0], "didnt clear all bits\n");
+ ok(buff[1] == 0xff, "cleared too many bits\n");
pRtlClearBits(&bm, sizeof(buff)*8-1, 1);
- ok(buff[sizeof(buff)-1] == 0x7f, "didnt set last bit");
+ ok(buff[sizeof(buff)-1] == 0x7f, "didnt set last bit\n");
}
static void test_RtlCheckBit()
@@ -207,17 +207,17 @@
pRtlSetBits(&bm, sizeof(buff)*8-1, 1);
bRet = RtlCheckBit(&bm, 0);
- ok (bRet, "didnt find set bit");
+ ok (bRet, "didnt find set bit\n");
bRet = RtlCheckBit(&bm, 7);
- ok (bRet, "didnt find set bit");
+ ok (bRet, "didnt find set bit\n");
bRet = RtlCheckBit(&bm, 8);
- ok (bRet, "didnt find set bit");
+ ok (bRet, "didnt find set bit\n");
bRet = RtlCheckBit(&bm, sizeof(buff)*8-1);
- ok (bRet, "didnt find set bit");
+ ok (bRet, "didnt find set bit\n");
bRet = RtlCheckBit(&bm, 1);
- ok (!bRet, "found non set bit");
+ ok (!bRet, "found non set bit\n");
bRet = RtlCheckBit(&bm, sizeof(buff)*8-2);
- ok (!bRet, "found non set bit");
+ ok (!bRet, "found non set bit\n");
}
static void test_RtlAreBitsSet()
@@ -231,38 +231,38 @@
pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
bRet = pRtlAreBitsSet(&bm, 0, 1);
- ok (!bRet, "found set bits after init");
+ ok (!bRet, "found set bits after init\n");
pRtlSetBits(&bm, 0, 1);
bRet = pRtlAreBitsSet(&bm, 0, 1);
- ok (bRet, "didnt find set bits");
+ ok (bRet, "didnt find set bits\n");
buff[0] = 0;
pRtlSetBits(&bm, 7, 2);
bRet = pRtlAreBitsSet(&bm, 7, 2);
- ok(bRet, "didnt find w/len < 8");
+ ok(bRet, "didnt find w/len < 8\n");
bRet = pRtlAreBitsSet(&bm, 6, 3);
- ok(!bRet, "found non set bit");
+ ok(!bRet, "found non set bit\n");
bRet = pRtlAreBitsSet(&bm, 7, 3);
- ok(!bRet, "found non set bit");
+ ok(!bRet, "found non set bit\n");
buff[0] = buff[1] = 0;
pRtlSetBits(&bm, 7, 10);
bRet = pRtlAreBitsSet(&bm, 7, 10);
- ok(bRet, "didnt find w/len < 8");
+ ok(bRet, "didnt find w/len < 8\n");
bRet = pRtlAreBitsSet(&bm, 6, 11);
- ok(!bRet, "found non set bit");
+ ok(!bRet, "found non set bit\n");
bRet = pRtlAreBitsSet(&bm, 7, 11);
- ok(!bRet, "found non set bit");
+ ok(!bRet, "found non set bit\n");
buff[0] = buff[1] = buff[2] = 0;
pRtlSetBits(&bm, 0, 8); /* 1st byte */
bRet = pRtlAreBitsSet(&bm, 0, 8);
- ok(bRet, "didn't find whole byte");
+ ok(bRet, "didn't find whole byte\n");
pRtlSetBits(&bm, sizeof(buff)*8-1, 1);
bRet = pRtlAreBitsSet(&bm, sizeof(buff)*8-1, 1);
- ok(bRet, "didn't find last bit");
+ ok(bRet, "didn't find last bit\n");
}
static void test_RtlAreBitsClear()
@@ -276,38 +276,38 @@
pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
bRet = pRtlAreBitsClear(&bm, 0, 1);
- ok (!bRet, "found clear bits after init");
+ ok (!bRet, "found clear bits after init\n");
pRtlClearBits(&bm, 0, 1);
bRet = pRtlAreBitsClear(&bm, 0, 1);
- ok (bRet, "didnt find set bits");
+ ok (bRet, "didnt find set bits\n");
buff[0] = 0xff;
pRtlClearBits(&bm, 7, 2);
bRet = pRtlAreBitsClear(&bm, 7, 2);
- ok(bRet, "didnt find w/len < 8");
+ ok(bRet, "didnt find w/len < 8\n");
bRet = pRtlAreBitsClear(&bm, 6, 3);
- ok(!bRet, "found non clear bit");
+ ok(!bRet, "found non clear bit\n");
bRet = pRtlAreBitsClear(&bm, 7, 3);
- ok(!bRet, "found non clear bit");
+ ok(!bRet, "found non clear bit\n");
buff[0] = buff[1] = 0xff;
pRtlClearBits(&bm, 7, 10);
bRet = pRtlAreBitsClear(&bm, 7, 10);
- ok(bRet, "didnt find w/len < 8");
+ ok(bRet, "didnt find w/len < 8\n");
bRet = pRtlAreBitsClear(&bm, 6, 11);
- ok(!bRet, "found non clear bit");
+ ok(!bRet, "found non clear bit\n");
bRet = pRtlAreBitsClear(&bm, 7, 11);
- ok(!bRet, "found non clear bit");
+ ok(!bRet, "found non clear bit\n");
buff[0] = buff[1] = buff[2] = 0xff;
pRtlClearBits(&bm, 0, 8); /* 1st byte */
bRet = pRtlAreBitsClear(&bm, 0, 8);
- ok(bRet, "didn't find whole byte");
+ ok(bRet, "didn't find whole byte\n");
pRtlClearBits(&bm, sizeof(buff)*8-1, 1);
bRet = pRtlAreBitsClear(&bm, sizeof(buff)*8-1, 1);
- ok(bRet, "didn't find last bit");
+ ok(bRet, "didn't find last bit\n");
}
static void test_RtlNumberOfSetBits()
@@ -321,23 +321,23 @@
pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
ulCount = pRtlNumberOfSetBits(&bm);
- ok(ulCount == 0, "set bits after init");
+ ok(ulCount == 0, "set bits after init\n");
pRtlSetBits(&bm, 0, 1); /* Set 1st bit */
ulCount = pRtlNumberOfSetBits(&bm);
- ok(ulCount == 1, "count wrong");
+ ok(ulCount == 1, "count wrong\n");
pRtlSetBits(&bm, 7, 8); /* 8 more, spanning bytes 1-2 */
ulCount = pRtlNumberOfSetBits(&bm);
- ok(ulCount == 8+1, "count wrong");
+ ok(ulCount == 8+1, "count wrong\n");
pRtlSetBits(&bm, 17, 33); /* 33 more crossing ULONG boundary */
ulCount = pRtlNumberOfSetBits(&bm);
- ok(ulCount == 8+1+33, "count wrong");
+ ok(ulCount == 8+1+33, "count wrong\n");
pRtlSetBits(&bm, sizeof(buff)*8-1, 1); /* Set last bit */
ulCount = pRtlNumberOfSetBits(&bm);
- ok(ulCount == 8+1+33+1, "count wrong");
+ ok(ulCount == 8+1+33+1, "count wrong\n");
}
static void test_RtlNumberOfClearBits()
@@ -351,23 +351,23 @@
pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
ulCount = pRtlNumberOfClearBits(&bm);
- ok(ulCount == 0, "cleared bits after init");
+ ok(ulCount == 0, "cleared bits after init\n");
pRtlClearBits(&bm, 0, 1); /* Set 1st bit */
ulCount = pRtlNumberOfClearBits(&bm);
- ok(ulCount == 1, "count wrong");
+ ok(ulCount == 1, "count wrong\n");
pRtlClearBits(&bm, 7, 8); /* 8 more, spanning bytes 1-2 */
ulCount = pRtlNumberOfClearBits(&bm);
- ok(ulCount == 8+1, "count wrong");
+ ok(ulCount == 8+1, "count wrong\n");
pRtlClearBits(&bm, 17, 33); /* 33 more crossing ULONG boundary */
ulCount = pRtlNumberOfClearBits(&bm);
- ok(ulCount == 8+1+33, "count wrong");
+ ok(ulCount == 8+1+33, "count wrong\n");
pRtlClearBits(&bm, sizeof(buff)*8-1, 1); /* Set last bit */
ulCount = pRtlNumberOfClearBits(&bm);
- ok(ulCount == 8+1+33+1, "count wrong");
+ ok(ulCount == 8+1+33+1, "count wrong\n");
}
/* Note: this tests RtlFindSetBits also */
@@ -384,21 +384,21 @@
pRtlSetBits(&bm, 0, 32);
ulPos = pRtlFindSetBitsAndClear(&bm, 32, 0);
- ok (ulPos == 0, "didnt find bits");
+ ok (ulPos == 0, "didnt find bits\n");
if(ulPos == 0)
{
bRet = pRtlAreBitsClear(&bm, 0, 32);
- ok (bRet, "found but didnt clear");
+ ok (bRet, "found but didnt clear\n");
}
memset(buff, 0 , sizeof(buff));
pRtlSetBits(&bm, 40, 77);
ulPos = pRtlFindSetBitsAndClear(&bm, 77, 0);
- ok (ulPos == 40, "didnt find bits");
+ ok (ulPos == 40, "didnt find bits\n");
if(ulPos == 40)
{
bRet = pRtlAreBitsClear(&bm, 40, 77);
- ok (bRet, "found but didnt clear");
+ ok (bRet, "found but didnt clear\n");
}
}
@@ -416,21 +416,21 @@
memset(buff, 0xff, sizeof(buff));
pRtlSetBits(&bm, 0, 32);
ulPos = pRtlFindSetBitsAndClear(&bm, 32, 0);
- ok (ulPos == 0, "didnt find bits");
+ ok (ulPos == 0, "didnt find bits\n");
if(ulPos == 0)
{
bRet = pRtlAreBitsClear(&bm, 0, 32);
- ok (bRet, "found but didnt clear");
+ ok (bRet, "found but didnt clear\n");
}
memset(buff, 0xff , sizeof(buff));
pRtlClearBits(&bm, 40, 77);
ulPos = pRtlFindClearBitsAndSet(&bm, 77, 50);
- ok (ulPos == 40, "didnt find bits");
+ ok (ulPos == 40, "didnt find bits\n");
if(ulPos == 40)
{
bRet = pRtlAreBitsSet(&bm, 40, 77);
- ok (bRet, "found but didnt set");
+ ok (bRet, "found but didnt set\n");
}
}
@@ -449,16 +449,16 @@
ulLong <<= i;
cPos = pRtlFindMostSignificantBit(ulLong);
- ok (cPos == i, "didnt find MSB %llx %d %d", ulLong, i, cPos);
+ ok (cPos == i, "didnt find MSB %llx %d %d\n", ulLong, i, cPos);
/* Set all bits lower than bit i */
ulLong = ((ulLong - 1) << 1) | 1;
cPos = pRtlFindMostSignificantBit(ulLong);
- ok (cPos == i, "didnt find MSB %llx %d %d", ulLong, i, cPos);
+ ok (cPos == i, "didnt find MSB %llx %d %d\n", ulLong, i, cPos);
}
cPos = pRtlFindMostSignificantBit(0);
- ok (cPos == -1, "found bit when not set");
+ ok (cPos == -1, "found bit when not set\n");
}
static void test_RtlFindLeastSignificantBit()
@@ -475,15 +475,15 @@
ulLong = (ULONGLONG)1 << i;
cPos = pRtlFindLeastSignificantBit(ulLong);
- ok (cPos == i, "didnt find LSB %llx %d %d", ulLong, i, cPos);
+ ok (cPos == i, "didnt find LSB %llx %d %d\n", ulLong, i, cPos);
ulLong = ~((ULONGLONG)0) << i;
cPos = pRtlFindLeastSignificantBit(ulLong);
- ok (cPos == i, "didnt find LSB %llx %d %d", ulLong, i, cPos);
+ ok (cPos == i, "didnt find LSB %llx %d %d\n", ulLong, i, cPos);
}
cPos = pRtlFindLeastSignificantBit(0);
- ok (cPos == -1, "found bit when not set");
+ ok (cPos == -1, "found bit when not set\n");
}
/* Note: Also tests RtlFindLongestRunSet() */
@@ -499,14 +499,14 @@
memset(buff, 0, sizeof(buff));
ulCount = pRtlFindSetRuns(&bm, runs, 16, TRUE);
- ok (ulCount == 0, "found set bits in empty bitmap");
+ ok (ulCount == 0, "found set bits in empty bitmap\n");
memset(runs, 0, sizeof(runs));
memset(buff, 0xff, sizeof(buff));
ulCount = pRtlFindSetRuns(&bm, runs, 16, TRUE);
- ok (ulCount == 1, "didnt find set bits");
- ok (runs[0].StartOfRun == 0,"bad start");
- ok (runs[0].SizeOfRun == sizeof(buff)*8,"bad size");
+ ok (ulCount == 1, "didnt find set bits\n");
+ ok (runs[0].StartOfRun == 0,"bad start\n");
+ ok (runs[0].SizeOfRun == sizeof(buff)*8,"bad size\n");
/* Set up 3 runs */
memset(runs, 0, sizeof(runs));
@@ -517,46 +517,46 @@
/* Get first 2 */
ulCount = pRtlFindSetRuns(&bm, runs, 2, FALSE);
- ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 101,"bad find");
- ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 101,"bad find");
- ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 19 + 3,"bad size");
- ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice");
- ok (runs[2].StartOfRun == 0,"found extra run");
+ ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 101,"bad find\n");
+ ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 101,"bad find\n");
+ ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 19 + 3,"bad size\n");
+ ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice\n");
+ ok (runs[2].StartOfRun == 0,"found extra run\n");
/* Get longest 3 */
memset(runs, 0, sizeof(runs));
ulCount = pRtlFindSetRuns(&bm, runs, 2, TRUE);
- ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 1877,"bad find");
- ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 1877,"bad find");
- ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 33 + 19,"bad size");
- ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice");
- ok (runs[2].StartOfRun == 0,"found extra run");
+ ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 1877,"bad find\n");
+ ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 1877,"bad find\n");
+ ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 33 + 19,"bad size\n");
+ ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice\n");
+ ok (runs[2].StartOfRun == 0,"found extra run\n");
/* Get all 3 */
memset(runs, 0, sizeof(runs));
ulCount = pRtlFindSetRuns(&bm, runs, 3, TRUE);
ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 101 ||
- runs[0].StartOfRun == 1877,"bad find");
+ runs[0].StartOfRun == 1877,"bad find\n");
ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 101 ||
- runs[1].StartOfRun == 1877,"bad find");
+ runs[1].StartOfRun == 1877,"bad find\n");
ok (runs[2].StartOfRun == 7 || runs[2].StartOfRun == 101 ||
- runs[2].StartOfRun == 1877,"bad find");
+ runs[2].StartOfRun == 1877,"bad find\n");
ok (runs[0].SizeOfRun + runs[1].SizeOfRun
- + runs[2].SizeOfRun == 19 + 3 + 33,"bad size");
- ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice");
- ok (runs[1].StartOfRun != runs[2].StartOfRun,"found run twice");
- ok (runs[3].StartOfRun == 0,"found extra run");
+ + runs[2].SizeOfRun == 19 + 3 + 33,"bad size\n");
+ ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice\n");
+ ok (runs[1].StartOfRun != runs[2].StartOfRun,"found run twice\n");
+ ok (runs[3].StartOfRun == 0,"found extra run\n");
if (pRtlFindLongestRunSet)
{
ULONG ulStart = 0;
ulCount = pRtlFindLongestRunSet(&bm, &ulStart);
- ok(ulCount == 33 && ulStart == 1877,"didn't find longest %ld %ld",ulCount,ulStart);
+ ok(ulCount == 33 && ulStart == 1877,"didn't find longest %ld %ld\n",ulCount,ulStart);
memset(buff, 0, sizeof(buff));
ulCount = pRtlFindLongestRunSet(&bm, &ulStart);
- ok(ulCount == 0,"found longest when none set");
+ ok(ulCount == 0,"found longest when none set\n");
}
}
@@ -573,14 +573,14 @@
memset(buff, 0xff, sizeof(buff));
ulCount = pRtlFindClearRuns(&bm, runs, 16, TRUE);
- ok (ulCount == 0, "found clear bits in full bitmap");
+ ok (ulCount == 0, "found clear bits in full bitmap\n");
memset(runs, 0, sizeof(runs));
memset(buff, 0, sizeof(buff));
ulCount = pRtlFindClearRuns(&bm, runs, 16, TRUE);
- ok (ulCount == 1, "didnt find clear bits");
- ok (runs[0].StartOfRun == 0,"bad start");
- ok (runs[0].SizeOfRun == sizeof(buff)*8,"bad size");
+ ok (ulCount == 1, "didnt find clear bits\n");
+ ok (runs[0].StartOfRun == 0,"bad start\n");
+ ok (runs[0].SizeOfRun == sizeof(buff)*8,"bad size\n");
/* Set up 3 runs */
memset(runs, 0, sizeof(runs));
@@ -591,46 +591,46 @@
/* Get first 2 */
ulCount = pRtlFindClearRuns(&bm, runs, 2, FALSE);
- ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 101,"bad find");
- ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 101,"bad find");
- ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 19 + 3,"bad size");
- ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice");
- ok (runs[2].StartOfRun == 0,"found extra run");
+ ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 101,"bad find\n");
+ ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 101,"bad find\n");
+ ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 19 + 3,"bad size\n");
+ ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice\n");
+ ok (runs[2].StartOfRun == 0,"found extra run\n");
/* Get longest 3 */
memset(runs, 0, sizeof(runs));
ulCount = pRtlFindClearRuns(&bm, runs, 2, TRUE);
- ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 1877,"bad find");
- ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 1877,"bad find");
- ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 33 + 19,"bad size");
- ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice");
- ok (runs[2].StartOfRun == 0,"found extra run");
+ ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 1877,"bad find\n");
+ ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 1877,"bad find\n");
+ ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 33 + 19,"bad size\n");
+ ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice\n");
+ ok (runs[2].StartOfRun == 0,"found extra run\n");
/* Get all 3 */
memset(runs, 0, sizeof(runs));
ulCount = pRtlFindClearRuns(&bm, runs, 3, TRUE);
ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 101 ||
- runs[0].StartOfRun == 1877,"bad find");
+ runs[0].StartOfRun == 1877,"bad find\n");
ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 101 ||
- runs[1].StartOfRun == 1877,"bad find");
+ runs[1].StartOfRun == 1877,"bad find\n");
ok (runs[2].StartOfRun == 7 || runs[2].StartOfRun == 101 ||
- runs[2].StartOfRun == 1877,"bad find");
+ runs[2].StartOfRun == 1877,"bad find\n");
ok (runs[0].SizeOfRun + runs[1].SizeOfRun
- + runs[2].SizeOfRun == 19 + 3 + 33,"bad size");
- ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice");
- ok (runs[1].StartOfRun != runs[2].StartOfRun,"found run twice");
- ok (runs[3].StartOfRun == 0,"found extra run");
+ + runs[2].SizeOfRun == 19 + 3 + 33,"bad size\n");
+ ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice\n");
+ ok (runs[1].StartOfRun != runs[2].StartOfRun,"found run twice\n");
+ ok (runs[3].StartOfRun == 0,"found extra run\n");
if (pRtlFindLongestRunClear)
{
ULONG ulStart = 0;
ulCount = pRtlFindLongestRunClear(&bm, &ulStart);
- ok(ulCount == 33 && ulStart == 1877,"didn't find longest");
+ ok(ulCount == 33 && ulStart == 1877,"didn't find longest\n");
memset(buff, 0xff, sizeof(buff));
ulCount = pRtlFindLongestRunClear(&bm, &ulStart);
- ok(ulCount == 0,"found longest when none clear");
+ ok(ulCount == 0,"found longest when none clear\n");
}
}
Index: dlls/ntdll/tests/rtlstr.c
===================================================================
RCS file: /home/cvs/wine/dlls/ntdll/tests/rtlstr.c,v
retrieving revision 1.13
diff -u -r1.13 rtlstr.c
--- dlls/ntdll/tests/rtlstr.c 6 Oct 2003 21:03:32 -0000 1.13
+++ dlls/ntdll/tests/rtlstr.c 17 Oct 2003 13:53:19 -0000
@@ -100,7 +100,7 @@
static void InitFunctionPtrs(void)
{
hntdll = LoadLibraryA("ntdll.dll");
- ok(hntdll != 0, "LoadLibrary failed");
+ ok(hntdll != 0, "LoadLibrary failed\n");
if (hntdll) {
pRtlAnsiStringToUnicodeString = (void *)GetProcAddress(hntdll, "RtlAnsiStringToUnicodeString");
pRtlAppendAsciizToString = (void *)GetProcAddress(hntdll, "RtlAppendAsciizToString");
@@ -143,14 +143,14 @@
str.MaximumLength = 0;
str.Buffer = (void *)0xdeadbeef;
pRtlInitString(&str, teststring);
- ok(str.Length == sizeof(teststring) - sizeof(char), "Length uninitialized");
- ok(str.MaximumLength == sizeof(teststring), "MaximumLength uninitialized");
- ok(str.Buffer == teststring, "Buffer not equal to teststring");
- ok(strcmp(str.Buffer, "Some Wild String") == 0, "Buffer written to");
+ ok(str.Length == sizeof(teststring) - sizeof(char), "Length uninitialized\n");
+ ok(str.MaximumLength == sizeof(teststring), "MaximumLength uninitialized\n");
+ ok(str.Buffer == teststring, "Buffer not equal to teststring\n");
+ ok(strcmp(str.Buffer, "Some Wild String") == 0, "Buffer written to\n");
pRtlInitString(&str, NULL);
- ok(str.Length == 0, "Length uninitialized");
- ok(str.MaximumLength == 0, "MaximumLength uninitialized");
- ok(str.Buffer == NULL, "Buffer not equal to NULL");
+ ok(str.Length == 0, "Length uninitialized\n");
+ ok(str.MaximumLength == 0, "MaximumLength uninitialized\n");
+ ok(str.Buffer == NULL, "Buffer not equal to NULL\n");
/* pRtlInitString(NULL, teststring); */
}
@@ -167,14 +167,14 @@
uni.MaximumLength = 0;
uni.Buffer = (void *)0xdeadbeef;
pRtlInitUnicodeString(&uni, teststring);
- ok(uni.Length == sizeof(teststring) - sizeof(WCHAR), "Length uninitialized");
- ok(uni.MaximumLength == sizeof(teststring), "MaximumLength uninitialized");
- ok(uni.Buffer == teststring, "Buffer not equal to teststring");
- ok(lstrcmpW(uni.Buffer, originalstring) == 0, "Buffer written to");
+ ok(uni.Length == sizeof(teststring) - sizeof(WCHAR), "Length uninitialized\n");
+ ok(uni.MaximumLength == sizeof(teststring), "MaximumLength uninitialized\n");
+ ok(uni.Buffer == teststring, "Buffer not equal to teststring\n");
+ ok(lstrcmpW(uni.Buffer, originalstring) == 0, "Buffer written to\n");
pRtlInitUnicodeString(&uni, NULL);
- ok(uni.Length == 0, "Length uninitialized");
- ok(uni.MaximumLength == 0, "MaximumLength uninitialized");
- ok(uni.Buffer == NULL, "Buffer not equal to NULL");
+ ok(uni.Length == 0, "Length uninitialized\n");
+ ok(uni.MaximumLength == 0, "MaximumLength uninitialized\n");
+ ok(uni.Buffer == NULL, "Buffer not equal to NULL\n");
/* pRtlInitUnicodeString(NULL, teststring); */
}
@@ -199,16 +199,16 @@
uni.Buffer = (void *) 0xdeadbeef;
result = pRtlInitUnicodeStringEx(&uni, teststring);
ok(result == STATUS_SUCCESS,
- "pRtlInitUnicodeStringEx(&uni, 0) returns %lx, expected %x",
+ "pRtlInitUnicodeStringEx(&uni, 0) returns %lx, expected %x\n",
result, STATUS_SUCCESS);
ok(uni.Length == 32,
- "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected %u",
+ "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected %u\n",
uni.Length, 32);
ok(uni.MaximumLength == 34,
- "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected %u",
+ "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected %u\n",
uni.MaximumLength, 34);
ok(uni.Buffer == teststring,
- "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %p",
+ "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %p\n",
uni.Buffer, teststring);
uni.Length = 12345;
@@ -216,13 +216,13 @@
uni.Buffer = (void *) 0xdeadbeef;
pRtlInitUnicodeString(&uni, teststring);
ok(uni.Length == 32,
- "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u",
+ "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u\n",
uni.Length, 32);
ok(uni.MaximumLength == 34,
- "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u",
+ "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u\n",
uni.MaximumLength, 34);
ok(uni.Buffer == teststring,
- "pRtlInitUnicodeString(&uni, 0) sets Buffer to %p, expected %p",
+ "pRtlInitUnicodeString(&uni, 0) sets Buffer to %p, expected %p\n",
uni.Buffer, teststring);
uni.Length = 12345;
@@ -230,16 +230,16 @@
uni.Buffer = (void *) 0xdeadbeef;
result = pRtlInitUnicodeStringEx(&uni, teststring2);
ok(result == STATUS_NAME_TOO_LONG,
- "pRtlInitUnicodeStringEx(&uni, 0) returns %lx, expected %x",
+ "pRtlInitUnicodeStringEx(&uni, 0) returns %lx, expected %x\n",
result, STATUS_NAME_TOO_LONG);
ok(uni.Length == 12345,
- "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected %u",
+ "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected %u\n",
uni.Length, 12345);
ok(uni.MaximumLength == 12345,
- "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected %u",
+ "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected %u\n",
uni.MaximumLength, 12345);
ok(uni.Buffer == (void *) 0xdeadbeef,
- "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %x",
+ "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %x\n",
uni.Buffer, 0xdeadbeef);
uni.Length = 12345;
@@ -247,32 +247,32 @@
uni.Buffer = (void *) 0xdeadbeef;
pRtlInitUnicodeString(&uni, teststring2);
ok(uni.Length == 33920,
- "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u",
+ "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u\n",
uni.Length, 33920);
ok(uni.MaximumLength == 33922,
- "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u",
+ "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u\n",
uni.MaximumLength, 33922);
ok(uni.Buffer == teststring2,
- "pRtlInitUnicodeString(&uni, 0) sets Buffer to %p, expected %p",
+ "pRtlInitUnicodeString(&uni, 0) sets Buffer to %p, expected %p\n",
uni.Buffer, teststring2);
ok(memcmp(uni.Buffer, teststring2, (TESTSTRING2_LEN + 1) * sizeof(WCHAR)) == 0,
- "pRtlInitUnicodeString(&uni, 0) changes Buffer");
+ "pRtlInitUnicodeString(&uni, 0) changes Buffer\n");
uni.Length = 12345;
uni.MaximumLength = 12345;
uni.Buffer = (void *) 0xdeadbeef;
result = pRtlInitUnicodeStringEx(&uni, 0);
ok(result == STATUS_SUCCESS,
- "pRtlInitUnicodeStringEx(&uni, 0) returns %lx, expected %x",
+ "pRtlInitUnicodeStringEx(&uni, 0) returns %lx, expected %x\n",
result, STATUS_SUCCESS);
ok(uni.Length == 0,
- "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected %u",
+ "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected %u\n",
uni.Length, 0);
ok(uni.MaximumLength == 0,
- "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected %u",
+ "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected %u\n",
uni.MaximumLength, 0);
ok(uni.Buffer == NULL,
- "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %p",
+ "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %p\n",
uni.Buffer, NULL);
uni.Length = 12345;
@@ -280,13 +280,13 @@
uni.Buffer = (void *) 0xdeadbeef;
pRtlInitUnicodeString(&uni, 0);
ok(uni.Length == 0,
- "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u",
+ "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u\n",
uni.Length, 0);
ok(uni.MaximumLength == 0,
- "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u",
+ "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u\n",
uni.MaximumLength, 0);
ok(uni.Buffer == NULL,
- "pRtlInitUnicodeString(&uni, 0) sets Buffer to %p, expected %p",
+ "pRtlInitUnicodeString(&uni, 0) sets Buffer to %p, expected %p\n",
uni.Buffer, NULL);
}
@@ -439,31 +439,31 @@
dest_ansi_buf[dest_ansi_str.Length] = '\0';
dest_ansi_str.Buffer = dest_ansi_buf;
ok(result == dupl_ustr[test_num].result,
- "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has result %lx, expected %lx",
+ "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has result %lx, expected %lx\n",
test_num, dupl_ustr[test_num].add_nul, result, dupl_ustr[test_num].result);
ok(dest_str.Length == dupl_ustr[test_num].res_Length,
- "(test %d): RtlDuplicateUnicodeString(%d, source, dest) destination has Length %d, expected %d",
+ "(test %d): RtlDuplicateUnicodeString(%d, source, dest) destination has Length %d, expected %d\n",
test_num, dupl_ustr[test_num].add_nul, dest_str.Length, dupl_ustr[test_num].res_Length);
ok(dest_str.MaximumLength == dupl_ustr[test_num].res_MaximumLength,
- "(test %d): RtlDuplicateUnicodeString(%d, source, dest) destination has MaximumLength %d, expected %d",
+ "(test %d): RtlDuplicateUnicodeString(%d, source, dest) destination has MaximumLength %d, expected %d\n",
test_num, dupl_ustr[test_num].add_nul, dest_str.MaximumLength, dupl_ustr[test_num].res_MaximumLength);
if (result == STATUS_INVALID_PARAMETER) {
ok((dest_str.Buffer == NULL && res_str.Buffer == NULL) ||
dest_str.Buffer == dest_buf,
- "(test %d): RtlDuplicateUnicodeString(%d, source, dest) destination buffer changed %p expected %p",
+ "(test %d): RtlDuplicateUnicodeString(%d, source, dest) destination buffer changed %p expected %p\n",
test_num, dupl_ustr[test_num].add_nul, dest_str.Buffer, dest_buf);
} else {
ok(dest_str.Buffer != dest_buf,
- "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has destination buffer unchanged %p",
+ "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has destination buffer unchanged %p\n",
test_num, dupl_ustr[test_num].add_nul, dest_str.Buffer);
} /* if */
if (dest_str.Buffer != NULL && dupl_ustr[test_num].res_buf != NULL) {
ok(memcmp(dest_str.Buffer, res_str.Buffer, dupl_ustr[test_num].res_buf_size) == 0,
- "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has destination \"%s\" expected \"%s\"",
+ "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has destination \"%s\" expected \"%s\"\n",
test_num, dupl_ustr[test_num].add_nul, dest_ansi_str.Buffer, dupl_ustr[test_num].res_buf);
} else {
ok(dest_str.Buffer == NULL && dupl_ustr[test_num].res_buf == NULL,
- "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has destination %p expected %p",
+ "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has destination %p expected %p\n",
test_num, dupl_ustr[test_num].add_nul, dest_str.Buffer, dupl_ustr[test_num].res_buf);
} /* if */
} /* for */
@@ -480,7 +480,7 @@
pRtlInitString(&str, teststring);
pRtlInitString(&deststr, deststring);
pRtlCopyString(&deststr, &str);
- ok(strncmp(str.Buffer, deststring, str.Length) == 0, "String not copied");
+ ok(strncmp(str.Buffer, deststring, str.Length) == 0, "String not copied\n");
}
@@ -500,7 +500,7 @@
expected_upper_ch = (CHAR) byte_ch;
} /* if */
ok(upper_ch == expected_upper_ch,
- "RtlUpperChar('%c'[=0x%x]) has result '%c'[=0x%x], expected '%c'[=0x%x]",
+ "RtlUpperChar('%c'[=0x%x]) has result '%c'[=0x%x], expected '%c'[=0x%x]\n",
ch, ch, upper_ch, upper_ch, expected_upper_ch, expected_upper_ch);
} /* for */
}
@@ -544,7 +544,7 @@
pRtlUpperString(&result_str, &ascii_str);
ok(memcmp(result_str.Buffer, upper_str.Buffer, 256) == 0,
- "RtlUpperString does not work as expected");
+ "RtlUpperString does not work as expected\n");
}
@@ -568,7 +568,7 @@
expected_upper_ch = ch;
} /* if */
ok(upper_ch == expected_upper_ch,
- "RtlUpcaseUnicodeChar('%c'[=0x%x]) has result '%c'[=0x%x], expected: '%c'[=0x%x]",
+ "RtlUpcaseUnicodeChar('%c'[=0x%x]) has result '%c'[=0x%x], expected: '%c'[=0x%x]\n",
ch, ch, upper_ch, upper_ch, expected_upper_ch, expected_upper_ch);
} /* for */
}
@@ -617,7 +617,7 @@
pRtlUpcaseUnicodeString(&result_str, &ascii_str, 0);
for (i = 0; i <= 255; i++) {
ok(result_str.Buffer[i] == upper_str.Buffer[i],
- "RtlUpcaseUnicodeString works wrong: '%c'[=0x%x] is converted to '%c'[=0x%x], expected: '%c'[=0x%x]",
+ "RtlUpcaseUnicodeString works wrong: '%c'[=0x%x] is converted to '%c'[=0x%x], expected: '%c'[=0x%x]\n",
ascii_str.Buffer[i], ascii_str.Buffer[i],
result_str.Buffer[i], result_str.Buffer[i],
upper_str.Buffer[i], upper_str.Buffer[i]);
@@ -702,7 +702,7 @@
pRtlDowncaseUnicodeString(&result_str, &source_str, 0);
for (i = 0; i <= 1024; i++) {
ok(result_str.Buffer[i] == lower_str.Buffer[i] || result_str.Buffer[i] == source_str.Buffer[i] + 1,
- "RtlDowncaseUnicodeString works wrong: '%c'[=0x%x] is converted to '%c'[=0x%x], expected: '%c'[=0x%x]",
+ "RtlDowncaseUnicodeString works wrong: '%c'[=0x%x] is converted to '%c'[=0x%x], expected: '%c'[=0x%x]\n",
source_str.Buffer[i], source_str.Buffer[i],
result_str.Buffer[i], result_str.Buffer[i],
lower_str.Buffer[i], lower_str.Buffer[i]);
@@ -778,16 +778,16 @@
} /* if */
result = pRtlUnicodeStringToAnsiString(&ansi_str, &uni_str, ustr2astr[test_num].doalloc);
ok(result == ustr2astr[test_num].result,
- "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) has result %lx, expected %lx",
+ "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) has result %lx, expected %lx\n",
test_num, ustr2astr[test_num].doalloc, result, ustr2astr[test_num].result);
ok(ansi_str.Length == ustr2astr[test_num].res_Length,
- "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) ansi has Length %d, expected %d",
+ "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) ansi has Length %d, expected %d\n",
test_num, ustr2astr[test_num].doalloc, ansi_str.Length, ustr2astr[test_num].res_Length);
ok(ansi_str.MaximumLength == ustr2astr[test_num].res_MaximumLength,
- "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) ansi has MaximumLength %d, expected %d",
+ "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) ansi has MaximumLength %d, expected %d\n",
test_num, ustr2astr[test_num].doalloc, ansi_str.MaximumLength, ustr2astr[test_num].res_MaximumLength);
ok(memcmp(ansi_str.Buffer, ustr2astr[test_num].res_buf, ustr2astr[test_num].res_buf_size) == 0,
- "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) has ansi \"%s\" expected \"%s\"",
+ "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) has ansi \"%s\" expected \"%s\"\n",
test_num, ustr2astr[test_num].doalloc, ansi_str.Buffer, ustr2astr[test_num].res_buf);
} /* for */
}
@@ -839,21 +839,21 @@
} /* if */
result = pRtlAppendAsciizToString(&dest_str, app_asc2str[test_num].src);
ok(result == app_asc2str[test_num].result,
- "(test %d): RtlAppendAsciizToString(dest, src) has result %lx, expected %lx",
+ "(test %d): RtlAppendAsciizToString(dest, src) has result %lx, expected %lx\n",
test_num, result, app_asc2str[test_num].result);
ok(dest_str.Length == app_asc2str[test_num].res_Length,
- "(test %d): RtlAppendAsciizToString(dest, src) dest has Length %d, expected %d",
+ "(test %d): RtlAppendAsciizToString(dest, src) dest has Length %d, expected %d\n",
test_num, dest_str.Length, app_asc2str[test_num].res_Length);
ok(dest_str.MaximumLength == app_asc2str[test_num].res_MaximumLength,
- "(test %d): RtlAppendAsciizToString(dest, src) dest has MaximumLength %d, expected %d",
+ "(test %d): RtlAppendAsciizToString(dest, src) dest has MaximumLength %d, expected %d\n",
test_num, dest_str.MaximumLength, app_asc2str[test_num].res_MaximumLength);
if (dest_str.Buffer == dest_buf) {
ok(memcmp(dest_buf, app_asc2str[test_num].res_buf, app_asc2str[test_num].res_buf_size) == 0,
- "(test %d): RtlAppendAsciizToString(dest, src) has dest \"%s\" expected \"%s\"",
+ "(test %d): RtlAppendAsciizToString(dest, src) has dest \"%s\" expected \"%s\"\n",
test_num, dest_buf, app_asc2str[test_num].res_buf);
} else {
ok(dest_str.Buffer == app_asc2str[test_num].res_buf,
- "(test %d): RtlAppendAsciizToString(dest, src) dest has Buffer %p expected %p",
+ "(test %d): RtlAppendAsciizToString(dest, src) dest has Buffer %p expected %p\n",
test_num, dest_str.Buffer, app_asc2str[test_num].res_buf);
} /* if */
} /* for */
@@ -920,21 +920,21 @@
} /* if */
result = pRtlAppendStringToString(&dest_str, &src_str);
ok(result == app_str2str[test_num].result,
- "(test %d): RtlAppendStringToString(dest, src) has result %lx, expected %lx",
+ "(test %d): RtlAppendStringToString(dest, src) has result %lx, expected %lx\n",
test_num, result, app_str2str[test_num].result);
ok(dest_str.Length == app_str2str[test_num].res_Length,
- "(test %d): RtlAppendStringToString(dest, src) dest has Length %d, expected %d",
+ "(test %d): RtlAppendStringToString(dest, src) dest has Length %d, expected %d\n",
test_num, dest_str.Length, app_str2str[test_num].res_Length);
ok(dest_str.MaximumLength == app_str2str[test_num].res_MaximumLength,
- "(test %d): RtlAppendStringToString(dest, src) dest has MaximumLength %d, expected %d",
+ "(test %d): RtlAppendStringToString(dest, src) dest has MaximumLength %d, expected %d\n",
test_num, dest_str.MaximumLength, app_str2str[test_num].res_MaximumLength);
if (dest_str.Buffer == dest_buf) {
ok(memcmp(dest_buf, app_str2str[test_num].res_buf, app_str2str[test_num].res_buf_size) == 0,
- "(test %d): RtlAppendStringToString(dest, src) has dest \"%s\" expected \"%s\"",
+ "(test %d): RtlAppendStringToString(dest, src) has dest \"%s\" expected \"%s\"\n",
test_num, dest_buf, app_str2str[test_num].res_buf);
} else {
ok(dest_str.Buffer == app_str2str[test_num].res_buf,
- "(test %d): RtlAppendStringToString(dest, src) dest has Buffer %p expected %p",
+ "(test %d): RtlAppendStringToString(dest, src) dest has Buffer %p expected %p\n",
test_num, dest_str.Buffer, app_str2str[test_num].res_buf);
} /* if */
} /* for */
@@ -992,21 +992,21 @@
} /* if */
result = pRtlAppendUnicodeToString(&dest_str, (LPCWSTR) app_uni2str[test_num].src);
ok(result == app_uni2str[test_num].result,
- "(test %d): RtlAppendUnicodeToString(dest, src) has result %lx, expected %lx",
+ "(test %d): RtlAppendUnicodeToString(dest, src) has result %lx, expected %lx\n",
test_num, result, app_uni2str[test_num].result);
ok(dest_str.Length == app_uni2str[test_num].res_Length,
- "(test %d): RtlAppendUnicodeToString(dest, src) dest has Length %d, expected %d",
+ "(test %d): RtlAppendUnicodeToString(dest, src) dest has Length %d, expected %d\n",
test_num, dest_str.Length, app_uni2str[test_num].res_Length);
ok(dest_str.MaximumLength == app_uni2str[test_num].res_MaximumLength,
- "(test %d): RtlAppendUnicodeToString(dest, src) dest has MaximumLength %d, expected %d",
+ "(test %d): RtlAppendUnicodeToString(dest, src) dest has MaximumLength %d, expected %d\n",
test_num, dest_str.MaximumLength, app_uni2str[test_num].res_MaximumLength);
if (dest_str.Buffer == dest_buf) {
ok(memcmp(dest_buf, app_uni2str[test_num].res_buf, app_uni2str[test_num].res_buf_size) == 0,
- "(test %d): RtlAppendUnicodeToString(dest, src) has dest \"%s\" expected \"%s\"",
+ "(test %d): RtlAppendUnicodeToString(dest, src) has dest \"%s\" expected \"%s\"\n",
test_num, (char *) dest_buf, app_uni2str[test_num].res_buf);
} else {
ok(dest_str.Buffer == (WCHAR *) app_uni2str[test_num].res_buf,
- "(test %d): RtlAppendUnicodeToString(dest, src) dest has Buffer %p expected %p",
+ "(test %d): RtlAppendUnicodeToString(dest, src) dest has Buffer %p expected %p\n",
test_num, dest_str.Buffer, app_uni2str[test_num].res_buf);
} /* if */
} /* for */
@@ -1077,21 +1077,21 @@
} /* if */
result = pRtlAppendUnicodeStringToString(&dest_str, &src_str);
ok(result == app_ustr2str[test_num].result,
- "(test %d): RtlAppendStringToString(dest, src) has result %lx, expected %lx",
+ "(test %d): RtlAppendStringToString(dest, src) has result %lx, expected %lx\n",
test_num, result, app_ustr2str[test_num].result);
ok(dest_str.Length == app_ustr2str[test_num].res_Length,
- "(test %d): RtlAppendStringToString(dest, src) dest has Length %d, expected %d",
+ "(test %d): RtlAppendStringToString(dest, src) dest has Length %d, expected %d\n",
test_num, dest_str.Length, app_ustr2str[test_num].res_Length);
ok(dest_str.MaximumLength == app_ustr2str[test_num].res_MaximumLength,
- "(test %d): RtlAppendStringToString(dest, src) dest has MaximumLength %d, expected %d",
+ "(test %d): RtlAppendStringToString(dest, src) dest has MaximumLength %d, expected %d\n",
test_num, dest_str.MaximumLength, app_ustr2str[test_num].res_MaximumLength);
if (dest_str.Buffer == dest_buf) {
ok(memcmp(dest_buf, app_ustr2str[test_num].res_buf, app_ustr2str[test_num].res_buf_size) == 0,
- "(test %d): RtlAppendStringToString(dest, src) has dest \"%s\" expected \"%s\"",
+ "(test %d): RtlAppendStringToString(dest, src) has dest \"%s\" expected \"%s\"\n",
test_num, (char *) dest_buf, app_ustr2str[test_num].res_buf);
} else {
ok(dest_str.Buffer == (WCHAR *) app_ustr2str[test_num].res_buf,
- "(test %d): RtlAppendStringToString(dest, src) dest has Buffer %p expected %p",
+ "(test %d): RtlAppendStringToString(dest, src) dest has Buffer %p expected %p\n",
test_num, dest_str.Buffer, app_ustr2str[test_num].res_buf);
} /* if */
} /* for */
@@ -1196,12 +1196,12 @@
pos = 12345;
result = pRtlFindCharInUnicodeString(find_ch_in_ustr[test_num].flags, &main_str, &search_chars, &pos);
ok(result == find_ch_in_ustr[test_num].result,
- "(test %d): RtlFindCharInUnicodeString(%d, %s, %s, [out]) has result %lx, expected %lx",
+ "(test %d): RtlFindCharInUnicodeString(%d, %s, %s, [out]) has result %lx, expected %lx\n",
test_num, find_ch_in_ustr[test_num].flags,
find_ch_in_ustr[test_num].main_str, find_ch_in_ustr[test_num].search_chars,
result, find_ch_in_ustr[test_num].result);
ok(pos == find_ch_in_ustr[test_num].pos,
- "(test %d): RtlFindCharInUnicodeString(%d, %s, %s, [out]) assigns %d to pos, expected %d",
+ "(test %d): RtlFindCharInUnicodeString(%d, %s, %s, [out]) assigns %d to pos, expected %d\n",
test_num, find_ch_in_ustr[test_num].flags,
find_ch_in_ustr[test_num].main_str, find_ch_in_ustr[test_num].search_chars,
pos, find_ch_in_ustr[test_num].pos);
@@ -1347,10 +1347,10 @@
pRtlInitUnicodeString(&uni, wstr);
result = pRtlUnicodeStringToInteger(&uni, str2int[test_num].base, &value);
ok(result == str2int[test_num].result,
- "(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) has result %lx, expected: %lx",
+ "(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) has result %lx, expected: %lx\n",
test_num, str2int[test_num].str, str2int[test_num].base, result, str2int[test_num].result);
ok(value == str2int[test_num].value,
- "(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d",
+ "(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d\n",
test_num, str2int[test_num].str, str2int[test_num].base, value, str2int[test_num].value);
free(wstr);
} /* for */
@@ -1359,38 +1359,38 @@
pRtlInitUnicodeString(&uni, wstr);
result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, NULL);
ok(result == STATUS_ACCESS_VIOLATION,
- "call failed: RtlUnicodeStringToInteger(\"%s\", %d, NULL) has result %lx",
+ "call failed: RtlUnicodeStringToInteger(\"%s\", %d, NULL) has result %lx\n",
str2int[1].str, str2int[1].base, result);
result = pRtlUnicodeStringToInteger(&uni, 20, NULL);
ok(result == STATUS_INVALID_PARAMETER,
- "call failed: RtlUnicodeStringToInteger(\"%s\", 20, NULL) has result %lx",
+ "call failed: RtlUnicodeStringToInteger(\"%s\", 20, NULL) has result %lx\n",
str2int[1].str, result);
uni.Length = 10; /* Make Length shorter (5 WCHARS instead of 7) */
result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value);
ok(result == STATUS_SUCCESS,
- "call failed: RtlUnicodeStringToInteger(\"12345\", %d, [out]) has result %lx",
+ "call failed: RtlUnicodeStringToInteger(\"12345\", %d, [out]) has result %lx\n",
str2int[1].base, result);
ok(value == 12345,
- "didn't return expected value (test a): expected: %d, got: %d",
+ "didn't return expected value (test a): expected: %d, got: %d\n",
12345, value);
uni.Length = 5; /* Use odd Length (2.5 WCHARS) */
result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value);
ok(result == STATUS_SUCCESS,
- "call failed: RtlUnicodeStringToInteger(\"12\", %d, [out]) has result %lx",
+ "call failed: RtlUnicodeStringToInteger(\"12\", %d, [out]) has result %lx\n",
str2int[1].base, result);
ok(value == 12,
- "didn't return expected value (test b): expected: %d, got: %d",
+ "didn't return expected value (test b): expected: %d, got: %d\n",
12, value);
uni.Length = 2;
result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value);
ok(result == STATUS_SUCCESS,
- "call failed: RtlUnicodeStringToInteger(\"1\", %d, [out]) has result %lx",
+ "call failed: RtlUnicodeStringToInteger(\"1\", %d, [out]) has result %lx\n",
str2int[1].base, result);
ok(value == 1,
- "didn't return expected value (test c): expected: %d, got: %d",
+ "didn't return expected value (test c): expected: %d, got: %d\n",
1, value);
/* w2k: uni.Length = 0 returns value 11234567 instead of 0 */
free(wstr);
@@ -1409,22 +1409,22 @@
value = 0xdeadbeef;
result = pRtlCharToInteger(str2int[test_num].str, str2int[test_num].base, &value);
ok(result == str2int[test_num].result,
- "(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) has result %lx, expected: %lx",
+ "(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) has result %lx, expected: %lx\n",
test_num, str2int[test_num].str, str2int[test_num].base, result, str2int[test_num].result);
ok(value == str2int[test_num].value,
- "(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d",
+ "(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d\n",
test_num, str2int[test_num].str, str2int[test_num].base, value, str2int[test_num].value);
} /* if */
} /* for */
result = pRtlCharToInteger(str2int[1].str, str2int[1].base, NULL);
ok(result == STATUS_ACCESS_VIOLATION,
- "call failed: RtlCharToInteger(\"%s\", %d, NULL) has result %lx",
+ "call failed: RtlCharToInteger(\"%s\", %d, NULL) has result %lx\n",
str2int[1].str, str2int[1].base, result);
result = pRtlCharToInteger(str2int[1].str, 20, NULL);
ok(result == STATUS_INVALID_PARAMETER,
- "call failed: RtlCharToInteger(\"%s\", 20, NULL) has result %lx",
+ "call failed: RtlCharToInteger(\"%s\", 20, NULL) has result %lx\n",
str2int[1].str, result);
}
@@ -1592,22 +1592,22 @@
} /* if */
} else {
ok(result == int2str->result,
- "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) has result %lx, expected: %lx",
+ "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) has result %lx, expected: %lx\n",
test_num, int2str->value, int2str->base, result, int2str->result);
if (result == STATUS_SUCCESS) {
ok(unicode_string.Buffer[unicode_string.Length/sizeof(WCHAR)] == '\0',
- "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) string \"%s\" is not NULL terminated",
+ "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) string \"%s\" is not NULL terminated\n",
test_num, int2str->value, int2str->base, ansi_str.Buffer);
} /* if */
} /* if */
ok(memcmp(unicode_string.Buffer, expected_unicode_string.Buffer, STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
- "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) assigns string \"%s\", expected: \"%s\"\n",
test_num, int2str->value, int2str->base, ansi_str.Buffer, expected_ansi_str.Buffer);
ok(unicode_string.Length == expected_unicode_string.Length,
- "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) string has Length %d, expected: %d",
+ "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) string has Length %d, expected: %d\n",
test_num, int2str->value, int2str->base, unicode_string.Length, expected_unicode_string.Length);
ok(unicode_string.MaximumLength == expected_unicode_string.MaximumLength,
- "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) string has MaximumLength %d, expected: %d",
+ "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) string has MaximumLength %d, expected: %d\n",
test_num, int2str->value, int2str->base, unicode_string.MaximumLength, expected_unicode_string.MaximumLength);
pRtlFreeAnsiString(&expected_ansi_str);
pRtlFreeAnsiString(&ansi_str);
@@ -1632,10 +1632,10 @@
dest_str[STRI_BUFFER_LENGTH] = '\0';
result = pRtlIntegerToChar(int2str->value, int2str->base, int2str->MaximumLength, dest_str);
ok(result == int2str->result,
- "(test %d): RtlIntegerToChar(%lu, %d, %d, [out]) has result %lx, expected: %lx",
+ "(test %d): RtlIntegerToChar(%lu, %d, %d, [out]) has result %lx, expected: %lx\n",
test_num, int2str->value, int2str->base, int2str->MaximumLength, result, int2str->result);
ok(memcmp(dest_str, int2str->Buffer, STRI_BUFFER_LENGTH) == 0,
- "(test %d): RtlIntegerToChar(%lu, %d, %d, [out]) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): RtlIntegerToChar(%lu, %d, %d, [out]) assigns string \"%s\", expected: \"%s\"\n",
test_num, int2str->value, int2str->base, int2str->MaximumLength, dest_str, int2str->Buffer);
}
@@ -1650,22 +1650,22 @@
result = pRtlIntegerToChar(int2str[0].value, 20, int2str[0].MaximumLength, NULL);
ok(result == STATUS_INVALID_PARAMETER,
- "(test a): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %x",
+ "(test a): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %x\n",
int2str[0].value, 20, int2str[0].MaximumLength, result, STATUS_INVALID_PARAMETER);
result = pRtlIntegerToChar(int2str[0].value, 20, 0, NULL);
ok(result == STATUS_INVALID_PARAMETER,
- "(test b): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %x",
+ "(test b): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %x\n",
int2str[0].value, 20, 0, result, STATUS_INVALID_PARAMETER);
result = pRtlIntegerToChar(int2str[0].value, int2str[0].base, 0, NULL);
ok(result == STATUS_BUFFER_OVERFLOW,
- "(test c): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %x",
+ "(test c): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %x\n",
int2str[0].value, int2str[0].base, 0, result, STATUS_BUFFER_OVERFLOW);
result = pRtlIntegerToChar(int2str[0].value, int2str[0].base, int2str[0].MaximumLength, NULL);
ok(result == STATUS_ACCESS_VIOLATION,
- "(test d): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %x",
+ "(test d): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %x\n",
int2str[0].value, int2str[0].base, int2str[0].MaximumLength, result, STATUS_ACCESS_VIOLATION);
}
Index: dlls/ntdll/tests/string.c
===================================================================
RCS file: /home/cvs/wine/dlls/ntdll/tests/string.c,v
retrieving revision 1.4
diff -u -r1.4 string.c
--- dlls/ntdll/tests/string.c 4 Oct 2003 03:04:46 -0000 1.4
+++ dlls/ntdll/tests/string.c 17 Oct 2003 13:53:19 -0000
@@ -65,7 +65,7 @@
static void InitFunctionPtrs()
{
hntdll = LoadLibraryA("ntdll.dll");
- ok(hntdll != 0, "LoadLibrary failed");
+ ok(hntdll != 0, "LoadLibrary failed\n");
if (hntdll) {
pRtlUnicodeStringToAnsiString = (void *)GetProcAddress(hntdll, "RtlUnicodeStringToAnsiString");
pRtlFreeAnsiString = (void *)GetProcAddress(hntdll, "RtlFreeAnsiString");
@@ -219,10 +219,10 @@
value = ulong2str->value;
result = p_itoa(value, dest_str, ulong2str->base);
ok(result == dest_str,
- "(test %d): _itoa(%d, [out], %d) has result %p, expected: %p",
+ "(test %d): _itoa(%d, [out], %d) has result %p, expected: %p\n",
test_num, value, ulong2str->base, result, dest_str);
ok(memcmp(dest_str, ulong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
- "(test %d): _itoa(%d, [out], %d) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): _itoa(%d, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
test_num, value, ulong2str->base, dest_str, ulong2str->Buffer);
}
@@ -238,10 +238,10 @@
value = ulong2str->value;
result = p_ltoa(ulong2str->value, dest_str, ulong2str->base);
ok(result == dest_str,
- "(test %d): _ltoa(%ld, [out], %d) has result %p, expected: %p",
+ "(test %d): _ltoa(%ld, [out], %d) has result %p, expected: %p\n",
test_num, value, ulong2str->base, result, dest_str);
ok(memcmp(dest_str, ulong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
- "(test %d): _ltoa(%ld, [out], %d) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): _ltoa(%ld, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
test_num, value, ulong2str->base, dest_str, ulong2str->Buffer);
}
@@ -257,10 +257,10 @@
value = ulong2str->value;
result = p_ultoa(ulong2str->value, dest_str, ulong2str->base);
ok(result == dest_str,
- "(test %d): _ultoa(%lu, [out], %d) has result %p, expected: %p",
+ "(test %d): _ultoa(%lu, [out], %d) has result %p, expected: %p\n",
test_num, value, ulong2str->base, result, dest_str);
ok(memcmp(dest_str, ulong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
- "(test %d): _ultoa(%lu, [out], %d) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): _ultoa(%lu, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
test_num, value, ulong2str->base, dest_str, ulong2str->Buffer);
}
@@ -309,10 +309,10 @@
result = p_itow(value, dest_wstr, ulong2str->base);
pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
ok(result == dest_wstr,
- "(test %d): _itow(%d, [out], %d) has result %p, expected: %p",
+ "(test %d): _itow(%d, [out], %d) has result %p, expected: %p\n",
test_num, value, ulong2str->base, result, dest_wstr);
ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
- "(test %d): _itow(%d, [out], %d) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): _itow(%d, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
test_num, value, ulong2str->base, ansi_str.Buffer, ulong2str->Buffer);
pRtlFreeAnsiString(&ansi_str);
}
@@ -345,10 +345,10 @@
result = p_ltow(value, dest_wstr, ulong2str->base);
pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
ok(result == dest_wstr,
- "(test %d): _ltow(%ld, [out], %d) has result %p, expected: %p",
+ "(test %d): _ltow(%ld, [out], %d) has result %p, expected: %p\n",
test_num, value, ulong2str->base, result, dest_wstr);
ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
- "(test %d): _ltow(%ld, [out], %d) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): _ltow(%ld, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
test_num, value, ulong2str->base, ansi_str.Buffer, ulong2str->Buffer);
pRtlFreeAnsiString(&ansi_str);
}
@@ -381,10 +381,10 @@
result = p_ultow(value, dest_wstr, ulong2str->base);
pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
ok(result == dest_wstr,
- "(test %d): _ultow(%lu, [out], %d) has result %p, expected: %p",
+ "(test %d): _ultow(%lu, [out], %d) has result %p, expected: %p\n",
test_num, value, ulong2str->base, result, dest_wstr);
ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
- "(test %d): _ultow(%lu, [out], %d) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): _ultow(%lu, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
test_num, value, ulong2str->base, ansi_str.Buffer, ulong2str->Buffer);
pRtlFreeAnsiString(&ansi_str);
}
@@ -415,7 +415,7 @@
expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
result = p_itow(ulong2str[0].value, NULL, 10);
ok(result == NULL,
- "(test a): _itow(%ld, NULL, 10) has result %p, expected: NULL",
+ "(test a): _itow(%ld, NULL, 10) has result %p, expected: NULL\n",
ulong2str[0].value, result);
for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
@@ -424,7 +424,7 @@
expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
result = p_ltow(ulong2str[0].value, NULL, 10);
ok(result == NULL,
- "(test b): _ltow(%ld, NULL, 10) has result %p, expected: NULL",
+ "(test b): _ltow(%ld, NULL, 10) has result %p, expected: NULL\n",
ulong2str[0].value, result);
for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
@@ -433,7 +433,7 @@
expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
result = p_ultow(ulong2str[0].value, NULL, 10);
ok(result == NULL,
- "(test c): _ultow(%ld, NULL, 10) has result %p, expected: NULL",
+ "(test c): _ultow(%ld, NULL, 10) has result %p, expected: NULL\n",
ulong2str[0].value, result);
}
@@ -598,19 +598,19 @@
dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
result = p_i64toa(ulonglong2str->value, dest_str, ulonglong2str->base);
ok(result == dest_str,
- "(test %d): _i64toa(%Lu, [out], %d) has result %p, expected: %p",
+ "(test %d): _i64toa(%Lu, [out], %d) has result %p, expected: %p\n",
test_num, ulonglong2str->value, ulonglong2str->base, result, dest_str);
if (ulonglong2str->mask & 0x04) {
if (memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) != 0) {
if (memcmp(dest_str, ulonglong2str[1].Buffer, LARGE_STRI_BUFFER_LENGTH) != 0) {
ok(memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
- "(test %d): _i64toa(%Lu, [out], %d) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): _i64toa(%Lu, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
test_num, ulonglong2str->value, ulonglong2str->base, dest_str, ulonglong2str->Buffer);
} /* if */
} /* if */
} else {
ok(memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
- "(test %d): _i64toa(%Lu, [out], %d) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): _i64toa(%Lu, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
test_num, ulonglong2str->value, ulonglong2str->base, dest_str, ulonglong2str->Buffer);
} /* if */
}
@@ -625,10 +625,10 @@
dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
result = p_ui64toa(ulonglong2str->value, dest_str, ulonglong2str->base);
ok(result == dest_str,
- "(test %d): _ui64toa(%Lu, [out], %d) has result %p, expected: %p",
+ "(test %d): _ui64toa(%Lu, [out], %d) has result %p, expected: %p\n",
test_num, ulonglong2str->value, ulonglong2str->base, result, dest_str);
ok(memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
- "(test %d): _ui64toa(%Lu, [out], %d) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): _ui64toa(%Lu, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
test_num, ulonglong2str->value, ulonglong2str->base, dest_str, ulonglong2str->Buffer);
}
@@ -675,7 +675,7 @@
result = p_i64tow(ulonglong2str->value, dest_wstr, ulonglong2str->base);
pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
ok(result == dest_wstr,
- "(test %d): _i64tow(%llu, [out], %d) has result %p, expected: %p",
+ "(test %d): _i64tow(%llu, [out], %d) has result %p, expected: %p\n",
test_num, ulonglong2str->value, ulonglong2str->base, result, dest_wstr);
if (ulonglong2str->mask & 0x04) {
if (memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) != 0) {
@@ -685,13 +685,13 @@
expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
if (memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) != 0) {
ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
- "(test %d): _i64tow(%llu, [out], %d) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): _i64tow(%llu, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
test_num, ulonglong2str->value, ulonglong2str->base, ansi_str.Buffer, ulonglong2str->Buffer);
} /* if */
} /* if */
} else {
ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
- "(test %d): _i64tow(%llu, [out], %d) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): _i64tow(%llu, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
test_num, ulonglong2str->value, ulonglong2str->base, ansi_str.Buffer, ulonglong2str->Buffer);
} /* if */
pRtlFreeAnsiString(&ansi_str);
@@ -723,10 +723,10 @@
result = p_ui64tow(ulonglong2str->value, dest_wstr, ulonglong2str->base);
pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
ok(result == dest_wstr,
- "(test %d): _ui64tow(%llu, [out], %d) has result %p, expected: %p",
+ "(test %d): _ui64tow(%llu, [out], %d) has result %p, expected: %p\n",
test_num, ulonglong2str->value, ulonglong2str->base, result, dest_wstr);
ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
- "(test %d): _ui64tow(%llu, [out], %d) assigns string \"%s\", expected: \"%s\"",
+ "(test %d): _ui64tow(%llu, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
test_num, ulonglong2str->value, ulonglong2str->base, ansi_str.Buffer, ulonglong2str->Buffer);
pRtlFreeAnsiString(&ansi_str);
}
@@ -756,7 +756,7 @@
expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
result = p_i64tow(ulong2str[0].value, NULL, 10);
ok(result == NULL,
- "(test d): _i64tow(%llu, NULL, 10) has result %p, expected: NULL",
+ "(test d): _i64tow(%llu, NULL, 10) has result %p, expected: NULL\n",
ulonglong2str[0].value, result);
if (p_ui64tow) {
@@ -766,7 +766,7 @@
expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
result = p_ui64tow(ulong2str[0].value, NULL, 10);
ok(result == NULL,
- "(test e): _ui64tow(%llu, NULL, 10) has result %p, expected: NULL",
+ "(test e): _ui64tow(%llu, NULL, 10) has result %p, expected: NULL\n",
ulonglong2str[0].value, result);
} /* if */
}
@@ -893,7 +893,7 @@
pRtlCreateUnicodeStringFromAsciiz(&uni, str2long[test_num].str);
result = p_wtoi(uni.Buffer);
ok(result == str2long[test_num].value,
- "(test %d): call failed: _wtoi(\"%s\") has result %d, expected: %ld",
+ "(test %d): call failed: _wtoi(\"%s\") has result %d, expected: %ld\n",
test_num, str2long[test_num].str, result, str2long[test_num].value);
pRtlFreeUnicodeString(&uni);
} /* for */
@@ -910,7 +910,7 @@
pRtlCreateUnicodeStringFromAsciiz(&uni, str2long[test_num].str);
result = p_wtol(uni.Buffer);
ok(result == str2long[test_num].value,
- "(test %d): call failed: _wtol(\"%s\") has result %ld, expected: %ld",
+ "(test %d): call failed: _wtol(\"%s\") has result %ld, expected: %ld\n",
test_num, str2long[test_num].str, result, str2long[test_num].value);
pRtlFreeUnicodeString(&uni);
} /* for */
@@ -1048,7 +1048,7 @@
for (test_num = 0; test_num < NB_STR2LONGLONG; test_num++) {
result = p_atoi64(str2longlong[test_num].str);
ok(result == str2longlong[test_num].value,
- "(test %d): call failed: _atoi64(\"%s\") has result %lld, expected: %lld",
+ "(test %d): call failed: _atoi64(\"%s\") has result %lld, expected: %lld\n",
test_num, str2longlong[test_num].str, result, str2longlong[test_num].value);
} /* for */
}
@@ -1064,7 +1064,7 @@
pRtlCreateUnicodeStringFromAsciiz(&uni, str2longlong[test_num].str);
result = p_wtoi64(uni.Buffer);
ok(result == str2longlong[test_num].value,
- "(test %d): call failed: _wtoi64(\"%s\") has result %lld, expected: %lld",
+ "(test %d): call failed: _wtoi64(\"%s\") has result %lld, expected: %lld\n",
test_num, str2longlong[test_num].str, result, str2longlong[test_num].value);
pRtlFreeUnicodeString(&uni);
} /* for */
--
Francois Gouget fgouget at free.fr http://fgouget.free.fr/
Linux: It is now safe to turn on your computer.
More information about the wine-patches
mailing list