ReactOS  0.4.15-dev-1397-g19779b3
large_int.c
Go to the documentation of this file.
1 /* Unit test suite for Rtl large integer functions
2  *
3  * Copyright 2003 Thomas Mertes
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18  *
19  * NOTES
20  * We use function pointers here as there is no import library for NTDLL on
21  * windows.
22  */
23 
24 #include <stdlib.h>
25 
26 #include "ntdll_test.h"
27 
28 
29 /* Function ptrs for ntdll calls */
30 static HMODULE hntdll = 0;
31 static LONGLONG (WINAPI *pRtlExtendedMagicDivide)(LONGLONG, LONGLONG, INT);
32 static VOID (WINAPI *pRtlFreeAnsiString)(PSTRING);
33 static NTSTATUS (WINAPI *pRtlInt64ToUnicodeString)(ULONGLONG, ULONG, UNICODE_STRING *);
34 static NTSTATUS (WINAPI *pRtlLargeIntegerToChar)(ULONGLONG *, ULONG, ULONG, PCHAR);
35 static NTSTATUS (WINAPI *pRtlUnicodeStringToAnsiString)(STRING *, const UNICODE_STRING *, BOOLEAN);
36 static void (WINAPI *p_alldvrm)(LONGLONG, LONGLONG);
37 static void (WINAPI *p_aulldvrm)(ULONGLONG, ULONGLONG);
38 
39 
40 static void InitFunctionPtrs(void)
41 {
42  hntdll = LoadLibraryA("ntdll.dll");
43  ok(hntdll != 0, "LoadLibrary failed\n");
44  if (hntdll) {
45  pRtlExtendedMagicDivide = (void *)GetProcAddress(hntdll, "RtlExtendedMagicDivide");
46  pRtlFreeAnsiString = (void *)GetProcAddress(hntdll, "RtlFreeAnsiString");
47  pRtlInt64ToUnicodeString = (void *)GetProcAddress(hntdll, "RtlInt64ToUnicodeString");
48  pRtlLargeIntegerToChar = (void *)GetProcAddress(hntdll, "RtlLargeIntegerToChar");
49  pRtlUnicodeStringToAnsiString = (void *)GetProcAddress(hntdll, "RtlUnicodeStringToAnsiString");
50  p_alldvrm = (void *)GetProcAddress(hntdll, "_alldvrm");
51  p_aulldvrm = (void *)GetProcAddress(hntdll, "_aulldvrm");
52  } /* if */
53 }
54 
55 #define ULL(a,b) (((ULONGLONG)(a) << 32) | (b))
56 
57 typedef struct {
63 
64 static const magic_divide_t magic_divide[] = {
65  { 3, ULL(0x55555555,0x55555555), 0, 0}, /* 1 */
66  { 333333333, ULL(0x55555555,0x55555555), 0, 111111110}, /* 111111111 */
67  { ULL(0x7fffffff,0xffffffff), ULL(0x55555555,0x55555555), 0, ULL(0x2aaaaaaa,0xaaaaaaaa)},
68  { 3, ULL(0xaaaaaaaa,0xaaaaaaaa), 1, 0}, /* 1 */
69  { 333333333, ULL(0xaaaaaaaa,0xaaaaaaaa), 1, 111111110}, /* 111111111 */
70  { ULL(0x7fffffff,0xffffffff), ULL(0xaaaaaaaa,0xaaaaaaaa), 1, ULL(0x2aaaaaaa,0xaaaaaaaa)},
71  { -3, ULL(0x55555555,0x55555555), 0, 0}, /* -1 */
72  { -333333333, ULL(0x55555555,0x55555555), 0, -111111110}, /* -111111111 */
73  {-ULL(0x7fffffff,0xffffffff), ULL(0x55555555,0x55555555), 0, -ULL(0x2aaaaaaa,0xaaaaaaaa)},
74  { -3, ULL(0xaaaaaaaa,0xaaaaaaaa), 1, 0}, /* -1 */
75  { -333333333, ULL(0xaaaaaaaa,0xaaaaaaaa), 1, -111111110}, /* -111111111 */
76  {-ULL(0x7fffffff,0xffffffff), ULL(0xaaaaaaaa,0xaaaaaaaa), 1, -ULL(0x2aaaaaaa,0xaaaaaaaa)},
77  { -3, -ULL(0x55555555,0x55555555), 0, -2}, /* -1 */
78  { -333333333, -ULL(0x55555555,0x55555555), 0, -222222222}, /* -111111111 */
79  {-ULL(0x7fffffff,0xffffffff), -ULL(0x55555555,0x55555555), 0, -ULL(0x55555555,0x55555554)},
80  { -3, -ULL(0xaaaaaaaa,0xaaaaaaaa), 1, 0}, /* -1 */
81  { -333333333, -ULL(0xaaaaaaaa,0xaaaaaaaa), 1, -55555555}, /* -111111111 */
82  {-ULL(0x7fffffff,0xffffffff), -ULL(0xaaaaaaaa,0xaaaaaaaa), 1, -ULL(0x15555555,0x55555555)},
83  { 3, -ULL(0x55555555,0x55555555), 0, 2}, /* -1 */
84  { 333333333, -ULL(0x55555555,0x55555555), 0, 222222222}, /* -111111111 */
85  { ULL(0x7fffffff,0xffffffff), -ULL(0x55555555,0x55555555), 0, ULL(0x55555555,0x55555554)},
86  { 3, -ULL(0xaaaaaaaa,0xaaaaaaaa), 1, 0}, /* -1 */
87  { 333333333, -ULL(0xaaaaaaaa,0xaaaaaaaa), 1, 55555555}, /* -111111111 */
88  { ULL(0x7fffffff,0xffffffff), -ULL(0xaaaaaaaa,0xaaaaaaaa), 1, ULL(0x15555555,0x55555555)},
89  { 3, ULL(0xaaaaaaaa,0xaaaaa800), 1, 0}, /* 1 */
90  { 333333333, ULL(0xaaaaaaaa,0xaaaaa800), 1, 111111110}, /* 111111111 */
91  { ULL(0x7fffffff,0xffffffff), ULL(0xaaaaaaaa,0xaaaaa800), 1, ULL(0x2aaaaaaa,0xaaaaa9ff)}, /* 0x2aaaaaaaaaaaaaaa */
92  { 5, ULL(0x33333333,0x333333ff), 0, 1},
93  { 555555555, ULL(0x33333333,0x333333ff), 0, 111111111},
94  { ULL(0x7fffffff,0xffffffff), ULL(0x33333333,0x333333ff), 0, ULL(0x19999999,0x999999ff)}, /* 0x199999999999999a */
95  { 5, ULL(0x66666666,0x666667fe), 1, 1},
96  { 555555555, ULL(0x66666666,0x666667fe), 1, 111111111},
97  { ULL(0x7fffffff,0xffffffff), ULL(0x66666666,0x666667fe), 1, ULL(0x19999999,0x999999ff)}, /* 0x199999999999999a */
98  { 5, ULL(0xcccccccc,0xcccccffd), 2, 1},
99  { 555555555, ULL(0xcccccccc,0xcccccffd), 2, 111111111},
100  { ULL(0x7fffffff,0xffffffff), ULL(0xcccccccc,0xcccccffd), 2, ULL(0x19999999,0x999999ff)}, /* 0x199999999999999a */
101  { ULL(0x00000add,0xcafeface), ULL(0x002f1e28,0xfd1b5cca), 33, 1},
102  { ULL(0x081ac1b9,0xc2310a80), ULL(0x002f1e28,0xfd1b5cca), 33, 0xbeef},
103  { ULL(0x74ae3b5f,0x1558c800), ULL(0x002f1e28,0xfd1b5cca), 33, 0xabcde},
104  { ULL(0x00000add,0xcafeface), ULL(0x2f1e28fd,0x1b5cca00), 41, 1},
105  { ULL(0x081ac1b9,0xc2310a80), ULL(0x2f1e28fd,0x1b5cca00), 41, 0xbeef},
106  { ULL(0x74ae3b5f,0x1558c800), ULL(0x2f1e28fd,0x1b5cca00), 41, 0xabcde},
107 
108 };
109 #define NB_MAGIC_DIVIDE (sizeof(magic_divide)/sizeof(*magic_divide))
110 
111 
113 {
114  int i;
116 
117  for (i = 0; i < NB_MAGIC_DIVIDE; i++) {
118  result = pRtlExtendedMagicDivide(magic_divide[i].a, magic_divide[i].b, magic_divide[i].shift);
120  "call failed: RtlExtendedMagicDivide(0x%s, 0x%s, %d) has result 0x%s, expected 0x%s\n",
123  }
124 }
125 
126 
127 #define LARGE_STRI_BUFFER_LENGTH 67
128 
129 typedef struct {
130  int base;
134  const char *Buffer;
137 
138 /*
139  * The native DLL does produce garbage or STATUS_BUFFER_OVERFLOW for
140  * base 2, 8 and 16 when the value is larger than 0xFFFFFFFF.
141  * Therefore these testcases are commented out.
142  */
143 
144 static const largeint2str_t largeint2str[] = {
145  {10, 123, 3, 11, "123\0---------------------------------------------------------------", STATUS_SUCCESS},
146 
147  { 0, 0x80000000U, 10, 11, "2147483648\0--------------------------------------------------------", STATUS_SUCCESS},
148  { 0, -2147483647, 20, 21, "18446744071562067969\0----------------------------------------------", STATUS_SUCCESS},
149  { 0, -2, 20, 21, "18446744073709551614\0----------------------------------------------", STATUS_SUCCESS},
150  { 0, -1, 20, 21, "18446744073709551615\0----------------------------------------------", STATUS_SUCCESS},
151  { 0, 0, 1, 11, "0\0-----------------------------------------------------------------", STATUS_SUCCESS},
152  { 0, 1, 1, 11, "1\0-----------------------------------------------------------------", STATUS_SUCCESS},
153  { 0, 12, 2, 11, "12\0----------------------------------------------------------------", STATUS_SUCCESS},
154  { 0, 123, 3, 11, "123\0---------------------------------------------------------------", STATUS_SUCCESS},
155  { 0, 1234, 4, 11, "1234\0--------------------------------------------------------------", STATUS_SUCCESS},
156  { 0, 12345, 5, 11, "12345\0-------------------------------------------------------------", STATUS_SUCCESS},
157  { 0, 123456, 6, 11, "123456\0------------------------------------------------------------", STATUS_SUCCESS},
158  { 0, 1234567, 7, 11, "1234567\0-----------------------------------------------------------", STATUS_SUCCESS},
159  { 0, 12345678, 8, 11, "12345678\0----------------------------------------------------------", STATUS_SUCCESS},
160  { 0, 123456789, 9, 11, "123456789\0---------------------------------------------------------", STATUS_SUCCESS},
161  { 0, 2147483646, 10, 11, "2147483646\0--------------------------------------------------------", STATUS_SUCCESS},
162  { 0, 2147483647, 10, 11, "2147483647\0--------------------------------------------------------", STATUS_SUCCESS},
163  { 0, 2147483648U, 10, 11, "2147483648\0--------------------------------------------------------", STATUS_SUCCESS},
164  { 0, 2147483649U, 10, 11, "2147483649\0--------------------------------------------------------", STATUS_SUCCESS},
165  { 0, 4294967294U, 10, 11, "4294967294\0--------------------------------------------------------", STATUS_SUCCESS},
166  { 0, 4294967295U, 10, 11, "4294967295\0--------------------------------------------------------", STATUS_SUCCESS},
167  { 0, ULL(0x2,0xdfdc1c35), 11, 12, "12345678901\0-------------------------------------------------------", STATUS_SUCCESS},
168  { 0, ULL(0xe5,0xf4c8f374), 12, 13, "987654321012\0------------------------------------------------------", STATUS_SUCCESS},
169  { 0, ULL(0x1c0,0xfc161e3e), 13, 14, "1928374656574\0-----------------------------------------------------", STATUS_SUCCESS},
170  { 0, ULL(0xbad,0xcafeface), 14, 15, "12841062955726\0----------------------------------------------------", STATUS_SUCCESS},
171  { 0, ULL(0x5bad,0xcafeface), 15, 16, "100801993177806\0---------------------------------------------------", STATUS_SUCCESS},
172  { 0, ULL(0xaface,0xbeefcafe), 16, 20, "3090515640699646\0--------------------------------------------------", STATUS_SUCCESS},
173  { 0, ULL(0xa5beef,0xabcdcafe), 17, 20, "46653307746110206\0-------------------------------------------------", STATUS_SUCCESS},
174  { 0, ULL(0x1f8cf9b,0xf2df3af1), 18, 20, "142091656963767025\0------------------------------------------------", STATUS_SUCCESS},
175  { 0, ULL(0x0fffffff,0xffffffff), 19, 20, "1152921504606846975\0-----------------------------------------------", STATUS_SUCCESS},
176  { 0, ULL(0xffffffff,0xfffffffe), 20, 21, "18446744073709551614\0----------------------------------------------", STATUS_SUCCESS},
177  { 0, ULL(0xffffffff,0xffffffff), 20, 21, "18446744073709551615\0----------------------------------------------", STATUS_SUCCESS},
178 
179  { 2, 0x80000000U, 32, 33, "10000000000000000000000000000000\0----------------------------------", STATUS_SUCCESS},
180 /*
181  * { 2, -2147483647, 64, 65, "1111111111111111111111111111111110000000000000000000000000000001\0--", STATUS_SUCCESS},
182  * { 2, -2, 64, 65, "1111111111111111111111111111111111111111111111111111111111111110\0--", STATUS_SUCCESS},
183  * { 2, -1, 64, 65, "1111111111111111111111111111111111111111111111111111111111111111\0--", STATUS_SUCCESS},
184  */
185  { 2, 0, 1, 33, "0\0-----------------------------------------------------------------", STATUS_SUCCESS},
186  { 2, 1, 1, 33, "1\0-----------------------------------------------------------------", STATUS_SUCCESS},
187  { 2, 10, 4, 33, "1010\0--------------------------------------------------------------", STATUS_SUCCESS},
188  { 2, 100, 7, 33, "1100100\0-----------------------------------------------------------", STATUS_SUCCESS},
189  { 2, 1000, 10, 33, "1111101000\0--------------------------------------------------------", STATUS_SUCCESS},
190  { 2, 10000, 14, 33, "10011100010000\0----------------------------------------------------", STATUS_SUCCESS},
191  { 2, 32767, 15, 33, "111111111111111\0---------------------------------------------------", STATUS_SUCCESS},
192  { 2, 32768, 16, 33, "1000000000000000\0--------------------------------------------------", STATUS_SUCCESS},
193  { 2, 65535, 16, 33, "1111111111111111\0--------------------------------------------------", STATUS_SUCCESS},
194  { 2, 100000, 17, 33, "11000011010100000\0-------------------------------------------------", STATUS_SUCCESS},
195  { 2, 1000000, 20, 33, "11110100001001000000\0----------------------------------------------", STATUS_SUCCESS},
196  { 2, 10000000, 24, 33, "100110001001011010000000\0------------------------------------------", STATUS_SUCCESS},
197  { 2, 100000000, 27, 33, "101111101011110000100000000\0---------------------------------------", STATUS_SUCCESS},
198  { 2, 1000000000, 30, 33, "111011100110101100101000000000\0------------------------------------", STATUS_SUCCESS},
199  { 2, 1073741823, 30, 33, "111111111111111111111111111111\0------------------------------------", STATUS_SUCCESS},
200  { 2, 2147483646, 31, 33, "1111111111111111111111111111110\0-----------------------------------", STATUS_SUCCESS},
201  { 2, 2147483647, 31, 33, "1111111111111111111111111111111\0-----------------------------------", STATUS_SUCCESS},
202  { 2, 2147483648U, 32, 33, "10000000000000000000000000000000\0----------------------------------", STATUS_SUCCESS},
203  { 2, 2147483649U, 32, 33, "10000000000000000000000000000001\0----------------------------------", STATUS_SUCCESS},
204  { 2, 4294967294U, 32, 33, "11111111111111111111111111111110\0----------------------------------", STATUS_SUCCESS},
205  { 2, 0xFFFFFFFF, 32, 33, "11111111111111111111111111111111\0----------------------------------", STATUS_SUCCESS},
206 /*
207  * { 2, 0x1FFFFFFFF, 33, 34, "111111111111111111111111111111111\0---------------------------------", STATUS_SUCCESS},
208  * { 2, 0x3FFFFFFFF, 34, 35, "1111111111111111111111111111111111\0--------------------------------", STATUS_SUCCESS},
209  * { 2, 0x7FFFFFFFF, 35, 36, "11111111111111111111111111111111111\0-------------------------------", STATUS_SUCCESS},
210  * { 2, 0xFFFFFFFFF, 36, 37, "111111111111111111111111111111111111\0------------------------------", STATUS_SUCCESS},
211  * { 2, 0x1FFFFFFFFF, 37, 38, "1111111111111111111111111111111111111\0-----------------------------", STATUS_SUCCESS},
212  * { 2, 0x3FFFFFFFFF, 38, 39, "11111111111111111111111111111111111111\0----------------------------", STATUS_SUCCESS},
213  * { 2, 0x7FFFFFFFFF, 39, 40, "111111111111111111111111111111111111111\0---------------------------", STATUS_SUCCESS},
214  * { 2, 0xFFFFFFFFFF, 40, 41, "1111111111111111111111111111111111111111\0--------------------------", STATUS_SUCCESS},
215  */
216 
217  { 8, 0x80000000U, 11, 12, "20000000000\0-------------------------------------------------------", STATUS_SUCCESS},
218 /*
219  * { 8, -2147483647, 22, 23, "1777777777760000000001\0--------------------------------------------", STATUS_SUCCESS},
220  * { 8, -2, 22, 23, "1777777777777777777776\0--------------------------------------------", STATUS_SUCCESS},
221  * { 8, -1, 22, 23, "1777777777777777777777\0--------------------------------------------", STATUS_SUCCESS},
222  */
223  { 8, 0, 1, 12, "0\0-----------------------------------------------------------------", STATUS_SUCCESS},
224  { 8, 1, 1, 12, "1\0-----------------------------------------------------------------", STATUS_SUCCESS},
225  { 8, 2147483646, 11, 12, "17777777776\0-------------------------------------------------------", STATUS_SUCCESS},
226  { 8, 2147483647, 11, 12, "17777777777\0-------------------------------------------------------", STATUS_SUCCESS},
227  { 8, 2147483648U, 11, 12, "20000000000\0-------------------------------------------------------", STATUS_SUCCESS},
228  { 8, 2147483649U, 11, 12, "20000000001\0-------------------------------------------------------", STATUS_SUCCESS},
229  { 8, 4294967294U, 11, 12, "37777777776\0-------------------------------------------------------", STATUS_SUCCESS},
230  { 8, 4294967295U, 11, 12, "37777777777\0-------------------------------------------------------", STATUS_SUCCESS},
231 
232  {10, 0x80000000U, 10, 11, "2147483648\0--------------------------------------------------------", STATUS_SUCCESS},
233  {10, -2147483647, 20, 21, "18446744071562067969\0----------------------------------------------", STATUS_SUCCESS},
234  {10, -2, 20, 21, "18446744073709551614\0----------------------------------------------", STATUS_SUCCESS},
235  {10, -1, 20, 21, "18446744073709551615\0----------------------------------------------", STATUS_SUCCESS},
236  {10, 0, 1, 11, "0\0-----------------------------------------------------------------", STATUS_SUCCESS},
237  {10, 1, 1, 11, "1\0-----------------------------------------------------------------", STATUS_SUCCESS},
238  {10, 2147483646, 10, 11, "2147483646\0--------------------------------------------------------", STATUS_SUCCESS},
239  {10, 2147483647, 10, 11, "2147483647\0--------------------------------------------------------", STATUS_SUCCESS},
240  {10, 2147483648U, 10, 11, "2147483648\0--------------------------------------------------------", STATUS_SUCCESS},
241  {10, 2147483649U, 10, 11, "2147483649\0--------------------------------------------------------", STATUS_SUCCESS},
242  {10, 4294967294U, 10, 11, "4294967294\0--------------------------------------------------------", STATUS_SUCCESS},
243  {10, 4294967295U, 10, 11, "4294967295\0--------------------------------------------------------", STATUS_SUCCESS},
244 
245  {16, 0, 1, 9, "0\0-----------------------------------------------------------------", STATUS_SUCCESS},
246  {16, 1, 1, 9, "1\0-----------------------------------------------------------------", STATUS_SUCCESS},
247  {16, 2147483646, 8, 9, "7FFFFFFE\0----------------------------------------------------------", STATUS_SUCCESS},
248  {16, 2147483647, 8, 9, "7FFFFFFF\0----------------------------------------------------------", STATUS_SUCCESS},
249  {16, 0x80000000, 8, 9, "80000000\0----------------------------------------------------------", STATUS_SUCCESS},
250  {16, 0x80000001, 8, 9, "80000001\0----------------------------------------------------------", STATUS_SUCCESS},
251  {16, 0xFFFFFFFE, 8, 9, "FFFFFFFE\0----------------------------------------------------------", STATUS_SUCCESS},
252  {16, 0xFFFFFFFF, 8, 9, "FFFFFFFF\0----------------------------------------------------------", STATUS_SUCCESS},
253 /*
254  * {16, 0x100000000, 9, 10, "100000000\0---------------------------------------------------------", STATUS_SUCCESS},
255  * {16, 0xBADDEADBEEF, 11, 12, "BADDEADBEEF\0-------------------------------------------------------", STATUS_SUCCESS},
256  * {16, 0x8000000000000000, 16, 17, "8000000000000000\0--------------------------------------------------", STATUS_SUCCESS},
257  * {16, 0xFEDCBA9876543210, 16, 17, "FEDCBA9876543210\0--------------------------------------------------", STATUS_SUCCESS},
258  * {16, 0xFFFFFFFF80000001, 16, 17, "FFFFFFFF80000001\0--------------------------------------------------", STATUS_SUCCESS},
259  * {16, 0xFFFFFFFFFFFFFFFE, 16, 17, "FFFFFFFFFFFFFFFE\0--------------------------------------------------", STATUS_SUCCESS},
260  * {16, 0xFFFFFFFFFFFFFFFF, 16, 17, "FFFFFFFFFFFFFFFF\0--------------------------------------------------", STATUS_SUCCESS},
261  */
262 
263  { 2, 32768, 16, 17, "1000000000000000\0--------------------------------------------------", STATUS_SUCCESS},
264  { 2, 32768, 16, 16, "1000000000000000---------------------------------------------------", STATUS_SUCCESS},
265  { 2, 65536, 17, 18, "10000000000000000\0-------------------------------------------------", STATUS_SUCCESS},
266  { 2, 65536, 17, 17, "10000000000000000--------------------------------------------------", STATUS_SUCCESS},
267  { 2, 131072, 18, 19, "100000000000000000\0------------------------------------------------", STATUS_SUCCESS},
268  { 2, 131072, 18, 18, "100000000000000000-------------------------------------------------", STATUS_SUCCESS},
269  {16, 0xffffffff, 8, 9, "FFFFFFFF\0----------------------------------------------------------", STATUS_SUCCESS},
270  {16, 0xffffffff, 8, 8, "FFFFFFFF-----------------------------------------------------------", STATUS_SUCCESS},
271  {16, 0xffffffff, 8, 7, "-------------------------------------------------------------------", STATUS_BUFFER_OVERFLOW},
272  {16, 0xa, 1, 2, "A\0-----------------------------------------------------------------", STATUS_SUCCESS},
273  {16, 0xa, 1, 1, "A------------------------------------------------------------------", STATUS_SUCCESS},
274  {16, 0, 1, 0, "-------------------------------------------------------------------", STATUS_BUFFER_OVERFLOW},
275  {20, 0xdeadbeef, 0, 9, "-------------------------------------------------------------------", STATUS_INVALID_PARAMETER},
276  {-8, 07654321, 0, 12, "-------------------------------------------------------------------", STATUS_INVALID_PARAMETER},
277 };
278 #define NB_LARGEINT2STR (sizeof(largeint2str)/sizeof(*largeint2str))
279 
280 
282 {
283  int pos;
284  WCHAR expected_str_Buffer[LARGE_STRI_BUFFER_LENGTH + 1];
285  UNICODE_STRING expected_unicode_string;
286  STRING expected_ansi_str;
287  WCHAR str_Buffer[LARGE_STRI_BUFFER_LENGTH + 1];
288  UNICODE_STRING unicode_string;
289  STRING ansi_str;
291 
292 #ifdef _WIN64
293  if (largeint2str->value >> 32 == 0xffffffff) /* this crashes on 64-bit Vista */
294  {
295  skip( "Value ffffffff%08x broken on 64-bit windows\n", (DWORD)largeint2str->value );
296  return;
297  }
298 #endif
299 
300  for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
301  expected_str_Buffer[pos] = largeint2str->Buffer[pos];
302  } /* for */
303  expected_unicode_string.Length = largeint2str->Length * sizeof(WCHAR);
304  expected_unicode_string.MaximumLength = largeint2str->MaximumLength * sizeof(WCHAR);
305  expected_unicode_string.Buffer = expected_str_Buffer;
306  pRtlUnicodeStringToAnsiString(&expected_ansi_str, &expected_unicode_string, 1);
307 
308  for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
309  str_Buffer[pos] = '-';
310  } /* for */
311  unicode_string.Length = 0;
312  unicode_string.MaximumLength = largeint2str->MaximumLength * sizeof(WCHAR);
313  unicode_string.Buffer = str_Buffer;
314 
315  if (largeint2str->base == 0) {
316  result = pRtlInt64ToUnicodeString(largeint2str->value, 10, &unicode_string);
317  } else {
318  result = pRtlInt64ToUnicodeString(largeint2str->value, largeint2str->base, &unicode_string);
319  } /* if */
320  pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
322  /* On BUFFER_OVERFLOW the string Buffer should be unchanged */
323  for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
324  expected_str_Buffer[pos] = '-';
325  } /* for */
326  /* w2k: The native function has two reasons for BUFFER_OVERFLOW: */
327  /* If the value is too large to convert: The Length is unchanged */
328  /* If str is too small to hold the string: Set str->Length to the length */
329  /* the string would have (which can be larger than the MaximumLength). */
330  /* To allow all this in the tests we do the following: */
331  if (expected_unicode_string.Length >= 64) {
332  /* The value is too large to convert only triggered when testing native */
333  /* Length is not filled with the expected string length (garbage?) */
334  expected_unicode_string.Length = unicode_string.Length;
335  } /* if */
336  } else {
338  "(test %d): RtlInt64ToUnicodeString(0x%s, %d, [out]) has result %x, expected: %x\n",
340  if (result == STATUS_SUCCESS) {
341  ok(unicode_string.Buffer[unicode_string.Length/sizeof(WCHAR)] == '\0',
342  "(test %d): RtlInt64ToUnicodeString(0x%s, %d, [out]) string \"%s\" is not NULL terminated\n",
343  test_num, wine_dbgstr_longlong(largeint2str->value), largeint2str->base, ansi_str.Buffer);
344  } /* if */
345  } /* if */
346  ok(memcmp(unicode_string.Buffer, expected_unicode_string.Buffer, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
347  "(test %d): RtlInt64ToUnicodeString(0x%x%08x, %d, [out]) assigns string \"%s\", expected: \"%s\"\n",
348  test_num, (DWORD)(largeint2str->value >>32), (DWORD)largeint2str->value, largeint2str->base,
349  ansi_str.Buffer, expected_ansi_str.Buffer);
350  ok(unicode_string.Length == expected_unicode_string.Length,
351  "(test %d): RtlInt64ToUnicodeString(0x%s, %d, [out]) string has Length %d, expected: %d\n",
353  unicode_string.Length, expected_unicode_string.Length);
354  ok(unicode_string.MaximumLength == expected_unicode_string.MaximumLength,
355  "(test %d): RtlInt64ToUnicodeString(0x%s, %d, [out]) string has MaximumLength %d, expected: %d\n",
357  unicode_string.MaximumLength, expected_unicode_string.MaximumLength);
358  pRtlFreeAnsiString(&expected_ansi_str);
359  pRtlFreeAnsiString(&ansi_str);
360 }
361 
362 
364 {
365  int test_num;
366 
367  for (test_num = 0; test_num < NB_LARGEINT2STR; test_num++) {
368  one_RtlInt64ToUnicodeString_test(test_num, &largeint2str[test_num]);
369  } /* for */
370 }
371 
372 
374 {
376  char dest_str[LARGE_STRI_BUFFER_LENGTH + 1];
378 
379 #ifdef _WIN64
380  if (largeint2str->value >> 32 == 0xffffffff) /* this crashes on 64-bit Vista */
381  {
382  skip( "Value ffffffff%08x broken on 64-bit windows\n", (DWORD)largeint2str->value );
383  return;
384  }
385 #endif
386 
387  memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
388  dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
390  if (largeint2str->base == 0) {
391  result = pRtlLargeIntegerToChar(&value, 10, largeint2str->MaximumLength, dest_str);
392  } else {
393  result = pRtlLargeIntegerToChar(&value, largeint2str->base, largeint2str->MaximumLength, dest_str);
394  } /* if */
396  "(test %d): RtlLargeIntegerToChar(0x%s, %d, %d, [out]) has result %x, expected: %x\n",
400  "(test %d): RtlLargeIntegerToChar(0x%s, %d, %d, [out]) assigns string \"%s\", expected: \"%s\"\n",
403 }
404 
405 
406 static void test_RtlLargeIntegerToChar(void)
407 {
409  int test_num;
411 
412  for (test_num = 0; test_num < NB_LARGEINT2STR; test_num++) {
413  one_RtlLargeIntegerToChar_test(test_num, &largeint2str[test_num]);
414  } /* for */
415 
416  value = largeint2str[0].value;
417  result = pRtlLargeIntegerToChar(&value, 20, largeint2str[0].MaximumLength, NULL);
419  "(test a): RtlLargeIntegerToChar(0x%s, %d, %d, NULL) has result %x, expected: %x\n",
422 
423  result = pRtlLargeIntegerToChar(&value, 20, 0, NULL);
425  "(test b): RtlLargeIntegerToChar(0x%s, %d, %d, NULL) has result %x, expected: %x\n",
428 
429  result = pRtlLargeIntegerToChar(&value, largeint2str[0].base, 0, NULL);
431  "(test c): RtlLargeIntegerToChar(0x%s, %d, %d, NULL) has result %x, expected: %x\n",
433 
434  result = pRtlLargeIntegerToChar(&value, largeint2str[0].base, largeint2str[0].MaximumLength, NULL);
436  "(test d): RtlLargeIntegerToChar(0x%s, %d, %d, NULL) has result %x, expected: %x\n",
439 }
440 
441 
442 #ifdef __i386__
443 
444 #include "pshpack1.h"
445 struct lldvrm_thunk
446 {
447  BYTE push_ebx; /* pushl %ebx */
448  DWORD push_esp1; /* pushl 24(%esp) */
449  DWORD push_esp2; /* pushl 24(%esp) */
450  DWORD push_esp3; /* pushl 24(%esp) */
451  DWORD push_esp4; /* pushl 24(%esp) */
452  DWORD call; /* call 24(%esp) */
453  WORD mov_ecx_eax; /* movl %ecx,%eax */
454  WORD mov_ebx_edx; /* movl %ebx,%edx */
455  BYTE pop_ebx; /* popl %ebx */
456  BYTE ret; /* ret */
457 };
458 #include "poppack.h"
459 
460 static void test__alldvrm(void)
461 {
462  struct lldvrm_thunk *thunk = VirtualAlloc(NULL, sizeof(*thunk), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
463  ULONGLONG (CDECL *call_lldvrm_func)(void *func, ULONGLONG, ULONGLONG) = (void *)thunk;
464  ULONGLONG ret;
465 
466  memset(thunk, 0x90, sizeof(*thunk));
467  thunk->push_ebx = 0x53; /* pushl %ebx */
468  thunk->push_esp1 = 0x182474ff; /* pushl 24(%esp) */
469  thunk->push_esp2 = 0x182474ff; /* pushl 24(%esp) */
470  thunk->push_esp3 = 0x182474ff; /* pushl 24(%esp) */
471  thunk->push_esp4 = 0x182474ff; /* pushl 24(%esp) */
472  thunk->call = 0x182454ff; /* call 24(%esp) */
473  thunk->pop_ebx = 0x5b; /* popl %ebx */
474  thunk->ret = 0xc3; /* ret */
475 
476  ret = call_lldvrm_func(p_alldvrm, 0x0123456701234567ULL, 3);
477  ok(ret == 0x61172255b66c77ULL, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret);
478  ret = call_lldvrm_func(p_alldvrm, 0x0123456701234567ULL, -3);
479  ok(ret == 0xff9ee8ddaa499389ULL, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret);
480 
481  ret = call_lldvrm_func(p_aulldvrm, 0x0123456701234567ULL, 3);
482  ok(ret == 0x61172255b66c77ULL, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret);
483  ret = call_lldvrm_func(p_aulldvrm, 0x0123456701234567ULL, -3);
484  ok(ret == 0, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret);
485 
486  thunk->mov_ecx_eax = 0xc889;
487  thunk->mov_ebx_edx = 0xda89;
488 
489  ret = call_lldvrm_func(p_alldvrm, 0x0123456701234567ULL, 3);
490  ok(ret == 2, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret);
491  ret = call_lldvrm_func(p_alldvrm, 0x0123456701234567ULL, -3);
492  ok(ret == 2, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret);
493 
494  ret = call_lldvrm_func(p_aulldvrm, 0x0123456701234567ULL, 3);
495  ok(ret == 2, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret);
496  ret = call_lldvrm_func(p_aulldvrm, 0x0123456701234567ULL, -3);
497  ok(ret == 0x123456701234567ULL, "got %x%08x\n", (DWORD)(ret >> 32), (DWORD)ret);
498 }
499 #endif /* __i386__ */
500 
501 
502 START_TEST(large_int)
503 {
505 
506  if (pRtlExtendedMagicDivide)
508  if (pRtlInt64ToUnicodeString)
510  if (pRtlLargeIntegerToChar)
512 
513 #ifdef __i386__
514  test__alldvrm();
515 #endif /* __i386__ */
516 }
GLenum func
Definition: glext.h:6028
static void one_RtlLargeIntegerToChar_test(int test_num, const largeint2str_t *largeint2str)
Definition: large_int.c:373
static ULONG
Definition: large_int.c:33
#define shift
Definition: input.c:1756
const char * Buffer
Definition: large_int.c:134
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
GLuint64EXT * result
Definition: glext.h:11304
USHORT MaximumLength
Definition: env_spec_w32.h:370
Definition: cproxy.c:247
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define NB_LARGEINT2STR
Definition: large_int.c:278
#define U(x)
Definition: wordpad.c:45
LONG NTSTATUS
Definition: precomp.h:26
ULONGLONG value
Definition: large_int.c:131
static void InitFunctionPtrs(void)
Definition: large_int.c:40
#define ULL(a, b)
Definition: large_int.c:55
USHORT MaximumLength
Definition: large_int.c:133
static HMODULE hntdll
Definition: large_int.c:30
static UNICODE_STRING *static PCHAR
Definition: large_int.c:34
#define MEM_COMMIT
Definition: nt_native.h:1313
int32_t INT
Definition: typedefs.h:58
static void test_RtlInt64ToUnicodeString(void)
Definition: large_int.c:363
static void(WINAPI *p_alldvrm)(LONGLONG
LONGLONG a
Definition: large_int.c:58
static void one_RtlInt64ToUnicodeString_test(int test_num, const largeint2str_t *largeint2str)
Definition: large_int.c:281
LPVOID NTAPI VirtualAlloc(IN LPVOID lpAddress, IN SIZE_T dwSize, IN DWORD flAllocationType, IN DWORD flProtect)
Definition: virtmem.c:74
struct _STRING * PSTRING
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
static LONGLONG
Definition: large_int.c:31
NTSTATUS result
Definition: large_int.c:135
int64_t LONGLONG
Definition: typedefs.h:68
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
_In_ WDFDMATRANSACTION _In_ size_t MaximumLength
__wchar_t WCHAR
Definition: xmlstorage.h:180
uint64_t ULONGLONG
Definition: typedefs.h:67
static void test_RtlExtendedMagicDivide(void)
Definition: large_int.c:112
#define WINAPI
Definition: msvc.h:6
unsigned short WORD
Definition: ntddk_ex.h:93
unsigned long DWORD
Definition: ntddk_ex.h:95
static ULONGLONG
Definition: large_int.c:37
std::wstring STRING
Definition: fontsub.cpp:33
int ret
static INT
Definition: large_int.c:31
START_TEST(large_int)
Definition: large_int.c:502
USHORT Length
Definition: large_int.c:132
#define NB_MAGIC_DIVIDE
Definition: large_int.c:109
GLsizei const GLfloat * value
Definition: glext.h:6069
static NTSTATUS(WINAPI *pRtlInt64ToUnicodeString)(ULONGLONG
unsigned char BYTE
Definition: xxhash.c:193
static const magic_divide_t magic_divide[]
Definition: large_int.c:64
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define CDECL
Definition: compat.h:29
#define LARGE_STRI_BUFFER_LENGTH
Definition: large_int.c:127
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
unsigned short USHORT
Definition: pedump.c:61
static void test_RtlLargeIntegerToChar(void)
Definition: large_int.c:406
#define ok(value,...)
Definition: atltest.h:57
static const UNICODE_STRING BOOLEAN
Definition: large_int.c:35
#define NULL
Definition: types.h:112
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG x2
Definition: winddi.h:3706
#define skip(...)
Definition: atltest.h:64
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
#define GetProcAddress(x, y)
Definition: compat.h:612
static const largeint2str_t largeint2str[]
Definition: large_int.c:144
#define PAGE_EXECUTE_READWRITE
Definition: nt_native.h:1308
#define STATUS_SUCCESS
Definition: shellext.h:65
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
LONGLONG b
Definition: large_int.c:59
#define memset(x, y, z)
Definition: compat.h:39
static VOID(WINAPI *pRtlFreeAnsiString)(PSTRING)
LONGLONG result
Definition: large_int.c:61