projects / wine / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Build test programs as .so files. Added missing imports.
[wine] / libtest / vartest.c
1 /*
2  * VARIANT test program
3  *
4  * Copyright 1998 Jean-Claude Cote
5  *
6  * The purpose of this program is validate the implementation
7  * of the APIs related to VARIANTs. The validation is done
8  * by comparing the results given by the Windows implementation
9  * versus the Wine implementation.
10  *
11  * This program tests the creation/coercion/destruction of VARIANTs.
12  *
13  * The program does not currently test any API that takes
14  * arguments of type: IDispatch, IUnknown, DECIMAL, CURRENCY.
15  *
16  * Since the purpose of this program is to compare the results
17  * from Windows and Wine it is written so that with a simple
18  * define it can be compiled either in Windows or Linux.
19  *
20  *
21  * NOTES
22  *       - The Variant structure in Windows has a non-named union. This means
23  *       the member of the union are accessible simply by doing pVariant->pfltVal.
24  *       With gcc it is not possible to have non-named union so it has been named
25  *       'u'.  So it's members are accessible using this name like so
26  *       pVariant->u.pfltVal.  So if this program is compiled in Windows
27  *       the references to 'u' will need to be take out of this file.
28  *
29  *       - Also the printf is a little different so the format specifiers may
30  *       need to be tweaked if this file is compile in Windows.
31  *       Printf is also different in that it continues printing numbers
32  *       even after there is no more significative digits left to print.  These
33  *       number are garbage and in windows they are set to zero but not
34  *       on Linux.
35  *
36  *       - The VarDateFromStr is not implemented yet.
37  *
38  *       - The date and floating point format may not be the exact same format has the one in
39  *       windows depending on what the Internatinal setting are in windows.
40  *
41  */
42
43
44
45 #include <stdio.h>
46 #include <malloc.h>
47 #include <windows.h>
48 #include <winerror.h>
49 #include <winnt.h>
50
51 #include <oleauto.h>
52
53 #include <math.h>
54 #include <float.h>
55 #include <time.h>
56
57 #include <windef.h>
58
59
60 #define MAX_BUFFER  1024
61
62 char* WtoA( OLECHAR* p )
63 {
64     static char buffer[MAX_BUFFER];
65     DWORD len = WideCharToMultiByte( CP_ACP, 0, p, -1, buffer+1, sizeof(buffer)-3, NULL, NULL );
66     buffer[0] = '\"';
67     buffer[len] = '\"';
68     buffer[len+1] = 0;
69     return buffer;
70 }
71
72 OLECHAR* AtoW( char* p )
73 {
74     OLECHAR *buffer;
75     DWORD len = MultiByteToWideChar( CP_ACP, 0, p, -1, NULL, 0 );
76     buffer = malloc( len * sizeof(OLECHAR) );
77     MultiByteToWideChar( CP_ACP, 0, p, -1, buffer, len );
78     return buffer;
79 }
80
81
82 int PASCAL WinMain (HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show)
83 {
84         VARIANTARG va;
85         VARIANTARG vb;
86         VARIANTARG vc;
87         VARIANTARG vd;
88         VARIANTARG ve;
89
90         int theInt = 0;
91         int* pInt = &theInt;
92         VARIANT_BOOL b = 0;
93         VARIANT_BOOL* pBool = &b;
94         unsigned short uShort = 0;
95         unsigned short* pUShort = &uShort;
96         unsigned long uLong = 0;
97         unsigned long* pULong = &uLong;
98         CHAR theChar;
99         CHAR* pChar = &theChar;
100         BYTE byte;
101         BYTE* pByte = &byte;
102         short s = 0;
103         short* pShort = &s;
104         long Long = 0;
105         long* pLong = &Long;
106         float f = 0;
107         float* pFloat = &f;
108         double d = 0;
109         double* pDouble = &d;
110         
111         unsigned short i = 0;
112         HRESULT res = 0;
113         BSTR bstr = NULL;
114         int olePtrIndex = 0;
115         int nOlePtrs = 120;
116         OLECHAR* pOleChar[120];
117
118         pOleChar[0] = AtoW( "-2" );
119         pOleChar[1] = AtoW( "-1" );
120         pOleChar[2] = AtoW( "-0.51" );
121         pOleChar[3] = AtoW( "-0.5" );
122         pOleChar[4] = AtoW( "-0.49" );
123         pOleChar[5] = AtoW( "-0.0" );
124         pOleChar[6] = AtoW( "0.0" );
125         pOleChar[7] = AtoW( "0.49" );
126         pOleChar[8] = AtoW( "0.5" );
127         pOleChar[9] = AtoW( "0.51" );
128         pOleChar[10] = AtoW( "1" );
129         pOleChar[11] = AtoW( "127" );
130         pOleChar[12] = AtoW( "128" );
131         pOleChar[13] = AtoW( "129" );
132         pOleChar[14] = AtoW( "255" );
133         pOleChar[15] = AtoW( "256" );
134         pOleChar[16] = AtoW( "257" );
135         pOleChar[17] = AtoW( "32767" );
136         pOleChar[18] = AtoW( "32768" );
137         pOleChar[19] = AtoW( "-32768" );
138         pOleChar[20] = AtoW( "-32769" );
139         pOleChar[21] = AtoW( "16777216" );
140         pOleChar[22] = AtoW( "16777217" );
141         pOleChar[23] = AtoW( "-16777216" );
142         pOleChar[24] = AtoW( "16777217" );
143         pOleChar[25] = AtoW( "2147483647" );
144         pOleChar[26] = AtoW( "2147483648" );
145         pOleChar[27] = AtoW( "-2147483647" );
146         pOleChar[28] = AtoW( "-2147483648" );
147
148         pOleChar[29] = AtoW( "" );
149         pOleChar[30] = AtoW( " " );
150         pOleChar[31] = AtoW( "1F" );
151         pOleChar[32] = AtoW( "1G" );
152         pOleChar[33] = AtoW( " 1 " );
153         pOleChar[34] = AtoW( " 1 2 " );
154         pOleChar[35] = AtoW( "1,2,3" );
155         pOleChar[36] = AtoW( "1 2 3" );
156         pOleChar[37] = AtoW( "1,2, 3" );
157         pOleChar[38] = AtoW( "1;2;3" );
158         pOleChar[39] = AtoW( "1.2.3" );
159
160         pOleChar[40] = AtoW( "0." );
161         pOleChar[41] = AtoW( ".0" );
162         pOleChar[42] = AtoW( "0.1E12" );
163         pOleChar[43] = AtoW( "2.4,E1" );
164         pOleChar[44] = AtoW( "  +3.2,E1" );
165         pOleChar[45] = AtoW( "4E2.5" );
166         pOleChar[46] = AtoW( "  2E+2" );
167         pOleChar[47] = AtoW( "1 E+2" );
168         pOleChar[48] = AtoW( "." );
169         pOleChar[49] = AtoW( ".E2" );
170         pOleChar[50] = AtoW( "1000000000000000000000000000000000000000000000000000000000000000" );
171         pOleChar[51] = AtoW( "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" );
172         pOleChar[52] = AtoW( "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" );
173         pOleChar[53] = AtoW( "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" );
174         pOleChar[54] = AtoW( "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" );
175         pOleChar[55] = AtoW( "65535" );
176         pOleChar[56] = AtoW( "65535.5" );
177         pOleChar[57] = AtoW( "65536" );
178         pOleChar[58] = AtoW( "4294967295" );
179         pOleChar[59] = AtoW( "4294967296" );
180         
181         pOleChar[60] = AtoW( "1 January 99" );
182         pOleChar[61] = AtoW( "December 31, 2078" );
183         pOleChar[62] = AtoW( "January 1, 1900" );
184         pOleChar[63] = AtoW( "January 2 1900" );
185         pOleChar[64] = AtoW( "11.11.1999" );
186         pOleChar[65] = AtoW( "11/11/1999" );
187         pOleChar[66] = AtoW( " 11 / 11 / 1999" );
188         pOleChar[67] = AtoW( "11/11/1999:11:11:1134" );
189         pOleChar[68] = AtoW( "11/11/1999 11:11:11:1" );
190         pOleChar[69] = AtoW( "\t1999/\t11/21 11 :11:11am" );
191
192         pOleChar[70] = AtoW( "11/11/1999 11:11:11Am" );
193         pOleChar[71] = AtoW( "11/11/1999 11:11:11PM" );
194         pOleChar[72] = AtoW( "11/11/199911:11:11PM" );
195         pOleChar[73] = AtoW( "11/11/1999 0:0:11am" );
196         pOleChar[74] = AtoW( "11/11/1999 11,11:11am" );
197         pOleChar[75] = AtoW( "11/11/1999 11:11:11am" );
198         pOleChar[76] = AtoW( "11/11/1999 11/11:11am" );
199         pOleChar[77] = AtoW( "11/11/1999 11:11AM" );
200         pOleChar[78] = AtoW( "11/11/1999 1AM" );
201         pOleChar[79] = AtoW( "11/11/1999 0AM" );
202
203         pOleChar[80] = AtoW( "11/11/1999 11:11:11" );
204         pOleChar[81] = AtoW( "11/13/1999 0AM" );
205         pOleChar[82] = AtoW( "13/13/1999 0AM" );
206         pOleChar[83] = AtoW( "13/11/1999 0AM" );
207         pOleChar[84] = AtoW( "11/33/1999 0AM" );
208         pOleChar[85] = AtoW( "11/11/1999 AM" );
209         pOleChar[86] = AtoW( "1/1/0 0AM" );
210         pOleChar[87] = AtoW( "1/1/-1 0AM" );
211         pOleChar[88] = AtoW( "1999 January 3 9AM" );
212         pOleChar[89] = AtoW( "1 January 1999 11AM" );
213
214         pOleChar[90] = AtoW( "4AM 11/11/1999" );
215         pOleChar[91] = AtoW( "4:22 11/11/1999 AM" );
216         pOleChar[92] = AtoW( " 1 1 /11/1999" );
217         pOleChar[93] = AtoW( "11-11/1999 11:11:11.12AM" );
218         pOleChar[94] = AtoW( "1999 January 3, 9AM" );
219         pOleChar[95] = AtoW( "December, 31, 2078" );
220         pOleChar[96] = AtoW( "December, 31, 2078," );
221         pOleChar[97] = AtoW( "December, 31 2078" );
222         pOleChar[98] = AtoW( "11/99" );
223         pOleChar[99] = AtoW( "11-1999" );
224
225         pOleChar[100] = AtoW( "true" );
226         pOleChar[101] = AtoW( "True" );
227         pOleChar[102] = AtoW( "TRue" );
228         pOleChar[103] = AtoW( "TRUE" );
229         pOleChar[104] = AtoW( " TRUE" );
230         pOleChar[105] = AtoW( "FALSE " );
231         pOleChar[106] = AtoW( "False" );
232         pOleChar[107] = AtoW( "JustSomeText" );
233         pOleChar[108] = AtoW( "Just Some Text" );
234         pOleChar[109] = AtoW( "" );
235
236         pOleChar[110] = AtoW( "1.5" );
237         pOleChar[111] = AtoW( "2.5" );
238         pOleChar[112] = AtoW( "3.5" );
239         pOleChar[113] = AtoW( "4.5" );
240         pOleChar[114] = AtoW( "" );
241         pOleChar[115] = AtoW( "" );
242         pOleChar[116] = AtoW( "" );
243         pOleChar[117] = AtoW( "" );
244         pOleChar[118] = AtoW( "" );
245         pOleChar[119] = AtoW( "" );
246
247
248         /* Start testing the Low-Level API ( the coercions )
249          */
250
251
252         /* unsigned char from...
253          */
254         printf( "\n\n======== Testing VarUI1FromXXX ========\n");
255         
256         /* res = VarUI1FromI2( 0, NULL );
257          */
258         printf( "VarUI1FromI2: passing in NULL as return val makes it crash, %X\n", (unsigned int) res );
259
260         res = VarUI1FromStr( NULL, 0, 0, pByte );
261         printf( "VarUI1FromStr: passing in NULL as param: %X\n", (unsigned int) res );
262
263         res = VarUI1FromI2( 0, pByte );
264         printf( "VarUI1FromI2: 0, %X, %X\n", *pByte, (unsigned int) res );
265         res = VarUI1FromI2( 69, pByte );
266         printf( "VarUI1FromI2: 69, %X, %X\n", *pByte, (unsigned int) res );
267         res = VarUI1FromI2( 70, pByte );
268         printf( "VarUI1FromI2: 70, %X, %X\n", *pByte, (unsigned int) res );
269         res = VarUI1FromI2( 128, pByte );
270         printf( "VarUI1FromI2: 128, %X, %X\n", *pByte, (unsigned int) res );
271         res = VarUI1FromI2( 255, pByte );
272         printf( "VarUI1FromI2: 255, %X, %X\n", *pByte, (unsigned int) res );
273         res = VarUI1FromI2( 256, pByte );
274         printf( "VarUI1FromI2: 256, %X, %X\n", *pByte, (unsigned int) res );
275         res = VarUI1FromI2( 257, pByte );
276         printf( "VarUI1FromI2: 257, %X, %X\n", *pByte, (unsigned int) res );
277
278         res = VarUI1FromR8( 0.0, pByte );
279         printf( "VarUI1FromR8: 0.0, %X, %X\n", *pByte, (unsigned int) res );
280         res = VarUI1FromR8( 69.33, pByte );
281         printf( "VarUI1FromR8: 69.33, %X, %X\n", *pByte, (unsigned int) res );
282         res = VarUI1FromR8( 69.66, pByte );
283         printf( "VarUI1FromR8: 69.66, %X, %X\n", *pByte, (unsigned int) res );
284         res = VarUI1FromR8( -69.33, pByte );
285         printf( "VarUI1FromR8: -69.33, %X, %X\n", *pByte, (unsigned int) res );
286         res = VarUI1FromR8( -69.66, pByte );
287         printf( "VarUI1FromR8: -69.66, %X, %X\n", *pByte, (unsigned int) res );
288
289         res = VarUI1FromR8( -0.5, pByte );
290         printf( "VarUI1FromR8: -0.5, %X, %X\n", *pByte, (unsigned int) res );
291         res = VarUI1FromR8( -0.51, pByte );
292         printf( "VarUI1FromR8: -0.51, %X, %X\n", *pByte, (unsigned int) res );
293         res = VarUI1FromR8( -0.49, pByte );
294         printf( "VarUI1FromR8: -0.49, %X, %X\n", *pByte, (unsigned int) res );
295
296         res = VarUI1FromR8( 0.5, pByte );
297         printf( "VarUI1FromR8: 0.5, %X, %X\n", *pByte, (unsigned int) res );
298         res = VarUI1FromR8( 0.51, pByte );
299         printf( "VarUI1FromR8: 0.51, %X, %X\n", *pByte, (unsigned int) res );
300         res = VarUI1FromR8( 0.49, pByte );
301         printf( "VarUI1FromR8: 0.49, %X, %X\n", *pByte, (unsigned int) res );
302
303         res = VarUI1FromDate( 0.0, pByte );
304         printf( "VarUI1FromDate: 0.0, %X, %X\n", *pByte, (unsigned int) res );
305         res = VarUI1FromDate( 69.33, pByte );
306         printf( "VarUI1FromDate: 69.33, %X, %X\n", *pByte, (unsigned int) res );
307         res = VarUI1FromDate( 69.66, pByte );
308         printf( "VarUI1FromDate: 69.66, %X, %X\n", *pByte, (unsigned int) res );
309         res = VarUI1FromDate( -69.33, pByte );
310         printf( "VarUI1FromDate: -69.33, %X, %X\n", *pByte, (unsigned int) res );
311         res = VarUI1FromDate( -69.66, pByte );
312         printf( "VarUI1FromDate: -69.66, %X, %X\n", *pByte, (unsigned int) res );
313
314         res = VarUI1FromBool( VARIANT_TRUE, pByte );
315         printf( "VarUI1FromBool: VARIANT_TRUE, %X, %X\n", *pByte, (unsigned int) res );
316         res = VarUI1FromBool( VARIANT_FALSE, pByte );
317         printf( "VarUI1FromBool: VARIANT_FALSE, %X, %X\n", *pByte, (unsigned int) res );
318
319         for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
320         {
321                 res = VarUI1FromStr( pOleChar[olePtrIndex], 0, 0, pByte );
322                 printf( "VarUI1FromStr: %s, %X, %X\n", WtoA(pOleChar[olePtrIndex]), *pByte, (unsigned int) res );
323         }
324
325
326         /* unsigned short from ...
327          */
328         printf( "\n\n======== Testing VarUI2FromXXX ========\n");
329         
330         res = VarUI2FromI2( -1, &i );
331         printf( "VarUI2FromI2: -1, %d, %X\n", i, (unsigned int) res );
332
333         /* res = VarUI2FromI2( 0, NULL );
334          */
335         printf( "VarUI2FromI2: passing in NULL as return val makes it crash, %X\n", (unsigned int) res );
336
337         res = VarUI2FromStr( NULL, 0, 0, pUShort );
338         printf( "VarUI2FromStr: passing in NULL as param: %X\n", (unsigned int) res );
339
340         res = VarUI2FromI2( 0, pUShort );
341         printf( "VarUI2FromI2: 0, %u, %X\n", *pUShort, (unsigned int) res );
342         res = VarUI2FromI2( 69, pUShort );
343         printf( "VarUI2FromI2: 69, %u, %X\n", *pUShort, (unsigned int) res );
344         res = VarUI2FromI2( 70, pUShort );
345         printf( "VarUI2FromI2: 70, %u, %X\n", *pUShort, (unsigned int) res );
346         res = VarUI2FromI2( 128, pUShort );
347         printf( "VarUI2FromI2: 128, %u, %X\n", *pUShort, (unsigned int) res );
348         res = VarUI2FromI4( 65535, pUShort );
349         printf( "VarUI2FromI4: 65535, %u, %X\n", *pUShort, (unsigned int) res );
350         res = VarUI2FromI4( 65536, pUShort );
351         printf( "VarUI2FromI4: 65536, %u, %X\n", *pUShort, (unsigned int) res );
352         res = VarUI2FromI4( 65537, pUShort );
353         printf( "VarUI2FromI4: 65537, %u, %X\n", *pUShort, (unsigned int) res );
354
355         res = VarUI2FromR8( 0.0, pUShort );
356         printf( "VarUI2FromR8: 0.0, %u, %X\n", *pUShort, (unsigned int) res );
357         res = VarUI2FromR8( 69.33, pUShort );
358         printf( "VarUI2FromR8: 69.33, %u, %X\n", *pUShort, (unsigned int) res );
359         res = VarUI2FromR8( 69.66, pUShort );
360         printf( "VarUI2FromR8: 69.66, %u, %X\n", *pUShort, (unsigned int) res );
361         res = VarUI2FromR8( -69.33, pUShort );
362         printf( "VarUI2FromR8: -69.33, %u, %X\n", *pUShort, (unsigned int) res );
363         res = VarUI2FromR8( -69.66, pUShort );
364         printf( "VarUI2FromR8: -69.66, %u, %X\n", *pUShort, (unsigned int) res );
365
366         res = VarUI2FromR8( -0.5, pUShort );
367         printf( "VarUI2FromR8: -0.5, %u, %X\n", *pUShort, (unsigned int) res );
368         res = VarUI2FromR8( -0.51, pUShort );
369         printf( "VarUI2FromR8: -0.51, %u, %X\n", *pUShort, (unsigned int) res );
370         res = VarUI2FromR8( -0.49, pUShort );
371         printf( "VarUI2FromR8: -0.49, %u, %X\n", *pUShort, (unsigned int) res );
372
373         res = VarUI2FromR8( 0.5, pUShort );
374         printf( "VarUI2FromR8: 0.5, %u, %X\n", *pUShort, (unsigned int) res );
375         res = VarUI2FromR8( 0.51, pUShort );
376         printf( "VarUI2FromR8: 0.51, %u, %X\n", *pUShort, (unsigned int) res );
377         res = VarUI2FromR8( 0.49, pUShort );
378         printf( "VarUI2FromR8: 0.49, %u, %X\n", *pUShort, (unsigned int) res );
379
380         res = VarUI2FromDate( 0.0, pUShort );
381         printf( "VarUI2FromDate: 0.0, %u, %X\n", *pUShort, (unsigned int) res );
382         res = VarUI2FromDate( 69.33, pUShort );
383         printf( "VarUI2FromDate: 69.33, %u, %X\n", *pUShort, (unsigned int) res );
384         res = VarUI2FromDate( 69.66, pUShort );
385         printf( "VarUI2FromDate: 69.66, %u, %X\n", *pUShort, (unsigned int) res );
386         res = VarUI2FromDate( -69.33, pUShort );
387         printf( "VarUI2FromDate: -69.33, %u, %X\n", *pUShort, (unsigned int) res );
388         res = VarUI2FromDate( -69.66, pUShort );
389         printf( "VarUI2FromDate: -69.66, %u, %X\n", *pUShort, (unsigned int) res );
390
391         res = VarUI2FromBool( VARIANT_TRUE, pUShort );
392         printf( "VarUI2FromBool: VARIANT_TRUE, %u, %X\n", *pUShort, (unsigned int) res );
393         res = VarUI2FromBool( VARIANT_FALSE, pUShort );
394         printf( "VarUI2FromBool: VARIANT_FALSE, %u, %X\n", *pUShort, (unsigned int) res );
395
396         for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
397         {
398                 res = VarUI2FromStr( pOleChar[olePtrIndex], 0, 0, pUShort );
399                 printf( "VarUI2FromStr: %s, %u, %X\n", WtoA(pOleChar[olePtrIndex]), (int)*pUShort, (unsigned int) res );
400         }
401
402         /* unsigned long from ...
403          */
404         printf( "\n\n======== Testing VarUI4FromXXX ========\n");
405         
406         /*res = VarUI4FromI2( 0, NULL );
407          */
408         printf( "VarUI4FromI2: passing in NULL as return val makes it crash, %X\n", (unsigned int) res );
409
410         res = VarUI4FromStr( NULL, 0, 0, pULong );
411         printf( "VarUI4FromStr: passing in NULL as param: %X\n", (unsigned int) res );
412
413         res = VarUI4FromI2( 0, pULong );
414         printf( "VarUI4FromI2: 0, %lu, %X\n", *pULong, (unsigned int) res );
415         res = VarUI4FromI2( 69, pULong );
416         printf( "VarUI4FromI2: 69, %lu, %X\n", *pULong, (unsigned int) res );
417         res = VarUI4FromI2( 70, pULong );
418         printf( "VarUI4FromI2: 70, %lu, %X\n", *pULong, (unsigned int) res );
419         res = VarUI4FromI2( 128, pULong );
420         printf( "VarUI4FromI2: 128, %lu, %X\n", *pULong, (unsigned int) res );
421         res = VarUI4FromI2( 255, pULong );
422         printf( "VarUI4FromI2: 255, %lu, %X\n", *pULong, (unsigned int) res );
423         res = VarUI4FromR8( 4294967295.0, pULong );
424         printf( "VarUI4FromR8: 4294967295, %lu, %X\n", *pULong, (unsigned int) res );
425         res = VarUI4FromR8( 4294967296.0, pULong );
426         printf( "VarUI4FromR8: 4294967296, %lu, %X\n", *pULong, (unsigned int) res );
427
428         res = VarUI4FromR8( 0.0, pULong );
429         printf( "VarUI4FromR8: 0.0, %lu, %X\n", *pULong, (unsigned int) res );
430         res = VarUI4FromR8( 69.33, pULong );
431         printf( "VarUI4FromR8: 69.33, %lu, %X\n", *pULong, (unsigned int) res );
432         res = VarUI4FromR8( 69.66, pULong );
433         printf( "VarUI4FromR8: 69.66, %lu, %X\n", *pULong, (unsigned int) res );
434         res = VarUI4FromR8( -69.33, pULong );
435         printf( "VarUI4FromR8: -69.33, %lu, %X\n", *pULong, (unsigned int) res );
436         res = VarUI4FromR8( -69.66, pULong );
437         printf( "VarUI4FromR8: -69.66, %lu, %X\n", *pULong, (unsigned int) res );
438
439         res = VarUI4FromR8( -0.5, pULong );
440         printf( "VarUI4FromR8: -0.5, %lu, %X\n", *pULong, (unsigned int) res );
441         res = VarUI4FromR8( -0.51, pULong );
442         printf( "VarUI4FromR8: -0.51, %lu, %X\n", *pULong, (unsigned int) res );
443         res = VarUI4FromR8( -0.49, pULong );
444         printf( "VarUI4FromR8: -0.49, %lu, %X\n", *pULong, (unsigned int) res );
445
446         res = VarUI4FromR8( 0.5, pULong );
447         printf( "VarUI4FromR8: 0.5, %lu, %X\n", *pULong, (unsigned int) res );
448         res = VarUI4FromR8( 0.51, pULong );
449         printf( "VarUI4FromR8: 0.51, %lu, %X\n", *pULong, (unsigned int) res );
450         res = VarUI4FromR8( 0.49, pULong );
451         printf( "VarUI4FromR8: 0.49, %lu, %X\n", *pULong, (unsigned int) res );
452
453         res = VarUI4FromDate( 0.0, pULong );
454         printf( "VarUI4FromDate: 0.0, %lu, %X\n", *pULong, (unsigned int) res );
455         res = VarUI4FromDate( 69.33, pULong );
456         printf( "VarUI4FromDate: 69.33, %lu, %X\n", *pULong, (unsigned int) res );
457         res = VarUI4FromDate( 69.66, pULong );
458         printf( "VarUI4FromDate: 69.66, %lu, %X\n", *pULong, (unsigned int) res );
459         res = VarUI4FromDate( -69.33, pULong );
460         printf( "VarUI4FromDate: -69.33, %lu, %X\n", *pULong, (unsigned int) res );
461         res = VarUI4FromDate( -69.66, pULong );
462         printf( "VarUI4FromDate: -69.66, %lu, %X\n", *pULong, (unsigned int) res );
463
464         res = VarUI4FromBool( VARIANT_TRUE, pULong );
465         printf( "VarUI4FromBool: VARIANT_TRUE, %lu, %X\n", *pULong, (unsigned int) res );
466         res = VarUI4FromBool( VARIANT_FALSE, pULong );
467         printf( "VarUI4FromBool: VARIANT_FALSE, %lu, %X\n", *pULong, (unsigned int) res );
468
469         for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
470         {
471                 res = VarUI4FromStr( pOleChar[olePtrIndex], 0, 0, pULong );
472                 printf( "VarUI4FromStr: %s, %lu, %X\n", WtoA(pOleChar[olePtrIndex]), *pULong, (unsigned int) res );
473         }
474
475         /* CHAR from ...
476          */
477         printf( "\n\n======== Testing VarI1FromXXX ========\n");
478
479         res = VarI1FromBool( VARIANT_TRUE, pByte );
480         printf( "VarI1FromBool: VARIANT_TRUE, %d, %X\n", *pByte, (unsigned int) res );
481
482         res = VarI1FromBool( VARIANT_TRUE, pChar );
483         printf( "VarI1FromBool: VARIANT_TRUE, %d, %X\n", *pChar, (unsigned int) res );
484
485         res = VarI1FromBool( VARIANT_FALSE, pChar );
486         printf( "VarI1FromBool: VARIANT_FALSE, %d, %X\n", *pChar, (unsigned int) res );
487
488         res = VarI1FromUI1( (unsigned char)32767, pChar );
489         printf( "VarI1FromUI1: 32767, %d, %X\n", *pChar, (unsigned int) res );
490         res = VarI1FromUI1( (unsigned char)65535, pChar );
491         printf( "VarI1FromUI1: 65535, %d, %X\n", *pChar, (unsigned int) res );
492
493         res = VarI1FromI4( 32767, pChar );
494         printf( "VarI1FromI4: 32767, %d, %X\n", *pChar, (unsigned int) res );
495         res = VarI1FromI4( 32768, pChar );
496         printf( "VarI1FromI4: 32768, %d, %X\n", *pChar, (unsigned int) res );
497         res = VarI1FromI4( -32768, pChar );
498         printf( "VarI1FromI4: -32768, %d, %X\n", *pChar, (unsigned int) res );
499         res = VarI1FromI4( -32769, pChar );
500         printf( "VarI1FromI4: -32769, %d, %X\n", *pChar, (unsigned int) res );
501
502         res = VarI1FromR8( 69.33, pChar );
503         printf( "VarI1FromR8: 69.33, %d, %X\n", *pChar, (unsigned int) res );
504         res = VarI1FromR8( 69.66, pChar );
505         printf( "VarI1FromR8: 69.66, %d, %X\n", *pChar, (unsigned int) res );
506         res = VarI1FromR8( -69.33, pChar );
507         printf( "VarI1FromR8: -69.33, %d, %X\n", *pChar, (unsigned int) res );
508         res = VarI1FromR8( -69.66, pChar );
509         printf( "VarI1FromR8: -69.66, %d, %X\n", *pChar, (unsigned int) res );
510
511         res = VarI1FromDate( -69.66, pChar );
512         printf( "VarI1FromDate: -69.66, %d, %X\n", *pChar, (unsigned int) res );
513
514         for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
515         {
516                 res = VarI1FromStr( pOleChar[olePtrIndex], 0, 0, pChar );
517                 printf( "VarI1FromStr: %s, %d, %X\n", WtoA(pOleChar[olePtrIndex]), *pChar, (unsigned int) res );
518         }
519
520         /* short from ...
521          */
522         printf( "\n\n======== Testing VarI2FromXXX ========\n");
523
524         res = VarI2FromUI2( 32767, pShort );
525         printf( "VarI2FromUI2: 32767, %d, %X\n", *pShort, (unsigned int) res );
526         res = VarI2FromUI2( 65535, pShort );
527         printf( "VarI2FromUI2: 65535, %d, %X\n", *pShort, (unsigned int) res );
528
529         res = VarI2FromI4( 32767, pShort );
530         printf( "VarI2FromI4: 32767, %d, %X\n", *pShort, (unsigned int) res );
531         res = VarI2FromI4( 32768, pShort );
532         printf( "VarI2FromI4: 32768, %d, %X\n", *pShort, (unsigned int) res );
533         res = VarI2FromI4( -32768, pShort );
534         printf( "VarI2FromI4: -32768, %d, %X\n", *pShort, (unsigned int) res );
535         res = VarI2FromI4( -32769, pShort );
536         printf( "VarI2FromI4: -32769, %d, %X\n", *pShort, (unsigned int) res );
537
538         res = VarI2FromR8( 69.33, pShort );
539         printf( "VarI2FromR8: 69.33, %d, %X\n", *pShort, (unsigned int) res );
540         res = VarI2FromR8( 69.66, pShort );
541         printf( "VarI2FromR8: 69.66, %d, %X\n", *pShort, (unsigned int) res );
542         res = VarI2FromR8( -69.33, pShort );
543         printf( "VarI2FromR8: -69.33, %d, %X\n", *pShort, (unsigned int) res );
544         res = VarI2FromR8( -69.66, pShort );
545         printf( "VarI2FromR8: -69.66, %d, %X\n", *pShort, (unsigned int) res );
546
547         res = VarI2FromDate( -69.66, pShort );
548         printf( "VarI2FromDate: -69.66, %d, %X\n", *pShort, (unsigned int) res );
549
550         for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
551         {
552                 res = VarI2FromStr( pOleChar[olePtrIndex], 0, 0, pShort );
553                 printf( "VarI2FromStr: %s, %d, %X\n", WtoA(pOleChar[olePtrIndex]), *pShort, (unsigned int) res );
554         }
555         
556         /* long from ...
557          */
558         printf( "\n\n======== Testing VarI4FromXXX ========\n");
559
560         res = VarI4FromI2( 3, (long*)pInt );
561         printf( "VarIntFromI2: 3, %d, %X\n", *pInt, (unsigned int) res );
562
563         res = VarI4FromR8( 69.33, pLong );
564         printf( "VarI4FromR8: 69.33, %ld, %X\n", *pLong, (unsigned int) res );
565         res = VarI4FromR8( 69.66, pLong );
566         printf( "VarI4FromR8: 69.66, %ld, %X\n", *pLong, (unsigned int) res );
567         res = VarI4FromR8( -69.33, pLong );
568         printf( "VarI4FromR8: -69.33, %ld, %X\n", *pLong, (unsigned int) res );
569         res = VarI4FromR8( -69.66, pLong );
570         printf( "VarI4FromR8: -69.66, %ld, %X\n", *pLong, (unsigned int) res );
571
572         res = VarI4FromR8( 2147483647.0, pLong );
573         printf( "VarI4FromR8: 2147483647.0, %ld, %X\n", *pLong, (unsigned int) res );
574         res = VarI4FromR8( 2147483648.0, pLong );
575         printf( "VarI4FromR8: 2147483648.0, %ld, %X\n", *pLong, (unsigned int) res );
576         res = VarI4FromR8( -2147483647.0, pLong );
577         printf( "VarI4FromR8: -2147483647.0, %ld, %X\n", *pLong, (unsigned int) res );
578         res = VarI4FromR8( -2147483648.0, pLong );
579         printf( "VarI4FromR8: -2147483648.0, %ld, %X\n", *pLong, (unsigned int) res );
580         res = VarI4FromR8( -2147483649.0, pLong );
581         printf( "VarI4FromR8: -2147483649.0, %ld, %X\n", *pLong, (unsigned int) res );
582
583         res = VarI4FromDate( -2147483649.0, pLong );
584         printf( "VarI4FromDate: -2147483649.0, %ld, %X\n", *pLong, (unsigned int) res );
585
586         for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
587         {
588                 res = VarI4FromStr( pOleChar[olePtrIndex], 0, 0, pLong );
589                 printf( "VarI4FromStr: %s, %ld, %X\n", WtoA(pOleChar[olePtrIndex]), *pLong, (unsigned int) res );
590         }
591
592         /* float from ...
593          */
594         printf( "\n\n======== Testing VarR4FromXXX ========\n");
595
596         res = VarR4FromI4( 16777216, pFloat );
597         printf( "VarR4FromI4: 16777216, %f, %X\n", *pFloat, (unsigned int) res );
598         res = VarR4FromI4( 16777217, pFloat );
599         printf( "VarR4FromI4: 16777217, %f, %X\n", *pFloat, (unsigned int) res );
600         res = VarR4FromI4( -16777216, pFloat );
601         printf( "VarR4FromI4: -16777216, %f, %X\n", *pFloat, (unsigned int) res );
602         res = VarR4FromI4( -16777217, pFloat );
603         printf( "VarR4FromI4: -16777217, %f, %X\n", *pFloat, (unsigned int) res );
604
605         res = VarR4FromR8( 16777216.0, pFloat );
606         printf( "VarR4FromR8: 16777216.0, %f, %X\n", *pFloat, (unsigned int) res );
607         res = VarR4FromR8( 16777217.0, pFloat );
608         printf( "VarR4FromR8: 16777217.0, %f, %X\n", *pFloat, (unsigned int) res );
609         res = VarR4FromR8( -16777216.0, pFloat );
610         printf( "VarR4FromR8: -16777216.0, %f, %X\n", *pFloat, (unsigned int) res );
611         res = VarR4FromR8( -16777217.0, pFloat );
612         printf( "VarR4FromR8: -16777217.0, %f, %X\n", *pFloat, (unsigned int) res );
613         
614         res = VarR4FromR8( 16777218e31, pFloat );
615         printf( "VarR4FromR8: 16777218e31, %f, %X\n", *pFloat, (unsigned int) res );
616         res = VarR4FromR8( 16777218e32, pFloat );
617         printf( "VarR4FromR8: 16777218e32, %f, %X\n", *pFloat, (unsigned int) res );
618         
619         res = VarR4FromDate( 16777218e31, pFloat );
620         printf( "VarR4FromDate: 16777218e31, %f, %X\n", *pFloat, (unsigned int) res );
621
622         for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
623         {
624                 res = VarR4FromStr( pOleChar[olePtrIndex], 0, 0, pFloat );
625                 printf( "VarR4FromStr: %s, %f, %X\n", WtoA(pOleChar[olePtrIndex]), *pFloat, (unsigned int) res );
626         }
627
628         /* double from ...
629          */
630         printf( "\n\n======== Testing VarR8FromXXX ========\n");
631
632         res = VarR8FromDate( 900719925474099.0, pDouble );
633         printf( "VarR8FromDate: 900719925474099.0, %f, %X\n", *pDouble, (unsigned int) res );
634
635         for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
636         {
637                 res = VarR8FromStr( pOleChar[olePtrIndex], 0, 0, pDouble );
638                 printf( "VarR8FromStr: %s, %f, %X\n", WtoA(pOleChar[olePtrIndex]), *pDouble, (unsigned int) res );
639         }
640
641         /* date from ...
642          */
643         printf( "\n\n======== Testing VarDateFromXXX ========\n");
644
645         res = VarDateFromI4( 2958465, pDouble );
646         printf( "VarDateFromI4: 2958465, %f, %X\n", *pDouble, (unsigned int) res );
647         res = VarDateFromI4( 2958466, pDouble );
648         printf( "VarDateFromI4: 2958466, %f, %X\n", *pDouble, (unsigned int) res );
649         res = VarDateFromI4( -657434, pDouble );
650         printf( "VarDateFromI4: -657434, %f, %X\n", *pDouble, (unsigned int) res );
651         res = VarDateFromI4( -657435, pDouble );
652         printf( "VarDateFromI4: -657435, %f, %X\n", *pDouble, (unsigned int) res );
653
654         res = VarDateFromR8( 2958465.9999, pDouble );
655         printf( "VarDateFromR8: 2958465.9999, %f, %X\n", *pDouble, (unsigned int) res );
656         res = VarDateFromR8( 2958466, pDouble );
657         printf( "VarDateFromR8: 2958466, %f, %X\n", *pDouble, (unsigned int) res );
658         res = VarDateFromR8( -657434.9999, pDouble );
659         printf( "VarDateFromR8: -657434.9999, %f, %X\n", *pDouble, (unsigned int) res );
660         res = VarDateFromR8( -657435, pDouble );
661         printf( "VarDateFromR8: -657435, %f, %X\n", *pDouble, (unsigned int) res );
662
663
664         res = VarDateFromR8( 0.0, pDouble );
665         printf( "VarDateFromR8: 0.0, %f, %X\n", *pDouble, (unsigned int) res );
666         res = VarDateFromR8( 1.0, pDouble );
667         printf( "VarDateFromR8: 1.0, %f, %X\n", *pDouble, (unsigned int) res );
668         res = VarDateFromR8( 2.25, pDouble );
669         printf( "VarDateFromR8: 2.25, %f, %X\n", *pDouble, (unsigned int) res );
670         res = VarDateFromR8( -2.0, pDouble );
671         printf( "VarDateFromR8: -2.0, %f, %X\n", *pDouble, (unsigned int) res );
672
673         /* Need some parsing function in Linux to emulate this...
674          * Still in progess.
675          */
676         for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
677         {
678                 res = VarDateFromStr( pOleChar[olePtrIndex], 0, 0, pDouble );
679                 printf( "VarDateFromStr: %s, %f, %X\n", WtoA(pOleChar[olePtrIndex]), *pDouble, (unsigned int) res );
680         }
681         
682         /* bool from ...
683          */
684         printf( "\n\n======== Testing VarBoolFromXXX ========\n");
685
686         res = VarBoolFromI4( 0, pBool );
687         printf( "VarBoolFromI4: 0, %d, %X\n", *pBool, (unsigned int) res );
688         res = VarBoolFromI4( 1, pBool );
689         printf( "VarBoolFromI4: 1, %d, %X\n", *pBool, (unsigned int) res );
690         res = VarBoolFromI4( -1, pBool );
691         printf( "VarBoolFromI4: -1, %d, %X\n", *pBool, (unsigned int) res );
692         res = VarBoolFromI4( 2, pBool );
693         printf( "VarBoolFromI4: 2, %d, %X\n", *pBool, (unsigned int) res );
694
695         res = VarBoolFromUI1( ' ', pBool );
696         printf( "VarBoolFromUI1: ' ', %d, %X\n", *pBool, (unsigned int) res );
697         res = VarBoolFromUI1( '\0', pBool );
698         printf( "VarBoolFromUI1: '\\0', %d, %X\n", *pBool, (unsigned int) res );
699         res = VarBoolFromUI1( 0x0000, pBool );
700         printf( "VarBoolFromUI1: 0x0000, %d, %X\n", *pBool, (unsigned int) res );
701         res = VarBoolFromUI1( (unsigned char)0xFFF, pBool );
702         printf( "VarBoolFromUI1: 0xFFF, %d, %X\n", *pBool, (unsigned int) res );
703         res = VarBoolFromUI1( (unsigned char)0xFFFF, pBool );
704         printf( "VarBoolFromUI1: 0xFFFF, %d, %X\n", *pBool, (unsigned int) res );
705         
706         res = VarBoolFromR8( 0.0, pBool );
707         printf( "VarBoolFromR8: 0.0, %d, %X\n", *pBool, (unsigned int) res );
708         res = VarBoolFromR8( 1.1, pBool );
709         printf( "VarBoolFromR8: 1.1, %d, %X\n", *pBool, (unsigned int) res );
710         res = VarBoolFromR8( 0.5, pBool );
711         printf( "VarBoolFromR8: 0.5, %d, %X\n", *pBool, (unsigned int) res );
712         res = VarBoolFromR8( 0.49, pBool );
713         printf( "VarBoolFromR8: 0.49, %d, %X\n", *pBool, (unsigned int) res );
714         res = VarBoolFromR8( 0.51, pBool );
715         printf( "VarBoolFromR8: 0.51, %d, %X\n", *pBool, (unsigned int) res );
716         res = VarBoolFromR8( -0.5, pBool );
717         printf( "VarBoolFromR8: -0.5, %d, %X\n", *pBool, (unsigned int) res );
718         res = VarBoolFromR8( -0.49, pBool );
719         printf( "VarBoolFromR8: -0.49, %d, %X\n", *pBool, (unsigned int) res );
720         res = VarBoolFromR8( -0.51, pBool );
721         printf( "VarBoolFromR8: -0.51, %d, %X\n", *pBool, (unsigned int) res );
722
723         
724         for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
725         {
726                 res = VarBoolFromStr( pOleChar[olePtrIndex], 0, 0, pBool );
727                 printf( "VarBoolFromStr: %s, %d, %X\n", WtoA(pOleChar[olePtrIndex]), *pBool, (unsigned int) res );
728         }
729
730         res = VarI1FromBool( VARIANT_TRUE, pByte );
731         printf( "VarI1FromBool: VARIANT_TRUE, %d, %X\n", *pByte, (unsigned int) res );
732
733         res = VarUI2FromI2( -1, &i );
734         printf( "VarUI2FromI2: -1, %d, %X\n", i, (unsigned int) res );
735
736
737         /* BSTR from ...
738          */
739         printf( "\n\n======== Testing VarBSTRFromXXX ========\n");
740
741         /* integers...
742          */
743         res = VarBstrFromI1( -100, 0, 0, &bstr );
744         printf( "VarBstrFromI1: -100, %s, %X\n", WtoA( bstr ), (unsigned int) res );
745
746         res = VarBstrFromUI1( 0x5A, 0, 0, &bstr );
747         printf( "VarBstrFromUI1: 0x5A, %s, %X\n", WtoA( bstr ), (unsigned int) res );
748
749         res = VarBstrFromI4( 2958465, 0, 0, &bstr );
750         printf( "VarBstrFromI4: 2958465, %s, %X\n", WtoA( bstr ), (unsigned int) res );
751
752         /* reals...
753          */
754         d=0;
755         for( i=0; i<20; i++ )
756         {
757                 /* add an integer to the real number
758                  */
759                 d += ((i%9)+1) * pow( 10, i );
760                 res = VarBstrFromR8( d, 0, 0, &bstr );
761                 printf( "VarBstrFromR8: %f, %s, %X\n", d, WtoA( bstr ), (unsigned int) res );
762                 res = VarBstrFromR8( -d, 0, 0, &bstr );
763                 printf( "VarBstrFromR8: %f, %s, %X\n", -d, WtoA( bstr ), (unsigned int) res );
764         }
765         d=0;
766         for( i=0; i<20; i++ )
767         {
768                 /* add a decimal to the real number
769                  */
770                 d += ((i%9)+1) * pow( 10, (i*-1) );
771                 res = VarBstrFromR8( d, 0, 0, &bstr );
772                 printf( "VarBstrFromR8: %f, %s, %X\n", d, WtoA( bstr ), (unsigned int) res );
773                 res = VarBstrFromR8( d-1, 0, 0, &bstr );
774                 printf( "VarBstrFromR8: %f, %s, %X\n", d-1, WtoA( bstr ), (unsigned int) res );
775                 res = VarBstrFromR8( -d, 0, 0, &bstr );
776                 printf( "VarBstrFromR8: %f, %s, %X\n", -d, WtoA( bstr ), (unsigned int) res );
777         }
778
779         d=0;
780         for( i=0; i<20; i++ )
781         {
782                 /* add an integer to the real number
783                  */
784                 d += ((i%9)+1) * pow( 10, i );
785                 /* add a decimal to the real number
786                  */
787                 d += ((i%9)+1) * pow( 10, (i*-1) );
788                 res = VarBstrFromR8( d, 0, 0, &bstr );
789                 printf( "VarBstrFromR8: %f, %s, %X\n", d, WtoA( bstr ), (unsigned int)res );
790                 res = VarBstrFromR8( -d, 0, 0, &bstr );
791                 printf( "VarBstrFromR8: %f, %s, %X\n", -d, WtoA( bstr ), (unsigned int) res );
792         }
793
794
795
796         d=0;
797         for( i=0; i<10; i++ )
798         {
799                 /* add an integer to the real number
800                  */
801                 d += ((i%9)+1) * pow( 10, i );
802                 res = VarBstrFromR4( (float)d, 0, 0, &bstr );
803                 printf( "VarBstrFromR4: %f, %s, %X\n", d, WtoA( bstr ), (unsigned int) res );
804                 res = VarBstrFromR4( (float)-d, 0, 0, &bstr );
805                 printf( "VarBstrFromR4: %f, %s, %X\n", -d, WtoA( bstr ), (unsigned int) res );
806         }
807         d=0;
808         for( i=0; i<10; i++ )
809         {
810                 /* add a decimal to the real number
811                  */
812                 d += ((i%9)+1) * pow( 10, (i*-1) );
813                 res = VarBstrFromR4( (float)d, 0, 0, &bstr );
814                 printf( "VarBstrFromR4: %f, %s, %X\n", d, WtoA( bstr ), (unsigned int) res );
815                 res = VarBstrFromR4( (float)d-1, 0, 0, &bstr );
816                 printf( "VarBstrFromR4: %f, %s, %X\n", d-1, WtoA( bstr ), (unsigned int) res );
817                 res = VarBstrFromR4( (float)-d, 0, 0, &bstr );
818                 printf( "VarBstrFromR4: %f, %s, %X\n", -d, WtoA( bstr ), (unsigned int) res );
819         }
820
821         d=0;
822         for( i=0; i<10; i++ )
823         {
824                 /* add an integer to the real number
825                  */
826                 d += ((i%9)+1) * pow( 10, i );
827                 /* add a decimal to the real number
828                  */
829                 d += ((i%9)+1) * pow( 10, (i*-1) );
830                 res = VarBstrFromR4( (float)d, 0, 0, &bstr );
831                 printf( "VarBstrFromR4: %f, %s, %X\n", d, WtoA( bstr ), (unsigned int) res );
832                 res = VarBstrFromR4( (float)-d, 0, 0, &bstr );
833                 printf( "VarBstrFromR4: %f, %s, %X\n", -d, WtoA( bstr ), (unsigned int) res );
834         }
835
836         res = VarBstrFromBool( 0x00, 0, 0, &bstr );
837         printf( "VarBstrFromBool: 0x00, %s, %X\n", WtoA( bstr ), (unsigned int) res );
838         res = VarBstrFromBool( 0xFF, 0, 0, &bstr );
839         printf( "VarBstrFromBool: 0xFF, %s, %X\n", WtoA( bstr ), (unsigned int) res );
840
841         res = VarBstrFromDate( 0.0, 0, 0, &bstr );
842         printf( "VarBstrFromDate: 0.0, %s, %X\n", WtoA( bstr ), (unsigned int) res );
843         res = VarBstrFromDate( 3.34, 0, 0, &bstr );
844         printf( "VarBstrFromDate: 3.34, %s, %X\n", WtoA( bstr ), (unsigned int) res );
845         res = VarBstrFromDate( 3339.34, 0, 0, &bstr );
846         printf( "VarBstrFromDate: 3339.34, %s, %X\n", WtoA( bstr ), (unsigned int) res );
847         res = VarBstrFromDate( 365.00, 0, 0, &bstr );
848         printf( "VarBstrFromDate: 365.00, %s, %X\n", WtoA( bstr ), (unsigned int) res );
849         res = VarBstrFromDate( 365.25, 0, 0, &bstr );
850         printf( "VarBstrFromDate: 365.25, %s, %X\n", WtoA( bstr ), (unsigned int) res );
851         res = VarBstrFromDate( 1461.0, 0, 0, &bstr );
852         printf( "VarBstrFromDate: 1461.00, %s, %X\n", WtoA( bstr ), (unsigned int) res );
853         res = VarBstrFromDate( 1461.5, 0, 0, &bstr );
854         printf( "VarBstrFromDate: 1461.5, %s, %X\n", WtoA( bstr ), (unsigned int) res );
855         
856
857         res = VarBstrFromBool( 0x00, 0, 0, &bstr );
858         printf( "VarBstrFromBool: 0x00, %s, %X\n", WtoA(bstr), (unsigned int) res );
859         res = VarBstrFromBool( 0xFF, 0, 0, &bstr );
860         printf( "VarBstrFromBool: 0xFF, %s, %X\n", WtoA(bstr), (unsigned int) res );
861
862         res = VarBstrFromDate( 0.0, 0, 0, &bstr );
863         printf( "VarBstrFromDate: 0.0, %s, %X\n", WtoA(bstr), (unsigned int) res );
864         res = VarBstrFromDate( 3.34, 0, 0, &bstr );
865         printf( "VarBstrFromDate: 3.34, %s, %X\n", WtoA(bstr), (unsigned int) res );
866
867         /* Test variant API...
868          */
869         printf( "\n\n======== Testing Hi-Level Variant API ========\n");
870
871         bstr = SysAllocString( pOleChar[4] );
872
873         res = VariantClear( &va );
874         printf( "Result is: %x\n", (unsigned int)res );
875
876         VariantInit( &va );
877         VariantInit( &vb );
878         VariantInit( &vc );
879         VariantInit( &vd );
880         VariantInit( &ve );
881
882         va.vt = VT_BSTR;
883         va.u.bstrVal = bstr;
884         res = VariantClear( &va );
885         printf( "VariantClear: %x\n", (unsigned int)res );
886         printf( "VariantClear: %x\n", (unsigned int)res );
887         SysFreeString( bstr );
888         SysFreeString( bstr );
889
890         res = VariantCopy( &vb, &va );
891         printf( "VariantCopy: %x\n", (unsigned int)res );
892         res = VariantClear( &vb );
893         printf( "VariantClear: %x\n", (unsigned int)res );
894         res = VariantClear( &va );
895         printf( "VariantClear: %x\n", (unsigned int)res );
896
897
898         va.vt = VT_R8;
899         d = 4.123;
900         va.u.dblVal = d;
901         res = VariantCopy( &va, &va );
902         printf( "VariantCopy %f -> %f: %x\n", V_R8(&va), V_R8(&va), (unsigned int)res );
903
904         va.vt = VT_R8 | VT_BYREF;
905         d = 31.123;
906         va.u.pdblVal = &d;
907         res = VariantCopyInd( &va, &va );
908         printf( "VariantCopyInd %f: %x\n", V_R8(&va), (unsigned int)res );
909
910         va.vt = VT_R8;
911         d = 1.123;
912         va.u.dblVal = d;
913         res = VariantCopy( &vb, &va );
914         printf( "VariantCopy %f -> %f: %x\n", V_R8(&va), V_R8(&vb), (unsigned int)res );
915
916         va.vt = VT_R8 | VT_BYREF;
917         d = 123.123;
918         va.u.pdblVal = &d;
919         res = VariantCopy( &vb, &va );
920         printf( "VariantCopy %f -> %f: %x\n", *(V_R8REF(&va)), *(V_R8REF(&vb)), (unsigned int)res );
921
922         va.vt = VT_R8 | VT_BYREF;
923         d = 111.2;
924         va.u.pdblVal = &d;
925         res = VariantCopyInd( &vb, &va );
926         printf( "VariantCopyInd %f -> %f: %x\n", *(V_R8REF(&va)), V_R8(&vb), (unsigned int)res );
927
928         va.vt = VT_R8 | VT_BYREF;
929         d = 1211.123453;
930         va.u.pdblVal = &d;
931         res = VariantChangeTypeEx( &va, &va, 0, 0, VT_I2 );
932         printf( "VariantChangeTypeEx %d: %x\n", V_I2(&va), (unsigned int) res );
933
934         va.vt = VT_INT;
935         va.u.intVal = 4;
936         res = VariantChangeTypeEx(&vb, &va, 0, 0, VT_BSTR );
937         printf( "VariantChangeTypeEx %d -> %s: %x\n", V_INT(&va), WtoA(V_BSTR(&vb)), (unsigned int)res );
938
939         va.vt = VT_DATE;
940         va.u.date = 34465.332431;
941         res = VariantChangeTypeEx(&vb, &va, 0, 0, VT_BSTR );
942         printf( "VariantChangeTypeEx %f -> %s: %x\n", V_DATE(&va), WtoA(V_BSTR(&vb)), (unsigned int)res );
943
944         bstr = pOleChar[4];
945         va.vt = VT_BSTR;
946         va.u.bstrVal = bstr;
947         res = VariantChangeTypeEx(&vb, &va, 0, 0, VT_R8 );
948         printf( "VariantChangeTypeEx %s -> %f: %x\n", WtoA(V_BSTR(&va)), V_R8(&vb), (unsigned int)res );
949
950
951         vc.vt = VT_BSTR | VT_BYREF;
952         vc.u.pbstrVal = &bstr;
953         vb.vt = VT_VARIANT | VT_BYREF;
954         vb.u.pvarVal = &vc;
955         va.vt = VT_VARIANT | VT_BYREF;
956         va.u.pvarVal = &vb;
957         res = VariantCopyInd( &vd, &va );
958         printf( "VariantCopyInd: %x\n", (unsigned int)res );
959
960         /* test what happens when bad vartypes are passed in
961          */
962         printf( "-------------- Testing different VARTYPES ----------------\n" );
963
964         for( i=0; i<100; i++ )
965         {
966                 /* Trying to use variants that are set to be BSTR but
967                  * do not contain a valid pointer makes the program crash
968                  * in Windows so we will skip those.  We do not need them
969                  * anyways to illustrate the behavior.
970                  */
971                 if( i ==  VT_BSTR )
972                         i = 77;
973
974                 va.vt = i;
975                 d = 4.123;
976                 va.u.dblVal = d;
977                 res = VariantCopyInd( &vb, &va );
978                 printf( "VariantCopyInd: %d -> %x\n", i, (unsigned int)res );
979
980                 va.vt = i | VT_BYREF;
981                 d = 4.123;
982                 va.u.pdblVal = &d;
983                 res = VariantCopyInd( &vb, &va );
984                 printf( "VariantCopyInd: %d -> %x\n", i, (unsigned int)res );
985
986                 va.vt = VT_R8;
987                 d = 4.123;
988                 va.u.dblVal = d;
989                 res = VariantChangeTypeEx( &vb, &va, 0, 0, i );
990                 printf( "VariantChangeTypeEx: %d -> %x\n", i, (unsigned int)res );
991
992                 va.vt = VT_R8;
993                 d = 4.123;
994                 va.u.dblVal = d;
995                 res = VariantChangeTypeEx( &vb, &va, 0, 0, i | VT_BYREF );
996                 printf( "VariantChangeTypeEx: VT_BYREF %d -> %x\n", i, (unsigned int)res );
997
998                 va.vt = 99;
999                 d = 4.123;
1000                 va.u.dblVal = d;
1001                 res = VariantClear( &va );
1002                 printf( "VariantClear: %d -> %x\n", i, (unsigned int)res );
1003
1004         }
1005         
1006         res = VariantClear( &va );
1007         printf( "VariantClear: %x\n", (unsigned int)res );
1008         res = VariantClear( &vb );
1009         printf( "VariantClear: %x\n", (unsigned int)res );
1010         res = VariantClear( &vc );
1011         printf( "VariantClear: %x\n", (unsigned int)res );
1012         res = VariantClear( &vd );
1013         printf( "VariantClear: %x\n", (unsigned int)res );
1014         res = VariantClear( &ve );
1015         printf( "VariantClear: %x\n", (unsigned int)res );
1016
1017
1018         /* There is alot of memory leaks but this is simply a test program.
1019          */
1020
1021         return 0;
1022 }
1023
WINE + custom patches